Word2vec代码实现

Word2vec纯python代码实现

 

1. 什么是 Word2vec?

在聊 Word2vec 之前，先聊聊 NLP (自然语言处理)。NLP 里面，最细粒度的是 词语，词语组成句子，句子再组成段落、篇章、文档。所以处理 NLP 的问题，首先就要拿词语开刀。

举个简单例子，判断一个词的词性，是动词还是名词。用机器学习的思路，我们有一系列样本(x,y)，这里 x 是词语，y 是它们的词性，我们要构建 f(x)->y 的映射，但这里的数学模型 f（比如神经网络、SVM）只接受数值型输入，而 NLP 里的词语，是人类的抽象总结，是符号形式的（比如中文、英文、拉丁文等等），所以需要把他们转换成数值形式，或者说——嵌入到一个数学空间里，这种嵌入方式，就叫词嵌入（word embedding)，而 Word2vec，就是词嵌入（ word embedding) 的一种

我在前作『都是套路: 从上帝视角看透时间序列和数据挖掘』提到，大部分的有监督机器学习模型，都可以归结为：

f(x)->y

在 NLP 中，把 x 看做一个句子里的一个词语，y 是这个词语的上下文词语，那么这里的 f，便是 NLP 中经常出现的『语言模型』（language model），这个模型的目的，就是判断 (x,y) 这个样本，是否符合自然语言的法则，更通俗点说就是：词语x和词语y放在一起，是不是人话。

Word2vec 正是来源于这个思想，但它的最终目的，不是要把 f 训练得多么完美，而是只关心模型训练完后的副产物——模型参数（这里特指神经网络的权重），并将这些参数，作为输入 x 的某种向量化的表示，这个向量便叫做——词向量（这里看不懂没关系，下一节我们详细剖析）。

我们来看个例子，如何用 Word2vec 寻找相似词：

• 对于一句话：『她们 夸 吴彦祖 帅 到 没朋友』，如果输入 x 是『吴彦祖』，那么 y 可以是『她们』、『夸』、『帅』、『没朋友』这些词
• 现有另一句话：『她们 夸 我 帅 到 没朋友』，如果输入 x 是『我』，那么不难发现，这里的上下文 y 跟上面一句话一样
• 从而 f(吴彦祖) = f(我) = y，所以大数据告诉我们：我 = 吴彦祖（完美的结论）

 

2. Skip-gram 和 CBOW 模型

上面我们提到了语言模型

• 如果是用一个词语作为输入，来预测它周围的上下文，那这个模型叫做『Skip-gram 模型』
• 而如果是拿一个词语的上下文作为输入，来预测这个词语本身，则是 『CBOW 模型』

 

 

Skip-gram体系结构实现（CBOW同理）

 

内容分为以下几个部分：

1.数据准备——定义语料库、整理、规范化和分词

2.超参数——学习率、训练次数、窗口尺寸、嵌入（embedding）尺寸

3.生成训练数据——建立词汇表，对单词进行one-hot编码，建立将id映射到单词的字典，以及单词映射到id的字典

4.模型训练——通过正向传递编码过的单词，计算错误率，使用反向传播调整权重和计算loss值

5.结论——获取词向量，并找到相似的词

6.进一步的改进 —— 利用Skip-gram负采样(Negative Sampling)和Hierarchical Softmax提高训练速度

 

详解

 

1.数据准备

首先，我们从以下语料库开始：

natural language processing and machine learning is fun and exciting

简单起见，我们选择了一个没有标点和大写的橘子。而且，我们没有删除停用词“and”和“is”。

实际上，文本数据是非结构化的，甚至可能很“很不干净”清理它们涉及一些步骤，例如删除停用词、标点符号、将文本转换为小写（实际上取决于你的实际例子）和替换数字等。KDnuggets 上有一篇关于这个步骤很棒的文章。另外，Gensim也提供了执行简单文本预处理的函数——gensim.utils.simple_preprocess，它将文档转换为由小写的词语（Tokens ）组成的列表，并忽略太短或过长的词语。

在预处理之后，我们开始对语料库进行分词。我们按照单词间的空格对我们的语料库进行分词，结果得到一个单词列表：

[“natural”, “language”, “processing”, “ and”, “ machine”, “ learning”, “ is”, “ fun”, “and”, “ exciting”]

 

2.超参数

在进入word2vec的实现之前，让我们先定义一些稍后需要用到的超参数。

 

[window_size/窗口尺寸]:上下文单词是与目标单词相邻的单词。但是，这些词应该有多远或多近才能被认为是相邻的呢？这里我们将窗口尺寸定义为2，这意味着目标单词的左边和右边最近的2个单词被视为上下文单词。

[n]：这是单词嵌入(word embedding)的维度，通常其的大小通常从100到300不等，取决于词汇库的大小。超过300维度会导致效益递减（参见图2（a）的1538页）。请注意，维度也是隐藏层的大小。

 

[epochs] ：表示遍历整个样本的次数。在每个epoch中，我们循环通过一遍训练集的样本。

[learning_rate/学习率]：学习率控制着损失梯度对权重进行调整的量。

 

3.生成训练数据

在本节中，我们的主要目标是将语料库转换one-hot编码表示，以方便Word2vec模型用来训练。

为了生成one-hot训练数据，我们首先初始化word2vec()对象，然后使用对象w2v通过settings 和corpus 参数来调用函数generate_training_data。

在函数generate_training_data内部，我们进行以下操作：

 

1. self.v_count: 词汇表的长度（注意，词汇表指的就是语料库中不重复的单词的数量）
2. self.words_list: 在词汇表中的单词组成的列表
3. self.word_index: 以词汇表中单词为key，索引为value的字典数据
4. self.index_word: 以索引为key，以词汇表中单词为value的字典数据
5. for循环给用one-hot表示的每个目标词和其的上下文词添加到training_data中，one-hot编码用的是word2onehot函数。

 

 

 

4.模型训练

 

Word2Vec——skip-gram的网络结构

拥有了training_data，我们现在可以准备训练模型了。训练从w2v.train(training_data)开始，我们传入训练数据，并执行train函数。

Word2Vec2模型有两个权重矩阵(w1和w2)，为了展示，我们把值初始化到形状分别为(9x10)和(10x9)的矩阵。这便于反向传播误差的计算，在实际的训练中，随机初始化这些权重（使用np.random.uniform()）。

 

训练——向前传递

接下来，我们开始用第一组训练样本来训练第一个epoch，方法是把w_t 传入forward_pass 函数，w_t 是表示目标词的one-hot向量。在forward_pass 函数中，我们执行一个w1 和w_t 的点乘积，得到h (原文是24行，但图中实际是第22行)。然后我们执行w2和h 点乘积，得到输出层的u（ 原文是26行，但图中实际是第24行 ）。最后，在返回预测向量y_pred和隐藏层h 和输出层u 前，我们使用softmax把u 的每个元素的值映射到0和1之间来得到用来预测的概率（第28行）。

 

 

训练——误差，反向传播和损失（loss）

误差——对于y_pred、h 和u，我们继续计算这组特定的目标词和上下文词的误差。这是通过对y_pred 与在w_c 中的每个上下文词之间的差的加合来实现的。

反向传播——接下来，我们使用反向传播函数backprop ，通过传入误差EI 、隐藏层h 和目标字w_t 的向量，来计算我们所需的权重调整量。

为了更新权重，我们将权重的调整量（dl_dw1 和dl_dw2 ）与学习率相乘，然后从当前权重（w1 和w2 ）中减去它。

损失——最后，根据损失函数计算出每个训练样本完成后的总损失。注意，损失函数包括两个部分。第一部分是输出层（在softmax之前）中所有元素的和的负数。第二部分是上下文单词的数量乘以在输出层中所有元素（在 exp之后）之和的对数。

 

 

5. 推论和总结（Inferencing）

 

既然我们已经完成了50个epoch的训练，两个权重（w1和w2）现在都准备好执行推论了。

获取单词的向量

有了一组训练后的权重，我们可以做的第一件事是查看词汇表中单词的词向量。我们可以简单地通过查找单词的索引来对训练后的权重（w1）进行查找。在下面的示例中，我们查找单词“machine”的向量。

 

> print(w2v.word_vec("machine"))
[ 0.76702922 -0.95673743  0.49207258  0.16240808 -0.4538815  
-0.74678226  0.42072706 -0.04147312  0.08947326 -0.24245257]

 

查询相似的单词

我们可以做的另一件事就是找到类似的单词。即使我们的词汇量很小，我们仍然可以通过计算单词之间的余弦相似度来实现函数vec_sim 。

 

全部代码：

import numpy as np
from collections import defaultdict
 
 
class word2vec():
 
    def __init__(self):
        self.n = settings['n']
        self.lr = settings['learning_rate']
        self.epochs = settings['epochs']
        self.window = settings['window_size']
 
    def generate_training_data(self, settings, corpus):
        """
        得到训练数据
        """
 
        #defaultdict(int)  一个字典，当所访问的键不存在时，用int类型实例化一个默认值
        word_counts = defaultdict(int)
 
        #遍历语料库corpus
        for row in corpus:
            for word in row:
                #统计每个单词出现的次数
                word_counts[word] += 1
 
        # 词汇表的长度
        self.v_count = len(word_counts.keys())
        # 在词汇表中的单词组成的列表
        self.words_list = list(word_counts.keys())
        # 以词汇表中单词为key，索引为value的字典数据
        self.word_index = dict((word, i) for i, word in enumerate(self.words_list))
        #以索引为key，以词汇表中单词为value的字典数据
        self.index_word = dict((i, word) for i, word in enumerate(self.words_list))
 
        training_data = []
 
        for sentence in corpus:
            sent_len = len(sentence)
 
            for i, word in enumerate(sentence):
 
                w_target = self.word2onehot(sentence[i])
 
                w_context = []
 
                for j in range(i - self.window, i + self.window):
                    if j != i and j <= sent_len - 1 and j >= 0:
                        w_context.append(self.word2onehot(sentence[j]))
 
                training_data.append([w_target, w_context])
 
        return np.array(training_data)
 
    def word2onehot(self, word):
 
        #将词用onehot编码
 
        word_vec = [0 for i in range(0, self.v_count)]
 
        word_index = self.word_index[word]
 
        word_vec[word_index] = 1
 
        return word_vec
 
    def train(self, training_data):
 
 
        #随机化参数w1,w2
        self.w1 = np.random.uniform(-1, 1, (self.v_count, self.n))
 
        self.w2 = np.random.uniform(-1, 1, (self.n, self.v_count))
 
        for i in range(self.epochs):
 
            self.loss = 0
 
            # w_t 是表示目标词的one-hot向量
            #w_t -> w_target,w_c ->w_context
            for w_t, w_c in training_data:
 
                #前向传播
                y_pred, h, u = self.forward(w_t)
 
                #计算误差
                EI = np.sum([np.subtract(y_pred, word) for word in w_c], axis=0)
 
                #反向传播，更新参数
                self.backprop(EI, h, w_t)
 
                #计算总损失
                self.loss += -np.sum([u[word.index(1)] for word in w_c]) + len(w_c) * np.log(np.sum(np.exp(u)))
 
            print('Epoch:', i, "Loss:", self.loss)
 
    def forward(self, x):
        """
        前向传播
        """
 
        h = np.dot(self.w1.T, x)
 
        u = np.dot(self.w2.T, h)
 
        y_c = self.softmax(u)
 
        return y_c, h, u
 
 
    def softmax(self, x):
        """
        """
        e_x = np.exp(x - np.max(x))
 
        return e_x / np.sum(e_x)
 
 
    def backprop(self, e, h, x):
 
        d1_dw2 = np.outer(h, e)
        d1_dw1 = np.outer(x, np.dot(self.w2, e.T))
 
        self.w1 = self.w1 - (self.lr * d1_dw1)
        self.w2 = self.w2 - (self.lr * d1_dw2)
 
    def word_vec(self, word):
 
        """
        获取词向量
        通过获取词的索引直接在权重向量中找
        """
 
        w_index = self.word_index[word]
        v_w = self.w1[w_index]
 
        return v_w
 
    def vec_sim(self, word, top_n):
        """
        找相似的词
        """
 
        v_w1 = self.word_vec(word)
        word_sim = {}
 
        for i in range(self.v_count):
            v_w2 = self.w1[i]
            theta_sum = np.dot(v_w1, v_w2)
 
            #np.linalg.norm(v_w1) 求范数 默认为2范数，即平方和的二次开方
            theta_den = np.linalg.norm(v_w1) * np.linalg.norm(v_w2)
            theta = theta_sum / theta_den
 
            word = self.index_word[i]
            word_sim[word] = theta
 
        words_sorted = sorted(word_sim.items(), key=lambda kv: kv[1], reverse=True)
 
        for word, sim in words_sorted[:top_n]:
            print(word, sim)
 
    def get_w(self):
        w1 = self.w1
        return  w1
#超参数
settings = {
    'window_size': 2,   #窗口尺寸 m
    #单词嵌入(word embedding)的维度,维度也是隐藏层的大小。
    'n': 10,
    'epochs': 50,         #表示遍历整个样本的次数。在每个epoch中，我们循环通过一遍训练集的样本。
    'learning_rate':0.01 #学习率
}
 
#数据准备
text = "natural language processing and machine learning is fun and exciting"
#按照单词间的空格对我们的语料库进行分词
corpus = [[word.lower() for word in text.split()]]
print(corpus)
 
#初始化一个word2vec对象
w2v = word2vec()
 
training_data = w2v.generate_training_data(settings,corpus)
 
#训练
w2v.train(training_data)
 
# 获取词的向量
word = "machine"
vec = w2v.word_vec(word)
print(word, vec)
 
# 找相似的词
w2v.vec_sim("machine", 3)