Fonction torch.nn.LSTM de PyTorch

PyTorch torch.nn 参考手册Manuel de référence torch.nn de PyTorch

torch.nn.LSTMIl s'agit d'un module de PyTorch pour les réseaux Long Short-Term Memory.

LSTM est un type spécial de réseau de neurones récurrent capable d'apprendre des dépendances à long terme et est largement utilisé dans les tâches de modélisation de séquences.

Définition de fonction

torch.nn.LSTM(input_size, hidden_size, num_layers=1, bias=True, batch_first=True, dropout=0, bidirectional=False)

Description des paramètres :

  • input_size(int) : dimension des caractéristiques d'entrée.
  • hidden_size(int) : dimension de l'état caché.
  • num_layers(int) : nombre de couches LSTM. La valeur par défaut est 1.
  • bias(bool) : indique s'il faut utiliser un biais. La valeur par défaut est True.
  • batch_first(bool): Si True, la forme de l'entrée et de la sortie est (batch, seq, feature). La valeur par défaut est True.
  • dropout(float): Dropout utilisé pour les couches non finales. La valeur par défaut est 0.
  • bidirectional(bool): Indique s'il faut utiliser un LSTM bidirectionnel. La valeur par défaut est False.

Entrées et sorties

Entrées :

  • input: Tenseur de forme (batch, seq_len, input_size)
  • h_0: État caché initial, de forme (num_layers * num_directions, batch, hidden_size)
  • c_0: État de cellule initial, de forme (num_layers * num_directions, batch, hidden_size)

Sorties :

  • output: La sortie de la dernière couche cachée, de forme (batch, seq_len, num_directions * hidden_size)
  • h_n: Le dernier état caché de toutes les couches
  • c_n: Le dernier état de cellule de toutes les couches

Exemples d'utilisation

Exemple 1 : Utilisation de base

Créer et utiliser un LSTM :

Exemple

import torch
import torch.nn as nn

# Créer un LSTM : dimension d'entrée 256, dimension cachée 512, 2 couches
lstm = nn.LSTM(input_size=256, hidden_size=512, num_layers=2, batch_first=True)

# Créer une entrée : batch=4, longueur de séquence=10, dimension d'entrée=256
input_tensor = torch.randn(4, 10, 256)

# Passe avant
output, (h_n, c_n) = lstm(input_tensor)

print("Forme de l'entrée :", input_tensor.shape)
print("Forme de sortie :", output.shape)      # (4, 10, 512)
print("Forme de l'état caché :", h_n.shape)     # (2, 4, 512)
print("Forme de l'état de cellule :", c_n.shape)     # (2, 4, 512)

Exemple 2 : LSTM bidirectionnel

Utiliser un LSTM bidirectionnel pour capturer le contexte bidirectionnel :

Exemple

import torch
import torch.nn as nn

# LSTM bidirectionnel
bilstm = nn.LSTM(input_size=256, hidden_size=256, num_layers=2, batch_first=True, bidirectional=True)

input_tensor = torch.randn(4, 10, 256)
output, (h_n, c_n) = bilstm(input_tensor)

print("Forme de sortie du LSTM bidirectionnel :", output.shape)   # (4, 10, 512) = 256*2
print("Forme de l'état caché :", h_n.shape)            # (4, 4, 256) = 2 couches * 2 directions
print("État caché de la dernière couche :", h_n[-2:, :, :].shape)  # Propagation avant et rétropropagation

Exemple 3 : Initialisation de l'état caché

Initialiser manuellement l'état caché :

Exemple

import torch
import torch.nn as nn

lstm = nn.LSTM(input_size=256, hidden_size=512, batch_first=True)

# Créer manuellement l'état caché initial
batch_size = 4
num_layers = 2
hidden_size = 512

h_0 = torch.zeros(num_layers, batch_size, hidden_size)
c_0 = torch.zeros(num_layers, batch_size, hidden_size)

# Passer l'état initial
input_tensor = torch.randn(4, 10, 256)
output, (h_n, c_n) = lstm(input_tensor, (h_0, c_0))

print("Terminé avec un état initial personnalisé")
print("Forme de sortie :", output.shape)

Exemple 4 : Modèle complet de classification de sentiments

Classification de texte basée sur LSTM :

Exemple

import torch
import torch.nn as nn

class LSTMClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes=2):
        super(LSTMClassifier, self).__init__()
        # Couche d'embedding
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        # Couche LSTM
        self.lstm = nn.LSTM(
            input_size=embed_dim,
            hidden_size=hidden_dim,
            num_layers=2,
            batch_first=True,
            bidirectional=True,
            dropout=0.3
        )
        # Couche de classification entièrement connectée
        self.fc = nn.Linear(hidden_dim * 2, num_classes)

    def forward(self, x):
        # x: (batch, seq_len)
        embedded = self.embedding(x)  # (batch, seq_len, embed_dim)

        # Sortie LSTM
        output, (hidden, cell) = self.lstm(embedded)

        # Concaténer les états cachés de la dernière couche bidirectionnelle
        # hidden : (4, batch, hidden_dim) - 2 couches * 2 directions
        hidden = torch.cat([hidden[-2], hidden[-1]], dim=1)  # (batch, hidden_dim*2)

        # Classification
        logits = self.fc(hidden)
        return logits

# Instancier le modèle
vocab_size = 10000
model = LSTMClassifier(vocab_size=vocab_size, embed_dim=128, hidden_dim=128, num_classes=2)

# Entrée de test : batch=8, longueur de séquence=50
input_ids = torch.randint(1, vocab_size, (8, 50))
output = model(input_ids)

print("Structure du modèle:")
print(model)
print("nForme d'entrée :", input_ids.shape)
print("Forme de sortie :", output.shape)  # (8, 2)

Exemple 5 : LSTM empilé multicouche

Réseau LSTM profond :

Exemple

import torch
import torch.nn as nn

# LSTM empilé à 4 couches avec dropout
deep_lstm = nn.LSTM(
    input_size=256,
    hidden_size=512,
    num_layers=4,
    batch_first=True,
    dropout=0.4  # Dropout entre les couches
)

input_tensor = torch.randn(2, 20, 256)
output, (h_n, c_n) = deep_lstm(input_tensor)

print("Forme de sortie du LSTM à 4 couches :", output.shape)
print("Forme de l'état caché (4 couches) :", h_n.shape)
print("Forme de l'état de la cellule (4 couches) :", c_n.shape)

Concept des portes LSTM

Le LSTM contrôle le flux d'informations à travers trois portes :

  • Porte d'oubli: Détermine la quantité d'informations de l'étape temporelle précédente à conserver
  • Porte d'entrée: Détermine la quantité de nouvelles informations à ajouter
  • Porte de sortie: Détermine la quantité d'informations à émettre en sortie

FAQ

Q1 : Que signifie batch_first=True ?

La première dimension des tenseurs d'entrée et de sortie est batch_size. Si False, la première dimension est la longueur de la séquence.

Q2 : Quand faut-il utiliser un LSTM bidirectionnel ?

Les tâches qui nécessitent un contexte bidirectionnel, comme l'étiquetage de séquences et l'analyse des sentiments. La traduction automatique utilise souvent l'architecture encodeur-décodeur.

Q3 : Comment choisir la taille de la couche cachée ?

Généralement 128-512, ajustée selon la complexité de la tâche et le volume de données. Trop petite conduit au sous-apprentissage, trop grande au surapprentissage.

Cas d'utilisation

nn.LSTMLes principaux scénarios d'application incluent :

  • Traitement du langage naturel: Classification de texte, reconnaissance d'entités nommées
  • Prédiction de séries temporelles: Prédiction boursière, reconnaissance vocale
  • Tâches séquence à séquence: Traduction automatique, génération de texte

Astuce : Lors de l'utilisation de bidirectional=True, la dimension de sortie devient hidden_size * 2.

PyTorch torch.nn 参考手册Manuel de référence torch.nn de PyTorch

Autres extensions