Referencia: Regularización

Por qué los modelos se sobreajustan

Un modelo se sobreajusta cuando aprende patrones que existen en el conjunto de entrenamiento pero no en el proceso subyacente de generación de datos. El síntoma es familiar: la pérdida de entrenamiento sigue cayendo, la pérdida de validación se estanca o sube, y la brecha entre ambas crece. La causa es que cualquier modelo con la capacidad suficiente eventualmente empezará a memorizar el ruido en su muestra de entrenamiento particular — y el ruido, por definición, no generaliza.

El planteamiento clásico es la descomposición sesgo-varianza. Para un objetivo $y = f(x) + \epsilon$ con varianza de ruido $\sigma^2$, el error cuadrático esperado de prueba de un estimador $\hat f$ se divide en tres partes: un término de sesgo (qué tan errónea es la predicción promedio), un término de varianza (cuánto varía la predicción entre diferentes conjuntos de entrenamiento) y el ruido irreducible $\sigma^2$. Un modelo simple tiene sesgo alto pero varianza baja: se subajusta. Un modelo complejo tiene sesgo bajo pero varianza alta: se sobreajusta. La regularización es el término amplio para cualquier técnica que añade sesgo a cambio de una mayor reducción en la varianza, deslizándote a lo largo de la curva en forma de U del error de prueba hacia su mínimo.

El resto de esta referencia cataloga los regularizadores más comunes, cuál es el costo de cada uno y cuándo es la herramienta adecuada.

Lista de regularizadores

Regularizador	Definición en una línea	Rango típico	Cuándo usarlo	Usado en el corpus
L2 (Ridge)	Añadir $\lambda\lVert w\rVert_2^2$ a la pérdida	$\lambda \in [10^{-5}, 10]$	Predeterminado para modelos lineales; base del weight decay en redes neuronales	classical-ml-p03, lora-and-qlora
L1 (Lasso)	Añadir $\lambda\lVert w\rVert_1$ a la pérdida	$\lambda \in [10^{-4}, 1]$	Cuando se necesitan características dispersas e interpretables	classical-ml-p03
ElasticNet	$\alpha \cdot \text{L1} + (1-\alpha) \cdot \text{L2}$	$\alpha \in [0,1]$, mismo rango de $\lambda$	Características correlacionadas donde L1 es demasiado agresivo	classical-ml-p03
Dropout	Poner a cero una fracción $p$ de las activaciones durante el entrenamiento	$p \in [0.2, 0.5]$	Redes profundas, especialmente capas totalmente conectadas anchas	attention-p11
BatchNorm	Normalizar cada característica a media 0, var 1 en el lote	momentum $\approx 0.9$	CNNs y redes profundas con un tamaño de lote cómodo	attention-p11
LayerNorm	Normalizar a lo largo de las características por ejemplo, no a lo largo del lote	—	Transformers, RNNs, configuraciones con tamaño de lote 1	attention-p03
Early stopping	Detener cuando la pérdida de validación ha subido durante $k$ épocas	$k \in [3, 20]$	Universal; esencialmente gratuito; probar primero	learning-curves
Weight decay	Penalización L2 aplicada a través del optimizador (AdamW)	$10^{-4}$ a $10^{-2}$	Redes profundas, especialmente transformers y grandes fine-tunes	lora-and-qlora
Data augmentation	Transformar entradas, conservar etiquetas, entrenar con la unión	varía según la modalidad	Visión, audio, cada vez más texto; regímenes con escasez de datos	—

Qué regularizador para cada arquitectura

Elige el regularizador según el tipo de modelo que tengas, no por lo que esté de moda actualmente:

• Regresión lineal / logística
  • ¿Necesitas características dispersas e interpretables? → L1 (Lasso) — pondrá en cero las irrelevantes.
  • ¿Solo quieres reducir los coeficientes y estabilizar? → L2 (Ridge) — casi nunca perjudica.
  • ¿Las características están correlacionadas y L1 por sí solo es inestable? → ElasticNet en $\alpha \approx 0.5$.
• Modelos basados en árboles (XGBoost, LightGBM, RandomForest)
  • No recurras a L1/L2 — no se aplican a los árboles.
  • Controla la profundidad: max_depth, min_samples_leaf.
  • Controla la aleatoriedad por árbol: subsample, colsample_bytree.
  • Ralentiza el ensamble: disminuye learning_rate, aumenta n_estimators proporcionalmente.
• Redes neuronales profundas
  • ¿Sobreajuste concentrado en capas FC anchas? → Dropout en $p = 0.3$–$0.5$.
  • ¿Las activaciones explotan o el entrenamiento es inestable? → BatchNorm (CNN) o LayerNorm (Transformer).
  • ¿Aún hay sobreajuste después de dropout + normalización? → Early stopping + weight decay (vía AdamW).
  • ¿Muy pocos datos de entrenamiento? → Aumento de datos.
• Cualquier arquitectura, de forma gratuita
  • Early stopping — ajusta la paciencia a ~10 épocas, registra la pérdida de validación en cada época y despliega el checkpoint con la menor pérdida de validación.

L1, L2 y ElasticNet — regularizadores basados en penalización

Estos tres son los regularizadores más antiguos y mejor comprendidos. La receta es la misma en cada caso: tome el objetivo de entrenamiento original $\mathcal{L}(w)$ y añada una penalización sobre el tamaño de los pesos.

L2 (Ridge). La penalización es $\lambda \lVert w \rVert_2^2 = \lambda \sum_i w_i^2$. Debido a que la penalización es suave, cada peso es atraído suavemente hacia cero, pero rara vez llega completamente hasta allí. L2 produce pesos pequeños, no pesos nulos. Es el regularizador por defecto para la regresión lineal y la base conceptual del weight decay en el aprendizaje profundo.

L1 (Lasso). La penalización es $\lambda \lVert w \rVert_1 = \lambda \sum_i |w_i|$. El quiebre en $w_i = 0$ en $|w_i|$ cambia la geometría de optimización lo suficiente para que la solución óptima frecuentemente tenga coeficientes completos fijados exactamente en cero. Esta es la propiedad de dispersión: L1 también funciona como selección automática de características. Úselo cuando tenga muchas características y solo unas pocas importen.

ElasticNet. Una mezcla convexa $\alpha \cdot \text{L1} + (1-\alpha) \cdot \text{L2}$. Cuando las características están correlacionadas, L1 tiene la costumbre de elegir una y llevar la otra a cero arbitrariamente; L2 mantiene ambos reducidos pero no nulos. ElasticNet reparte la diferencia. Establezca $\alpha$ cerca de 1 para un comportamiento dominado por la dispersión, cerca de 0 para uno dominado por Ridge.

El objetivo de Ridge y su gradiente:

$\mathcal{L}_{\text{ridge}}(w) = \mathcal{L}(w) + \lambda \sum_i w_i^2, \qquad \nabla \mathcal{L}_{\text{ridge}} = \nabla \mathcal{L}(w) + 2\lambda w$

El objetivo de Lasso y su subgradiente (el valor absoluto no es diferenciable en cero, por lo que usamos un subgradiente):

$\mathcal{L}_{\text{lasso}}(w) = \mathcal{L}(w) + \lambda \sum_i |w_i|, \qquad \partial \mathcal{L}_{\text{lasso}} = \nabla \mathcal{L}(w) + \lambda \, \text{sign}(w)$

Por qué L1 es disperso pero L2 no. Imagine la pérdida no regularizada como un conjunto de elipses concéntricas en el espacio de pesos, centradas en la solución no regularizada. La restricción de L2 $\lVert w \rVert_2^2 \le c$ es una esfera; la restricción de L1 $\lVert w \rVert_1 \le c$ es un diamante con esquinas en los ejes. La elipse más pequeña que toca la esfera usualmente toca en un punto suave, fuera de los ejes — todas las coordenadas son no nulas. La elipse más pequeña que toca el diamante casi siempre lo hace en una esquina — y una esquina es un punto donde al menos una coordenada es cero. Ese es el argumento geométrico completo para la dispersión.

Descomposición sesgo-varianza. Para referencia, el desglose en tres partes que motiva todo en este archivo:

$\mathbb{E}\!\left[(y - \hat f)^2\right] = \big(\mathbb{E}[\hat f] - f\big)^2 + \mathbb{E}\!\left[\big(\hat f - \mathbb{E}[\hat f]\big)^2\right] + \sigma^2$

En lenguaje sencillo	Símbolo estadístico	Equivalente en Python
Error cuadrático medio de predicción	$\mathbb{E}[(y - \hat f)^2]$	mean_squared_error(y, y_pred)
Norma L2 al cuadrado de los pesos	$\lVert w\rVert_2^2 = \sum_i w_i^2$	(w ** 2).sum()
Norma L1 de los pesos	$\lVert w\rVert_1 = \sum_i \lvert w_i\rvert$	np.abs(w).sum()
Fuerza de regularización	$\lambda$ (alpha en sklearn)	Ridge(alpha=1.0)

Dropout, BatchNorm y LayerNorm — regularizadores estructurales para redes profundas

Una vez que el modelo tiene capas ocultas no lineales, las penalizaciones de peso por sí solas hacen menos trabajo del que podría esperar. La siguiente familia de regularizadores cambia la arquitectura del entrenamiento en lugar de la pérdida.

Dropout. Durante el entrenamiento, se toma un subconjunto aleatorio de activaciones en una capa y se establecen en cero con probabilidad $p$ (normalmente de $0.2$ a $0.5$). En la inferencia, se utilizan todas las activaciones, escaladas para compensar. El efecto es que ninguna neurona individual puede convertirse en una característica fundamental, porque en cualquier paso dado podría ser desactivada. La red aprende representaciones redundantes y distribuidas, y estas generalizan mejor. Dropout es más útil en capas completamente conectadas anchas; en capas convolucionales suele ser redundante una vez que BatchNorm está en su lugar, y en los transformers ha sido desplazado en gran medida por LayerNorm más el decaimiento de peso.

BatchNorm. Normaliza cada canal de características a lo largo del lote a una media de 0 y una varianza de 1, y luego aprende una escala y un desplazamiento por canal. El efecto inmediato es estabilizar el entrenamiento: los gradientes fluyen de manera más fluida y se pueden utilizar tasas de aprendizaje más grandes. El efecto regularizador es un beneficio secundario: las estadísticas por lote inyectan ruido, lo que por sí mismo suprime el sobreajuste. BatchNorm necesita un lote lo suficientemente grande (digamos de 32+) para que las estadísticas sean significativas; con un tamaño de lote de 1, o con secuencias de longitud variable, deja de ser una buena idea.

LayerNorm. Misma idea, diferente eje: se normaliza a través de las características de un solo ejemplo, no a lo largo del lote. Esto lo hace agnóstico al tamaño del lote y la opción estándar para transformers y RNNs. El efecto regularizador de LayerNorm es más débil que el de BatchNorm — está principalmente para la estabilidad del entrenamiento —, pero no falla en las cargas de trabajo donde BatchNorm sí lo hace.

Early stopping, weight decay y data augmentation — la familia sin penalización

El último grupo de regularizadores no toca la pérdida en absoluto. Funcionan cambiando cuándo se detiene, cómo se actualiza, o qué se introduce al modelo.

Early stopping. Monitorear una métrica de validación. Detener el entrenamiento la primera vez que empeore durante $k$ épocas consecutivas (la paciencia), y revertir al mejor checkpoint. Es el regularizador más económico que se tiene — sin reentrenamiento, sin barrido de hiperparámetros más allá de la paciencia, y se combina limpiamente con todo lo demás. La razón más profunda por la que funciona es que el descenso de gradiente explora primero las soluciones de norma baja; cuanto más se entrena, mayor es la norma efectiva de los pesos. Early stopping es aproximadamente L2 con un $\lambda$ dependiente de los datos.

Weight decay. En los optimizadores modernos (AdamW, Adam con weight_decay activado), weight decay es la versión de deep learning de L2 — pero la implementación importa. El Adam original acoplaba la penalización L2 en el gradiente, lo cual interactúa mal con el escalado de momentos adaptativos de Adam. AdamW los desacopla: reduce los pesos primero por un factor $(1 - \eta \lambda)$, y luego aplica el paso del gradiente. Siempre usar AdamW en lugar de Adam con L2 cuando se quiere weight decay en un transformer.

Data augmentation. Generar nuevos ejemplos de entrenamiento aplicando transformaciones que preservan las etiquetas: volteos y recortes para imágenes, cambios de tono y ruido para audio, paráfrasis o traducción inversa para texto. Data augmentation es el único regularizador que aumenta el tamaño efectivo del dataset en lugar de restringir el modelo, por lo que es lo primero a lo que se debe recurrir cuando los datos son escasos. Se combina con todo lo demás.

Ejemplo en Python: un modelo sobreajustado y qué hace cada regularizador con él

El primer ejemplo utiliza una configuración de regresión lineal deliberadamente hostil: 200 muestras, 60 características, de las cuales solo 5 llevan señal. El modelo no regularizado se ajusta al conjunto de entrenamiento casi a la perfección y generaliza mal.

import numpy as np
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
from sklearn.datasets import make_regression

# 200 samples, 60 features, only 5 carry signal — the rest are noise.
X, y, true_coef = make_regression(
    n_samples=200, n_features=60, n_informative=5,
    noise=15, coef=True, random_state=7,
)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=7)

def fit_and_score(model, name):
    model.fit(X_train, y_train)
    tr = r2_score(y_train, model.predict(X_train))
    te = r2_score(y_test,  model.predict(X_test))
    nz = int(np.sum(np.abs(model.coef_) > 1e-6))
    print(f"{name:18s}  train R²={tr:.3f}  val R²={te:.3f}  nonzero coefs={nz}")

fit_and_score(LinearRegression(),                         "OLS (no reg)")
fit_and_score(Ridge(alpha=1.0),                           "Ridge (L2)")
fit_and_score(Lasso(alpha=0.1),                           "Lasso (L1)")
fit_and_score(ElasticNet(alpha=0.1, l1_ratio=0.5),        "ElasticNet")

Salida plausible (ilustrativa, no una ejecución en vivo):

OLS (no reg)        train R²=0.961  val R²=0.711  nonzero coefs=60
Ridge (L2)          train R²=0.912  val R²=0.778  nonzero coefs=60
Lasso (L1)          train R²=0.847  val R²=0.821  nonzero coefs=8
ElasticNet          train R²=0.872  val R²=0.815  nonzero coefs=12

La historia está en las dos últimas columnas. OLS usa los 60 coeficientes y se sobreajusta por 25 puntos de R². L2 mantiene los 60 coeficientes pero los encoge — el de entrenamiento baja, el de validación sube. L1 descarta 52 de los 60 coeficientes y obtiene la mejor puntuación de validación, porque solo 5 características importan realmente. ElasticNet se sitúa en un punto intermedio, reteniendo algunos vecinos correlacionados de las características reales.

El segundo ejemplo pasa a una red neuronal profunda pequeña con el mismo tipo de problema y muestra qué hacen el dropout, el weight decay y el early stopping a la curva de pérdida de entrenamiento frente a validación.

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(7)
X = torch.randn(400, 20)
true_w = torch.zeros(20); true_w[:5] = torch.tensor([1.5, -2.0, 0.8, 3.0, -1.2])
y = X @ true_w + 0.5 * torch.randn(400)
loader = DataLoader(TensorDataset(X, y), batch_size=32, shuffle=True)
X_tr, y_tr, X_val, y_val = X[:300], y[:300], X[300:], y[300:]

def make_model(p_drop=0.0):
    return nn.Sequential(
        nn.Linear(20, 128), nn.ReLU(), nn.Dropout(p_drop),
        nn.Linear(128, 128), nn.ReLU(), nn.Dropout(p_drop),
        nn.Linear(128, 1),
    )

def train(p_drop=0.0, epochs=150, lr=1e-3, weight_decay=0.0, patience=None):
    model = make_model(p_drop)
    opt = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
    loss_fn = nn.MSELoss()
    tr_hist, val_hist = [], []
    best, best_ep, wait = float("inf"), 0, 0
    for ep in range(epochs):
        model.train()
        for xb, yb in loader:
            opt.zero_grad()
            loss = loss_fn(model(xb).squeeze(-1), yb)
            loss.backward(); opt.step()
        model.eval()
        with torch.no_grad():
            tr_loss  = loss_fn(model(X_tr ).squeeze(-1), y_tr ).item()
            val_loss = loss_fn(model(X_val).squeeze(-1), y_val).item()
        tr_hist.append(tr_loss); val_hist.append(val_loss)
        if patience is not None:
            if val_loss < best - 1e-4:
                best, best_ep, wait = val_loss, ep, 0
            else:
                wait += 1
                if wait >= patience: break
    return tr_hist, val_hist

for label, kwargs in [
    ("baseline",            dict()),
    ("dropout=0.3",         dict(p_drop=0.3)),
    ("weight_decay=1e-2",  dict(weight_decay=1e-2)),
    ("early_stop=10",       dict(patience=10)),
]:
    tr, val = train(epochs=150, **kwargs)
    print(f"{label:22s}  final train={tr[-1]:.3f}  final val={val[-1]:.3f}  epochs={len(tr)}")

Salida plausible:

baseline              final train=0.182  final val=0.341  epochs=150
dropout=0.3           final train=0.219  final val=0.289  epochs=150
weight_decay=1e-2     final train=0.241  final val=0.272  epochs=150
early_stop=10         final train=0.247  final val=0.268  epochs=47

Cada regularizador aumenta ligeramente la pérdida de entrenamiento y reduce la de validación — ese es el tradeoff de sesgo-varianza en acción. El early stopping logra la mejor pérdida de validación en un tercio de las épocas, que es el patrón habitual: es el regularizador que da resultados más rápido.

La parte lineal. make_regression construye un problema de regresión donde n_informative=5 de las 60 características realmente impulsan el objetivo; las otras 55 son puro ruido. Con 200 muestras y 60 características, OLS tiene suficiente capacidad para ajustarse al ruido del entrenamiento y termina 25 puntos de R² peor en los datos reservados. El asistente fit_and_score imprime el R² de entrenamiento, el R² de validación y el recuento de coeficientes por encima de $10^{-6}$ en valor absoluto — ese último número es lo que hace visible el efecto de dispersión de L1.

La comparación interesante es entre Ridge y Lasso. Ambos tienen magnitudes de alpha similares (1.0 y 0.1 — escalas diferentes porque la penalización de L1 es menor por unidad de peso). Ridge mantiene las 60 características distintas de cero pero las encoge; Lasso pone a cero 52 de ellas y llega a un R² de validación más alto. Esta es la propiedad de dispersión del toggle de matemáticas, hecha visible en números.

La parte profunda. make_model construye un MLP de 20-128-128-1 con ReLU y (opcionalmente) dropout entre capas. La función train es un bucle de entrenamiento mínimo con un giro: registra tr_hist y val_hist en cada época, y si patience está configurado, se detiene en el momento en que la pérdida de validación no ha mejorado durante ese número de épocas consecutivas.

Tres cosas a notar en la salida:

1. El dropout aumenta la pérdida de entrenamiento pero disminuye la de validación. Ese es todo el punto: el dropout hace que el entrenamiento sea más difícil, lo que obliga al modelo a aprender características redundantes que sobreviven al enmascaramiento aleatorio.
2. El weight decay (AdamW) desplaza ambas curvas ligeramente hacia arriba pero la brecha se reduce. Está haciendo lo mismo que Ridge en el modelo lineal — encoger los pesos — pero a través del optimizador en lugar de un término de pérdida explícito.
3. El early stopping se detiene en la época 47, antes de que la red tenga tiempo de sobreajustarse. También obtiene la mejor pérdida de validación de las cuatro ejecuciones. Si solo tienes tiempo para probar un regularizador, ese es el indicado.

La función devuelve deliberadamente el historial completo, no solo el número final — la curva de entrenamiento frente a validación es el diagnóstico que realmente quieres examinar, no un solo punto. Traza tr_hist y val_hist uno contra el otro y la brecha entre ellos es la brecha de sobreajuste, hecha visible.

Casos límite y errores comunes

• Confundir el weight decay con L2. Con SGD estándar son equivalentes. Con Adam no lo son: la penalización L2 se reescala por el segundo momento del gradiente, lo cual es incorrecto. Usa AdamW, que los desacopla. Los valores predeterminados de PyTorch y HuggingFace hacen esto correctamente; el código antiguo que usa torch.optim.Adam(..., weight_decay=...) no.
• Configurar un dropout demasiado alto. $p = 0.5$ es el máximo en los libros de texto y ya es mucho. Por encima de $0.5$ generalmente estás subajustando a propósito. Si necesitas tanta regularización, tu modelo es demasiado grande o tus datos son muy pocos: arregla uno de esos dos primero.
• Usar BatchNorm con un tamaño de lote de 1. Las estadísticas del lote pierden sentido; la estimación de la varianza es esencialmente cero y la normalización no hace nada útil, o hace algo perjudicial. Usa LayerNorm o GroupNorm en cualquier escenario donde los lotes sean minúsculos o variables: aprendizaje federado, inferencia en línea, modelos recurrentes de secuencias.
• Poner LayerNorm donde debería ir BatchNorm. LayerNorm no recibe el ruido por lote que le da a BatchNorm su efecto secundario regularizador; en CNNs con tamaños de lote cómodos, generalmente tiene un rendimiento inferior. Haz coincidir la normalización con la arquitectura: BatchNorm para CNNs, LayerNorm para transformers.
• Asumir que L1 te dará interpretabilidad. L1 te da dispersión, lo cual es necesario pero no suficiente para la interpretabilidad. Con características correlacionadas, L1 elige una de forma arbitraria; el conjunto de valores distintos de cero no es estable entre remuestreos. Si realmente necesitas características interpretables, combina L1 con selección por estabilidad o atribución estilo Shapley.
• Olvidar reentrenar después de la parada temprana. Si haces una parada temprana en un conjunto de validación y luego despliegas el modelo, has incorporado el ruido del conjunto de validación en la decisión de parada. Ya sea reservar un conjunto de prueba separado para la métrica final, o —si debes reentrenar con todos los datos— usa el número de épocas de la ejecución de parada temprana como un calendario fijo.
• Aumentar el conjunto de prueba. El aumento de datos aplica solo al entrenamiento. El conjunto de prueba es el conjunto de prueba: transfórmalo de la misma manera en que transformas las entradas de inferencia (redimensionamiento, normalización, etc.), pero nunca lo voltees, recortes ni le apliques jitter.
• Usar L1 con un $\lambda$ minúsculo. La dispersión se activa en un rango estrecho de $\lambda$. Si es demasiado pequeño, no obtienes dispersión (solo tienes OLS); si es demasiado grande, has puesto todo a cero. Siempre barre $\lambda$ en una escala logarítmica (p. ej., [1e-4, 1e-3, 1e-2, 1e-1, 1]) en lugar de una lineal.
• Añadir regularización antes de haber establecido un baseline. La regularización añade hiperparámetros, y los hiperparámetros te cuestan presupuesto de ajuste. Ajusta primero el modelo sin regularizar, observa la curva de entrenamiento contra validación y añade solo el regularizador que aborde el modo de falla real que ves. Si la curva no muestra una brecha de sobreajuste, ninguna cantidad de dropout ayudará: solo causará subajuste.

Referencias cruzadas

• Compensación de sesgo y varianza en términos sencillos — el fundamento conceptual de todo en este archivo.
• Regularización explicada: por qué tus modelos se sobreajustan — la versión narrativa completa de la historia de L1/L2.
• Por qué las redes profundas mueren: resolviendo el gradiente evanescente — cubre los problemas de flujo de gradiente que BatchNorm y LayerNorm abordan parcialmente.
• Batch Normalization y Dropout: el par de regularización — la familia de regularizadores para redes profundas en detalle.
• LoRA y QLoRA explicados: ajuste fino de modelos grandes en una sola GPU — utiliza el decaimiento de pesos y dropout en el contexto del ajuste fino eficiente en parámetros.
• Curvas de aprendizaje: cómo leer la mente de tu modelo para combatir el sobreajuste — el diagnóstico que te dice qué regularizador realmente necesitas.

Lecturas adicionales

• Tibshirani, R. (1996). Regression shrinkage and selection via the Lasso. Journal of the Royal Statistical Society, Series B, 58(1), 267–288. El artículo original de Lasso; sigue siendo la exposición más clara de la propiedad de dispersión.
• Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., & Salakhutdinov, R. (2014). Dropout: A Simple Way to Prevent Neural Networks from Overfitting. Journal of Machine Learning Research, 15(56), 1929–1958.
• Ioffe, S., & Szegedy, C. (2015). Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. arXiv:1502.03167. El artículo original de BatchNorm.
• Loshchilov, I., & Hutter, F. (2019). Decoupled Weight Decay Regularization. arXiv:1711.05101. El artículo de AdamW — léelo antes de recurrir a weight_decay en cualquier optimizador.
• Documentación de librerías: modelos lineales de scikit-learn, PyTorch nn.Dropout, PyTorch nn.LayerNorm, PyTorch optim.AdamW.