Deep Learning-word2vec

Posted by maple Blog on October 23, 2016

词向量

在自然语言处理中,需要将具体的文字数字化,那么就可以当做常规的机器学习问题。

比如短文本分类,首先是一个句子的形式,需要转化为单个词语。然后还需要转化为具体数字,用来描述、分析词之间的关系等等。

One-hot Representation

比如

苹果 [0 0 0 1 0 0 0 0 ...]
香蕉 [0 0 0 0 0 0 1 0 ...]

那么每个词就是一堆0的中的1. 这种称为 One-hot Representation,一种编码方式。那么数字化之后,就可以作计算。

不过这种表示方式,词表的矩阵是个稀疏矩阵,如果词汇量很大,那么会是一个很大的维度,作存储和计算都不是很理想;而且对于词之间的关系也无法体现。那么存在另一种方式

Distributed Representation

与One-hot Representation想法类似,不过更为精简,人们希望可以这样:

[0.302 0.123 0.690 ...] 

一般只有50,100维度。就足以表达成千上万词汇。并且还能计算词之间的关系。比如 苹果,香蕉。应该很接近才是,因为都是水果。word2vec就可以训练这样的词向量。

word2vec

word2vec是Google开源的一个高效计算词向量的工具。计算得到的词向量可应用于各种NLP任务。其高效在于使用了2种模式cbow和skip-gram.

NNLM

word2vec作为一种简化的神经网络模型。在了解内部原理之前,我们需要知道下 NNLM网络结构。

NNLM 即 Neural Network Language Model,由Bengio提出《A Neural Probabilistic Language Model》

图中,该网络分2层,从低往上,输入层,隐藏层,输出层。

表示前面n-1个词,来预测下一个词.

图中有个 C,其实就是词汇表,存放着相应的词向量。就是对应的词向量。这里输入的词向量其实是个index。

第一层,n-1个词,首尾相连,形成(n-1)m维的向量。m为单个词向量维度,比如100。

第二层,也就是隐藏层,计算得到。d是偏置项,H是隐藏层参数().x就是第一层的输入。

第三层,有个节点,也就是词汇表的大小,每个节点的输出表示下一个词是i的概率,也就是总共有V个概率,取最大的概率咯。这里的y是未归一化的log概率.

也就是上图中左边的虚线,输入层到输出层的直连。如果去掉直连,那么W参数就为0了。

就是隐藏层到输出层的参数

bias项

那么这里所有的参数

分析完成,那么接下来就是一个求解神经网络的问题,论文中用的是随机梯度下降法优化出来。这里有点特别的是,输入层参数C,也就是词向量,也是参数,也要求解的,与一般的神经网络不同的地方。 解出来,我们会得到2样东西,一个C,也就是词向量,还有一个是语言模型。本文我们只谈词向量。

word2vec

在NNLM中计算的开销主要在于隐藏层,以及因此层到输出层的参数计算。 在word2vec所以干脆去掉了隐层。大大提高了计算效率,并提出了2种模型CBOW和skip-gram

CBOW

CBOW是Continuous Bag-of-Words Model。与NNLM模型类似,不过去掉了隐藏层。

由图可以看出来,这里的输入是直接求和到隐藏层。要求的是

与NNLM不同的地方

  • 在NNLM中是词向量首尾相连变成很长的一串,这里是直接求和/求平均

  • 这里的求t,用了t前后的词向量,而前面是前n-1个词。似乎看起来这样更合理,因为考虑了将来的词。

  • CBOW去掉了隐藏层复杂的计算。

inut到project层,来看下源代码,我加了注释。

	  //随机选择窗口大小
     b = next_random % window;
     if (cbow) {  //train the cbow architecture
      // in -> hidden
      cw = 0;
      for (a = b; a < window * 2 + 1 - b; a++) if (a != window) {
        //以 sentence_position 为中心 前后各 window - b 个词
        c = sentence_position - window + a;
        if (c < 0) continue;
        if (c >= sentence_length) continue;
        last_word = sen[c];
        if (last_word == -1) continue;
        //窗口内词向量相加
        for (c = 0; c < layer1_size; c++) neu1[c] += syn0[c + last_word * layer1_size];
        cw++;
      }
	  if (cw) {
        //相加的词向量取平均
        for (c = 0; c < layer1_size; c++) neu1[c] /= cw;

那么接下来就是project层到输出层的计算。这里又有2种方式, Hierarchical SoftmaxNEGATIVE SAMPLING

Hierarchical Softmax

关于这个思想的提出,我们想下之前的NNLM中的输出有V个节点,对于每个节点都要计算其是不是的概率值,那么计算量还是比较大的。

如果换个思路,我们先把词语分个类,做个编码。比如,苹果。先判断是不是水果,再判断是不是苹果。论文中的方法,是先对所有词作Huffman编码。那么高频词的编码就很短。所有的词都是Huffman树的一个节点。

假如=苹果。其编码是1010.那么$L(w)=5$,算上root根节点。表示该词所在节点到root根节点的距离是4。表示root通往w的第j个节点,=root,

输出:

这里的

表示的一个子节点,感觉这是很显然的事,又多这么一个概念。

[x]表示x=true 则为1,否则为-1。

表示Huffman树的inner(内部)节点也就是非叶子节点;

表示Huffman树的叶子节点,也就是一个个词。

那么 具体如何求解,我们看下代码

		//Hierarchical Softmax 也就是根据初始化的 vocab 词汇表的huffman编码来计算输出f值,
        if (hs) for (d = 0; d < vocab[word].codelen; d++) {
          f = 0;
          l2 = vocab[word].point[d] * layer1_size;
          // Propagate hidden -> output
          for (c = 0; c < layer1_size; c++) f += neu1[c] * syn1[c + l2];
          if (f <= -MAX_EXP) continue;
          else if (f >= MAX_EXP) continue;
          //f值转化到0.01~1 之间 查表expTable得到,expTable的默认大小为EXP_TABLE_SIZE=1000
          else f = expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))];
          // 'g' is the gradient multiplied by the learning rate
          // 1 - vocab[word].code[d] 表示word的第d位huffman编码 0或者1 用来表示目标值,减去输出f 计算g
          g = (1 - vocab[word].code[d] - f) * alpha;
          // Propagate errors output -> hidden
          //g * syn1[c + l2] 梯度部分,误差回传 隐层。在后面 neu1e会继续回传到输入层,用来优化syn0
          for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1[c + l2];
          // Learn weights hidden -> output
          for (c = 0; c < layer1_size; c++) syn1[c + l2] += g * neu1[c];

这里的syn1其实就是上面提到的Huffman的inner(内部)节点。

梯度

1 - vocab[word].code[d] 表示word的第d位huffman编码 0或者1,比如苹果的第0位是1.

NEGATIVE SAMPLING

再说一下另一种方式,NEGATIVE SAMPLING。主要的思想是,随机生成一些负样本,如果命中 word 则 label=1 不更新误差;否则更新误差 更新网络参数

代码:

		//负采样 (默认采用这种方式)
        //随机选择 negative 个词,如果命中 word 则 不更新误差;否则更新误差 更新网络参数
        // NEGATIVE SAMPLING
        if (negative > 0) for (d = 0; d < negative + 1; d++) {
          if (d == 0) {
            target = word;
            label = 1;
          } else {
            next_random = next_random * (unsigned long long)25214903917 + 11;
            target = table[(next_random >> 16) % table_size];
            if (target == 0) target = next_random % (vocab_size - 1) + 1;
            if (target == word) continue;
            label = 0;
          }
          l2 = target * layer1_size;
          f = 0;
          for (c = 0; c < layer1_size; c++) f += neu1[c] * syn1neg[c + l2];
          if (f > MAX_EXP) g = (label - 1) * alpha;
          else if (f < -MAX_EXP) g = (label - 0) * alpha;
          //查表
          else g = (label - expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))]) * alpha;
          for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1neg[c + l2];
          for (c = 0; c < layer1_size; c++) syn1neg[c + l2] += g * neu1[c];

与前面的差别在于

用label代替 1 - vocab[word].code[d].而这个label是随机生成的,当然是考虑了词频的随机抽样。

Skip-gram

Skip-gram的模型图与cbow正好反一下。

由当前词去推周围词的概率。

见代码注释。

} else {  //train skip-gram
      for (a = b; a < window * 2 + 1 - b; a++) if (a != window) {
        c = sentence_position - window + a;
        if (c < 0) continue;
        if (c >= sentence_length) continue;
        last_word = sen[c];
        if (last_word == -1) continue;
        l1 = last_word * layer1_size;
        for (c = 0; c < layer1_size; c++) neu1e[c] = 0;
        // HIERARCHICAL SOFTMAX
        if (hs) for (d = 0; d < vocab[word].codelen; d++) {
          f = 0;
          l2 = vocab[word].point[d] * layer1_size;
          // Propagate hidden -> output
          // skip-gram与cbow之间的差别
          // 这里的f 是直接输入 syn0 与输出syn1相乘
          // 而cbow中 是输入的向量相加取平均后再作计算
          // skip-gram的理念在于 用当前输入的词 word[t] 去推 上下文 word[t-2] word[t-1] word[t+1] word[t+2]的概率.
          // 具体的计算目标就是优化输出syn1对应的上下文词向量
          for (c = 0; c < layer1_size; c++) f += syn0[c + l1] * syn1[c + l2];
          if (f <= -MAX_EXP) continue;
          else if (f >= MAX_EXP) continue;
          else f = expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))];
          // 'g' is the gradient multiplied by the learning rate
          g = (1 - vocab[word].code[d] - f) * alpha;
          // Propagate errors output -> hidden
          for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1[c + l2];
          // Learn weights hidden -> output
          for (c = 0; c < layer1_size; c++) syn1[c + l2] += g * syn0[c + l1];
        }

PS

短短700行的代码,做完了所有的事情。虽然代码风格很豪放,一堆abc变量名:P

不过编译运行还是很方便的,无任何依赖了,甚至连随机数生成都自己写。。。

这里再推荐几篇文章 @licstar的《Deep Learning in NLP (一)词向量和语言模型》,关于词向量的前世今生讲的很详细;

还有网易的Deep Learning实战之word2vec有代码讲解,还有word2vec相关人物的八卦😄~

完整注释代码word2vec.c

参考

1.word2vec

2.A Neural Probabilistic Language Model

3.Distributed Representations of Words and Phrasesand their Compositionality

4.Efficient Estimation of Word Representations in Vector Space

5.Deep Learning in NLP (一)词向量和语言模型

6.Deep Learning实战之word2vec