Manipulación de tensores en PyTorch. ¡El primer paso para el deep learning!

*Nota: Contactar a Omar Espejel ([email protected]) para cualquier observación. Cualquier error es responsabilidad del autor.

*Nota: El autor considera que, si bien el escrito está en español y el objetivo es expandir el conocimiento del deep learning en este idioma, existen palabras insustituibles del inglés. Por lo tanto, este y siguientes escritos utilizarán indiscriminadamente palabras en inglés.

Manipulación de tensores

Se introduce el tensor como la estructura de datos básica en la creación de deep learning. Usamos pytorch como herramienta para la construcción de tensores capaces de correr en CUDA (GPU). Finalmente, aplicamos manipulación de tensores para hacer broadcasting (transmisión, en español), agregar y quitar dimensiones, y hacer reshaping de nuestras estructuras. Terminamos con una función que utilizaremos más adelante para aplanar imágenes.

¿Dónde correr el código?

En mi opinión, la mejor forma de aprender deep learning es escribir y escribir código. Esto es irrealizable, en terminos de tiempo, si se utiliza el poder de una CPU. Estaremos trabajando en Google Colab donde se nos asigna de manera gratuita por máximo 12 horas un GPU modelo Tesla K80. Solo necesitamos una cuenta de Google.

Ingresar a 

https://colab.research.google.com

NUEVO BLOCK DE NOTAS DE PYTHON 3

Entorno de ejecución

Cambiar tipo de entorno de ejecución

El tensor

En matemáticas estamos comunmente familiarizados con tres estructuras de datos: el escalar, el vector y la matriz. Los escalares corresponden a un único número, 2 por ejemplo; los vectores son una formación ordenada (arrays, en inglés) de datos en una única dimensión, por ejemplo (1,3,5,6,7,8); las matrices son una formación ordenada de dos dimensiones, por ejemplo ([1,2,3],[4,5,6]). Sin embargo, ¿cómo nombramos a las estructuras de datos, como las imágenes, de más de 2 dimensiones? La siguiente imagen obtenida de Leonardo Araujo Santos nos permite visualizar estas estructuras de datos y la limitación al tratar de nombrar estructuras de más de dos dimensiones.

Los matemáticos tienen la tendencia de nombrar cada particularidad de una forma diferente, en deep learning usaremos una manera general de nombrar las estructuras de datos. No hablaré de escalares, vectores o matrices, sino de tensores de rango cero, uno y dos, respectivamente. Para una explicación más detallada de lo que es un tensor ver este artículo. Sin embargo, para los fines de este artículo, pensemos en los tensores como una formación ordenada de N dimensiones.

Creemos tensores (si se tienen conocimientos previos de lenguajes como R y Matlab entonces la sintaxis les parecerá conocida). Primero necesitamos importar Pyorch: 

import torch

t = torch.tensor(1, dtype = torch.int32, device = "cuda")

El argumento

dtype

torch.double

torch.float64

device

device = "cpu"

Rango 1:

t = torch.tensor([1.1, 2.2, 3.3], dtype = torch.double64, device = "cuda")

Rango 2:

t = torch.tensor([
    [1,1,1,1],
    [2,2,2,2],
    [3,3,3,3]
], dtype=torch.float32, device = "cuda")

Para conocer la forma de un tensor utilizamos 

t.shape

torch.Size([3, 4])

t

Finalmente, podemos realizar operaciones entre tensores. Usemos nuestro tensor 

t

torch.Size([3,4])

1. Suma: 

   t + t 

   o

   t.sum(t)

   .
2. Multiplicación: 

   t*t

   .
3. Multiplicación de matrices: 

   t.mm(s)

    donde 

   s

    se define como:

s = torch.tensor([
    [1,1,1],
    [2,2,2],
    [3,3,3],
    [4,4,4]
], dtype=torch.float32, device = "cuda")

Además, pytorch nos permite hacer indexing de la misma manera que se hace con numpy. No ahondamos en el tema dado que no es tan relevante para iniciar con el deep learning, sin embargo, en la documentación de pytorch se encuentra todo lo necesario.

Broadcasting (transmisión, en español)

El broadcasting es una herramienta muy poderosa que nos permite trabajar mejor con tensores sin usar fors. Esta técnica existe también en numpy.

Cuando pytorch opera en dos tensores, compara sus formas en cuanto a elementos. Comienza con las dimensiones finales y avanza.

Dos dimensiones son compatibles cuando: (1) son iguales o (2) una de ellas es 1, en cuyo caso esta dimensión se transmite para que tenga el mismo tamaño. Esto significa que una dimensión con valor de 1 es compatible con cualquier otra dimensión, ya que se transmitirá. Por ejemplo, se puede operar en tensores de forma (1,3) y (5,1) ya que 1 es compatible con 3 y 5.

Los tensores no necesitan tener el mismo número de dimensiones. Por ejemplo, si tienes un tensor 256 * 256 * 3 de valores RGB (red-green-blue), 

RGB_tensor

t

Para hacer esto necesitamos compatibilizar nuestros tensores 

RGB_tensor

t

RGB_tensor

t

t

t = t[None, None,:]

RGB_tensor

t.expand_as(RGB_tensor)

Estamos escribiendo código que se ejecuta tan rápido como C con esto. Además, el broadcasting nos da velocidad C sin necesidad de memoria adicional. Toma un poco de tiempo acostumbrarse a la forma de codificación de broadcasting, pero, según Jeremy Howard en su clase de practical deep learning, vale la pena ya que reduce muchos errores provenientes de los bucles, y también es más cómodo una vez que nos acostumbramos.

De acuerdo a Jeremy Howard, el broadcasting podría ser el truco más útil para escribir código que sea lo suficientemente rápido.

Agregar dimensiones o ejes

En el texto se utilizarán de forma indiscriminada las palabras "dimensión" y "eje".

Hay dos formas diferentes de agregar una nueva dimensión a un Tensor de pytorch. 

tensor.unsqueeze(dim = 0)

Esto es relevante porque nos permite elegir cómo transmitir nuestros tensores. Considere que la transmisión se producirá automáticamente para la dimensión del tensor con forma 1. Por ejemplo, si tenemos un tensor, 

t

s

torch.Size([3])

s = torch.unsqueeze(s, dim = 0)

t

t.expand_as(t)

Nota: Squeeze hace lo contrario que unsqueeze(); elimina dimensiones.

Reshaping (remodelación, en español) de tensores

Continuemos con nuestro tensor 

t

t.shape

len(t.shape)

t.numel()

t.shape, len(t.shape), t.numel()

que da como resultado 

(torch.Size([3, 4]), 2, 12)

t

t.reshape(1,12), t.reshape(6,2), t.reshape(12,1);

Nota: reshape() y view() hacen lo mismo.

“Veamos un caso de uso común para squeeze un tensor mediante la construcción de una función flatten (aplanar). […] Una operación de aplanar en un tensor da nueva forma al tensor para que tenga una forma que sea igual al número de elementos contenidos en el tensor. Esto es lo mismo que un tensor de rango 1°. […] Aplanar un tensor significa eliminar todas las dimensiones excepto una” - Deeplizard.

En este texto, recreé la función de aplanar en el blog para tomar en cuenta los batches (lotes, en español) de datos.

Indiquemos que nuestro tensor es un batch creando una dimensión adicional en la posición 0:

t = t[None, :]
t.shape

Da 

torch.Size([1, 3, 4])

cat

t

t = t[None, :]
t_batch = torch.cat((t, t), dim = 0)

t_batch.shape

torch.Size([2, 3, 4])

def flatten(t):
  f = torch.reshape(t, (t.shape[0], 1, -1))
  return f.squeeze()

Entonces 

t_batch.shape

flatten(t_batch).shape

(torch.Size([2, 3, 4])

torch.Size([2, 12]))

“Dado que el argumento t puede ser cualquier tensor, pasamos -1 como segundo (tercer) argumento a la función reshape(). En pytorch, el -1 le dice a la función reshape() que descubra cuál debe ser el valor en función del número de elementos contenidos dentro del tensor. […] Veremos que se requieren operaciones de aplanamiento cuando se pasa un tensor de salida de una capa convolucional a una capa lineal.” Deeplizard.

En el siguiente texto comenzaremos con los básicos del deep learning.