Comparación de optimizadores SGD vs Momentum vs Adam
Ejecutar los tres optimizadores sobre la misma función de pérdida en forma de "valle estrecho y alargado" para visualizar las diferencias en la trayectoria y velocidad de convergencia.
Al completar este caso, comprenderás:La oscilación de SGD, la suavidad por inercia de Momentum y el ajuste adaptativo del paso de Adam: los principios matemáticos y los efectos intuitivos de las tres estrategias.
Introducción desde la vida cotidiana
Bajar una montaña con curvas: tres estrategias
Estrategia SGD: solo miras tus pies, siempre caminas en la dirección más empinada. Al encontrar una zanja estrecha, rebotas de un lado a otro.
Estrategia Momentum: como una bola de nieve que rueda: recuerda la dirección y velocidad anteriores, y la inercia le permite superar pequeños baches.
Estrategia Adam: no solo tiene inercia, sino que también ajusta el tamaño del paso según el terreno en cada tramo: pasos pequeños en pendientes pronunciadas y pasos grandes en terreno llano.
Comprensión intuitiva
theta -= lr * v
v = beta2*v + (1-beta2)*g^2
theta -= lr * m_hat/(sqrt(v_hat)+eps)
Función de prueba: \(f(x, y) = 0.5x^2 + 5y^2\): un valle estrecho y alargado donde la dirección x es suave y la dirección y es empinada.
Práctica con Python
Ejemplo
def f(pos):
x, y = pos
return 0.5 * x**2 + 5 * y**2
def grad(pos):
x, y = pos
return np.array([x, 10 * y])
def sgd(start, lr=0.1, steps=60):
pos = np.array(start, dtype=float)
history = [pos.copy()]
for _ in range(steps):
pos = pos - lr * grad(pos)
history.append(pos.copy())
return np.array(history)
def momentum(start, lr=0.1, beta=0.9, steps=60):
pos = np.array(start, dtype=float)
v = np.zeros_like(pos)
history = [pos.copy()]
for _ in range(steps):
g = grad(pos)
v = beta * v + (1 - beta) * g
pos = pos - lr * v
history.append(pos.copy())
return np.array(history)
def adam(start, lr=0.3, beta1=0.9, beta2=0.999, eps=1e-8, steps=60):
pos = np.array(start, dtype=float)
m = np.zeros_like(pos)
v = np.zeros_like(pos)
history = [pos.copy()]
for t in range(1, steps + 1):
g = grad(pos)
m = beta1 * m + (1 - beta1) * g
v = beta2 * v + (1 - beta2) * (g ** 2)
m_hat = m / (1 - beta1 ** t)
v_hat = v / (1 - beta2 ** t)
pos = pos - lr * m_hat / (np.sqrt(v_hat) + eps)
history.append(pos.copy())
return np.array(history)
start = [4.0, 4.0]
results = {
"SGD": sgd(start, lr=0.1),
"Momentum": momentum(start, lr=0.1),
"Adam": adam(start, lr=0.3),
}
print("EJEMPLO comparación de tres optimizadores (punto de inicio [4,4]):\n")
for name, hist in results.items():
dists = np.linalg.norm(hist, axis=1)
mask = dists < 0.05
conv = (np.argmax(mask) if mask.any() else "No convergido")
n_osc = np.sum(np.diff(np.sign(hist[:, 1])) != 0)
print(f" {name:10s}: {str(conv):>6s} pasos para converger, oscilaciones en y {n_osc} veces, pérdida={f(hist[-1]):.6f}")
EJEMPLO 三种优化器对比 (起点 [4,4]): SGD : 未收敛 步收敛, y震荡36次, 损失=0.000035 Momentum : 21 步收敛, y震荡6次, 损失=0.000000 Adam : 16 步收敛, y震荡0次, 损失=0.000000
Escenarios de aplicación en IA
| Escenario | Optimizador recomendado | Razón |
|---|---|---|
| La mayoría de las tareas | Adam/AdamW | Adaptativo, convergencia rápida, pocos ajustes de hiperparámetros |
| Entrenamiento de Transformer | AdamW | GPT/BERT lo usan |
| Cuando se necesita precisión extrema | SGD+Momentum | A veces la capacidad de generalización es mejor |