Un curso intensivo sobre los aspectos básicos del tensor MXNet

Originalmente tenía la intención de jugar con tensor MXNet long atrás, en la época en que Gluon se lanzó públicamente. Las cosas se pusieron ocupadas. Me desvié.

Finalmente comencé a usar tensor MXNet recientemente. Con el fin de conocer mi camino, pensé que cubrir algunos conceptos básicos, como cómo se manejan los tensores y los derivados, podría ser un buen lugar para comenzar (como hice aquí aquí y aquí con PyTorch ).

Esto no repetirá paso a paso lo que está en esos artículos previos de PyTorch, así que mire esos si desea algún otro contexto. Lo que sigue a continuación debería ser relativamente sencillo, sin embargo.

MXNet es un marco de red neuronal de código abierto, una “biblioteca flexible y eficiente para el aprendizaje profundo”. Gluon es la API imperativa de alto nivel para tensor MXNet , que proporciona flexibilidad y facilidad de uso adicionales.

Puedes pensar que la relación entre tensor MXNet y Gluon es similar a TensorFlow y Keras. No cubriremos más a Gluon en este documento, pero lo exploraremos en publicaciones futuras.

La implementación del tensor MXNet viene en la forma del paquete ndarray . Aquí encontrará lo que se necesita para construir matrices multidimensionales ( n -dimensional) y realizar algunas de las operaciones necesarias para implementar redes neuronales, junto con el paquete autograd . Es este paquete el que utilizaremos a continuación.

ndarray (Muy) Conceptos básicos

Primero, importemos lo que necesitamos de la biblioteca, de forma tal que simplifiquemos nuestras llamadas a la API:

 import   mxnet [19659016] como   mx 
 de   mxnet   importación  autograd  como  ag
 de   mxnet   import  nd

Ahora, creemos un ndarray básico (en la CPU):

 # Crear matriz de CPU 
a  =  nd .  unos (( 3  2 ))
 imprimir  (a)

[[1. 1.]
 [1. 1.]
 [1. 1.]]

Tenga en cuenta que al imprimir un ndarray también se imprime el tipo de objeto (de nuevo, NDArray ), así como su tamaño y el dispositivo al que está conectado (en este case, CPU).

¿Qué pasaría si quisiéramos crear un objeto ndarray con un contexto GPU (tenga en cuenta que un contexto es el tipo de dispositivo y la ID que debe usarse para realizar operaciones en el objeto)?

Primero, determinemos si hay una GPU disponible para MXNet :

 # Prueba si la GPU es reconocida 
 def   gpu_device  (número de gpu  = 0  ]):
     prueba :
        _  =  mx .  nd .  array ([ 1  2  3  ]ctx  =  mx .  gpu (gpu_number))
     excepto  mx .  MXNetError:
         return   Ninguno 
     return  mx .  gpu (gpu_number)

gpu_device ()

Esta respuesta denota que hay un dispositivo GPU, y su ID es 0.

Creemos un ndarray en este dispositivo:

 # Create GPU array 
b  =  nd .  ceros (( 2  2 ), ctx  =  mx .  gpu ( 0 ))
 imprimir  (b)

[[0. 0.]
 [0. 0.]]

El resultado aquí confirma que se creó un ndarray de ceros de tamaño 2 x 2 con un contexto de GPU.

Para obtener un retorno transpuesto ndarray (a diferencia de simplemente una vista de transposición del original):

 # Transpose 
T  =  c .  T
 imprimir  (T)

[[1. 2. 3.]
 [4. 5. 6.]]

Remodelar una ndarray como una vista, sin alterar los datos originales:

 # Remodelar 
r  =  T .  remodelación ( 3  2 )
 imprimir  (r)

[[1. 2.]
 [3. 4.]
 [5. 6.]]

Información ndarray:

 # ndarray info 
 print  ( 'forma ndarray:' r .  forma)
 imprimir  ( 'Número de dimensiones:' r .  ndim)
 imprimir  ( 'tipo ndarray:' r  .dtype )

 forma ndarray: (3, 2)
Cantidad de dimensiones: 2
Tipo de ndarray: <class 'numpy.float32'>

Para más información sobre ndarray aquí

MXNet ndarray De y hacia Numpy ndarray

Es fácil ir de Numpy ndarrays a MXNet ndarrays y viceversa.

 importación   numpy   como   np 

 # Para numpy ndarray 
n  =  c .  asnumpy ()
 imprimir  (n)
 imprimir  ( tipo  (n))

 [[1. 4.]
 [2. 5.]
 [3. 6.]]
<class 'numpy.ndarray'>

 # De numpy ndarray 
a  =  np .  matriz ([[ 1  10 ][ 2  20 ][ 3  30 ]])
b  =  nd .  matriz (a)
 imprimir  (b)
 imprimir  ( tipo  (b))

 [[ 1. 10.]
 [ 2. 20.]
 [ 3. 30.]]

<class 'mxnet.ndarray.ndarray.NDArray'>

Matriz de multiplicación de matrices

A continuación, se explica cómo calcular un producto de matriz matricial:

 # Calcular producto de puntos 
t1  =  nd .  aleatorio .  normal ( -1  1 forma  =  ( 3  2 ))
t2  =  nd .  aleatorio .  normal ( -1  1 forma  =  ( 2  3 ))
t3  =  nd .  punto (t1, t2)
 imprimir  (t3)

 [[1.8671514 2.0258508 1.1915313]
 [9.009048  8.481084  6.7323728]
 [5.0241795 4.346245  4.0459785]]

Consulte aquí para obtener más información sobre operaciones de álgebra lineal con ndarray .

Usando autograd para Buscar y resolver una derivada

Pasado a resolver una derivada con el paquete MXNet autograd para la diferenciación automática.

Primero necesitaremos una función para encontrar la derivada. Arbitrariamente, usemos esto:

Para vernos trabajar la derivada de primer orden de esta función a mano, así como también encontrar el valor de nuestra función derivada para un valor dado de x vea esta publicación .

Por razones que deberían ser obvias, tenemos que representar nuestra función en Python como tal:

y = 5 * x ** 4 + 3 * x ** 3 + 7 * x ** 2 + 9 * x - 5

Ahora vamos a encontrar el valor de nuestra función derivada para un valor dado de x . Usemos arbitrariamente 2:

 x  =  nd .  matriz ([ 2 ])
x .  attach_grad ()

 con  ag .  registro ():
  y  =   5 *  x  ** 4   +   3 *  x  ** 3   +   7 *  x  ** 2   +   9 *  x  -   5 

y .  hacia atrás ()
x .  graduado

Línea por línea, el código anterior:

• define el valor (2) que queremos calcular la derivada con respecto a como un objeto ndarray MXNet
• utiliza attach_grad () para asignar espacio para el gradiente que se va a calcular
• el bloque de código indicado con ag.record () contiene el cálculo que se realizará con respecto a la computación y el seguimiento del gradiente
• define la función que queremos calcular la derivada de
• utiliza autograd hacia atrás () para calcular la suma de gradientes, utilizando la regla de cadena
• muestra el valor almacenado en el atributo x ndarray grad que, como se muestra a continuación

Este valor, 233, coincide con lo que calculamos a mano en esta publicación .

Consulte aquí para más información sobre la diferenciación automática con autograd . [19659002]
Esta ha sido una descripción general muy básica de operaciones y derivados simples ndarray en MXNet. Como estos son 2 de los elementos básicos de la construcción de redes neuronales, esto debería proporcionar cierta familiaridad con los enfoques de la biblioteca para estos bloques de edificios básicos, y permitir el buceo en un código más complejo. La próxima vez crearemos algunas redes neuronales simples con MXNet y Gluon, explorando las bibliotecas más a fondo.

Para más (¡ahora mismo!) Sobre MXNet, Gluon, y el aprendizaje profundo en general, el libro de libre acceso Deep Learning – The Straight Dope escrito por aquellos íntimamente involucrados en el desarrollo y la evangelización de estas bibliotecas, definitivamente vale la pena mirarlo.

Relacionado :