本着“凡我不能创造的,我就不能理解”的思想,本系列文章会基于纯Python以及NumPy从零创建自己的深度学习框架,该框架类似PyTorch能实现自动求导。
要深入理解深度学习,从零开始创建的经验非常重要,从自己可以理解的角度出发,尽量不使用外部完备的框架前提下,实现我们想要的模型。本系列文章的宗旨就是通过这样的过程,让大家切实掌握深度学习底层实现,而不是仅做一个调包侠。
本文从共现矩阵到点互信息和奇异值分解,介绍了分布式单词表示法。
共现矩阵共现矩阵(co-occurrence matrix)是一种表示单词共现频率的方式。我们来看两个常用的矩阵:term-document矩阵和term-term矩阵。
term-document 矩阵在该矩阵中,每行表示词汇表中的一个单词,每列表示一个文档。下表显示了一个term-document矩阵中的一个子集,显示了莎士比亚的四个剧本中出现的四个单词。矩阵中的每个单元格表示特定的单词(行)在特定文档(列)中出现的次数。
| As You Like It | Twelfth Night | Julius Caesar | Henry V | |
|---|---|---|---|---|
| battle | 1 | 0 | 7 | 13 |
| good | 114 color{red}114 114 | 80 | 62 | 89 |
| fool | 36 | 58 | 1 | 4 |
| wit | 20 | 15 | 2 | 3 |
比如上面的 114 114 114,表示单词good在剧本(文档)As You Like It中出现了114次。
这种矩阵有什么用呢?其实常用于信息检索中,作为其向量空间模型的一部分。比如,一个文档可以由上表中的列向量表示。
| As You Like It | Twelfth Night | Julius Caesar | Henry V | |
|---|---|---|---|---|
| battle | 1 color{red}1 1 | 0 color{blue}0 0 | 7 color{green}7 7 | 13 color{black}13 13 |
| good | 114 color{red}114 114 | 80 color{blue}80 80 | 62 color{green}62 62 | 89 color{black}89 89 |
| fool | 36 color{red}36 36 | 58 color{blue}58 58 | 1 color{green}1 1 | 4 color{black}4 4 |
| wit | 20 color{red}20 20 | 15 color{blue}15 15 | 2 color{green}2 2 | 3 color{black}3 3 |
这里我们列向量的维度为 4 4 4。
这里单词作为有意义的维度,比如As You Like It和Twelfth Night在维度battle上比较接近。
如果两个文档在大多数维度上越接近,那么它们就越相似。
在实际的term-document矩阵中,每个列向量的维度为词汇表大小 ∣ V ∣ |V| ∣V∣。为了方便可视化,我们选择了两个维度(行),如下图所示:
可以看到,Henry V和Julius Caesar两者很接近;而As You Like It和Twelfth Night很接近。实际上,我们可以通过余弦公式来计算这些向量的相似度。
上面我们是把行(单词)看成维度,得到文档向量。那如果换一个角度,把列(文档)看成维度,不就可以得到单词向量了吗?
| As You Like It | Twelfth Night | Julius Caesar | Henry V | |
|---|---|---|---|---|
| battle | 1 color{blue}1 1 | 0 color{blue}0 0 | 7 color{blue}7 7 | 13 color{blue}13 13 |
| good | 114 color{red}114 114 | 80 color{red}80 80 | 62 color{red}62 62 | 89 color{red}89 89 |
| fool | 36 color{green}36 36 | 58 color{green}58 58 | 1 color{green}1 1 | 4 color{green}4 4 |
| wit | 20 color{black}20 20 | 15 color{black}15 15 | 2 color{black}2 2 | 3 color{black}3 3 |
相似的单词也有相似的向量,因为它们往往出现在相似的文档中。
term-term矩阵除了使用term-document来表示单词向量外,还有一种方法是使用term-term矩阵,又称为word-word矩阵、term-context矩阵。该矩阵中的列也是单词,而不是文档。因此,该矩阵的维数为 ∣ V ∣ × ∣ V ∣ |V| times |V| ∣V∣×∣V∣。
那么要怎么表示呢?它需要在上下文内统计两个单词一起出现的次数,而上下文是由上下文窗口来定义的,通过该窗口来定义上下文的范围。
当然,也可以将整个文档当成上下文,那么单元格表示两个单词在同一个文档中出现的次数。但最常见的还是使用较小的上下文。比如,假设窗口大小为 4 4 4,那么某个单词左边 4 4 4个单词,加右边 4 4 4个单词的范围作为一个上下文。
举个例子,假设语料库中有以下三句话:
我 喜欢 自然 语言 处理 。 我 爱 深度 学习 。 我 喜欢 机器 学习 。
假设以词所在句子(文档)作为上下文=
从上面的句子中,可以得到词汇表:
[ '我', '喜欢', '自然', '语言', '处理', '爱', '深度', '学习', '机器', '。']
那么可以计算出共现矩阵为:
| 我 | 喜欢 | 自然 | 语言 | 处理 | 爱 | 深度 | 学习 | 机器 | 。 | |
|---|---|---|---|---|---|---|---|---|---|---|
| 我 | 0 | 2 | 1 | 1 | 1 | 1 | 1 | 2 | 1 | 3 |
| 喜欢 | 2 | 0 | 1 | 1 | 1 | 0 | 0 | 1 | 1 | 2 |
| 自然 | 1 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 1 |
| 语言 | 1 | 1 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 1 |
| 处理 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 |
| 爱 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 |
| 深度 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 1 |
| 学习 | 2 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 2 |
| 机器 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 |
| 。 | 3 | 2 | 1 | 1 | 1 | 1 | 1 | 2 | 1 | 0 |
通过计算两个向量之间的余弦相似度,可以得到两个单词之间的相似度。比如“喜欢”和“爱”,由于有共同的上下文“我”和“学习”,使得它们之间具有一定的相似性。
不过,这种共现矩阵存在一些问题:
- 高频词误导计算结果。比如“我”和“。”与其他词的共现频次都很高,导致实际没有关系的两个词,产生较高的相似度。
- 共现频次无法反映词之间的高阶关系。比如“A”和“B”共现过;“B”和“C”共现过;“C”和“D”共现过。通过共现频次,只能得知“A”和“C”都与“B”共现过,而“A”与“D”这种高阶的关系则无法知晓。
- 存在稀疏性问题。如我们所见,向量中存在大量的零。
下面分别介绍如何通过点互信息和奇异值分解两种技术来解决这些问题。
点互信息先看如何解决高频词误导计算结果的问题。最直接的想法是:如果某个词与很多次共现,那么降低它的权重;反之,如果某个词只与个别词共现,那么提高它的权重。
信息论中的点互信息(Pointwise Mutual Information,PMI)恰好能做到这一点,它衡量两个事件发生的频率,并与我们预期的两个事件是独立的进行比较。
对于单词
w
w
w和上下文
c
c
c,则PMI为:
PMI
(
w
,
c
)
=
log
2
P
(
w
,
c
)
P
(
w
)
P
(
c
)
(1)
text{PMI}(w,c) =log_2 frac{P(w,c)}{P(w)P(c)} tag 1
PMI(w,c)=log2P(w)P(c)P(w,c)(1)
其中
P
(
w
,
c
)
P(w,c)
P(w,c)、
P
(
w
)
P(w)
P(w)和
P
(
c
)
P(c)
P(c)分别代表
w
w
w与
c
c
c的共现概率;
w
w
w出现的概率;
c
c
c出现的概率。分子告诉我们观察到这两个单词在一起出现的概率;分母告诉我们,假设这两个单词都独立出现,我们期望它们同时出现的概率。
如果 w w w和 c c c的共现概率较高,但是 w w w或 c c c出现的概率也较高,则最终的PMI值会变小;反之,即使 w w w和 c c c的共现概率不高,但是 w w w或 c c c出现的概率较低,则最终的PMI值也可能会比较大。这样,解决了高频词误导计算结果的问题。
通过最大似然估计,可以计算相关的概率值。假设我们有一个
W
W
W行(单词),
C
C
C列(上下文)的共现矩阵
M
M
M,其中
m
i
j
m_{ij}
mij代表单词
w
i
w_i
wi与上下文
c
j
c_j
cj在语料库中的共现频次。这可以转换为一个PMI矩阵,其中
PMI
i
j
text{PMI}_{ij}
PMIij代表单词
w
i
w_i
wi上下文
c
j
c_j
cj的PMI值:
P
(
w
,
c
)
=
P
i
j
=
m
i
j
∑
i
=
1
W
∑
j
=
1
C
m
i
j
(2)
P(w,c) = P_{ij} = frac{m_{ij}}{sum_{i=1}^W sum_{j=1}^C m_{ij}} tag 2
P(w,c)=Pij=∑i=1W∑j=1Cmijmij(2)
P ( w ) = P i ∗ = ∑ j = 1 C m i j ∑ i = 1 W ∑ j = 1 C m i j (3) P(w) = P_{i*} = frac{sum_{j=1}^C m_{ij}}{sum_{i=1}^W sum_{j=1}^C m_{ij}} tag 3 P(w)=Pi∗=∑i=1W∑j=1Cmij∑j=1Cmij(3)
P ( c ) = P ∗ j = ∑ i = 1 W m i j ∑ i = 1 W ∑ j = 1 C m i j (4) P(c) = P_{*j} = frac{sum_{i=1}^W m_{ij}}{sum_{i=1}^W sum_{j=1}^C m_{ij}} tag 4 P(c)=P∗j=∑i=1W∑j=1Cmij∑i=1Wmij(4)
其中,
∑ j = 1 C m i j sum_{j=1}^C m_{ij} ∑j=1Cmij为term-term共现矩阵按行求和;
∑ i = 1 W sum_{i=1}^W ∑i=1W为term-term共现矩阵按列求和;
∑ i = 1 W ∑ j = 1 C m i j sum_{i=1}^W sum_{j=1}^C m_{ij} ∑i=1W∑j=1Cmij为全部共现频次的和。
代入上面三个公式,公式
(
1
)
(1)
(1)可以写成:
PMI
(
w
,
c
)
=
log
2
P
(
w
,
c
)
P
(
w
)
P
(
c
)
=
log
2
m
i
j
∑
i
=
1
W
∑
j
=
1
C
m
i
j
∑
j
=
1
C
m
i
j
∑
i
=
1
W
∑
j
=
1
C
m
i
j
∑
i
=
1
W
m
i
j
∑
i
=
1
W
∑
j
=
1
C
m
i
j
=
log
2
m
i
j
∑
j
=
1
C
m
i
j
∑
i
=
1
W
m
i
j
∑
i
=
1
W
∑
j
=
1
C
m
i
j
(5)
begin{aligned} text{PMI}(w,c) &= log_2 frac{P(w,c)}{P(w)P(c)} \ &= log_2 frac{frac{m_{ij}}{sum_{i=1}^W sum_{j=1}^C m_{ij}} }{ frac{sum_{j=1}^C m_{ij}}{sum_{i=1}^W sum_{j=1}^C m_{ij}} frac{sum_{i=1}^W m_{ij}}{sum_{i=1}^W sum_{j=1}^C m_{ij}} } \ &= log_2 frac{m_{ij} }{ frac{sum_{j=1}^C m_{ij} sum_{i=1}^W m_{ij}}{sum_{i=1}^W sum_{j=1}^C m_{ij}} } end{aligned} tag{5}
PMI(w,c)=log2P(w)P(c)P(w,c)=log2∑i=1W∑j=1Cmij∑j=1Cmij∑i=1W∑j=1Cmij∑i=1Wmij∑i=1W∑j=1Cmijmij=log2∑i=1W∑j=1Cmij∑j=1Cmij∑i=1Wmijmij(5)
当某个词与上下文之间的共现次数较低时,可能会得到负PMI值。这种情况会导致较大的方差,因此在实际应用中通常采用PPMI(Positive PMI)的形式,即:
PPMI
(
w
,
c
)
=
max
(
PMI
(
w
,
c
)
,
0
)
(6)
text{PPMI}(w,c) = max(text{PMI}(w,c) , 0) tag 6
PPMI(w,c)=max(PMI(w,c),0)(6)
下面通过代码来实现一下。将上面例子中的共现频次定义为共现矩阵的形式。然后编写如下代码计算PPMI:
import numpy as np
# 上面例子中的共现矩阵
M = np.array([[0, 2, 1, 1, 1, 1, 1, 2, 1, 3],
[2, 0, 1, 1, 1, 0, 0, 1, 1, 2],
[1, 1, 0, 1, 1, 0, 0, 0, 0, 1],
[1, 1, 1, 0, 1, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 1, 1, 0, 1],
[1, 0, 0, 0, 0, 1, 0, 1, 0, 1],
[2, 1, 0, 0, 0, 1, 1, 0, 1, 2],
[1, 1, 0, 0, 0, 0, 0, 1, 0, 1],
[3, 2, 1, 1, 1, 1, 1, 2, 1, 0]])
def pmi(M, positive=True):
# 按行求和
col_totals = M.sum(axis=0)
# 按列求和
row_totals = M.sum(axis=1)
# 全部频次的和
total = col_totals.sum()
# 计算公式(5)中的分母
expected = np.outer(row_totals, col_totals) / total
# 公式(5)中的分子除以分母
M = M / expected
# 不显示log(0)的告警
with np.errstate(divide='ignore'):
M = np.log(M) # 取对数
# 把log(0)转换为0
M[np.isinf(M)] = 0.0 # log(0) = 0
# 支持PPMI
if positive:
M[M < 0] = 0.0
return M
M_pmi = pmi(M)
# 设置显示精度为2
np.set_printoptions(precision=2)
print(M_pmi)
[[0. 0.18 0.07 0.07 0.07 0.3 0.3 0.3 0.3 0.22] [0.18 0. 0.44 0.44 0.44 0. 0. 0. 0.66 0.18] [0.07 0.44 0. 1.03 1.03 0. 0. 0. 0. 0.07] [0.07 0.44 1.03 0. 1.03 0. 0. 0. 0. 0.07] [0.07 0.44 1.03 1.03 0. 0. 0. 0. 0. 0.07] [0.3 0. 0. 0. 0. 0. 1.48 0.78 0. 0.3 ] [0.3 0. 0. 0. 0. 1.48 0. 0.78 0. 0.3 ] [0.3 0. 0. 0. 0. 0.78 0.78 0. 0.78 0.3 ] [0.3 0.66 0. 0. 0. 0. 0. 0.78 0. 0.3 ] [0.22 0.18 0.07 0.07 0.07 0.3 0.3 0.3 0.3 0. ]]奇异值分解
下面来看奇异值分解(Singular Value Decomposition,SVD),用于解决共现频次无法反映词之间高阶关系的问题。奇异值分解是一种常见的做法。
对共现矩阵
M
M
M进行奇异值分解:
M
=
U
Σ
V
T
(7)
M = USigma V^T tag 7
M=UΣVT(7)
其中,
U
∈
R
∣
V
∣
×
r
U in Bbb R^{|Bbb V | times r}
U∈R∣V∣×r,
V
∈
R
r
×
∣
C
∣
V in Bbb R^{rtimes |Bbb C| }
V∈Rr×∣C∣为正交矩阵,满足
U
T
U
=
V
T
V
=
I
U^TU=V^TV=I
UTU=VTV=I;
Σ ∈ R r × r Sigma in Bbb R^{r times r} Σ∈Rr×r,是由 r r r个奇异值构成的对角矩阵。
若在
Σ
Sigma
Σ中仅保留
d
d
d(
d
<
r
d < r
d 通过截断奇异值分解所得到的的矩阵
U
U
U中的每一行,则为相应词的
d
d
d维向量表示,该向量具有连续、低维和稠密的性质。由于
U
U
U的各列相互正交,因此可认为词表示的每一维表达了该词的一种独立的“潜在语义”,所以这种做法也称为潜在语义分析。相应地,
Σ
V
T
Sigma V^T
ΣVT的每一列也可以作为相应上下文的向量表示。 看上去不好理解,需要很强的线性代数知识。我们连看一个实例吧。 NumPy内置了SVD函数,只有输入共现矩阵,调用此函数即可。并且进行可视化: 虽然这些方法得到的词的分布取得了不错的效果,但是仍然存在一些问题。 为了解决这些问题,我们需要一种新的词表示方式——词嵌入表示。且看下文分析。import matplotlib.pyplot as plt
U, s, Vh = np.linalg.svd(M_pmi)
words = [ '我', '喜欢', '自然', '语言', '处理', '爱', '深度', '学习', '机器', '。']
plt.xlim(0, 0.6)
plt.ylim(-0.5, 0.6)
for i in range(len(words)):
plt.text(U[i, 0], U[i, 1], words[i], fontproperties=zhfont)
plt.show()



