Phase 01 - Lesson 04

Cálculo para Aprendizaje Automático

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

Las derivadas te dicen cuál es el camino cuesta abajo. Eso es todo lo que una red neuronal necesita para aprender.

Tipo: Aprender Lenguaje: Python Requisitos previos: Fase 1, Lecciones 01-03 Tiempo: ~60 minutos

Objetivos de Aprendizaje

• Calcular derivadas numéricas y analíticas para funciones comunes de ML (x^2, sigmoide, entropía cruzada)
• Implementar el descenso de gradiente desde cero para minimizar una función de pérdida en 1D y 2D
• Derivar el gradiente de un modelo de regresión lineal y entrenarlo mediante actualizaciones manuales de pesos
• Explicar la matriz Hessiana, las aproximaciones por series de Taylor y su conexión con los métodos de optimización

El Problema

Tienes una red neuronal con millones de pesos. Cada peso es una perilla. Necesitas averiguar en qué dirección girar cada perilla para que el modelo esté un poco menos equivocado. El cálculo te da esa dirección.

Sin cálculo, entrenar una red neuronal significaría probar cambios aleatorios y esperar lo mejor. Con derivadas, sabes exactamente cómo cada peso afecta el error. Giras cada perilla de la forma correcta, cada vez.

El Concepto

¿Qué es una derivada?

Una derivada mide la tasa de cambio. Para una función y = f(x), la derivada f'(x) te dice: si empujas x una cantidad minúscula, ¿cuánto cambia y?

Geométricamente, la derivada es la pendiente de la recta tangente en un punto.

f(x) = x^2:

En x=2, la pendiente es 4. Si mueves x un poquito a la derecha, y aumenta aproximadamente 4 veces esa cantidad. En x=0, la pendiente es 0. Estás en el fondo del tazón.

La definición formal:

f'(x) = lim   f(x + h) - f(x)
        h->0  -----------------
                     h

En el código, te saltas el límite y usas solo un h muy pequeño. Esa es la derivada numérica.

Derivadas parciales: una variable a la vez

Las funciones reales tienen muchas entradas. La pérdida de una red neuronal depende de miles de pesos. Una derivada parcial mantiene todas las variables constantes excepto una, y luego calcula la derivada respecto a esa única variable.

f(x, y) = x^2 + 3xy + y^2

df/dx = 2x + 3y     (treat y as a constant)
df/dy = 3x + 2y     (treat x as a constant)

Cada derivada parcial responde: si empujo solo este peso, ¿cómo cambia la pérdida?

El gradiente: vector de todas las derivadas parciales

El gradiente reúne cada derivada parcial en un solo vector. Para una función f(x, y, z), el gradiente es:

grad f = [ df/dx, df/dy, df/dz ]

El gradiente apunta en la dirección de mayor ascenso. Para minimizar una función, ve en la dirección opuesta.

Gráfico de contorno de f(x,y) = x^2 + y^2:

La función forma una figura de tazón con círculos concéntricos como líneas de contorno. El mínimo está en (0, 0).

Esto es el descenso de gradiente en una imagen. Calcula el gradiente, négalo, da un paso.

La conexión con la optimización

Entrenar una red neuronal es optimización. Tienes una función de pérdida L(w1, w2, ..., wn) que mide qué tan equivocado está el modelo. Quieres minimizarla.

Gradient descent update rule:

  w_new = w_old - learning_rate * dL/dw

For every weight:
  1. Compute the partial derivative of loss with respect to that weight
  2. Subtract a small multiple of it from the weight
  3. Repeat

La tasa de aprendizaje controla el tamaño del paso. Demasiado grande y te pasas. Demasiado pequeña y avanzas a paso de tortuga.

Paisaje de pérdida (corte 1D):

La función de pérdida L(w) forma una curva con picos y valles a medida que varía el peso w.

El descenso de gradiente sigue la pendiente cuesta abajo. Puede quedar atrapado en mínimos locales, pero en espacios de alta dimensión (millones de pesos) esto rara vez es un problema práctico.

Derivadas numéricas vs analíticas

Hay dos maneras de calcular una derivada.

Analítica: aplicar las reglas del cálculo a mano. Para f(x) = x^2, la derivada es f'(x) = 2x. Exacta. Rápida.

Numérica: aproximar usando la definición. Calcula f(x+h) y f(x-h) para un h minúsculo, luego usa la diferencia.

Numerical (central difference):

f'(x) ~= f(x + h) - f(x - h)
          -----------------------
                  2h

h = 0.0001 works well in practice

Las derivadas numéricas son más lentas pero funcionan para cualquier función. Las derivadas analíticas son rápidas pero requieren que derives la fórmula. Los frameworks de redes neuronales usan un tercer enfoque: la diferenciación automática, que calcula derivadas exactas de forma mecánica. Lo verás en la Fase 3.

Derivadas a mano para funciones simples

Estas son las derivadas que verás una y otra vez en ML.

Function        Derivative       Used in
--------        ----------       -------
f(x) = x^2     f'(x) = 2x      Loss functions (MSE)
f(x) = wx + b  f'(w) = x        Linear layer (gradient w.r.t. weight)
                f'(b) = 1        Linear layer (gradient w.r.t. bias)
                f'(x) = w        Linear layer (gradient w.r.t. input)
f(x) = e^x     f'(x) = e^x     Softmax, attention
f(x) = ln(x)   f'(x) = 1/x     Cross-entropy loss
f(x) = 1/(1+e^-x)  f'(x) = f(x)(1-f(x))   Sigmoid activation

Para f(x) = x^2:

f(x) = x^2    f'(x) = 2x

  x    f(x)   f'(x)   meaning
  -2    4      -4      slope tilts left (decreasing)
  -1    1      -2      slope tilts left (decreasing)
   0    0       0      flat (minimum!)
   1    1       2      slope tilts right (increasing)
   2    4       4      slope tilts right (increasing)

Para f(w) = wx + b con x=3, b=1:

f(w) = 3w + 1    f'(w) = 3

The derivative with respect to w is just x.
If x is big, a small change in w causes a big change in output.

La regla de la cadena

Cuando las funciones se componen, la regla de la cadena te dice cómo diferenciar.

If y = f(g(x)), then dy/dx = f'(g(x)) * g'(x)

Example: y = (3x + 1)^2
  outer: f(u) = u^2       f'(u) = 2u
  inner: g(x) = 3x + 1    g'(x) = 3
  dy/dx = 2(3x + 1) * 3 = 6(3x + 1)

Las redes neuronales son cadenas de funciones: entrada -> lineal -> activación -> lineal -> activación -> pérdida. La backpropagation es la regla de la cadena aplicada repetidamente desde la salida hasta la entrada. Ese es todo el algoritmo.

La Matriz Hessiana

El gradiente te dice la pendiente. La Hessiana te dice la curvatura.

La Hessiana es la matriz de derivadas parciales de segundo orden. Para una función f(x1, x2, ..., xn), la entrada (i, j) de la Hessiana es:

H[i][j] = d^2f / (dx_i * dx_j)

Para una función de 2 variables f(x, y):

H = | d^2f/dx^2    d^2f/dxdy |
    | d^2f/dydx    d^2f/dy^2 |

Lo que la Hessiana te dice en un punto crítico (donde el gradiente = 0):

Ejemplo: f(x, y) = x^2 - y^2 (una función de silla)

df/dx = 2x       df/dy = -2y
d^2f/dx^2 = 2    d^2f/dy^2 = -2    d^2f/dxdy = 0

H = | 2   0 |
    | 0  -2 |

Eigenvalues: 2 and -2 (one positive, one negative)
--> Saddle point at (0, 0)

Compara con f(x, y) = x^2 + y^2 (un tazón):

H = | 2  0 |
    | 0  2 |

Eigenvalues: 2 and 2 (both positive)
--> Local minimum at (0, 0)

Por qué importa la Hessiana en ML:

El método de Newton usa la Hessiana para dar pasos de optimización mejores que el descenso de gradiente. En lugar de solo seguir la pendiente, tiene en cuenta la curvatura:

Newton's update:    w_new = w_old - H^(-1) * gradient
Gradient descent:   w_new = w_old - lr * gradient

El método de Newton converge más rápido porque la Hessiana "reescala" el gradiente -- las direcciones empinadas reciben pasos más pequeños, las direcciones planas reciben pasos más grandes.

El inconveniente: para una red neuronal con N parámetros, la Hessiana es N x N. Un modelo con 1 millon de parámetros necesitaría una matriz de 1 billón de entradas. Por eso usamos aproximaciones.

En la práctica, Adam es el optimizador por defecto para deep learning. Aproxima la información de segundo orden de forma barata rastreando la media y la varianza moviles de los gradientes por parámetro.

Aproximación por Serie de Taylor

Cualquier función suave puede aproximarse localmente por un polinomio:

f(x + h) = f(x) + f'(x)*h + (1/2)*f''(x)*h^2 + (1/6)*f'''(x)*h^3 + ...

Cuántos más términos incluyas, mejor la aproximación -- pero solo cerca del punto x.

Por qué importan las series de Taylor para ML:

• Taylor de primer orden = descenso de gradiente. Cuando usas f(x + h) ~ f(x) + f'(x)*h, estas haciendo una aproximación lineal. El descenso de gradiente minimiza ese modelo lineal para elegir h = -lr * f'(x).

• Taylor de segundo orden = método de Newton. Usando f(x + h) ~ f(x) + f'(x)*h + (1/2)*f''(x)*h^2, obtienes un modelo cuadrático. Minimizarlo da h = -f'(x)/f''(x) -- el paso de Newton.

• Diseño de funciones de pérdida. El MSE y la entropía cruzada son suaves, lo que significa que sus expansiones de Taylor están bien comportadas. Esto no es un accidente. Las perdidas suaves hacen que la optimización sea predecible.

Approximation order    What it captures    Optimization method
-------------------    -----------------   -------------------
0th order (constant)   Just the value      Random search
1st order (linear)     Slope               Gradient descent
2nd order (quadratic)  Curvature           Newton's method
Higher orders          Finer structure     Rarely used in ML

La idea clave: toda optimización basada en gradiente trata realmente de aproximar la función de pérdida localmente y dar un paso hasta el mínimo de esa aproximación.

Integrales en ML

Las derivadas te dicen tasas de cambio. Las integrales calculan acumulaciones -- el área bajo una curva.

En ML, rara vez calculas integrales a mano, pero el concepto está en todas partes:

Probabilidad. Para una variable aleatoria continua con densidad p(x):

P(a < X < b) = integral from a to b of p(x) dx

El área bajo la curva de densidad de probabilidad entre a y b es la probabilidad de caer en ese rango.

Valor esperado. El resultado promedio ponderado por la probabilidad:

E[f(X)] = integral of f(x) * p(x) dx

La pérdida esperada sobre una distribucion de datos es una integral. El entrenamiento minimiza una aproximación empírica de esto.

Divergencia KL. Mide qué tan diferentes son dos distribuciones:

KL(p || q) = integral of p(x) * log(p(x) / q(x)) dx

Se usa en VAE, destilación de conocimiento e inferencia bayesiana.

Constantes de normalización. En la inferencia bayesiana:

p(w | data) = p(data | w) * p(w) / integral of p(data | w) * p(w) dw

El denominador es una integral sobre todos los valores posibles de parámetros. A menudo es intratable, por eso usamos aproximaciones como MCMC e inferencia variacional.

Regla de la Cadena Multivariable en un Grafo de Computación

La regla de la cadena no solo aplica a funciones escalares en línea. En una red neuronal, las variables se ramifican y se fusionan. Así es como fluyen las derivadas a través de un forward pass simple:

graph LR
    x["x (input)"] -->|"*w"| z1["z1 = w*x"]
    z1 -->|"+b"| z2["z2 = w*x + b"]
    z2 -->|"sigmoid"| a["a = sigmoid(z2)"]
    a -->|"loss fn"| L["L = -(y*log(a) + (1-y)*log(1-a))"]

El backward pass calcula los gradientes de derecha a izquierda:

graph RL
    dL["dL/dL = 1"] -->|"dL/da"| da["dL/da = -y/a + (1-y)/(1-a)"]
    da -->|"da/dz2 = a(1-a)"| dz2["dL/dz2 = dL/da * a(1-a)"]
    dz2 -->|"dz2/dw = x"| dw["dL/dw = dL/dz2 * x"]
    dz2 -->|"dz2/db = 1"| db["dL/db = dL/dz2 * 1"]

Cada flecha multiplica por la derivada local. El gradiente de cualquier parámetro es el producto de todas las derivadas locales a lo largo del camino desde la pérdida hasta ese parámetro. Cuando los caminos se ramifican y se fusionan, sumas las contribuciones (regla de la cadena multivariable).

Eso es todo lo que es la backpropagation: la regla de la cadena aplicada sistemáticamente a través de un grafo de computación, desde la salida hasta las entradas.

La matriz Jacobiana

Cuando una función mapea un vector a un vector (como una capa de red neuronal), su derivada es una matriz. La Jacobiana contiene todas las derivadas parciales de cada salida respecto a cada entrada.

Para f: R^n -> R^m, la Jacobiana J es una matriz m x n:

No vas a calcular Jacobianas a mano para redes neuronales. PyTorch se encarga de eso. Pero saber que existe ayuda a entender los formatos en la backpropagation: si una capa mapea R^n a R^m, su Jacobiana es m x n. El gradiente fluye hacia atras a través de la transpuesta de esta matriz.

Por qué esto importa para las redes neuronales

Cada peso en una red neuronal recibe un gradiente. El gradiente te dice cómo ajustar ese peso para reducir la pérdida.

graph LR
    subgraph Forward["Forward Pass"]
        I["input"] --> W1["W1"] --> R["relu"] --> W2["W2"] --> S["softmax"] --> L["loss"]
    end

graph RL
    subgraph Backward["Backward Pass"]
        dL["dL/dloss"] --> dW2["dL/dW2"] --> d2["..."] --> dW1["dL/dW1"]
    end

Cada actualización de peso:

• W1 = W1 - lr * dL/dW1
• W2 = W2 - lr * dL/dW2

El forward pass calcula la predicción y la pérdida. El backward pass calcula el gradiente de la pérdida respecto a cada peso. Luego cada peso da un pequeño paso cuesta abajo. Repite por millones de pasos. Eso es deep learning.

Construye

Paso 1: Derivada numérica desde cero

def numerical_derivative(f, x, h=1e-7):
    return (f(x + h) - f(x - h)) / (2 * h)

def f(x):
    return x ** 2

for x in [-2, -1, 0, 1, 2]:
    numerical = numerical_derivative(f, x)
    analytical = 2 * x
    print(f"x={x:2d}  f'(x) numerical={numerical:.6f}  analytical={analytical:.1f}")

La derivada numérica coincide con la analítica hasta muchos decimales.

Paso 2: Derivadas parciales y gradientes

def numerical_gradient(f, point, h=1e-7):
    gradient = []
    for i in range(len(point)):
        point_plus = list(point)
        point_minus = list(point)
        point_plus[i] += h
        point_minus[i] -= h
        partial = (f(point_plus) - f(point_minus)) / (2 * h)
        gradient.append(partial)
    return gradient

def f_multi(point):
    x, y = point
    return x**2 + 3*x*y + y**2

grad = numerical_gradient(f_multi, [1.0, 2.0])
print(f"Numerical gradient at (1,2): {[f'{g:.4f}' for g in grad]}")
print(f"Analytical gradient at (1,2): [2*1+3*2, 3*1+2*2] = [{2*1+3*2}, {3*1+2*2}]")

Paso 3: Descenso de gradiente para encontrar el mínimo de f(x) = x^2

x = 5.0
lr = 0.1
for step in range(20):
    grad = 2 * x
    x = x - lr * grad
    print(f"step {step:2d}  x={x:8.4f}  f(x)={x**2:10.6f}")

Empezando en x=5, cada paso se acerca a x=0 (el mínimo).

Paso 4: Descenso de gradiente en una función 2D

def f_2d(point):
    x, y = point
    return x**2 + y**2

point = [4.0, 3.0]
lr = 0.1
for step in range(30):
    grad = numerical_gradient(f_2d, point)
    point = [p - lr * g for p, g in zip(point, grad)]
    loss = f_2d(point)
    if step % 5 == 0 or step == 29:
        print(f"step {step:2d}  point=({point[0]:7.4f}, {point[1]:7.4f})  f={loss:.6f}")

Paso 5: Comparando derivadas numéricas y analíticas

import math

test_functions = [
    ("x^2",      lambda x: x**2,          lambda x: 2*x),
    ("x^3",      lambda x: x**3,          lambda x: 3*x**2),
    ("sin(x)",   lambda x: math.sin(x),   lambda x: math.cos(x)),
    ("e^x",      lambda x: math.exp(x),   lambda x: math.exp(x)),
    ("1/x",      lambda x: 1/x,           lambda x: -1/x**2),
]

x = 2.0
print(f"{'Function':<12} {'Numerical':>12} {'Analytical':>12} {'Error':>12}")
print("-" * 50)
for name, f, df in test_functions:
    num = numerical_derivative(f, x)
    ana = df(x)
    err = abs(num - ana)
    print(f"{name:<12} {num:12.6f} {ana:12.6f} {err:12.2e}")

Paso 6: Calculando la Hessiana numéricamente

def hessian_2d(f, x, y, h=1e-5):
    fxx = (f(x + h, y) - 2 * f(x, y) + f(x - h, y)) / (h ** 2)
    fyy = (f(x, y + h) - 2 * f(x, y) + f(x, y - h)) / (h ** 2)
    fxy = (f(x + h, y + h) - f(x + h, y - h) - f(x - h, y + h) + f(x - h, y - h)) / (4 * h ** 2)
    return [[fxx, fxy], [fxy, fyy]]

def saddle(x, y):
    return x ** 2 - y ** 2

def bowl(x, y):
    return x ** 2 + y ** 2

H_saddle = hessian_2d(saddle, 0.0, 0.0)
H_bowl = hessian_2d(bowl, 0.0, 0.0)
print(f"Saddle Hessian: {H_saddle}")  # [[2, 0], [0, -2]] -- mixed signs
print(f"Bowl Hessian:   {H_bowl}")    # [[2, 0], [0, 2]]  -- both positive

La Hessiana de la función de silla tiene autovalores 2 y -2 (signos mixtos, lo que confirma un punto de silla). El tazón tiene autovalores 2 y 2 (ambos positivos, lo que confirma un mínimo).

Paso 7: Aproximación de Taylor en accion

import math

def taylor_approx(f, f_prime, f_double_prime, x0, h, order=2):
    result = f(x0)
    if order >= 1:
        result += f_prime(x0) * h
    if order >= 2:
        result += 0.5 * f_double_prime(x0) * h ** 2
    return result

x0 = 0.0
for h in [0.1, 0.5, 1.0, 2.0]:
    true_val = math.sin(h)
    t1 = taylor_approx(math.sin, math.cos, lambda x: -math.sin(x), x0, h, order=1)
    t2 = taylor_approx(math.sin, math.cos, lambda x: -math.sin(x), x0, h, order=2)
    print(f"h={h:.1f}  sin(h)={true_val:.4f}  order1={t1:.4f}  order2={t2:.4f}")

Cerca de x0=0, sin(x) ~ x (Taylor de primer orden). La aproximación es excelente para h pequeño, pero se degrada para h grande. Por eso el descenso de gradiente funciona mejor con tasas de aprendizaje pequeñas -- cada paso asume que la aproximación lineal es precisa.

Paso 8: Por qué esto importa para una red neuronal

import random

random.seed(42)

w = random.gauss(0, 1)
b = random.gauss(0, 1)
lr = 0.01

xs = [1.0, 2.0, 3.0, 4.0, 5.0]
ys = [3.0, 5.0, 7.0, 9.0, 11.0]

for epoch in range(200):
    total_loss = 0
    dw = 0
    db = 0
    for x, y in zip(xs, ys):
        pred = w * x + b
        error = pred - y
        total_loss += error ** 2
        dw += 2 * error * x
        db += 2 * error
    dw /= len(xs)
    db /= len(xs)
    total_loss /= len(xs)
    w -= lr * dw
    b -= lr * db
    if epoch % 40 == 0 or epoch == 199:
        print(f"epoch {epoch:3d}  w={w:.4f}  b={b:.4f}  loss={total_loss:.6f}")

print(f"\nLearned: y = {w:.2f}x + {b:.2f}")
print(f"Actual:  y = 2x + 1")

Todo bucle de entrenamiento basado en gradiente sigue este patrón: predecir, calcular la pérdida, calcular los gradientes, actualizar los pesos.

Usalo

Con NumPy, las mismas operaciones son más rápidas y concisas:

import numpy as np

x = np.array([1, 2, 3, 4, 5], dtype=float)
y = np.array([3, 5, 7, 9, 11], dtype=float)

w, b = np.random.randn(), np.random.randn()
lr = 0.01

for epoch in range(200):
    pred = w * x + b
    error = pred - y
    loss = np.mean(error ** 2)
    dw = np.mean(2 * error * x)
    db = np.mean(2 * error)
    w -= lr * dw
    b -= lr * db

print(f"Learned: y = {w:.2f}x + {b:.2f}")

Acabas de construir el descenso de gradiente desde cero. PyTorch automatiza el cálculo del gradiente, pero el bucle de actualización es idéntico.

Ejercicios

1. Implementa numerical_second_derivative(f, x) usando numerical_derivative llamado dos veces. Verifica que la segunda derivada de x^3 en x=2 es 12.
2. Usa el descenso de gradiente para encontrar el mínimo de f(x, y) = (x - 3)^2 + (y + 1)^2. Empieza desde (0, 0). La respuesta debería converger a (3, -1).
3. Agrega momentum al bucle de descenso de gradiente: mantén un vector de velocidad que acumule gradientes pasados. Compara la velocidad de convergencia con y sin momentum en f(x) = x^4 - 3x^2.

Términos Clave

Lectura Adicional

• 3Blue1Brown: Essence of Calculus - intuición visual para derivadas, integrales y la regla de la cadena
• Stanford CS231n: Backpropagation - como fluyen los gradientes a través de las capas de redes neuronales