了解连续的单词袋（CBOW）-人工智能-PHP中文网

语义很重要，因为在NLP中，这是正在研究的单词之间的关系。最简单但最有效的过程之一是连续的单词袋（CBOW），将单词映射到称为单词向量的高度有意义的向量。 CBow在Word2Vec框架中使用，并根据与之相邻的单词预测一个单词，该单词捕获了语言的语义和语法含义。在本文中，读者将了解CBOW模型的操作以及其使用方法。

学习目标

了解CBOW模型背后的理论。
了解CBow和Skip-gram之间的差异。
使用示例数据集实现Python中的CBOW模型。
分析CBOW的优势和局限性。
探索CBOW生成的单词嵌入的用例。

什么是连续的单词模型？

连续的单词袋（CBOW）也是一种模型，它在使用神经网络确定嵌入单词时使用，并且是Tomas Mikolov的Word2Vec模型的一部分。 CBow试图根据给定句子观察的上下文单词预测目标词。这样，它就能捕获语义关系，因此在高维空间中密切表示近距离表示。

例如，在“猫坐在垫子上”的句子中，如果上下文窗口大小为2，则“ sat”的上下文单词是[“”，“”，“ cat”，“ on”，“ the”] ，并且该模型的任务是预测“ sat”一词。

CBOW通过汇总上下文单词（例如，平均嵌入）并使用此汇总表示来预测目标单词来运行。该模型的体系结构涉及上下文单词的输入层，用于嵌入生成的隐藏层以及使用概率分布预测目标单词的输出层。

这是一个适合处理频繁单词的快速高效模型，非常适合需要语义理解的任务，例如文本分类，推荐系统和情感分析。

连续的单词如何工作

CBow是根据上下文的最简单，有效的技术之一，用于单词嵌入，其中整个单词的词汇映射到向量。本节还将CBOW系统的操作描述为在其最基本的层面上理解该方法的一种手段，讨论了基于CBOW方法的主要思想，并为CBOW命中计算系统的架构布局提供了综合指南。

了解上下文和目标词

CBow依靠两个关键概念：上下文单词和目标词。

上下文词：这些是定义的窗口大小中的目标词围绕目标单词的单词。例如，在句子中：
“快速的棕色狐狸跳过懒狗” ，
如果目标词是“ fox” ，而上下文窗口大小为2，则上下文单词为[“快速”，“棕色”，“跳”，“ Over”] 。
目标词：这是CBOW旨在预测上下文单词的单词。在上面的示例中，目标词是“狐狸” 。

通过分析上下文与大型语料库中的目标单词之间的关系，CBOW生成嵌入，以捕获单词之间的语义关系。

CBOW的逐步过程

这是CBOW工作原理的细分，分步：

步骤1：数据准备

选择文本语料库（例如，句子或段落）。
将文本归为单词并构建词汇。
定义上下文窗口大小nnn（例如，每侧2个单词）。

步骤2：生成上下文目标对

对于语料库中的每个单词，请根据窗口大小提取其周围的上下文单词。
示例：对于“我爱机器学习”和n = 2n = 2n = 2的句子，对是：目标词上下文单词爱[i”，“ machine”]机器[“爱”，“学习”]

步骤3：单速编码

基于词汇大小，将上下文单词和目标单词转换为单热矢量。对于大小5的词汇，“爱”一词的单次表示可能看起来像[0、1、0、0、0、0] 。

步骤4：嵌入层

通过嵌入层传递单热编码的上下文单词。该层将每个单词映射到密集的向量表示，通常比词汇大小较低。

步骤5：上下文聚合

汇总所有上下文单词的嵌入（例如，平均或求和它们）形成单个上下文向量。

步骤6：预测

将聚合的上下文向量馈入具有软磁输出层的完全连接的神经网络。
该模型根据词汇上的概率分布预测最可能的单词作为目标。

步骤7：损失计算和优化

使用跨透镜损失函数计算预测和实际目标词之间的误差。
反向传播误差以调整嵌入和预测层中的权重。

步骤8：对所有对重复

重复语料库中所有上下文目标对的过程，直到模型收敛为止。

CBow架构详细解释

连续的单词（CBOW）模型架构旨在根据其周围上下文单词进行预测目标单词。它是一个具有直接但有效结构的浅神经网络。 CBOW架构由以下组件组成：

输入层

输入表示：
该模型的输入是上下文单词表示为单热编码向量。
- 如果词汇大小为v，则每个单词表示为大小为V的单式向量，在索引处单个1表示与单词相对应的索引，而在其他地方为0。
- 例如，如果词汇为[“猫”，“狗”，“狐狸”，“树”，“鸟”]和“狐狸”一词是第三个单词，则其一hot矢量为[0,0,1,0,0] [0，0，0，0，1，1，0，0，0] [0,0,1,1,0,0]。
上下文窗口：
上下文窗口大小n确定了使用的上下文单词的数量。如果n = 2，则使用目标单词的每一侧两个单词。
- 对于句子： “快速的棕色狐狸跳过懒狗”和目标单词“狐狸” ，n = 2的上下文单词是[“快速”，“棕色”，“跳跃”，“ Over”] 。

嵌入层

目的：
该层将在高尺寸中存在的单热量向量转换为最大密度和低尺寸向量。与以下事实相反：在单词嵌入单词中被表示为具有零值的向量，在嵌入式层中，每个单词都由所需维度的连续向量编码，这些维度反映了单词含义的特定特征。
单词嵌入矩阵：
嵌入层保持一个单词嵌入尺寸v×d的矩阵W，其中v是词汇大小，d是嵌入尺寸。
- W的每一行代表单词的嵌入。
- 对于单热向量XXX，将嵌入计算为W^TX X。
上下文词嵌入：
使用嵌入矩阵将每个上下文单词转换为相应的致密矢量。如果窗口大小n = 2，并且我们有4个上下文单词，则提取了这些单词的嵌入。

隐藏层：上下文聚合

目的：
将上下文单词的嵌入组合在一起以形成单个上下文向量。
聚合方法：
- 平均值：所有上下文单词的嵌入平均以计算上下文向量。

了解连续的单词袋（CBOW）

求和：嵌入而不是平均，而是求和。

了解连续的单词袋（CBOW）

结果上下文向量：结果是单个密集的向量HHH，代表周围单词的汇总上下文。

输出层

目的：输出层使用上下文向量HHH预测目标单词。
完全连接的层：上下文向量HHH通过一个完全连接的层，该层输出了词汇中每个单词的原始分数。这些分数称为逻辑。
SoftMax函数：逻辑通过SoftMax函数传递，以计算词汇上的概率分布：

了解连续的单词袋（CBOW）

预测的目标词：第一个原因是，在SoftMax输出时，该算法将目标词定义为具有最高概率的单词。

损失功能

跨透镜损失用于将预测的概率分布与实际目标词（地面真相）进行比较。
使用随机梯度下降（SGD）或其变体等优化技术将损失最小化。

CBOW的示例

输入：
句子： “我爱机器学习” ，目标词： “机器” ，上下文词： [“我”，“爱”，“学习”] 。

单速编码：
词汇： [“我”，“爱”，“机器”，“学习”，“ AI”]

一旋向量：
- “ i”：[1,0,0,0,0] [1，0，0，0，0] [1,0,0,0,0]
- “爱”：[0,1,0,0,0] [0、1、0、0、0] [0,1,0,0,0]
- “学习”：[0,0,0,1,0] [0，0，0，1，0] [0,0,0,1,0]

嵌入层：

嵌入尺寸：d = 3。
嵌入矩阵W：

了解连续的单词袋（CBOW）

嵌入：

“我”：[0.1,0.2,0.3]
“爱”：[0.4,0.5,0.6]
“学习”：[0.2,0.3,0.4]

聚合：

平均嵌入：

了解连续的单词袋（CBOW）

输出层：

计算logits，应用SoftMax并预测目标词。

CBOW建筑图

输入层：[“ i”，“ love”，“学习”]
     - >一式编码
     - >嵌入层
         - >密集的嵌入
         - >汇总上下文向量
         - >完全连接的层Softmax
输出：预测单词“机器”

登录后复制

从头开始编码CBOW（带有Python的示例）

现在，我们将浏览Python中从头开始实施CBOW模型。

准备CBOW数据

第一个尖峰是将文本转换为代币，将文字与上下文对键对面生成的单词与上下文作为包含目标单词的单词。

 copus =“快速棕狐跳过懒狗”
colpus = colpus.lower（）。split（）＃tokenization和lowercase转换

＃定义上下文窗口大小
C = 2
context_target_pairs = []

＃生成上下文目标对
对于我的范围（c，len（corpus） -  c）：
    context = copus [i -c：i] copus [i 1：i c 1]
    target = copus [i]
    context_target_pairs.append（（（上下文，目标）））

print（“上下文 - 目标对：”，context_target_pairs）

登录后复制

输出：

上下文目标对：[（[['the'，'quick'，'fox'，跳跃']，'brown'），（['quick''，''，'brown'，''''，'off'']，'fox'），（['brown''，'fox'over'over'over'off'' “超过”，“懒惰”，“狗”]，“''）]]

登录后复制

创建字典一词

我们构建了一个词汇（独特的单词集），然后将每个单词映射到唯一的索引，反之亦然，以期在训练过程中进行有效的查找。

 ＃创建词汇并将每个单词映射到索引
vocab = set（语料库）
word_to_index = {word：idx for IDX，枚举（vocab）中的字}}
index_to_word = {idx：Word Word，word_to_index.items（）}中的idx

打印（“ word to Index字典：”，Word_to_index）

登录后复制

输出：

单词到索引字典：{'brown'：0，'dog'：1，'quick'：2，'跳跃'：3，'fox'：4，'over'：5，'the'：6，'lazy'：7}

登录后复制

一式编码示例

单速编码作品是通过将单词形成系统中的每个单词转换为向量的，其中该单词的指标为“ 1”，而其余的地方则为“ 0”，出于很快的原因。

 def One_hot_encode（word，word_to_index）：
    ONE_HOT = NP.Zeros（len（word_to_index））
    ONE_HOT [word_to_index [word]] = 1
    返回One_hot

＃一个单词“快速”的示例用法
context_one_hot = [one_hot_encode（word，word_to_index）for ['the'the'，'quick']]中的字
print（“'quick''的单速编码：”，context_one_hot [1]）

登录后复制

输出：

单速编码为“快速”：[0。 0。1。0。0。0。0。0。0。]

登录后复制

从头开始构建CBOW模型

在此步骤中，我们创建了一个具有两个层的基本神经网络：一个用于单词嵌入，另一个用于基于上下文单词计算输出，平均上下文并将其传递到网络中。

 cbow级：
    def __init __（self，vocab_size，embedding_dim）：
        ＃随机初始化嵌入和输出层的权重
        self.w1 = np.random.randn（vocab_size，embedding_dim）
        self.w2 = np.random.randn（embedding_dim，vocab_size）
        
    def向前（self，context_words）：
        ＃计算隐藏层（上下文单词的平均值）
        h = np.mean（context_words，axis = 0）
        ＃计算输出层（SoftMax概率）
        输出= np.dot（h，self.w2）
        返回输出
    
    向后def（self，context_words，target_word，Learning_rate = 0.01）：
        ＃正向通行证
        h = np.mean（context_words，axis = 0）
        输出= np.dot（h，self.w2）
        
        ＃计算错误和梯度
        错误= target_word-输出
        self.w2 = Learning_rate * np.outer（h，错误）
        self.w1 = Learning_rate * np.outer（context_words，错误）

＃创建CBOW对象的示例
vocab_size = len（word_to_index）
embedding_dim = 5＃让我们假设5维嵌入

cbow_model = cbow（vocab_size，embedding_dim）

＃使用随机上下文单词和目标（例如）
context_words = [one_hot_encode（word，word_to_index）for ['the'the'，'quick'，'fox'，'跃跳']中的字
context_words = np.array（context_words）
context_words = np.mean（context_words，axis = 0）＃普通上下文单词
target_word = one_hot_encode（'brown'，word_to_index）

＃向前通过CBOW模型
输出= cbow_model.forward（context_words）
打印（“ CBOW向前通行证的输出：”，输出）

登录后复制

输出：

 CBOW向前通行证的输出：[[-0.20435729 -0.23851241 -0.08105261 -0.14251447 0.20442154 0.14336586
  -0.06523201 0.0255063]
 [-0.0192184 -0.12958821 0.1019369 0.11101922 -0.177773069 -0.02340574
  -0.22222151 -0.23863179]
 [0.21221977 -0.15263454 -0.015248 0.27618767 0.02959409 0.21777961
   0.16619577 -0.20560026]
 [0.05354038 0.06903295 0.0592706 -0.13509918 -0.00439649 0.18007843
   0.1611929 0.2449023]
 [0.01092826 0.19643582 -0.07430934 -0.16443165 -0.01094085 -0.27452367
  -0.13747784 0.31185284]]]

登录后复制

使用TensorFlow实现CBOW

TensorFlow通过定义使用嵌入层来学习单词表示和输出密集层的神经网络来简化过程，并使用上下文单词预测目标单词。

导入TensorFlow作为TF

＃使用TensorFlow定义简单的CBOW模型
cbowmodel类（tf.keras.model）：
    def __init __（self，vocab_size，embedding_dim）：
        super（cbowmodel，self）.__ init __（）
        self.embeddings = tf.keras.layers.embedding（input_dim = vocab_size，output_dim = embedding_dim）
        self.output_layer = tf.keras.layers.dense（vocab_size，activation ='softmax'）
    
    def呼叫（self，context_words）：
        embedded_context = self.embeddings（context_words）
        context_avg = tf.reduce_mean（embedded_context，axis = 1）
        输出= self.output_layer（context_avg）
        返回输出

＃示例用法
model = cbowmodel（vocab_size = 8，embedding_dim = 5）
context_input = np.random.randint（0，8，size =（1，4））＃随机上下文输入
context_input = tf.convert_to_tensor（context_input，dtype = tf.int32）

＃正向通行证
输出=模型（context_input）
打印（“ Tensorflow Cbow型号的输出：”，output.numpy（））

登录后复制

输出：

 TensorFlow CBOW模型的输出：[[0.12362909 0.12616573 0.12758036 0.12601459 0.12477358 0.1237749
  0.1231998 0.12486169]]]

登录后复制

使用Gensim进行CBOW

Gensim在Word2Vec（）函数中提供了现成的CBOW实现，其中无需在培训上劳动，因为Gensim训练文本语料库的单词嵌入。

导入Gensim
来自Gensim.models导入Word2vec

＃准备数据（单词列表列表）
copus = [[“”，“ Quick”，“ Brown”，“ Fox”]，[“跳”，“ Over”，“ The”，“ lazy”，“ dog”]]

＃使用CBOW训练Word2Vec型号
model = word2vec（colpus，vector_size = 5，window = 2，min_count = 1，sg = 0）

＃获取单词的向量表示
vector = model.wv ['fox']
打印（“'fox'的向量表示：”，向量）

登录后复制

输出：

 “福克斯”的矢量表示：[-0.06810732 -0.01892803 0.11537147 -0.15043275 -0.07872207]

登录后复制

连续袋的优点

现在，我们将探索连续袋的优势：

有效学习单词表示：CBOW通过使用上下文单词有效地学习单词的密集矢量表示。与传统的单热编码相比，这会导致较低的矢量，这在计算上可能很昂贵。
捕获语义关系：CBOW基于单词在大型语料库中的上下文中捕获语义关系。这使模型可以学习单词相似性，同义词和其他上下文细微差别，这些差异在信息检索和情感分析之类的任务中很有用。
可伸缩性：CBOW模型可扩展，并且可以有效地处理大型数据集，从而非常适合具有大量文本数据的应用程序，例如搜索引擎和社交媒体平台。
上下文灵活性：CBOW可以处理不同数量的上下文（即所考虑的周围单词的数量），在学习单词表示单词所需的上下文中提供灵活性。
NLP任务中的性能提高了：CBOW的单词嵌入式通过提供高质量的功能表示，增强了下游NLP任务的性能，例如文本分类，命名实体识别和机器翻译。

连续的单词袋的局限

现在让我们讨论CBOW的局限性：

对上下文窗口大小的敏感性：CBOW的性能高度取决于上下文窗口大小。一个小窗口可能只会捕获本地关系，而大窗口可能会模糊单词的独特性。找到最佳上下文大小可能具有挑战性且依赖于任务。
缺乏单词顺序敏感性：CBOW无视上下文中单词的顺序，这意味着它不会捕获语言的顺序性质。对于需要对单词顺序深入了解的任务，例如句法解析和语言建模，此限制可能是有问题的。
稀有词的困难：CBOW难以生成有意义的嵌入，以实现稀有或访问量的单词（OOV）。该模型依赖于上下文，但是单词不经常的数据稀疏会导致矢量表示不良。
仅限于浅色上下文理解：尽管CBOW捕获基于周围单词的单词含义，但它在理解更复杂的语言现象（例如长期依赖性，讽刺或讽刺）方面具有有限的功能，这可能需要更复杂的模型（例如变形金刚）。
无法很好地处理多义：具有多种含义的单词（polysemy）对于CBOW可能是有问题的。由于该模型会为每个单词生成一个嵌入，因此与Bert或Elmo（例如Bert或Elmo ）不同，它可能无法捕获单词在不同上下文中所具有的不同含义。

结论

事实证明，连续的单词（CBOW）模型是通过利用周围环境来生成单词嵌入的一种有效而直观的方法。通过其简单而有效的架构，Cbow弥合了原始文本和有意义的向量表示之间的差距，从而实现了广泛的NLP应用程序。通过了解CBOW的工作机制，其优势和局限性，我们可以更深入地了解NLP技术的发展。 Cbow凭借其在嵌入生成中的基本作用，继续成为探索先进语言模型的垫脚石。