Optimizadores de redes neuronales: SGD, Momentum y Adam en Python

El concepto en palabras sencillas

Un optimizador es la regla que convierte los gradientes en actualizaciones de pesos. El descenso de gradiente simple usa solo el gradiente actual; momentum recuerda las direcciones anteriores, y Adam además adapta el tamaño del paso para cada peso.

Compara el descenso de gradiente simple, momentum y Adam minimizando paso a paso la misma función.

Ideas clave

Momentum mantiene una velocidad, así que atraviesa zonas planas y pequeños baches.
Adam lleva medias móviles del gradiente y del gradiente al cuadrado.
La corrección de sesgo (dividir entre 1 − βᵗ) arregla esas medias en los primeros pasos.
Una buena inicialización de pesos y los mini-lotes también hacen el entrenamiento más rápido y estable.

¿Cuándo se utiliza?

Entender qué pasa dentro de las redes neuronales y las bibliotecas de IA.
Aprender la idea antes de implementarla en los retos correspondientes.
Prepararte para cursos de aprendizaje automático, entrevistas y proyectos.

Pruébalo en acción

Pulsa Reproducir para que tres optimizadores compitan bajando el mismo valle irregular. Prueba una tasa de aprendizaje mayor para ver cómo momentum se pasa.

Código de ejemplo

Ejecutar código →

main.py

import math

# Minimise f(x) = (x - 3)² with three optimizers. The gradient is 2(x - 3).
grad = lambda x: 2 * (x - 3)

def sgd(steps, lr=0.1):
    x = 0.0
    for _ in range(steps):
        x -= lr * grad(x)
    return x

def momentum(steps, lr=0.1, beta=0.9):
    x, v = 0.0, 0.0
    for _ in range(steps):
        v = beta * v + grad(x)        # remember the direction we were going
        x -= lr * v
    return x

def adam(steps, lr=0.3, b1=0.9, b2=0.999, eps=1e-8):
    x, m, v = 0.0, 0.0, 0.0
    for t in range(1, steps + 1):
        g = grad(x)
        m = b1 * m + (1 - b1) * g     # running mean of gradients
        v = b2 * v + (1 - b2) * g * g # running mean of squared gradients
        m_hat, v_hat = m / (1 - b1 ** t), v / (1 - b2 ** t)
        x -= lr * m_hat / (math.sqrt(v_hat) + eps)
    return x

for steps in (5, 20, 50):
    print(f"{steps:>2} steps  sgd={sgd(steps):.3f}  momentum={momentum(steps):.3f}  adam={adam(steps):.3f}")

Resultado esperado

5 steps  sgd=2.017  momentum=4.741  adam=1.476
20 steps  sgd=2.965  momentum=4.048  adam=3.813
50 steps  sgd=3.000  momentum=3.091  adam=3.014

Cómo funciona

Los tres minimizan (x − 3)², cuyo punto más bajo es x = 3. SGD avanza de forma constante, momentum gana velocidad y se pasa antes de estabilizarse, y Adam ajusta cada paso con medias móviles del gradiente y de su cuadrado. Tras 50 pasos, los tres están cerca de 3.

Cambia los valores y ejecuta el programa en el compilador Python online de CodeUtility sin instalar Python.

Ejercicios prácticos

Modifica las entradas y prueba casos límite antes de usar conjuntos de datos mayores.

Cambia las entradas o los pesos y predice la salida antes de ejecutar.
Imprime los valores intermedios para seguir cada paso del cálculo.
Resuelve los retos enlazados abajo para implementar la idea por tu cuenta.

Ejecutar en el IDE de Python →

Practica con un reto

Usa lo que cubre esta lección para resolver un problema real. Cada reto se ejecuta en el navegador, con pruebas al instante y una revisión de IA.

Todos los retos