La regla de la cadena es una técnica matemática para calcular la derivada de una función compuesta de otras funciones. Se explica con un ejemplo de dos funciones vinculadas y cómo calcular la derivada de la función exterior con respecto a la variable de entrada de la función interior. Luego, se demuestra que aplicar la regla de la cadena o calcular directamente la derivada sustituyendo funciones produce el mismo resultado. Finalmente, se explica que la regla de la cadena es importante para entrenar redes neuronales.

1. La regla de la cadena
The Chain Rule En el Capítulo 7, cuando construyamos una red neuronal, vamos a necesitar
un truco matemáticoespecial llamado regla de la cadena. Cuando compongamos las capas
de la red neuronal, tendremos que desenredar las derivadas de cada capa. Pero por ahora
aprendamos la regla de la cadena con un ejemplo algebraico simple. Digamos que te dan
dos funciones:
y = x2
+ 1
z = y3 - 2
Observe que estas dos funciones están vinculadas, porque y es la variable de salida en la
primera función pero es la variable de entrada en la segunda. Esto significa que podemos
sustituir la primera función y en la segunda función z así:
Entonces, ¿cuál es la derivada de z con respecto a x ? Ya tenemos la sustitución
expresando z en términos de x. Usemos SymPypara calcular eso en el ejemplo 1-24.
Ejemplo 1-24. Encontrar la derivada de z con respecto a x
from sympy import *
z = (x**2 + 1)**3 - 2
dz_dx = diff(z, x)
print(dz_dx)
# 6*x*(x**2 + 1)**2
Entonces nuestra derivada de z con respecto a x es 6x (x2
+1) 2
:
Pero mira esto. Comencemos de nuevo y tomemos un enfoque diferente. Si tomamos las
derivadas de las funciones y y z por separado, y luego las multiplicamos juntas, ¡esto
también produce la derivada de z con respecto a x ! Vamos a intentarlo:
Muy bien, 6 xy2
puede no parecerse a 6 x (x2
+1) 2, pero eso es solo porque aún no hemos
sustituido la función y. Haga eso para que toda la derivada se exprese en términos
de x sin y.

2. Ahora vemos que tenemos la misma función derivada 6x (x2
+1)2 !
Esta es la regla de la cadena, que dice que para una función dada y (con variable de entrada
x ) compuesta en otra función z (con variable de entrada y ), podemos encontrar la derivada
de z con respecto a x multiplicando las dos derivadas respectivas :
El ejemplo 1-25 muestra el código SymPy que hace esta comparación, mostrando que la
derivada de la regla de la cadena es igual a la derivada de la función sustituida.
Ejemplo 1-25. Calcular la derivada dz/dx con y sin la regla de la cadena, pero aún
obteniendo la misma respuesta
fromsympy import*
x, y = symbols('x y')
# derivativeforfirstfunction
# needtounderscore y to preventvariable clash
_y = x**2 + 1
dy_dx = diff(_y)
# derivativeforsecondfunction
z = y**3 - 2
dz_dy = diff(z)
# Calculate derivativewithandwithout
# chainrule,substitute yfunction
dz_dx_chain = (dy_dx * dz_dy).subs(y, _y)
dz_dx_no_chain = diff(z.subs(y, _y))
# Prove chainrule byshowingbothare equal
print(dz_dx_chain) # 6*x*(x**2 + 1)**2
print(dz_dx_no_chain) # 6*x*(x**2 + 1)**2
La regla de la cadena es una parte clave del entrenamiento de una red neuronal con los
pesos y sesgos adecuados. En lugar de desenredar la derivada de cada nodo en forma de
cebolla anidada, podemos multiplicar las derivadas en cada nodo, lo cual es
matemáticamente mucho más fácil.
Integrales
Lo contrario de una derivada es una integral, que encuentra el área bajo la curva para un
rango dado. En los Capítulos 2 y 3, encontraremos las áreas bajo distribuciones de
probabilidad. Aunque no usaremos integrales directamente, y en su lugar usaremos
funciones de densidad acumulativa que ya están integradas, es bueno saber cómo las
integrales encuentran áreas bajo curvas. El Apéndice A contiene ejemplos del uso de este
enfoque en distribuciones de probabilidad.
Quiero adoptar un enfoque intuitivo para aprender integrales llamado Reimann Sums, uno
que se adapte de manera flexible a cualquier función continua. Primero, señalemos que
encontrar el área de un rango debajo de una línea recta es fácil. Digamos que tengo una
función f( x ) = 2x y quiero encontrar el área debajo de la línea entre 0 y 1, como se muestra
en la figura 1-9.

3. Figura 1-9. Cálculo de un área bajo una función lineal
Observe que estoy encontrando el área delimitada entre la línea y el eje x, y en el rango x
de 0,0 a 1,0. Si recuerdas las fórmulas básicas de geometría, el área A de un triángulo es
donde b es la longitud de la base y h es la altura. Podemos detectar visualmente que
b = 1 y h = 2. Entonces, al conectarnos a la fórmula, obtenemos para nuestra área 1.0
como se calcula aquí:
A = 1
Eso no estuvo mal, ¿verdad? Pero veamos una función en la que es difícil encontrar el área
debajo: f ( x ) = x 2
+ 1. ¿Cuál es el área entre 0 y 1 sombreada en la figura 1-10 ?

4. Figura 1-10. Calcular el área bajo funciones no lineales es menos sencillo
Nuevamente, estamos interesados en el área debajo de la curva y sobre el eje x, solo dentro
del rango x entre 0 y 1. La curvatura aquí no nos brinda una fórmula geométrica clara para
encontrar el área, pero aquí hay un pequeño truco inteligente. tu puedes hacer.
¿Qué pasa si empaquetamos cinco rectángulos de igual longitud debajo de la curva como
se muestra en la Figura 1-11, donde la altura de cada uno se extiende desde el eje x hasta
donde el punto medio toca la curva?
El área de un rectángulo es A = length × width A = largo × ancho , por lo que podríamos
sumar fácilmente las áreas de los rectángulos. ¿Nos daría eso una buena aproximación del
área bajo la curva? ¿Qué pasa si empacamos 100 rectángulos? 1,000? 100,000? A medida
que aumentamos el número de rectángulos mientras disminuimos su ancho, ¿no nos
acercaríamos al área bajo la curva? Sí, lo haríamos, y es otro caso más en el que
aumentamos/disminuimos algo hacia el infinito para acercarnos a un valor real.

5. Figura 1-11. Rectángulos de embalaje debajo de una curva para aproximar el área
Probémoslo en Python. Primero necesitamos una función que aproxime una integral que
llamaremos approximate_integral(). Los argumentos a y b especificarán el mínimo y el
máximo del rango x, respectivamente. n será el número de rectángulos a empaquetar y f
será la función que estamos integrando. Implementamos la función en el Ejemplo 1-26 y
luego la usamos para integrar nuestra función f ( x ) = x2
+ 1 con cinco rectángulos, entre
0.0 y 1.0.
Ejemplo 1-26. Una aproximación integral en Python
def approximate_integral(a, b, n, f):
delta_x = (b - a) / n
total_sum = 0
for i in range(1, n + 1):
midpoint = 0.5 * (2 * a + delta_x * (2 * i - 1))
total_sum += f(midpoint)
return total_sum * delta_x
def my_function(x):
return x**2 + 1
area = approximate_integral(a=0, b=1, n=5, f=my_function)
print(area) # prints 1.33
Entonces obtenemos un área de 1.33. ¿Qué pasa si usamos 1,000 rectángulos?
Probémoslo en el ejemplo 1-27.
Ejemplo 1-27. Otra aproximación integral en Python
area = approximate_integral(a=0, b=1, n=1000, f=my_function)
print(area) # prints 1.333333250000001
Bien, estamos obteniendo algo más de precisión aquí y obteniendo algunos lugares
decimales más. ¿Qué pasa con un millón de rectángulos como se muestra en el
Ejemplo 1-28 ?
Ejemplo 1-28. Otra aproximación integral en Python

6. area = approximate_integral(a=0, b=1, n=1_000_000, f=my_function)
print(area) # prints 1.3333333333332733
Bien, creo que estamos obteniendo un rendimiento decreciente aquí y convergiendo
en el valor 1. 333 ¯ donde la parte ".333" se repite para siempre. Si fuera un número
racional, probablemente 4/3 = 1. 333. A medida que aumentamos el número de
rectángulos, la aproximación comienza a alcanzar su límite con decimales cada vez
más pequeños.
Ahora que tenemos cierta intuición sobre lo que estamos tratando de lograr y por
qué, hagamos un enfoque más exacto con SymPy, que es compatible con los
números racionales, en el Ejemplo 1-29.
Ejemplo 1-29. Uso de SymPy para realizar la integración
from sympy import *
# Declare 'x' to SymPy
x = symbols('x')
# Now just use Python syntax to declare function
f = x**2 + 1
# Calculate the integral of the function with respect to x
# for the area between x = 0 and 1
area = integrate(f, (x, 0, 1))
print(area) # prints 4/3¡
Enfriar! Entonces, el área en realidad es 4/3, que es en lo que convergió nuestro
método anterior. Desafortunadamente, Python simple (y muchos lenguajes de
programación) solo admiten decimales, pero los sistemas de álgebra computacional
como SymPy nos brindan números racionales exactos. Usaremos integrales para
encontrar áreas bajo curvas en los Capítulos 2 y 3, aunque scikit-learn hará el
trabajo por nosotros.
CÁLCULO DE INTEGRALES CON LÍMITES
Para los súper curiosos, así es como calculamos integrales definidas usando límites
en SymPy. ¡Por favor! Omita o regrese a esta barra lateral más tarde si tiene
suficiente para digerir. Pero si te sientes bien y quieres profundizar en cómo se
derivan las integrales usando límites, continúa!
La idea principal sigue mucho de lo que hicimos antes: empaqueta rectángulos bajo
una curva y hazlos infinitamente más pequeños hasta que nos acerquemos al área
exacta. Pero, por supuesto, los rectángulos no pueden tener un ancho de 0.. solo
tienen que seguir acercándose a 0 sin llegar nunca a 0. Es otro caso de usar límites.
Khan Academy tiene un excelente artículo que explica cómo usar los límites para
las Sumas de Reimann, pero así es como lo hacemos en SymPy, como se muestra
en el Ejemplo 1-30.
Ejemplo 1-30. Usar límites para calcular integrales
fromsympy import*
# Declare variablestoSymPy
x, i, n = symbols('x i n')
# Declare functionandrange
f = x**2 + 1

7. lower, upper = 0, 1
# Calculate widthandeachrectangle heightatindex "i"
delta_x = ((upper - lower) / n)
x_i = (lower + delta_x * i)
fx_i = f.subs(x, x_i)
# Iterate all "n"rectanglesandsumtheirareas
n_rectangles = Sum(delta_x * fx_i, (i, 1, n)).doit()
# Calculate the areabyapproachingthe number
# of rectangles"n"to infinity
area = limit(n_rectangles, n, oo)
print(area) #prints4/3
Aquí determinamos la longitud de cada rectángulo delta_x y el inicio de cada
rectángulo x_i donde i es el índice de cada rectángulo. fx_i es la altura de cada
rectángulo en el índice i. Declaramos un número n de rectángulos y sumamos sus
áreas delta_x * fx_i, pero aún no tenemos un valor de área porque no hemos
asignado un número para n. En cambio, nos acercamos a n hacia el infinito para ver
en qué área convergemos, ¡y deberías obtener 4/3!
Conclusión
En este capítulo cubrimos algunos fundamentos que usaremos para el resto de este
libro. Desde la teoría de números hasta los logaritmos y las integrales de cálculo,
destacamos algunos conceptos matemáticos importantes relevantes para la ciencia
de datos, el aprendizaje automático y el análisis. Es posible que tenga preguntas
acerca de por qué estos conceptos son útiles. ¡Eso vendrá después!
Antes de pasar a discutir la probabilidad, tómate un poco de tiempo para repasar
estos conceptos una vez más y luego haz los siguientes ejercicios. Siempre puede
volver a visitar este capítulo a medida que avanza en este libro y actualizar según
sea necesario cuando comience a aplicar estas ideas matemáticas.