Conseguir que entrene y que generalice

Empieza mirando, en vez de adivinar. Pasa un lote de entradas por la red e imprime la desviación estándar de las activaciones en cada capa, y después la desviación estándar de los gradientes de los pesos:

def profile(model, x):
    h = x
    for layer in model:
        h = layer(h)
        if isinstance(layer, (nn.Tanh, nn.ReLU)):
            print(f"activation std: {h.std().item():.4f}")
    model(x).sum().backward()
    for p in model.parameters():
        if p.dim() == 2:
            print(f"gradient std: {p.grad.std().item():.2e}")

Tres inicializaciones, misma arquitectura, seis capas de $\tanh$:

La primera fila es la red de arriba, y no está aprendiendo despacio: ya no le queda señal. En la capa cuatro, la desviación estándar de activación se ha subdesbordado hasta cero a cuatro decimales. Cada entrada produce la misma salida, la salida es una constante y el gradiente de una constante no es nada. Los pesos se inicializaron pequeños «para ir sobre seguro», y pequeño fue fatal.

La segunda fila es el fallo contrario y merece entenderse porque va contra la intuición. Las activaciones parecen sanas —alrededor de 0.96—, pero eso es $\tanh$ saturado, clavado cerca de su límite, exactamente el régimen que el Capítulo 5 midió como una pérdida de un factor de casi diez mil en el gradiente. Y aun así los gradientes son enormes: 1940 en la primera capa. Ambas cosas son ciertas a la vez. Cada paso hacia atrás multiplica por $W^\top$, y con 128 entradas a varianza unitaria ese factor tiene una ganancia de alrededor de $\sqrt{128} \approx 11$, que supera la contracción del $\tanh$ saturado. Los gradientes crecen geométricamente al retroceder. Este es el gradiente explosivo, y produce valores de pérdida de nan en unos pocos pasos en cualquier entrenamiento real.

La tercera fila es lo que quieres: activaciones con una escala más o menos constante a través de la profundidad, gradientes con una escala más o menos constante a través de la profundidad. Nada muere, nada explota.

Inicializar bien fija la escala en el paso cero. No la mantiene fija: los pesos se mueven, y para el paso cinco mil el cuidadoso argumento de varianza ya no se aplica.

Las capas de normalización imponen la escala de forma continua. Dado un vector de activaciones, resta una media, divide por una desviación estándar y después aplica una escala aprendida $\gamma$ y un desplazamiento $\beta$ para que la capa pueda deshacer la normalización si eso resulta ser lo que quiere:

La única pregunta real es sobre qué promedias. La normalización por lote³ toma $\mu$ y $\sigma$ a través de la dimensión del lote, una estadística por característica. La normalización por capa⁴ los toma a través de las características, una estadística por ejemplo.

Esa elección parece menor y decide casi todo lo que viene después:

Por eso LayerNorm es la que volverás a encontrar en el Capítulo 9 sin cambios: el bloque transformer la usa, y la usa por las razones de la columna derecha, no porque funcione mejor en abstracto.

Cuatro posibles arreglos para la red muerta: inicialización Xavier, LayerNorm, conexiones residuales y Adam en vez de SGD. La tentación es aplicar los cuatro y seguir adelante. Hazlo y nunca sabrás cuál importaba, y la próxima vez que ocurra no tendrás un método: solo un ritual.

Así que aplícalos de uno en uno. Misma semilla, mismos datos, misma arquitectura, 800 pasos:

Lee esa tabla como la leerías a las 2 de la mañana y la conclusión es: nada funciona solo, todo funciona junto, por tanto el deep learning es alquimia. Esa conclusión es falsa, y descubrir por qué es lo más útil de este capítulo.

Dale a cada ejecución seis veces el presupuesto —5000 pasos en vez de 800— y cambia por completo:

Ahora la imagen es nítida, y es un diagnóstico en vez de un ritual.

La inicialización por sí sola lo arregla. La normalización por sí sola lo arregla. Cada una ataca la enfermedad real —la señal hacia delante colapsando a cero— y cualquiera de las dos es suficiente. A los 800 pasos solo parecían mérito parcial, porque habían resuelto el problema y aún estaban saliendo del agujero.

Las conexiones residuales y Adam no lo arreglan, con ningún presupuesto. No porque sean malas, sino porque tratan otra enfermedad. Una conexión residual da al gradiente un camino alrededor de una capa bloqueante; eso vale muchísimo cuando el problema es el gradiente, y no vale nada cuando la señal hacia delante ya es cero, porque un atajo alrededor de una capa muerta sigue llevando un valor muerto. Adam reescala el paso de cada parámetro según su propio historial de gradientes; eso ayuda cuando los gradientes tienen magnitudes muy distintas, y no puede resucitar una red cuya salida no depende de su entrada.

Y «nada» sigue siendo exactamente 0.6931 después de cinco mil pasos. No 0.6929. No va lenta; está muerta, y esa distinción ahora es visible de una forma que antes no lo era, porque tienes la fila que dice que un arreglo funciona para comparar.

A partir de aquí este curso usa PyTorch. Eso debería ganarse, no anunciarse, así que aquí tienes exactamente qué hace que tú ya sabes hacer.

Un optimizador es una regla para convertir gradientes en actualizaciones de parámetros. El gradient descent puro usa el gradiente. Momentum usa una media móvil de él, lo que suaviza el ruido y gana velocidad en direcciones que se mantienen consistentes:

v = beta * v + p.grad          
p -= lr * v                    

Adam⁵ mantiene dos medias móviles —del gradiente y del gradiente al cuadrado— y divide una por la raíz cuadrada de la otra, de modo que cada parámetro recibe un paso escalado a la magnitud reciente de su propio gradiente:

m = b1 * m + (1 - b1) * g          # mean of the gradient          
v = b2 * v + (1 - b2) * g * g      # mean of the squared gradient  
m_hat = m / (1 - b1 ** t)          # bias correction: both averages start at zero
v_hat = v / (1 - b2 ** t)
p -= lr * m_hat / (v_hat.sqrt() + eps)   

Diez líneas. Ejecuta ambos contra torch.optim en el mismo problema durante 50 pasos:

SGD+momentum   by hand [2.7781870365142822, -1.0304985046386719]
               torch   [2.7781870365142822, -1.0304983854293823]   max |diff| = 1.19e-07
Adam           by hand [0.4893140196800232, -0.46317872405052185]
               torch   [0.48931416869163513, -0.46317875385284424]   max |diff| = 1.49e-07

Idénticos a precisión float32. torch.optim.Adam son esas cinco líneas, más décadas de cuidado con casos límite y un kernel en C++. Ese es el intercambio que harás a partir de ahora: no magia a cambio de comprensión, sino velocidad a cambio de líneas que ya has escrito.

La explicación habitual de Adam es «learning rates adaptativos por parámetro», que es una descripción más que una razón. La razón es la geometría, y se puede medir.

Toma una pérdida cuya curvatura difiere entre direcciones: empinada en una, suave en otra. SGD tiene un learning rate global, así que debe escoger un valor lo bastante pequeño para ser estable en la dirección más empinada; y ese valor queda entonces demasiado pequeño para la dirección suave, donde el progreso se arrastra. Esto es lo que causa la imagen clásica de gradient descent zigzagueando por un valle estrecho.

Dos ratios de curvatura, tres optimizadores, 300 pasos, y a cada optimizador se le da el mejor learning rate de un barrido para que nadie tenga desventaja:

Con un ratio de diez, todo funciona y no hay nada que discutir. Con mil, SGD puro no puede llegar a la respuesta con ningún learning rate probado —su mejor resultado sigue siendo un error de 1.93— y diverge directamente con la mitad de las tasas. Adam aterriza exactamente en el objetivo y no diverge con ninguna.

Esa última columna es la razón práctica por la que Adam es el valor por defecto. No es que Adam encuentre soluciones mejores; en problemas bien condicionados, SGD bien ajustado a menudo lo iguala o lo supera. Es que Adam es mucho menos sensible al learning rate que elegiste, y las redes reales tienen ratios de curvatura mucho peores que mil a través de sus millones de parámetros.

Aquí van dos piezas más y ambas son de una línea. Gradient clipping reescala el vector de gradiente siempre que su norma supera un umbral, lo que convierte la fila «la pérdida salta de repente a un valor enorme» de la tabla de diagnóstico en un no suceso. Y learning rate schedules: un warmup corto desde casi cero durante los primeros cientos de pasos, porque las estimaciones de varianza de Adam son basura hasta que han visto algunos gradientes y un paso de tamaño completo tomado sobre basura puede destrozar una inicialización; después cosine decay hacia cero, porque terminar una ejecución con el mismo tamaño de paso con el que empezaste significa temblar alrededor del mínimo en vez de asentarte en él.

Todo hasta ahora trataba de hacer bajar la pérdida. Ahora viene la mitad más difícil, porque que la pérdida baje no es el objetivo: es un proxy del objetivo, y el proxy falla de una forma concreta y famosa.

Doce puntos de una función suave con un poco de ruido. Ajusta polinomios de grado creciente:

El grado 11 con 12 puntos pasa por todos y cada uno exactamente —error de entrenamiento cero a seis decimales— y es ocho veces peor que el grado 5 en datos que no ha visto. Pide al grado 3 y al grado 11 que predigan en $x = 3.25$, justo fuera del rango de entrenamiento:

degree  3: predicts   -1.053   (truth -0.012)
degree 11: predicts  +61.224   (truth -0.012)

Sesenta y uno, cuando la respuesta es aproximadamente cero. El modelo no aprendió la función; aprendió los doce puntos, y entre ellos hace lo que la aritmética exija.

Esto es overfitting, y su opuesto —grado 1, que no puede representar la curva en absoluto y es malo en todas partes— es underfitting. La explicación clásica divide el error esperado de un modelo en tres partes: sesgo, el error de que el modelo sea demasiado rígido para representar la verdad; varianza, el error de que el modelo sea tan flexible que persiga el ruido de esta muestra concreta; y ruido irreducible, que nada arregla. Los modelos simples están sesgados, los modelos flexibles tienen alta varianza, y la receta clásica es encontrar el punto dulce en medio: grado 5 en la tabla de arriba.

Las herramientas estándar atacan todas el término de varianza:

• Regularización L2 (weight decay) añade $\lambda \lVert w \rVert^2$ a la pérdida, tirando de los pesos hacia cero y haciendo la función más suave. En la tabla de arriba, el mayor coeficiente del grado 11 hace el daño; penalizar el tamaño lo desactiva.
• L1 añade $\lambda \sum |w_i|$ en su lugar. La diferencia no es cosmética: el gradiente de L2 es proporcional al peso y por tanto se reduce a medida que lo hace el peso, acercándose a cero sin llegar, mientras que el gradiente de L1 es una constante $\pm\lambda$ que sigue empujando hasta el final. Por tanto L1 produce pesos que son exactamente cero: selecciona características. L2 produce pesos pequeños. Usa L2 cuando quieras suavidad, L1 cuando quieras escasez.
• Dropout⁷ pone a cero un subconjunto aleatorio de activaciones en cada paso de entrenamiento, de modo que ninguna unidad pueda depender de que otra unidad concreta esté presente.
• Parada temprana vigila la pérdida de validación y se detiene cuando empieza a subir.
• Aumento de datos fabrica más ejemplos de entrenamiento a partir de los que tienes, lo que ataca el problema en su origen: el overfitting es tanto una escasez de datos como un exceso de parámetros.
• Validación cruzada divide los datos de $k$ maneras y entrena $k$ veces, lo que compra una estimación fiable del error de test cuando tienes demasiado pocos datos para reservar un conjunto aparte.

Ahora el hecho que rompe la imagen.

La historia sesgo-varianza dice que, pasado el punto dulce, más parámetros significan peor generalización. Los modelos de lenguaje modernos tienen muchos más parámetros de los que las reglas clásicas permitirían para los datos que ven, y generalizan magníficamente. Ambas afirmaciones son ciertas, y reconciliarlas es lo más útil de este capítulo.

Cuarenta puntos de entrenamiento, entradas de veinte dimensiones, características ReLU aleatorias, y el número de características $P$ barrido de 2 a 5000, con la solución de norma mínima elegida siempre que hay muchas que ajustan:

Léela en tres partes. Hasta $P/n = 0.5$ la historia clásica se cumple exactamente: el error cae y luego empieza a subir. En $P = n = 40$ —el umbral de interpolación, donde el modelo tiene exactamente suficientes parámetros para pasar por todos los puntos de entrenamiento— el error de test alcanza su pico, en 5.81, cinco veces peor que el modelo pequeño. Ese pico es la advertencia clásica, y es real.

Luego desciende de nuevo. Y sigue descendiendo, más allá de $P = 5n$, más allá de $P = 37n$, hasta $P = 125n$, donde el error de test de 0.5664 es mejor que el mejor modelo infraparametrizado jamás logró. Un modelo con 5000 parámetros ajustado a 40 puntos es el mejor modelo de la tabla.

Esto es double descent,⁸⁹ y el mecanismo se ve en la última columna. Una vez que $P > n$ hay infinitas configuraciones de parámetros que ajustan exactamente los datos de entrenamiento, y cuál obtienes depende de cómo elijas. La solución de norma mínima escoge la más pequeña, y $\lVert w \rVert$ muestra lo que eso significa: alcanza un pico de 14.83 justo en el umbral —donde hay exactamente una solución interpolante y te quedas con ella, por extrema que sea— y luego cae monótonamente a medida que $P$ crece, porque más parámetros significan más soluciones interpolantes entre las que elegir, lo que significa que la más pequeña disponible se hace más pequeña. En $P = 5000$ la norma es 0.18, ochenta veces menor que en el umbral.

Así que los parámetros extra no añaden complejidad. Añaden elección, y la regla de selección gasta esa elección en simplicidad. La regularización no está en la función de pérdida; está en el algoritmo. Gradient descent desde una inicialización pequeña tiene un sesgo documentado hacia soluciones de norma pequeña, que es por lo que este comportamiento aparece en redes reales entrenadas de la forma ordinaria y no solo en el álgebra lineal de arriba.

La consecuencia práctica, de la que depende el Capítulo 10: «el modelo tiene más parámetros que datos, así que hará overfit» no es un argumento válido. Era una buena regla cuando los modelos vivían a la izquierda del umbral. Ahora todo lo interesante vive muy a la derecha, donde la regla se invierte.

Las herramientas de este capítulo bastan para entrenar una red que funcione con datos que puedes poner en una tabla: filas de números, una columna de etiquetas.

El lenguaje no es eso. Antes de que un modelo pueda predecir la siguiente palabra, algo tiene que decidir qué es siquiera una «palabra», y la respuesta no son ni letras ni palabras, sino un vocabulario que el modelo aprende a partir de los bytes brutos de los datos de entrenamiento. Esa decisión, tomada una vez antes de que empiece el entrenamiento, determina cuántas cosas puede decir el modelo, cuánto cuesta una petición y por qué modelos que pueden aprobar un examen de Derecho no pueden contar de forma fiable las letras de strawberry.

El Capítulo 7 construye un tokenizer.

Para las conexiones residuales usadas arriba, He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Building makemore Part 3: Activations & Gradients, BatchNorm, de Andrej Karpathy, recorre el diagnóstico de histogramas de activación en un modelo real y es el mejor tratamiento práctico de la primera mitad de este capítulo. Las clases 8 y 11–13 de Learning From Data, de Yaser Abu-Mostafa, presentan correctamente la teoría clásica de la generalización, incluidas las partes que este capítulo comprimió en un párrafo.