深入解析CBOW模型的词嵌入矩阵生成原理与实现

1次阅读

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

词嵌入（Word Embedding）是自然语言处理中的一项核心技术，它能够将词语映射到一个低维连续向量空间中，使得语义相似的词语在向量空间中的距离更近。CBOW（Continuous Bag-of-Words）模型是生成词嵌入的经典方法之一，它通过上下文词语来预测目标词，从而学习到词向量表示。

CBOW 模型的结构相对简单，主要由输入层、隐藏层和输出层组成。输入层接收上下文词语的 one-hot 编码，隐藏层对这些输入进行加权平均，输出层则通过 softmax 函数计算目标词的概率分布。整个过程可以看作是一个简单的神经网络，通过不断调整权重矩阵来最小化预测误差。

词嵌入矩阵是 CBOW 模型的核心部分，它实际上是一个权重矩阵，将词语的 one-hot 编码映射到低维向量空间。具体来说，假设我们的词汇表大小为 V，词向量维度为 D，那么词嵌入矩阵 W 的大小为 V×D。

输入层到隐藏层的计算 ：
假设窗口大小为 C，即使用目标词前后的 C 个词语作为上下文。
每个上下文词语的 one-hot 编码 x_i（大小为 V×1）与词嵌入矩阵 W 相乘，得到词向量 v_i = W^T x_i（大小为 D×1）。
隐藏层的输出 h 是对所有上下文词向量的平均：h = (1/C) * Σ(v_i)。
隐藏层到输出层的计算 ：
隐藏层的输出 h 与另一个权重矩阵 W ’（大小为 D×V）相乘，得到未归一化的得分向量 u = W’^T h。
通过 softmax 函数将 u 转换为概率分布：y = softmax(u)。
目标是最小化预测分布 y 与真实分布（目标词的 one-hot 编码）之间的交叉熵损失。

以下是使用 PyTorch 实现 CBOW 模型的完整代码，包含详细注释：

import torch
import torch.nn as nn
import torch.optim as optim

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):
        # inputs 是上下文词语的索引，形状为 (batch_size, window_size*2)
        embeds = self.embeddings(inputs)           # 获取词向量，形状为 (batch_size, window_size*2, embedding_dim)
        h = torch.mean(embeds, dim=1)              # 平均词向量，形状为 (batch_size, embedding_dim)
        out = self.linear(h)                       # 线性变换，形状为 (batch_size, vocab_size)
        log_probs = torch.log_softmax(out, dim=1)  # 对数概率
        return log_probs

# 示例用法
vocab_size = 10000
embedding_dim = 100
model = CBOW(vocab_size, embedding_dim)
loss_function = nn.NLLLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 假设 context_ids 是上下文词语的索引，target_id 是目标词语的索引
context_ids = torch.tensor([[1, 2, 4, 5], [3, 6, 1, 2]], dtype=torch.long)
target_id = torch.tensor([3, 7], dtype=torch.long)

# 训练步骤
model.zero_grad()
log_probs = model(context_ids)
loss = loss_function(log_probs, target_id)
loss.backward()
optimizer.step()