Regla de la cadena -- la técnica de descomposición para derivar funciones compuestas

La regla de la cadena es el alma matemática del algoritmo de retropropagación.Derivada externa × derivada interna, transmitida capa por capa.


Explicación del concepto

Regla de la cadena univariada

Si y = g(x), z = f(y), entonces:

\[ \frac{dz}{dx} = \frac{dz}{dy} \cdot \frac{dy}{dx} \]

Retropropagación = aplicación inversa de la regla de la cadena a lo largo del grafo de cálculo

x
y=g(x)
∂y/∂x
z=f(y)
∂z/∂y
L
∂L/∂z

Durante la retropropagación, el gradientese transmite capa por capa desde la salida hacia la entrada: «gradiente local» de cada capa × «gradiente transmitido desde aguas arriba» = gradiente de los parámetros de esa capa con respecto a la pérdida.


Ejemplo de la vida real

Acelerador → consumo de combustible

El consumo de combustible depende de la velocidad del vehículo, y la velocidad depende de la profundidad del acelerador.

«¿Cuánto aumenta el consumo si piso un poco más el acelerador?» = (tasa de cambio del consumo respecto a la velocidad) × (tasa de cambio de la velocidad respecto al acelerador).

Esto es la regla de la cadena:Transmitir los cambios capa por capa y multiplicarlos para obtener el efecto total.。


Práctica con Python

Ejemplo

import sympy as sp

x = sp.Symbol('x')
# f(g(x)): sin(x^2), capa externa sin, capa interna x^2
d_direct = sp.diff(sp.sin(x**2), x)
d_chain = sp.cos(x**2) * 2*x
print(f"Derivada directa: {d_direct}")
print(f"Regla de la cadena: cos(x^2)·2x = {d_chain}")
print(f"Coinciden: {sp.simplify(d_direct-d_chain)==0}")

# Retropropagación en una red de dos capas
w, xi, yi = sp.symbols('w x_i y_i')
a = sp.Symbol('a')            # Variables intermedias definidas por separado como símbolos
a_expr = w * xi               # Expresión concreta de a en función de w
loss = (a - yi)**2            # loss definida como función del símbolo a

dL_da = sp.diff(loss, a)                      # ∂L/∂a
da_dw = sp.diff(a_expr, w)                    # ∂a/∂w
dL_dw_chain = dL_da.subs(a, a_expr) * da_dw   # Regla de la cadena: sustituir a=w*x_i y multiplicar

loss_direct = loss.subs(a, a_expr)            # Expandir loss completamente como función de w
dL_dw_direct = sp.diff(loss_direct, w)

print(f"\n"Regla de la cadena ∂L/∂w: {sp.simplify(dL_dw_chain)}")
print(f"Directa ∂L/∂w: {sp.simplify(dL_dw_direct)}")
print(f"Coinciden: {sp.simplify(dL_dw_chain-dL_dw_direct)==0}")

Salida:

直接求导: 2*x*cos(x**2)
链式法则: cos(x^2)·2x = 2*x*cos(x**2)
一致: True

链式 ∂L/∂w: 2*x_i*(w*x_i - y_i)
直接 ∂L/∂w: 2*x_i*(w*x_i - y_i)
一致: True

Escenarios de aplicación en IA

Retropropagación = aplicación sistemática de la regla de la cadena en grafos de cálculo

El motor autograd de PyTorch registra automáticamente el grafo de cálculo en cada operación de tensor. Al llamar a loss.backward(), parte del nodo loss, recorre el grafo de cálculo en sentido inverso y aplica la regla de la cadena a cada nodo: gradiente local × gradiente de aguas arriba = gradiente de aguas abajo. El desarrollador no necesita escribir ningún código de derivación a mano.

Verificación de gradientes (Gradient Check)

Si has escrito una capa personalizada o una función de pérdida a mano, ¿cómo verificas que el cálculo del gradiente en la retropropagación es correcto? Usa el gradiente numérico \( (f(x+h)-f(x-h))/2h \) como valor «verdadero» y compáralo con el gradiente calculado por autograd. El error relativo debe ser menor que 1e-5. Este es el principio de torch.autograd.gradcheck en PyTorch.

Optimización de grafos de cálculo

Los compiladores de aprendizaje profundo (como TensorRT, XLA) optimizan el grafo de cálculo: fusionan operaciones adyacentes (fusión de operadores) para reducir lecturas y escrituras de memoria. Pero deben garantizar que el cálculo de gradientes bajo la regla de la cadena siga siendo correcto: esta es una restricción importante de la optimización de grafos.


Otras extensiones