PyTorch torch.nn.GRU-Funktion
PyTorch torch.nn Referenzhandbuch
torch.nn.GRUDas Gated Recurrent Unit-Modul in PyTorch.
GRU ist eine vereinfachte Version von LSTM, mit weniger Parametern, schnellerer Berechnung und ähnlicher Leistung.
Funktionsdefinition
torch.nn.GRU(input_size, hidden_size, num_layers=1, bias=True, batch_first=True, dropout=0, bidirectional=False)
Anwendungsbeispiele
Beispiel 1: Grundlegende Verwendung
Beispiel
import torch
import torch.nn as nn
# GRU: 256-dim Eingabe, 256-dim versteckte Dimension, 2 Schichten
gru = nn.GRU(input_size=256, hidden_size=256, num_layers=2, batch_first=True)
# Eingabe: Batch=4, Sequenz=10, Merkmale=256
x = torch.randn(4, 10, 256)
output, hidden = gru(x)
print("Eingabeform:", x.shape)
print("Ausgabeform:", output.shape)
print("Form des versteckten Zustands:", hidden.shape)
import torch.nn as nn
# GRU: 256-dim Eingabe, 256-dim versteckte Dimension, 2 Schichten
gru = nn.GRU(input_size=256, hidden_size=256, num_layers=2, batch_first=True)
# Eingabe: Batch=4, Sequenz=10, Merkmale=256
x = torch.randn(4, 10, 256)
output, hidden = gru(x)
print("Eingabeform:", x.shape)
print("Ausgabeform:", output.shape)
print("Form des versteckten Zustands:", hidden.shape)
Beispiel 2: Vergleich mit LSTM
Beispiel
import torch
import torch.nn as nn
import time
# LSTM und GRU mit derselben Konfiguration
lstm = nn.LSTM(256, 256, 1, batch_first=True)
gru = nn.GRU(256, 256, 1, batch_first=True)
x = torch.randn(32, 100, 256)
# Leistungsvergleich
for model, name in [(lstm, "LSTM"), (gru, "GRU")]:
start = time.time()
for _ in range(100):
_ = model(x)
print(f"{name} Zeit: {time.time()-start:.3f}s")
import torch.nn as nn
import time
# LSTM und GRU mit derselben Konfiguration
lstm = nn.LSTM(256, 256, 1, batch_first=True)
gru = nn.GRU(256, 256, 1, batch_first=True)
x = torch.randn(32, 100, 256)
# Leistungsvergleich
for model, name in [(lstm, "LSTM"), (gru, "GRU")]:
start = time.time()
for _ in range(100):
_ = model(x)
print(f"{name} Zeit: {time.time()-start:.3f}s")
Beispiel 3: Klassifikationsaufgabe
Beispiel
import torch
import torch.nn as nn
class GRUClassifier(nn.Module):
def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
super(GRUClassifier, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim)
self.gru = nn.GRU(embed_dim, hidden_dim, batch_first=True, bidirectional=True)
self.fc = nn.Linear(hidden_dim * 2, num_classes)
def forward(self, x):
embedded = self.embedding(x)
_, hidden = self.gru(embedded)
# Konkateniere die finalen Hidden-States der bidirektionalen
hidden = torch.cat([hidden[-2], hidden[-1]], dim=1)
return self.fc(hidden)
model = GRUClassifier(10000, 128, 128, 2)
x = torch.randint(0, 10000, (8, 50))
output = model(x)
print("Eingabe:", x.shape, "-> Ausgabe:", output.shape)
import torch.nn as nn
class GRUClassifier(nn.Module):
def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
super(GRUClassifier, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim)
self.gru = nn.GRU(embed_dim, hidden_dim, batch_first=True, bidirectional=True)
self.fc = nn.Linear(hidden_dim * 2, num_classes)
def forward(self, x):
embedded = self.embedding(x)
_, hidden = self.gru(embedded)
# Konkateniere die finalen Hidden-States der bidirektionalen
hidden = torch.cat([hidden[-2], hidden[-1]], dim=1)
return self.fc(hidden)
model = GRUClassifier(10000, 128, 128, 2)
x = torch.randint(0, 10000, (8, 50))
output = model(x)
print("Eingabe:", x.shape, "-> Ausgabe:", output.shape)
LSTM vs. GRU
| Aspekt | LSTM | GRU |
|---|---|---|
| Parameteranzahl | Mehr | Weniger |
| Gating | 3 Gates | 2 Gates |
| Berechnung | Langsamer | Schneller |
Anwendungsfälle
- Sequenzmodellierung: Text, Audio
- Schnelles Prototyping: Wenn Ressourcen begrenzt sind
- Maschinelle Übersetzung: Encoder-Seite
Andere Erweiterungen