Diferencia entre una sola unidad LSTM y una red neuronal LSTM de 3 unidades

El LSTM en el siguiente 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())

puede ser representado como

Entiendo que cuando llamamos a model.predict(np.array([[[1],[2],[3],[4]]]))la (única) unidad LSTM, primero se procesa el vector [1], luego [2] más la retroalimentación de la entrada anterior y así sucesivamente hasta el vector [4]. En otras palabras$x_1 = [1], x_2 = [2], x_3 = [3], x_4 = [4]$.

No entiendo cómo la siguiente red neuronal procesará la misma secuencia 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())

En este NN tenemos tres unidades LSTM. ¿Cómo procesan la secuencia [1],[2],[3],[4]? ¿Están interconectados entre sí? ¿Procesan la secuencia de entrada en paralelo o una unidad procesa la secuencia de entrada y luego su entrada se alimenta a la segunda unidad LSTM y así sucesivamente? ¿Podría alguien usar esquemáticamente esta imagen para explicar todo el proceso?

En Keras LSTM(n)significa "crear una capa LSTM que consta de unidades LSTM. La siguiente imagen muestra qué capa y unidad (o neurona) son, y la imagen de la derecha muestra la estructura interna de una sola unidad LSTM.

La siguiente imagen muestra cómo funciona toda la capa LSTM.

Como sabemos, una capa LSTM procesa una secuencia, es decir, $\mathbb{x}_1, \dots, \mathbb{x}_N$. En cada paso$t$ la capa (cada neurona) toma la entrada $\mathbb{x_t}$, salida del paso anterior $\mathbb{h_{t-1}}$y sesgo $b$y genera un vector $\mathbb{h_t}$. Coordenadas de$\mathbb{h_t}$ son salidas de las neuronas / unidades y, por lo tanto, el tamaño del vector $\mathbb{h_t}$es igual al número de unidades / neuronas. Este proceso continúa hasta$\mathbb{x}_N$.

Ahora vamos a calcular el número de parámetros para LSTM(1)y LSTM(3)y compararlo con lo que se muestra Keras cuando llamamos model.summary().

Dejar $inp$ ser el tamaño del vector $\mathbb{x_t}$ y $out$ ser el tamaño del vector $\mathbb{h_t}$(este también es el número de neuronas / unidades). Cada neurona / unidad toma el vector de entrada, la salida del paso anterior y un sesgo que hace$inp + out + 1$parámetros (pesos). Pero tenemos$out$ número de neuronas y así tenemos $out\times(inp + out + 1)$parámetros Finalmente, cada unidad tiene 4 pesos (ver la imagen de la derecha, cuadros amarillos) y tenemos la siguiente fórmula para el número de parámetros:

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

Comparemos con lo que produce Keras.

Ejemplo 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
  _________________________________________________________________

El número de unidades es 1, el tamaño del vector de entrada es 1, entonces $4\times 1 \times (1 + 1 + 1) = 12$.

Ejemplo 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

El número de unidades es 3, el tamaño del vector de entrada es 2, entonces $4\times 3 \times (2 + 3 +1) = 72$

Normalmente trabajo con Tensorflow pero, como pude ver en la documentación, es similar a Keras.

Básicamente, cuando estás llamando NOLSTM(3) estás creando LSTM uno encima del otro como en esta imagen 1 . Este es un problema completamente diferente.

Sin embargo, cuando está creando LSTM(3), está haciendo un LSTM con 3 unidades ocultas o celdas ocultas . En su código, 3 será la dimensión de las celdas internas en LSTM. ¿Qué significa? Esto significa que la dimensionalidad del estado oculto y la dimensionalidad del estado de salida serán las mismas que su parámetro de unidades ocultas.

En lugar de imaginar un LSTM como algo que obtiene una secuencia de escalares y da un escalar de salida, imagine esto: tiene una secuencia de longitud T con 512 valores de cada T, entonces [Batchsize, T, 512]. En el primer paso de tiempo T = 1, alimentarás el LSTM con estos 512 valores a la vez y esto es gracias a las unidades ocultas.

Te adjunto algunas referencias y enlaces si mi explicación no es muy clara. Q Referencia , S Referencia .