PyTorch torch.nn.LSTM-Funktion
PyTorch torch.nn Referenzhandbuch
torch.nn.LSTMEs ist ein Modul in PyTorch für Long-Short-Term-Memory-Netzwerke.
LSTM ist eine spezielle Art eines rekurrenten neuronalen Netzes, das langfristige Abhängigkeiten lernen kann und häufig in Aufgaben der Sequenzmodellierung verwendet wird.
Funktionsdefinition
torch.nn.LSTM(input_size, hidden_size, num_layers=1, bias=True, batch_first=True, dropout=0, bidirectional=False)
Parameterbeschreibung:
input_size(int): Dimension der Eingabemerkmale.hidden_size(int): Dimension des verborgenen Zustands.num_layers(int): Anzahl der LSTM-Schichten. Standardwert ist 1.bias(bool): Ob Bias verwendet werden soll. Standardwert ist True.batch_first(bool): Wenn True, ist die Form der Eingabe und Ausgabe (batch, seq, feature). Standard ist True.dropout(float): Dropout wird für nicht letzte Schichten verwendet. Standard ist 0.bidirectional(bool): Ob bidirektionaler LSTM verwendet werden soll. Standard ist False.
Eingaben und Ausgaben
Eingaben:
input: Tensor der Form (batch, seq_len, input_size)h_0: Anfänglicher verborgener Zustand, Form (num_layers * num_directions, batch, hidden_size)c_0: Anfänglicher Zellzustand, Form (num_layers * num_directions, batch, hidden_size)
Ausgaben:
output: Die Ausgabe der letzten verborgenen Schicht, Form (batch, seq_len, num_directions * hidden_size)h_n: Der letzte verborgene Zustand aller Schichtenc_n: Der letzte Zellzustand aller Schichten
Anwendungsbeispiele
Beispiel 1: Grundlegende Verwendung
LSTM erstellen und verwenden:
Beispiel
import torch
import torch.nn as nn
# LSTM erstellen: Eingabedimension 256, Hidden-Dimension 512, 2 Schichten
lstm = nn.LSTM(input_size=256, hidden_size=512, num_layers=2, batch_first=True)
# Eingabe erstellen: Batch=4, Sequenzlänge=10, Eingabedimension=256
input_tensor = torch.randn(4, 10, 256)
# Vorwärtsdurchlauf
output, (h_n, c_n) = lstm(input_tensor)
print("Eingabeform:", input_tensor.shape)
print("Ausgabeform:", output.shape) # (4, 10, 512)
print("Form des versteckten Zustands:", h_n.shape) # (2, 4, 512)
print("Form des Zellzustands:", c_n.shape) # (2, 4, 512)
import torch.nn as nn
# LSTM erstellen: Eingabedimension 256, Hidden-Dimension 512, 2 Schichten
lstm = nn.LSTM(input_size=256, hidden_size=512, num_layers=2, batch_first=True)
# Eingabe erstellen: Batch=4, Sequenzlänge=10, Eingabedimension=256
input_tensor = torch.randn(4, 10, 256)
# Vorwärtsdurchlauf
output, (h_n, c_n) = lstm(input_tensor)
print("Eingabeform:", input_tensor.shape)
print("Ausgabeform:", output.shape) # (4, 10, 512)
print("Form des versteckten Zustands:", h_n.shape) # (2, 4, 512)
print("Form des Zellzustands:", c_n.shape) # (2, 4, 512)
Beispiel 2: Bidirektionales LSTM
Bidirektionales LSTM verwenden, um bidirektionalen Kontext zu erfassen:
Beispiel
import torch
import torch.nn as nn
# Bidirektionales LSTM
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("Ausgabeform des bidirektionalen LSTM:", output.shape) # (4, 10, 512) = 256*2
print("Form des versteckten Zustands:", h_n.shape) # (4, 4, 256) = 2 Schichten * 2 Richtungen
print("Versteckter Zustand der letzten Schicht:", h_n[-2:, :, :].shape) # Vorwärts- und Rückwärtsdurchlauf
import torch.nn as nn
# Bidirektionales LSTM
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("Ausgabeform des bidirektionalen LSTM:", output.shape) # (4, 10, 512) = 256*2
print("Form des versteckten Zustands:", h_n.shape) # (4, 4, 256) = 2 Schichten * 2 Richtungen
print("Versteckter Zustand der letzten Schicht:", h_n[-2:, :, :].shape) # Vorwärts- und Rückwärtsdurchlauf
Beispiel 3: Initialisieren des versteckten Zustands
Versteckten Zustand manuell initialisieren:
Beispiel
import torch
import torch.nn as nn
lstm = nn.LSTM(input_size=256, hidden_size=512, batch_first=True)
# Anfänglichen versteckten Zustand manuell erstellen
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)
# Anfänglichen Zustand übergeben
input_tensor = torch.randn(4, 10, 256)
output, (h_n, c_n) = lstm(input_tensor, (h_0, c_0))
print("Abgeschlossen mit benutzerdefiniertem Anfangszustand")
print("Ausgabeform:", output.shape)
import torch.nn as nn
lstm = nn.LSTM(input_size=256, hidden_size=512, batch_first=True)
# Anfänglichen versteckten Zustand manuell erstellen
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)
# Anfänglichen Zustand übergeben
input_tensor = torch.randn(4, 10, 256)
output, (h_n, c_n) = lstm(input_tensor, (h_0, c_0))
print("Abgeschlossen mit benutzerdefiniertem Anfangszustand")
print("Ausgabeform:", output.shape)
Beispiel 4: Vollständiges Sentiment-Klassifikationsmodell
Textklassifikation basierend auf LSTM:
Beispiel
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__()
# Embedding-Schicht
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
# LSTM-Schicht
self.lstm = nn.LSTM(
input_size=embed_dim,
hidden_size=hidden_dim,
num_layers=2,
batch_first=True,
bidirectional=True,
dropout=0.3
)
# Vollständig verbundene Klassifikationsschicht
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)
# LSTM-Ausgabe
output, (hidden, cell) = self.lstm(embedded)
# Hidden States der letzten bidirektionalen Schicht verketten
# hidden: (4, batch, hidden_dim) - 2 Schichten * 2 Richtungen
hidden = torch.cat([hidden[-2], hidden[-1]], dim=1) # (batch, hidden_dim*2)
# Klassifikation
logits = self.fc(hidden)
return logits
# Modell instanziieren
vocab_size = 10000
model = LSTMClassifier(vocab_size=vocab_size, embed_dim=128, hidden_dim=128, num_classes=2)
# Testeingabe: batch=8, Sequenzlänge=50
input_ids = torch.randint(1, vocab_size, (8, 50))
output = model(input_ids)
print("Modellstruktur:")
print(model)
print("nEingabeform:", input_ids.shape)
print("Ausgabeform:", output.shape) # (8, 2)
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__()
# Embedding-Schicht
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
# LSTM-Schicht
self.lstm = nn.LSTM(
input_size=embed_dim,
hidden_size=hidden_dim,
num_layers=2,
batch_first=True,
bidirectional=True,
dropout=0.3
)
# Vollständig verbundene Klassifikationsschicht
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)
# LSTM-Ausgabe
output, (hidden, cell) = self.lstm(embedded)
# Hidden States der letzten bidirektionalen Schicht verketten
# hidden: (4, batch, hidden_dim) - 2 Schichten * 2 Richtungen
hidden = torch.cat([hidden[-2], hidden[-1]], dim=1) # (batch, hidden_dim*2)
# Klassifikation
logits = self.fc(hidden)
return logits
# Modell instanziieren
vocab_size = 10000
model = LSTMClassifier(vocab_size=vocab_size, embed_dim=128, hidden_dim=128, num_classes=2)
# Testeingabe: batch=8, Sequenzlänge=50
input_ids = torch.randint(1, vocab_size, (8, 50))
output = model(input_ids)
print("Modellstruktur:")
print(model)
print("nEingabeform:", input_ids.shape)
print("Ausgabeform:", output.shape) # (8, 2)
Beispiel 5: Mehrschichtiges gestapeltes LSTM
Tiefes LSTM-Netzwerk:
Beispiel
import torch
import torch.nn as nn
# 4-schichtiges gestapeltes LSTM mit Dropout
deep_lstm = nn.LSTM(
input_size=256,
hidden_size=512,
num_layers=4,
batch_first=True,
dropout=0.4 # Dropout zwischen den Schichten
)
input_tensor = torch.randn(2, 20, 256)
output, (h_n, c_n) = deep_lstm(input_tensor)
print("Ausgabeform der 4-Schicht-LSTM:", output.shape)
print("Form des Hidden States (4 Schichten):", h_n.shape)
print("Form des Zellzustands (4 Schichten):", c_n.shape)
import torch.nn as nn
# 4-schichtiges gestapeltes LSTM mit Dropout
deep_lstm = nn.LSTM(
input_size=256,
hidden_size=512,
num_layers=4,
batch_first=True,
dropout=0.4 # Dropout zwischen den Schichten
)
input_tensor = torch.randn(2, 20, 256)
output, (h_n, c_n) = deep_lstm(input_tensor)
print("Ausgabeform der 4-Schicht-LSTM:", output.shape)
print("Form des Hidden States (4 Schichten):", h_n.shape)
print("Form des Zellzustands (4 Schichten):", c_n.shape)
Konzept der LSTM-Gates
LSTM steuert den Informationsfluss durch drei Gates:
- Vergessens-Gate: Bestimmt, wie viel Information aus dem vorherigen Zeitschritt beibehalten wird
- Eingabe-Gate: Bestimmt, wie viel neue Information hinzugefügt wird
- Ausgabe-Gate: Bestimmt, wie viel Information ausgegeben wird
FAQ
F1: Was bedeutet batch_first=True?
Die erste Dimension der Eingabe- und Ausgabe-Tensoren ist batch_size. Wenn False, ist die erste Dimension die Sequenzlänge.
F2: Wann sollte ein bidirektionales LSTM verwendet werden?
Aufgaben, die bidirektionalen Kontext erfordern, wie Sequenzkennzeichnung und Sentimentanalyse. Maschinelle Übersetzung verwendet häufig die Encoder-Decoder-Architektur.
F3: Wie wählt man die Hidden-Layer-Größe?
Üblicherweise 128-512, angepasst an Aufgabenkomplexität und Datenmenge. Zu klein führt zu Underfitting, zu groß zu Overfitting.
Anwendungsfälle
nn.LSTMZu den wichtigsten Anwendungsszenarien gehören:
- Verarbeitung natürlicher Sprache: Textklassifikation, Named-Entity-Erkennung
- Zeitreihenvorhersage: Aktienvorhersage, Spracherkennung
- Sequence-to-Sequence-Aufgaben: Maschinelle Übersetzung, Textgenerierung
Tipp: Bei Verwendung von bidirectional=True beträgt die Ausgabedimension hidden_size * 2.
Andere Erweiterungen