las ecuaciones de esta slide
MSE(w,b) = 1n Σi=1..n ( yi − (w xi + b) )²(pérdida de regresión)
el error cuadrático medio: para cada cliente, la distancia vertical entre su gasto real yi y el gasto que predice la recta w xi+b, elevada al cuadrado (los errores grandes pesan mucho más) y promediada sobre los n clientes. Se mide en €².
ℓ(ŷ,y) = −[ y log ŷ + (1−y) log(1−ŷ) ],   ŷ = σ(wc x + bc)(Ec. 3 de la nota)
la log-loss o cross-entropy binaria: si el cliente churneó (y=1) solo cuenta −log ŷ (castiga decir "no churneará" cuando sí); si no churneó (y=0) cuenta −log(1−ŷ). La predicción ŷ pasa por la sigmoide σ para vivir en (0,1) y leerse como probabilidad.
guion paso a paso
  1. Mueve w y b hasta dejar la MSE del lector lo más baja que puedas, y compárala con la MSE óptima. A ojo te quedarás a un 5–20% de la recta de mínimos cuadrados (dorada discontinua). El descenso de gradiente hace esta misma búsqueda solo, y en miles de dimensiones a la vez.
  2. En el panel de abajo, ajusta wc y bc hasta que la curva suba donde están los churners. La log-loss baja hacia la óptima: como los churners son los clientes nuevos, la pendiente buena es negativa.
  3. Pon wc = 0. La sigmoide se vuelve plana: predice la misma probabilidad para todos. La mejor constante es la tasa base de churn, y su log-loss es la entropía de esa moneda: el suelo de un modelo que no mira los datos.
  4. Pulsa "nueva muestra" tres veces. Las pérdidas óptimas cambian un poco cada vez: son estimaciones sobre 70 clientes, no constantes de la naturaleza.
Comprueba que entiendes: ¿por qué no usamos MSE también para clasificar?
Porque con la sigmoide la MSE castiga poco los errores con confianza: si el modelo dice ŷ = 0.01 y el cliente churneó, la MSE aporta (1−0.01)² ≈ 1, acotado, y su gradiente lleva un factor σ′ casi nulo (saturación). La log-loss aporta −log(0.01) ≈ 4.6, crece sin techo con la confianza equivocada, y su gradiente respecto a z es simplemente ŷ−y: nunca se apaga. Además la log-loss es la verosimilitud Bernoulli: optimizarla produce probabilidades calibradas, que son lo que el negocio necesita para decidir.

Setup. Una telco con 70 clientes generados con semilla fija (mulberry32). El eje x es la antigüedad en meses. Arriba, regresión: predecir el gasto mensual en euros con una recta w x+b que tú controlas (la verdad generadora es gasto = 35 + 0.55·antigüedad + ruido). Abajo, clasificación: predecir si churneará (puntos en 0/1, con jitter para verlos) con una sigmoide σ(wcx+bc); la verdad generadora hace que los clientes jóvenes churneen mucho más.

Juega. Cada slider re-evalúa la pérdida sobre los 70 clientes y la compara con la mejor posible: para la recta, la solución cerrada de mínimos cuadrados; para la sigmoide, una regresión logística ajustada por descenso de gradiente al cargar la muestra. Estás haciendo a mano lo que el entrenamiento automatiza.

Lee así. Mismo cliente, misma feature, dos preguntas de negocio distintas: "¿cuánto gastará?" (un número, MSE, euros) y "¿se irá?" (una probabilidad, log-loss, decisión). La pérdida no es un detalle técnico: define qué significa equivocarse.

Mensaje. Todo el deep learning del curso es esto mismo con modelos más ricos: elegir una familia de funciones, una pérdida que mida el error en las unidades del problema, y un algoritmo que baje esa pérdida. Hoy la familia será la neurona y el MLP.

Términos. MSE: error cuadrático medio, pérdida estándar de regresión. log-loss: cross-entropy binaria, pérdida estándar de clasificación probabilística. churn: baja del cliente. sigmoide: σ(z) = 1/(1+e−z), convierte un número real en una probabilidad.

las ecuaciones de esta slide
n(θ) = 1n Σi=1..n ℓ( fθ(xi), yi )(riesgo empírico, Ec. 4 de la nota)
el riesgo empírico: la pérdida media sobre los datos de entrenamiento. Es lo único que el optimizador ve y minimiza, pero NO es lo que el negocio paga: el negocio paga el error sobre clientes nuevos. La brecha entre ambos es exactamente el overfitting.
fd(x) = c0 + c1x + c2x² + … + cdxd(el modelo de la demo)
un polinomio de grado d ajustado por mínimos cuadrados: d es el mando de capacidad. Con d = 0 una constante (infraajuste); con d = 12 puede pasar por casi todos los puntos (sobreajuste). En redes el papel de d lo juegan la anchura y la profundidad.
guion paso a paso
  1. Con n = 24, sube d de 0 a 3 mirando el panel inferior. Las DOS curvas de error bajan a la vez: el modelo gana capacidad que sí generaliza, porque la demanda real tiene forma de onda.
  2. Sigue subiendo d hasta 12. La MSE de train sigue bajando hacia 0; la de validación se dispara. El modelo ya no aprende demanda: memoriza el ruido de esa muestra concreta.
  3. Baja n a 12 dejando d = 9. La curva ajustada serpentea por casi todos los puntos. Con menos datos, el overfitting llega con menos capacidad.
  4. Con d = 12, pulsa "otra muestra" varias veces. La curva ajustada cambia salvajemente de muestra a muestra: eso es alta varianza, la firma estadística del sobreajuste.
Comprueba que entiendes: ¿por qué el error de train no sirve para elegir d?
Porque es monótono: más capacidad nunca empeora el ajuste sobre los mismos puntos que se usaron para ajustar, así que el train siempre vota "más grado". Solo datos que el modelo no ha visto (validación) detectan que la mejora es memoria y no señal. De ahí el k-fold del deck: repartir el papel de validación entre k trozos para que el veredicto no dependa de una partición con suerte.

Setup. Forecast de demanda en retail (piensa en una referencia de Inditex): el eje x es la intensidad promocional normalizada y el eje y la demanda normalizada. La verdad generadora (curva gris discontinua) es una onda suave; los puntos llevan ruido gaussiano. Ajusto por mínimos cuadrados un polinomio de grado d sobre los n puntos de entrenamiento, y evalúo la MSE sobre 200 puntos de validación que el ajuste nunca ve. Abajo: las dos MSE para todos los grados 0…12, con tu d marcado.

Juega. El panel inferior es la figura más importante del machine learning aplicado: la U del error de validación. A su izquierda, infraajuste; a su derecha, sobreajuste; en el valle, el modelo que pondrías en producción.

Lee así. El lector marca el grado que minimiza la MSE de validación en esta muestra. Fíjate en que ese ganador también baila al cambiar de muestra: por eso en la práctica se promedia con validación cruzada en vez de confiar en una partición única.

Mensaje. Las redes del curso tienen miles de "grados de libertad", así que viven permanentemente a la derecha de esta U. Todo el Día 03 (regularización, early stopping) consiste en empujarlas hacia el valle.

Términos. capacidad: riqueza de la familia de funciones que el modelo puede representar. overfitting: memorizar ruido de la muestra; train baja, validación sube. validación: datos apartados que no tocan el ajuste. varianza: sensibilidad del modelo ajustado a la muestra concreta.

las ecuaciones de esta slide
y = σ( Σi=1..d wi xi + b ) = σ( wx + b )(Ec. 1 de la nota)
la neurona: cada entrada xi (antigüedad, llamadas…) se multiplica por su peso wi (cuánto importa y con qué signo), se suma el sesgo b (la predicción por defecto sin señal) y el total z pasa por la activación σ. La frontera de decisión es z = 0: una recta en el plano de entradas, siempre.
σ(z) = 11+e−z,   tanh(z) = ez−e−zez+e−z,   ReLU(z) = máx(0, z)
las tres activaciones del deck: la sigmoide aplasta a (0,1) y se lee como probabilidad; la tanh aplasta a (−1,1) centrada en cero; la ReLU deja pasar lo positivo tal cual y apaga lo negativo. Cambian CÓMO se gradúa la respuesta, no DÓNDE está la frontera.
guion paso a paso
  1. Con la sigmoide, mueve w₁ y w₂ y observa la línea negra (z = 0). La frontera siempre es una recta: gira y se desplaza, pero una neurona sola jamás dibuja una curva. Los pesos fijan su orientación; b, su posición.
  2. Sube los pesos a w₁ = −8, w₂ = 8 manteniendo la dirección. El degradado dorado se comprime contra la frontera: misma recta, transición más abrupta. Pesos grandes compran confianza, no expresividad.
  3. Cambia la activación a ReLU. Medio plano exactamente a 0 (apagado) y una rampa lineal creciente en el otro: esta pieza "a trozos" es el ladrillo con el que un MLP construye funciones complejas.
  4. Cambia a tanh y mira el cliente seguido en el lector. Mismo z, salida ahora en (−1,1): la frontera no se mueve, solo cambia la escala y el centro de la respuesta.
Comprueba que entiendes: si apilo tres capas SIN activación, ¿qué fronteras puedo dibujar?
Solo rectas. La composición de funciones afines es afín: W₃(W₂(W₁x+b₁)+b₂)+b₃ = Wx+b para ciertos W, b. Tres capas lineales colapsan en una única neurona lineal equivalente, con la misma frontera recta que acabas de mover. La no-linealidad σ entre capas es lo único que impide ese colapso: es literalmente lo que hace "profundo" al deep learning.

Setup. Cada punto es un cliente de la telco en el plano (antigüedad normalizada, llamadas al soporte normalizadas): dorados oscuros = churn, blancos = se quedan; las dos nubes salen de mulberry32 con semilla fija. El fondo es el mapa de calor de la salida de TU neurona a = σ(w₁x₁ + w₂x₂ + b) en cada punto del plano (blanco = salida baja, sepia = alta), y la línea negra es la frontera z = 0. Abajo: la activación elegida, con el z del cliente seguido marcado.

Juega. El lector da el z y la salida del cliente seguido, y la accuracy de tu neurona sobre los 80 clientes con la regla "churn si z > 0". Intenta superar el 90%: necesitas w₁ negativo (la antigüedad protege) y w₂ positivo (las llamadas delatan).

Lee así. Una neurona es exactamente una regresión logística cuando σ es la sigmoide: lo que ya sabías de ML clásico es el caso d = 1 capa. Lo nuevo del curso empieza al apilarlas.

Mensaje. Pesos = orientación de la frontera; sesgo = posición; activación = cómo se gradúa la respuesta a cada lado. Con esto leído, el MLP de dos slides más adelante es solo "varias de estas, en cadena".

Términos. z: pre-activación, la suma ponderada antes de σ. frontera de decisión: lugar donde z = 0 y la predicción cambia de bando. ReLU: rectified linear unit, la activación moderna por defecto.

las ecuaciones de esta slide
z = w₁x₁ + w₂x₂ + w₃x₃ + b = (−0.04)(24) + (0.02)(80) + (0.55)(5) + (−0.50) = 2.89
la combinación lineal del cliente del deck, sumando contribución a contribución: −0.96 (la antigüedad resta riesgo) + 1.60 (el gasto suma) + 2.75 (las llamadas disparan) − 0.50 (el sesgo). Ojo: con el gasto en 60 € sale z = 2.49 y ŷ = 0.923 (la nota técnica del día lo redondea a 0.924); compruébalo con el slider.
ŷ = σ(z) = 11 + e−z,   σ(2.49) = 0.923,  σ(2.89) = 0.947
la sigmoide convierte el marcador z en probabilidad de churn. Con umbral 0.5 (es decir, z > 0), el cliente se marca como prioritario para la campaña de retención.
guion paso a paso
  1. Con los valores del deck (24 meses, 80 €, 5 llamadas) lee el lector. z = 2.89 y ŷ = 0.947: cliente muy caliente. La barra de las llamadas al soporte (+2.75) domina la suma.
  2. Baja el gasto a 60 €. z = 2.49 y ŷ = 0.923: los números del ejemplo a mano de la nota técnica (que redondea la probabilidad a 0.924). Cada barra del panel superior es un sumando de esa cuenta.
  3. Sube la antigüedad a 72 meses. La contribución −0.04·72 = −2.88 arrastra z casi dos puntos hacia abajo: la antigüedad protege, pero con 5 llamadas el cliente sigue en zona de riesgo.
  4. Deja las llamadas en 0. z se hunde por debajo de 0 y ŷ cae a la zona del 15%: la señal de alarma eran las llamadas. El punto dorado del panel inferior resbala por la sigmoide en cada movimiento.
Comprueba que entiendes: el peso del gasto es 0.02, ¿significa que el gasto "importa poco"?
No. Los pesos son por unidad de la feature, y las features tienen escalas distintas: 0.02 por euro sobre un gasto de 80 € aporta 1.60, comparable al 2.75 de las llamadas. Lo que mide la importancia en esta cuenta es la contribución wixi (las barras del panel), no el peso suelto. Por eso en la práctica se estandarizan las features antes de entrenar: con todas en la misma escala, los pesos sí son comparables entre sí.

Setup. El cliente del deck, en vivo: tres atributos observables (tenure, monthly, support_calls) y la neurona con los pesos del día, w = (−0.04, 0.02, 0.55) y b = −0.50. Arriba: cada contribución wixi y el sesgo como barras que suman z. Abajo: la sigmoide con el punto (z, ŷ) del cliente actual y el umbral 0.5 marcado.

Juega. Los tres sliders son la ficha del cliente. El JS rehace la cuenta completa en cada movimiento: no hay nada precalculado. La cuenta del deck imprime z = 2.49 con monthly = 80; la aritmética real de esos pesos da 2.89, y el 2.49 corresponde a monthly = 60: el paso 2 del guion te lo deja ver.

Lee así. z es un marcador en "unidades de riesgo": cada feature empuja a favor o en contra según el signo de su peso. La sigmoide solo traduce ese marcador a probabilidad; la decisión de negocio (campaña sí/no) es el umbral.

Mensaje. Esto es TODO el forward de una neurona: una suma ponderada y una función. El forward de la red entera de la slide siguiente es esta misma cuenta repetida capa a capa.

Términos. forward (pass): evaluar la red de entrada a salida. contribución: wixi, el aporte de cada feature a z. umbral: probabilidad a partir de la cual se actúa; aquí 0.5, en la slide de churn verás que el negocio lo mueve.

las ecuaciones de esta slide
fθ(x) = hL ∘ hL−1 ∘ … ∘ h1(x),   h(z) = σ( Wz + b )(Ec. 2 de la nota)
el MLP: L capas encadenadas, cada una multiplica por su matriz W, suma su sesgo y aplica su activación. Sin las σ la cadena colapsa a una capa lineal única.
δ = ( Wℓ+1 δℓ+1 ) ⊙ σ′(z)  ⇒   ‖δ1‖ ≈ ‖δL‖ · Π (factor de capa)(Ec. 5 de la nota)
la señal de error δ baja capa a capa multiplicándose por W y por σ′. L factores multiplicados: si el factor típico es < 1 el gradiente se desvanece exponencialmente; si es > 1, explota. La sigmoide tiene σ′ ≤ 0.25 siempre: factor condenado a ser pequeño.
guion paso a paso
  1. Con g = 1 y L = 16, mira el panel inferior. La curva de la sigmoide (gris) cae unos 10 órdenes de magnitud de la última capa a la primera: en float32 eso es cero, las primeras capas no reciben señal y no aprenden.
  2. Sube g a 1.5. tanh (tinta) se aplana y ReLU (dorada) empieza a crecer: la MISMA red pasa de desvanecerse a explotar solo cambiando la escala inicial de los pesos.
  3. Pon g = 1.41 ≈ √2. La curva ReLU queda casi horizontal: es la inicialización de He, diseñada exactamente para que el factor medio de capa con ReLU valga 1.
  4. Sube g a 2.5 y pulsa "otra semilla" un par de veces. ReLU y tanh suben con pendiente positiva (explosión); la forma se repite semilla a semilla: es geometría de la red, no suerte.
Comprueba que entiendes: ¿por qué la sigmoide está condenada aunque suba g?
Su derivada está acotada: σ′(z) = σ(z)(1−σ(z)) ≤ 0.25, así que cada capa multiplica como mucho por 0.25·(escala de W). Y subir g no rescata: con pesos grandes las pre-activaciones z crecen, la sigmoide se satura y σ′(z) → 0, o sea que el factor empeora. La tanh al menos tiene σ′(0) = 1, y la ReLU tiene derivada exactamente 1 en toda la zona activa: por eso es la opción moderna por defecto del deck.

Setup. Arriba: las tres activaciones (trazo continuo) y sus derivadas (discontinuo). Abajo, el experimento de verdad: construyo una red de L capas y 20 neuronas por capa con pesos W ~ N(0, g²/20) (mulberry32), hago un forward con entrada aleatoria, inyecto un gradiente aleatorio arriba y ejecuto la recursión de backprop de la Ec. 5, capa a capa y para las tres activaciones con los MISMOS pesos. La curva es la norma media de δ (en log₁₀, promediada sobre 10 redes) en función de la capa.

Juega. El slider g es la decisión que en PyTorch toma init por ti; el slider L es la profundidad. El lector resume el factor total ‖δ1‖/‖δL‖ de cada activación: léelo como "cuántas veces más débil (o fuerte) llega la señal de aprendizaje a la primera capa".

Lee así. Esto explica un hecho histórico: antes de 2012 las redes profundas con sigmoide no entrenaban. ReLU + inicialización correcta (He) es lo que hizo entrenables las redes de 20, 50, 150 capas que verás en el curso.

Mensaje. La activación no es una preferencia estética: decide si el gradiente sobrevive al viaje de vuelta. ReLU por defecto; sigmoide solo en la capa de salida, donde su lectura como probabilidad es lo que el negocio necesita.

Términos. δ: señal de error de la capa ℓ, gradiente de la pérdida respecto a z. : producto componente a componente. gain g: factor de escala de la desviación típica inicial de los pesos. He init: g = √2, la escala que conserva la señal con ReLU. saturación: zona plana de la activación donde σ′ ≈ 0.

las ecuaciones de esta slide (ejemplo resuelto del deck)
z₁ = 0.5·1 + 0.3·2 + 0.1 = 1.2,  a₁ = ReLU(1.2) = 1.2;   z₂ = 0.2·1 + 0.7·2 − 0.1 = 1.5,  a₂ = ReLU(1.5) = 1.5
la capa oculta: cada neurona hace su suma ponderada de las DOS entradas y aplica ReLU. Aquí ambas z son positivas, así que las ReLU dejan pasar el valor tal cual: las dos neuronas están "vivas".
zo = 0.6·1.2 − 0.4·1.5 + 0.1 = 0.22,   ŷ = σ(0.22) = 0.555,   ℒ = −log(0.555) = 0.589
la capa de salida consume las activaciones ocultas (no las entradas), aplica la sigmoide y produce la probabilidad 0.555. Como la etiqueta verdadera es y = 1, la BCE de la Ec. 3 se reduce a −log ŷ = 0.589: la pérdida que backprop repartirá en la slide siguiente.
cantidadcálculovalor
guion paso a paso
  1. Con x = (1, 2), compara la tabla con el deck. z₁ = 1.2, a₁ = 1.2, z₂ = 1.5, a₂ = 1.5, zo = 0.22, ŷ = 0.555: el ejemplo resuelto, calculado en vivo.
  2. Baja x₁ despacio hacia −2 mirando la curva inferior. La curva ŷ(x₁) tiene esquinas: son los puntos donde z₁ o z₂ cruzan 0 y una ReLU se enciende o se apaga.
  3. Localiza x₁ < −1.4. Ahí z₁ < 0 y la neurona 1 se apaga: su fila de la tabla se queda en 0 y la salida pasa a depender solo de h₂. En el diagrama, el nodo se vacía.
  4. Pon x₂ = −2 y recorre x₁. Hay tramos con las dos ocultas apagadas donde la red emite σ(0.1) = 0.525 constante: sin neuronas vivas no hay sensibilidad a la entrada.
Comprueba que entiendes: ¿por qué ŷ(x₁) es "lineal a trozos deformada" y no una curva cualquiera?
Antes de la sigmoide, zo(x₁) es lineal a trozos: cada ReLU es lineal a trozos y la capa de salida es una combinación afín de ellas, así que solo puede haber cambios de pendiente donde alguna zj cruza 0 (aquí, como mucho 2 esquinas). La sigmoide final solo re-escala monótonamente. Con miles de neuronas hay miles de esquinas, y la "curva suave" de una red grande es en realidad un mosaico finísimo de trozos lineales.

Setup. La red 2→2→1 del deck con sus pesos exactos: capa oculta w = (0.5, 0.3 | 0.2, 0.7), sesgos (0.1, −0.1), ReLU; capa de salida (0.6, −0.4), sesgo 0.1, sigmoide. Arriba: el grafo con los valores fluyendo (grosor de arista proporcional a |peso|; dorado = positivo, gris = negativo; dentro de cada nodo, su z y su a actuales). Abajo: la salida ŷ como función de x₁ con tu x₂ fijo, con el punto actual marcado.

Juega. La tabla recalcula las seis cantidades del ejemplo en cada movimiento, en el orden exacto en que las calcularías a mano: primero las dos z ocultas, luego las ReLU, luego zo, la sigmoide y la pérdida con y = 1.

Lee así. Piensa en x₁, x₂ como dos atributos estandarizados de un cliente (por ejemplo, desviaciones de gasto y de llamadas respecto a la media). El forward es una cascada de las cuentas de la slide anterior: ninguna pieza nueva, solo composición.

Mensaje. Si sabes hacer ESTA tabla a mano, sabes qué hace cualquier MLP por dentro: multiplicar matrices, sumar sesgos, aplicar activaciones. Lo único que crece en las redes reales es el tamaño de las matrices.

Términos. capa oculta: la que ni recibe la entrada cruda ni emite la salida final. aj: activación, salida de la neurona j tras la ReLU. neurona muerta: ReLU con z < 0 para todas las entradas de interés; no contribuye ni aprende.

las ecuaciones de esta slide
δL = ∇aLℓ ⊙ σ′L(zL),   δ = ( Wℓ+1δℓ+1 ) ⊙ σ′(z),   ∂ℓ∂W = δ aℓ−1∂ℓ∂b = δ(Ec. 5 de la nota)
backprop completo en una línea: la señal de error δ nace arriba, baja multiplicada por W y filtrada por σ′, y el gradiente de cada peso es siempre (error del nodo destino) × (activación del nodo origen).
δout = ŷ − y = −0.445;   ∂ℒ∂w₅ = δ·a₁ = −0.534,  ∂ℒ∂w₆ = δ·a₂ = −0.668;   δh₁ = w₅δ·𝟙z₁>0 = −0.267,  ∂ℒ∂w₁ = δh₁x₁ = −0.267
los números del deck: para sigmoide + BCE el error de salida es simplemente ŷ − y (las derivadas de la sigmoide y del log se cancelan); la indicatriz 𝟙z>0 es la derivada de la ReLU: deja pasar el error si la neurona estaba viva y lo corta si estaba muerta.
θt+1 = θt − η ∇θℒ(θt)(Ec. 4 de la nota)
el paso de descenso que dispara el botón: cada parámetro se mueve contra su gradiente, a velocidad η.
parám.valor∂ℒ/∂·tras el paso
guion paso a paso
  1. Lee la tabla con los pesos recién reiniciados. ∂ℒ/∂w₅ = −0.534, ∂ℒ/∂w₆ = −0.668, ∂ℒ/∂w₁ = −0.267: los números de la slide del deck, calculados por la regla de la cadena en JS, no aproximados.
  2. Con η = 0.5, pulsa "un paso de descenso". Todos los pesos se mueven CONTRA su gradiente y la pérdida cae de 0.589 a ≈ 0.13 en un solo paso: el panel izquierdo dibuja la caída.
  3. Pulsa "reinicia", pon η = 3 y da diez pasos. La pérdida baja a saltos y puede oscilar; con saltos así puedes empujar una z oculta por debajo de 0 y "matar" su ReLU: mira cómo sus gradientes pasan a 0 exacto en la tabla.
  4. Mira el check numérico del lector. El gradiente de w₅ por diferencias finitas coincide con el analítico hasta ≈ 10&supmin;⁹: la regla de la cadena es exacta, no una aproximación.
Comprueba que entiendes: ¿por qué ∂ℒ/∂w₂ es justo el doble de ∂ℒ/∂w₁?
Los dos pesos comparten la misma señal de error δh₁ = −0.267 (van a la misma neurona) y el gradiente es siempre δ × entrada de origen: para w₁ la entrada es x₁ = 1 y para w₂ es x₂ = 2. De ahí −0.267 vs −0.534. Es la regla universal de backprop: "error del destino por activación del origen", la misma que en la capa de salida da δ·a₁ y δ·a₂.

Setup. La misma red 2→2→1 con la entrada fija x = (1, 2) y la etiqueta y = 1. El JS implementa la regla de la cadena simbólica: δout = ŷ−y, las δ ocultas con la indicatriz de la ReLU, y los nueve gradientes exactos (seis pesos y tres sesgos). Izquierda: la trayectoria de la pérdida paso a paso. Derecha: los nueve gradientes actuales como barras. La tabla muestra cada parámetro, su gradiente y dónde quedará tras un paso con tu η.

Juega. El botón "un paso" ejecuta literalmente la Ec. 4: θ ← θ − ηg, recalcula el forward y añade el punto a la trayectoria. No hay ninguna curva precocinada: si cambias η cambias la trayectoria que se dibuja.

Lee así. Los gradientes de la capa de salida son los más grandes (la señal aún no se ha atenuado) y los de h₂ tienen signo contrario a los de h₁ porque w₆ = −0.4 invierte el error al repartirlo. El signo del gradiente dice hacia dónde NO moverse.

Mensaje. Esto es exactamente lo que hace loss.backward() en PyTorch sobre millones de parámetros: la misma regla de la cadena, el mismo "error destino × activación origen", automatizado sobre el grafo de operaciones.

Términos. δ: gradiente de la pérdida respecto a la pre-activación de un nodo. 𝟙z>0: derivada de la ReLU (1 si viva, 0 si muerta). paso de descenso: θ ← θ − ηg. check de gradiente: comparar el gradiente analítico con (ℒ(w+ε)−ℒ(w−ε))/2ε.

las ecuaciones de esta slide
θt+1 = θt − η ∇θnt),   R̂n(w,b) = 1n Σi ( yi − w xi − b )²(Ec. 4 de la nota)
descenso de gradiente sobre la superficie MSE de dos parámetros (pendiente w y corte b): el mapa de calor ES la pérdida, y la trayectoria son los θt de verdad, uno por paso.
κ = λmáxλmín,   ηcrít = 2λmáx(condicionamiento)
λmáx, λmín son las curvaturas extremas del valle (autovalores de la Hessiana). Si η supera ηcrít, cada paso sobrepasa el valle en la dirección empinada más de lo que bajó: divergencia. Y η segura para la dirección empinada significa lentitud desesperante en la suave: ese castigo es κ.
guion paso a paso
  1. Con η = 10&supmin;³·⁵ y T = 60. La trayectoria zigzaguea cruzando el cañón y casi no avanza a lo largo de él: lee κ en el lector (miles). El gradiente apunta casi perpendicular al óptimo.
  2. Sube η justo por encima del crítico que marca el lector. El zigzag crece en vez de encogerse y la pérdida del panel derecho sube en línea recta (escala log): divergencia limpia, el badge se pone en rojo.
  3. Activa "estandariza la antigüedad". κ cae a ≈ 1: el cañón se vuelve un cuenco redondo. El mismo descenso ahora va casi en línea recta al óptimo.
  4. Estandarizado, prueba η = 10&supmin;₀·² con T = 40. Converge en unas decenas de pasos con un learning rate CUATRO órdenes de magnitud mayor: estandarizar entradas es la mejora de optimización más barata que existe.
Comprueba que entiendes: ¿por qué estandarizar la feature cambia la forma del valle?
La Hessiana de la MSE depende de los segundos momentos de las entradas: vale (2/n)Σ(xi,1)(xi,1). Con la antigüedad en meses (media ≈ 36, valores hasta 72), las direcciones w y b están fuertemente acopladas y sus curvaturas difieren en miles. Al centrar (media 0) se desacoplan w y b, y al re-escalar (sd 1) sus curvaturas se igualan: la Hessiana queda casi proporcional a la identidad y κ ≈ 1. La geometría del valle no la pone el problema de negocio: la pones tú al elegir las unidades.

Setup. Vuelvo a la regresión de la primera slide: predecir gasto mensual a partir de la antigüedad con dos parámetros, θ = (w, b). El mapa de calor es la MSE real sobre los 60 clientes (blanco = bajo, sepia = alto, en escala log de color), la estrella es el mínimo de mínimos cuadrados, y la línea dorada es la trayectoria exacta de descenso de gradiente desde θ₀ con tu η y tus T pasos. Derecha: la MSE en cada iteración, en escala log.

Juega. El lector calcula la Hessiana exacta, sus autovalores, κ y ηcrít = 2/λmáx; todo cambia al pulsar "nueva muestra" o al estandarizar. La frontera convergencia/divergencia que ves en pantalla es la teórica, al pixel.

Lee así. Este valle con dos parámetros es la caricatura honesta de los millones de parámetros de una red: allí también hay direcciones empinadas y suaves, y el learning rate vive atrapado entre divergir y no avanzar. Por eso el deck dice que el 80% de los entrenamientos fallidos son un η mal puesto.

Mensaje. Dos remedios al mal condicionamiento: arreglar los datos (estandarizar: lo acabas de ver) y arreglar el algoritmo (adaptar el paso por coordenada: la slide siguiente, Adam).

Términos. superficie de pérdida: R̂n como función de los parámetros. Hessiana: matriz de curvaturas. κ: número de condición, alargamiento del valle. divergencia: pasos que sobrepasan el valle y amplifican el error.

las ecuaciones de esta slide
mt = β₁mt−1 + (1−β₁)gt,   vt = β₂vt−1 + (1−β₂)gt²,   m̂t = mt1−β₁t,  v̂t = vt1−β₂t,   θt+1 = θt − ηt√v̂t + ε(Adam, Ec. 6 de la nota)
Adam lleva dos memorias por coordenada: mt, la media móvil del gradiente (la inercia, mando β₁), y vt, la del gradiente al cuadrado (la escala típica, mando β₂). Dividir por √v̂ iguala el paso en direcciones empinadas y suaves; las correcciones 1−βt compensan que ambas memorias arrancan en 0.
Δθi ≈ −η sign(∂ℒ∂θi);    momentum:  v ← μv − ηg,  θ ← θ + v;    AdamW:  θ ← θ − ηλθ
tres lecturas del deck: en el límite, Adam da pasos de tamaño η con el SIGNO del gradiente (un Newton "barato", insensible a la curvatura); momentum acumula velocidad con fricción μ y amortigua el zigzag; AdamW añade el weight decay desacoplado, que regulariza sin contaminar las medias móviles.
guion paso a paso
  1. Con κ = 25 y los valores por defecto. SGD (tinta) zigzaguea perpendicular al valle; momentum (gris) amortigua las oscilaciones y avanza; Adam (dorado) baja casi en diagonal recta: cada coordenada con su propio paso.
  2. Sube κ a 100 sin tocar nada más. SGD diverge (ηκ = 3 > 2); momentum sobrevive a duras penas; Adam ni se inmuta. El lector marca quién llegó y quién explotó.
  3. Baja μ a 0. Momentum degenera exactamente en SGD: misma trayectoria de zigzag. La inercia ERA toda la diferencia.
  4. Pon β₂ = 0.9 con κ = 100. La memoria de escala de Adam se vuelve miope y la trayectoria se riza cerca del óptimo: la v̂ estable (β₂ = 0.999) existe para esto.
Comprueba que entiendes: ¿por qué Adam tolera el mismo η con κ = 2 y con κ = 100?
Porque normaliza cada coordenada por su propia escala de gradiente: en la dirección empinada el gradiente es grande, √v̂ es grande, y el cociente m̂/√v̂ queda de tamaño ≈ 1; en la suave, ambos son pequeños y el cociente también queda ≈ 1. El paso efectivo es ≈ η por coordenada, independiente de la curvatura: la geometría del valle desaparece de la condición de estabilidad, que para SGD era η < 2/λmáx. El precio: pasos que no siguen exactamente el gradiente, lo que a veces generaliza un pelo peor en problemas pequeños (de ahí "SGD con momentum si el dataset es chico", como dice el deck).

Setup. El banco de pruebas clásico: el valle cuadrático mal condicionado f(θ) = ½(θ₁² + κ θ₂²), con gradiente exacto (θ₁, κθ₂). Los tres corredores parten del mismo punto (−9, 1.6) y dan 160 pasos: SGD puro, SGD con momentum, y Adam con corrección de sesgo completa, implementados ecuación a ecuación. Derecha: f en cada iteración (escala log), la carrera en versión métrica.

Juega. κ controla cuán alargado es el valle (el mapa de contorno se re-dibuja); η es compartido por SGD y momentum para que la comparación sea limpia, y Adam lleva el suyo porque su paso efectivo tiene otras unidades (es ≈ η, no ≈ η·gradiente).

Lee así. En las redes reales el valle no es cuadrático, pero localmente se le parece y κ es gigantesco. Lo que ves aquí es la razón operativa del consejo del deck: AdamW con η = 10&supmin;³ como punto de partida para casi todo.

Mensaje. SGD fracasa por geometría, no por mala suerte; momentum cura el síntoma (oscilación) y Adam cura la causa (escala por coordenada). Elegir optimizador es elegir cuánta geometría quieres ignorar.

Términos. gt: gradiente del paso t. mt, vt: medias móviles de g y g². corrección de sesgo: dividir por 1−βt para compensar el arranque en cero. ε: 10&supmin;⁸, evita dividir por cero. weight decay λ: encogimiento θ ← θ−ηλθ de AdamW.

las ecuaciones de esta slide
B = 1B Σi∈batchθℓ( fθ(xi), yi ),   E[ĝB] = ∇θn(gradiente mini-batch)
el gradiente estimado con B ejemplos elegidos al azar: es insesgado (su media es el gradiente completo), así que cada paso está mal pero la dirección media es correcta. Esa es la licencia matemática del "estocástico" de SGD.
sd( ĝB ) ∝ 1√B
la desviación típica del ruido cae como la raíz del batch: cuadruplicar B solo divide el ruido entre 2. Rendimientos decrecientes: pagar batch gigante compra poco silencio, y el ruido moderado hasta ayuda a generalizar.
guion paso a paso
  1. Pon B = 1. La trayectoria es un zigzag borracho que aun así cae hacia el valle: cada gradiente individual está mal, su media está bien. Y da 512 pasos en 2 épocas.
  2. Sube B a 256 (batch completo). Trayectoria lisa y determinista… pero en 2 épocas solo ha dado 2 pasos. Con el mismo presupuesto de datos, el batch gigante apenas aprende.
  3. Mira el panel derecho. El ruido medido cae en línea recta de pendiente −½ en log-log, clavado a la referencia teórica 1/√B: acabas de verificar un teorema con una simulación.
  4. Con B = 8, pulsa "otra semilla" varias veces. Cada zigzag es distinto pero todos terminan en la misma zona: el ruido del mini-batch es aleatorio, la señal no.
Comprueba que entiendes: ¿por qué B = 32–128 es el estándar y no B = n?
Por la pendiente −½: pasar de B = 32 a B = 256 multiplica el coste de cada paso por 8 y solo divide el ruido por √8 ≈ 2.8. Con presupuesto de cómputo fijo, conviene aceptar algo de ruido a cambio de muchos más pasos, que es lo que de verdad mueve la pérdida. Además, el ruido actúa como regularizador: ayuda a salir de mínimos estrechos que generalizan mal. El batch pequeño no es una concesión a la memoria de la GPU: es, dentro de un rango, una decisión estadísticamente sensata.

Setup. La regresión gasto~antigüedad con la feature ya estandarizada y n = 256 clientes. Izquierda: el valle MSE con la trayectoria de SGD mini-batch durante 2 épocas exactas con tu B: en cada paso muestreo B clientes (mulberry32), calculo su gradiente medio y actualizo. Derecha: el experimento de varianza: en el punto de partida extraigo 150 mini-batches de cada tamaño y mido la desviación ‖ĝB − g‖ respecto al gradiente completo; la línea discontinua es la teoría 1/√B anclada en B = 1.

Juega. El lector da los pasos por época (256/B), el error relativo medio del gradiente con tu B, y la predicción teórica. La comparación medido vs teoría es la honestidad de la slide: nada está dibujado a mano.

Lee así. Hay dos relojes: pasos (cada actualización aprende) y datos procesados (cada época cuesta lo mismo procese B = 1 o B = 256). El mini-batch pequeño gana en el primer reloj y empata en el segundo: por eso existe.

Mensaje. Los 32–128 del deck no son folclore: son el compromiso cuantitativo entre una curva de ruido con pendiente −½ y un coste por paso lineal en B. Ahora sabes derivarlo, no solo recitarlo.

Términos. mini-batch: submuestra aleatoria de B ejemplos por actualización. época: una pasada completa por los n datos. insesgado: estimador cuya media es la cantidad verdadera. 1/√B: ley de reducción del ruido al promediar B observaciones independientes.

las ecuaciones de esta slide
Recall = TPTP+FN,   Precision = TPTP+FP,   F₁ = 2 P·RP+R(Ec. 7 de la nota)
recall: de los churners reales, qué fracción cazo; precision: de los que marco, cuántos eran churners de verdad. El umbral τ las intercambia: bajarlo caza más (recall ↑) ensuciando la lista (precision ↓).
Ahorro(τ) = s·TP·LTV − (TP+FP)·cr,    τ* ≈ crs·LTV(la cuenta del negocio)
cada cliente marcado recibe una oferta de coste cr; si era churner de verdad, la oferta lo retiene con probabilidad s y salva su valor LTV. Ofertar compensa cuando el ahorro esperado supera el coste: s·p·LTV > cr, o sea p > cr/(s·LTV). Con probabilidades calibradas, ese cociente ES el umbral óptimo.
realidad \ modelomarcado (p ≥ τ)no marcado
guion paso a paso
  1. Con τ = 0.5, lee matriz y ahorro. El umbral "neutro" deja escapar a la mayoría de churners (recall bajo): cada FN son 600 € que se van por la puerta.
  2. Baja τ hacia 0.25. El recall sube y la precision baja; el ahorro neto SUBE, porque perder un cliente (600 €) cuesta como diez ofertas (60 €): conviene ser generoso marcando.
  3. Lleva τ al punto dorado del panel inferior y compáralo con la τ* teórica del lector. Coinciden aproximadamente (cr/(s·LTV) = 60/360 ≈ 0.17): el umbral óptimo casi nunca es 0.5 y se calcula, no se adivina.
  4. Sube cr a 180 €. El óptimo se desplaza a la derecha: cuando intervenir es caro hay que ser selectivo. El negocio mueve el umbral sin tocar el modelo.
Comprueba que entiendes: ¿por qué el umbral óptimo no es 0.5?
0.5 minimiza el número de errores cuando equivocarse en un sentido cuesta lo mismo que en el otro. Aquí no: un falso negativo cuesta s·LTV = 360 € esperados y un falso positivo solo cr = 60 €. Igualando coste marginal y beneficio marginal de marcar, conviene ofertar a todo cliente con p > cr/(s·LTV) ≈ 0.17. La separación de papeles es la lección: el modelo estima probabilidades calibradas; la decisión la fija la economía del problema. Cambia el precio de la oferta y cambia τ*, sin re-entrenar nada.

Setup. El caso del día, de punta a punta: 400 clientes telco sintéticos y reproducibles (mulberry32) con tenure, monthly y support_calls; el churn verdadero sale de una logística con los signos de la slide "Forward" (la antigüedad protege, las llamadas delatan). Sobre ellos entreno al cargar, por descenso de gradiente sobre la BCE, una regresión logística con features estandarizadas: la neurona del día, completa. Arriba: las probabilidades predichas p̂ separadas por clase real (contorno tinta = se quedan, relleno dorado = churn) con tu umbral τ. Abajo: el ahorro anual en euros como función de τ, con el máximo marcado.

Juega. La matriz de confusión, las métricas y los euros se recalculan en cada movimiento. El AUC del lector resume cuánto separa el modelo las dos distribuciones de arriba, independientemente del umbral.

Lee así. La trampa del accuracy del deck, en vivo: con τ = 0.9 el modelo marca a casi nadie y aun así conserva un accuracy en torno al 65% (la tasa de no-churn), mientras el ahorro se hunde a cero. La métrica de negocio y el accuracy no votan igual.

Mensaje. Este es el pipeline completo del día: datos → neurona (regresión logística) → entrenamiento por gradiente → probabilidad → decisión en euros. En la práctica del curso harás exactamente esto sobre el Telco Customer Churn real, con un MLP en PyTorch en lugar de la neurona.

Términos. TP/FP/FN/TN: aciertos y errores de cada signo al cruzar predicción con realidad. LTV: lifetime value, valor del cliente. s: probabilidad de que la oferta retenga a un churner (aquí 0.6). AUC: probabilidad de que un churner al azar reciba más p̂ que un no-churner al azar. calibración: que p̂ = 0.3 signifique "30% de las veces churnea".

Repaso ML — el problema y su pérdida
Slides: Reg vs clas · Overfitting
"Primero decide qué predices (un número → MSE; una probabilidad → log-loss) y aparta datos de validación: el optimizador solo ve el riesgo empírico, y la brecha train/validación es el overfitting que pagará el negocio."
La neurona y el MLP — la familia de funciones
Slides: La neurona · Forward · MLP 2-2-1
"Una neurona es z = w⊤x + b más una activación: frontera recta, respuesta graduada. Apiladas con ReLU componen funciones lineales a trozos arbitrariamente ricas; el forward es la cuenta del cliente del deck (z = 2.89, y la versión impresa 2.49 con gasto 60 €) repetida capa a capa hasta ŷ = 0.555."
Backprop — el gradiente exacto
Slides: Backprop · Activación
"La regla de la cadena reparte la culpa: δ baja capa a capa (W⊤δ ⊙ σ′) y cada peso recibe error-del-destino × activación-del-origen (−0.534, −0.668, −0.267…). La activación decide si esa señal sobrevive al viaje: ReLU + He la conservan; la sigmoide profunda la mata."
Optimizadores — bajar el valle
Slides: Superficie · Optimizad. · Mini-batch
"El valle real está mal condicionado: SGD vive atrapado entre divergir (η > 2/λmáx) y no avanzar. Momentum amortigua, Adam normaliza por coordenada y el mini-batch hace cada paso barato con ruido que cae como 1/√B. Receta del deck: AdamW, η = 10&supmin;³, B = 32–128."
Caso churn — del modelo a los euros
Slides: Churn telco
"El pipeline entero sobre 400 clientes: entrenar la neurona por gradiente, leer probabilidades calibradas y decidir con la economía del problema: τ* ≈ cr/(s·LTV), no 0.5. El accuracy puede mentir; el ahorro en euros, no."

En una frase. Hoy has abierto la caja negra: una red es una composición de sumas ponderadas y activaciones, su aprendizaje es la regla de la cadena más un descenso bien dosificado, y su valor se mide en la moneda del negocio, no en porcentaje de aciertos.

Garrido-Merchán — ecgarrido@comillas.edu — Deep Learning para Business Analytics — Día 02 · Fundamentos: la neurona, backprop y optimizadores