引言

本文是对近日学习word2vec的一个总结，期间看了不少博客和论文。

word2vec是一种高效的训练词向量的模型，基于上下文相似的两个词,它们的词向量也应该相似, 比如，“A dog is running in the room"和"A cat is running in the room”。这两个句子，只是"cat"和"dog"不同，word2vec认为它们是相似的，而n-gram模型做不到这一点。

word2vec有两个模型：CBOW(COntinuous Bag of Words)和Skip-Gram。

CBOW模型中，通过一个上下文(比如说一个句子)来预测目标词；而Skip-Gram模型则相反，根据给定的输入词来预测上下文。

Skip-Gram：能够很好地处理少量的训练数据，而且能够很好地表示不常见的单词或短语 CBOW：比skip-gram训练快几倍，对出现频率高的单词的准确度稍微更好一些

Simple CBOW模型

要想理解CBOW和SkipGram模型，我们先从最简单版本的CBOW模型开始介绍，又被称为One Word模型，上下文只有一个单词，目标词也是一个单词。 意味着给定一个上下文词来预测一个目标词。有点类似bigram模型。

在上图中$V$是词典大小,$N$是一个超参数，是隐藏层中单元数量，也是我们要学的词向量的维度，一般最多设置到300。

输入向量$x$是$V\times 1$的one-hot向量，只有$x_k=1$，其他都是$0$。

输入层和输出层之间的权重是一个$V\times N$的矩阵$W$，给定一个上下文单词，隐藏层$h$计算如下：

$$h=W^{T}x=W_{(k,\cdot )}^T:=v_{w_I}^T\text{\hspace{1em}(1)}$$

$W$是$V\times N$。 $h$的维度是$N\times 1$

这个公式详细描述一下，展开上面的$W$矩阵：

$$W_{V\times N}=\left[\begin{array}{cccc}{w}_{11}& w_{12}& \cdots & w_{1N}\\ w_{21}& w_{22}& \cdots & w_{2N}\\ ⋮& ⋮& \ddots & ⋮\\ w_{V1}& w_{V2}& \cdots & w_{VN}\end{array}\right]$$

$x$：

$$x=\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_V\end{array}\right]$$

$$h=W^{T}x={\left[\begin{array}{ccccc}{w}_{11}& w_{21}& \cdots & w_{k1}\cdots & w_{V1}\\ w_{12}& w_{22}& \cdots & w_{k2}\cdots & w_{V2}\\ ⋮& ⋮& \ddots & ⋮& ⋮\\ w_{1N}& w_{2N}& \cdots & w_{kN}\cdots & w_{VN}\end{array}\right]}_{N\times V}\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_k\\ ⋮\\ x_V\end{array}\right]=\left[\begin{array}{c}{w}_{k1}\\ w_{k2}\\ ⋮\\ w_{kN}\end{array}\right]$$

$W$的第$i$行用$v_w$表示，相当于是$w$的词向量，是$1\times N$的。

$W^{T}x$得到$N\times 1$的列向量，相当于是$W$中$x_k=1$对应的那一行。

基本上就是拷贝了$W$的第$k$行到$h$去了。

输入单词$w_I$的向量表示是$v_{w_I}$，维度是$N\times 1$。

从隐藏层到输出层，有一个不同的权重矩阵$W^{\prime }$，它是$N\times V$的。使用这个权重矩阵，可以计算第$j$个单词的得分$u_j$:

$$u_j={v_{w_j}^{\prime }}^T\cdot h\text{\hspace{1em}(2)}$$

$v_{w_j}^{\prime }$是矩阵$W^{\prime }$的第$j$列，维度是$N\times 1$的， ${v_{w_j}^{\prime }}^T$维度就是$1\times N$。因此$u_j$是这两个向量的内积，结果是一个标量，代表某个单词的分数。

这个得分可以理解为衡量中心词与输出词的相似度，$h$其实就是输入词的向量$v_{w_I}$。

我们可以一次性求出所有单词的得分:$u={W^{\prime }}^T\cdot h$，得到的是$V\times 1$的向量，$V$是词典大小。

接着对$u$进行softmax就可以得到每个单词得分的概率分布：

$$p(w_j|w_I)=y_j=\frac{exp(u_j)}{{\sum }_{j^{\prime }=1}^{V}exp(u_{j^{\prime }})}\text{\hspace{1em}(3)}$$

$y_j$是输出层第$j$个单元的输出。把$(1)$,$(2)$代入到$(3)$得：

$$p(w_j|w_I)=\frac{exp({v_{w_j}^{\prime }}^T\cdot v_{w_I})}{{\sum }_{j^{\prime }=1}^{V}exp({v_{w_{j^{\prime }}}^{\prime }}^T{v}_{w_I})}\text{\hspace{1em}(4)}$$

这里要注意的是：

输入单词$x$和输出单词$y$都是one-hot向量$v_w$和$v_w^{\prime }$是输入单词$w$的两种表示，分别称为输入向量和输出向量$v_w$来自$W$的行$v_w^{\prime }$来自$W^{\prime }$的列

更新权重:隐藏层到输出层

下面我们就可以根据上面的式子来求梯度了。

训练目标是最大化公式$(4)$，即给定输入单词$w_I$，最大化观察到输出单词$w_O$的条件概率(用$j^{\ast }$表示它输出层的索引)。

$$\begin{array}{rl}\max p(w_O|w_I)& =\max y_{j^{\ast }}\\ & =\max \log y_{j^{\ast }}\\ & =\max \log \exp (u_{j^{\ast }})-\log \sum _{j^{\prime }=1}^{V}exp(u_{j^{\prime }})\\ & =u_j^{\ast }-log\sum _{j^{\prime }=1}^{V}exp(u_{j^{\prime }}):=-E\end{array}$$

$:=$是记作的意思，即整个式子记作$-E$,也就是$E=-\log p(w_O|w_I)$，因为我们习惯最小化损失函数。

现在我们更新隐藏层和输出层之间的权重。

下面求$E$对$u_j$的偏导，得到了

$$\frac{\partial E}{\partial u_j}=y_j-t_j:=e_j\text{\hspace{1em}(5)}$$

当$j=j^{\ast }$时，$t_j=1$，否则$t_j=0$。

下面给出公式推导：

$$\begin{array}{rl}\frac{\partial E}{\partial u_j}& =-\frac{\partial \left(u_j^{\ast }-log{\sum }_{j^{\prime }=1}^{V}exp(u_{j^{\prime }})\right)}{\partial u_j}\\ & =-\frac{\partial u_{j^{\ast }}}{\partial u_j}+\frac{\partial \left(\log {\sum }_{j^{\prime }=1}^V\exp (u_{j^{\prime }})\right)}{\partial u_j}\\ & =-t_j+\frac{exp(u_j)}{{\sum }_{j^{\prime }=1}^{V}exp(u_j)}\\ & =y_j-t_j\end{array}$$

其中

$$\frac{\partial \left(\log {\sum }_{j^{\prime }=1}^V\exp (u_{j^{\prime }})\right)}{\partial u_j}$$ 是通过复合函数的求导法则来求的，$\frac{\partial \log f(x)}{\partial x}=\frac{f(x{)}^{\prime }}{f(x)}$ ，这里把$f(x)={\sum }_{j^{\prime }=1}^V\exp (u_{j^{\prime }})$

要求${\sum }_{j^{\prime }=1}^V\exp (u_{j^{\prime }})$对$u_j$的偏导，其实很简单，把求和符号展开即可。

$$\frac{\partial \left(exp(u_1)+exp(u_2)+\cdots +exp(u_j)+\cdots +exp(u_V)\right)}{\partial u_j}=exp(u_j)$$

把$u_j$看成一个变量，其他$u_1,u_2,\cdots$都是与$u_j$无关的，因此求导结果为0。

根据公式$(3)$就可以化简为$y_j-t_j$。

结果简单地就是预测值与真实值之差。

下一步就是对$w_{ij}^{\prime }$求导来获取它的梯度。

来看下$\frac{\partial u_j}{\partial w_{ij}^{\prime }}$

由公式$(2)$知道$u_j$与$w_{ij}^{\prime }$的关系。$h=v_{w_I}=[h_1,h_2,\cdots ,h_N]$

${v_{w_j}^{\prime }}^T=[w_{1j}^{\prime },w_{2j}^{\prime },\cdots ,w_{1N}^{\prime }]$

$u_j=h_1\cdot w_{1j}^{\prime }+h_2\cdot w_{2j}^{\prime }+\cdots +h_i\cdot w_{ij}^{\prime }+\cdots +h_N\cdot w_{Nj}^{\prime }$

所以 $\frac{\partial u_j}{\partial w_{ij}^{\prime }}=h_i$

$$\frac{\partial E}{\partial w_{ij}^{\prime }}=\frac{\partial E}{\partial u_j}\cdot \frac{\partial u_j}{\partial w_{ij}^{\prime }}=e_j\cdot h_i\text{\hspace{1em}(6)}$$

现在就可以使用梯度下降来更新隐藏层到输出层的权重： $$w_{ij}^{\prime }=w_{ij}^{\prime }-\eta \cdot e_j\cdot h_i$$ 或者向量的形式为： $$v_{w_j}^{\prime }=v_{w_j}^{\prime }-\eta \cdot e_j\cdot h$$

$h_i$是隐藏层的第$i$个单元，$v{\prime }_{w_j}$是单词$w_j$的输出向量。对每个训练样本都需要做一次复杂度为$V$的操作去更新$W^{\prime }$。

更新权重：输入层到隐藏层

接着我们关注输入层到隐藏层的权重。首先求$\frac{\partial E}{\partial h_i}$

$$\begin{gathered} \frac{\partial E}{\partial h_i}=\sum _{j=1}^V\frac{\partial E}{\partial u_j}\cdot \frac{\partial u_j}{\partial h_i} \\ =\sum _{j=1}^V{e}_j\cdot w_{ij}^{\prime } \\ :=E{H}_i \end{gathered}$$

$EH$是一个$N$维的向量($N\times 1$)，就是所有输出单词的权重之和，权重是它们的预测错误。

下一步就是要求$E$对$W$的导数，首先回顾下隐藏层就是输入层的线性变换： $$h_i=\sum _{k=1}^V{x}_k\cdot w_{ki}$$

然后我们用链式法则来求$E$对$W$的导数： $$\begin{gathered} \frac{\partial E}{\partial w_{ki}}=\frac{\partial E}{\partial h_i}\cdot \frac{\partial h_i}{\partial w_{ki}} \\ =E{H}_i\cdot x_k \end{gathered}$$

向量化形式等价于$x$和$EH$的张量积： $$\frac{\partial E}{\partial W}=x\otimes EH=x\cdot E{H}^T$$

这样就得到了一个$V\times N$的矩阵，因为$x$向量中只有一个元素为$1$，其他都为$0$，所以在$\frac{\partial E}{\partial W}$的矩阵中，只有一行是非零的。并且这一行的值是$E{H}^T$。

现在我们就可以写出$W$的更新式子了： $$v_{w_I}=v_{w_I}-\eta \cdot E{H}^T$$

因为只有一行是非零的，所以一次也只会更新一行。

CBOW模型

CBOW模型的图示如下：

CBOW模型由多个单词作为输入，每个输入都是one-hot模型，同样输出一个单词。由多个上下文单词来预测中心词。计算隐藏层的时候，取输入单词的平均向量，然后乘以权重$W$作为输出：

$$\begin{gathered} h=\frac{1}{C}(x_1^T+x_2^T+\cdots +x_C^T)W \\ =\frac{1}{C}(v_{w_1}+v_{w_2}+\cdots +v_{w_C}) \end{gathered}$$

$C$是上下文单词数量，因为是把$C$个输入单词的平均向量作为输入向量，损失函数的定义和上面一个单词的模型一样。

更新隐藏层到输出层的式子也是一样的： $$v_{w_j}^{\prime }=v_{w_j}^{\prime }-\eta \cdot e_j\cdot hforj=1,2,\cdots ,V$$

更新输入层到隐藏层的权重和之前一样，除了我们需要将梯度均摊到每个输入单词上：

$$v_{w_{I,c}}=v_{w_{I,c}}-\frac{1}{C}\cdot \eta \cdot E{H}^{T}forc=1,2,\cdots ,C$$

这里每次会更新$W$中的$C$行。

Skipgram模型

Skip-Gram模型和CBOW模型相反，把中心词放到输入层中，输出层输出的是上下文词。即用中心词来预测上下文词。

我们仍然使用$v_{w_I}$来表示Skip-gram模型的唯一输入向量。然后隐藏层输出$h$的定义也和$(1)$一样。

$$h=W^{T}x=W_{(k,\cdot )}^T:=v_{w_I}^T$$

在输出层，不是输出一个多项式分布，而是输出$C$个多项式分布。但每个分布使用同样的权重矩阵来计算：

$$p(w_{c,j}|w_I)=y_{c,j}=\frac{exp(u_{c,j})}{{\sum }_{j^{\prime }=1}^{V}exp(u_{j^{\prime }})}$$

需要注意的是，这$C$个输出是相互独立的。$w_{c,j}$是第$c$个panel(输出)中的第$j$个单词。$w_I$是输入单词。$y_{c,j}$是第$c$个输出层中的第$j$个单元。 $u_{c,j}$是第$c$个输出的第$j$个单元的得分。因为这些输出都共享同样的权重，因此 $$u_{c,j}=u_j={v_{w_j}^{\prime }}^T\cdot hforc=1,2,\cdots ,C$$

$v_{w_j}^{\prime }$是词典中第$j$个单词的输出向量，它是矩阵$W^{\prime }$中的第$j$列。

参数更新的式子和简单CBOW模型有点不同，

$$\begin{array}{rl}E& =-\log p(w_{O,1},w_{O,2},\cdots ,w_{O,C}|w_I)\\ & =-\log \prod _{c=1}^{C}P(w_{O,c}|w_i)\\ & =-\log \prod _{c=1}^C\frac{exp(u_{c,j_c^{\ast }})}{{\sum }_{j^{\prime }=1}^{V}exp(u_{j^{\prime }})}\\ & =-\log \prod _{c=1}^{C}exp(u_{c,j_c^{\ast }})+\log \prod _{c=1}^C\sum _{j^{\prime }=1}^{V}exp(u_{j^{\prime }})\\ & =-\sum _{c=1}^C{u}_{j_c^{\ast }}+\log (\sum _{j^{\prime }=1}^{V}exp(u_{j^{\prime }}){)}^C\\ & =-\sum _{c=1}^C{u}_{j_c^{\ast }}+C\cdot \log \sum _{j^{\prime }=1}^{V}exp(u_{j^{\prime }})\end{array}$$

$w_{O,c}$代表第$c$个输出单词，$j_c^{\ast }$表示第$c$个输出单词的索引。 因为这$C$个输出是相互独立的，因此$p(w_{O,1},w_{O,2},\cdots ,w_{O,C}|w_I)=\prod P(w_{O,c}|w_I)$

下面我们求梯度，对第$c$个多项分布的第$j$项的梯度为：

$$\frac{\partial E}{\partial u_{c,j}}=y_{c,j}-t_{c,j}:=e_{c,j}$$

就是某个输出的预测错误，考虑到$C$个多项分布产生的影响，所以需要求和。

为了简化，我们定义一个$V$维的向量$EI=E{I}_1,\cdots ,E{I}_V$作为所有上下文单词的预测错误之和。

对第$j$个单词的预测错误之和为： $$E{I}_j=\sum _{c=1}^C{e}_{c,j}$$

接下来，对隐藏层到输出层矩阵$W^{\prime }$求导：

$$\frac{\partial E}{\partial w_{ij}^{\prime }}=\sum _{c=1}^C\frac{\partial E}{\partial u_{c,j}}\cdot \frac{\partial u_{c,j}}{\partial w_{ij}^{\prime }}=E{I}_j\cdot h_i$$

所以更新隐藏层到输出层权重的式子为：

$$w_{ij}^{\prime }=w_{ij}^{\prime }-\eta \cdot E{I}_j\cdot h_i$$ 或者 $$v_{w_j}^{\prime }=v_{w_j}^{\prime }-\eta \cdot E{I}_j\cdot hforj=1,2,\cdots ,V$$

下面考虑对隐藏层的梯度： $$\begin{array}{rl}\frac{\partial E}{\partial h_i}& =\sum _{c=1}^C\sum _{j=1}^V\frac{\partial E}{\partial u_{c,j}}\frac{\partial u_{c,j}}{\partial h_i}\\ & =\sum _{c=1}^C\sum _{j=1}^V{e}_{c,j}\cdot w_{ij}^{\prime }\\ & =\sum _{j=1}^{V}E{I}_j\cdot w_{ij}^{\prime }:=E{H}_i\end{array}$$

和简单CBOW模型一样，整成向量化的形式为： $$\frac{\partial E}{\partial h}=E{H}^T$$

由于输入只有一个词，$h=v_{w_I}^T$，每次也是更新$W$的一行：

$$v_{w_I}=v_{w_I}-\eta \cdot E{H}^T$$

简单代码实现

# -*- coding: utf-8 -*- # @Author : Jue from collections import defaultdict import numpy as np class word2vec: def __init__(self, settings): self.n = settings['n'] self.eta = settings['learning_rate'] self.epochs = settings['epochs'] self.window = settings['window_size'] # true:cbow ; false:skipgram self.cbow = settings['model'] == 'cbow' def generate_training_data(self, corpus): # 单词计数 word_counts = defaultdict(int) for row in corpus: for word in row: word_counts[word] += 1 # 词典大小V self.v_count = len(word_counts.keys()) # 生成LOOKUP 词典 self.words_list = sorted(list(word_counts.keys()), reverse=False) # 单词对应的索引 self.word_index = dict((word, i) for i, word in enumerate(self.words_list)) # 索引对应的单词 self.index_word = dict((i, word) for word, i in self.word_index.items()) 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 + 1): if j != i and sent_len - 1 >= j >= 0: w_context.append(self.word2onehot(sentence[j])) training_data.append([w_target, w_context]) # 中心词,上下文词 return np.array(training_data, dtype=object) def train(self, training_data, debug=False): # 初始化权重矩阵 self.w1 = np.random.uniform(-0.8, 0.8, (self.v_count, self.n)) # 目标词矩阵 W v x n self.w2 = np.random.uniform(-0.8, 0.8, (self.n, self.v_count)) # 上下文词矩阵 W′ n x v # 迭代epochs次 for i in range(self.epochs): self.loss = 0 # 中心词,上下文词 for w_t, w_c in training_data: if self.cbow: x = np.mean(w_c, axis=0) else: x = w_t # 前向传播 y_pred, h, u = self.forward_pass(x) # 计算损失 e_j if self.cbow: e = y_pred - w_t # dE/du else: e = np.sum([np.subtract(y_pred, word) for word in w_c], axis=0) # 反向传播 self.backprop(e, h, x) if self.cbow: self.loss += -float(u[w_t == 1]) + np.log(np.sum(np.exp(u))) else: self.loss += -np.sum([u[word == 1] for word in w_c]) + len(w_c) * np.log(np.sum(np.exp(u))) if i % 100 == 0 and debug: print('EPOCH:', i, 'LOSS:', self.loss) def forward_pass(self, x): ''' :param x: vx1 one-hot向量 :return: ''' h = np.dot(self.w1.T, x) # (nxv) (vx1) -> nx1 u = np.dot(self.w2.T, h) # (v x n) (n x 1) -> vx1 计算每个单词的得分 y_c = self.softmax(u) # 通过softmax进行归一化，得到每个单词对应的概率 return y_c, h, u def backprop(self, e, h, x): ''' :param e: v x 1 :param h: n x 1 :param x: v x 1 :return: ''' dw2 = np.outer(h, e) # n x v W′的梯度 dw1 = np.outer(x, np.dot(self.w2, e)) # (vx1) (nxv vx1)->nx1 self.w1 -= self.eta * dw1 self.w2 -= self.eta * dw2 def word2onehot(self, word): word_vec = np.zeros((self.v_count, 1)) word_vec[self.word_index[word]] = 1 return word_vec def softmax(self, x): e_x = np.exp(x - np.max(x)) return e_x / e_x.sum(axis=0) def word_2_vec(self, word): w_index = self.word_index[word] return self.w1[w_index] def cos_similarity(v1, v2): return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)) if __name__ == '__main__': settings = {} settings['n'] = 2 # dimension of word embeddings settings['window_size'] = 2 # context window +/- center word settings['min_count'] = 0 # minimum word count settings['epochs'] = 5000 # number of training epochs settings['neg_samp'] = 5 # number of negative words to use during training settings['learning_rate'] = 0.1 # learning rate settings['model'] = 'skipgram' # cbow or skipgram np.random.seed(0) # set the seed for reproducibility corpus = [['A', 'dog', 'is', 'running', 'in', 'the', 'room'], ['A', 'cat', 'is', 'running', 'in', 'the', 'room']] # corpus = [] # corpus = [['natural', 'language', 'processing', 'and', 'machine', 'learning', 'is', 'fun', 'and', 'exciting']] # I like playing football with my friends w2v = word2vec(settings) # 生成训练数据 training_data = w2v.generate_training_data(corpus) # print(training_data) # 训练 w2v.train(training_data, debug=True) for w1 in w2v.word_index.keys(): for w2 in w2v.word_index.keys(): print("%s & %s similarity is %s" % (w1, w2, cos_similarity(w2v.word_2_vec(w1), w2v.word_2_vec(w2)))) vecs = np.array([w2v.word_2_vec(vec) for vec in w2v.word_index.keys()]) import matplotlib.pyplot as plt plt.scatter(vecs[:, 0], vecs[:, 1]) words = list(w2v.word_index.keys()) for i, word in enumerate(words): plt.annotate(word, xy=(vecs[i, 0], vecs[i, 1])) plt.show()

至此我们知道了word2vec的原理和代码实现，但训练效率低是它的一个缺点，在下篇文章将会介绍两种优化的方法。

参考

Word2vec from Scratch with Python and NumPyword2vec Parameter Learning Explained自然语言处理与词嵌入