A Neural Probabilistic Language Model 论文阅读及实战

技术交流QQ群:1027579432，欢迎你的加入！

1.词向量介绍

• 在NLP任务中，第一步首先将自然语言转化成数学符号表示。一般常用的词汇表示方法:one-hot表示，这种方法是将每个单词表示为一个很长的向量，这个向量的长度是词汇表的大小，其中绝大数元素是0，只有一个元素是1，如“男人”表示为:[0 0 0 1 0 0 0 0 0 0...]，“男孩”表示为:[0 1 0 0 0 0 0 0 0 0...]。one-hot方法采用稀疏的方式进行单词的表示，非常的简洁。即为每个单词分配一个数字ID号，数字ID号对应于每个单词在词汇表中的索引。比如“国王”这个词语在词汇表中的索引是3，“男孩”这个词语在词汇表中的索引是1。
• one-hot编码单词存在的问题：每个one-hot向量之间是相互正交的，任意两个单词之间是相互独立的，仅从one-hot表示出的词向量中无法看出两个单词之间是否有关系，即使是同义词也是相互独立。
• 大多数NLP任务中，一般用到的词向量并不是one-hot表示出来的维数很长的词向量，而是采用一种"Distributed Representation"的表示方法来表示一种低维实数向量。这个词向量的表示一般是这样的:[0.792,-0.177,-0.107,0.109,-0.542,...]，维度以5o和100维比较常见，这种向量的表示也不唯一。
• Distributed Representation最大的贡献是让相关或相似的词，在距离上更接近。向量的距离可以是传统的欧式距离衡量，也可以使用余弦相似度cosine来衡量。

2.词向量的来历

• Distributed representation 最早是 Hinton 在 1986 年的论文《Learning distributed representations of concepts》中提出的。Distributed representation 用来表示词，通常被称为“Word Representation”或“Word Embedding”，中文俗称“词向量”或“词嵌入”。
• 如果用传统的稀疏表示法表示单词，在解决某些任务的时候（比如构建语言模型）会造成维数灾难[Bengio 2003]。使用低维的词向量就没这样的问题。同时从实践上看，高维的特征如果要套用 Deep Learning，其复杂度几乎是难以接受的，因此低维的词向量在这里也备受追捧。

3.词向量的训练

• 在介绍如何训练词向量之前，必须先介绍语言模型。因为对于大多数的训练方法，都是在训练语言模型的同时，顺便得到词向量的，词向量只是训练语言模型过程中的“意外之物”。从大量未标注的普通文本数据中无监督地学习出词向量，建立一个语言模型。
• 语言模型的作用就是检测一句话是不是正常人说出来的，语言模型意义重大。比如机器翻译、语音识别得到若干候选选项后，可以利用语言模型挑选一个尽量准确的结果。在其他NLP任务中都能用到。
• 语言模型形像化的解释是：给定一句话，看它是自然语言的概率P(w1,w2,w3,..,wt)是多少。w1到wt依次表示这句话中的每个单词，简单的推论是:P(w1,w2,w3...,wt)=P(w1)P(w2|w1)P(w3|w1,w2)*...P(wt|w1,w2,...,wt-1)，常用的语言模型都是在求P(wt|w1,w2,...,wt-1)的值，比如n-gram模型就是用P(wt|w1,w2,...,wt-1)近似代替P(w1,w2,w3...,wt)

4.A Neural Probabilistic Language Model 原理解释

• 训练语言模型的最经典之作，要数 Bengio 等人在 2001 年发表在 NIPS 上的文章《A Neural Probabilistic Language Model》，Bengio 用了一个三层的神经网络来构建语言模型，同样也是 n-gram 模型，如下图所示。

  
  
  

  Neural Probabilistic Language Model原理图.png
• 目标：上图中最下方的wt-n+1,...,wt-2,wt-1就是前n-1个单词，现在根据这已知的n-1个单词预测下一个单词wt。
• 数学符号说明：
  • C(w):表示单词w对应的词向量，整个模型中使用一套唯一的词向量。
  • C：词向量C(w)存在于矩阵C(|V|*m)中，矩阵C的行数表示词汇表的大小；列数表示词向量C(w)的维度。矩阵C的某一行对应一个单词的词向量表示。
  • |V|:表示词汇表的大小，即语料库中的单词总数
  • m:表示词向量C(w)的维度，一般是50到100
  • w到C(w)的转化:从矩阵C中取出一行
  • d:隐藏层偏置bias(h)
  • H: 隐藏层的权重(h*(n-1)m)
  • U:隐藏层到输出层的权重(|V|*h)
  • b:输出层的偏置bias(|V|)
  • W:输入层到输出层权重(|V|*(n-1)m)
  • h:隐藏层神经元的数量
• 网络的第一层(输入层)是将C(wt-n+1),...,C(wt-2),C(wt-1)这已知的n-1和单词的词向量首尾相连拼接起来，形成(n-1)w的向量，下面用x表示。
• 网络的第二层(隐藏层)直接用d+Hx计算得到，d是一个偏置项。之后，用tanh作为激活函数。
• 网络的第三层(输出层)一共有|V|个节点，每个节点yi表示下一个单词i的未归一化log概率。最后使用softmax函数将输出值y归一化成概率，最终y的计算公式如下：
  y = b + Wx + Utanh(d+Hx)
• 最后，用随机梯度下降法把这个模型优化出来就可以了。

5.代码实现---PyTorch版本

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date    : 2019-02-26 14:15:49
# @Author  : cdl ([email protected])
# @Link    : https://github.com/cdlwhm1217096231/python3_spider
# @Version : $Id$


import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable

"""
1.Basic Embedding Model
    1-1. NNLM(Neural Network Language Model)
"""

dtype = torch.FloatTensor
sentences = ["i like dog", "i love coffee", "i hate milk"]

word_list = " ".join(sentences).split()  # 制作词汇表
print(word_list)
word_list = list(set(word_list))  # 去除词汇表中的重复元素
print("去重后的word_list:", word_list)
word_dict = {w: i for i, w in enumerate(word_list)}  # 将每个单词对应于相应的索引
number_dict = {i: w for i, w in enumerate(word_list)}  # 将每个索引对应于相应的单词
n_class = len(word_dict)  # 单词的总数

# NNLM parameters
n_step = 2   # 根据前两个单词预测第3个单词
n_hidden = 2  # 隐藏层神经元的个数
m = 2  # 词向量的维度


# 由于pytorch中输入的数据是以batch小批量进行输入的，下面的函数就是将原始数据以一个batch为基本单位喂给模型
def make_batch(sentences):
    input_batch = []
    target_batch = []
    for sentence in sentences:
        word = sentence.split()
        input = [word_dict[w] for w in word[:-1]]
        target = word_dict[word[-1]]
        input_batch.append(input)
        target_batch.append(target)
    return input_batch, target_batch

# Model


class NNLM(nn.Module):
    def __init__(self):
        super(NNLM, self).__init__()
        self.C = nn.Embedding(n_class, embedding_dim=m)
        self.H = nn.Parameter(torch.randn(n_step * m, n_hidden).type(dtype))
        self.W = nn.Parameter(torch.randn(n_step * m, n_class).type(dtype))
        self.d = nn.Parameter(torch.randn(n_hidden).type(dtype))
        self.U = nn.Parameter(torch.randn(n_hidden, n_class).type(dtype))
        self.b = nn.Parameter(torch.randn(n_class).type(dtype))

    def forward(self, x):
        x = self.C(x)
        x = x.view(-1, n_step * m)
        # x: [batch_size, n_step*n_class]
        tanh = torch.tanh(self.d + torch.mm(x, self.H))
        # tanh: [batch_size, n_hidden]
        output = self.b + torch.mm(x, self.W) + torch.mm(tanh, self.U)
        # output: [batch_size, n_class]
        return output


model = NNLM()

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 制作输入
input_batch, target_batch = make_batch(sentences)
input_batch = Variable(torch.LongTensor(input_batch))
target_batch = Variable(torch.LongTensor(target_batch))


# 开始训练
for epoch in range(5000):
    optimizer.zero_grad()
    output = model(input_batch)
# output : [batch_size, n_class], target_batch : [batch_size] (LongTensor, not one-hot)
    loss = criterion(output, target_batch)
    if (epoch + 1) % 1000 == 0:
        print("Epoch:{}".format(epoch + 1), "Loss:{:.3f}".format(loss))
    loss.backward()
    optimizer.step()

# 预测
predict = model(input_batch).data.max(
    1, keepdim=True)[1]  # [batch_size, n_class]
print("predict: \n", predict)
# 测试
print([sentence.split()[:2] for sentence in sentences], "---->",
      [number_dict[n.item()] for n in predict.squeeze()])

6.结果

['i', 'like', 'dog', 'i', 'love', 'coffee', 'i', 'hate', 'milk']
去重后的word_list: ['coffee', 'i', 'hate', 'dog', 'love', 'milk', 'like']
Epoch:1000 Loss:0.114
Epoch:2000 Loss:0.021
Epoch:3000 Loss:0.007
Epoch:4000 Loss:0.003
Epoch:5000 Loss:0.002
predict: 
 tensor([[3],
        [0],
        [5]])
[['i', 'like'], ['i', 'love'], ['i', 'hate']] ----> ['dog', 'coffee', 'milk']
[Finished in 4.5s]

7.代码实现----TensorFlow版本

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date    : 2019-02-26 21:25:01
# @Author  : cdl ([email protected])
# @Link    : https://github.com/cdlwhm1217096231/python3_spider
# @Version : $Id$

import numpy as np
import tensorflow as tf


tf.reset_default_graph()


sentences = ["i like coffee", "i love curry", "i hate apple"]
word_list = " ".join(sentences).split()
word_list = list(set(word_list))
print(word_list)

word_dict = {w: i for i, w in enumerate(word_list)}
number_dict = {i: w for i, w in enumerate(word_list)}
n_class = len(word_dict)


# Model parameters
n_step = 2
n_hidden = 5


def make_batch(sentences):
    input_batch = []
    target_batch = []
    for sentence in sentences:
        words = sentence.split()
        input = [word_dict[word] for word in words[:-1]]
        target = word_dict[words[-1]]

        input_batch.append(np.eye(n_class)[input])  # np.eye()是单位对角阵
        target_batch.append(np.eye(n_class)[target])

    return input_batch, target_batch


# Model

# [batch_size, number of steps, number of Vocabulary]
X = tf.placeholder(tf.float32, [None, n_step, n_class])
Y = tf.placeholder(tf.float32, [None, n_class])

# [batch_size, n_step * n_class]
input = tf.reshape(X, shape=[-1, n_step * n_class])
H = tf.Variable(tf.random_normal([n_step * n_class, n_hidden]))
d = tf.Variable(tf.random_normal([n_hidden]))
U = tf.Variable(tf.random_normal([n_hidden, n_class]))
b = tf.Variable(tf.random_normal([n_class]))

tanh = tf.nn.tanh(d + tf.matmul(input, H))  # [batch_size, n_hidden]
output = tf.matmul(tanh, U) + b  # [batch_size, n_class]

cost = tf.reduce_mean(
    tf.nn.softmax_cross_entropy_with_logits_v2(logits=output, labels=Y))
optimizer = tf.train.AdamOptimizer(0.001).minimize(cost)
prediction = tf.argmax(output, 1)

# Training
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

    input_batch, target_batch = make_batch(sentences)

    for epoch in range(5000):
        _, loss = sess.run([optimizer, cost], feed_dict={
                           X: input_batch, Y: target_batch})
        if (epoch + 1) % 1000 == 0:
            print("Epoch:{}".format(epoch + 1), "Cost:{:.4f}".format(loss))
    # Predict
    predict = sess.run([prediction], feed_dict={X: input_batch})

    # Test
    input = [sentence.split()[:2] for sentence in sentences]
    print([sentence.split()[:2] for sentence in sentences],
          '---->', [number_dict[n] for n in predict[0]])

8.结果

['like', 'love', 'apple', 'coffee', 'hate', 'curry', 'i']
Epoch:1000 Cost:0.1147
Epoch:2000 Cost:0.0324
Epoch:3000 Cost:0.0127
Epoch:4000 Cost:0.0057
Epoch:5000 Cost:0.0029
[['i', 'like'], ['i', 'love'], ['i', 'hate']] ----> ['coffee', 'curry', 'apple']
[Finished in 7.0s]

9.参考文献

1.Yoshua Bengio, Rejean Ducharme, Pascal Vincent, and Christian Jauvin. A neural probabilistic language model. Journal of Machine Learning Research (JMLR), 3:1137–1155, 2003.
2.LICSTAR的博客
3.A Neural Probabilistic Language Model CSDN博客