neural-network - layernorm - pytorch nllloss

Entendiendo un simple Pytorch LSTM

Question

import torch,ipdb
import torch.autograd as autograd
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
rnn = nn.LSTM(input_size=10, hidden_size=20, num_layers=2)
input = Variable(torch.randn(5, 3, 10))
h0 = Variable(torch.randn(2, 3, 20))
c0 = Variable(torch.randn(2, 3, 20))
output, hn = rnn(input, (h0, c0))

Este es el ejemplo de LSTM de los documentos. No sé entender las siguientes cosas:

1. ¿Qué es el tamaño de salida y por qué no se especifica en ninguna parte?
2. ¿Por qué la entrada tiene 3 dimensiones. ¿Qué representan 5 y 3?
3. ¿Qué son 2 y 3 en h0 y c0, qué representan esos?

Editar:

import torch,ipdb
import torch.autograd as autograd
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
import torch.nn.functional as F
num_layers=3
num_hyperparams=4
batch = 1
hidden_size = 20
rnn = nn.LSTM(input_size=num_hyperparams, hidden_size=hidden_size, num_layers=num_layers)
input = Variable(torch.randn(1, batch, num_hyperparams)) # (seq_len, batch, input_size)
h0 = Variable(torch.randn(num_layers, batch, hidden_size)) # (num_layers, batch, hidden_size)
c0 = Variable(torch.randn(num_layers, batch, hidden_size))
output, hn = rnn(input, (h0, c0))
affine1 = nn.Linear(hidden_size, num_hyperparams)
ipdb.set_trace()
print output.size()
print h0.size()

*** RuntimeError: se esperaban matrices, se obtuvieron tensores 3D, 2D en

Answer 1

La salida para el LSTM es la salida para todos los nodos ocultos en la capa final.
hidden_size - el número de bloques LSTM por capa.
input_size : el número de input_size de entrada por paso de tiempo.
num_layers - el número de capas ocultas.
En total hay hidden_size * num_layers LSTM blocks.

Las dimensiones de entrada son (seq_len, batch, input_size) .
seq_len - el número de pasos de tiempo en cada flujo de entrada.
batch : el tamaño de cada lote de secuencias de entrada.

Las dimensiones ocultas y de celda son: (num_layers, batch, hidden_size)

salida (seq_len, batch, hidden_size * num_directions): tensor que contiene las características de salida (h_t) de la última capa del RNN, para cada t.

Así que habrá hidden_size * num_directions salidas. No inicializó el RNN para que sea bidireccional, por lo que num_directions es 1. Entonces output_size = hidden_size .

Editar : puede cambiar el número de salidas utilizando una capa lineal:

out_rnn, hn = rnn(input, (h0, c0))
lin = nn.Linear(hidden_size, output_size)
v1 = nn.View(seq_len*batch, hidden_size)
v2 = nn.View(seq_len, batch, output_size)
output = v2(lin(v1(out_rnn)))

Nota : para esta respuesta asumí que solo estamos hablando de LSTM no bidireccionales.

Fuente: documentos de PyTorch .

Answer 2

Respuesta por cdo256 es casi correcta. Se equivoca al referirse a lo que significa tamaño oculto. Lo explica como:

hidden_size - el número de bloques LSTM por capa.

Pero en realidad, aquí hay una mejor explicación:

Cada capa de estado sigmoide, tanh o oculta en la celda es en realidad un conjunto de nodos, cuyo número es igual al tamaño de capa oculta. Por lo tanto, cada uno de los "nodos" en la celda LSTM es en realidad un grupo de nodos neuronales normales, como en cada capa de una red neuronal densamente conectada. Por lo tanto, si establece hidden_size = 10, entonces cada uno de sus bloques o celdas LSTM tendrá redes neuronales con 10 nodos en ellas. El número total de bloques LSTM en su modelo LSTM será equivalente al de su longitud de secuencia.

Esto se puede ver analizando las diferencias en los ejemplos entre nn.LSTM y nn.LSTMCell:

https://pytorch.org/docs/stable/nn.html#torch.nn.LSTM

y

https://pytorch.org/docs/stable/nn.html#torch.nn.LSTMCell

Answer 3

Usted puede establecer

batch_first = True

Si desea hacer entrada y salida proporcionada como

(batch_size, seq, input_size)

Tengo que saberlo hoy, así que compartir con ustedes.