las ecuaciones de esta slide
Ldata(w) = 1n Σi=1..n (yi − fw(xi))2,    fw(x) = w0 + w1t + … + wdtd(t = 2x−1)
el error cuadrático medio sobre los n datos y el modelo: un polinomio de grado d. El grado d es el "tamaño" del modelo: d = 1 es una recta; d = 12 puede pasar por casi todos los puntos. El reescalado t = 2x−1 solo mejora el condicionamiento numérico.
w* = (X⊤X)−1X⊤y(ecuaciones normales)
el ajuste de mínimos cuadrados tiene solución cerrada: X es la matriz n×(d+1) cuya fila i es (1, ti, …, tid). El JS de esta slide resuelve este sistema de verdad (eliminación gaussiana) cada vez que mueves el slider.
guion paso a paso
  1. Pon d = 1 y mira las dos curvas de error del panel inferior. Train y test son parecidos y ambos altos: el modelo es demasiado simple (infraajuste); ni siquiera memoriza.
  2. Sube despacio hasta d = 3–4. Los dos errores bajan a la vez: el modelo está capturando estructura real (el precio importa y hay una curvatura).
  3. Sigue hasta d = 12 mirando el panel superior. La curva dorada serpentea para pasar por cada punto de train; el error de train sigue cayendo pero el de test se dispara órdenes de magnitud: pura memorización del ruido.
  4. Pulsa "nueva muestra" tres veces con d = 12. La forma de los zigzags cambia por completo con cada muestra: lo que el modelo "aprendió" era el ruido de ESA muestra, no una regularidad del negocio.
Comprueba que entiendes: ¿por qué el error de train NUNCA sube al aumentar d?
Porque cada grado añade un parámetro y el ajuste es de mínimos cuadrados exactos: el polinomio de grado d+1 contiene al de grado d como caso particular (wd+1 = 0), así que su mínimo de Ldata no puede ser peor. El train mide flexibilidad, no calidad. Por eso el test (datos que el ajuste no vio) es el único juez honesto — y por eso la curva de test tiene forma de U: primero baja (estructura) y luego sube (ruido memorizado).

Setup. Una cadena de retail tipo Inditex quiere predecir unidades vendidas (miles) en función del precio (10–40€) de un artículo. La relación verdadera (línea discontinua) es suave: las ventas caen con el precio con una pequeña ondulación estacional. Tienes 18 observaciones de train (puntos tinta) y 12 de test (puntos grises), ambas con ruido de demanda. Arriba: el ajuste polinómico de grado d por ecuaciones normales. Abajo: el error de train y de test para TODOS los grados de 1 a 12, con tu grado marcado.

Juega. El slider de grado es el dial de "capacidad" del modelo. Con d pequeño, sesgo: la recta no puede representar la ondulación. Con d grande, varianza: el polinomio persigue el ruido. La zona útil (d ≈ 3–5) es estrecha, y nada en el train te avisa de cuándo la abandonas.

Lee así. El lector numérico da los dos errores y su cociente. Un cociente test/train que crece sin parar es la firma del overfitting: es exactamente lo que le pasó al modelo de fraude de BBVA del deck del día (98% en train, 72% en producción).

Mensaje. El overfitting no es un concepto abstracto: es la brecha entre estas dos curvas, y cuesta dinero real cuando el modelo sale a producción. Todo el resto del día (weight decay, dropout, early stopping) son formas distintas de cerrar esa brecha.

Términos. train/test: datos usados para ajustar vs datos reservados para evaluar. capacidad: cuántas formas distintas puede representar el modelo (aquí, el grado d). MSE: error cuadrático medio. infra/sobreajuste: errores altos en ambos / brecha grande entre ambos.

las ecuaciones de esta slide
Ltotal(w) = Ldata(w) + λ ‖w‖22(Ec. 3 del día)
la pérdida del día: al error de datos se le suma un coste por pesos grandes. ‖w‖22 = Σjwj2 es la suma de cuadrados de todos los pesos y λ decide cuánto pesa ese coste frente a ajustar los datos. Equivale a un prior gaussiano sobre w.
wλ = (X⊤X + nλI)−1X⊤y(ridge, solución cerrada)
para regresión lineal el mínimo de Ltotal también es cerrado: basta sumar nλ a la diagonal de X⊤X. Eso encoge los pesos hacia 0 (aquí no se penaliza el término independiente w0, para no encoger la media de ventas).
AdamW:   θ ← θ − η λ θ(decaimiento directo)
en redes no hay solución cerrada y el decay se aplica como encogimiento directo en cada paso, sin pasar por el gradiente: así no interfiere con las medias móviles (mt, vt) de Adam. Es la W de AdamW: weight_decay=1e-4.
guion paso a paso
  1. Parte de λ = 10−7 (casi cero) y mira la curva gris del panel superior. Es el polinomio de grado 10 sin regularizar: serpentea entre los puntos y ‖w‖ vale decenas. Es la slide anterior con d alto.
  2. Sube λ despacio hasta 10−2. La curva dorada se alisa, ‖w‖ cae en picado y el error de test baja aunque el de train sube un poco: estás comprando generalización pagando ajuste.
  3. Sigue hasta λ = 10. Demasiado: la curva se aplana hacia la media y ambos errores suben. Sobre-regularizar es infraajustar.
  4. Localiza en el panel inferior el mínimo de la curva de test y lee el λ óptimo. Pulsa "nueva muestra" y repite. El óptimo ronda siempre 10−3–10−1: por eso la receta del curso usa un valor por defecto en ese rango (10−4 para redes) y lo afina con validación.
Comprueba que entiendes: el modelo sigue teniendo 11 parámetros con λ alto. ¿Por qué se comporta como uno simple?
Porque la capacidad efectiva no la da el número de parámetros sino cuánto pueden moverse. Con λ grande, los coeficientes de los términos de grado alto (los que generan los zigzags y necesitan valores enormes para compensarse entre sí) son los primeros en encogerse hacia 0, y el polinomio queda prácticamente reducido a sus términos suaves. Por eso ‖w‖ es el termómetro correcto de la complejidad: mismo modelo, distinta libertad. En redes ocurre igual: weight decay no quita neuronas, les quita margen para memorizar.

Setup. Mismos datos de ventas vs precio que la slide anterior, pero el grado queda fijo en d = 10 (un modelo deliberadamente sobredimensionado, como casi todas las redes que entrenarás) y el dial pasa a ser λ, en escala logarítmica. Arriba: el ajuste ridge (dorado) frente al ajuste sin regularizar (gris discontinuo) y la verdad (tinta discontinua). Abajo: error de train, error de test y la norma ‖w‖2 en función de λ, con tu valor marcado.

Juega. El recorrido completo del slider cuenta la historia entera de la regularización: con λ ≈ 0 dominan los datos (varianza); con λ enorme domina la penalización (sesgo); en medio hay un valle donde el test es mínimo. Fíjate en que la curva de ‖w‖ cae de forma monótona: ese es el mecanismo, no el objetivo. El objetivo es el valle del test.

Lee así. El lector da ‖w‖2 y los dos errores. Compara mentalmente con la slide anterior: allí cambiabas la capacidad a saltos discretos (grado); aquí la encoges de forma continua. Por eso weight decay es el regularizador universal: funciona en cualquier modelo con pesos.

Mensaje. En PyTorch toda esta slide es un argumento: AdamW(params, lr=1e-3, weight_decay=1e-4). Detrás de ese argumento está exactamente esta geometría: sumar λ a la diagonal, encoger los pesos, cambiar un poco de train por mucho de test.

Términos. λ: coeficiente de la penalización, típicamente 10−5–10−3 en redes. ‖w‖2: norma euclídea de los pesos, el termómetro de complejidad efectiva. ridge: nombre clásico de la regresión con penalización L2. AdamW: Adam con el decay aplicado fuera del gradiente.

las ecuaciones de esta slide
ãℓ = 11−p m ⊙ aℓ,    mi ∼ Bernoulli(1−p)(Ec. 1 del día)
en cada minibatch se sortea una máscara binaria m: cada neurona oculta sigue viva con probabilidad 1−p y se apaga (se multiplica por 0) con probabilidad p. El símbolo ⊙ es producto componente a componente. El factor 1/(1−p) re-escala las que sobreviven.
Em[ãℓ] = aℓ   ⇒    en inferencia: p = 0, m ≡ 1
gracias al re-escalado, la activación esperada bajo máscaras aleatorias coincide con la activación sin dropout: E[mi/(1−p)] = (1−p)/(1−p) = 1. Por eso en test se apagan las máscaras y la red queda calibrada igual: predecir con todas las neuronas equivale a promediar el ensemble.
nº de sub-redes = 2H(aquí 2⁸ = 256)
cada máscara define una sub-red distinta; entrenar con dropout es entrenar implícitamente las 2H a la vez, compartiendo pesos: el ensemble más barato que existe.
guion paso a paso
  1. Con p = 0.3, pulsa "nueva máscara" cinco veces mirando la red de arriba y la curva dorada de abajo. Cada vez se apagan neuronas distintas y la predicción de la sub-red cambia de forma visible: cada minibatch entrena un modelo diferente.
  2. Mira la curva discontinua (media de 300 máscaras) contra la curva tinta (red completa). Casi coinciden, y el lector confirma que su distancia media es de centésimas: es la identidad E[ã] = a en acción.
  3. Sube p a 0.7. La banda dorada (±1 desviación del ensemble) se ensancha mucho: con pocas neuronas vivas por máscara, cada sub-red opina distinto. Más regularización, pero también más ruido de entrenamiento.
  4. Pon p = 0. Máscara siempre completa, banda de anchura cero, las tres curvas coinciden: sin dropout no hay ensemble.
Comprueba que entiendes: ¿por qué hace falta el factor 1/(1−p)?
Sin él, la suma que llega a la capa de salida tendría en media solo una fracción 1−p de su tamaño normal: con p = 0.5, la red "entrenada" vería señales de la mitad de amplitud que la red de inferencia, y las predicciones de test estarían descalibradas (todas encogidas). Re-escalando por 1/(1−p) en entrenamiento, la media se conserva (E[mi/(1−p)] = 1) y puedes apagar el dropout en test sin tocar nada más. Puedes verificarlo aquí: la media del ensemble coincide con la red completa para cualquier p.

Setup. Una red pequeña ya entrenada para un scoring de churn telco: 1 entrada (gasto mensual normalizado), H = 8 neuronas ocultas tanh, 1 salida (propensión a la baja, en unidades de score). Arriba: la red dibujada; las neuronas vivas de la máscara actual van en dorado y las apagadas en gris tachado; el grosor de cada conexión es proporcional a |peso|. Abajo: la predicción de la red completa (tinta), la de la sub-red de la máscara actual re-escalada por 1/(1−p) (dorado), la media Monte Carlo sobre 300 máscaras (discontinua) y la banda ±1 desviación típica del ensemble (sombreado).

Juega. Todo lo que ves es el forward pass real: el JS calcula hj = tanh(wjx + bj), aplica la máscara con su re-escalado y suma la capa de salida; las 300 máscaras del ensemble se muestrean con mulberry32, así que el experimento es reproducible. El slider p controla la Bernoulli; el botón sortea la máscara del "minibatch actual".

Lee así. La banda dorada es la varianza del ensemble: mide cuánto discrepan las sub-redes. Que la media del ensemble clave la curva tinta mientras la banda se ensancha es el resumen completo de dropout: en media no distorsiona, en varianza obliga a la red a no depender de ninguna neurona concreta (representaciones redundantes, menos co-adaptación).

Mensaje. Dropout es estudiar tapándose apuntes al azar: si ninguna neurona puede "cargar" sola con la señal del churn, el conocimiento queda repartido y robusto. Valores típicos: p = 0.2 en MLP, p = 0.1 en CNN; en inferencia, siempre apagado.

Términos. m: máscara binaria, una nueva por minibatch. p: probabilidad de apagar (0.1–0.5 en la práctica). ⊙: producto elemento a elemento. co-adaptación: neuronas que solo funcionan en presencia de otras concretas; dropout la rompe.

las ecuaciones de esta slide
μB = 1BΣi ai,    σB2 = 1BΣi (ai−μB)2
media y varianza calculadas en el minibatch, no en todo el dataset: son estimaciones ruidosas cuya calidad depende de B (panel inferior).
âi = ai − μB√(σB2+ε),    yi = γ âi + β(Ec. 2 del día)
primero normalizar (media 0, varianza 1; ε = 10−5 evita dividir por cero), después re-escalar y desplazar con dos parámetros aprendibles por canal. Ejemplo del deck: con a = (2, 4, 6, 8) sale μB = 5, σB2 = 5, â ≈ (−1.34, −0.45, 0.45, 1.34) y con γ = 1.5, β = 0.5: y ≈ (−1.51, −0.17, 1.17, 2.51).
guion paso a paso
  1. Con B = 32, pulsa "nuevo minibatch" varias veces mirando el histograma dorado. El histograma normalizado apenas se mueve: media(â) ≈ 0.000 y var(â) ≈ 1.000 en el lector, minibatch tras minibatch.
  2. Mueve γ y β. El bloque dorado se estira (γ) y se desplaza (β) en bloque, sin deformarse: la red puede recolocar la distribución donde le convenga, incluso deshacer la normalización si aprende γ = σ, β = μ.
  3. Baja B a 4 y pulsa "nuevo minibatch" cinco veces mirando el panel inferior. Las estimaciones μB de minibatches distintos bailan dentro de una banda ancha (±1.96σ/√B): con batch pequeño, BatchNorm normaliza con una media equivocada distinta cada vez.
  4. Sube B a 256. La banda se vuelve finísima: la estadística de minibatch ya casi es la del dataset. Esta es la razón de la regla del deck: con B ≤ 4, usa LayerNorm.
Comprueba que entiendes: si BatchNorm normaliza a media 0 y varianza 1, ¿para qué sirven γ y β?
Sin ellos, BatchNorm impondría que TODAS las capas tengan activaciones estandarizadas, lo cual es una restricción arbitraria: quizá la mejor representación para la capa siguiente necesita otra escala u otro centro (una sigmoide, por ejemplo, trabaja distinto centrada en 0 que en 2). γ y β devuelven esos dos grados de libertad como parámetros aprendibles: la red conserva la estabilidad del paso de normalización (gradientes bien escalados, menos sensibilidad a la inicialización) sin perder expresividad. En el límite, γ = √σB2 y β = μB recuperan la identidad.

Setup. Estás dentro de una capa oculta del modelo de fraude de BBVA. Las pre-activaciones ai de esa capa llegan con media ≈ 3 y desviación ≈ 1.8 (histograma gris): descentradas y anchas, como casi siempre tras unas cuantas capas. BatchNorm toma el minibatch de B valores, calcula μB y σB2 de ese minibatch, normaliza y aplica (γ, β). Arriba: histograma antes (gris) y después (dorado), con μB y β marcadas. Abajo: la media μB estimada por 40 minibatches independientes del tamaño B elegido, contra la media verdadera y su banda teórica ±1.96σ/√B.

Juega. Los números del lector son cálculos reales sobre el minibatch: comprueba que media(â) = 0.000 y var(â) = 1.000 exactos (es una identidad algebraica, no una aproximación), y que media(y) ≈ β y sd(y) ≈ γ. Después juega con B: el panel inferior es el compromiso central de BatchNorm, estadísticas por minibatch = ruido ∝ 1/√B.

Lee así. BatchNorm estabiliza la distribución que ve cada capa: permite lr más alto, acelera y suaviza la pérdida. Su talón de Aquiles es exactamente el panel inferior: con B pequeño las estadísticas son ruido, y por eso en Transformers (y siempre que B ≤ 4) se usa LayerNorm, que normaliza sobre la dimensión de features y no depende del batch.

Mensaje. Por defecto: BatchNorm en CNN y MLP densos, LayerNorm en Transformers. Y recuerda que (γ, β) se aprenden: BatchNorm no impone una distribución, ofrece una re-parametrización estable.

Términos. μB, σB2: estadísticas del minibatch. ε: 10−5, estabilidad numérica. γ, β: escala y desplazamiento aprendibles, uno por canal. LayerNorm: normaliza sobre features, no sobre el batch; estándar en Transformers.

las ecuaciones de esta slide
t★ = min{ t : V(t) > mint'≤t V(t')  durante  P  épocas }(Ec. 4 del día)
el criterio de parada con patience: V(t) es la pérdida de validación en la época t; si lleva P épocas seguidas sin mejorar su propio mínimo histórico, se para. P absorbe el ruido: una época mala aislada no debe abortar el entrenamiento.
checkpoint devuelto:  w(argmint'≤t★ V(t'))
no se devuelve el modelo del momento de parar, sino el de la mejor época de validación vista hasta entonces: parar tarde solo cuesta cómputo, no calidad, siempre que guardes checkpoints.
wt+1 = wt − η ∇Ltrain(wt)
el entrenamiento de esta demo es descenso por gradiente real sobre un modelo polinómico con datos ruidosos: cada época da un paso, y el JS guarda w en cada una para poder enseñarte el ajuste en el momento exacto en que decidas parar.
guion paso a paso
  1. Arrastra t desde 1 hacia delante mirando las dos curvas. El train (tinta) baja siempre; el val (dorado) baja, toca fondo y vuelve a subir: a partir de ahí cada época adicional es memorización del ruido del train.
  2. Para t en tres sitios: muy pronto, en el mínimo del val, y al final. Mira el panel inferior en cada parada. Pronto: curva sosa que no sigue los datos (infraajuste). En el mínimo: curva suave y fiel. Tarde: zigzags entre los puntos de train, badge en rojo.
  3. Sube P de 10 a 60 y mira el marcador t★ del panel superior. Con más patience, la regla espera más antes de declarar que el val ya no mejora: t★ se desplaza a la derecha, pero el checkpoint devuelto sigue siendo el mínimo, así que solo pagas cómputo.
  4. Pulsa "nueva muestra" y repite. La época óptima cambia de muestra a muestra (a veces 30, a veces 150): por eso se automatiza con la regla de patience en vez de fijar el número de épocas a mano.
Comprueba que entiendes: ¿por qué "más épocas" se comporta como "más capacidad"?
Partiendo de w = 0, el descenso por gradiente ajusta primero las direcciones de la solución con más señal (las componentes suaves, que reducen mucho la pérdida) y solo después, lentamente, las direcciones que requieren coeficientes grandes y delicados (los zigzags que encajan el ruido punto a punto). Parar pronto equivale entonces a impedir que esos coeficientes crezcan, igual que hacía weight decay: es una regularización implícita. Por eso la curva de val tiene la misma forma de U que tenía frente al grado del polinomio o frente a λ: épocas, grado y 1/λ son tres diales de la misma capacidad efectiva.

Setup. Entrenamos de verdad (descenso por gradiente, 600 épocas, lr = 0.4) un modelo polinómico de grado 11 sobre 12 observaciones ruidosas de la curva de demanda, con 60 puntos de validación apartados. Es el modelo de churn/demanda de juguete del día: sobredimensionado a propósito, como tu primer MLP. Arriba: pérdida de train (tinta) y de validación (dorado) por época, en escala logarítmica; la vertical discontinua marca el mínimo de validación, el punto dorado tu época de parada t, y el rombo el t★ que dispararía la regla de patience. Abajo: el ajuste que tendrías si te quedas con el checkpoint de la época t.

Juega. El slider t es tu dedo sobre el botón de parar; el badge se pone verde si tu V(t) está a menos de un 5% del mínimo alcanzable y rojo si paraste demasiado pronto o seguiste de largo. El slider P controla la regla automática de la Ec. 4: comprueba que para P razonable, el checkpoint que devuelve coincide con (o queda muy cerca de) tu mejor parada manual.

Lee así. El gap creciente entre train y val a la derecha del mínimo es el overfitting de la slide 1, ahora desplegado en el tiempo de entrenamiento. Early stopping es el regularizador de coste cero: no toca el modelo ni la pérdida, solo elige el instante de la trayectoria donde la generalización era máxima.

Mensaje. En la práctica: patience=10 sobre la pérdida de validación, guardando el mejor checkpoint. Cuesta cero, previene la mitad del overfitting, y es la quinta línea de la receta exprés del día.

Términos. V(t): pérdida de validación en la época t. patience P: épocas seguidas sin mejorar que se toleran antes de parar. checkpoint: copia de los pesos guardada en una época concreta. t★: época en la que la regla decide parar.

las ecuaciones de esta slide
θt+1 = θt − ηt gt,    step:  ηt = η0 γ⌊t/Ts⌋(γ = 0.1)
la regla de actualización admite un lr variable por iteración; step decay lo divide por 10 cada Ts pasos (aquí Ts = T/3): la receta histórica de las CNN sobre ImageNet.
cosine:  ηt = ηmin + 12(ηmax−ηmin)(1+cos πtT)(Ec. 5 del día)
medio coseno de ηmax a ηmin: decae despacio al principio (explora), rápido en el medio y muy despacio al final (afina). Es el defecto moderno con AdamW: CosineAnnealingLR(opt, T_max=epochs).
warmup+cosine:  ηt = ηmax tTw  si t < Tw,  luego cosine en T−Tw pasos
subida lineal de 0 a ηmax en Tw pasos y después el coseno. El warmup evita pasos gigantes al inicio, cuando los momentos de Adam y las estadísticas de BatchNorm aún no están estabilizados: obligatorio en modelos grandes.
guion paso a paso
  1. Con los valores por defecto, compara en el panel inferior la curva del lr constante (gris) con la del cosine (dorado). La constante baja rápido y se atasca en una meseta ruidosa; el cosine la sigue al principio y después sigue bajando órdenes de magnitud: bajar η apaga el ruido del gradiente.
  2. Sube ηmax hasta 10−0.7. La meseta de la constante sube (el suelo de ruido crece con η) mientras los schedules que decaen siguen llegando abajo: con lr agresivo, decaer no es opcional.
  3. Compara step (tinta) con cosine (dorado). Step baja a saltos: cada división por 10 desbloquea un escalón de pérdida. Cosine hace lo mismo sin elegir cuándo saltar: por eso es el defecto cuando no sabes dónde poner los escalones.
  4. Alarga T de 200 a 400. El cosine reparte el mismo descenso en más pasos y el suelo final baja: el lr final pequeño es quien pule los últimos decimales.
Comprueba que entiendes: ¿por qué con lr constante la pérdida se queda en una meseta y no sigue bajando?
Cerca del mínimo, el gradiente verdadero es casi cero y el paso queda dominado por el ruido: θ da saltos aleatorios de tamaño ≈ ησ alrededor del óptimo, y la pérdida media de esos saltos es proporcional a η. Es un equilibrio, no una convergencia: para romperlo hay que reducir η, y eso es exactamente lo que hace un schedule. La intuición exploración-explotación del deck es esta misma frase: paso grande para llegar a la zona buena, paso pequeño para instalarse en ella.

Setup. Para aislar el efecto del schedule, optimizamos un problema donde todo lo demás es conocido: una cuadrática mal condicionada (curvatura 1 en una dirección, 8 en la otra: la "hondonada alargada" típica de las pérdidas reales) con gradiente ruidoso, como el que produce un minibatch en el forecast de demanda de Inditex. Arriba: η(t) para los cuatro schedules del día, calculados con sus fórmulas exactas: constante (gris), step decay (tinta), cosine (dorado) y warmup+cosine (dorado oscuro). Abajo: la pérdida que consigue cada uno optimizando la MISMA cuadrática con el MISMO ruido (misma semilla), en escala logarítmica.

Juega. Los tres sliders son los tres números que fijarás en PyTorch: ηmax (el lr del optimizador), T (T_max del scheduler) y el warmup. El botón cambia la semilla del ruido: comprueba que el orden de los schedules apenas cambia (la comparación es justa porque comparten ruido).

Lee así. El lector da la pérdida final de cada schedule. En este juguete convexo el warmup apenas mejora (no hay BatchNorm ni momentos de Adam que estabilizar): su papel aparece en redes grandes, donde los primeros pasos con lr alto pueden romper el entrenamiento. Lo que sí es general es la meseta de la constante: suelo de ruido ∝ η.

Mensaje. Si te bloqueas con el lr: cosine. Cinco líneas de PyTorch (CosineAnnealingLR + sched.step() por época) que en la práctica del curso suben la AUC de validación un 2–5% sin tocar el modelo.

Términos. ηmax, ηmin: lr inicial y final de la trayectoria (aquí ηmin = 0). T: horizonte total en iteraciones o épocas. Tw: duración del warmup. suelo de ruido: pérdida residual ∝ η al optimizar con gradiente ruidoso y lr fijo.

las ecuaciones de esta slide
gB = 1BΣi∈batch ∇ℓi(θ),    Var[gB] = σ2B
el gradiente de minibatch es una media de B gradientes individuales: insesgado (en media apunta como el gradiente completo) pero con una varianza que cae como 1/B. Duplicar el batch divide el ruido por √2, no por 2.
θt+1 = θt − η gB = θt − η(∇L(θt) + σ√B ξt)
cada paso de SGD es el paso "ideal" más un empujón aleatorio de tamaño σ/√B: exactamente lo que simula esta slide. El ruido no es solo un estorbo: zarandea la trayectoria fuera de mínimos estrechos y actúa como regularización implícita.
guion paso a paso
  1. Con B = 8, sigue las tres trayectorias sobre las curvas de nivel. Bajan hacia el centro pero con tembleque permanente; al llegar a la zona del óptimo no se posan: orbitan en una nube cuyo radio fija σ/√B.
  2. Baja B a 1. SGD puro: trayectorias borrachas que a veces suben de nivel. Aun así progresan en media: el gradiente de un solo ejemplo es ruidosísimo pero insesgado.
  3. Sube B a 256. Las tres trayectorias se vuelven casi idénticas y limpias: ya casi es descenso por gradiente exacto. Pero mira el lector: cada paso ahora procesa 256 ejemplos, 256 veces más cómputo por paso que B = 1.
  4. Con B = 4, baja η a la mitad. La nube final se encoge: el radio del merodeo escala con η·σ/√B. Batch y lr son dos diales del mismo ruido efectivo: por eso al escalar B se suele escalar también el lr.
Comprueba que entiendes: si B grande es "más limpio", ¿por qué no entrenar siempre con el batch más grande que quepa?
Tres razones. Coste: cada paso procesa B ejemplos; con B = 256 haces 1 paso por el precio de 256 de B = 1, y en pasos (no en ejemplos) el progreso inicial por ejemplo procesado suele ser peor. Memoria: las activaciones de todo el batch viven a la vez en la GPU. Y generalización: el ruido de batch pequeño zarandea la trayectoria fuera de mínimos estrechos y afilados, que suelen generalizar peor; entrenamientos con batch enorme a menudo necesitan warmup y lr re-escalado para igualar la calidad de val. El batch es un hiperparámetro de compromiso, no un "más es mejor".

Setup. El recomendador de Netflix no calcula el gradiente sobre los millones de interacciones de su dataset: muestrea un minibatch de B y usa su media. Aquí simulamos exactamente ese proceso sobre la cuadrática mal condicionada de la slide anterior: en cada paso, el JS calcula el gradiente verdadero Aθ y le suma ruido gaussiano de desviación σ/√B por componente (σ = 3, el "ruido de un ejemplo"). Arriba: las curvas de nivel de la pérdida y tres trayectorias con semillas distintas partiendo del mismo punto. Abajo: la pérdida de cada trayectoria por iteración (log) y su media (dorado grueso).

Juega. El slider de B recorre potencias de 2 de 1 a 256: el rango real que manejarás (8–128 en tabular, 32–256 en imágenes). Observa que el efecto sobre el ruido es √B, no B: de 1 a 4 se nota muchísimo, de 64 a 256 casi nada — los retornos del batch grande son decrecientes mientras su coste crece lineal.

Lee así. El lector da el ruido por paso σ/√B, la pérdida final media y el total de ejemplos procesados (B×T): la métrica honesta de coste. Compara configuraciones a ejemplos iguales, no a pasos iguales.

Mensaje. El batch fija el punto de la balanza ruido-coste: pequeño = barato por paso, ruidoso, regularizante; grande = limpio, caro, y con riesgo de generalizar peor. Defecto razonable del curso: 32–64, y si lo subes mucho, sube también el lr y añade warmup.

Términos. gB: gradiente medio del minibatch. σ2: varianza del gradiente de un ejemplo individual. ξt: ruido gaussiano estándar. mínimos planos vs afilados: cuencas anchas/estrechas de la pérdida; las anchas suelen generalizar mejor.

las ecuaciones de esta slide
los 4 paneles:  Ltrain/Lval,   ‖gt‖2,   métrica de negocio (R2),   ηt
los cuatro imprescindibles de la nota técnica: pérdidas (¿hay overfitting?), norma del gradiente (¿explota?), la métrica que mira el cliente (¿mejora lo que importa?) y el lr efectivo (¿el schedule se está ejecutando de verdad? los typos rompen schedules en silencio).
clipping:  g ← g · min(1, c‖g‖2)
si la norma del gradiente supera el tope c, se re-escala el vector entero (misma dirección, longitud c). Es el airbag estándar contra explosiones de gradiente.
R2 = 1 − MSEvalVar(yval)
la métrica de negocio de esta demo: fracción de la varianza de la demanda explicada por el modelo. Correlaciona con la pérdida pero no coincide: el cliente no factura en MSE.
guion paso a paso
  1. Con ηmax = 10−0.7, lee los cuatro paneles en orden. Pérdidas que bajan y se separan al final (overfitting suave), ‖g‖ decreciente, R2 subiendo hacia ≈0.8 y el medio coseno del lr: un run sano se reconoce de un vistazo.
  2. Sube ηmax a 100.3. El panel de ‖g‖ se dispara verticalmente y las pérdidas se van a infinito en pocas épocas: badge "run roto". El panel del gradiente avisa ANTES de que la pérdida sea NaN.
  3. Sin bajar el lr, activa el clipping con c = 2. El entrenamiento sobrevive: la norma queda serrada en c (el lector te dice qué % de épocas recortó) y la pérdida vuelve a bajar. Mismo lr, airbag puesto.
  4. Mira siempre el cuarto panel. El lr dibuja exactamente el medio coseno de la Ec. 5; si un día ese panel sale plano, tu sched.step() no se está ejecutando: ese typo silencioso se caza aquí y solo aquí.
Comprueba que entiendes: ¿por qué el panel de métrica de negocio no puede sustituirse por el de pérdida?
Porque optimizas una y facturas con la otra. La pérdida (MSE, cross-entropy) es diferenciable y por eso se entrena con ella, pero el cliente decide con AUC, MAPE o R2, y la relación entre ambas no es monótona en general: una mejora de 0.01 en pérdida puede no mover el R2, y dos runs con la misma pérdida pueden diferir en métrica. Si solo registras la pérdida, no puedes defender el modelo ante negocio; si solo registras la métrica, no puedes diagnosticar el entrenamiento. Por eso son paneles separados y obligatorios los dos.

Setup. El dashboard de un run real, como lo verías en W&B o TensorBoard monitorizando el modelo de demanda: el JS entrena por descenso de gradiente (400 épocas, schedule cosine, weight decay 10−4) el modelo polinómico del día sobre los datos ruidosos de ventas, y registra en cada época las cuatro series de la nota técnica. Panel 1: Ltrain y Lval (log). Panel 2: ‖gt‖2 antes del clipping (log), con el tope c marcado. Panel 3: R2 de validación. Panel 4: ηt, el lr efectivo.

Juega. Esta slide es un simulador de averías: el slider de lr te deja cruzar la frontera de estabilidad y ver cómo se manifiesta la avería en cada panel (el gradiente la anuncia, la pérdida la confirma, la métrica la paga, el lr la explica). El clipping es la reparación de urgencia; bajar ηmax es la de fondo.

Lee así. El badge resume el run (sano/roto) y el lector da la mejor época de val, el máximo de ‖g‖, el % de épocas recortadas y el R2 final. Si los cuatro paneles no están registrados, nada de esto se puede reconstruir: el experimento es irreproducible, que es la palabra exacta de la nota técnica del día.

Mensaje. No se entrena sin dashboard. Cuatro series, coste de logging cero, y la diferencia entre "creo que el modelo va bien" y "puedo enseñarte exactamente qué pasó en la época 173".

Términos. ‖g‖2: norma euclídea del gradiente; su explosión es el síntoma más temprano de un lr excesivo. c: tope de clipping (0.5–5 típico). R2: varianza explicada en validación. lr efectivo: el ηt que de verdad usó cada paso, no el que crees haber configurado.

las ecuaciones de esta slide
p̂ = σ(w·x + b),    σ(z) = 11+e−z
el modelo de cada run: regresión logística sobre dos variables del cliente (minutos de uso y antigüedad, estandarizadas). σ aplasta la puntuación lineal a una probabilidad de churn en (0,1).
Lval = −1nΣi[yi log p̂i + (1−yi) log(1−p̂i)](log-loss)
la columna que ordena la tabla: la log-loss de validación del run. En entrenamiento se minimiza esta misma pérdida sobre train más el término λ‖w‖22 del día, con minibatch SGD de tamaño B y lr η: los tres hiperparámetros de tus sliders.
guion paso a paso
  1. Lanza un run con los valores por defecto y vuelve a lanzarlo SIN tocar nada. Dos filas idénticas dígito a dígito: con semilla fija, mismo config = mismo número. Eso es reproducibilidad.
  2. Desmarca "semilla fija" y lanza el mismo config tres veces. Tres val-loss distintas para el MISMO config: ese baile es la varianza de la semilla, y es más grande que muchas "mejoras" que verás publicadas en tablas internas.
  3. Vuelve a semilla fija y barre η en tres runs: 10−2, 10−0.7, 100.3. La tabla los registra y la fila dorada (mejor val-loss) identifica el ganador; el panel superior dibuja su frontera de decisión sobre los clientes de validación.
  4. Cambia ahora solo λ, luego solo B. Un hiperparámetro por vez, todo registrado: en tres minutos has hecho una búsqueda defendible. Eso que acabas de sentir es lo contrario del random search de las 03:14.
Comprueba que entiendes: ¿por qué comparar dos configs con semillas distintas es trampa?
Porque la diferencia observada mezcla dos efectos: el del hiperparámetro y el del azar (inicialización, orden de los minibatches). Si config A con semilla 7 bate a config B con semilla 13, no sabes cuánto del margen es mérito de A. Acabas de medir en el paso 2 que el efecto semilla puede ser comparable al efecto hiperparámetro. El protocolo correcto: misma semilla para comparar configs (o mejor, varias semillas por config y comparar medias). Un tracker hace esto trivial porque la semilla es un campo más del registro de cada run.

Setup. Eres el equipo de datos de una telco con un modelo de churn, y esta slide es tu W&B / MLflow de bolsillo. Cada vez que pulsas "lanzar run", el JS entrena DE VERDAD una regresión logística con minibatch SGD (6 épocas, deliberadamente pocas para que el efecto de la inicialización y del orden de los datos sea visible) sobre 250 clientes sintéticos y evalúa en 150 de validación; la fila que se añade a la tabla registra exactamente lo que registraría un tracker: config completo (η, λ, B, semilla) y resultados (val-loss, accuracy). La mejor fila queda resaltada en dorado. Arriba: los clientes de validación (dorado = churn, tinta = se queda) con la frontera de decisión del último run (continua) y la del mejor run (discontinua). Abajo: la val-loss de cada run lanzado, en orden.

Juega. El checkbox de la semilla es el corazón de la slide: con él marcado, el experimento es una función determinista del config; sin él, cada run lleva ruido de inicialización y de orden de datos. Haz la secuencia del guion y decide tú cuántas de tus comparaciones pasadas eran ruido.

Lee así. La tabla ES el argumento del día sobre trackers: sin ella no recuerdas qué probaste, no puedes reproducir el mejor run y no puedes defender la elección ante el equipo. TensorBoard para logging local, W&B para equipo y barridos, MLflow para producción self-hosted: cualquiera vale, ninguno es opcional.

Mensaje. La regla del deck: antes de barrer, fija modelo, pérdida, optimizador y schedule; luego mueve UN hiperparámetro por vez, con semilla fija, y registra todo. Cada hora invertida en el tracker ahorra una semana de búsqueda ciega.

Términos. run: un entrenamiento completo con su config y sus resultados. semilla: estado inicial del generador aleatorio; fija = experimento repetible. val-loss: log-loss en validación, el criterio de la tabla. frontera de decisión: la recta w·x+b = 0 donde el modelo cambia de opinión.

1 — Diagnostica antes de medicar
Slides: Overfitting · Dashboard
"La brecha train–test es el síntoma; las curvas por época son el electrocardiograma. Sin medir la brecha (y sin los cuatro paneles registrados) cualquier regularización es un disparo a ciegas."
↓
2 — AdamW con weight decay 10−4
Slides: Weight decay
"λ‖w‖22 encoge los pesos y la capacidad efectiva: mismo modelo, menos margen para memorizar. En AdamW el decay se aplica directo (θ ← θ − ηλθ), sin contaminar los momentos de Adam."
↓
3 — Cosine annealing del lr (+ warmup si el modelo es grande)
Slides: Schedules · Batch size
"lr alto al inicio para explorar, decaimiento en medio coseno para apagar el suelo de ruido ∝ η y afinar al final. El batch fija el otro dial del mismo ruido: Var[gB] = σ2/B."
↓
4 — Dropout 0.1–0.3 y BatchNorm tras cada Linear
Slides: Dropout · BatchNorm
"Dropout entrena 2H sub-redes que comparten pesos (E[ã] = a: en test, apagado y calibrado); BatchNorm re-centra cada capa con (γ, β) aprendibles. Con batch ≤ 4, LayerNorm."
↓
5 — Early stopping con patience 10
Slides: Early stop
"t★ = primera época con P sin mejorar el mínimo de V(t); se devuelve el checkpoint del argmin. Regularización de coste cero: elige el punto de la trayectoria donde la generalización era máxima."
↓
6 — Tracker con semilla fija y un hiperparámetro por vez
Slides: Dashboard · Tracker
"Cada run registrado con su config y su semilla; comparaciones solo a semilla igual (el efecto semilla compite con el efecto hiperparámetro). W&B / MLflow / TensorBoard: cualquiera, pero uno."

En una frase. La receta exprés del primer prototipo correcto — AdamW(lr = 10−3, weight_decay = 10−4) + CosineAnnealingLR + Dropout/BatchNorm + early stopping(patience = 10) + tracking de los cuatro paneles + validación 5-fold — no es una superstición: cada ingrediente cierra una de las brechas que has manipulado hoy con tus propias manos.

Garrido-Merchán — ecgarrido@comillas.edu — Deep Learning para Business Analytics — Día 03 · Regularización, LR schedules y dashboards