Aprende Implementación del Descenso de Gradiente en Python

El descenso por gradiente sigue una idea simple pero poderosa: moverse en la dirección del descenso más pronunciado para minimizar una función.

La regla matemática es:

theta = theta - alpha * gradient(theta)

Donde:

theta es el parámetro que estamos optimizando;
alpha es la tasa de aprendizaje (tamaño del paso);
gradient(theta) es el gradiente de la función en theta.

1. Definir la Función y su Derivada

Comenzamos con una función cuadrática simple:

def f(theta):
    return theta**2  # Function we want to minimize

Su derivada (gradiente) es:

def gradient(theta):
    return 2 * theta  # Derivative: f'(theta) = 2*theta

f(theta): esta es nuestra función, y queremos encontrar el valor de theta que la minimiza;
gradient(theta): esto nos indica la pendiente en cualquier punto theta, que usamos para determinar la dirección de actualización.

2. Inicializar los Parámetros del Descenso por Gradiente

alpha = 0.3  # Learning rate
theta = 3.0  # Initial starting point
tolerance = 1e-5  # Convergence threshold
max_iterations = 20  # Maximum number of updates

alpha (tasa de aprendizaje): controla el tamaño de cada paso;
theta (estimación inicial): el punto de partida para el descenso;
tolerance: cuando las actualizaciones se vuelven muy pequeñas, detenemos el proceso;
max_iterations: asegura que no entremos en un bucle infinito.

3. Realizar descenso por gradiente

for i in range(max_iterations):
    grad = gradient(theta)  # Compute gradient
    new_theta = theta - alpha * grad  # Update rule
    if abs(new_theta - theta) < tolerance:
        print("Converged!")
        break
    theta = new_theta

Calcular el gradiente en theta;
Actualizar theta usando la fórmula de descenso por gradiente;
Detener cuando las actualizaciones sean muy pequeñas (convergencia);
Imprimir cada paso para monitorear el progreso.

4. Visualización del descenso por gradiente


              123456789101112131415161718192021222324252627282930313233343536373839
            
import matplotlib.pyplot as plt
import numpy as np

def f(theta):
    return theta**2  # Function we want to minimize

def gradient(theta):
    return 2 * theta  # Derivative: f'(theta) = 2*theta

alpha = 0.3           # Learning rate
theta = 3.0           # Initial starting point
tolerance = 1e-5      # Convergence threshold
max_iterations = 20   # Maximum number of updates

theta_values = [theta]          # Track parameter values
output_values = [f(theta)]      # Track function values

for i in range(max_iterations):
    grad = gradient(theta)                # Compute gradient
    new_theta = theta - alpha * grad      # Update rule
    if abs(new_theta - theta) < tolerance:
        break
    theta = new_theta
    theta_values.append(theta)
    output_values.append(f(theta))

# Prepare data for plotting the full function curve
theta_range = np.linspace(-4, 4, 100)
output_range = f(theta_range)

# Plot
plt.plot(theta_range, output_range, label="f(θ) = θ²", color='black')
plt.scatter(theta_values, output_values, color='red', label="Gradient Descent Steps")
plt.title("Gradient Descent Visualization")
plt.xlabel("θ")
plt.ylabel("f(θ)")
plt.legend()
plt.grid(True)
plt.show()

Este gráfico muestra:

La curva de la función $f(θ) = θ^2$ ;
Puntos rojos que representan cada paso del descenso por gradiente hasta la convergencia.

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 3. Capítulo 10

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

Awesome!

Completion rate improved to 1.96

Desliza para mostrar el menú