PyTorch torch.nn.Embedding-Funktion

PyTorch torch.nn 参考手册PyTorch torch.nn Referenzhandbuch

torch.nn.EmbeddingEs ist ein Modul in PyTorch, das für Wort-Embedding verwendet wird.

Es bildet diskrete Wortindizes auf einen kontinuierlichen Vektorraum ab und ist eine der grundlegendsten Operationen in der Verarbeitung natürlicher Sprache.

Funktionsdefinition

torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, sparse=False)

Parameterbeschreibung:

  • num_embeddings(int): Vokabulargröße, d. h. die Anzahl der Zeilen in der Embedding-Matrix.
  • embedding_dim(int): Die Dimension jedes Embedding-Vektors.
  • padding_idx(int): Gibt den Padding-Index an, dessen Embedding-Vektor ein Nullvektor ist. Standard ist None.
  • max_norm(float): Wenn nicht None, werden Embedding-Vektoren auf diese Norm normalisiert. Standard ist None.
  • norm_type(float): Die Ordnung der zu berechnenden Norm. Standard ist 2.0.
  • scale_grad_by_freq(bool): Ob Gradienten anhand der Worthäufigkeit skaliert werden. Standard ist False.
  • sparse(bool): Ob die Gewichtsmatrix eine dünnbesetzte Matrix ist. Standard ist False.

Attribute:

  • weight(Tensor): Lernbare Gewichte der Form (num_embeddings, embedding_dim).

Anwendungsbeispiele

Beispiel 1: Grundlegende Verwendung

Word-Embeddings erstellen und verwenden:

Beispiel

import torch
import torch.nn as nn

# Embedding-Schicht erstellen: Vokabular 10000, Embedding-Dimension 256
embedding = nn.Embedding(num_embeddings=10000, embedding_dim=256)

# Wortindizes (beginnend bei 0)
# Form: (batch, seq_len)
input_indices = torch.tensor([[12, 45, 678], [901, 23, 56]])

# Embedding-Vektoren nachschlagen
output = embedding(input_indices)

print("Form des Eingabeindex:", input_indices.shape)
print("Form des Ausgabe-Embeddings:", output.shape)  # (2, 3, 256)

# Die Form der Embedding-Matrix anzeigen
print("Form der Embedding-Matrix:", embedding.weight.shape)

Beispiel 2: Verwendung von padding_idx

Geben Sie den Padding-Index an:

Beispiel

import torch
import torch.nn as nn

# Embedding-Schicht mit Padding erstellen
embedding = nn.Embedding(num_embeddings=1000, embedding_dim=64, padding_idx=0)

# 0 wird als Padding verwendet
input_indices = torch.tensor([[1, 2, 3], [4, 0, 0]])  # Der zweite Satz enthält Padding

output = embedding(input_indices)

print("Eingabeform:", input_indices.shape)
print("Ausgabeform:", output.shape)
print("Embedding-Vektor des Paddings:", output[1, 1].tolist())  # Alle Nullen
print("Einbettungsvektor der Nicht-Padding-Elemente:", output[0, 0].tolist()[:5])  # Nicht null

Beispiel 3: Vortrainierte Wortvektoren

Vortrainierte Wortvektoren laden:

Beispiel

import torch
import torch.nn as nn
import numpy as np

# Vortrainierte Wortvektoren simulieren (in der Praxis können GloVe, Word2Vec usw. verwendet werden)
vocab_size = 1000
embedding_dim = 300

# Zufällige Initialisierung (in der Praxis vortrainierte Vektoren laden)
pretrained_weights = np.random.randn(vocab_size, embedding_dim).astype('float32')

# Einbettungsschicht erstellen
embedding = nn.Embedding(vocab_size, embedding_dim)

# Vortrainierte Gewichte laden
embedding.weight.data = torch.from_numpy(pretrained_weights)

# Die Embedding-Schicht einfrieren (nicht trainiert)
embedding.weight.requires_grad = False

print("Embedding-Schicht trainierbar:", embedding.weight.requires_grad)
print("Form der Embedding-Matrix:", embedding.weight.shape)

Beispiel 4: Einschränken der Norm von Embedding-Vektoren

Verwenden Sie max_norm, um die Vektornorm zu beschränken:

h2 class="example">Beispiel
import torch
import torch.nn as nn

# Maximale Norm der Embedding-Vektoren auf 1.0 beschränken
embedding = nn.Embedding(1000, 64, max_norm=1.0)

# Eingabe
input_indices = torch.tensor([1, 2, 3])

# Ursprüngliche Gewichtsnorm
original_norm = embedding.weight.data.norm(dim=1)[:3]
print("Ursprüngliche Gewichtsnorm:", original_norm.tolist())

# Vektornorm nach Lookup
output = embedding(input_indices)
output_norm = output.norm(dim=1)
print("Norm des Ausgabevektors:", output_norm.tolist())

Beispiel 5: Vollständiges Textklassifikationsmodell

Textklassifikation unter Verwendung einer Embedding-Schicht:

Beispiel

import torch
import torch.nn as nn

class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes=2):
        super(TextClassifier, self).__init__()
        # Worteinbettungsschicht
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        # LSTM
        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
        # Klassifikator
        self.classifier = nn.Linear(hidden_dim, num_classes)

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

        # LSTM verwendet die letzte Ausgabe
        _, (hidden, _) = self.lstm(embedded)
        hidden = hidden[-1]  # Verborgener Zustand der letzten Schicht

        # Klassifikation
        logits = self.classifier(hidden)
        return logits

# Parameter
VOCAB_SIZE = 10000
EMBED_DIM = 128
HIDDEN_DIM = 256

model = TextClassifier(VOCAB_SIZE, EMBED_DIM, HIDDEN_DIM)

# Eingabe: batch=4, Sequenzlänge=50
input_ids = torch.randint(1, VOCAB_SIZE, (4, 50))
output = model(input_ids)

print("Modellarchitektur:")
print(model)
print("Eingabeform:", input_ids.shape)
print("Ausgabeform:", output.shape)

Unterschied zwischen Embedding und EmbeddingBag

Type Eingabe Ausgabe Anwendungsszenarien
nn.Embedding Wortindizes Sequenz von Wortvektoren Sequenzmodelle, LSTM, Transformer
nn.EmbeddingBag Wortindizes + Offsets Aggregierter Vektor Textklassifikation, schnelle Verarbeitung

Häufig gestellte Fragen

F1: Wie wählt man die Embedding-Dimension?

  • Kleine Datensätze: 50-100 Dimensionen
  • Mittlere Datensätze: 100-300 Dimensionen
  • Große Datensätze: 300-500 Dimensionen

F2: Welchen Zweck hat padding_idx?

Er setzt den Embedding-Vektor am angegebenen Index auf einen Nullvektor und berechnet seinen Gradienten während der Backpropagation nicht.

F3: Wann sollte man die Embedding-Schicht einfrieren?

Bei der Verwendung vortrainierter Wortvektoren ist es üblich, die Schicht einzufrieren, eine Weile zu trainieren und dann feinabzustimmen.

Anwendungsfälle

nn.EmbeddingZu den wichtigsten Anwendungsszenarien gehören:

  • Wortvektor-Darstellung: Wörter in dichte Vektoren umwandeln
  • Textklassifikation: Als Eingabeschicht von NLP-Modellen
  • Sequenzmodelle: Eingabe für LSTM, GRU
  • Empfehlungssysteme: Embedding-Repräsentationen von Nutzern und Artikeln

Hinweis: embedding.weight ist ein lernbarer Parameter und kann direkt im Optimierer trainiert werden.

PyTorch torch.nn 参考手册PyTorch torch.nn Referenzhandbuch

Andere Erweiterungen