PyTorch-Worteinbettung
Die Worteinbettung ist eine der grundlegendsten und wichtigsten Techniken in der natürlichen Sprachverarbeitung.
Die Worteinbettung bildet diskrete Wortsymbole auf kontinuierliche dichte Vektoren ab, wodurch Maschinen Textdaten verstehen und verarbeiten können.
PyTorch bietetnn.EmbeddingModul zur Implementierung dieser Funktionalität, das als Grundlage für den Aufbau verschiedener NLP-Modelle dient.
1. Grundlegende Konzepte des Word Embeddings
In einem Computer ist Text im Wesentlichen eine Folge von Ganzzahlen. Jedem Wort wird eine eindeutige Index-ID zugewiesen, aber diese diskrete Darstellung hat ein Problem: Semantisch ähnliche Wörter können in ihrer Bedeutung nahe beieinanderliegen, doch ihre IDs stehen in keinerlei Beziehung zueinander.
Word Embedding löst dieses Problem durch das Erlernen einerEmbedding-Matrix:
\[ E \in \mathbb{R}^{V \times D} \]
Dabei ist \(V\) die Vokabulargröße und \(D\) die Embedding-Dimension. Jede Wort-ID entspricht einer Zeile in der Embedding-Matrix, und ihre Vektordarstellung wird durch eine Lookup-Operation ermittelt:
\[ \text{embedding} = E[\text{word\_id}] \]
Die Vorteile von Word Embedding umfassen:
- Umwandlung hochdimensionaler dünnbesetzter One-Hot-Vektoren in niedrigdimensionale dichte Vektoren, wodurch der Rechenaufwand erheblich reduziert wird
- Semantisch ähnliche Wörter liegen im Vektorraum näher beieinander, und die Wortähnlichkeit kann über die Kosinusähnlichkeit berechnet werden
- Embedding-Vektoren sind lernbare Parameter und können durch Backpropagation automatisch angepasst werden
2. nn.Embedding im Detail erklärt
nn.Embeddingist die von PyTorch bereitgestellte Wort-Embedding-Schicht, die die Erstellung der Embedding-Matrix und die Lookup-Operation kapselt.
2.1 Grundlegende Verwendung
Beispiel
import torch.nn as nn
# Eine Embedding-Schicht erstellen
# num_embeddings: Vokabulargröße (vocab_size)
# embedding_dim: Einbettungsdimension (embedding_dim)
vocab_size = 10000
embedding_dim = 256
embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)
# Die Form der Embedding-Matrix anzeigen
print(embedding.weight.shape) # torch.Size([10000, 256])
# Wortindizes (LongTensor) eingeben, um Embedding-Vektoren zu erhalten
word_ids = torch.tensor([0, 1, 2, 9999]) # Beliebige Wortindizes
embedded = embedding(word_ids)
print(embedded.shape) # torch.Size([4, 256])
# Jede Wort-ID entspricht einem 256-dimensionalen Vektor
2.2 Details zu den Parametern von nn.Embedding
Beispiel
embedding = nn.Embedding(
num_embeddings=10000, # Größe des Vokabulars, muss größer oder gleich dem maximalen Indexwert in der Eingabe sein
embedding_dim=256, # Dimension des Embedding-Vektors, üblicherweise 50, 100, 200, 300 usw.
padding_idx=None, # Index des Padding-Worts; der Embedding-Vektor für das Padding-Wort besteht ausschließlich aus Nullen
max_norm=None, # Maximale Norm des Embedding-Vektors, wird zur Normalisierung verwendet
norm_type=2.0, # Normalisierungstyp, üblicherweise L2-Norm
scale_grad_by_freq=False,# Gradienten anhand der Worthäufigkeit skalieren
sparse=False, # Ob sparse Gradienten verwendet werden sollen (spart GPU-Speicher, aber das Training ist langsamer)
_weight=None, # Vordefinierte Gewichte, verwendet zum Laden vortrainierter Embeddings
)
# Anzahl der Parameter anzeigen
total_params = embedding.num_embeddings * embedding.embedding_dim
print(f"Parameteranzahl der Embedding-Schicht: {total_params:,}")
# 10000 * 256 = 2,560,000
Die Anzahl der Parameter in der Embedding-Schicht = Vokabulargröße × Embedding-Dimension. Dies ist eine sehr große Matrix. Üblicherweise macht die Embedding-Schicht eines NLP-Modells einen großen Anteil der Gesamtparameteranzahl des Modells aus.
2.3 Padding-Index padding_idx
Bei der Verarbeitung von Sequenzen variabler Länge müssen kurze Sequenzen mit Padding versehen werden. Durch die Verwendung vonpadding_idxkann der Embedding-Vektor des Padding-Worts auf einen Nullvektor fixiert werden, wodurch verhindert wird, dass Padding-Inhalte das Modell beeinflussen:
Beispiel
import torch.nn as nn
# padding_idx=0 setzen, bedeutet, dass Index 0 das Padding-Wort ist
embedding = nn.Embedding(num_embeddings=10000, embedding_dim=128, padding_idx=0)
# Die Gewichte initialisieren
nn.init.uniform_(embedding.weight, -0.1, 0.1)
# Der Embedding-Vektor bei Index 0 besteht nur aus Nullen
word_0 = embedding(torch.tensor([0]))
print(f"Einbettung des Padding-Wortes: {word_0}") # Alle Nullen
# Andere Indizes bleiben normal
word_5 = embedding(torch.tensor([5]))
print(f"Einbettung von Wort 5: {word_5}") # Nicht-Null-Werte
2.4 Max-Norm-Normalisierung
Verwendungmax_normkann die Norm von Einbettungsvektoren begrenzen und dadurch verhindern, dass sie während des Trainings zu groß werden:
Beispiel
import torch.nn as nn
# Maximale Norm auf 1.0 setzen
embedding = nn.Embedding(num_embeddings=1000, embedding_dim=64, max_norm=1.0)
# Beliebige Wortindizes eingeben
ids = torch.tensor([1, 2, 3])
embedded = embedding(ids)
# L2-Norm jedes Vektors prüfen
norms = torch.norm(embedded, p=2, dim=1)
print(f"Normen jedes Vektors: {norms}") # Alle Werte liegen nahe bei 1.0
3. Laden vortrainierter Word Embeddings
Die Verwendung vortrainierter Word Embeddings kann die Modellleistung erheblich verbessern, besonders wenn Trainingsdaten knapp sind. Gängige vortrainierte Word Embeddings umfassen Word2Vec, GloVe, FastText usw.
3.1 Unterschied zwischen Training von Grund auf und Laden vortrainierter Embeddings
| Methode | Vorteile | Nachteile | Geeignete Szenarien |
|---|---|---|---|
| Zufällige Initialisierung und Training | Vollständig anpassbar, passt sich an spezifische Aufgaben an | Erfordert eine große Menge an Trainingsdaten | Viele domänenspezifische Wörter und ausreichend Trainingsdaten |
| Laden vortrainierter Embeddings | Nutzt Wissen aus großen Korpora, schnelles Training und gute Ergebnisse | Begrenzte Vokabularabdeckung, kann Wörter außerhalb des Vokabulars nicht verarbeiten | Allgemeine Aufgaben, begrenzte Trainingsdaten |
| Einfrieren vortrainierter Embeddings | Schnelles Training, geringer GPU-Speicherverbrauch | Embeddings können nicht feinabgestimmt werden | Begrenzte Trainingsressourcen, wobei der Fokus nur auf den oberen Schichten des Modells liegt |
| Feinabstimmung vortrainierter Embeddings | Können an spezifische Aufgaben angepasst werden | Langsameres Training, hoher GPU-Speicherverbrauch | Moderate Datenmenge, bestimmte Domänenunterschiede |
3.2 Laden vortrainierter GloVe-Wortvektoren
GloVe ist ein vortrainierter Wortvektor, der von der Stanford University veröffentlicht wurde. Im Folgenden wird gezeigt, wie er geladen wird:
Beispiel
import torch.nn as nn
import numpy as np
# Laden von GloVe-Wortvektoren simulieren (eigentlich müssen GloVe-Dateien heruntergeladen werden)
# Angenommen, es gibt bereits eine Wortvektor-Datei mit dem Format: Jede Zeile enthält ein Wort, gefolgt von seinen Vektoren
def load_glove_embeddings(path, word2idx, embedding_dim=300):
"""
GloVe-vortrainierte Wortvektoren laden
path: Pfad zur Wortvektor-Datei
word2idx: Wörterbuch, das Wörter Indizes zuordnet
embedding_dim: Dimension des Wortvektors
"""
embeddings = np.random.randn(len(word2idx), embedding_dim).astype(np.float32)
word_count = 0
with open(path, 'r', encoding='utf-8') as f:
for line in f:
values = line.strip().split()
word = values[0]
if word in word2idx:
word_idx = word2idx[word]
embeddings[word_idx] = np.asarray(values[1:], dtype=np.float32)
word_count += 1
print(f"Geladen {word_count}/{len(word2idx)} Wortvektoren")
return torch.from_numpy(embeddings)
# Angenommen, es gibt bereits ein Vokabular
word2idx = {'hello': 0, 'world': 1, 'example': 2, 'python': 3}
EMBED_DIM = 300
# Vortrainierte Embeddings laden und eine Embedding-Schicht erstellen
# pretrained_embeddings = load_glove_embeddings('glove.6B.300d.txt', word2idx, EMBED_DIM)
# embedding = nn.Embedding.from_pretrained(pretrained_embeddings, padding_idx=0)
# Vereinfachtes Beispiel: eine zufällig initialisierte vortrainierte Matrix verwenden
pretrained_embeddings = torch.randn(len(word2idx), EMBED_DIM)
embedding = nn.Embedding.from_pretrained(pretrained_embeddings, padding_idx=0)
print(f"Form der Embedding-Schicht: {embedding.weight.shape}")
3.3 Einfrieren und Feinabstimmung der Embedding-Schicht
Je nach Aufgabenanforderungen können Sie wählen, die Embedding-Schicht einzufrieren oder feinabzustimmen:
Beispiel
import torch.nn as nn
embedding = nn.Embedding(num_embeddings=10000, embedding_dim=256)
# Methode 1: Embedding-Schicht einfrieren (nicht am Training beteiligt)
embedding.weight.requires_grad = False
# Während des Trainings werden nur Parameter, bei denen embedding.weight.requires_grad = False ist, nicht aktualisiert
# Methode 2: Embedding-Schicht feinabstimmen (am Training beteiligt)
embedding.weight.requires_grad = True
# Methode 3: Teilweise Wortvektoren einfrieren (hochfrequente Wörter wie "the", "is" einfrieren)
# Angenommen, die Indizes der hochfrequenten Wörter sind 0-99
embedding.weight.requires_grad = True
with torch.no_grad():
embedding.weight[0:100] *= 0 # Oder feste Werte zuweisen
# Eingefrorene Parameter im Optimierer herausfiltern
optimizer = torch.optim.Adam(
filter(lambda p: p.requires_grad, embedding.parameters()),
lr=1e-3
)
4. Kombination von Embedding-Schicht mit RNN/LSTM
Wort-Embedding ist die erste Schicht eines NLP-Modells. Es wandelt Text-IDs in dichte Vektoren um, die dann zur Verarbeitung an Sequenzmodelle wie RNN und LSTM übergeben werden.
4.1 Embedding-Schicht + LSTM-Textklassifikation
Beispiel
import torch.nn as nn
class TextClassifier(nn.Module):
"""
Embedding-Schicht + LSTM-Textklassifikationsmodell
"""
def __init__(self, vocab_size, embed_dim, hidden_size, num_classes, padding_idx=0):
super().__init__()
# Worteinbettungsschicht
self.embedding = nn.Embedding(
num_embeddings=vocab_size,
embedding_dim=embed_dim,
padding_idx=padding_idx
)
# LSTM-Schicht
self.lstm = nn.LSTM(
input_size=embed_dim,
hidden_size=hidden_size,
num_layers=2,
batch_first=True,
bidirectional=True,
dropout=0.3
)
# Klassifikator
self.fc = nn.Linear(hidden_size * 2, num_classes)
def forward(self, x):
# x: (batch_size, seq_len) - Wortindizes
embedded = self.embedding(x) # (batch_size, seq_len, embed_dim)
# LSTM-Ausgabe
output, (h_n, c_n) = self.lstm(embedded)
# Nimm den Hidden State des letzten Zeitschritts (bidirektionale Verkettung)
# Letzter Hidden State vorwärts: h_n[-2]
# Letzter Hidden State rückwärts: h_n[-1]
h_combined = torch.cat([h_n[-2], h_n[-1]], dim=-1)
# Klassifikation
logits = self.fc(h_combined)
return logits
# Modell instanziieren
VOCAB_SIZE = 10000
EMBED_DIM = 128
HIDDEN_SIZE = 128
NUM_CLASSES = 2
model = TextClassifier(VOCAB_SIZE, EMBED_DIM, HIDDEN_SIZE, NUM_CLASSES)
# Simulierte Eingabe: batch_size=4, Sequenzlänge=10
batch_input = torch.randint(1, VOCAB_SIZE, (4, 10))
output = model(batch_input)
print(f"Input shape: {batch_input.shape}") # torch.Size([4, 10])
print(f"Output shape: {output.shape}") # torch.Size([4, 2])
4.2 Verwendung vortrainierter Wortvektoren
Beispiel
import torch.nn as nn
# Angenommen, vortrainierte Wortvektoren wurden geladen
pretrained_vectors = torch.randn(10000, 300) # Simuliere vortrainierte Vektoren
# Erstelle eine Embedding-Schicht und lade vortrainierte Gewichte
embedding = nn.Embedding.from_pretrained(
pretrained_vectors,
padding_idx=0,
freeze=False # True: einfrieren und nicht trainieren, False: Feinabstimmung
)
# Wenn GloVe oder andere vortrainierte Wortvektoren verwendet werden, meist zuerst für ein paar Epochen einfrieren, dann für Feinabstimmung auftauen
# Für die ersten paar Epochen nur die oberen Schichten des Modells trainieren
embedding.weight.requires_grad = False
# Nach dem Training über mehrere Epochen die Embedding-Schicht für Feinabstimmung auftauen
# embedding.weight.requires_grad = True
5. Positionskodierung
Im Gegensatz zu RNN/LSTM enthält das Transformer-Modell keine Positionsinformationen. Positionskodierung muss zusätzlich hinzugefügt werden, damit das Modell die Reihenfolge der Wörter in einer Sequenz wahrnehmen kann.
5.1 Prinzip der Positionskodierung
Die Positionskodierung verwendet Sinus- und Kosinusfunktionen, um Positionsvektoren zu erzeugen:
\[ \begin{aligned} PE_{(pos, 2i)} &= \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right) \\ PE_{(pos, 2i+1)} &= \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right) \end{aligned} \]
Die Besonderheit dieser Kodierungsmethode ist, dass Kodierungen an verschiedenen Positionen durch lineare Transformationen ineinander überführt werden können, wodurch das Modell Positionsbeziehungen leicht lernen kann.
5.2 Implementierung der Positionskodierung
Beispiel
import torch.nn as nn
import math
class PositionalEncoding(nn.Module):
"""
Positionskodierungsschicht
"""
def __init__(self, d_model, max_len=5000):
super().__init__()
# Positionskodierungsmatrix erstellen
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
# Den Divisor-Term berechnen
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
# sin für gerade Indizes und cos für ungerade Indizes verwenden
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
# Eine Batch-Dimension hinzufügen und sie als Puffer registrieren, der nicht an der Gradientenberechnung teilnimmt
pe = pe.unsqueeze(0) # (1, max_len, d_model)
self.register_buffer('pe', pe)
def forward(self, x):
"""
x: (batch_size, seq_len, d_model)
"""
seq_len = x.size(1)
# Die Positionskodierung der entsprechenden Länge ausschneiden und sie hinzufügen
x = x + self.pe[:, :seq_len, :]
return x
# Verwendungsbeispiel
d_model = 256
max_len = 100
pos_encoding = PositionalEncoding(d_model, max_len)
# Simulierte Eingabe: batch_size=4, seq_len=20, d_model=256
x = torch.randn(4, 20, d_model)
x = pos_encoding(x)
print(f"Eingabeform: {x.shape}") # torch.Size([4, 20, 256])
Positionskodierung ist eine Schlüsselkomponente in der Transformer-Architektur. Sie ermöglicht es dem Modell, Wörter an unterschiedlichen Positionen zu unterscheiden, selbst wenn ihre Einbettungsvektoren identisch sind.
5.3 Lernbare Positionskodierung
Zusätzlich zur festen Positionskodierung kann auch eine lernbare Positionskodierung verwendet werden:
Beispiel
import torch.nn as nn
class LearnablePositionalEncoding(nn.Module):
"""
Lernbare Positionskodierung
"""
def __init__(self, d_model, max_len=5000):
super().__init__()
self.pos_embedding = nn.Embedding(max_len, d_model)
def forward(self, x):
batch_size, seq_len, d_model = x.size(1), x.size(1), x.size(2)
# Erzeuge Positionsindizes [0, 1, 2, ..., seq_len-1]
positions = torch.arange(seq_len, device=x.device).unsqueeze(0).expand(batch_size, -1)
pos_encoded = self.pos_embedding(positions)
return x + pos_encoded
# Verwendungsbeispiel
pos_encoding = LearnablePositionalEncoding(d_model=256, max_len=100)
x = torch.randn(4, 20, 256)
x = pos_encoding(x)
print(f"Ausgabeform: {x.shape}") # torch.Size([4, 20, 256])
6. Fortgeschrittene Techniken für Embedding-Schichten
6.1 Reduzierung der GPU-Speichernutzung
Wenn das Vokabular sehr groß ist, verbraucht die Embedding-Schicht viel GPU-Speicher. Die folgenden Techniken können zur Optimierung verwendet werden:
Beispiel
import torch.nn as nn
# Technik 1: Sparse-Gradienten verwenden (sparse=True)
embedding = nn.Embedding(
num_embeddings=100000,
embedding_dim=256,
sparse=True # Gradienten werden im Sparse-Format gespeichert, wodurch GPU-Speicher gespart wird
)
# Technik 2: Quantisierung verwenden
# float32 in int8 oder float16 konvertieren
embedding_int8 = embedding.to(torch.int8)
# Technik 3: Selten verwendete Wortvektoren einfrieren
# In einem großen Vokabular nur hochfrequente Wörter trainieren; niederfrequente Wörter eingefroren halten
embedding = nn.Embedding(num_embeddings=100000, embedding_dim=256)
embedding.weight.requires_grad = True
# Wortvektoren mit Index größer als 50000 einfrieren
with torch.no_grad():
embedding.weight[50000:] *= 0
embedding.weight.requires_grad = False
# Nur hochfrequente Wörter trainieren
embedding.weight[1:50000].requires_grad = True
6.2 Umgang mit Wörtern außerhalb des Vokabulars (OOV)
Wörter, die nicht im Vokabular enthalten sind (Out-of-Vocabulary-/OOV-Wörter), können im Testsatz auftreten und erfordern eine spezielle Behandlung:
Beispiel
import torch.nn as nn
class EmbeddingWithOOV(nn.Module):
"""
Einbettungsschicht zur Unterstützung von Wörtern außerhalb des Vokabulars
"""
def __init__(self, vocab_size, embed_dim, oov_idx=Keine):
super().__init__()
self.embedding = nn.Embedding(vocab_size + 1, embed_dim, padding_idx=0)
self.oov_idx = oov_idx if oov_idx is not None else vocab_size # Letzten Index als OOV verwenden
def forward(self, x):
# Ersetze die Indizes von OOV-Wörtern durch oov_idx
oov_mask = x >= self.vocab_size
x = x.clone()
x[oov_mask] = self.oov_idx
return self.embedding(x)
# Hashing-Techniken verwenden, um größere Vokabulare zu verarbeiten
class HashEmbedding(nn.Module):
"""
Einbettungsschicht unter Verwendung von Hashing zur Behandlung von Vokabularen beliebiger Größe
"""
def __init__(self, num_buckets, embed_dim):
super().__init__()
self.num_buckets = num_buckets
self.embedding = nn.Embedding(num_buckets, embed_dim)
def forward(self, x):
# Wortindizes in Buckets hashen
# Verwende die Hashing-Methode des Python-Wörterbuchs
hashed = torch.remainder(x, self.num_buckets)
return self.embedding(hashed)
6.3 Subwort-Einbettung
Für morphologisch reiche Sprachen (wie Deutsch und Russisch) kann Subwort-Einbettung effektiv das Out-of-Vocabulary-Problem behandeln:
Beispiel
import torch.nn as nn
class SubwordEmbedding(nn.Module):
"""
Vereinfachtes Beispiel für Subwort-Einbettung
In der Praxis sollten Algorithmen wie BPE und WordPiece zur Tokenisierung verwendet werden
"""
def __init__(self, vocab_size, embed_dim, char_dim=50):
super().__init__()
# Einbettung auf Zeichenebene
self.char_embedding = nn.Embedding(vocab_size, char_dim)
# Einbettung auf Wortebene
self.word_embedding = nn.Embedding(vocab_size, embed_dim - char_dim)
# LSTM auf Zeichenebene zur Kombination von Zeichenvektoren
self.char_lstm = nn.LSTM(
char_dim, char_dim,
batch_first=True, bidirectional=True
)
def forward(self, word_ids, char_ids):
"""
word_ids: Wortindizes (batch_size, seq_len)
char_ids: Zeichenindizes (batch_size, seq_len, max_word_len)
"""
# Wort-Embedding
word_emb = self.word_embedding(word_ids)
# Zeichen-Embedding + LSTM
batch_size, seq_len, max_word_len = char_ids.shape
char_ids_flat = char_ids.view(-1, max_word_len) # (batch_size * seq_len, max_word_len)
char_emb = self.char_embedding(char_ids_flat) # (batch_size * seq_len, max_word_len, char_dim)
char_output, (h_n, _) = self.char_lstm(char_emb)
# Bidirektionale finale verborgene Zustände nehmen und verketten
char_rep = torch.cat([h_n[-2], h_n[-1]], dim=-1) # (batch_size * seq_len, char_dim * 2)
char_rep = char_rep.view(batch_size, seq_len, -1) # (batch_size, seq_len, char_dim * 2)
# Wort-Embedding und Zeichendarstellung verketten
combined = torch.cat([word_emb, char_rep], dim=-1)
return combined
7. Vollständiges praktisches Beispiel: Textklassifikationsmodell
Nachfolgend ein vollständiges Beispiel für ein Textklassifikationsmodell, einschließlich Embedding-Schicht, LSTM und Klassifikator:
Beispiel
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# ── Konfigurationsparameter ──────────────────────────────────────
VOCAB_SIZE = 10000
EMBED_DIM = 128
HIDDEN_SIZE = 128
NUM_LAYERS = 2
NUM_CLASSES = 5
DROPOUT = 0.3
MAX_LEN = 200
# ── Modell-Definition ──────────────────────────────────────
class TextClassificationModel(nn.Module):
def __init__(self, vocab_size, embed_dim, hidden_size,
num_layers, num_classes, dropout=0.3, padding_idx=0):
super().__init__()
# Embedding-Schicht
self.embedding = nn.Embedding(
vocab_size,
embed_dim,
padding_idx=padding_idx
)
# BiLSTM
self.lstm = nn.LSTM(
embed_dim,
hidden_size,
num_layers=num_layers,
batch_first=True,
bidirectional=True,
dropout=dropout if num_layers > 1 else 0
)
# Klassifikator
self.dropout = nn.Dropout(dropout)
self.fc = nn.Linear(hidden_size * 2, num_classes)
def forward(self, x):
# x: (batch_size, seq_len)
embedded = self.embedding(x) # (batch_size, seq_len, embed_dim)
# LSTM
output, (h_n, c_n) = self.lstm(embedded)
# Bidirektionale finale verborgene Zustände verketten
h_forward = h_n[-2] # (batch_size, hidden_size)
h_backward = h_n[-1] # (batch_size, hidden_size)
h_combined = torch.cat([h_forward, h_backward], dim=-1)
# Klassifikation
dropped = self.dropout(h_combined)
logits = self.fc(droped)
return logits
# ── Datensatz ──────────────────────────────────────
class TextDataset(Dataset):
def __init__(self, texts, labels, vocab, max_len=200):
self.texts = texts
self.labels = labels
self.vocab = vocab
self.max_len = max_len
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx][:self.max_len]
# Wörter in Indizes umwandeln, unbekannte Wörter durch 1 (<UNK>) dargestellt
ids = [self.vocab.get(word, 1) for word in text]
# Mit Nullen auf eine feste Länge auffüllen
if len(ids) < self.max_len:
ids += [0] * (self.max_len - len(ids))
return torch.tensor(ids), torch.tensor(self.labels[idx])
# ── Trainingsfunktion ──────────────────────────────────────
def train_epoch(model, loader, optimizer, criterion, device):
model.train()
total_loss = 0
correct = 0
total = 0
for inputs, labels in loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
total_loss += loss.item() * inputs.size(0)
_, predicted = outputs.max(1)
correct += predicted.eq(labels).sum().item()
total += labels.size(0)
return total_loss / total, correct / total
# ── Initialisierung und Training ──────────────────────────────────
# Angenommen, ein Vokabular existiert bereits
word2idx = {'<PAD>': 0, '<UNK>': 1} # Das Vokabular muss basierend auf dem tatsächlichen Korpus aufgebaut werden
model = TextClassificationModel(
VOCAB_SIZE, EMBED_DIM, HIDDEN_SIZE,
NUM_LAYERS, NUM_CLASSES, DROPOUT
).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
# Simuliertes Training
print("Starte Training...")
for epoch in range(10):
train_loss, train_acc = train_epoch(model, None, optimizer, criterion, device)
print(f"Epoch {epoch+1}: Loss={train_loss:.4f}, Acc={train_acc:.4f}")
8. API-Kurzreferenz
8.1 Häufige Operationen auf nn.Embedding
| Aktion | Code |
|---|---|
| Embedding-Schicht erstellen | nn.Embedding(num_embeddings, embedding_dim) |
| Vortrainierte Embeddings laden | nn.Embedding.from_pretrained(weights) |
| Nachschlagetabelle zum Abrufen von Embeddings | embedding(word_ids) |
| Embeddings einfrieren | embedding.weight.requires_grad = False |
| Embedding-Vektoren abrufen | embedding.weight[idx] |
8.2 Ressourcen für vortrainierte Wortvektoren
| Ressource | Dimension | Funktionen |
|---|---|---|
| GloVe | 50, 100, 200, 300 | Wort-Kookkurrenzstatistiken, schnelles Training |
| Word2Vec | 50-500 | Von Google trainiert, breite Abdeckung |
| FastText | 300 | Unterstützt Subwörter, gut im Umgang mit OOV |
| BERT | 768+ | Kontextabhängig, beste Leistung |
8.3 Empfehlungen zur Auswahl einer Embedding-Schicht
数据量小(< 10K)
-> 使用预训练词向量(GloVe/FastText)+ 冻结或微调
数据量中等(10K ~ 100K)
-> 使用预训练词向量 + 微调
数据量大(> 100K)
-> 可考虑从头训练,或使用大规模预训练模型
领域差异大
-> 使用领域相关预训练模型或增量训练
资源受限
-> 冻结嵌入层,使用较小的嵌入维度
Andere Erweiterungen