Derivada

$f'(a)$ es la tasa de cambio instantánea de $f$ en $a$: la pendiente de la recta tangente a la gráfica, definida como el límite de las pendientes de las rectas secantes.

Las tasas medias son fáciles: distancia entre tiempo. Pero «¿a qué velocidad va el coche ahora?» pide una tasa sobre un intervalo de longitud cero: $0/0$. Newton la necesitaba para la mecánica y Leibniz para las tangentes; la derivada es la respuesta común, hecha rigurosa con el límite. Resuelve el problema de cuantificar el cambio local.

Geométricamente: si haces zoom sobre una curva suave parece una recta; la derivada es la pendiente de esa recta. Físicamente: si $s(t)$ es la posición, $s'(t)$ es la velocidad y $s''(t)$ la aceleración. Como sensibilidad: $f(a + h) \approx f(a) + f'(a)\,h$: la salida se mueve $f'(a)$ veces lo que se mueve la entrada, para empujones pequeños. Esa última lectura es la que usa el aprendizaje automático: la derivada de la pérdida respecto de un peso dice hacia dónde mover el peso.

f(x)
 │          ╱  tangent: slope = f'(a)
 │        ●
 │      ╱ ╱
 │_____╱_╱________
         a        x

cuando el límite existe (entonces $f$ es derivable en $a$). La función $f' : x \mapsto f'(x)$ es la derivada de $f$; Leibniz la escribe $\frac{\dd f}{\dd x}$.

Hay tres formas, y el software usa las tres:

1. Simbólicamente, aplicando reglas (potencia, producto, cociente, cadena) a una fórmula: lo que hace un CAS.
2. Numéricamente, con una diferencia finita $\frac{f(a+h) - f(a - h)}{2h}$: fácil pero inexacta (error de truncamiento si $h$ es grande, de redondeo si es diminuto).
3. Automáticamente: propagando derivadas exactas por cada operación elemental de un programa; es la diferenciación automática, el motor de PyTorch y JAX.

$f(x) = x^2$ en $a = 3$: $\frac{(3 + h)^2 - 9}{h} = \frac{6h + h^2}{h} = 6 + h \to 6$. Así que $f'(3) = 6$ y la tangente es $y = 9 + 6(x - 3)$. En código, la diferencia centrada con $h = 10^{-5}$ da $6{,}000000000039…$, mientras que con $h = 10^{-15}$ da basura: la resta cancela todas las cifras.

Optimizar es seguir las derivadas cuesta abajo; simular es integrarlas hacia delante en el tiempo; renderizar necesita derivadas para orientar las superficies; controlar las usa para anticiparse. El deep learning moderno es, en su núcleo computacional, una máquina extremadamente eficiente de calcular derivadas de un número (la pérdida) respecto de miles de millones de entradas (los pesos).