Calc-07 — Multivariable chain rule & backpropagation

Why this matters for ML

Este es el módulo más importante de todo el pilar de cálculo. Backpropagation — el algoritmo con el que se entrena toda red neuronal — no es más que el chain rule multivariable aplicado con eficiencia sobre un grafo de cómputo. Cuando lo derives a mano una vez, el deep learning deja de ser una caja negra para siempre.

Concepts covered

• Chain rule multivariable
• Computational graphs
• Forward pass y backward pass
• Backpropagation derivada desde el chain rule
• Reverse-mode automatic differentiation (idea)

Intuition first

🎬 3Blue1Brown Neural Networks cap. 3 ("What is backpropagation really doing?") y cap. 4 ("Backpropagation calculus"). Es, literalmente, este módulo en video. Míralo dos veces.

Theory & key results

Chain rule multivariable: si $z$ depende de variables intermedias $u_1,\dots,u_k$ que a su vez dependen de $t$: $$\frac{dz}{dt} = \sum_{i=1}^{k}\frac{\partial z}{\partial u_i}\frac{du_i}{dt}.$$ En forma matricial es producto de Jacobians (Calc-06): para $\mathbf{z}=f(\mathbf{y})$, $\mathbf{y}=g(\mathbf{x})$, $$J_{\mathbf{z}/\mathbf{x}} = J_{\mathbf{z}/\mathbf{y}}; J_{\mathbf{y}/\mathbf{x}}.$$

Computational graph: representa un cálculo como un grafo de operaciones. Ejemplo (una neurona con loss): $$x \xrightarrow{\ \cdot w\ } a=wx \xrightarrow{\ +b\ } z=a+b \xrightarrow{\ \sigma\ } \hat y=\sigma(z) \xrightarrow{\ \text{loss}\ } L=(\hat y - y)^2.$$

Forward pass: calcula los valores de izquierda a derecha (obtienes $\hat y$ y $L$).

Backward pass (backprop): calcula las derivadas de $L$ respecto a cada parámetro, de derecha a izquierda, multiplicando derivadas locales (chain rule). Para el grafo de arriba: $$\frac{\partial L}{\partial \hat y}=2(\hat y - y),\quad \frac{\partial \hat y}{\partial z}=\sigma(z)(1-\sigma(z)),\quad \frac{\partial z}{\partial a}=1,\quad \frac{\partial a}{\partial w}=x.$$ Encadenando: $$\frac{\partial L}{\partial w} = \frac{\partial L}{\partial \hat y}\cdot\frac{\partial \hat y}{\partial z}\cdot\frac{\partial z}{\partial a}\cdot\frac{\partial a}{\partial w} = 2(\hat y - y),\sigma(z)(1-\sigma(z)),x.$$ Y $\frac{\partial L}{\partial b}$ es igual pero con $\frac{\partial a}{\partial b}=1$ en vez de $x$.

Por qué "backward": compartir subresultados. Calcular de atrás hacia adelante reutiliza $\frac{\partial L}{\partial (\text{nodo})}$ una sola vez por nodo → coste lineal en el tamaño del grafo. Eso es reverse-mode autodiff, lo que hacen PyTorch/TensorFlow por ti.

Worked example (numérico, una neurona)

$x=1,\ w=0.5,\ b=0,\ y=1$.

• Forward: $a=0.5$, $z=0.5$, $\hat y=\sigma(0.5)\approx0.622$, $L=(0.622-1)^2\approx0.143$.
• Backward: $\frac{\partial L}{\partial\hat y}=2(0.622-1)=-0.756$; $\sigma'(z)=0.622\cdot0.378\approx0.235$; entonces $\frac{\partial L}{\partial w}=-0.756\cdot0.235\cdot1\cdot x=-0.178$ y $\frac{\partial L}{\partial b}=-0.178$ (con $x=1$ coinciden).
• Un paso de GD ($\eta=0.1$): $w\leftarrow0.5-0.1(-0.178)=0.518$ → la loss baja.

Notebook exercises (by hand)

1. Dibuja el computational graph de $L=(\sigma(wx+b)-y)^2$ y marca cada derivada local.
2. Deriva $\partial L/\partial w$ y $\partial L/\partial b$ del ejercicio 1 con el chain rule.
3. Para $z=f(u,v)$, $u=x^2$, $v=xy$: calcula $\partial z/\partial x$ con la versión de suma del chain rule.
4. Extiende el ejemplo a dos neuronas en serie ($x\to h\to \hat y$) y encuentra $\partial L/\partial w_1$ (la primera capa) — verás aparecer el producto de factores.
5. Explica por qué backprop es más eficiente que calcular cada derivada por separado.
6. ¿Qué le pasa al gradient si muchos factores $\sigma'(z)$ (≤0.25) se multiplican en cadena? (Pista: vanishing gradients.)

Python lab

import numpy as np

def sigmoid(z): return 1/(1+np.exp(-z))

# forward + backward de una neurona, a mano
x, w, b, y = 1.0, 0.5, 0.0, 1.0
a = w*x + b; z = a; yhat = sigmoid(z); L = (yhat - y)**2
# backward
dL_dyhat = 2*(yhat - y)
dyhat_dz = yhat*(1 - yhat)
dL_dw = dL_dyhat * dyhat_dz * x
dL_db = dL_dyhat * dyhat_dz * 1
print("L:", L, " dL/dw:", dL_dw, " dL/db:", dL_db)

# verifica con gradiente numérico
def loss(w, b): return (sigmoid(w*x+b) - y)**2
h = 1e-6
num_w = (loss(w+h,b) - loss(w-h,b)) / (2*h)
print("dL/dw numérico:", num_w, " vs analítico:", dL_dw)   # coinciden

Reto (adelanto del capstone): implementa backprop para una red de 2 capas con varias neuronas usando Jacobians/matrices.

Examen final 📝

Intenta cada nivel antes de abrir las soluciones.

🟡 Medio

1. Con $z=u^2$, $u=3x+1$: calcula $dz/dx$ con el chain rule y evalúa en $x=1$.
2. Con $z=f(u,v)$, $u=x^2$, $v=\sin x$: escribe $dz/dx$ en términos de $\partial z/\partial u$, $\partial z/\partial v$.

🟠 Medio-difícil

3. Para $L=(\sigma(wx+b)-y)^2$ con $x=2, w=0.5, b=0, y=0$: haz forward pass y backward pass y da $\partial L/\partial w$ numérico.
4. Red de dos capas escalares: $h=\sigma(w_1 x)$, $\hat y=w_2 h$, $L=(\hat y-y)^2$. Deriva $\partial L/\partial w_1$ con el chain rule (verás factores multiplicándose capa a capa).

🔴 Difícil

5. Deriva las ecuaciones de backprop para una capa vectorial $\mathbf z=W\mathbf x+\mathbf b$, $\mathbf a=\sigma(\mathbf z)$: expresa $\frac{\partial L}{\partial W}$, $\frac{\partial L}{\partial \mathbf b}$ y $\frac{\partial L}{\partial \mathbf x}$ en términos de $\boldsymbol\delta=\frac{\partial L}{\partial \mathbf z}$ (usa matrix calculus, Calc-09).
6. Explica el problema de vanishing gradients: si una red profunda encadena $n$ capas sigmoid, ¿por qué $\partial L/\partial(\text{peso de la 1ª capa})$ tiende a 0? Estima el orden de magnitud si cada factor $\sigma'\le0.25$ y hay 10 capas, y menciona cómo ReLU mitiga esto.