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
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

import torch.nn as nn

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
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
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
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
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
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
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
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
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
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
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
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
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