Optimización moderna: optimizadores adaptativos y programación de tasa de aprendizaje

¿Por qué necesitamos optimización “moderna”?

En la práctica, entrenar redes neuronales rara vez se parece al caso ideal de un gradiente “limpio” y una superficie de pérdida suave. Aparecen tres dificultades típicas:

• Valles y ravinas: la pérdida cambia muy rápido en una dirección y muy lento en otra; el descenso puede zigzaguear y avanzar despacio.
• Gradientes ruidosos: con mini-batches, el gradiente es una estimación con varianza; la pérdida puede oscilar.
• Escalas distintas por parámetro: algunos pesos reciben gradientes grandes y otros muy pequeños; un único learning rate puede ser demasiado agresivo para unos y demasiado tímido para otros.

Los optimizadores con momentum y/o tasas adaptativas atacan estos problemas ajustando cómo se acumula y se escala la actualización de parámetros.

Momentum: acelerar en valles y reducir zigzag

Idea: en lugar de movernos solo según el gradiente actual, acumulamos una “velocidad” que promedia gradientes pasados. Esto ayuda a atravesar ravinas: amortigua oscilaciones en la dirección empinada y acelera en la dirección suave.

v_t = β * v_{t-1} + (1-β) * g_t   (promedio exponencial del gradiente)
θ_t = θ_{t-1} - α * v_t

Qué problema resuelve: valles/ravinas (zigzag) y parte del ruido del gradiente.

Hiperparámetros clave

• α (learning rate): escala el tamaño del paso. Si es alto, puede divergir u oscilar; si es bajo, converge lento.
• β (momentum): típicamente 0.9. Más alto = más “inercia” (suaviza más, acelera más en direcciones consistentes), pero puede tardar más en reaccionar a cambios y provocar sobrepasos si α es grande.

RMSProp: estabilidad con gradientes ruidosos y escalas distintas

Idea: mantener un promedio exponencial de los cuadrados del gradiente para estimar su magnitud típica por parámetro. Luego, dividir el gradiente por esa magnitud para normalizar el paso. Así, parámetros con gradientes grandes reciben pasos más pequeños y viceversa.

s_t = ρ * s_{t-1} + (1-ρ) * (g_t ⊙ g_t)
θ_t = θ_{t-1} - α * g_t / (sqrt(s_t) + ε)

Qué problema resuelve: gradientes ruidosos (mini-batches) y escalas distintas entre parámetros.

Hiperparámetros clave

• α (learning rate): sigue siendo crucial; RMSProp no “salva” un α absurdamente alto.
• ρ: típico 0.9. Más alto = promedio más lento (más estable, menos reactivo); más bajo = más reactivo pero puede amplificar ruido.
• ε (epsilon): típico 1e-8 o 1e-7. Evita división por cero y mejora estabilidad numérica. Si es demasiado grande, reduce el efecto adaptativo; si es demasiado pequeño, puede haber inestabilidad cuando s_t es muy pequeño.

Adam: Momentum + RMSProp (el estándar práctico)

Idea: combinar (1) un promedio exponencial del gradiente (momentum) y (2) un promedio exponencial del cuadrado del gradiente (escala adaptativa). Además, aplica corrección de sesgo al inicio (porque los promedios empiezan en cero).

m_t = β1 * m_{t-1} + (1-β1) * g_t
v_t = β2 * v_{t-1} + (1-β2) * (g_t ⊙ g_t)
m̂_t = m_t / (1 - β1^t)
v̂_t = v_t / (1 - β2^t)
θ_t = θ_{t-1} - α * m̂_t / (sqrt(v̂_t) + ε)

Qué problema resuelve: valles (por momentum), gradientes ruidosos y escalas distintas (por normalización adaptativa).

Hiperparámetros clave (y efectos en estabilidad)

• α (learning rate): valor típico 1e-3, pero depende del modelo y del batch size. Si la pérdida oscila fuerte o explota, suele ser el primer sospechoso.
• β1: típico 0.9. Más alto = más suavizado del gradiente (menos ruido), pero puede “arrastrar” direcciones antiguas.
• β2: típico 0.999. Controla el suavizado de la magnitud del gradiente. Más alto = estimación más estable; demasiado alto puede hacer que el adaptativo reaccione lento a cambios.
• ε: típico 1e-8. Afecta estabilidad numérica y, en algunos casos, el tamaño efectivo del paso cuando v̂_t es pequeño.

Cuándo elegir cada uno (regla práctica)

Situación	Opción práctica	Motivo
Entrenamiento general, baseline rápido	Adam	Robusto a ruido y escalas distintas
Superficie con ravinas, zigzag evidente	Momentum o Adam	Acelera en direcciones consistentes
Gradientes muy ruidosos (mini-batches pequeños)	RMSProp o Adam	Normaliza por magnitud y estabiliza

Para profundizar con implementaciones y ejemplos interactivos, puedes contrastar configuraciones en notebooks de PyTorch Tutorials, TensorFlow/Keras Guides o cursos con laboratorios en Coursera y DeepLearning.AI.

Programación de learning rate (LR scheduling): el “cuándo” del paso

Incluso con Adam, un learning rate fijo suele ser subóptimo. La programación de LR busca:

• Arrancar estable (evitar explosiones al inicio).
• Explorar rápido al principio y refinar al final.
• Mejorar generalización al reducir LR cuando el modelo se estanca.

1) Step decay (reducción por escalones)

Reduce el LR en hitos (epochs) predefinidos.

si epoch en {30, 60, 90}:  α = α * γ   (γ típico: 0.1 o 0.5)

• Ventaja: simple y efectivo.
• Riesgo: si los hitos no coinciden con el progreso real, puedes reducir demasiado pronto (entrenamiento lento) o demasiado tarde (oscilaciones).

2) Cosine annealing (decaimiento cosenoidal)

Disminuye el LR suavemente siguiendo una curva coseno, desde α_max hasta α_min.

α_t = α_min + 0.5*(α_max-α_min)*(1 + cos(π * t / T))

• Ventaja: transición suave, suele dar buen refinamiento final.
• Uso típico: entrenamientos largos donde quieres una bajada gradual sin “saltos”.

3) Warmup (calentamiento inicial)

Empieza con LR bajo y lo incrementa gradualmente durante las primeras iteraciones/epochs hasta llegar a α objetivo.

para t < T_warmup:  α_t = α_target * (t / T_warmup)

• Ventaja: mejora estabilidad al inicio, especialmente con batches grandes o modelos profundos.
• Combinación común: warmup + cosine annealing (sube suave, luego baja suave).

Parada temprana (Early Stopping) basada en validación

La parada temprana detiene el entrenamiento cuando la métrica de validación deja de mejorar, evitando sobreentrenamiento y ahorrando cómputo. Se basa en observar valid_loss (o una métrica como accuracy/F1 según el caso) y aplicar un criterio de paciencia.

Criterio típico

• Monitor: valid_loss (queremos que baje).
• Patience: número de epochs sin mejora antes de parar (p.ej., 5–20).
• Min delta: mejora mínima para contar como progreso (p.ej., 1e-4).
• Restore best weights: al parar, volver a los pesos con mejor validación.

best = +inf
wait = 0
for epoch in 1..E:
  entrenar()
  val = evaluar_validacion()
  if val < best - min_delta:
    best = val
    guardar_pesos()
    wait = 0
  else:
    wait += 1
    if wait >= patience:
      cargar_mejores_pesos()
      parar

Consejo: si usas un scheduler que reduce LR al estancarse (por ejemplo, “reduce on plateau”), coordínalo con early stopping para no parar justo antes de que la reducción de LR haga efecto (p.ej., patience de early stopping mayor que la del scheduler).

Guía práctica paso a paso: configuración robusta de optimización

Paso 1: elige un baseline razonable

• Empieza con Adam.
• Valores iniciales típicos: lr=1e-3, betas=(0.9, 0.999), eps=1e-8.

Paso 2: añade un scheduler simple

• Si no sabes por dónde empezar: cosine annealing (con lr_min pequeño) o step decay con 1–3 reducciones.
• Si observas inestabilidad al inicio: añade warmup (p.ej., 5% de las iteraciones totales).

Paso 3: activa early stopping con restauración de mejores pesos

• monitor=val_loss, patience=10, min_delta=1e-4, restore_best_weights=true.

Paso 4: registra curvas y métricas

• Guarda por epoch: train_loss, val_loss, LR actual, y (si aplica) la métrica principal.
• Herramientas: TensorBoard, Weights & Biases o MLflow.

Diagnóstico con curvas de pérdida: detectar learning rate demasiado alto o bajo

Las curvas de train_loss y val_loss son tu instrumento principal para ajustar LR y scheduler. A continuación, patrones comunes y acciones.

Patrón observado	Interpretación probable	Acción recomendada
train_loss sube y baja violentamente; a veces explota (NaN/inf)	LR demasiado alto o inestabilidad numérica	Baja lr (p.ej., x0.1), añade warmup, revisa eps si hay NaNs, considera gradient clipping
train_loss baja muy lento, casi plano desde el inicio	LR demasiado bajo	Sube lr (p.ej., x2 o x3), o usa warmup para permitir un LR objetivo mayor
train_loss baja bien, val_loss no mejora y empeora	Sobreajuste (no es solo LR)	Activa/ajusta early stopping, regularización, data augmentation; también prueba bajar LR al estancarse
train_loss baja, val_loss mejora a saltos tras reducir LR	Scheduler está ayudando a refinar	Mantén estrategia; considera más reducciones o un lr_min menor
val_loss oscila mucho entre epochs	Gradiente ruidoso / validación pequeña / LR alto	Aumenta batch size si es posible, baja LR, usa promedio (EMA) de pesos o mayor paciencia

Mini-protocolo de ajuste de LR (rápido)

• 1) Entrena pocas epochs (p.ej., 5–10) con tu configuración actual y mira la forma de train_loss.
• 2) Si hay oscilación fuerte o divergencia: reduce lr 10× o añade warmup.
• 3) Si está plano: incrementa lr 2–3×.
• 4) Cuando el descenso sea estable: añade scheduler para refinar (cosine o step) y early stopping para detener en el mejor punto de validación.