Differenza tra una singola rete LSTM e una rete neurale LSTM a 3 unità

LSTM nel seguente codice Keras

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

può essere rappresentato come

Capisco che quando chiamiamo model.predict(np.array([[[1],[2],[3],[4]]]))la (sola) unità LSTM prima elabora il vettore [1], quindi [2] più il feedback dall'input precedente e così via fino al vettore [4]. In altre parole$x_1 = [1], x_2 = [2], x_3 = [3], x_4 = [4]$.

Non capisco come la seguente rete neurale elaborerebbe la stessa sequenza di input [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())

In questo NN abbiamo tre unità LSTM. Come elaborano la sequenza [1],[2],[3],[4]? Sono interconnessi tra loro? Elaborano la sequenza di input in parallelo o una unità elabora la sequenza di input e successivamente il suo input viene inviato alla seconda unità LSTM e così via? Qualcuno potrebbe usare schematicamente questa immagine per spiegare l'intero processo?

In Keras LSTM(n)significa "creare un livello LSTM costituito da unità LSTM. L'immagine seguente mostra quale livello e unità (o neurone) sono, e l'immagine più a destra mostra la struttura interna di una singola unità LSTM.

L'immagine seguente mostra come funziona l'intero livello LSTM.

Come sappiamo, un livello LSTM elabora una sequenza, ovvero $\mathbb{x}_1, \dots, \mathbb{x}_N$. Ad ogni passo$t$ lo strato (ogni neurone) accetta l'input $\mathbb{x_t}$, output dal passaggio precedente $\mathbb{h_{t-1}}$e pregiudizio $b$e genera un vettore $\mathbb{h_t}$. Coordinate di$\mathbb{h_t}$ sono uscite dei neuroni / unità, e quindi la dimensione del vettore $\mathbb{h_t}$è uguale al numero di unità / neuroni. Questo processo continua fino al$\mathbb{x}_N$.

Ora cerchiamo di calcolare il numero di parametri per LSTM(1)e LSTM(3)e confrontate con quella spettacoli Keras quando chiamiamo model.summary().

Permettere $inp$ essere la dimensione del vettore $\mathbb{x_t}$ e $out$ essere la dimensione del vettore $\mathbb{h_t}$(questo è anche il numero di neuroni / unità). Ogni neurone / unità prende il vettore di input, l'output dal passaggio precedente e un bias che rende$inp + out + 1$parametri (pesi). Ma noi abbiamo$out$ numero di neuroni e così abbiamo $out\times(inp + out + 1)$parametri. Infine ogni unità ha 4 pesi (vedi l'immagine più a destra, caselle gialle) e abbiamo la seguente formula per il numero di parametri:

Confrontiamo con ciò che produce Keras.

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

Il numero di unità è 1, la dimensione del vettore di input è 1, quindi $4\times 1 \times (1 + 1 + 1) = 12$.

Esempio 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

Il numero di unità è 3, la dimensione del vettore di input è 2, quindi $4\times 3 \times (2 + 3 +1) = 72$

Di solito lavoro con Tensorflow ma, come ho potuto vedere nella documentazione, è simile a Keras.

Fondamentalmente, quando chiami NONLSTM(3) stai creando LSTM uno sopra l'altro come in questa immagine 1 . Questo è un problema completamente diverso.

Tuttavia, quando stai creando, LSTM(3)stai realizzando un LSTM con 3 unità nascoste o celle nascoste . Sul tuo codice, 3 sarà la dimensione delle celle interne in LSTM. Cosa significa? Ciò significa che la dimensionalità dello stato nascosto e la dimensionalità dello stato di uscita saranno le stesse del parametro delle unità nascoste.

Invece di immaginare un LSTM come qualcosa che ottenga una sequenza di scalari e dia e produca scalare, immagina questo: hai una sequenza di lunghezza T con 512 valori ciascuno T così [Batchsize, T, 512]. Al primo timestemp T = 1, alimenterai LSTM con questi 512 valori contemporaneamente e questo grazie alle unità nascoste.

Vi allego alcuni riferimenti e collegamenti se la mia spiegazione non è molto chiara. Q di riferimento , S Riferimento .