Différence entre un réseau de neurones LSTM à une unité et LSTM à 3 unités

Le LSTM dans le code Keras suivant

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

peut être représenté comme

Je comprends que lorsque nous appelons model.predict(np.array([[[1],[2],[3],[4]]]))l'unité (uniquement) LSTM traite d'abord le vecteur [1], puis [2] plus le retour de l'entrée précédente et ainsi de suite jusqu'au vecteur [4]. En d'autres termes, .$x_1 = [1], x_2 = [2], x_3 = [3], x_4 = [4]$

Je ne comprends pas comment le réseau de neurones suivant traiterait la même séquence d'entrée [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())

Dans ce NN, nous avons trois unités LSTM. Comment traitent-ils la séquence [1],[2],[3],[4]? Sont-ils interconnectés entre eux? Traitent-ils la séquence d'entrée en parallèle ou une unité traite-t-elle la séquence d'entrée et plus tard son entrée est envoyée à la deuxième unité LSTM et ainsi de suite? Quelqu'un pourrait-il utiliser schématiquement cette image pour expliquer tout le processus?

En Keras LSTM(n)signifie "créer une couche LSTM composée d'unités LSTM. L'image suivante montre ce que sont la couche et l'unité (ou neurone), et l'image la plus à droite montre la structure interne d'une seule unité LSTM.

L'image suivante montre comment fonctionne toute la couche LSTM.

Comme nous le savons, une couche LSTM traite une séquence, c'est-à-dire . À chaque étape la couche (chaque neurone) prend l'entrée , la sortie de l'étape précédente , et le biais , et un vecteur . Les coordonnées de sont des sorties des neurones / unités, et donc la taille du vecteur est égale au nombre d'unités / neurones. Ce processus se poursuit jusqu'à .$\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$

Maintenant , nous allons calculer le nombre de paramètres pour LSTM(1)et LSTM(3)et le comparer avec ce que montre KERAS quand nous appelons model.summary().

Soit la taille du vecteur et la taille du vecteur (c'est aussi le nombre de neurones / unités). Chaque neurone / unité prend un vecteur d'entrée, une sortie de l'étape précédente et un biais qui crée paramètres d' (poids). Mais nous avons certain nombre de neurones et nous avons donc paramètres . Enfin, chaque unité a 4 poids (voir l'image la plus à droite, les cases jaunes) et nous avons la formule suivante pour le nombre de paramètres: $inp$$\mathbb{x_t}$$out$$\mathbb{h_t}$$inp + out + 1$$out$$out\times(inp + out + 1)$

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

Comparons avec ce que Keras produit.

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

Le nombre d'unités est 1, la taille du vecteur d'entrée est 1, donc .$4\times 1 \times (1 + 1 + 1) = 12$

Exemple 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

Le nombre d'unités est 3, la taille du vecteur d'entrée est 2, donc$4\times 3 \times (2 + 3 +1) = 72$

Je travaille généralement avec Tensorflow mais comme je pouvais le voir dans la documentation, il est similaire à Keras.

Fondamentalement, lorsque vous appelez, LSTM(3)vous ne créez PAS LSTM les uns sur les autres comme sur cette image 1 . C'est un problème complètement différent.

Cependant, lorsque vous créez, LSTM(3)vous créez un LSTM avec 3 unités cachées ou cellules cachées . Sur votre code, 3 sera la dimension des cellules internes dans LSTM. Qu'est-ce que ça veut dire? Cela signifie que la dimensionnalité de l'état caché et la dimensionnalité de l'état de sortie seront les mêmes que votre paramètre d'unités cachées.

Au lieu d'imaginer un LSTM comme quelque chose qui obtient une séquence de scalaires et donne et produit un scalaire, imaginez ceci: vous avez une séquence de longueur T avec 512 valeurs chaque T donc [Batchsize, T, 512]. Au premier timestemp T = 1, vous alimenterez le LSTM avec ces 512 valeurs à la fois et ceci grâce aux unités cachées.

Je vous attache quelques références et liens si mon explication n'est pas très claire. Q Référence , S Référence .