Cómo aprende un modelo

Para mejorar algo necesitas medirlo. Para entrenar un modelo hace falta un solo número que diga qué tan equivocado está: mientras más bajo, mejor, y 0 si es perfecto. Ese número es la pérdida (loss), y la fórmula que lo calcula se llama función de pérdida. Entrenar es, literalmente, hacer que la pérdida baje.

La entropía cruzada, para un ejemplo

En una clasificación como C01, el modelo no da una sola respuesta: da una probabilidad para cada una de las 500 categorías, y suman 100 %. La pérdida más usada se llama entropía cruzada (cross-entropy) y funciona así:

1. Mira solo la probabilidad que el modelo le dio a la respuesta correcta. Llámala p.
2. La pérdida es −ln(p).

«ln» es el logaritmo natural, la tecla «ln» de la calculadora. No necesitas saber más que dos cosas: ln(1) = 0, y mientras p se hace más chica, −ln(p) se hace más grande, sin tope.

Esa última fila sirve en la práctica. Un modelo que todavía no sabe nada reparte parejo, 1 entre 500 para cada categoría, y su pérdida es −ln(1/500) = ln(500) ≈ 6.21. Si empiezas a entrenar un modelo nuevo de 500 categorías y la pérdida arranca cerca de 6.2, todo va normal. Si arranca en 50, algo está roto.

Por qué no basta con contar aciertos

¿Por qué no usar simplemente «porcentaje de aciertos»? Porque casi no se mueve con cambios pequeños. Imagina que el modelo le da 40 % a «Tenis» y 45 % a «Botas»: se equivoca. Le giras un poquito una perilla y ahora da 41 % a «Tenis»: se sigue equivocando, y el porcentaje de aciertos no cambió. Pero la pérdida sí bajó, de −ln(0.40) ≈ 0.92 a −ln(0.41) ≈ 0.89. La pérdida dice «vas mejor» antes de que el modelo acierte. Esa es justo la señal que hace falta para saber hacia dónde girar.

Para un grupo de fotos: el promedio

Al entrenar no se mira una foto a la vez sino un grupo, y la pérdida del grupo es el promedio.

Para predecir un número: el error cuadrático

Muchos modelos no eligen una categoría sino que predicen un número: cuántos kilos de jitomate va a vender una tienda mañana, cuánto va a tardar un pedido. Eso es una regresión, y ahí no hay «probabilidad de la respuesta correcta». La pérdida más usada es el error cuadrático medio (mean squared error, MSE): para cada ejemplo, el error al cuadrado, (predicción − respuesta)², y luego el promedio.

¿Por qué al cuadrado? Quita el signo (pasarse 2 kg y quedarse corto 2 kg cuentan igual) y castiga mucho más los errores grandes: uno de 6 pesa 36 veces lo que uno de 1.

Y una consecuencia que conviene saber: el número que hace más chico el MSE es el promedio. Si un producto vendió 2, 3, 3, 4 y 13 kilos en cinco días, la predicción fija con menor MSE es 5, el promedio (MSE de 16.4), y no 3, el valor de en medio (MSE de 20.4): el día de 13 kilos jala la respuesta hacia arriba. Entrenar con MSE es pedirle el promedio; para otra cosa, como un número que alcance 9 de cada 10 días, hace falta otra pérdida (C14, en «En la vida real»).

La pérdida depende de las perillas del modelo, sus parámetros. Si mueves una perilla, la pérdida cambia. La pregunta clave del entrenamiento es: si muevo esta perilla un poquito, ¿la pérdida sube o baja, y cuánto? La respuesta, para todas las perillas a la vez, es el gradiente.

Veámoslo con un modelo de juguete que tiene una sola perilla.

Ese −24 es el gradiente de la perilla w en el punto w = 0. Se lee en dos partes:

• El signo dice la dirección. Negativo quiere decir que si subes la perilla, la pérdida baja. Así que hay que subirla. La regla general: mover cada perilla en contra de su gradiente.
• El tamaño dice qué tan empinado está. 24 es mucho: cerca de aquí, cualquier cambio de la perilla mueve mucho la pérdida.

Para este modelo hay una fórmula que da la pendiente exacta sin mover nada: 2 × error × entrada = 2 × (−6) × 2 = −24. Sale de la derivada, una herramienta del cálculo, pero basta con la idea de «mueve un poquito y mira qué pasa».

La ResNet-50 de C01 tiene unos 24.5 millones de perillas, así que su gradiente es una lista de 24.5 millones de números. Medirlo moviendo cada perilla por separado exigiría pasar las fotos por el modelo 24.5 millones de veces para un solo paso. En la sección siguiente verás cómo se calcula todo de una vez.

Descenso de gradiente

Con el gradiente en la mano, la regla para mejorar es simple y se llama descenso de gradiente (gradient descent):

perilla nueva = perilla − learning rate × gradiente

El learning rate (tasa de aprendizaje, o lr) es un número chico que decide qué tan grande es cada paso. El signo menos es el «en contra»: si el gradiente es negativo, la perilla sube; si es positivo, baja.

Desde w = 1.2 se repite la misma cuenta: el gradiente ahora es −14.4 y la perilla sube a 1.92. Desde ahí el gradiente es −8.64 y sube a 2.352. Después de tres pasos la predicción es 4.704 y la pérdida, 1.68: bajó de 36 a 1.68. El mejor valor posible es w = 3, porque 3 × 2 = 6 da error 0.

El learning rate fue siempre 0.05, pero los pasos se achicaron solos (1.2, luego 0.72, luego 0.432), porque el gradiente se achica cerca del fondo. Muy cerca del fondo el gradiente es casi 0 y la perilla casi no se mueve. Se dice que el entrenamiento convergió: los pasos ya casi no cambian nada.

Muy chico, bien, muy grande

¿Qué pasa con otros learning rates? Las mismas cuentas, empezando en w = 0:

Con 0.3, el primer paso lleva la perilla a 7.2, al otro lado del valle y más lejos del 3 que antes, donde la pendiente es más fuerte; el siguiente salto es aún más grande. En un entrenamiento real se ve como una pérdida que sube hasta que aparece NaN (not a number, «no es un número»): los números crecieron tanto que la computadora ya no los puede representar, y las cuentas con ellos dejan de dar resultados válidos.

Juega con el learning rate

En esta parábola hay un atajo para hacer todos los pasos de golpe. El gradiente es 2 × (2w − 6) × 2 = 8 × (w − 3): ocho veces la distancia al fondo. Si llamas distancia a w − 3, cada paso hace:

distancia nueva = distancia − lr × 8 × distancia = (1 − 8 × lr) × distancia

Con lr = 0.05 el factor es 1 − 0.4 = 0.6, y la distancia pasa de −3 a −1.8, a −1.08, a −0.648: los mismos 1.2, 1.92 y 2.352 de antes. Ese es el atajo: después de n pasos, la distancia es −3 × 0.6ⁿ, sin dar los pasos uno por uno. Si el factor está entre −1 y 1, la perilla se acerca al fondo; si es negativo, brinca al otro lado en cada paso; si se sale de ese rango, se aleja.

En código

El mismo descenso en Python puro, sin nada que instalar. Córrelo y cambia los learning rates de la lista:

def perdida(w):
    return (w * 2 - 6) ** 2        # predicción = w × 2; respuesta correcta = 6

def gradiente(w):
    return 2 * (w * 2 - 6) * 2     # 2 × error × entrada

for lr in [0.05, 0.3]:
    w = 0.0
    print(f"learning rate = {lr}")
    for paso in range(1, 6):
        w = w - lr * gradiente(w)  # el descenso de gradiente
        print(f"  paso {paso}:  w = {w:7.3f}   pérdida = {perdida(w):8.2f}")

learning rate = 0.05
  paso 1:  w =   1.200   pérdida =    12.96
  paso 2:  w =   1.920   pérdida =     4.67
  paso 3:  w =   2.352   pérdida =     1.68
  paso 4:  w =   2.611   pérdida =     0.60
  paso 5:  w =   2.767   pérdida =     0.22
learning rate = 0.3
  paso 1:  w =   7.200   pérdida =    70.56
  paso 2:  w =  -2.880   pérdida =   138.30
  paso 3:  w =  11.232   pérdida =   271.06
  paso 4:  w =  -8.525   pérdida =   531.28
  paso 5:  w =  19.135   pérdida =  1041.32

El learning rate de C01

C01 entrena con lr = 3e-4, que quiere decir 3 × 10⁻⁴ = 3 ÷ 10,000 = 0.0003. Es mucho más chico que el 0.05 del juguete por dos razones: hay millones de perillas moviéndose a la vez, y C01 no empieza de cero sino desde un modelo que ya sabe mucho (fine-tuning: ajustar un modelo ya entrenado), así que solo quiere ajustarlo con suavidad. La primera versión de C01 partió de una ResNet-50 entrenada con ImageNet; desde entonces, cada reentrenamiento mensual parte del modelo que está en producción. No existe un learning rate correcto universal: depende del modelo, del optimizador y del tamaño del batch, y se encuentra probando.

El forward pass: de la foto a la respuesta

Un modelo grande no es una sola multiplicación como el juguete. Es una cadena de pasos, uno tras otro, que se llaman capas: la foto entra a la primera, lo que sale entra a la segunda, y así hasta la última, que da las probabilidades. Recorrer esa cadena de principio a fin es el forward pass (pasada hacia adelante).

Es exactamente lo que hace la inferencia. La diferencia es que, al entrenar, además de la respuesta se guardan los resultados intermedios de cada capa, las activaciones, porque el paso siguiente los necesita. Por eso entrenar ocupa mucha más memoria que responder.

La regla de la cadena

Medir el gradiente moviendo cada perilla funciona con una, no con 24.5 millones. El atajo viene del cálculo, y se entiende con un ejemplo de todos los días.

Esa multiplicación es la regla de la cadena: si A mueve a B y B mueve a C, lo que C cambia por cada pedacito de A es lo que C cambia por B, multiplicado por lo que B cambia por A. No hizo falta manejar el kilómetro extra: bastó con conocer cada eslabón por separado.

Backpropagation: la cadena de la culpa

La backpropagation (o backprop) es la regla de la cadena aplicada a todo el modelo a la vez. Recorre la cadena al revés: de la pérdida hacia la entrada. Cada capa sabe una cosa local, «si mi entrada cambia un poquito, mi salida cambia tanto», y la culpa del error se va multiplicando por esas sensibilidades de atrás para adelante. Al final, cada perilla sabe qué parte de la culpa le toca: ese es su gradiente. Una pasada hacia atrás da los 24.5 millones de números.

Lo importante para producción:

• Nadie la programa a mano. Los frameworks (las librerías con las que se escriben los modelos, como PyTorch) la hacen solos. En PyTorch, la línea loss.backward() calcula el gradiente de las 24.5 millones de perillas.
• Cuesta más o menos el doble que el forward pass. Así que entrenar con una foto (forward más backpropagation) cuesta unas 3 veces lo que cuesta responderla. Es una regla práctica, no una ley exacta.
• No es nueva. La popularizó un artículo de Rumelhart, Hinton y Williams en 1986; lo que cambió después fue tener datos y GPUs para usarla en modelos enormes.

En código, un paso de entrenamiento en PyTorch se ve más o menos así. Es una ilustración (sin PyTorch instalado no corre); fíjate en que son los cuatro pasos del ciclo:

for fotos, etiquetas in batches:              # un grupo de fotos con sus respuestas
    predicciones = modelo(fotos)              # 1. forward pass
    perdida = cross_entropy(predicciones, etiquetas)   # 2. pérdida
    optimizador.zero_grad()                   #    (borra el gradiente del paso anterior)
    perdida.backward()                        # 3. backpropagation: el gradiente
    optimizador.step()                        # 4. gira las perillas

Batch, paso y época: con cuántas fotos se da cada paso

¿Con cuántas fotos se calcula la pérdida en cada vuelta? Hay dos extremos y los dos son malos:

• Con todas las fotos de train a la vez. Son casi 2 millones en C01: no caben juntas en la memoria de la GPU, y darías un solo paso cada vez que las procesas todas.
• Con una foto a la vez. El gradiente de una sola foto es muy ruidoso (lo que ayuda a esa foto puede empeorar a otras) y desperdicia la GPU, que está hecha para calcular muchas cosas en paralelo.

El punto medio es el batch (lote): un grupo de fotos, por ejemplo 64, que se procesan juntas. La pérdida es el promedio de las 64, y con su gradiente se da un paso. Dos palabras más:

• Un paso (step o iteración) es una vuelta del ciclo con un batch: forward pass, pérdida, backpropagation y ajuste de las perillas.
• Una época (epoch) es una pasada completa por el train: cada foto se vio una vez.

Con 50,000 fotos en batches de 64: 50,000 ÷ 64 = 781.25. Son 781 batches completos (49,984 fotos) y uno más con las 16 que sobran: 782 pasos por época. Es redondear hacia arriba, lo que en programación se llama ceil (techo): ⌈781.25⌉ = 782. Si se tira el batch incompleto (en PyTorch, drop_last=True), son 781.

Dos detalles que vas a oír:

• Al empezar cada época se revuelven las fotos. Así los batches no son siempre los mismos grupos, en el mismo orden.
• El gradiente de un batch es una estimación. 64 fotos son una muestra de todo el train; otro batch daría un gradiente un poco distinto. Por eso el descenso con batches al azar se llama estocástico, que quiere decir «con algo de azar». Batches más grandes dan una estimación menos ruidosa, pero ocupan más memoria.

La pieza que toma el gradiente y decide cuánto girar cada perilla se llama optimizador. Vas a oír tres nombres todo el tiempo.

SGD: la regla tal cual

SGD (stochastic gradient descent, descenso de gradiente estocástico) es la regla que ya conoces, con el gradiente de un batch: perilla − lr × gradiente. Le cuestan los valles angostos: si el valle es empinado de lado y casi plano a lo largo, el gradiente apunta sobre todo a las paredes, y la perilla rebota de pared a pared avanzando poco. Y como cada batch da un gradiente un poco distinto, los pasos tiemblan.

Momentum: arrastrar la dirección de antes

El momentum (inercia) arregla las dos cosas con una idea: cada paso arrastra parte de la dirección de los anteriores. Para cada perilla lleva una velocidad v:

v nueva = 0.9 × v + gradiente, y luego: perilla nueva = perilla − lr × v nueva

El 0.9 es el valor usual y dice cuánto se recuerda del pasado.

Adam: un paso a la medida de cada perilla

Adam (Kingma y Ba, 2014) es el optimizador que más se usa por defecto, y el de C01. Para cada perilla lleva dos promedios:

• m, el promedio de sus gradientes recientes: hacia dónde ha empujado, como el momentum.
• v, el promedio de sus gradientes al cuadrado: qué tan grandes suelen ser.

El paso es lr × m ÷ √v. Dividir entre √v, que mide el tamaño típico del gradiente de esa perilla, iguala los pasos: una perilla con gradientes enormes y otra con gradientes chiquitos avanzan parecido, del orden del learning rate. Al principio m y v valen 0, así que Adam los corrige para que los primeros promedios no salgan demasiado chicos; a los ya corregidos se les escribe con gorrito, m̂ y v̂.

En Python, el mismo primer paso (los números 0.9, 0.999 y 0.00000001 son los que trae Adam por defecto):

import math

lr, b1, b2, eps = 0.0003, 0.9, 0.999, 1e-8
for g in [100.0, 0.01]:              # el gradiente de cada perilla
    m = (1 - b1) * g                 # primer paso: m y v arrancan en 0
    v = (1 - b2) * g ** 2
    m_hat = m / (1 - b1)             # corrección del arranque
    v_hat = v / (1 - b2)
    paso_adam = lr * m_hat / (math.sqrt(v_hat) + eps)
    print(f"gradiente {g:>6}:  SGD mueve {lr * g:.6f}   Adam mueve {paso_adam:.6f}")

gradiente  100.0:  SGD mueve 0.030000   Adam mueve 0.000300
gradiente   0.01:  SGD mueve 0.000003   Adam mueve 0.000300

Dos consecuencias prácticas. Con Adam, el learning rate es casi cuánto se mueve cada perilla por paso: con 0.0003, del orden de 0.0003. Y si el gradiente de una perilla cambia de signo a cada rato (puro ruido), m se cancela y el paso se achica solo. Por eso funciona bien sin tanto ajuste fino; PyTorch trae 0.001 por defecto y 0.0003 es otro punto de partida muy usado.

El precio: m y v son dos números extra por perilla, que viven en memoria todo el entrenamiento. En C01 son 24.5 millones × 2 = 49 millones de números más. El momentum de SGD pide uno; SGD solo, ninguno. Los vas a volver a ver en el checkpoint y en la memoria de la GPU.

Parámetros contra hiperparámetros

Son dos palabras que se confunden mucho y que la Ronda usa a cada rato:

Los hiperparámetros de C01, según la Ronda: Adam, learning rate 3e-4, batch 64, 8 épocas y semilla 17 (el número que fija el azar del entrenamiento). ¿Cómo se eligen? Probando varias opciones y comparando cómo le va a cada una en validación, nunca en el test (ya viste por qué en la lección anterior).

1. Un learning rate demasiado grande. La pérdida sube, brinca o llega a NaN. Cómo evitarlo: empieza con un valor conocido para tu optimizador (con Adam, del orden de 0.0001 a 0.001), mira la pérdida desde los primeros cientos de pasos y prueba dividir o multiplicar por 3; usa warmup.
2. Olvidar borrar el gradiente. PyTorch suma cada gradiente nuevo al que ya había. Sin optimizador.zero_grad() en cada paso, cada paso usa la suma de todos los anteriores. Cómo evitarlo: un zero_grad por vuelta, como en el loop de la sección de backpropagation.
3. Darle probabilidades a una pérdida que espera logits. En PyTorch, cross_entropy aplica el softmax por dentro. Si le pasas probabilidades, se aplica dos veces: entrena, pero peor, y no sale ningún error. Cómo evitarlo: la última capa saca logits; el softmax se aplica solo al responder.
4. Juzgar el modelo por la pérdida de entrenamiento. Baja casi siempre, también cuando el modelo memoriza. Cómo evitarlo: mide la validación al final de cada época y quédate con el mejor checkpoint.
5. Reanudar solo con los pesos. Sin el estado de Adam, del calendario del learning rate y del azar, el entrenamiento reanudado es otro. Cómo evitarlo: checkpoint completo: perillas, optimizador, scheduler, GradScaler si usas precisión mixta, época, paso y generadores de azar.
6. Calcular la memoria solo con los pesos. 98 MB de pesos no son 98 MB para entrenar. Cómo evitarlo: ≈ 16 bytes por parámetro con Adam, más las activaciones; mídelo con torch.cuda.max_memory_allocated(). Si no cabe, baja el batch.
7. Cambiar el batch sin revisar el learning rate. Un batch 4 veces más grande da 4 veces menos pasos por época y un gradiente menos ruidoso: el learning rate que servía puede quedar chico o grande. Cómo evitarlo: trátalos juntos. Para SGD, una regla de partida es escalar el learning rate en proporción al batch, con warmup (Goyal y otros, 2017); con Adam, vuelve a probar en validación.

Intenta cada uno con lápiz antes de abrir la solución.

1. 1Fácil

   El modelo le da 25 % a la categoría correcta. ¿Cuál es su pérdida? Si después de entrenar le da 50 %, ¿cuánto bajó?

   Ver la solución paso a paso

   • Antes: −ln(0.25) ≈ 1.386.
   • Después: −ln(0.50) ≈ 0.693.
   • Bajó exactamente a la mitad: 1.386 ÷ 2 = 0.693. Pasa porque 0.25 = 0.5 × 0.5, y el logaritmo convierte esa multiplicación en una suma: ln(0.25) = 2 × ln(0.5).
2. 2Fácil

   Un modelo predice 10, 12 y 8 minutos de entrega, y los pedidos tardaron 11, 15 y 8. ¿Cuál es el MSE?

   Ver la solución paso a paso

   • Errores: 10 − 11 = −1, 12 − 15 = −3 y 8 − 8 = 0.
   • Al cuadrado: 1, 9 y 0. Suma: 10.
   • MSE: 10 ÷ 3 ≈ 3.33 minutos al cuadrado. Su raíz, √3.33 ≈ 1.83 minutos, es el RMSE.
3. 3Fácil

   Una perilla vale 1.5, su gradiente es 4 y el learning rate es 0.1. ¿Cuánto vale después de un paso de descenso de gradiente? ¿Hacia dónde se movió y por qué?

   Ver la solución paso a paso

   • Perilla nueva = 1.5 − 0.1 × 4 = 1.5 − 0.4 = 1.1.
   • Bajó. El gradiente positivo dice que subir la perilla sube la pérdida, así que hay que moverla en contra: hacia abajo.
4. 4Fácil

   Tienes 120,000 fotos de train y batches de 256. ¿Cuántos pasos hay por época? ¿Y en 5 épocas?

   Ver la solución paso a paso

   • 120,000 ÷ 256 = 468.75: 468 batches completos (119,808 fotos) y uno más con las 192 que sobran.
   • 469 pasos por época, redondeando hacia arriba. En 5 épocas, 469 × 5 = 2,345 (o 468 × 5 = 2,340 si se tira el batch incompleto).
5. 5Medio

   Usa la regla de la cadena: u = 5 × x − 2 y y = 4 × u. ¿Cuánto cambia y por cada pedacito que cambie x? Compruébalo moviendo x de 1 a 1.01.

   Ver la solución paso a paso

   • Cada eslabón: u cambia 5 por cada unidad de x; y cambia 4 por cada unidad de u.
   • La cadena: 4 × 5 = 20.
   • Con x = 1: u = 3 y y = 12. Con x = 1.01: u = 3.05 y y = 12.2. Cambió 0.2 por un cambio de 0.01: 0.2 ÷ 0.01 = 20.
6. 6Medio

   En la parábola de la lección (pérdida 4 × (w − 3)², perilla que empieza en 0), ¿dónde queda la perilla después de 2 pasos con lr = 0.1? ¿Con qué learning rate rebotaría para siempre?

   Ver la solución paso a paso

   • El factor por paso es 1 − 8 × 0.1 = 0.2.
   • La distancia al fondo empieza en −3 y en dos pasos queda en −3 × 0.2 × 0.2 = −0.12. La perilla queda en 3 − 0.12 = 2.88.
   • Rebota para siempre cuando el factor es exactamente −1: 1 − 8 × lr = −1, o sea lr = 0.25. La perilla brinca entre 0 y 6, y la pérdida se queda en 36.
7. 7Medio

   Dos perillas tienen gradientes 50 y −0.5 en el primer paso. ¿Cuánto se mueve cada una con SGD y con Adam, los dos con lr = 0.001?

   Ver la solución paso a paso

   • SGD: 0.001 × 50 = 0.05 y 0.001 × (−0.5) = −0.0005. La primera baja 0.05; la segunda sube 0.0005: cien veces menos.
   • Adam, primer paso: después de corregir el arranque, m̂ es el gradiente y √v̂ su tamaño, así que el paso es lr × gradiente ÷ tamaño del gradiente = 0.001 con el signo del gradiente.
   • La primera baja 0.001 y la segunda sube 0.001: el mismo tamaño de paso.
8. 8Medio

   Quieres ajustar completo, con Adam en precisión mixta, un modelo de 1,000 millones de parámetros en una L4 de 24 GB. ¿Cuánta memoria fija pide? ¿Cuánto ocuparía solo para servirlo en FP16?

   Ver la solución paso a paso

   • Lo fijo: 1,000,000,000 × 16 B = 16 GB.
   • En la L4 quedarían ≈ 8 GB para las activaciones y el runtime (≈ 0.3 a 1 GB). Cabe, pero con un batch chico: con un modelo así, las activaciones de un batch grande pasan fácil de 8 GB.
   • Servir en FP16: 1,000,000,000 × 2 B = 2 GB de pesos. Ocho veces menos.
9. 9Reto

   En la red y = w2 × ReLU(w1 × x), con x = 2, respuesta correcta 1, w1 = 1 y w2 = 1.5, calcula todos los gradientes con backpropagation, da un paso con lr = 0.01 y di si la pérdida bajó.

   Ver la solución paso a paso

   • Forward: z = 1 × 2 = 2; h = ReLU(2) = 2; y = 1.5 × 2 = 3; L = (3 − 1)² = 4.
   • ∂L/∂y = 2 × (3 − 1) = 4.
   • ∂L/∂w2 = 4 × h = 4 × 2 = 8.
   • ∂L/∂h = 4 × w2 = 4 × 1.5 = 6; como z > 0, ∂L/∂z = 6.
   • ∂L/∂w1 = 6 × x = 6 × 2 = 12.
   • Paso: w1 = 1 − 0.01 × 12 = 0.88 y w2 = 1.5 − 0.01 × 8 = 1.42.
   • Nuevo forward: z = 1.76, h = 1.76, y = 1.42 × 1.76 ≈ 2.499, L = (2.499 − 1)² ≈ 2.25. Bajó de 4 a 2.25: los gradientes eran positivos porque el modelo predecía de más, y las dos perillas bajaron.
10. 10Reto

    Otra parábola, mucho más empinada: pérdida 25 × (w − 1)². ¿A partir de qué learning rate diverge el descenso de gradiente? ¿Qué te dice eso de un modelo con millones de perillas?

    Ver la solución paso a paso

    • El gradiente es 2 × 25 × (w − 1) = 50 × (w − 1). Cada paso: distancia nueva = (1 − 50 × lr) × distancia.
    • Diverge si el factor sale de [−1, 1]: 1 − 50 × lr < −1, o sea lr > 0.04. En la parábola de la lección (gradiente 8 × (w − 3)) el límite era 0.25.
    • Un modelo real tiene direcciones planas y direcciones muy empinadas a la vez, y un solo learning rate tiene que servir para todas. Lo fija la más empinada, y las planas avanzan lento. Adam lo corrige en parte, al dar a cada perilla un paso a la medida de su gradiente.

• M04 · Hardware para inferencia hace las cuentas de memoria de la GPU para servir: pesos (2 bytes por parámetro en FP16), activaciones, runtime y margen, para ver qué cabe en una T4, una L4 o una H100. Los ≈ 16 bytes por parámetro de entrenar con Adam (el artículo de ZeRO) los menciona en una nota.
• M10 · MLOps registra cada entrenamiento con sus hiperparámetros (lr, épocas, semilla) y su validación por época, guarda el checkpoint de 294 MB cada 15 minutos para poder usar máquinas spot (más baratas, pero el proveedor te las puede quitar), y explica por qué en GPU «misma semilla» no alcanza.
• El caso C01 describe el reentrenamiento mensual: un fine-tune desde el modelo en producción, unas horas en una GPU, con precisión mixta, semillas y configuración fijadas, que solo pasa a producción si no empeora en el golden set.
• Los casos C14 y C15 eligen su pérdida por el negocio: cuantiles para el colchón de inventario y log loss calibrada para cobrar bien un clic.
• M03 · Latencia y capacidad y M07 · Servidores de modelos usan «batch» en el otro sentido: el dynamic batching de Triton, que junta peticiones en inferencia.
• En el Dojo, la estación 3, «Entrenamiento», es la de esta lección; todavía está en preparación.
• En Sensei, «¿Aprendió de verdad?» mide si lo que aprendió sirve con fotos nuevas (overfitting, curvas, métricas); «Redes neuronales y CNNs» abre las capas por las que pasa la backpropagation; «Cómo guarda números una computadora» explica FP16, BF16 y la precisión mixta; y «CPU y GPU» abre la máquina.

Estos son los conceptos que presentó esta lección. Cada uno tiene su tarjeta con la definición completa.

Intenta responder en tu cabeza antes de abrir cada respuesta.

1. 1El modelo le da 30 % a la categoría correcta. ¿Cuál es su pérdida? ¿Y si después de entrenar le da 60 %?Ver respuesta

   −ln(0.30) ≈ 1.20. Con 60 %: −ln(0.60) ≈ 0.51. La pérdida bajó a menos de la mitad, aunque en los dos casos el modelo podría estar acertando o no, según cuánto les dé a las demás categorías.

2. 2El gradiente de una perilla es +5 y el learning rate es 0.01. ¿Hacia dónde se mueve la perilla, y cuánto?Ver respuesta

   Hacia abajo, en contra del gradiente: perilla nueva = perilla − 0.01 × 5 = perilla − 0.05. Gradiente positivo quiere decir que subir la perilla sube la pérdida, así que hay que bajarla.

3. 3La pérdida sube en cada paso y termina en NaN. ¿Qué sospechas primero?Ver respuesta

   Un learning rate demasiado grande: cada paso se pasa del fondo del valle al otro lado, cada vez más lejos, hasta que los números crecen tanto que la computadora ya no los puede representar.

4. 4¿Qué hace la backpropagation, en una frase?Ver respuesta

   Aplica la regla de la cadena de la pérdida hacia atrás: multiplica la sensibilidad de cada capa para obtener, en una sola pasada, el gradiente de todas las perillas.

5. 5¿Por qué Adam ocupa más memoria que SGD?Ver respuesta

   Porque guarda dos números por perilla, el promedio de sus gradientes (m) y el de sus gradientes al cuadrado (v). En C01 son 49 millones de números, ≈ 196 MB en float32. SGD solo no guarda nada extra; con momentum, uno por perilla.

6. 6Entrenas dos veces con la misma configuración y sale 85.3 % y 85.1 %. ¿El segundo modelo es peor?Ver respuesta

   No se puede decir. El entrenamiento tiene azar (perillas iniciales, orden de las fotos, augmentation, sumas en paralelo en la GPU) y, con números como los de la Ronda, la diferencia entre semillas ya es de unos 0.2 puntos. Para comparar recetas hay que medir cuánto varía el resultado entre semillas.

7. 7¿Por qué un checkpoint de C01 pesa ≈ 294 MB si el modelo solo pesa 98 MB?Ver respuesta

   Porque además de las perillas guarda el estado de Adam: dos promedios por perilla, 2 × 98 MB = 196 MB. Sin ellos, reanudar no sería seguir el mismo entrenamiento.