Apache MXNet: paquetes de Python

En este capítulo aprenderemos sobre los paquetes de Python disponibles en Apache MXNet.

Paquetes importantes de MXNet Python

MXNet tiene los siguientes paquetes importantes de Python que discutiremos uno por uno:

  • Autograd (diferenciación automática)

  • NDArray

  • KVStore

  • Gluon

  • Visualization

Primero comencemos con Autograd Paquete de Python para Apache MXNet.

Autogrado

Autograd representa automatic differentiationutilizado para retropropagar los gradientes de la métrica de pérdida a cada uno de los parámetros. Junto con la retropropagación, utiliza un enfoque de programación dinámica para calcular de manera eficiente los gradientes. También se llama diferenciación automática en modo inverso. Esta técnica es muy eficaz en situaciones de "abanico" en las que muchos parámetros afectan a una única métrica de pérdida.

¿Qué son los gradientes?

Los gradientes son los fundamentos del proceso de entrenamiento de redes neuronales. Básicamente nos dicen cómo cambiar los parámetros de la red para mejorar su rendimiento.

Como sabemos, las redes neuronales (NN) están compuestas por operadores como sumas, producto, convoluciones, etc. Estos operadores, para sus cálculos, utilizan parámetros como los pesos en núcleos de convolución. Deberíamos tener que encontrar los valores óptimos para estos parámetros y los gradientes nos muestran el camino y nos llevan a la solución también.

Estamos interesados ​​en el efecto de cambiar un parámetro sobre el rendimiento de la red y los gradientes nos dicen cuánto aumenta o disminuye una variable dada cuando cambiamos una variable de la que depende. El rendimiento generalmente se define mediante el uso de una métrica de pérdida que intentamos minimizar. Por ejemplo, para la regresión podríamos intentar minimizarL2 pérdida entre nuestras predicciones y el valor exacto, mientras que para la clasificación podríamos minimizar la cross-entropy loss.

Una vez que calculamos el gradiente de cada parámetro con referencia a la pérdida, podemos usar un optimizador, como el descenso de gradiente estocástico.

¿Cómo calcular gradientes?

Tenemos las siguientes opciones para calcular gradientes:

  • Symbolic Differentiation- La primera opción es Diferenciación simbólica, que calcula las fórmulas para cada gradiente. El inconveniente de este método es que conducirá rápidamente a fórmulas increíblemente largas a medida que la red se vuelve más profunda y los operadores se vuelven más complejos.

  • Finite Differencing- Otra opción es utilizar la diferenciación finita que prueba ligeras diferencias en cada parámetro y ver cómo responde la métrica de pérdida. El inconveniente de este método es que sería computacionalmente costoso y puede tener poca precisión numérica.

  • Automatic differentiation- La solución a los inconvenientes de los métodos anteriores es utilizar la diferenciación automática para propagar hacia atrás los gradientes de la métrica de pérdida a cada uno de los parámetros. La propagación nos permite un enfoque de programación dinámica para calcular de manera eficiente los gradientes. Este método también se denomina diferenciación automática en modo inverso.

Diferenciación automática (autogrado)

Aquí, entenderemos en detalle el funcionamiento del autogrado. Básicamente funciona en las siguientes dos etapas:

Stage 1 - Esta etapa se llama ‘Forward Pass’de entrenamiento. Como su nombre lo indica, en esta etapa se crea el registro del operador utilizado por la red para realizar predicciones y calcular la métrica de pérdidas.

Stage 2 - Esta etapa se llama ‘Backward Pass’de entrenamiento. Como su nombre lo indica, en esta etapa se trabaja hacia atrás a través de este registro. Yendo hacia atrás, evalúa las derivadas parciales de cada operador, hasta el parámetro de red.

Ventajas del autogrado

Las siguientes son las ventajas de usar la diferenciación automática (autograd):

  • Flexible- La flexibilidad, que nos da a la hora de definir nuestra red, es uno de los grandes beneficios de utilizar autograd. Podemos cambiar las operaciones en cada iteración. Estos se denominan gráficos dinámicos, que son mucho más complejos de implementar en marcos que requieren gráficos estáticos. Autograd, incluso en tales casos, aún podrá propagar los degradados correctamente.

  • Automatic- Autograd es automático, es decir, las complejidades del procedimiento de retropropagación las atiende por usted. Solo necesitamos especificar qué gradientes estamos interesados ​​en calcular.

  • Efficient - Autogard calcula los gradientes de manera muy eficiente.

  • Can use native Python control flow operators- Podemos usar los operadores de flujo de control nativos de Python, como condición if y bucle while. El autogrado aún podrá propagar hacia atrás los gradientes de manera eficiente y correcta.

Usando autograd en MXNet Gluon

Aquí, con la ayuda de un ejemplo, veremos cómo podemos usar autograd en MXNet Gluon.

Ejemplo de implementación

En el siguiente ejemplo, implementaremos el modelo de regresión con dos capas. Después de la implementación, usaremos autograd para calcular automáticamente el gradiente de la pérdida con referencia a cada uno de los parámetros de peso -

Primero importe el autogrard y otros paquetes necesarios de la siguiente manera:

from mxnet import autograd
import mxnet as mx
from mxnet.gluon.nn import HybridSequential, Dense
from mxnet.gluon.loss import L2Loss

Ahora, necesitamos definir la red de la siguiente manera:

N_net = HybridSequential()
N_net.add(Dense(units=3))
N_net.add(Dense(units=1))
N_net.initialize()

Ahora necesitamos definir la pérdida de la siguiente manera:

loss_function = L2Loss()

A continuación, necesitamos crear los datos ficticios de la siguiente manera:

x = mx.nd.array([[0.5, 0.9]])
y = mx.nd.array([[1.5]])

Ahora, estamos listos para nuestro primer pase directo a través de la red. Queremos que autograd registre el gráfico computacional para que podamos calcular los gradientes. Para esto, necesitamos ejecutar el código de red en el alcance deautograd.record contexto de la siguiente manera:

with autograd.record():
   y_hat = N_net(x)
   loss = loss_function(y_hat, y)

Ahora, estamos listos para el pase hacia atrás, que comenzamos llamando al método hacia atrás en la cantidad de interés. La cantidad de interés en nuestro ejemplo es la pérdida porque estamos tratando de calcular el gradiente de pérdida con referencia a los parámetros:

loss.backward()

Ahora, tenemos gradientes para cada parámetro de la red, que serán utilizados por el optimizador para actualizar el valor del parámetro para mejorar el rendimiento. Veamos los degradados de la primera capa de la siguiente manera:

N_net[0].weight.grad()

Output

La salida es la siguiente

[[-0.00470527 -0.00846948]
[-0.03640365 -0.06552657]
[ 0.00800354 0.01440637]]
<NDArray 3x2 @cpu(0)>

Ejemplo de implementación completo

A continuación se muestra el ejemplo de implementación completo.

from mxnet import autograd
import mxnet as mx
from mxnet.gluon.nn import HybridSequential, Dense
from mxnet.gluon.loss import L2Loss
N_net = HybridSequential()
N_net.add(Dense(units=3))
N_net.add(Dense(units=1))
N_net.initialize()
loss_function = L2Loss()
x = mx.nd.array([[0.5, 0.9]])
y = mx.nd.array([[1.5]])
with autograd.record():
y_hat = N_net(x)
loss = loss_function(y_hat, y)
loss.backward()
N_net[0].weight.grad()