Lección · Módulo 3 · Cálculo y optimización

Derivadas parciales y gradiente: la brújula de muchas dimensiones

Cuando una función depende de más de una variable, no hay una derivada — hay una por cada variable. Juntas forman un vector llamado gradiente que apunta en la dirección de máxima subida. Negativo del gradiente = cómo bajar al mínimo.

Mate MathPlay · Lección 3.2 · Cálculo y optimización

10 minutosInteractivoVisualCon Python

Idea central: en una función f(x, y) hay dos preguntas: ¿cuánto cambia f si movés solo x? y ¿cuánto cambia si movés solo y? Las dos respuestas son las derivadas parciales. Empaquetadas como vector, forman el gradiente, que apunta exactamente hacia donde f crece más rápido. Esa flecha es la brújula que toda red neuronal usa para aprender.

1 El salto: de una a muchas variables

En la lección anterior, la función dependí>a de una sola variable: f(x). Su derivada era un solo número, la pendiente de la tangente. Eso funciona para problemas chicos: una curva de costo, una variable a optimizar.

En la realidad las funciones interesantes dependen de muchas variables al mismo tiempo:

La recuperación de una planta depende de dosis de colector, pH, granulometrí>a, flujo de aire… varias decenas de variables.
El error de una red neuronal depende de cada uno de sus pesos, que pueden ser millones (o miles de millones, en modelos como GPT-4).
La ley estimada de un yacimiento en un punto depende de las leyes de varios testigos vecinos con distintos pesos.

La buena noticia: la pregunta sigue siendo la misma — ¿hacia dónde moverse para minimizar la función? — pero ahora la respuesta es un vector en lugar de un número.

2 Derivadas parciales: una variable a la vez

El truco es simple: congetá todas las variables menos una, y calculá la derivada habitual. Repetí con cada variable. Lo que sale para cada una es una derivada parcial.

∂f/∂x = derivada de f respecto a x, manteniendo y fijo

∂f/∂y = derivada de f respecto a y, manteniendo x fijo

Por ejemplo, si f(x, y) = x² + 3y²:

∂f/∂x: tratando y como una constante, derivamos x² y obtenemos 2x. El término 3y² es constante y desaparece.
∂f/∂y: tratando x como constante, derivamos 3y² y obtenemos 6y. El término x² es constante y desaparece.

El símbolo ∂ (que se llama "d redonda") es como el d de las derivadas, pero subraya que estamos derivando respecto a una sola variable de varias.

Interpretación geométrica

Si imaginás f(x, y) como una superficie 3D (un terreno con colinas y valles), entonces ∂f/∂x es la pendiente del terreno cuando caminás en dirección del eje X manteniendo y fijo. Es como cortar el terreno con un plano perpendicular al eje Y — la pendiente de la curva que queda es la derivada parcial.

3 El gradiente: empaquetando todo en un vector

El gradiente de f es el vector que junta todas las derivadas parciales:

∇f(x, y) = (∂f/∂x, ∂f/∂y)

En el ejemplo de arriba: ∇f = (2x, 6y). En el punto (1, 2), el gradiente vale (2, 12). Es un vector que en cada punto del plano apunta hacia alguna dirección.

Tres propiedades fundamentales del gradiente:

Dirección de máxima subida: el vector gradiente apunta exactamente hacia donde la función crece más rápido en ese punto. Si seguís la flecha, subis lo más empinado posible.
Magnitud = velocidad de cambio: la longitud del gradiente dice cuán empinada es la subida. Gradiente largo = pendiente fuerte. Gradiente corto = zona casi plana.
Perpendicular a las curvas de nivel: las "curvas de nivel" son las líneas que conectan puntos con el mismo valor de f (como las isobaras en un mapa de presión o las isolineas en un mapa topográfico). El gradiente siempre cruza esas líneas perpendicularmente.

−∇f(x, y) = dirección de máxima bajada

Esa es la fórmula del descenso por gradiente en cualquier dimensión: en cada punto, movéte un poco en dirección contraria al gradiente. Repetí hasta llegar a un mínimo (donde el gradiente vale cero).

4 Tu turno: mové el punto y mirá el gradiente

El mapa de la izquierda es una vista aérea del terreno: las líneas concéntricas son las curvas de nivel (puntos con la misma altura). Cuanto más juntas está>n, más empinado el terreno. La flecha naranja es el gradiente: apunta a la subida máxima. La flecha azul claro es el negativo del gradiente: la dirección de máxima bajada (lo que usa una red neuronal para aprender).

Curvas de nivel: misma altura ∇f: gradiente (sube) Punto: posición actual

Sandbox interactivo

Elegí una función y mové los sliders x, y para deslizar el punto sobre el mapa.

x-1.50

y+1.00

Altura

f(x,y)

3.25

Parcial X

∂f/∂x

-3.00

Parcial Y

∂f/∂y

+2.00

Magnitud

||∇f||

3.61

Tocá "Ir al mínimo (0,0)": en el tazón simple, el gradiente desaparece (magnitud ≈ 0). Tangente plana en todas direcciones — mínimo global.
Tocá "Solo en X" con el tazón: ∂f/∂y = 0 porque y = 0; el gradiente apunta directo hacia +X.
Probá la función "Silla": tiene puntos donde el gradiente vale cero pero no son mínimos — son puntos silla. Subes en una dirección y bajás en la otra.
Tocá "Un paso de descenso" repetidas veces: el punto se mueve hacia abajo del terreno siguiendo −∇f. Es exactamente lo que hace una red neuronal cuando entrena.

5 La regla del descenso por gradiente en alta dimensión

La regla del descenso por gradiente en una variable era:

w_nuevo = w − α · f′(w)

Generalizada a varias variables, la regla es idéntica, solo que ahora los pesos son un vector y la derivada es el gradiente:

w_nuevo = w − α · ∇f(w)

donde w es un vector con todos los pesos al mismo tiempo (puede tener millones de coordenadas), α es la tasa de aprendizaje, y ∇f(w) es el vector gradiente calculado en el punto actual. La operación es coordenada a coordenada: cada peso se actualiza por su propia derivada parcial.

Esto significa que entrenar una red neuronal de mil millones de parámetros se reduce a calcular un gradiente de mil millones de componentes y restarlo. La magia está en cómo se calcula ese gradiente de manera eficiente (backpropagation, lección 3.4), pero conceptualmente es la misma idea que viste con una sola variable.

Por qué importa que sea perpendicular a las curvas de nivel

Si querés minimizar caminando, lo lógico es ir en contra de la subida máxima. Ese es −∇f. Como el gradiente es perpendicular a las curvas de nivel, el descenso siempre cruza las curvas de nivel perpendicularmente — el camino más eficiente para bajar al valle. En el sandbox vas a ver que la flecha celeste siempre es perpendicular a las elipses concéntricas.

6 Caso aplicado: optimización con varias variables

⛏Caso aplicado · condiciones óptimas de flotación

Recuperación como función de pH y dosis

La recuperación metálurgica R(pH, dosis) de una planta de flotación depende de al menos dos variables operacionales. Hay una zona "óptima" donde la recuperación es máxima. Para encontrarla:

Modelar la recuperación como función de pH y dosis usando datos históricos.
Calcular ∂R/∂pH y ∂R/∂dosis.
Igualar el gradiente a cero: resolver el sistema de dos ecuaciones para obtener el punto óptimo (pH*, dosis*).
Verificar con la matriz Hessiana (segundas derivadas) que es un máximo.

Gradiente cero + Hessiana negativa = máximo local de recuperación

Calibrar un modelo de leyes con varios parámetros

Un modelo de estimación de leyes (variograma) tiene varios parámetros: rango, meseta, efecto pepita, anisotropía. Para ajustarlo a los datos, se define un error total (suma de cuadrados entre predicción y observación) y se minimiza por descenso por gradiente:

En cada iteración se calcula el gradiente del error respecto a cada parámetro.
Los parámetros se actualizan en dirección contraria al gradiente.
Se repite hasta que el gradiente es chico — ahí está el mejor ajuste.

Ajuste de variograma = descenso por gradiente en el espacio de parámetros

Despacho óptimo de flota minera

Un sistema de despacho de camiones distribuye n camiones entre m palas. El tiempo total de operación depende de cuántos camiones asignaste a cada pala (x₁, x₂, …, x_m). Con restricciones (suma de camiones = total disponible), el problema se reduce a buscar un punto donde el gradiente del tiempo sea proporcional al gradiente de la restricción (multiplicadores de Lagrange).

Gradiente + restricciones = la base de toda la optimización de operaciones

+ Más parientes del concepto

El gradiente vino con varias herramientas adicionales que toda la maquinaria de optimización moderna usa:

Matriz HessianaVer▾

La generalización de la segunda derivada a varias variables. Es una matriz cuadrada con todas las segundas derivadas parciales: H_ij = ∂²f / ∂x_i∂x_j. Si todos sus valores propios son positivos en un punto crítico, es un mínimo. Si todos son negativos, máximo. Si hay mezcla, punto silla. La Hessiana conecta optimización con todo lo que viste de matrices en el Módulo 2.

Multiplicadores de LagrangeVer▾

El truco para optimizar funciones con restricciones. La idea es que en el óptimo, el gradiente de la función objetivo es paralelo al gradiente de la restricción. El factor de proporción es el "multiplicador de Lagrange" y suele tener una interpretación económica directa (precio sombra, costo marginal).

Derivada direccionalVer▾

Si querés saber cuán empinada es la subida en una dirección cualquiera (no solo X o Y), se calcula con el producto interno entre el gradiente y un vector unitario en esa dirección: D_uf = ∇f · u. La dirección que maximiza este producto es exactamente la dirección del gradiente. Eso prueba formalmente que el gradiente apunta a la subida máxima.

JacobianoVer▾

Cuando una función no toma vectores y devuelve un número, sino que toma vectores y devuelve vectores (como cada capa de una red neuronal), la generalización del gradiente es la matriz Jacobiana: una matriz donde la fila i es el gradiente de la salida i. Es la herramienta clave para entender cómo se propagan errores en backpropagation.

Ver el código en Python: gradientes a mano, automáticos y descenso 2D Click para abrir

Cinco snippets que cubren todos los modos de calcular un gradiente en Python.

1. Gradiente numérico (definición directa):

01_gradiente_numerico.pyPYTHON

import numpy as np

def gradiente_numerico(f, x, h=1e-5):
    """Aproxima el gradiente de f en el punto x (numpy array)."""
    grad = np.zeros_like(x, dtype=float)
    for i in range(len(x)):
        x_mas = x.copy(); x_mas[i] += h
        x_men = x.copy(); x_men[i] -= h
        grad[i] = (f(x_mas) - f(x_men)) / (2 * h)
    return grad

# f(x, y) = x^2 + 3y^2
f = lambda v: v[0]**2 + 3 * v[1]**2

x = np.array([1.0, 2.0])
print(f"∇f(1, 2) = {gradiente_numerico(f, x)}")
# Esperado: [2, 12] (que es exactamente la formula derivada a mano)

2. Gradiente simbólico con sympy:

02_gradiente_simbolico.pyPYTHON

import sympy as sp

x, y = sp.symbols('x y')

# f(x, y) = x^2 + 3*y^2 + 2*x*y - 4*x
f = x**2 + 3*y**2 + 2*x*y - 4*x

df_dx = sp.diff(f, x)
df_dy = sp.diff(f, y)

print(f"∂f/∂x = {df_dx}")
print(f"∂f/∂y = {df_dy}")

# Resolver gradiente = 0 para encontrar puntos criticos
puntos = sp.solve([df_dx, df_dy], [x, y])
print(f"Puntos criticos: {puntos}")

3. Descenso por gradiente 2D:

03_descenso_2d.pyPYTHON

import numpy as np

# Funcion y su gradiente analitico
def f(v):
    return v[0]**2 + 3 * v[1]**2

def grad_f(v):
    return np.array([2 * v[0], 6 * v[1]])

# Descenso desde un punto inicial
x = np.array([2.5, -2.0])
alpha = 0.1

for i in range(25):
    g = grad_f(x)
    x = x - alpha * g
    print(f"Iter {i+1:2d}: x = {x.round(3)}, f(x) = {f(x):.4f}, ||∇f|| = {np.linalg.norm(g):.4f}")

print(f"
Minimo: x = {x.round(4)}, f = {f(x):.6f}")
# Converge a (0, 0), el minimo global del tazon

4. Gradiente automático con autograd:

04_autograd.pyPYTHON

# pip install autograd
import autograd.numpy as anp
from autograd import grad

# Funcion compleja: combinacion lineal, ReLU, suma de cuadrados
def perdida(w):
    # w es un vector de pesos de tamano 5
    z = w[0] + w[1]**2 + anp.sin(w[2]) * w[3] + w[4]**3 / 3
    return z**2

# Calcula el gradiente automaticamente
grad_perdida = grad(perdida)

w = anp.array([1.0, 2.0, 0.5, 1.5, 0.8])
print(f"∇Perdida = {grad_perdida(w)}")
# autograd recorre la funcion y aplica regla de cadena solo.
# Eso es lo que PyTorch hace adentro tambien.

5. Visualizar el camino del descenso:

05_camino_descenso.pyPYTHON

import numpy as np
import matplotlib.pyplot as plt

def f(v):       return v[0]**2 + 3 * v[1]**2
def grad_f(v):  return np.array([2*v[0], 6*v[1]])

# Trayectoria del descenso
camino = [np.array([2.5, -2.0])]
for _ in range(30):
    camino.append(camino[-1] - 0.1 * grad_f(camino[-1]))
camino = np.array(camino)

# Curvas de nivel + camino
X, Y = np.meshgrid(np.linspace(-3, 3, 80), np.linspace(-3, 3, 80))
Z = X**2 + 3*Y**2

plt.contour(X, Y, Z, levels=20, cmap='Blues')
plt.plot(camino[:, 0], camino[:, 1], 'ro-', markersize=4, linewidth=1.5)
plt.title("Camino del descenso por gradiente")
plt.xlabel("x"); plt.ylabel("y")
plt.show()

7 Pregunta de chequeo

El gradiente de una función f(x, y) en un cierto punto vale ∇f = (4, -3). ¿En qué dirección hay que moverse desde ese punto para que f baje lo más rápido posible?

Próxima lección

Ya tenemos el gradiente. Ahora hay que usarlo: descenso por gradiente en acción, con la elección del learning rate, los problemas que aparecen (minimos locales, valles estrechos, oscilaciones) y las variantes modernas (momentum, Adam) que toda librerí>a de IA implementa. Eso es la lección 3.3.

Regístrate al boletín MathPlay

De la idea al laboratorio que funciona: datos, simulación, visualización e IA explicadas con imágenes que se mueven. Te escribo cuando hay algo nuevo que vale la pena compartir.

Sin calendario fijo. Sin spam.

Listo. Te escribo cuando haya algo nuevo.

Mate MathPlay

Matemática visual abierta

MathPlay conecta matemática, programación y visualización para que los conceptos se entiendan jugando, no memorizando. Cada lección se sostiene por sí sola y trae código Python para que pruebes en tu máquina.

Más de MathPlay

▶ YouTube · Tech ☰ Datos · IA aplicada ⚙ Prototipado 3D

← Lección anterior: derivadas Volver al módulo Mate MathPlay