深入解析CBOW模型：从词向量到自然语言处理实践

1次阅读

共计 2370 个字符，预计需要花费 6 分钟才能阅读完成。

在自然语言处理（NLP）任务中，词向量（Word Embedding）是表示词语语义的核心技术。传统的词表示方法，如 one-hot 编码，存在维度灾难和无法捕捉语义关系的局限性。词向量技术通过将词语映射到低维连续向量空间，解决了这些问题。

CBOW（Continuous Bag-of-Words）模型是一种经典的词向量训练方法，它通过上下文预测当前词，适合处理大规模语料库。

CBOW 模型：通过上下文词语预测当前词，训练速度快，适合处理高频词。
Skip-gram 模型：通过当前词预测上下文词语，适合处理低频词，但训练速度较慢。
适用场景：
CBOW 适用于语料库较大且对训练速度要求高的场景。
Skip-gram 适用于需要更好捕捉低频词语义的场景。

以下是一个完整的 CBOW 模型实现代码，包含数据预处理、模型架构和训练循环。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# 数据预处理
class CBOWDataset(Dataset):
    def __init__(self, texts, vocab, window_size=2):
        self.vocab = vocab
        self.data = []
        for text in texts:
            tokens = text.split()
            for i in range(window_size, len(tokens) - window_size):
                context = [vocab[tokens[i + j]] for j in range(-window_size, window_size + 1) if j != 0]
                target = vocab[tokens[i]]
                self.data.append((context, target))

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        context, target = self.data[idx]
        return torch.tensor(context), torch.tensor(target)

# 模型架构
class CBOW(nn.Module):
    def __init__(self, vocab_size, embedding_dim):
        super(CBOW, self).__init__()
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.linear = nn.Linear(embedding_dim, vocab_size)

    def forward(self, inputs):
        embeds = self.embeddings(inputs).mean(dim=1)
        out = self.linear(embeds)
        return out

# 训练循环
def train_model(texts, vocab, embedding_dim=100, epochs=10, batch_size=32, lr=0.001):
    dataset = CBOWDataset(texts, vocab)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    model = CBOW(len(vocab), embedding_dim)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=lr)

    for epoch in range(epochs):
        total_loss = 0
        for context, target in dataloader:
            optimizer.zero_grad()
            output = model(context)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            total_loss += loss.item()
        print(f'Epoch {epoch}, Loss: {total_loss / len(dataloader)}')

    return model