Fundamentos de PyTorch. LSTMs

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

Una LSTM (Long short-term memory) es un tipo de red neuronal recurrente (RNN) muy usada en problemas con dependencia temporal, que se compone de una unidad de memoria y tres reguladores que controlan el flujo de información a la unidad de memoria, “input gate”, “output gate” y “forget gate”.

En PyTorch, las LSTM se implementan con la clase torch.nn.LSTM(*args, **kwargs). La clase tiene los siguientes parámetros, entre otros:

• Dimensión de la entrada.
• Dimensión del estado oculto h.
• Número de capas.

La entrada tiene la siguiente forma (input, (h_0, c_0)):

• La entrada input es el tensor de la forma (longitud de la secuencia, número de instancias batch, dimensión de la entrada).
• h_0 es el estado oculto inicial.
• c_0 es el estado inicial de la unidad de memoria.

La salida tiene la siguiente forma (output, (h_n, c_n)):

• La salida es el tensor de la forma (longitud de la secuencia, número de instancias batch, num_directions * dimensión del estado oculto) con la salida para cada instante de la secuencia.
• Tensor h_n con la forma (num_capas * num_directions, batch, dimensión estado oculto) que contiene el estado oculto en el último instante.
• Tensor c_n con la forma (num_capas * num_directions, batch, dimensión estado oculto) que contiene el estado de la unidad de memoria en el último instante.

A continuación se puede ver una representación gráfica del tensor entrada de rango 3.

import torch
import torch.nn as nn

#Creamos una instancia con una entrada de 10 dimensiones, una capa oculta de 6 dimeniones y 2 capas
LSTM1 = nn.LSTM(10, 6, 2)

#Creamos la entrada, un batch de dos instancias, cada una con una secuencia de 5 time steps y dimensión 10
input = torch.randn(5, 2, 10)

#Inicializamos los estados iniciales para cada una de las instancias y cada una de las dos capas
h0 = torch.randn(2, 2, 6)
c0 = torch.randn(2, 2, 6)

#Llamamos al método forward de la instancia creada, pasándole la entrada y los estados iniciales creados
output, (hn, cn) = LSTM1(input, (h0, c0))

#La salida output tiene la forma (seq_len, batch, num_directions * hidden_size) y contiene la salida h_t de la última capa para todos los intantes de tiempo para cada instancia del batc.
print(output)
print(output.shape)

#La salida hn tiene la forma (num_layers * num_directions, batch, hidden_size) y contiene h_t para el último intantes de tiempo en cada capa.
#Como se puede ver el último time step de la salida output coincide con la última capa de la salida hn
print(hn)
print(hn.shape)

tensor([[[-0.0212,  0.0481,  0.0351,  0.3754, -0.0085, -0.1330],
         [-0.2699,  0.2120, -0.2443, -0.0252,  0.2005,  0.1459]],

        [[ 0.0352, -0.0233, -0.0744,  0.1915, -0.0332, -0.1680],
         [-0.1555,  0.0230, -0.2110, -0.0331,  0.0401, -0.0915]],

        [[ 0.0580, -0.0158, -0.1563,  0.0681, -0.0504, -0.1990],
         [-0.0486,  0.0010, -0.2333, -0.0459, -0.0542, -0.1393]],

        [[ 0.0535, -0.0114, -0.1836, -0.0287, -0.0979, -0.2382],
         [ 0.0099, -0.0303, -0.2338, -0.0556, -0.0698, -0.1764]],

        [[ 0.0896,  0.0014, -0.1426, -0.0814, -0.1498, -0.1807],
         [ 0.0659, -0.0394, -0.1764, -0.0901, -0.1108, -0.1159]]],
       grad_fn=<StackBackward>)
torch.Size([5, 2, 6])
tensor([[[-0.2841, -0.0278,  0.1141, -0.1267,  0.3383,  0.0995],
         [-0.0443,  0.1272,  0.1914,  0.2779,  0.0864, -0.0740]],

        [[ 0.0896,  0.0014, -0.1426, -0.0814, -0.1498, -0.1807],
         [ 0.0659, -0.0394, -0.1764, -0.0901, -0.1108, -0.1159]]],
       grad_fn=<StackBackward>)
torch.Size([2, 2, 6])