Diferença entre uma única rede LSTM e uma rede neural LSTM de 3 unidades

O LSTM no seguinte código Keras

input_t = Input((4, 1))
output_t = LSTM(1)(input_t)
model = Model(inputs=input_t, outputs=output_t)
print(model.summary())

pode ser representado como

Entendo que quando chamamos model.predict(np.array([[[1],[2],[3],[4]]]))a (apenas) unidade LSTM processa primeiro o vetor [1], depois [2] mais o feedback da entrada anterior e assim por diante até o vetor [4]. Em outras palavras, .$x_1 = [1], x_2 = [2], x_3 = [3], x_4 = [4]$

Não entendo como a seguinte rede neural processaria a mesma sequência de entrada [1],[2],[3],[4]

 input_t = Input((4, 1))
 output_t = LSTM(3)(input_t)
 model = Model(inputs=input_t, outputs=output_t)
 print(model.summary())

Neste NN, temos três unidades LSTM. Como eles processam a sequência [1],[2],[3],[4]? Eles estão interconectados? Eles processam a sequência de entrada em paralelo ou uma unidade processa a sequência de entrada e, posteriormente, sua entrada é alimentada para a segunda unidade LSTM e assim por diante? Alguém usando esquematicamente essa imagem poderia explicar todo o processo?

Em Keras LSTM(n)significa "criar uma camada LSTM que consiste em unidades LSTM. A figura a seguir demonstra o que camada e unidade (ou neurônio) são e a imagem mais à direita mostra a estrutura interna de uma única unidade LSTM.

A figura a seguir mostra como toda a camada LSTM opera.

$\mathbb{x}_1, \dots, \mathbb{x}_N$$t$$\mathbb{x_t}$$\mathbb{h_{t-1}}$$b$$\mathbb{h_t}$$\mathbb{h_t}$$\mathbb{h_t}$$\mathbb{x}_N$

Agora vamos calcular o número de parâmetros para LSTM(1)e LSTM(3)e compará-lo com o que aparece Keras quando chamamos model.summary().

$inp$$\mathbb{x_t}$$out$$\mathbb{h_t}$$inp + out + 1$$out$$out\times(inp + out + 1)$

$$4out(inp + out + 1)$$

Vamos comparar com o que o Keras produz.

Exemplo 1.

 t1 = Input(shape=(1, 1))
 t2 = LSTM(1)(t1)
 model = Model(inputs=t1, outputs=t2)
 print(model.summary())

  Layer (type)                 Output Shape              Param #   
  =================================================================
  input_2 (InputLayer)         (None, 1, 1)              0         
  _________________________________________________________________
  lstm_2 (LSTM)                (None, 1)                 12        
  =================================================================
  Total params: 12
  Trainable params: 12
  Non-trainable params: 0
  _________________________________________________________________

$4\times 1 \times (1 + 1 + 1) = 12$

Exemplo 2

  input_t = Input((4, 2))
  output_t = LSTM(3)(input_t)
  model = Model(inputs=input_t, outputs=output_t)
  print(model.summary())

    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    input_6 (InputLayer)         (None, 4, 2)              0         
    _________________________________________________________________
    lstm_6 (LSTM)                (None, 3)                 72        
    =================================================================
    Total params: 72
    Trainable params: 72
    Non-trainable params: 0

$4\times 3 \times (2 + 3 +1) = 72$

Normalmente, trabalho com o Tensorflow, mas, como pude ver na documentação, é semelhante ao Keras.

Basicamente, quando você está ligando, NÃOLSTM(3) está criando um LSTM um por cima do outro, como nesta imagem 1 . Este é um problema completamente diferente.

No entanto, ao criar, LSTM(3)você está criando um LSTM com 3 unidades ocultas ou células ocultas . No seu código, 3 será a dimensão das células internas no LSTM. O que isso significa? Isso significa que a dimensionalidade do estado oculto e a dimensionalidade do estado de saída serão as mesmas do seu parâmetro de unidades ocultas.

Em vez de imaginar um LSTM como algo que obtém uma sequência de escalares e dá e produz escalares, imagine o seguinte: Você tem uma sequência de comprimento T com 512 valores cada T, então [Batchsize, T, 512]. No primeiro timestemp T = 1, você alimentará o LSTM com esses 512 valores de uma só vez e isso é graças às unidades ocultas.

Anexo-lhe algumas referências e links se minha explicação não for muito clara. Q Referência , S Referência .