深入解析CBOW模型：手算词嵌入步骤与梯度计算实战指南

1次阅读

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

词嵌入（Word Embedding）是自然语言处理（NLP）中的一项基础技术，它将词汇映射到低维向量空间中，使得相似的词在向量空间中距离更近。CBOW（Continuous Bag of Words）模型是词嵌入的经典实现之一，广泛应用于词向量训练任务。然而，许多开发者在手动实现 CBOW 模型时，对词嵌入步骤和梯度计算的理解不够深入，导致模型效果不佳或训练效率低下。

常见的困惑点包括：

如何正确构建输入和输出矩阵？
前向传播过程中如何计算词向量？
损失函数的选择和计算方式是什么？
反向传播中梯度如何更新？

本文将从零开始，详细解析 CBOW 模型的手算词嵌入步骤和梯度计算过程，帮助开发者掌握核心原理。

CBOW 和 Skip-gram 是 Word2Vec 的两种主要实现方式，各有优缺点：

CBOW 模型：
优点：训练速度快，尤其适合小型数据集。
缺点：对罕见词的捕捉能力较弱。
Skip-gram 模型：
优点：对罕见词的表现更好。
缺点：训练速度较慢，需要更多数据。

在实际应用中，CBOW 更适合高频词较多的任务，而 Skip-gram 更适合低频词较多的任务。

前向传播是 CBOW 模型的核心步骤之一，主要包括以下几个部分：

输入层：将上下文词（通常是窗口内的词）转换为 one-hot 向量。
隐藏层：将 one-hot 向量与嵌入矩阵相乘，得到词向量。
输出层：将隐藏层的输出与输出矩阵相乘，并通过 softmax 函数计算概率分布。

CBOW 模型的损失函数通常采用交叉熵损失，其计算公式为：

[L = -\sum_{i=1}^{V} y_i \log(p_i) ]

其中，(y_i)是目标词的 one-hot 向量，(p_i)是模型预测的概率分布。

反向传播是梯度计算的核心步骤，主要包括：

计算输出层的梯度。
更新输出矩阵。
计算隐藏层的梯度。
更新嵌入矩阵。

以下是一个简单的 Python 实现，展示如何手动计算词嵌入和梯度：

import numpy as np

# 定义词汇表大小和嵌入维度
vocab_size = 10000
embedding_dim = 100

# 初始化嵌入矩阵和输出矩阵
W1 = np.random.randn(vocab_size, embedding_dim)  # 嵌入矩阵
W2 = np.random.randn(embedding_dim, vocab_size)  # 输出矩阵

# 定义前向传播函数
def forward(context_words, target_word):
    # 将上下文词转换为 one-hot 向量
    context_vectors = np.zeros((len(context_words), vocab_size))
    for i, word in enumerate(context_words):
        context_vectors[i, word] = 1

    # 计算隐藏层输出
    hidden = np.mean(np.dot(context_vectors, W1), axis=0)

    # 计算输出层
    output = np.dot(hidden, W2)

    # softmax 计算概率分布
    exp_output = np.exp(output)
    probs = exp_output / np.sum(exp_output)

    return hidden, probs

# 定义损失函数
def compute_loss(probs, target_word):
    target_vector = np.zeros(vocab_size)
    target_vector[target_word] = 1
    loss = -np.sum(target_vector * np.log(probs))
    return loss

# 定义反向传播函数
def backward(context_words, target_word, hidden, probs, learning_rate=0.01):
    # 计算输出层的梯度
    target_vector = np.zeros(vocab_size)
    target_vector[target_word] = 1
    d_output = probs - target_vector

    # 更新输出矩阵
    dW2 = np.outer(hidden, d_output)
    W2 -= learning_rate * dW2

    # 计算隐藏层的梯度
    d_hidden = np.dot(W2, d_output)

    # 更新嵌入矩阵
    context_vectors = np.zeros((len(context_words), vocab_size))
    for i, word in enumerate(context_words):
        context_vectors[i, word] = 1

    dW1 = np.dot(context_vectors.T, d_hidden.reshape(1, -1))
    W1 -= learning_rate * dW1

# 示例调用
context_words = [1, 2, 3]  # 假设词汇索引为 1, 2, 3 的词是上下文
target_word = 4            # 目标词索引为 4
hidden, probs = forward(context_words, target_word)
loss = compute_loss(probs, target_word)
backward(context_words, target_word, hidden, probs)

CBOW 模型的计算复杂度主要取决于词汇表大小和嵌入维度。具体来说：