深入理解CBOW模型：词嵌入矩阵训练原理与实战优化

1次阅读

没有评论

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

传统 NLP 处理文本时，最直接的方法是使用 one-hot 编码。这种方法简单直观，但存在明显缺陷：

维度灾难：词汇表大小决定向量维度，百万级词汇意味着百万维向量
语义缺失：所有词向量相互正交，无法表达词间关系
数据稀疏：实际文本中大部分维度为 0，存储和计算效率低下

CBOW(Continuous Bag-of-Words) 模型通过预测中心词来学习词向量，相比 Skip-gram 有以下优势：

训练效率更高：一次预测利用多个上下文词，特别适合高频词学习
对小数据集更友好：上下文词的共现信息被集中利用
实现更简单：隐藏层直接求平均，计算复杂度更低

CBOW 的核心计算流程可分为三步：

将上下文词 one-hot 向量 ${x_1,…,x_C}$ 通过共享的嵌入矩阵 $W_{V×N}$ 映射：
$$h = \frac{1}{C} \sum_{c=1}^C W^Tx_c$$
隐藏层 $h$ 通过输出矩阵 $W’_{N×V}$ 计算得分：
$$u_j = {W’_j}^T h$$
使用 Softmax 得到概率分布：
$$p(w_j|w_{c1},…,w_{cC}) = \frac{exp(u_j)}{\sum_{j’=1}^V exp(u_{j’})}$$

损失函数采用负对数似然：
$$L = -\log p(w_O|w_{I1},…,w_{IC})$$

梯度更新时需注意：

输入矩阵 $W$ 的梯度是所有上下文词共享的
输出矩阵 $W’$ 只需更新正样本和采样的负样本对应的行

import torch
import torch.nn as nn

# 超参数设置
V = 10000  # 词汇表大小
N = 300    # 嵌入维度

class CBOW(nn.Module):
    def __init__(self):
        super().__init__()
        self.embedding = nn.EmbeddingBag(V, N, mode='mean')
        self.linear = nn.Linear(N, V)

    def forward(self, inputs, offsets):
        # inputs: 拼接的上下文词 ID
        # offsets: 每个样本的起始位置
        embeds = self.embedding(inputs, offsets)
        output = self.linear(embeds)
        return output

from collections import Counter
import numpy as np

# 构建 unigram 分布
word_counts = Counter()
# ... 统计词频 ...

# 计算采样概率
counts = np.array([word_counts[w] for w in range(V)])
noise_dist = counts ** 0.75 / np.sum(counts ** 0.75)

# 负采样函数
def negative_sample(batch_size, num_negatives):
    return torch.multinomial(torch.tensor(noise_dist, dtype=torch.float),
        batch_size * num_negatives,
        replacement=True
    )

def subsample_prob(word_freq, t=1e-5):
    return 1 - np.sqrt(t / word_freq)

# 处理训练数据时
for word in sentence:
    if random.random() < subsample_prob(word_counts[word]):
        continue  # 跳过该词
    # 否则保留

维度	语义相似度 (WS-353)	类比任务准确率	训练时间
50	0.65	38%	1.2h
100	0.71	45%	2.1h
300	0.75	52%	5.8h

测试环境：Intel Xeon 2.4GHz, Tesla V100, 10M tokens 数据集

采用线性 warmup 与余弦退火结合：

from torch.optim.lr_scheduler import (LinearWarmup, CosineAnnealingLR)

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
warmup = LinearWarmup(optimizer, warmup_steps=5000)
scheduler = CosineAnnealingLR(optimizer, T_max=100000)