Llevamos dos lecciones aplazando la gran pregunta: ¿cómo aprende sus pesos una red con capas ocultas? La regla del perceptrón no sirve (nadie le dice a una neurona oculta cuál era su salida "correcta") y en la lección anterior preparamos el ingrediente que faltaba: activaciones con derivada útil. En esta lección cerramos el círculo. Primero formalizaremos el forward pass (propagación hacia adelante) como una cadena de multiplicaciones matriciales, retomando nuestra red 3-4-2-1 de 29 parámetros. Después construiremos, de forma accesible, la noción de gradiente y la regla de la cadena, y con ellas entenderemos backpropagation: el algoritmo de 1986 que reparte la culpa del error entre todas las capas. Lo trazaremos a mano con un ejemplo numérico pequeño, veremos por qué de esta mecánica nacen los problemas de vanishing y exploding gradients, y terminaremos entrenando en numpy, desde cero, una red de 2 capas sobre datos ficticios de TecnoMarket.

1. Forward pass con matrices: la red 3-4-2-1 en acción
2. El gradiente: la brújula del error
3. La regla de la cadena, contada sin dolor
4. Backpropagation: un ejemplo numérico trazado a mano
5. Vanishing y exploding gradients
6. Implementación completa en numpy: red de 2 capas para TecnoMarket

El forward pass es el recorrido de los datos desde la entrada hasta la salida. Ya lo hicimos a pequeña escala con el MLP de XOR; ahora lo escribimos en general. Para una capa con matriz de pesos $W$ (una columna por neurona), sesgos $b$ y activación $f$:

$$z = xW + b \qquad a = f(z)$$

donde $z$ es la pre-activación (la suma ponderada de cada neurona) y $a$ la activación (lo que sale hacia la capa siguiente). Una red entera es simplemente esta operación repetida capa a capa. Recuperemos la red 3-4-2-1 que contamos a mano en el módulo 1 (29 parámetros: 16 + 10 + 3) y démosle vida:

Tres observaciones clave:

• Las formas encajan como fichas de dominó: (1,3)·(3,4) → (1,4); (1,4)·(4,2) → (1,2); (1,2)·(2,1) → (1,1). Verificar .shape en cada paso es el mejor detector de errores.
• Procesar un batch es gratis: si x tiene forma (32, 3) —32 pedidos a la vez—, el mismo código devuelve (32, 1) sin cambiar una línea. Esta es la razón práctica de organizar los datos en batches (vocabulario de 01-04) y de que las GPU brillen aquí.
• La salida con pesos aleatorios ronda 0.5: la red aún es una moneda al aire. Entrenar consiste en mover esos 29 parámetros hasta que las salidas coincidan con las etiquetas.

Para entrenar necesitamos medir el error con un número. Usaremos por ahora el error cuadrático $L = (\hat{y} - y)^2$ (las funciones de pérdida en detalle son el tema de la próxima lección; con esta nos basta).

La pregunta central del aprendizaje es: si muevo un peso concreto $w$ un poquito, ¿el error sube o baja, y cuánto? La respuesta es la derivada parcial $\frac{\partial L}{\partial w}$. El vector con todas esas derivadas —una por parámetro— es el gradiente, y apunta en la dirección en que el error crece más deprisa. Por tanto, para reducir el error caminamos en dirección contraria:

$$w \leftarrow w - \eta \frac{\partial L}{\partial w}$$

Esto es el descenso de gradiente, y es la versión matemática exacta de la analogía del grifo de la ducha: la derivada dice hacia dónde girar (¿está saliendo demasiado caliente o demasiado fría?) y $\eta$ (la tasa de aprendizaje) cuánto girar cada vez. Compárala con la regla del perceptrón de 02-01: aquella era un caso particular rígido; esta funciona para cualquier red derivable.

El problema práctico: nuestra pequeña red 3-4-2-1 tiene 29 derivadas que calcular, y una red real tiene millones. Calcular cada una por separado sería inviable. Backpropagation es, simplemente, la manera eficiente de calcularlas todas de una pasada, reutilizando cálculos. Y su motor es la regla de la cadena.

Piensa en una cadena de causas y efectos dentro de la red:

el peso $w_1$ afecta a la pre-activación $z_1$, que afecta a la activación $h$, que afecta a la salida $\hat{y}$, que afecta al error $L$.

La regla de la cadena dice que el efecto total de $w_1$ sobre $L$ es el producto de los efectos de cada eslabón:

$$\frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial z_2} \cdot \frac{\partial z_2}{\partial h} \cdot \frac{\partial h}{\partial z_1} \cdot \frac{\partial z_1}{\partial w_1}$$

Una analogía TecnoMarket: si el departamento de compras negocia mal un precio (causa), el coste del producto sube, el margen baja, el beneficio trimestral cae. ¿Cuánta culpa tiene compras del resultado trimestral? La culpa se propaga multiplicándose eslabón a eslabón por la cadena. Backpropagation hace exactamente eso: empieza por el error final y va repartiendo culpa hacia atrás, capa por capa — de ahí el nombre, propagación hacia atrás. Y es eficiente porque los primeros factores de la cadena (los cercanos a la salida) se calculan una vez y se reutilizan para todos los pesos anteriores.

Solo necesitas tres derivadas elementales, todas ya conocidas:

Vamos a hacer una iteración completa, con números, sobre la red más pequeña posible con capa oculta: 1 entrada → 1 neurona oculta (sigmoide) → 1 salida (sigmoide). Datos: entrada $x = 1.0$, etiqueta $y = 1$ (es fraude). Pesos iniciales: $w_1 = 0.6$, $b_1 = 0$, $w_2 = 0.4$, $b_2 = 0$. Tasa de aprendizaje $\eta = 0.5$.

Forward pass (guardamos todos los valores intermedios: los necesitaremos a la vuelta):

La red dice "56 % de probabilidad de fraude" cuando debería decir casi 100 %. Repartamos la culpa.

Backward pass, de la salida hacia la entrada:

1. Culpa de la salida: $\frac{\partial L}{\partial \hat{y}} = 2(\hat{y}-y) = 2(0.564-1) = -0.872$ (negativa: hay que subir $\hat{y}$).
2. Atravesamos la sigmoide de salida: $\frac{\partial \hat{y}}{\partial z_2} = \hat{y}(1-\hat{y}) = 0.564 \times 0.436 = 0.246$. Acumulado: $\delta_2 = -0.872 \times 0.246 = -0.214$.
3. Culpas de los parámetros de la capa 2: $\frac{\partial L}{\partial w_2} = \delta_2 \cdot h = -0.214 \times 0.646 = -0.139$; $\frac{\partial L}{\partial b_2} = \delta_2 = -0.214$.
4. La culpa que baja hacia la capa oculta viaja por el peso: $\frac{\partial L}{\partial h} = \delta_2 \cdot w_2 = -0.214 \times 0.4 = -0.086$.
5. Atravesamos la sigmoide oculta: $\frac{\partial h}{\partial z_1} = h(1-h) = 0.646 \times 0.354 = 0.229$. Acumulado: $\delta_1 = -0.086 \times 0.229 = -0.020$.
6. Culpas de la capa 1: $\frac{\partial L}{\partial w_1} = \delta_1 \cdot x = -0.020$; $\frac{\partial L}{\partial b_1} = \delta_1 = -0.020$.

Actualización ($w \leftarrow w - \eta \cdot \text{gradiente}$):

$$w_2 = 0.4 - 0.5(-0.139) = 0.470 \qquad b_2 = 0 - 0.5(-0.214) = 0.107$$ $$w_1 = 0.6 - 0.5(-0.020) = 0.610 \qquad b_1 = 0 - 0.5(-0.020) = 0.010$$

Comprobación: repitiendo el forward con los pesos nuevos, $\hat{y}$ sube de $0.564$ a $\approx 0.594$ y la pérdida baja de $0.190$ a $\approx 0.165$. La red ha aprendido un poquito. Repetir esto miles de veces (sobre muchos ejemplos) es entrenar.

Fíjate en un detalle revelador del paso 3 frente al paso 6: el gradiente de $w_2$ ($-0.139$) es unas 7 veces mayor que el de $w_1$ ($-0.020$). La capa más lejana de la salida recibe menos señal de corrección. Ese detalle es la puerta del siguiente apartado.

Cada vez que la culpa retrocede una capa, se multiplica por dos cosas: la derivada de la activación y los pesos. En nuestro trazado, atravesar cada sigmoide multiplicó la señal por ~0.23–0.25. Recuerda de la lección anterior que la derivada de la sigmoide nunca supera 0.25. Entonces, en una red de 10 capas sigmoides:

$$0.25^{10} \approx 0.00000095$$

La culpa que llega a las primeras capas es prácticamente cero: no aprenden. Es el vanishing gradient (desvanecimiento del gradiente), y es la razón histórica de que durante los 90 fuera casi imposible entrenar redes profundas, y una de las razones del triunfo de ReLU (su derivada es 1 en la zona positiva: la señal no se encoge al atravesarla).

El fenómeno inverso también existe: si los pesos son grandes (mayores que 1 en magnitud), la señal se amplifica en cada capa y los gradientes se disparan a valores enormes — exploding gradient — produciendo actualizaciones gigantes que destrozan el entrenamiento (verás pérdidas que saltan a nan). Es especialmente típico de las redes recurrentes, donde la "profundidad" es la longitud de la secuencia (lo retomaremos en el módulo 4), y las técnicas modernas de mitigación se tratan en el módulo 5.

Juntemos todo: una red 3-8-1 (3 entradas, 8 ocultas con sigmoide, 1 salida sigmoide) entrenada con descenso de gradiente para estimar la probabilidad de fraude de un pedido. Es el salto de calidad respecto al perceptrón de 02-01: entradas continuas, salida con matices y capas ocultas entrenadas de verdad.

Primero, datos ficticios de TecnoMarket generados sintéticamente (400 pedidos):

Ahora la red. Todo el backward pass es la versión matricial exacta de los 6 pasos que trazamos a mano:

Salida típica:

De moneda al aire (52 %) a un clasificador decente (94 %), sin que nadie programara la regla de riesgo: la red la ha extraído de los datos vía forward + backward + actualización. Probémosla como haría el equipo antifraude:

Las correspondencias código ↔ trazado a mano merecen una segunda lectura: h.T @ delta2 es "la culpa de un peso es la señal que le llegó por la culpa de su neurona", sumada sobre los 400 ejemplos del batch; delta2 @ W2.T es "la culpa baja hacia la capa anterior viajando por los pesos". Si entiendes esas dos líneas, entiendes backpropagation.

• No guardar los valores intermedios del forward. El backward necesita h, y_hat, etc. Si los recalculas o los pierdes, o el código se complica o se vuelve lento. Estructura siempre: forward guarda → backward consume.
• Inicializar todos los pesos a cero. En el perceptrón funcionaba; con capas ocultas es fatal: todas las neuronas de una capa reciben el mismo gradiente, aprenden lo mismo y la capa se comporta como una sola neurona (el problema de la simetría). Inicializa con valores aleatorios pequeños.
• Confundir el signo de la actualización. Es $w \mathrel{-}= \eta \cdot dW$ (restar: descender). Un += accidental hace que la pérdida suba y es un despiste sorprendentemente frecuente.
• Errores de dimensiones en el backward. Regla de oro: el gradiente dW debe tener exactamente la misma forma que W. Comprueba dW1.shape == W1.shape como test rápido.
• Pérdida que se vuelve nan. Casi siempre exploding gradient o tasa de aprendizaje demasiado alta. Baja $\eta$ un orden de magnitud y revisa la inicialización.
• Verificar el gradiente numéricamente cuando dudes. Aproxima $\frac{\partial L}{\partial w} \approx \frac{L(w+\epsilon) - L(w-\epsilon)}{2\epsilon}$ con $\epsilon = 10^{-5}$ para un peso concreto y compáralo con tu backward. Si no coinciden en varias cifras, hay un bug en el backward.

1. Segunda iteración a mano. Continúa el ejemplo trazado a mano: con los pesos actualizados ($w_1=0.610$, $b_1=0.010$, $w_2=0.470$, $b_2=0.107$), haz el forward completo y calcula la nueva pérdida. Comprueba que ha bajado respecto a 0.190.
2. Sentir el vanishing gradient. En la red numpy de TecnoMarket, cambia la arquitectura a 4 capas ocultas sigmoides de 8 neuronas (en lugar de 1) y entrena con los mismos hiperparámetros. Imprime en la época 0 la magnitud media de los gradientes de la primera y de la última capa oculta (np.abs(dW).mean()). ¿Cuántas veces más pequeño es el de la primera capa? ¿Qué pasa con la velocidad de aprendizaje?
3. Tasa de aprendizaje extrema. Vuelve a la red 3-8-1 original y entrena con eta = 20. Describe qué observas en la pérdida y explícalo con el vocabulario de esta lección. ¿Y con eta = 0.001?

Ejercicio 1. Forward con los pesos nuevos: $z_1 = 0.610 \times 1.0 + 0.010 = 0.620$; $h = \sigma(0.620) = 0.650$; $z_2 = 0.470 \times 0.650 + 0.107 = 0.413$; $\hat{y} = \sigma(0.413) = 0.602$; $L = (0.602 - 1)^2 = 0.158$. La pérdida baja de 0.190 a ≈0.158 (los decimales exactos pueden variar levemente según el redondeo que arrastres): el descenso de gradiente ha funcionado.

Ejercicio 2. Al apilar 4 capas sigmoides, en la época 0 el gradiente medio de la primera capa suele ser entre 20 y 100 veces menor que el de la última (cada sigmoide atravesada multiplica la señal por ≤ 0.25, más el efecto de los pesos pequeños). El entrenamiento se vuelve mucho más lento y la pérdida puede quedarse estancada cerca de su valor inicial durante cientos de épocas: estás viendo el vanishing gradient en vivo. Sustituir las sigmoides ocultas por ReLU (y su derivada, (z > 0).astype(float)) mejora la situación notablemente.

Ejercicio 3. Con eta = 20 la pérdida oscila salvajemente o crece hasta estabilizarse en un valor malo (o directamente aparece nan si los gradientes explotan): cada actualización es un giro de grifo tan grande que saltamos de "helada" a "hirviendo" sin pasar por el punto bueno. Con eta = 0.001 la pérdida baja de forma monótona pero lentísima: tras 3000 épocas el acierto apenas ha mejorado. La tasa de aprendizaje es un compromiso; en la próxima lección veremos técnicas (y optimizadores) que lo gestionan mejor que un valor fijo.

Ya tienes el corazón del deep learning completo: el forward pass convierte entradas en predicciones mediante multiplicaciones matriciales encadenadas; la pérdida resume el error en un número; el gradiente dice hacia dónde mover cada parámetro; la regla de la cadena permite calcularlo capa a capa repartiendo la culpa hacia atrás — eso es backpropagation, el algoritmo que en 1986 sacó a las redes de su primer invierno; y el descenso de gradiente aplica la corrección, giro suave de grifo a giro suave de grifo. Lo has visto en fórmulas, trazado a mano número a número, y funcionando en numpy sobre pedidos de TecnoMarket. También has visto que la propia mecánica multiplicativa del backward engendra sus patologías: gradientes que se desvanecen o explotan.

En nuestro entrenamiento hemos usado la pérdida y el optimizador más simples posibles: error cuadrático y descenso de gradiente puro sobre todos los datos a la vez. La próxima lección examina esas dos elecciones con lupa: qué funciones de pérdida existen y cuál corresponde a cada problema, y qué optimizadores (mini-batch, momentum, RMSprop, Adam) hacen que el descenso sea más rápido y estable. Con eso tendrás todas las piezas para montar tu primera red completa en Keras al final del módulo.