PyTorch LSTM – Formes de l’entrée, de l’état caché, de l’état de la cellule et de la sortie

PyTorch LSTM - Entrée, état caché, état cellulaire et sortie

Dans Pytorch, pour utiliser un LSTM (avec nn.LSTM()), nous devons comprendre comment les tenseurs représentant la série temporelle d’entrée, le vecteur d’état caché et le vecteur d’état de la cellule doivent être formés. Dans cet article, supposons que vous travaillez avec des séries temporelles multivariées. Chaque série temporelle multivariée dans l’ensemble de données contient plusieurs séries temporelles univariées.

Les différences par rapport à LSTMCell de pytorch sont les suivantes:

Pytorch LSTMCell — formes de l’entrée, de l’état caché et de l’état de la cellule

Dans pytorch, pour utiliser un LSTMCell, nous devons comprendre comment les tenseurs représentant la série temporelle d’entrée, l’état caché…

VoAGI.com

  1. Avec nn.LSTM, il est possible de créer plusieurs couches de LSTM en les empilant pour former un LSTM empilé. Le deuxième LSTM prend la sortie du premier LSTM comme entrée, et ainsi de suite.

2. On peut ajouter un dropout dans la classe nn.LSTM.

3. On peut fournir des entrées non groupées à nn.LSTM.

Il y a une autre différence significative qui sera discutée plus tard dans cet article.

Dans cet article, nous utilisons la terminologie suivante:

batch = nombre de séries temporelles multivariées dans un seul lot provenant de l’ensemble de données

input_features = nombre de séries temporelles univariées dans une série temporelle multivariée

time steps = nombre d’étapes de temps dans chaque série temporelle multivariée

Le lot de séries temporelles multivariées à donner en entrée au LSTM doit être un tenseur de forme (time_steps, batch, input_features)

L’image suivante donne une compréhension de cette forme pour l’entrée:

Cependant, dans LSTM, il y a une autre façon de former l’entrée. Cela est expliqué ci-dessous.

Lors de l’initialisation d’un objet LSTM, les arguments input_features et hidden_size doivent être donnés.

Ici,

input_features = nombre de séries temporelles univariées dans une série temporelle multivariée (même valeur que input_features mentionné ci-dessus)

hidden_size = nombre de dimensions dans le vecteur d’état caché.

D’autres arguments que la classe LSTM peut prendre:

num_layers = nombre de couches LSTM empilées les unes sur les autres. Lorsque plusieurs couches sont empilées les unes sur les autres, cela s’appelle un LSTM empilé. Par défaut, le nombre de couches est de 1

dropout = si différent de zéro, une couche dropout sera ajoutée à la sortie de chaque couche LSTM avec une probabilité de dropout égale à cette valeur. Par défaut, cette valeur est de 0, ce qui signifie qu’il n’y a pas de dropout.

batch_first = si cela est vrai, les tenseurs d’entrée et de sortie auront des dimensions (batch, time_steps, input_features) au lieu de (time_steps, batch, input_features). Par défaut, c’est faux.

proj_size = taille de la projection. Si proj_size > 0, un LSTM avec des projections sera utilisé.

La série temporelle, l’état caché initial et l’état de la cellule initial doivent être donnés en entrée pour une propagation avant à travers le LSTM.

La propagation avant de l’entrée, de l’état caché initial et de l’état de la cellule initial à travers l’objet LSTM doit être dans le format:

LSTM(input_time_series, (h_0, c_0))

Voyons comment former le vecteur d’état caché et le vecteur d’état de la cellule avant de les donner au LSTM pour une propagation avant.

h_0 — (num_layers, batch, h_out). Ici, h_out = proj_size si proj_size > 0 sinon hidden_size

c_0 — (num_layers, batch, hidden_size)

La figure suivante aide à comprendre la forme des vecteurs cachés.

Une figure similaire s’applique également aux vecteurs d’état de la cellule.

À partir de la figure, on peut comprendre que la dimensionnalité des états cachés et des états de cellule pour toutes les couches est la même.

Considérez le code suivant:

import torchimport torch.nn as nn lstm_0 = nn.LSTM(10, 20, 2) # (input_features, hidden_size, num_layers)inp = torch.randn(4, 3, 10) # (time_steps, batch, input_features) -> série temporelle d'entréeh0 = torch.randn(2, 3, 20) # (num_layers, batch, hidden_size) -> valeur initiale de l'état cachéc0 = torch.randn(2, 3, 20) # (num_layers, batch, hidden_size) -> valeur initiale de l'état de celluleoutput, (hn, cn) = lstm_0(input, (h0, c0)) # passage avant de l'entrée à travers LSTM

Appeler nn.LSTM() appellera la méthode magique __init__() et créera l’objet LSTM. Dans le code ci-dessus, cet objet est référencé comme lstm_0.

Dans les RNN en général (LSTM est un type de RNN), chaque pas de temps de la série temporelle d’entrée doit être passé dans le RNN un par un dans un ordre séquentiel pour être traité par le RNN.

Pour traiter des séries temporelles multivariées en lot à l’aide d’un LSTM, chaque pas de temps dans toutes les MTS du lot doit être passé séquentiellement à travers le LSTM.

Un seul appel à la passe avant du LSTM traite la série entière en traitant chaque pas de temps séquentiellement. Cela est différent de LSTMCell dans lequel un seul appel traite seulement un pas de temps et non la série entière.

La sortie du code ci-dessus est:

tensor([[[ 3.8995e-02,  1.1831e-01,  1.1922e-01,  1.3734e-01,  1.6157e-02,           3.3094e-02,  2.8738e-01, -6.9250e-02, -1.8313e-01, -1.2594e-01,           1.4951e-01, -3.2489e-01,  2.1723e-01, -1.1722e-01, -2.5523e-01,          -6.5740e-02, -5.2556e-02, -2.7092e-01,  3.0432e-01,  1.4228e-01],         [ 9.2476e-02,  1.1557e-02, -9.3600e-03, -5.2662e-02,  5.5299e-03,          -6.2017e-02, -1.9826e-01, -2.7072e-01, -5.5575e-02, -2.3024e-03,          -2.6832e-01, -5.8481e-01, -8.3415e-03, -2.8817e-01,  4.6101e-03,           3.5043e-02, -6.2501e-01,  4.2930e-02, -5.4698e-01, -5.8626e-01],         [-2.8034e-01, -3.4194e-01, -2.1888e-02, -2.1787e-01, -4.0497e-01,          -3.6124e-01, -1.5303e-01, -1
Dans cette sortie, il y a 4 tableaux correspondant aux 4 étapes temporelles. Chacune de ces étapes temporelles contient 3 tableaux correspondant aux 3 séries temporelles multivariées (MTS) du lot. Chacun de ces 3 tableaux contient 20 éléments -> cela correspond à l'état caché. Ainsi, pour chaque vecteur x_t à chaque étape temporelle de chaque MTS, un état caché est produit. Ce sont les états cachés dans la dernière couche du LSTM empilé.
Sortie : (séries_temporelles_multivariées_de_sortie, (h_n, c_n))
Si vous imprimez hn qui est présent dans le code ci-dessus, voici la sortie :
tensor([[[-0.3046, -0.1601, -0.0024, -0.0138, -0.1810, -0.1406, -0.1181,           0.0634,  0.0936, -0.1094, -0.2822, -0.2263, -0.1090,  0.2933,           0.0760, -0.1877, -0.0877, -0.0813,  0.0848,  0.0121],         [ 0.0349, -0.2068,  0.1353,  0.1121,  0.1940, -0.0663, -0.0031,          -0.2047, -0.0008, -0.0439, -0.0249,  0.0679, -0.0530,  0.1078,          -0.0631,  0.0430,  0.0873, -0.1087,  0.3161, -0.1618],         [-0.0528, -0.2693,  0.1001, -0.1097,  0.0097, -0.0677, -0.0048,           0.0509,  0.0655,  0.0075, -0.1127, -0.0641,  0.0050,  0.1991,           0.0370, -0.0923,  0.0629,  0.0122,  0.0688, -0.2374]],        [[ 0.0273, -0.1082,  0.0243, -0.0924,  0.0077,  0.0359,  0.1209,           0.0545, -0.0838,  0.0139,  0.0086, -0.2110,  0.0880, -0.1371,          -0.0171,  0.0332,  0.0509, -0.1481,  0.2044, -0.1747],         [ 0.0087, -0.0943,  0.0111, -0.0618, -0.0376, -0.1297,  0.0497,           0.0071, -0.0905,  0.0700, -0.1282, -0.2104,  0.1350, -0.1672,           0.0697,  0.0679,  0.0512,  0.0183,  0.1531, -0.2602],         [-0.0705, -0.1263,  0.0099, -0.0797, -0.1074, -0.0752,  0.1020,           0.0254, -0.1382, -0.0007, -0.0787, -0.1934,  0.1283, -0.0721,           0.1132,  0.0252,  0.0765,  0.0238,  0.1846, -0.2379]]],       grad_fn=<StackBackward0>)


Ceci contient les vecteurs d'état caché dans la première couche et la deuxième couche du LSTM empilé pour la dernière étape temporelle de chacune des 3 MTS du lot. Si vous remarquez, l'état caché de la deuxième couche (dernière couche) est le même que l'état caché de la dernière étape temporelle mentionnée précédemment.


Donc, la dimensionnalité de sortie de MTS est (time_steps, batch, hidden_size).


Cette dimensionnalité de sortie peut être comprise à partir de l'image ci-dessous:




Dimensionnalité de h_n: (num_layers, batch, h_out)


Dimensionnalité de c_n: (num_layers, batch, hidden_size)


                  
We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

                  

                  

                  

                    

                      Share:

















                    

                  

                  

                  

                    
                      
                    
                    
                      
                    
                  

                  

                        

        

          
Was this article helpful?

        


        

          
          
        


        
93 out of 132 found this helpful

      

                  
Related articles

Discover more

Want to read more? Go here