Skip to content

English · Español

03 — Optimizadores, derivados de "¿qué memoria tenemos?"

🇪🇸 Cada optimizador se construye añadiendo una pieza de memoria al paso anterior: SGD = solo el gradiente actual; Momentum = media móvil del gradiente; Adam = media móvil de g + media móvil de g²; AdamW = Adam + weight decay desacoplado.

Esta página deriva la jerarquía de optimizadores como una secuencia de "añade un ingrediente cada vez", no como una tabla memorizada.

Descenso de gradiente puro (GD)

Dada una pérdida diferenciable L(θ), la actualización del descenso de gradiente es:

\[ \theta_{t+1} = \theta_t - \eta \nabla L(\theta_t) \]

η es la tasa de aprendizaje.

Por qué funciona (intuición): el gradiente apunta en la dirección de máximo ascenso; restarlo mueve hacia el máximo descenso. Para η suficientemente pequeño, cada paso disminuye L.

Por qué es lento (en la práctica): para una pérdida anisotrópica (valle largo y estrecho), el gradiente apunta sobre todo a través del valle (hacia las paredes empinadas), no a lo largo de él (hacia el mínimo). Cada paso zigzaguea. El argumento del número de condición de la Fase 3 explica la geometría; los siguientes optimizadores arreglan el síntoma.

Descenso de gradiente estocástico (SGD)

En ML, calcular el gradiente completo ∇L(θ) requiere el dataset completo — caro. En su lugar, usamos una estimación estocástica de un mini-batch:

\[ g_t = \frac{1}{|B|} \sum_{i \in B} \nabla \ell(x_i, \theta_t) \]

La ecuación de actualización se ve idéntica a GD:

\[ \theta_{t+1} = \theta_t - \eta g_t \]

Pero g_t es ruidoso — es una estimación insesgada de ∇L(θ_t) con varianza que escala como 1 / |B|. El ruido en realidad ayuda a escapar de puntos de silla (la Fase 16 lo revisitará). El coste dominante por paso es ahora O(|B|), no O(N).

Momentum

La intuición: si los gradientes pasados coincidieron en una dirección, esa dirección es probablemente correcta. Promediémoslos.

Define un vector de velocidad v_t como media móvil exponencial de gradientes:

\[ v_t = \beta v_{t-1} + g_t \]

β ∈ [0, 1) es el coeficiente de momentum (comúnmente 0.9). Entonces:

\[ \theta_{t+1} = \theta_t - \eta v_t \]

Derivación. Resolviendo la recurrencia:

\[ v_t = \sum_{k=0}^{t} \beta^{t-k} g_k \]

Una suma ponderada de gradientes pasados, con los recientes pesando más. En β = 0.9, la vida media es log(0.5) / log(0.9) ≈ 6.6 pasos — así que v_t está dominado por los últimos ~10 gradientes.

Por qué ayuda: en un valle largo y estrecho, el gradiente a través del valle alterna de signo paso a paso (zigzag) → se cancela en el promedio. El gradiente a lo largo del valle apunta consistentemente en la misma dirección → se refuerza. Efecto neto: momentum suprime el zigzag, amplifica la dirección consistente.

Modo de fallo: si pasas un mínimo (overshoot), momentum te lleva más allá. De ahí el decaimiento β < 1 — eventualmente el momentum muere.

Nesterov momentum

Una variante donde el gradiente se evalúa en la posición futura predicha:

\[ v_t = \beta v_{t-1} + \nabla L(\theta_t - \eta \beta v_{t-1}) \]

(luego θ_{t+1} = θ_t - η v_t). La "anticipación" da convergencia ligeramente mejor en problemas convexos; en la práctica, la diferencia vs momentum puro es pequeña para redes neuronales. Menciónalo una vez; por defecto, momentum puro.

AdaGrad — escalado por parámetro

La intuición: parámetros que históricamente han visto gradientes grandes deberían tener tasas de aprendizaje pequeñas (ya se están moviendo rápido); parámetros con historial pequeño deberían tener tasas de aprendizaje grandes.

Define un "historial del gradiente al cuadrado" por parámetro:

\[ s_t = s_{t-1} + g_t^2 \]

(elemento a elemento). Entonces:

\[ \theta_{t+1} = \theta_t - \eta \cdot g_t / (\sqrt{s_t} + \epsilon) \]

Propiedades:

  • Parámetros con gradientes consistentes acumulan s grande → LR efectiva más pequeña.
  • Parámetros con gradientes raros (p. ej., features dispersas) mantienen LR efectiva grande.
  • s_t crece monótonamente, así que la LR efectiva decrece monótonamente. Eventualmente demasiado pequeña para progresar. Este es el problema de decaimiento de AdaGrad; RMSProp lo arregla.

Usado en ML temprano de features dispersas (clasificación de texto con bag-of-words). Raramente la elección correcta para aprendizaje profundo.

RMSProp — media móvil exponencial de g²

Reemplaza la suma acumulada con una EMA:

\[ s_t = \beta_2 s_{t-1} + (1 - \beta_2) g_t^2 \]

β_2 ≈ 0.999. Actualización:

\[ \theta_{t+1} = \theta_t - \eta \cdot g_t / (\sqrt{s_t} + \epsilon) \]

s_t es ahora una EMA de gradientes al cuadrado — sin crecimiento monótono, sin problema de LR-decaimiento-a-cero.

Propiedades: misma intuición de escalado por parámetro que AdaGrad, pero s_t "olvida" gradientes antiguos. Funciona mucho mejor en la práctica.

Adam — Momentum + RMSProp + corrección de sesgo

Adam combina las dos ideas:

  1. Primer momento (EMA del gradiente — como Momentum): $\(m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t\)$

  2. Segundo momento (EMA del gradiente al cuadrado — como RMSProp): $\(v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2\)$

  3. Corrección de sesgo. En pasos iniciales (t = 1, 2, 3), las EMAs están sesgadas hacia cero porque empezaron en cero. Corrige:

$\(\hat{m}_t = m_t / (1 - \beta_1^t), \qquad \hat{v}_t = v_t / (1 - \beta_2^t)\)$

  1. Actualización:

$\(\theta_{t+1} = \theta_t - \eta \cdot \hat{m}_t / (\sqrt{\hat{v}_t} + \epsilon)\)$

Hiperparámetros por defecto: β_1 = 0.9, β_2 = 0.999, ε = 1e-8. Memoriza.

Por qué la corrección de sesgo importa

En t = 1: m_1 = (1 - β_1) g_1 = 0.1 g_1. Sin corrección, la actualización efectiva es η · 0.1 g_1 / sqrt(0.001 g_1²) — η · 0.1 / sqrt(0.001) ≈ η · 3.16. El primer paso es 3× mayor del deseado.

Con corrección: m̂_1 = m_1 / (1 - 0.9) = g_1. v̂_1 = v_1 / 0.001 = g_1². La primera actualización se vuelve η · g_1 / sqrt(g_1²) = η · sign(g_1). Paso de tamaño unitario, como se quería.

A medida que t crece, β^t → 0, así que 1 - β^t → 1, así que la corrección no tiene efecto. Solo importa al inicio.

Por qué Adam es "el default"

Dos razones prácticas:

  1. LR por parámetro autosintonizada. 1/sqrt(v̂) aproxima un precondicionador diagonal — cada parámetro obtiene un tamaño de paso escalado por su magnitud reciente de gradiente. La superficie de pérdida se vuelve "aproximadamente redonda" en las coordenadas de Adam.

  2. Robusto a la elección de hiperparámetros. Adam con lr=1e-3 funciona en un rango de ajustes mucho más amplio que SGD con cualquier lr único. Para código de investigación donde sintonizar es caro, Adam es la elección segura.

Para entrenamiento de frontera (pre-entrenamiento de grandes LLMs), variantes de AdamW (siguiente) más programaciones cuidadosas de LR dominan.

AdamW — weight decay desacoplado

El weight decay L2 (también llamado regularización de pesos) es el término de pérdida (λ/2) ||θ||². Su gradiente es λθ.

El enfoque "Adam con L2" añade λθ al gradiente g_t antes de calcular m_t, v_t. Esto es incorrecto de manera sutil: el término de decay fluye a través de las EMAs y del escalado por parámetro, así que los parámetros con mucho decay obtienen su decay atenuado por el divisor 1/sqrt(v̂).

AdamW desacopla el decay: aplícalo directamente a θ, no al gradiente.

\[ \theta_{t+1} = \theta_t - \eta \cdot \hat{m}_t / (\sqrt{\hat{v}_t} + \epsilon) - \eta \lambda \theta_t \]

Dos efectos:

  1. El término λθ_t se aplica uniformemente a todos los parámetros, independiente de v̂.
  2. La actualización de Adam y la actualización de decay se suman (o, equivalentemente, el decay es implícito en θ_t ← (1 - ηλ) θ_t antes del paso de Adam).

Empíricamente, AdamW da mejor generalización que Adam-con-L2. El paper de Loshchilov-Hutter (2017) lo hizo estándar.

λ por defecto: 0.01 para transformers, 0.1 para algunos modelos de visión. Sintoniza por problema.

¿Por qué 1/sqrt(v̂) en lugar de 1/v̂?

Si usaras 1/v̂ directamente, la actualización tendría unidades de 1/g, lo que no tiene sentido dimensional — la actualización debería tener unidades de θ, lo que significa las mismas unidades que g · learning_rate. Dividir por sqrt(g²) = |g| da una actualización de paso unitario modulada por m̂, lo que es correcto.

(Adagrad y RMSProp también usan sqrt(s); mismo argumento dimensional.)

Trabajado: pasando por Adam durante dos iteraciones

Planteamiento: θ_0 = 1.0, η = 0.1, β_1 = 0.9, β_2 = 0.999, ε = 1e-8. Pérdida L = θ²; gradiente g_t = 2 θ_t.

Paso 1. θ_0 = 1.0, g_1 = 2.0.

  • m_1 = 0.9 · 0 + 0.1 · 2.0 = 0.2
  • v_1 = 0.999 · 0 + 0.001 · 4.0 = 0.004
  • m̂_1 = 0.2 / (1 - 0.9) = 2.0
  • v̂_1 = 0.004 / (1 - 0.999) = 4.0
  • θ_1 = 1.0 - 0.1 · 2.0 / (sqrt(4.0) + 1e-8) = 1.0 - 0.1 · 2.0 / 2.0 = 1.0 - 0.1 = 0.9

Paso 2. θ_1 = 0.9, g_2 = 1.8.

  • m_2 = 0.9 · 0.2 + 0.1 · 1.8 = 0.18 + 0.18 = 0.36
  • v_2 = 0.999 · 0.004 + 0.001 · 3.24 = 0.003996 + 0.00324 = 0.007236
  • m̂_2 = 0.36 / (1 - 0.81) = 1.8947...
  • v̂_2 = 0.007236 / (1 - 0.998001) ≈ 3.620...
  • θ_2 = 0.9 - 0.1 · 1.8947 / (sqrt(3.620) + ε) ≈ 0.9 - 0.1 · 1.8947 / 1.9026 ≈ 0.9 - 0.0996 ≈ 0.8004

Compara con SGD con η = 0.1: θ_2_sgd = 0.9 - 0.1 · 1.8 = 0.72. SGD se mueve más rápido aquí porque el gradiente es grande y no anisotrópico. El escalado adaptativo de Adam brilla solo cuando los gradientes son anisotrópicos — que es exactamente el caso para redes neuronales reales.

Volverás a hacer este ejercicio en el lab 02 sobre Rosenbrock, que sí es anisotrópico.

Problemas de práctica

Soluciones en solutions/03-optimizers-derived-ref.md en la apertura de fase.

  1. Deriva Momentum desde "quiero tomar una media móvil exponencial de gradientes pasados".
  2. Demuestra que la LR efectiva de AdaGrad para un parámetro decrece monótonamente. Demuestra que la de RMSProp no.
  3. Para Adam, demuestra que la corrección de sesgo recupera la estimación insesgada de E[g] y E[g²] si g es i.i.d. (Pista: toma expectativas de m_t y v_t.)
  4. Deriva la interpretación "shrink-then-step" de AdamW: demuestra que θ_t ← (1 - ηλ) θ_t (decay) seguido del paso normal de Adam es equivalente a la ecuación unificada dada arriba.
  5. ¿Por qué Adam-con-L2 falla en aplicar weight decay igual a través de parámetros con diferentes v̂?
  6. Supón β_1 = 0 (sin EMA del primer momento). ¿A qué optimizador previamente definido se reduce Adam?

Recapitulación en un párrafo

Cada optimizador añade una pieza de memoria al anterior: SGD tiene solo el gradiente actual; Momentum añade una media móvil de gradientes pasados; AdaGrad añade una suma móvil de gradientes al cuadrado para LR por parámetro; RMSProp reemplaza la suma con una EMA (arreglando el problema de decaimiento-a-cero de AdaGrad); Adam combina Momentum y RMSProp con corrección de sesgo para estabilidad de pasos iniciales; AdamW desacopla el weight decay del gradiente. Cada adición está motivada por un modo de fallo de la versión anterior, y cada una puede derivarse de "¿qué media móvil necesito calcular?". El lab de la Fase 4 implementa los cuatro (SGD, Momentum, Adam, AdamW) como funciones puras sobre un diccionario de estado y los compite en la función de Rosenbrock para ver el comportamiento geométrico.

Siguiente: theory/04-lr-schedules-and-warmup.md.