Fonction torch.nn.Embedding de PyTorch

PyTorch torch.nn 参考手册Manuel de référence torch.nn de PyTorch

torch.nn.EmbeddingIl s'agit d'un module dans PyTorch utilisé pour le plongement de mots.

Il associe des indices de mots discrets à un espace vectoriel continu, et constitue l'une des opérations les plus fondamentales du traitement du langage naturel.

Définition de fonction

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

Description des paramètres :

  • num_embeddings(int) : Taille du vocabulaire, c'est-à-dire le nombre de lignes dans la matrice de plongement.
  • embedding_dim(int) : La dimension de chaque vecteur de plongement.
  • padding_idx(int): Spécifie l'indice de padding, dont le vecteur d'embedding est un vecteur nul. La valeur par défaut est None.
  • max_norm(float): Si ce n'est pas None, les vecteurs d'embedding sont normalisés selon cette norme. La valeur par défaut est None.
  • norm_type(float): L'ordre de la norme à calculer. La valeur par défaut est 2.0.
  • scale_grad_by_freq(bool): Indique si les gradients doivent être mis à l'échelle en fonction de la fréquence des mots. La valeur par défaut est False.
  • sparse(bool): Indique si la matrice de poids est une matrice creuse. La valeur par défaut est False.

Attributs :

  • weight(Tensor): Poids apprenables de forme (num_embeddings, embedding_dim).

Exemples d'utilisation

Exemple 1 : Utilisation de base

Créer et utiliser des embeddings de mots :

Exemple

import torch
import torch.nn as nn

# Créer une couche d'embedding : vocabulaire 10000, dimension d'embedding 256
embedding = nn.Embedding(num_embeddings=10000, embedding_dim=256)

# Indices de mots (à partir de 0)
# Forme : (batch, seq_len)
input_indices = torch.tensor([[12, 45, 678], [901, 23, 56]])

# Récupérer les vecteurs d'embedding
output = embedding(input_indices)

print("Forme de l'indice d'entrée :", input_indices.shape)
print("Forme de l'embedding de sortie :", output.shape)  # (2, 3, 256)

# Afficher la forme de la matrice d'embedding
print("Forme de la matrice d'embedding :", embedding.weight.shape)

Exemple 2 : Utilisation de padding_idx

Spécifiez l'indice de remplissage :

Exemple

import torch
import torch.nn as nn

# Créer une couche d'embedding avec remplissage
embedding = nn.Embedding(num_embeddings=1000, embedding_dim=64, padding_idx=0)

# 0 est utilisé comme remplissage
input_indices = torch.tensor([[1, 2, 3], [4, 0, 0]])  # La deuxième phrase contient du remplissage

output = embedding(input_indices)

print("Forme de l'entrée :", input_indices.shape)
print("Forme de sortie :", output.shape)
print("Vecteur d'embedding du remplissage :", output[1, 1].tolist())  # Que des zéros
print("Vecteur d'embedding des non-padding :", output[0, 0].tolist()[:5])  # Non nul

Exemple 3 : Vecteurs de mots pré-entraînés

Charger les vecteurs de mots pré-entraînés :

Exemple

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

# Simuler des vecteurs de mots pré-entraînés (en pratique, on peut utiliser GloVe, Word2Vec, etc.)
vocab_size = 1000
embedding_dim = 300

# Initialisation aléatoire (en pratique, charger des vecteurs pré-entraînés)
pretrained_weights = np.random.randn(vocab_size, embedding_dim).astype('float32')

# Créer une couche d'embedding
embedding = nn.Embedding(vocab_size, embedding_dim)

# Charger les poids pré-entraînés
embedding.weight.data = torch.from_numpy(pretrained_weights)

# Geler la couche d'embedding (non entraînée)
embedding.weight.requires_grad = False

print("Couche d'embedding entraînable :", embedding.weight.requires_grad)
print("Forme de la matrice d'embedding :", embedding.weight.shape)

Exemple 4 : Contrainte de la norme des vecteurs d'embedding

Utilisez max_norm pour contraindre la norme du vecteur :

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

# Contraindre la norme maximale des vecteurs d'embedding à 1.0
embedding = nn.Embedding(1000, 64, max_norm=1.0)

# Entrée
input_indices = torch.tensor([1, 2, 3])

# Norme originale du poids
original_norm = embedding.weight.data.norm(dim=1)[:3]
print("Norme originale du poids :", original_norm.tolist())

# Norme du vecteur après recherche
output = embedding(input_indices)
output_norm = output.norm(dim=1)
print("Norme du vecteur de sortie :", output_norm.tolist())

Exemple 5 : Modèle complet de classification de texte

Classification de texte à l'aide d'une couche d'embedding :

Exemple

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__()
        # Couche de plongement de mots
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        # LSTM
        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
        # Classificateur
        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 prend la dernière sortie
        _, (hidden, _) = self.lstm(embedded)
        hidden = hidden[-1]  # État caché de la dernière couche

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

# Paramètres
VOCAB_SIZE = 10000
EMBED_DIM = 128
HIDDEN_DIM = 256

model = TextClassifier(VOCAB_SIZE, EMBED_DIM, HIDDEN_DIM)

# Entrée : batch=4, longueur de séquence=50
input_ids = torch.randint(1, VOCAB_SIZE, (4, 50))
output = model(input_ids)

print("Architecture du modèle :")
print(model)
print("Forme de l'entrée :", input_ids.shape)
print("Forme de sortie :", output.shape)

Différence entre Embedding et EmbeddingBag

Type Entrée Sortie Scénarios d'application
nn.Embedding Indices de mots Séquence de vecteurs de mots Modèles séquentiels, LSTM, Transformer
nn.EmbeddingBag Indices de mots + offsets Vecteur agrégé Classification de texte, traitement rapide

Questions fréquentes

Q1 : Comment choisir la dimension d'embedding ?

  • Petits jeux de données : 50-100 dimensions
  • Jeux de données moyens : 100-300 dimensions
  • Grands jeux de données : 300-500 dimensions

Q2 : Quel est le but de padding_idx ?

Il définit le vecteur d'embedding à l'index spécifié comme un vecteur nul et ne calcule pas son gradient pendant la rétropropagation.

Q3 : Quand figer la couche d'embedding ?

Lors de l'utilisation de vecteurs de mots pré-entraînés, il est courant de figer la couche, d'entraîner pendant un moment, puis d'affiner.

Cas d'utilisation

nn.EmbeddingLes principaux scénarios d'application incluent :

  • Représentation vectorielle des mots: Convertir les mots en vecteurs denses
  • Classification de texte: Comme couche d'entrée des modèles NLP
  • Modèles séquentiels: Entrée pour LSTM, GRU
  • Systèmes de recommandation: Représentations d'embedding des utilisateurs et des éléments

Remarque : embedding.weight est un paramètre apprenable et peut être entraîné directement dans l'optimiseur.

PyTorch torch.nn 参考手册Manuel de référence torch.nn de PyTorch

Autres extensions