Incrustación de palabras en PyTorch (Embedding)

El embedding de palabras es una de las técnicas más básicas e importantes en el procesamiento del lenguaje natural.

El embedding de palabras mapea símbolos de palabras discretos a vectores densos continuos, lo que permite a las máquinas comprender y procesar datos de texto.

PyTorch proporcionann.Embeddingel módulo para implementar esta función, que es la base para construir diversos modelos de NLP.

1. Conceptos básicos de los embeddings de palabras

En una computadora, el texto es esencialmente una secuencia de enteros. Cada palabra recibe un ID de índice único, pero esta representación discreta tiene un problema: palabras similares pueden estar semánticamente cercanas, pero sus ID no tienen ninguna relación.

El embedding de palabras aprende unamatriz de embeddingpara resolver este problema:

\[ E \in \mathbb{R}^{V \times D} \]

donde \(V\) es el tamaño del vocabulario y \(D\) es la dimensión del embedding. Cada ID de palabra corresponde a una fila de la matriz de embedding, y su representación vectorial se obtiene mediante una operación de búsqueda en tabla:

\[ \text{embedding} = E[\text{word\_id}] \]

Las ventajas del embedding de palabras incluyen:

Convierte los vectores one-hot dispersos de alta dimensión en vectores densos de baja dimensión, lo que reduce en gran medida el costo computacional.
Las palabras semánticamente similares están más cerca en el espacio vectorial, y la similitud entre palabras puede calcularse mediante la similitud del coseno.
Los vectores de embedding son parámetros aprendibles que pueden ajustarse automáticamente mediante retropropagación.

2. Explicación detallada de nn.Embedding

nn.EmbeddingEs la capa de embedding proporcionada por PyTorch, que encapsula la creación de la matriz de embedding y la operación de búsqueda en tabla.

2.1 Uso básico

Ejemplo

import torch
import torch.nn as nn

# Crear la capa de embedding
# num_embeddings: tamaño del vocabulario (vocab_size)
# embedding_dim: dimensión del embedding (embedding_dim)
vocab_size = 10000
embedding_dim = 256

embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)

# Ver la forma de la matriz de embedding
print(embedding.weight.shape) # torch.Size([10000, 256])

# Introducir índices de palabras (LongTensor) para obtener los vectores de embedding
word_ids = torch.tensor([0, 1, 2, 9999]) # Índice de palabra arbitrario
embedded = embedding(word_ids)

print(embedded.shape) # torch.Size([4, 256])
# Cada ID de palabra corresponde a un vector de 256 dimensiones

2.2 Explicación detallada de los parámetros de nn.Embedding

Ejemplo

import torch.nn as nn

embedding = nn.Embedding(
num_embeddings=10000, # Tamaño del vocabulario, debe ser mayor o igual que el índice máximo de entrada
embedding_dim=256, # Dimensión del vector de embedding, normalmente 50, 100, 200, 300, etc.
padding_idx=None, # Índice de la palabra de relleno; el vector de embedding de la palabra de relleno es todo ceros
max_norm=None, # Norma máxima del vector de embedding, utilizada para la normalización
norm_type=2.0, # Tipo de normalización, normalmente norma L2
scale_grad_by_freq=False,# Escalar el gradiente según la frecuencia de la palabra
sparse=False, # Si se usan gradientes dispersos (ahorra memoria de video, pero el entrenamiento es más lento)
_weight=None, # Pesos predefinidos, utilizados para cargar embeddings preentrenados
)

# Ver la cantidad de parámetros
total_params = embedding.num_embeddings * embedding.embedding_dim
print(fCantidad de parámetros de la capa de embedding: {total_params:,})
# 10000 * 256 = 2,560,000

La cantidad de parámetros de la capa de embedding = tamaño del vocabulario × dimensión del embedding, lo que supone una matriz muy grande. Normalmente, la capa de embedding de un modelo de NLP representa una gran proporción del total de parámetros del modelo.

2.3 Índice de relleno padding_idx

Al procesar secuencias de longitud variable, es necesario rellenar las secuencias cortas. Utilizandopadding_idxse puede fijar el vector de embedding de la palabra de relleno como un vector cero, evitando que el contenido de relleno afecte al modelo:

Ejemplo

import torch
import torch.nn as nn

# Establecer padding_idx=0, lo que indica que el índice 0 es la palabra de relleno
embedding = nn.Embedding(num_embeddings=10000, embedding_dim=128, padding_idx=0)

# Inicializar los pesos
nn.init.uniform_(embedding.weight, -0.1, 0.1)

# El vector de embedding del índice 0 es todo ceros
word_0 = embedding(torch.tensor([0]))
print(fEmbedding de la palabra de relleno: {word_0}) # Todo ceros

# Otros índices normales
word_5 = embedding(torch.tensor([5]))
print(fEmbedding de la palabra 5: {word_5}) # Valores no cero

2.4 Normalización por norma máxima

Utilizandomax_normse puede limitar la norma de los vectores de embedding, evitando que estos se vuelvan demasiado grandes durante el entrenamiento:

Ejemplo

import torch
import torch.nn as nn

# Establecer la norma máxima en 1.0
embedding = nn.Embedding(num_embeddings=1000, embedding_dim=64, max_norm=1.0)

# Introducir un índice de palabra arbitrario
ids = torch.tensor([1, 2, 3])
embedded = embedding(ids)

# Comprobar la norma L2 de cada vector
norms = torch.norm(embedded, p=2, dim=1)
print(fNormas de los vectores: {norms}) # Todos los valores están cerca de 1.0

3. Cargar embeddings de palabras preentrenados

El uso de embeddings de palabras preentrenados puede mejorar significativamente el rendimiento del modelo, especialmente cuando los datos de entrenamiento son escasos. Los embeddings preentrenados más comunes incluyen Word2Vec, GloVe, FastText, etc.

3.1 Diferencia entre entrenar desde cero y cargar preentrenados

Método	Ventajas	Desventajas	Escenarios aplicables
Entrenamiento con inicialización aleatoria	Totalmente personalizable, se adapta a tareas específicas	Requiere una gran cantidad de datos de entrenamiento	Muchas palabras específicas del dominio y datos de entrenamiento suficientes
Cargar embeddings preentrenados	Aprovecha el conocimiento de corpus a gran escala, entrenamiento rápido y buenos resultados	Cobertura de vocabulario limitada, no puede manejar palabras fuera de vocabulario	Tareas generales, datos de entrenamiento limitados
Congelar embeddings preentrenados	Entrenamiento rápido y bajo uso de memoria de video	No se pueden ajustar los embeddings	Recursos de entrenamiento limitados, solo se enfoca en el modelo superior
Ajuste fino de embeddings preentrenados	Puede adaptarse a tareas específicas	Entrenamiento más lento y mayor uso de memoria de video	Cantidad de datos media, el dominio tiene ciertas diferencias

3.2 Cargar los vectores de palabras preentrenados GloVe

GloVe es un vector de palabras preentrenado publicado por la Universidad de Stanford. A continuación se muestra cómo cargarlo:

Ejemplo

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

# Simular la carga de los vectores de palabras GloVe (en realidad se necesita descargar los archivos de GloVe)
# Asumir que ya existe un archivo de vectores de palabras, con el formato: cada línea contiene una palabra seguida de sus vectores

def load_glove_embeddings(path, word2idx, embedding_dim=300):
"""
Cargar los vectores de palabras preentrenados GloVe
path: ruta del archivo de vectores de palabras
word2idx: diccionario de mapeo de palabras a índices
embedding_dim: dimensión de los vectores de palabras
"""
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(fSe cargaron {word_count}/{len(word2idx)} vectores de palabras)
return torch.from_numpy(embeddings)

# Asumir que ya existe un vocabulario
word2idx = {'hello': 0, 'world': 1, 'ejemplo': 2, 'python': 3}
EMBED_DIM = 300

# Cargar los embeddings preentrenados y crear la capa de embedding
# pretrained_embeddings = load_glove_embeddings('glove.6B.300d.txt', word2idx, EMBED_DIM)
# embedding = nn.Embedding.from_pretrained(pretrained_embeddings, padding_idx=0)

# Ejemplo simplificado: usar una matriz preentrenada con inicialización aleatoria
pretrained_embeddings = torch.randn(len(word2idx), EMBED_DIM)
embedding = nn.Embedding.from_pretrained(pretrained_embeddings, padding_idx=0)

print(fForma de la capa de embedding: {embedding.weight.shape})

3.3 Congelar y ajustar la capa de embedding

Según los requisitos de la tarea, se puede elegir congelar o ajustar la capa de embedding:

Ejemplo

import torch
import torch.nn as nn

embedding = nn.Embedding(num_embeddings=10000, embedding_dim=256)

# Opción 1: congelar la capa de embedding (no participa en el entrenamiento)
embedding.weight.requires_grad = False
# Durante el entrenamiento, solo los parámetros con embedding.weight.requires_grad = False no se actualizan

# Opción 2: ajustar la capa de embedding (participa en el entrenamiento)
embedding.weight.requires_grad = True

# Método 3: Congelar algunos vectores de palabras (congelar palabras de alta frecuencia como "the", "is")
# Supongamos que los índices de las palabras de alta frecuencia están en 0-99
embedding.weight.requires_grad = True
with torch.no_grad():
embedding.weight[0:100] *= 0 # O asignar un valor fijo

# Filtrar los parámetros congelados en el optimizador
optimizer = torch.optim.Adam(
filter(lambda p: p.requires_grad, embedding.parameters()),
lr=1e-3
)

4. Combinación de la capa de embedding con RNN/LSTM

El word embedding es la primera capa de los modelos de NLP, que convierte los IDs de texto en vectores densos y luego los pasa a modelos secuenciales como RNN, LSTM para su procesamiento.

4.1 Capa de embedding + clasificación de texto con LSTM

Ejemplo

import torch
import torch.nn as nn

class TextClassifier(nn.Module):
"""
Modelo de capa de embedding + LSTM para clasificación de texto
"""
def __init__(self, vocab_size, embed_dim, hidden_size, num_classes, padding_idx=0):
super().__init__()

# Capa de embedding de palabras
self.embedding = nn.Embedding(
num_embeddings=vocab_size,
embedding_dim=embed_dim,
padding_idx=padding_idx
)

# Capa LSTM
self.lstm = nn.LSTM(
input_size=embed_dim,
hidden_size=hidden_size,
num_layers=2,
batch_first=True,
bidirectional=True,
dropout=0.3
)

# Clasificador
self.fc = nn.Linear(hidden_size * 2, num_classes)

def forward(self, x):
# x: (batch_size, seq_len) - índices de palabras
embedded = self.embedding(x) # (batch_size, seq_len, embed_dim)

# Salida de LSTM
output, (h_n, c_n) = self.lstm(embedded)

# Tomar el estado oculto del último paso de tiempo (concatenación bidireccional)
# Estado oculto final hacia adelante: h_n[-2]
# Estado oculto final hacia atrás: h_n[-1]
h_combined = torch.cat([h_n[-2], h_n[-1]], dim=-1)

# Clasificación
logits = self.fc(h_combined)
return logits

# Instanciación del modelo
VOCAB_SIZE = 10000
EMBED_DIM = 128
HIDDEN_SIZE = 128
NUM_CLASSES = 2

model = TextClassifier(VOCAB_SIZE, EMBED_DIM, HIDDEN_SIZE, NUM_CLASSES)

# Entrada simulada: batch_size=4, longitud de secuencia=10
batch_input = torch.randint(1, VOCAB_SIZE, (4, 10))
output = model(batch_input)

print(f"Forma de entrada: {batch_input.shape}") # torch.Size([4, 10])
print(f"Forma de salida: {output.shape}") # torch.Size([4, 2])

4.2 Uso de vectores de palabras preentrenados

Ejemplo

import torch
import torch.nn as nn

# Supongamos que ya se cargaron vectores de palabras preentrenados
pretrained_vectors = torch.randn(10000, 300) # Simular vectores preentrenados

# Crear la capa de embedding y cargar los pesos preentrenados
embedding = nn.Embedding.from_pretrained(
pretrained_vectors,
padding_idx=0,
freeze=False # True: congelar sin entrenar, False: ajuste fino
)

# Al usar glove u otros vectores de palabras preentrenados, normalmente se congela y se entrena durante algunas épocas, y luego se descongela para ajuste fino
# En las primeras épocas, solo se entrena el modelo de capas superiores
embedding.weight.requires_grad = False

# Después de entrenar varias épocas, descongelar la capa de embedding para ajuste fino
# embedding.weight.requires_grad = True

5. Codificación posicional (Positional Encoding)

A diferencia de RNN/LSTM, el modelo Transformer no contiene información de posición, por lo que es necesario agregar codificación posicional para que el modelo perciba el orden de las palabras en la secuencia.

5.1 Principio de la codificación posicional

La codificación posicional utiliza funciones seno y coseno para generar vectores de posición:

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

La característica de este método de codificación es que las codificaciones de diferentes posiciones pueden transformarse entre sí mediante transformaciones lineales, lo que facilita que el modelo aprenda relaciones posicionales.

5.2 Implementación de la codificación posicional

Ejemplo

import torch
import torch.nn as nn
import math

class PositionalEncoding(nn.Module):
"""
Capa de codificación posicional
"""
def __init__(self, d_model, max_len=5000):
super().__init__()

# Crear la matriz de codificación posicional
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)

# Calcular el término divisor
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))

# Los índices pares usan sin, los índices impares usan cos
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)

# Agregar la dimensión de batch y registrarlo como un buffer que no participa en el cálculo de gradientes
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)
# Recortar la codificación posicional de la longitud correspondiente y sumarla
x = x + self.pe[:, :seq_len, :]
return x

# Ejemplo de uso
d_model = 256
max_len = 100

pos_encoding = PositionalEncoding(d_model, max_len)

# Entrada simulada: batch_size=4, seq_len=20, d_model=256
x = torch.randn(4, 20, d_model)
x = pos_encoding(x)

print(f"Forma de entrada: {x.shape}") # torch.Size([4, 20, 256])

La codificación posicional es un componente clave en la arquitectura Transformer, que permite al modelo distinguir palabras en diferentes posiciones, incluso si sus vectores de embedding son iguales.

5.3 Codificación posicional aprendible

Además de la codificación posicional fija, también se puede usar una codificación posicional aprendible:

Ejemplo

import torch
import torch.nn as nn

class LearnablePositionalEncoding(nn.Module):
"""
Codificación posicional aprendible
"""
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)
# Crear índices de posición [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

# Ejemplo de uso
pos_encoding = LearnablePositionalEncoding(d_model=256, max_len=100)
x = torch.randn(4, 20, 256)
x = pos_encoding(x)
print(f"Forma de salida: {x.shape}") # torch.Size([4, 20, 256])

6. Técnicas avanzadas de la capa de embedding

6.1 Reducir la ocupación de memoria de video

Cuando el vocabulario es muy grande, la capa de embedding ocupa mucha memoria de video. Se pueden usar las siguientes técnicas para optimizar:

Ejemplo

import torch
import torch.nn as nn

# Técnica 1: Usar gradientes dispersos (sparse=True)
embedding = nn.Embedding(
num_embeddings=100000,
embedding_dim=256,
sparse=True # Los gradientes se almacenan en formato disperso, ahorrando memoria de video
)

# Técnica 2: Usar cuantización (quantization)
# Convertir float32 a int8 o float16
embedding_int8 = embedding.to(torch.int8)

# Técnica 3: Congelar los vectores de palabras poco frecuentes
# En un vocabulario a gran escala, solo entrenar palabras de alta frecuencia, mantener congeladas las de baja frecuencia
embedding = nn.Embedding(num_embeddings=100000, embedding_dim=256)
embedding.weight.requires_grad = True

# Congelar los vectores de palabras con índices mayores que 50000
with torch.no_grad():
embedding.weight[50000:] *= 0
embedding.weight.requires_grad = False

# Entrenar solo las palabras de alta frecuencia
embedding.weight[1:50000].requires_grad = True

6.2 Manejo de palabras fuera de vocabulario (OOV)

En el conjunto de prueba pueden aparecer palabras que no están en el vocabulario (palabras fuera de vocabulario / OOV), lo que requiere un manejo especial:

Ejemplo

import torch
import torch.nn as nn

class EmbeddingWithOOV(nn.Module):
"""
Capa de embedding compatible con el manejo de palabras fuera de vocabulario
"""
def __init__(self, vocab_size, embed_dim, oov_idx=None):
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 # El último índice se usa como OOV

def forward(self, x):
# Reemplazar el índice de las palabras OOV por oov_idx
oov_mask = x >= self.vocab_size
x = x.clone()
x[oov_mask] = self.oov_idx
return self.embedding(x)

# Usar técnicas de hash para manejar vocabularios de mayor escala
class HashEmbedding(nn.Module):
"""
Capa de embedding que usa técnicas de hash para manejar vocabularios de cualquier escala
"""
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):
# Aplicar hash a los índices de palabras en cubos
# Usar el método de hash de los diccionarios de Python
hashed = torch.remainder(x, self.num_buckets)
return self.embedding(hashed)

6.3 Embedding de subpalabras (Subword Embedding)

Para lenguas morfológicamente ricas (como alemán, ruso), el embedding de subpalabras puede manejar eficazmente el problema de las palabras fuera de vocabulario:

Ejemplo

import torch
import torch.nn as nn

class SubwordEmbedding(nn.Module):
"""
Ejemplo simplificado de embedding de subpalabras
En la práctica se deben usar algoritmos como BPE, WordPiece para la tokenización
"""
def __init__(self, vocab_size, embed_dim, char_dim=50):
super().__init__()
# Embedding a nivel de caracteres
self.char_embedding = nn.Embedding(vocab_size, char_dim)
# Embedding a nivel de palabras
self.word_embedding = nn.Embedding(vocab_size, embed_dim - char_dim)
# LSTM a nivel de caracteres, para combinar vectores de caracteres
self.char_lstm = nn.LSTM(
char_dim, char_dim,
batch_first=True, bidirectional=True
)

def forward(self, word_ids, char_ids):
"""
word_ids: índices de palabras (batch_size, seq_len)
char_ids: índices de caracteres (batch_size, seq_len, max_word_len)
"""
# Embedding de palabras
word_emb = self.word_embedding(word_ids)

# Embedding de caracteres + 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)
# Tomar el último estado oculto bidireccional y concatenarlo
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)

# Concatenar el embedding de palabras y la representación de caracteres
combined = torch.cat([word_emb, char_rep], dim=-1)
return combined

7. Práctica completa: modelo de clasificación de texto

A continuación se muestra un ejemplo completo de un modelo de clasificación de texto, que incluye capa de embedding, LSTM y clasificador:

Ejemplo

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

# ── Parámetros de configuración ──────────────────────────────────────
VOCAB_SIZE = 10000
EMBED_DIM = 128
HIDDEN_SIZE = 128
NUM_LAYERS = 2
NUM_CLASSES = 5
DROPOUT = 0.3
MAX_LEN = 200

# ── Definición del modelo ──────────────────────────────────────
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__()

# Capa de embedding
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
)

# Clasificador
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)

# Concatenación del último estado oculto bidireccional
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)

# Clasificación
dropped = self.dropout(h_combined)
logits = self.fc(droped)
return logits

# ── Dataset ──────────────────────────────────────
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]
# Convertir palabras a índices, las palabras desconocidas se representan con 1 (<UNK>)
ids = [self.vocab.get(word, 1) for word in text]
# Rellenar con ceros hasta una longitud fija
if len(ids) < self.max_len:
ids += [0] * (self.max_len - len(ids))
return torch.tensor(ids), torch.tensor(self.labels[idx])

# ── Función de entrenamiento ──────────────────────────────────────
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

# ── Inicialización y entrenamiento ──────────────────────────────────
# Supongamos que ya existe un vocabulario
word2idx = {'<PAD>': 0, '<UNK>': 1} # El vocabulario debe construirse según el corpus real

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)

# Entrenamiento simulado
print("Comenzando entrenamiento...")
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. Referencia rápida de API

8.1 Operaciones comunes de nn.Embedding

Operación	Código
Crear capa de embedding	`nn.Embedding(num_embeddings, embedding_dim)`
Cargar embedding preentrenado	`nn.Embedding.from_pretrained(weights)`
Consultar tabla para obtener embedding	`embedding(word_ids)`
Congelar embedding	`embedding.weight.requires_grad = False`
Obtener vector de embedding	`embedding.weight[idx]`

8.2 Recursos de vectores de palabras preentrenados

Recurso	Dimensión	Características
GloVe	50, 100, 200, 300	Estadísticas de co-ocurrencia de palabras, entrenamiento rápido
Word2Vec	50-500	Entrenado por Google, amplia cobertura
FastText	300	Soporta subpalabras, buen manejo de OOV
BERT	768+	Dependiente del contexto, mejores resultados

8.3 Recomendaciones para elegir la capa de embedding

数据量小（< 10K）
    -> 使用预训练词向量（GloVe/FastText）+ 冻结或微调

数据量中等（10K ~ 100K）
    -> 使用预训练词向量 + 微调

数据量大（> 100K）
    -> 可考虑从头训练，或使用大规模预训练模型

领域差异大
    -> 使用领域相关预训练模型或增量训练

资源受限
    -> 冻结嵌入层，使用较小的嵌入维度

Otras extensiones