精华内容
下载资源
问答
  • 项目 软件测试计划 编号v 1.0 武藏物联公司 2018年03月 xx-软件测试计划 目录 1 文档说明 . 2 1.1 文档信息 . 2 1.2 文档控制 . 2 1.2.1 变更记录 . 2 1.2.2 审阅记录 . 3 引言. 4 2 .
  • word2vec

    2019-12-04 19:40:03
    目录 1.为何不用one-hot 2.跳字模型skip-gram 2.1训练跳字模型 3.连续词袋模型continuous bag of words,CBOW 3.1训练连续词袋模型 4.近似训练 4.1负采样 4.2 层序hierarchical softmax 负采样通过考虑...

    目录

    1.为何不用one-hot

    2.跳字模型skip-gram

    2.1训练跳字模型

    3.连续词袋模型continuous bag of words,CBOW

    3.1训练连续词袋模型

    4.近似训练

    4.1负采样

    4.2 层序hierarchical softmax  

     

    负采样通过考虑同时含有正类样本和负类样本的相互独⽴事件来构造损失函数。其训练中每⼀步的梯度计算开销与采样的噪声词的个数线性相关。

    层序softmax使用了二叉树,并根据根结点到叶结点的路径来构造损失函数。其训练中每一步的梯度计算开销与词典大小的对数相关。


    1.为何不用one-hot

             one-hot将每个词转换成对应的索引0~N-1;假设某个词的索引i,那么其one-hot向量表示为全长N的零向量,并将第i个设为1。

            虽然 one-hot词向量构造起来很容易,但通常并不是⼀个好选择。 ⼀个主要的原因是,one-hot词向量⽆法准确表达不同词之间的相似度,如我们常使⽤的余弦相似度。对于向量X,Y,它们的余弦相似度是它们之间夹⻆的余弦值

                       \frac{x^Ty}{||x|| \ ||y||} \in [-1,1]

           由于任何两个不同词的one-hot向量的余弦相似度都为0,多个不同词之间的相似度难以通过one-hot向量准确地体现出来。

           word2vec⼯具的提出正是为了解决上⾯这个问题 [1]。它将每个词表示成⼀个定⻓的向量,并使得这些向量能较好地表达不同词之间的相似和类⽐关系。word2vec⼯具包含了两个模型,即跳字模型 (skip-gram)[2] 和连续词袋模型(continuous bag of words,CBOW)[3]。接下来让我们分别介绍这两个模型以及它们的训练⽅法。

    2.跳字模型skip-gram

    跳字模型假设基于某个词来⽣成它在⽂本序列周围的词.举个例⼦,假设⽂本序列 是“the”“man”“loves”“his”“son”。

    以“loves”作为中⼼词,设背景窗⼝⼤⼩为2。如图所示,跳字模型所关⼼的是,给定中⼼词“loves”,⽣成与它距离不超过2个词的背景词“the”“man”“his”“son”的 条件概率,即

                     P(the,man,his,son|loves)

    贝叶斯网络推断条件独立性,给定中⼼词的情况下,背景词的⽣成是相互独⽴的,那么上式可以改写成

                   P(the|loves)\cdot P(man|loves)\cdot P(his|loves)\cdot P(son|loves)

    在跳字模型中,每个词被表示成两个d维向量,⽤来计算条件概率。假设这个词在词典中索引为i,当它为中⼼词时向量表示为v_i\in R^d,⽽为背景词时向量表示为u_i\in R^d。设中⼼词w_c在词典中索引为c ,背景词w_o在词典中索引为o ,给定中⼼词⽣成背景词的条件概率可以通过对向量内积做softmax运算⽽得到:

                P(w_o|w_c)=\frac{exp(u_o^Tv_c)}{\sum_{i\in V}exp(u_i^Tv_c)},其中词典索引集V=\left\{ 0,1,...,|V|-1 \right\}                  (1)

     假设给定一个长度为T的文本序列,设时间步t的词为w^{(t)}。那么给定中心词的情况下,当背景词窗口大小为m时,跳字模型的似然函数,即 给定任一中心词生成所有背景词的条件概率:

              \prod _{t=1}^T\prod_{-m\leq j\leq m,j\neq0}P(w^{(t+j)}|w^{(t)})                                                                                   (2)

    2.1训练跳字模型

            跳字模型的参数是每个词对应的中心词向量和背景词向量。训练中我们通过最大似然估计来学习模型参数,即等价于最小化对数损失函数:

                        L=-\sum _{t=1}^T\sum_{-m\leq j\leq m,j\neq0}logP(w^{(t+j)}|w^{(t)})                                                   (3)

    (1)式求对数得:

                     logP(w_o|w_c)=u_o^Tv_c-log({\sum_{i\in V}exp(u_i^Tv_c)})                                                 (4)

       通过微分,我们可以得到上式中v_c的梯度:

                    \begin{align*}\frac{\partial logP(w_o|w_c)}{\partial v_c} &=u_o-\frac{\sum_{j\in V}exp(u_j^Tv_c)}{\sum_{i\in V}exp(u_i^Tv_c)}\cdot u_j \\ &=u_o-\sum_{j\in V}\frac{exp(u_j^Tv_c)}{\sum_{i\in V}exp(u_i^Tv_c)}\cdot u_j \\ &= u_o-\sum_{j\in V}P(w_j|w_c)\cdot u_j \end{align*}                                        (5)

    它的计算需要词典中所有词以w_c为中心词的条件概率。有关其它词向量的梯度同理可得。

    训练结束后,对于字典中任一索引为i的词,我们均得到该词作为中心词和背景词的两组词向量v_i,u_i

    在⾃然语⾔处理应⽤中,⼀般使⽤跳字模型的中⼼词向量作为词的表征向量

    3.连续词袋模型continuous bag of words,CBOW

           连续词袋模型与跳字模型类似。与跳字模型最⼤的不同在于,

           连续词袋模型假设基于某中⼼词在⽂本序列前后的背景词来⽣成该中⼼词。

           在同样的⽂本序列“the”“man”“loves”“his”“son”⾥,以“loves”作为中⼼词,且背景窗⼝⼤⼩为2时,连续词袋模型关⼼的是,给定背景词“the”“man”“his”“son”⽣成中⼼词“loves”的条件概率(如图所示),

     

          也就是            

                   P(loves|the,man,his,son)

          因为连续词袋模型的背景词有多个,我们将这些背景词向量取平均,然后使⽤和跳字模型⼀样的⽅法来计算条件概率.

          假设v_i\in R^du_i\in R^d分别为词典中索引为i的词作为背景词和中⼼词的向量(注意符号与跳字模型中的相反)。设中⼼词w_c在词典中索引为c ,背景词w_{o_1},...,w_{o_{2m}}在词典中索引为o_1,...,o_{2m},那么给定背景词生成中心词的条件概率:

                   P(w_c|w_{o_1},...,w_{o_{2m}})=\frac{exp(\frac{1}{2m}u_c^T(v_{o_1}+...+v_{o_{2m}}))}{\sum_{i\in V}exp(\frac{1}{2m}u_i^T(v_{o_1}+...+v_{o_{2m}}))}               (6)

          为了让符号更加简单,记W_o=\left \{ w_{o_1},...,w_{o_{2m}} \right \},and \ \bar{v}_o=(v_{o_1}+...v_{o_{2m}})/(2m),那么上式可写成

                  P(w_c|W_o)=\frac{exp(u_c^T \bar{v}_o)}{\sum_{i\in V}exp(u_i^T \bar{v}_o)}                                                            (7)

           给定一个长度为T的文本序列,设时间步t的词为w^{(t)},背景词窗口大小为m。连续词袋模型的似然函数,即 由背景词生成任一中心词的条件概率:

              \prod_{t=1}^TP(w^{(t)}|w^{(t-m)},...,w^{(t-1)},w^{(t+1)},...,w^{(t+m)})

    3.1训练连续词袋模型

            与跳字模型基本一致。其损失函数为:

                   L=-\sum_{t=1}^TlogP(w^{(t)}|w^{(t-m)},...,w^{(t-1)},w^{(t+1)},...,w^{(t+m)})             (8)

           注意到(7)式取对数得

                 logP(w_o|w_c)=u_c^T\bar{v}_o-log({\sum_{i\in V}exp(u_i^T\bar{v}_o)})                                      (9)

          通过微分,对上式任一背景词向量v_{o_i}(i=1,...,2m)求梯度得

                \frac{\partial logP(w_c|W_o)}{\partial v_{o_i}}=\frac{1}{2m}\left ( u_c-\sum_{j\in V}\frac{exp(u_j^T\bar{v}_o)}{\sum_{i\in V}exp(u_i^T\bar{v}_o)}\cdot u_j \right )=\frac{1}{2m}\left (u_c-\sum_{j\in V}P(w_j|W_o)\cdot u_j \right )      (10)

          有关其他词向量的梯度同理可得。同跳字模型不⼀样的⼀点在于我们⼀般使⽤连续词袋模型的背景词向量作为词的表征向量

    4.近似训练

          跳字模型的核心在于使用softmax运算得到给定中心词w_c来生成背景词w_o的条件概率:

                  即(1)式                

                   P(w_o|w_c)=\frac{exp(u_o^Tv_c)}{\sum_{i\in V}exp(u_i^Tv_c)}

         该条件概率对应的相应的对数损失为

                  -logP(w_o|w_c)=-u_o^Tv_c+log({\sum_{i\in V}exp(u_i^Tv_c)})                                               (11)

         由于softmax运算考虑了背景词可能是词典中的任⼀词,以上损失包含了词典⼤⼩数⽬的项的累加。

         不论是跳字模型还是连续词袋模型,由于条件概率使⽤了softmax运算,每⼀步的梯度计算都包含词典⼤⼩数⽬的项的累加。对于含⼏⼗万或上百万词的较⼤词典,每次的梯度计算开销可能过⼤。

         为了降低该计算复杂度,介绍两种近似训练⽅法,即负采样(negative sampling)或层序softmax(hierarchical softmax)。由于跳字模型和连续词袋模型类似,这里仅以跳字模型为例介绍这两种⽅法。

    4.1负采样

            负采样修改了原来的⽬标函数。给定中心词w_c的一个背景窗口,我们把背景词w_o出现在该背景窗口看作⼀个事件,并将该事件的概率计算为

                      P(D=1|w_c,w_o)=\sigma (u_o^Tv_c),其中σ是sigmoid激活函数

             我们先考虑最⼤化⽂本序列中所有该事件的联合概率来训练词向量。具体来说,给定⼀个⻓度为T的⽂本序列,设时间步t的词为w^{(t)} 且背景窗⼝⼤⼩为 m,考虑最⼤化联合概率:

                                                       (12)                            

             然而,以上模型中包含的事件仅考虑了正类样本。这导致当所有词向量相等且值为⽆穷⼤时,以上的联合概率才被最⼤化为1。很明显,这样的词向量毫⽆意义。

            负采样通过采样并添加负类样本使目标函数更有意义。设背景词w_o出现在中心词w_c的⼀个背景窗⼝为事件P,我们根据分布P(w) 采样K个未出现在该背景窗⼝中的词,即噪声词。设噪声词w_k(k=1,...,K)不出现在中心词w_c的该背景窗口为事件\mathbf{N_k}            假设同时含有正类样本和负类样本的事件P,N_1,...,N_K相互独立,负采样将仅考虑正类样本的(最大化的)联合概率(12)改写为:

                                                                       (13)

           其中条件概率被近似表示为:

                   P(w^{(t+j)}|w^{(t)})=P(D=1|w^{(t)},w^{(t+j)})\prod_{k=1,w_k\sim P(w)}^KP(D=0|w^{(t)},w_k)       (14)

                    即 给定中心词生成背景词的条件概率表示为,正类事件发生且负类事件不发生的联合概率

           设⽂本序列中时间步t的词w^{(t)}在词典中的索引为i_t,噪声词w_k在词典中的索引为h_k。有关以上条件概率的对数损失为

                             (15)

                  巧妙利用了sigmoid激活函数的性质:σ(-x)=1-σ(x)

         现在,训练中每一步的梯度计算开销不再与词典大小相关,而与K线性相关。当K取较小的常数时,负采样在每一步的梯度计算开销较小。

    4.2 层序hierarchical softmax  

         层序softmax是另⼀种近似训练法。它使⽤了⼆叉树这⼀数据结构, 树的每个叶结点代表词典V中的每个词。

         假设L(w)为从二叉树的根结点到词w的叶结点的路径(包括根结点和叶结点)上的结点数。设n(w,j)为该路径上第j个结点,并设该结点的背景词向量为\mathbf{u}_{n(w,j)}。以图10.3为例,L(w_3)=4 。层序softmax将跳字模型中的条件概率近似表示为

                  

        LeftChild(n)是结点n的左子结点:如果判断x为真,。例如,让我们计算图10.3中给定词 w_c生成词w_3的条件概率:我们需要将w_c的词向量v_c和根结点到w_3路径上的非叶结点向量\mathbf{u}_{n(w,j)}⼀一⼀一求内积.

        由于在二叉树中由根结点到叶结点w_3的路径上需要向左、向右再向左地遍历(图10.3中加粗的路径),我们得到

                  

            由于σ(-x)+σ(x)=1,给定中心词w_c生成词典V中任⼀词的条件概率之和为1这⼀条件也将满足:

                 

         此外,由于{\color{Red} L(w_o)-1}的数量级为{\color{Red} O(log_2 |V|)}, 当词典V很大时,层序softmax在训练中每一步的梯度计算开销相较未使用近似训练时大幅降低。

     

    负采样通过考虑同时含有正类样本和负类样本的相互独⽴事件来构造损失函数。其训练中每⼀步的梯度计算开销与采样的噪声词的个数线性相关。

    层序softmax使用了二叉树,并根据根结点到叶结点的路径来构造损失函数。其训练中每一步的梯度计算开销与词典大小的对数相关。

     

    展开全文
  • 文章目录什么是 Word2vec?Word2vec 的样本是怎么生成的?Word2vec 模型的结构是什么样的?怎样把词向量从 Word2vec 模型中提取出来?Word2vec 对 Embedding 技术的奠基性意义Item2Vec:Word2vec 方法的推广Word2vec...


    提到 Embedding,就一定要深入讲解一下 Word2vec。它不仅让词向量在自然语言处理领域再度流行,更关键的 是,自从 2013 年谷歌提出 Word2vec 以来,Embedding 技术从自然语言处理领域推广到广告、搜索、图像、推 荐等几乎所有深度学习的领域,成了深度学习知识框架中不可或缺的技术点。Word2vec 作为经典的 Embedding 方法,熟悉它对于我们理解之后所有的 Embedding 相关技术和概念都是至关重要的。下面,我就给你详细讲一讲 Word2vec 的原理。

    什么是 Word2vec?

    Word2vec 是“word to vector”的简称,顾名思义,它是一个生成对“词”的向量表达的模型。 想要训练 Word2vec 模型,我们需要准备由一组句子组成的语料库。假设其中一个长度为 T 的句子包含的词有 w1,w2……wt,并且我们假定每个词都跟其相邻词的关系最密切。

    根据模型假设的不同,Word2vec 模型分为两种形式,CBOW 模型(图 3 左)和 Skip-gram 模型(图 3 右)。其 中,CBOW 模型假设句子中每个词的选取都由相邻的词决定,因此我们就看到 CBOW 模型的输入是 wt周边的词, 预测的输出是 wt。Skip-gram 模型则正好相反,它假设句子中的每个词都决定了相邻词的选取,所以你可以看到 Skip-gram 模型的输入是 wt,预测的输出是 wt周边的词。按照一般的经验,Skip-gram 模型的效果会更好一些, 所以我接下来也会以 Skip-gram 作为框架,来给你讲讲 Word2vec 的模型细节

    在这里插入图片描述

    Word2vec 的样本是怎么生成的?

    我们先来看看训练 Word2vec 的样本是怎么生成的。 作为一个自然语言处理的模型,训练 Word2vec 的样本当然 来自于语料库,比如我们想训练一个电商网站中关键词的 Embedding 模型,那么电商网站中所有物品的描述文字 就是很好的语料库。

    我们从语料库中抽取一个句子,选取一个长度为 2c+1(目标词前后各选 c 个词)的滑动窗口,将滑动窗口由左至 右滑动,每移动一次,窗口中的词组就形成了一个训练样本。根据 Skip-gram 模型的理念,中心词决定了它的相邻 词,我们就可以根据这个训练样本定义出 Word2vec 模型的输入和输出,输入是样本的中心词,输出是所有的相邻 词。

    为了方便你理解,我再举一个例子。这里我们选取了“Embedding 技术对深度学习推荐系统的重要性”作为句子样 本。首先,我们对它进行分词、去除停用词的过程,生成词序列,再选取大小为 3 的滑动窗口从头到尾依次滑动生 成训练样本,然后我们把中心词当输入,边缘词做输出,就得到了训练 Word2vec 模型可用的训练样本。

    Word2vec 模型的结构是什么样的?

    有了训练样本之后,我们最关心的当然是 Word2vec 这个模型的结构是什么样的。我相信,通过第 3 节课的学习, 你已经掌握了神经网络的基础知识,那再理解 Word2vec 的结构就容易多了,它的结构本质上就是一个三层的神经 网络(如图 5)。

    在这里插入图片描述
    它的输入层和输出层的维度都是 V,这个 V 其实就是语料库词典的大小。假设语料库一共使用了 10000 个词,那 么 V 就等于 10000。根据图 4 生成的训练样本,这里的输入向量自然就是由输入词转换而来的 One-hot 编码向 量,输出向量则是由多个输出词转换而来的 Multi-hot 编码向量,显然,基于 Skip-gram 框架的 Word2vec 模型解 决的是一个多分类问题。

    隐层的维度是 N,N 的选择就需要一定的调参能力了,我们需要对模型的效果和模型的复杂度进行权衡,来决定最 后 N 的取值,并且最终每个词的 Embedding 向量维度也由 N 来决定。

    最后是激活函数的问题,这里我们需要注意的是,隐层神经元是没有激活函数的,或者说采用了输入即输出的恒等 函数作为激活函数,而输出层神经元采用了 softmax 作为激活函数。

    你可能会问为什么要这样设置 Word2vec 的神经网络,以及我们为什么要这样选择激活函数呢?因为这个神经网络 其实是为了表达从输入向量到输出向量的这样的一个条件概率关系,我们看下面的式子:

    在这里插入图片描述
    这个由输入词 WI 预测输出词 WO 的条件概率,其实就是 Word2vec 神经网络要表达的东西。我们通过极大似然的 方法去最大化这个条件概率,就能够让相似的词的内积距离更接近,这就是我们希望 Word2vec 神经网络学到的。

    当然,如果你对数学和机器学习的底层理论没那么感兴趣的话,也不用太深入了解这个公式的由来,因为现在大多 数深度学习平台都把它们封装好了,你不需要去实现损失函数、梯度下降的细节,你只要大概清楚他们的概念就可 以了

    如果你是一个理论派,其实 Word2vec 还有很多值得挖掘的东西,比如,为了节约训练时间,Word2vec 经常会采 用负采样(Negative Sampling)或者分层 softmax(Hierarchical Softmax)的训练方法。

    怎样把词向量从 Word2vec 模型中提取出来?

    在训练完 Word2vec 的神经网络之后,可能你还会有疑问,我们不是想得到每个词对应的 Embedding 向量嘛,这 个 Embedding 在哪呢?其实,它就藏在输入层到隐层的权重矩阵 WVxN 中。我想看了下面的图你一下就明白了。

    在这里插入图片描述
    你可以看到,输入向量矩阵 WVxN 的每一个行向量对应的就是我们要找的“词向量”。比如我们要找词典里第 i 个词 对应的 Embedding,因为输入向量是采用 One-hot 编码的,所以输入向量的第 i 维就应该是 1,那么输入向量矩 阵 WVxN 中第 i 行的行向量自然就是该词的 Embedding

    细心的你可能也发现了,输出向量矩阵 W′ 也遵循这个道理,确实是这样的,但一般来说,我们还是习惯于使用输 入向量矩阵作为词向量矩阵。

    在实际的使用过程中,我们往往会把输入向量矩阵转换成词向量查找表(Lookup table,如图 7 所示)。例如,输 入向量是 10000 个词组成的 One-hot 向量,隐层维度是 300 维,那么输入层到隐层的权重矩阵为 10000x300 维。在转换为词向量 Lookup table 后,每行的权重即成了对应词的 Embedding 向量。如果我们把这个查找表存 储到线上的数据库中,就可以轻松地在推荐物品的过程中使用 Embedding 去计算相似性等重要的特征了。

    在这里插入图片描述

    Word2vec 对 Embedding 技术的奠基性意义

    Word2vec 是由谷歌于 2013 年正式提出的,其实它并不完全是原创性的,学术界对词向量的研究可以追溯到 2003 年,甚至更早的时期。但正是谷歌对 Word2vec 的成功应用,让词向量的技术得以在业界迅速推广,进而使 Embedding 这一研究话题成为热点。毫不夸张地说,Word2vec 对深度学习时代 Embedding 方向的研究具有奠基 性的意义。

    从另一个角度来看,Word2vec 的研究中提出的模型结构、目标函数、负采样方法、负采样中的目标函数在后续的 研究中被重复使用并被屡次优化。掌握 Word2vec 中的每一个细节成了研究 Embedding 的基础。从这个意义上 讲,熟练掌握本节课的内容是非常重要的。

    Item2Vec:Word2vec 方法的推广

    在 Word2vec 诞生之后,Embedding 的思想迅速从自然语言处理领域扩散到几乎所有机器学习领域,推荐系统也 不例外。既然 Word2vec 可以对词“序列”中的词进行 Embedding,那么对于用户购买“序列”中的一个商品,用户观 看“序列”中的一个电影,也应该存在相应的 Embedding 方法。

    在这里插入图片描述
    于是,微软于 2015 年提出了 Item2Vec 方法,它是对 Word2vec 方法的推广,使 Embedding 方法适用于几乎所 有的序列数据。Item2Vec 模型的技术细节几乎和 Word2vec 完全一致,只要能够用序列数据的形式把我们要表达 的对象表示出来,再把序列数据“喂”给 Word2vec 模型,我们就能够得到任意物品的 Embedding 了。

    Item2vec 的提出对于推荐系统来说当然是至关重要的,因为它使得“万物皆 Embedding”成为了可能。对于推荐系 统来说,Item2vec 可以利用物品的 Embedding 直接求得它们的相似性,或者作为重要的特征输入推荐模型进行 训练,这些都有助于提升推荐系统的效果

    Embedding 就是用一个数值向 量“表示”一个对象的方法。通过 Embedding,我们又引出了 Word2vec,Word2vec 是生成对“词”的向量表达的模 型。其中,Word2vec 的训练样本是通过滑动窗口一一截取词组生成的。在训练完成后,模型输入向量矩阵的行向 量,就是我们要提取的词向量。最后,我们还学习了 Item2vec,它是 Word2vec 在任意序列数据上的推广

    在这里插入图片描述

    Word2vec代码实现

    import itertools
    
    import joblib
    import numpy as np
    
    from word2vec.utils import distance, unitvec
    
    
    class WordVectors(object):
        def __init__(self, vocab, vectors, clusters=None):
            """
            Initialize a WordVectors class based on vocabulary and vectors
    
            This initializer precomputes the vectors of the vectors
    
            Parameters
            ----------
            vocab : np.array
                1d array with the vocabulary
            vectors : np.array
                2d array with the vectors calculated by word2vec
            clusters : word2vec.WordClusters (optional)
                1d array with the clusters calculated by word2vec
            """
            self.vocab = vocab
            self.vectors = vectors
            self.clusters = clusters
    
            # Used to make indexing faster
            self.vocab_hash = {}
            for i, word in enumerate(vocab):
                self.vocab_hash[word] = i
    
        def ix(self, word):
            """
            Returns the index on `self.vocab` and `self.vectors` for `word`
            """
            return self.vocab_hash[word]
    
        def word(self, ix):
            """Returns the word that corresponds to the index.
    
            Parameters
            -------
            ix : int
                The index of the word
    
            Returns
            -------
            str
                The word that corresponds to the index
            """
            return self.vocab[ix]
    
        def __getitem__(self, word):
            return self.get_vector(word)
    
        def __contains__(self, word):
            return word in self.vocab_hash
    
        def get_vector(self, word):
            """
            Returns the vector for a `word` in the vocabulary
            """
            return self.vectors[self.ix(word)]
    
        def distance(self, *args, **kwargs):
            """
            Compute the distance distance between two vectors or more (all combinations) of words
    
            Parameters
            ----------
            words : one or more words
            n : int (default 10)
                number of neighbors to return
            metric : string (default "cosine")
                What metric to use
            """
            metric = kwargs.get("metric", "cosine")  # Default is cosine
    
            combinations = list(itertools.combinations(args, r=2))
    
            ret = []
            for word1, word2 in combinations:
                dist = distance(self[word1], self[word2], metric=metric)
                ret.append((word1, word2, dist))
            return ret
    
        def closest(self, vector, n=10, metric="cosine"):
            """Returns the closest n words to a vector
    
            Parameters
            -------
            vector : numpy.array
            n : int (default 10)
    
            Returns
            -------
            Tuple of 2 numpy.array:
                1. position in self.vocab
                2. cosine similarity
            """
            distances = distance(self.vectors, vector, metric=metric)
            best = np.argsort(distances)[::-1][1 : n + 1]
            best_metrics = distances[best]
            return best, best_metrics
    
        def similar(self, word, n=10, metric="cosine"):
            """
            Return similar words based on a metric
    
            Parameters
            ----------
            word : string
            n : int (default 10)
    
            Returns
            -------
            Tuple of 2 numpy.array:
                1. position in self.vocab
                2. cosine similarity
            """
            return self.closest(self[word], n=n, metric=metric)
    
        def analogy(self, pos, neg, n=10, metric="cosine"):
            """
            Analogy similarity.
    
            Parameters
            ----------
            pos : list
            neg : list
    
            Returns
            -------
            Tuple of 2 numpy.array:
                1. position in self.vocab
                2. cosine similarity
    
            Example
            -------
                `king - man + woman = queen` will be: `pos=['king', 'woman'], neg=['man']`
            """
            exclude = pos + neg
            pos = [(word, 1.0) for word in pos]
            neg = [(word, -1.0) for word in neg]
    
            mean = []
            for word, direction in pos + neg:
                mean.append(direction * self[word])
            mean = np.array(mean).mean(axis=0)
    
            metrics = distance(self.vectors, mean, metric=metric)
            best = metrics.argsort()[::-1][: n + len(exclude)]
    
            exclude_idx = [
                np.where(best == self.ix(word)) for word in exclude if self.ix(word) in best
            ]
            new_best = np.delete(best, exclude_idx)
            best_metrics = metrics[new_best]
            return new_best[:n], best_metrics[:n]
    
        def generate_response(self, indexes, metrics, clusters=True):
            """
            Generates a pure python (no numpy) response based on numpy arrays
            returned by `self.cosine` and `self.analogy`
            """
            if self.clusters and clusters:
                return np.rec.fromarrays(
                    (self.vocab[indexes], metrics, self.clusters.clusters[indexes]),
                    names=("word", "metric", "cluster"),
                )
            else:
                return np.rec.fromarrays(
                    (self.vocab[indexes], metrics), names=("word", "metric")
                )
    
        def to_mmap(self, fname):
            joblib.dump(self, fname)
    
        @classmethod
        def from_binary(
            cls,
            fname,
            vocab_unicode_size=78,
            desired_vocab=None,
            encoding="utf-8",
            new_lines=True,
        ):
            """
            Create a WordVectors class based on a word2vec binary file
    
            Parameters
            ----------
            fname : path to file
            vocabUnicodeSize: the maximum string length (78, by default)
            desired_vocab: if set any words that don't fall into this vocab will be droped
    
            Returns
            -------
            WordVectors instance
            """
            with open(fname, "rb") as fin:
                # The first line has the vocab_size and the vector_size as text
                header = fin.readline()
                vocab_size, vector_size = list(map(int, header.split()))
    
                vocab = np.empty(vocab_size, dtype="<U%s" % vocab_unicode_size)
                vectors = np.empty((vocab_size, vector_size), dtype=np.float)
                binary_len = np.dtype(np.float32).itemsize * vector_size
                for i in range(vocab_size):
                    # read word
                    word = b""
                    while True:
                        ch = fin.read(1)
                        if ch == b" ":
                            break
                        word += ch
                    include = desired_vocab is None or word in desired_vocab
                    if include:
                        vocab[i] = word.decode(encoding)
    
                    # read vector
                    vector = np.fromstring(fin.read(binary_len), dtype=np.float32)
                    if include:
                        vectors[i] = unitvec(vector)
                    if new_lines:
                        fin.read(1)  # newline char
    
                if desired_vocab is not None:
                    vectors = vectors[vocab != "", :]
                    vocab = vocab[vocab != ""]
            return cls(vocab=vocab, vectors=vectors)
    
        @classmethod
        def from_text(
            cls, fname, vocabUnicodeSize=78, desired_vocab=None, encoding="utf-8"
        ):
            """
            Create a WordVectors class based on a word2vec text file
    
            Parameters
            ----------
            fname : path to file
            vocabUnicodeSize: the maximum string length (78, by default)
            desired_vocab: if set, this will ignore any word and vector that
                           doesn't fall inside desired_vocab.
    
            Returns
            -------
            WordVectors instance
            """
            with open(fname, "rb") as fin:
                header = fin.readline()
                vocab_size, vector_size = list(map(int, header.split()))
    
                vocab = np.empty(vocab_size, dtype="<U%s" % vocabUnicodeSize)
                vectors = np.empty((vocab_size, vector_size), dtype=np.float)
                for i, line in enumerate(fin):
                    line = line.decode(encoding).rstrip()
                    parts = line.split(" ")
                    word = parts[0]
                    include = desired_vocab is None or word in desired_vocab
                    if include:
                        vector = np.array(parts[1:], dtype=np.float)
                        vocab[i] = word
                        vectors[i] = unitvec(vector)
    
                if desired_vocab is not None:
                    vectors = vectors[vocab != "", :]
                    vocab = vocab[vocab != ""]
            return cls(vocab=vocab, vectors=vectors)
    
        @classmethod
        def from_mmap(cls, fname):
            """
            Create a WordVectors class from a memory map
    
            Parameters
            ----------
            fname : path to file
    
            Returns
            -------
            WordVectors instance
            """
            memmaped = joblib.load(fname, mmap_mode="r+")
            return cls(vocab=memmaped.vocab, vectors=memmaped.vectors)
    
    
    展开全文
  • word2vec原理(四):word2vec训练流程

    千次阅读 2019-05-15 14:57:06
    目录 1. 基于负例采样的Skipgram:训练过程 2. 窗口大小和负样本数量 2.1 窗口大小 2.2 负样本数量 1. 基于负例采样的Skipgram:训练过程 在训练过程开始之前,我们预先处理我们正在训练模型的文本。在这...

    目录

    1. 基于负例采样的Skipgram:训练过程

    2. 窗口大小和负样本数量

    2.1 窗口大小

    2.2 负样本数量


    1. 基于负例采样的Skipgram:训练过程

                             

            在训练过程开始之前,我们预先处理我们正在训练模型的文本。在这一步中,我们确定一下词典的大小(我们称之为vocab_size,比如说10,000)以及哪些词被它包含在内。

            在训练阶段的开始,我们创建两个矩阵——Embedding矩阵Context矩阵。这两个矩阵在我们的词汇表中嵌入了每个单词(所以vocab_size是他们的维度之一)。第二个维度是我们希望每次嵌入的长度(embedding_size——300是一个常见值,但我们在前文也看过50的例子):行数=词汇表的大小,列数=词向量的维度

                                
            在训练过程开始时,我们用随机值初始化这些矩阵。然后我们开始训练过程。在每个训练步骤中,我们采取一个相邻的例子及其相关的非相邻例子。我们来看看我们的第一组:

                         
           现在我们有四个单词:输入单词not输出/上下文单词: thou(实际邻居词),aaron和taco(负面例子)。我们继续查找它们的嵌入将单词转换为向量表示形式

           对于输入词,我们查看Embedding矩阵;

           对于上下文单词,我们查看Context矩阵。(即使两个矩阵都在我们的词汇表中嵌入了每个单词)

                                            Embedding矩阵Context矩阵:将单词转换为向量表示形式

                         

            然后,我们计算输入嵌入与每个上下文嵌入的点积(向量之间的点积)。在每种情况下,结果都将是表示输入和上下文嵌入的相似性的数字。

                                          
            现在我们需要一种方法将这些分数转化为看起来像概率的东西——我们需要它们都是正值,并且 处于0到1之间。sigmoid这一逻辑函数转换正适合用来做这样的事情啦。

                                
            现在我们可以将sigmoid操作的输出视为这些示例的模型输出。您可以看到taco得分最高,aaron最低,无论是sigmoid操作之前还是之后。

            既然未经训练的模型已做出预测,而且我们确实拥有真实目标标签来作对比,那么让我们计算模型预测中的误差吧。为此我们只需从目标标签中减去sigmoid分数。

                            
            error = target - sigmoid_scores  (标签值 - 模型预测值)

           这是“机器学习”的“学习”部分。现在,我们可以利用这个错误分数来调整not、thou、aaron和taco的嵌入,使我们下一次做出这一计算时,结果会更接近目标分数。

                             
            第一组的训练步骤到此结束。我们从中得到了这一步所使用词语更好一些的嵌入(not,thou,aaron和taco)。我们现在进行下一步(下一组相邻样本及其相关的非相邻样本),并再次执行相同的过程。

                                     
            训练结果:当我们循环遍历整个数据集多次时,嵌入会继续得到改进。然后我们就可以停止训练过程,丢弃Context矩阵,并使用Embeddings矩阵作为下一项任务的已被训练好的嵌入

    2. 窗口大小和负样本数量

    word2vec训练过程中的两个关键超参数是窗口大小和负样本的数量。

    2.1 窗口大小

     

                        
           不同的任务适合不同的窗口大小。一种启发式方法是:

         (1)使用较小的窗口大小(2-15)会得到这样的嵌入:两个嵌入之间的高相似性得分表明这些单词是可互换的(注意,如果我们只查看附近距离很近的单词,反义词通常可以互换——例如,好的和坏的经常出现在类似的语境中)。

         (2)使用较大的窗口大小(15-50,甚至更多)会得到相似性更能指示单词相关性的嵌入。

           在实际操作中,你通常需要对嵌入过程提供指导以帮助读者得到相似的”语感“。Gensim默认窗口大小为5(除了输入字本身以外还包括输入字之前与之后的两个字)。

    2.2 负样本数量

                              
            负样本的数量是训练训练过程的另一个因素。原始论文认为5-20个负样本是比较理想的数量。它还指出,当你拥有足够大的数据集时,2-5个似乎就已经足够了。Gensim默认为5个负样本。

    参考:

    https://blog.csdn.net/han_xiaoyang/article/details/89082129

    展开全文
  • 理解word2vec

    2019-08-31 19:47:01
    文章目录独热编码word2vecCBOWSkip-Gram 独热编码 我们的feature_1有两种可能的取值,比如是男/女,这里男用1表示,女用2表示。feature_2 和feature_3各有4种取值(状态)。one-hot编码就是保证每个样本中的单个...

    独热编码

    在这里插入图片描述
    我们的feature_1有两种可能的取值,比如是男/女,这里男用1表示,女用2表示。feature_2 和feature_3各有4种取值(状态)。one-hot编码就是保证每个样本中的单个特征只有1位处于状态1,其他的都是0。上述状态用one-hot编码如下图所示
    在这里插入图片描述
    优点:一是解决了分类器不好处理离散数据的问题,二是在一定程度上也起到了扩充特征的作用。

    缺点:在文本特征表示上有些缺点就非常突出了。首先,它是一个词袋模型,不考虑词与词之间的顺序(文本中词的顺序信息也是很重要的);其次,它假设词与词相互独立(在大多数情况下,词与词是相互影响的);最后,它得到的特征是离散稀疏的

    如何解决离散稀疏的缺点?
    Dristributed representation可以解决One hot representation的问题,它的思路是通过训练,将每个词都映射到一个较短的词向量上来。所有的这些词向量就构成了向量空间,进而可以用普通的统计学的方法来研究词与词之间的关系。这个较短的词向量维度是多大呢?这个一般需要我们在训练时自己来指定。
    在这里插入图片描述
    在这里插入图片描述
    过程称为词嵌入

    word2vec

    简单化的神经网络
    在这里插入图片描述
    输入是One-Hot Vector,Hidden Layer没有激活函数,也就是线性的单元。Output Layer维度跟Input Layer的维度一样,用的是Softmax回归。
    当这个模型训练好以后,我们并不会用这个训练好的模型处理新的任务,我们真正需要的是这个模型通过训练数据所学得的参数,例如隐层的权重矩阵

    两种模型

    CBOW

    CBOW模型的训练输入是某一个特征词的上下文相关的词对应的词向量,而输出就是这特定的一个词的词向量
    在这里插入图片描述

    Skip-Gram

    Skip-Gram模型和CBOW的思路是反着来的,即输入是特定的一个词的词向量,而输出是特定词对应的上下文词向量。
    在这里插入图片描述
    CBOW对小型数据库比较合适,而Skip-Gram在大型语料中表现更好

    窗口为2:
    在这里插入图片描述

    import tensorflow as tf
    
    # 假设vocab_size = 1000
    VOCAB_SIZE = 1000
    # 假设embedding_size = 300
    EMBEDDINGS_SIZE = 300
    
    # 输入单词x是一个[1,vocab_size]大小的矩阵。当然实际上我们一般会用一批单词作为输入,那么就是[N, vocab_size]的矩阵了
    x = tf.placeholder(tf.float32, shape=(1,VOCAB_SIZE))
    # W1是一个[vocab_size, embedding_size]大小的矩阵
    W1 = tf.Variable(tf.random_normal([VOCAB_SIZE, EMBEDDING_SIZE]))
    # b1是一个[1,embedding_size]大小的矩阵
    b1 = tf.Variable(tf.random_normal([EMBEDDING_SIZE]))
    # 简单的矩阵乘法和加法
    hidden = tf.add(tf.mutmul(x,W1),b1)
    
    W2 = tf.Variable(tf.random_normal([EMBEDDING_SIZE,VOCAB_SIZE]))
    b2 = tf.Variable(tf.random_normal([VOCAB_SIZE]))
    # 输出是一个vocab_size大小的矩阵,每个值都是一个词的概率值
    prediction = tf.nn.softmax(tf.add(tf.mutmul(hidden,w2),b2))
    # 损失函数 
    cross_entropy_loss = tf.reduce_mean(-tf.reduce_sum(y_label * tf.log(prediction), reduction_indices=[1]))
    # 训练操作
    train_op = tf.train.GradientDescentOptimizer(0.1).minimize(cross_entropy_loss)
    

    为啥输入使用one-hot编码?

    我们知道word2vec训练后会得到一个权值矩阵W1(暂时忽略b1),这个矩阵就是我们的所有词的向量表示啦!这个矩阵的每一行,就是一个词的矢量表示。如果两个矩阵相乘
    在这里插入图片描述
    所谓的word2vec,实际上就是一个查找表,是一个二维的浮点数矩阵

    展开全文
  • 内容目录写在前面的话1. 什么是 Word2vec?2.Skip-gram 和 CBOW 模型2.1Skip-gram 和 CBOW 的简单情形2.2Skip-gram 更一般的情形2.3 CBOW 更一般的情形3.Word2vec 的训练trick4.扩展5.你问我答6.什么是embedding?...
  • 【分享】导出到WORD

    2010-12-28 09:51:40
    SBO系统允许将系统中的凭证以及报表以Word形式导出。在SBO客户端的安装目录中,有个名字为”WordDocs”的文件夹...文件夹中存放着导出Word功能的样本文件。这些模板文件可以适用于系统支持的所有语言。 初始定义 ...
  • Word2Vec学习笔记(一)

    2016-06-12 11:39:57
    目录 Word2Vec基本数学内容 语言模型 Hierarchical Softmax 模型 Negative Sampling 模型 一、Word2Vec基本数学内容1. Sigmod 函数&absp;&absp;&absp;&absp;Sigmod函数通常在二分类中应用。它将样本映射后投影在[0, ...
  • text_classify 以复旦中文文本分类语料库为样本,用python实现的文本分类算法 ...step2: corpus2Bunch.py (需要提前创建目录train_word_bag和test_word_bag) step3: TFIDF_space.py step4:NBayes_Predict.py
  • 文章目录负采样算法CBOW模型Skip-gram模型 在讲基于Negative Sampling的word2vec模型前,我们先看看Hierarchical Softmax的的缺点。的确,使用霍夫曼树来代替传统的神经网络,可以提高模型训练的效率。但是如果我们...
  • 4-1 C&W Word2Vec

    2021-04-09 20:32:04
    文章目录C&W Loss FunctionC&W 模型结构Word2Vec - CBOW C&W Loss Function ∑(w,c)∈D∑w′∈Vmax(0,1−score(w,c)+score(w′,c)\sum_{(w,c)\in D}\sum_{w'\in V}max(0, 1-score(w,c)+score(w',c)∑(w,...
  • 非包容性单词过滤器 :magnifying_glass_tilted...样本CSV输出 根目录 文件路径 电话号码 片段 优先 Searched_Word 文件扩展名 程式库 〜/ codebase / components / foo.js 3 myString =“我买了一个苹果” 1个 苹果
  • NLP算法(一)- Word2Vec

    2020-12-22 23:37:14
    文章目录1 背景1.1 算法提出1.2 数学基础2 模型2.1 CBOW模型2.1 SkipGram模型2.3 算法优化3 Hierachical霍夫曼编码3.1.1 CBOW3.2 SkipGram4 负采样4.1 负样本4.2 CBOW4.3 SkipGram 1 背景 1.1 算法提出 词向量的概念...
  • 目录 分类的背景 分类问题中更新词向量 Window classification 神经网络 分类的背景 关于分类 给定训练集: 其中是一个d维向量,是一个c维one-hot向量,N是训练集样本数。在传统的机器学习方法中,往往...
  • 文章目录1.样本信息2.宏代码分析3.user.dat文件分析 1.样本信息 样本SHA1: f293a2bfb728060c54efeeb03c5323893b5c80df word内容: 2.宏代码分析 宏代码本身是加密码的,这里就使用VBA Password Bypasser进行绕过,...
  • Pytorch实现Skip-Gram模型

    2020-12-13 17:19:20
    文章目录词向量Word2Vec: Skip-Gram模型 词向量 Word2Vec: Skip-Gram模型 由于样本数据太多,所以我们采取负例采样。我们选取一个正例样本,然后选取若干个负例样本。也就是给我一个中心词的正确的周围词...
  • 主题模型---实践

    2020-05-07 11:52:38
    文章目录理论LDA开源库介绍以文本分类为例Gensim安装word2vec实践 理论 LDA开源库介绍 以文本分类为例 保证所有样本的特征映射成的维度都是一样的。即由0-1组成的V维度向量。 Gensim安装 ...
  • Rasa中文聊天机器人开发指南(2):NLU篇

    万次阅读 多人点赞 2020-02-27 10:28:46
    文章目录1. 什么是NLU2. NLU训练数据2.1 NLU样本格式2.2 验证数据有效性2.2.1 使用命令2.2.2 使用代码2. Rasa NLU Components2.1 词向量资源(Word Vector Sources)2.1.1 MitieNLP2.1.2 SpacyNLP2.2 分词...
  • 准备NLP面试问题

    2020-09-05 09:54:34
    文章目录word2vecCGANPCA降维协同过滤VGG16LSTM RNN处理文本分类中样本不均衡的问题 emmm不知道会问啥 把简历里有的 没的都准备一遍吧呜呜呜…我是答案的搬运工. word2vec 模型结构描述:三层结构,输入层,投射层...
  • 文章大纲章节目录参考文档 章节目录 《自然语言处理实战入门》 文本检索----...适合word2vec模型向量化的数据。 (2)Jaccard(杰卡德)相似性系数,主要用于计算符号度量或布尔值度量的样本间的相似度。若样本间的特
  • @本文来源于公众号:csdn2299,喜欢可以关注公众号 程序员学府 今天小编就为大家分享一篇使用PyTorch实现MNIST手写体识别代码,...MNIST 包括6万张28×28的训练样本,1万张测试样本,可以说是CV里的“Hello Word”。本
  • 1_VBA_POWERSHELL病毒分析

    2020-03-17 18:22:44
    文章目录分析VBA_PS脚本: 样本信息: MD5 0bf87fd5ff555a5f0fc94b5e36f0d4ff 文件名称 0bf87fd5ff555a5f0fc94b5e36f0d4ff.doc 文件类型 Word文档 分析VBA_PS脚本: 原混淆代码: Private Declare Sub Sleep Lib ...
  • 目录 特征 支持 PDF、MS word 和文本文件。 提取重要信息,如技能、教育、经验、电子邮件、电话号码等。 同时处理多个文件。 将提取的数据保存在 JSON 文件中。 样本: 。 将提取的日期保存在 CSV 文件中。 样本: ...
  • 目录 产品特点 支持PDF,MS word和文本文件。 提取重要信息,例如技能,教育程度,经验,电子邮件,电话号码等。 同时处理多个文件。 将提取的数据保存在JSON文件中。 样本:。 将提取的日期保存在CSV文件中。 ...
  • 目录 1. 基本信息的描述统计——频率分析 1.1 统计结果 1.2 操作步骤——方法1 1.3 分析步骤——方法2(推荐使用) 1.4 三线表插入到word中 2. 基本信息的描述统计——统计描述(平均值、标准差、方差等) ...
  • 文章目录1.业务背景1.基于click session的房源embedding(短期兴趣)1.1 如何确定click session?1.2 房源embedding方法1.2.1 业务思考:原始的word2vec是非监督的,怎样融入提升“预订率”这一业务目标?1.2.2 业务...
  • ##项目结构模型:英语解析器和中文解析器的训练模型data :样本依赖项数据和经过训练的单词嵌入(通过word2vec) src :我们三个模型的代码 ##培训和测试要编译培训代码,请转到src目录并运行: 制作dep_parser_...
  • 目录 大纲 第二课 总结 图表示由来 负采样由来 Word2Vec DeepWalk(随机游走DFS) node2vec(有偏游走DFS+BFS+考虑边权值) metapath2vec 异构图由来 异构图定义 基于远路径游走 元路径 游走 meta...
  • 文章目录方案说明信息方案1. 合并重复id的标签,直接多标签分类,也方便交叉验证2. 分词:word level + char level3. 数据增强4. 双向RNN(GRU/LSTM)编码+注意力/胶囊5. 输出6. 训练指标F1,总出现NaN, 花费了很多...
  • 基于内容的Embedding方法(如word2vec、BERT等)都是针对“序列”样本(如句子、用户行为序列)设计的,但在互联网场景下,数据对象之间更多呈现出图结构,如下图所示 (1) 有用户行为数据生成的物品关系图;...

空空如也

空空如也

1 2 3
收藏数 57
精华内容 22
关键字:

word目录样本