Autograd, clave de la flexibilidad de PyTorch

Esta entrada es parte del curso de Deep learning con PyTorch.

En los últimos dos años hemos visto como PyTorch, el framework basado en Torch para Deep Learning creado por Facebook, está siendo una alternativa potente a Tensorflow.

Una de las principales ventajas de PyTorch es que es un framework imperativo, en el que las operaciones/computaciones se van realizando conforme se ejecuta el programa. Tensorflow es en origen declarativo, el grafo se define primero y para cada ejecución se compila asignándole unos valores de entrada.

La clave para tener entornos de deep learning eficientes es la diferenciación automática, un procedimiento de cálculo automático de las derivadas en un punto. En redes neuronales profundas, esta diferenciación es necesaria para el descenso por gradiente y como hemos visto en otros posts, se realiza usando propagación hacia atrás (backpropagation).

PyTorch implementa la diferenciación automática con el paquete Autograd y el uso de variables. Las variables en PyTorch son nodos en el grafo computacional que almacenan:

  • Datos.
  • El gradiente de una función respecto a la variable.
  • La función que crea la variable.

¿Cómo computa Autograd los gradientes?

Sigue un procedimiento en varias fases:

  • Se construye el grafo computacional haciendo un seguimiento de las operaciones realizadas en el flujo hacia delante de la red neuronal (forward pass). Mientras en Tensorflow, como hemos comentado, el grafo lo construye explícitamente el usuario, en PyTorch se construye de manera implícita.
  • Todas las operaciones se convierten en operaciones atómicas (sumas y multiplicaciones) para calcular las derivadas.
  • Se hace propagación hacia atrás con la regla de la cadena para calcular los gradientes respecto a los parámetros.

Para una explicación más detallada de la implementación automática y Autograd ver el siguiente enlace.

Vamos a ver un ejemplo de Autograd. A continuación se muestra el grafo a implementar con sus nodos y sus operaciones.

Grafo computacional PyTorch

Vemos por ejemplo como se calcularía el gradiente de la función de coste con respecto al primer parámetro w0 usando la regla de la cadena:

\frac{\partial L}{\partial _{W0}}=\frac{\partial L}{\partial _{C}}\frac{\partial c}{\partial _{B1}}\frac{\partial b1}{\partial _{W0}}=-1\ast w3\ast a1= -28

A continuación se muestra el ejemplo en PyTorch del grafo mostrado, con las variables, las operaciones y la implementación de Autograd.

Una vez declaradas las variables e implementado el grafo, llamando al método backward() sobre la función de coste, se calcula el gradiente respecto a las variables correspondientes.


from torch import FloatTensor
from torch.autograd import Variable
import torch

# Leaf nodes are defined
a1 = Variable(FloatTensor([4]))
a2 = Variable(FloatTensor([3]))

# Variables with gradients required are define
w=Variable(FloatTensor([2,5,9,7,3]), requires_grad=True)

b1 = w[0] * a1 + w[1] * a2 #b1=2*4+5*3=23
b2 = w[2] * a1 #b2=9*4=36
c = w[3] * b1 + w[4] * b2
L = (15 - c)

L.backward()

gradient = w.grad.data
for i in range(0, 5):
    print(f"Gradiente de w{i} respecto a L: {gradient[i]}")

El resultado de ejecutar el programa sería:
«Gradiente de w0 respecto a L: -28.0
Gradiente de w1 respecto a L: -21.0
Gradiente de w2 respecto a L: -12.0
Gradiente de w3 respecto a L: -23.0
Gradiente de w4 respecto a L: -36.0″

Como hemos podido ver, Autograd permite realizar la diferenciación automática y calcular los gradientes de manera sencilla.

Un comentario sobre “Autograd, clave de la flexibilidad de PyTorch

Agrega el tuyo

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Orgullosamente ofrecido por WordPress | Tema: Baskerville 2 por Anders Noren.

Subir ↑

A %d blogueros les gusta esto: