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内部,我们进行以下操作:
- self.v_count: 词汇表的长度(注意,词汇表指的就是语料库中不重复的单词的数量)
- self.words_list: 在词汇表中的单词组成的列表
- self.word_index: 以词汇表中单词为key,索引为value的字典数据
- self.index_word: 以索引为key,以词汇表中单词为value的字典数据
- 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)