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

1次阅读

没有评论

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

在自然语言处理（NLP）中，计算机需要将词语转换为数值形式才能进行处理。传统的表示方法如 one-hot 编码存在明显缺陷：

维度灾难：词汇表越大，向量维度越高
无法表达语义关系：所有词向量都是正交的
无法处理未登录词（OOV）

Word2Vec 家族中两个主要模型对比：

CBOW（Continuous Bag-of-Words）
通过上下文预测当前词
训练速度更快
对高频词表现更好
Skip-gram
通过当前词预测上下文
更适合处理低频词
需要更多训练时间

实际选择建议：
– 小型数据集优先考虑 CBOW
– 需要捕捉细粒度语义时选择 Skip-gram

import torch
import torch.nn as nn
import torch.optim as optim
from collections import Counter
import numpy as np

# 构建词汇表
def build_vocab(corpus, min_freq=5):
    vocab = Counter()
    for sentence in corpus:
        vocab.update(sentence.split())

    # 过滤低频词
    vocab = {word:idx for idx, (word, count) in enumerate(vocab.items()) 
             if count >= min_freq}
    # 添加特殊 token
    vocab['<unk>'] = len(vocab)
    vocab['<pad>'] = len(vocab)
    return vocab

class CBOW(nn.Module):
    def __init__(self, vocab_size, embedding_dim, context_size):
        super(CBOW, self).__init__()
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.linear = nn.Linear(embedding_dim, vocab_size)
        self.context_size = context_size

    def forward(self, inputs):
        # inputs 形状: [batch_size, 2*context_size]
        embeds = self.embeddings(inputs)  # [batch_size, 2*context_size, emb_dim]
        out = torch.mean(embeds, dim=1)   # 平均池化 [batch_size, emb_dim]
        out = self.linear(out)            # [batch_size, vocab_size]
        return out

def train_model(model, data_loader, epochs=10, lr=0.001):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)
    optimizer = optim.Adam(model.parameters(), lr=lr)
    criterion = nn.CrossEntropyLoss()

    for epoch in range(epochs):
        total_loss = 0
        for batch in data_loader:
            context, target = batch
            context, target = context.to(device), target.to(device)

            optimizer.zero_grad()
            output = model(context)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()

            total_loss += loss.item()
        print(f"Epoch {epoch+1}, Loss: {total_loss/len(data_loader):.4f}")