文本表示角度

统计模型

文本切分

在中文和拉丁语系中，文本的直观表示就存在一定的差异，拉丁语系中词与词之间存在天然的分隔符，而中文则没有。

I can eat glass, it doesn’t hurt me.
我能吞下玻璃而不伤身体。

因此针对拉丁语系的文本切分相对中文容易许多。

• N 元语法

N-gram (N 元语法) 是一种文本表示方法，指文中连续出现的 $n$ 个词语。N-gram 模型是基于 $n-1$ 阶马尔科夫链的一种概率语言模型，可以通过前 $n-1$ 个词对第 $n$ 个词进行预测。以 南京市长江大桥 为例，N-gram 的表示如下：

一元语法（unigram）：南/京/市/长/江/大/桥
二元语法（bigram）：南京/京市/市长/长江/江大/大桥
三元语法（trigram）：南京市/京市长/市长江/长江大/江大桥

import re
from nltk.util import ngrams

s = '南京市长江大桥'
tokens = re.sub(r'\s', '', s)

list(ngrams(tokens, 1))
# [('南',), ('京',), ('市',), ('长',), ('江',), ('大',), ('桥',)]

list(ngrams(tokens, 2))
# [('南', '京'), ('京', '市'), ('市', '长'),
#  ('长', '江'), ('江', '大'), ('大', '桥')]

list(ngrams(tokens, 3, pad_left=True, pad_right=True, left_pad_symbol='<s>', right_pad_symbol='</s>'))
# [('<s>', '<s>', '南'),
#  ('<s>', '南', '京'),
#  ('南', '京', '市'),
#  ('京', '市', '长'),
#  ('市', '长', '江'),
#  ('长', '江', '大'),
#  ('江', '大', '桥'),
#  ('大', '桥', '</s>'),
#  ('桥', '</s>', '</s>')]

• 分词

分词就是将连续的字序列按照一定的规范重新组合成词序列的过程。在英文的行文中，单词之间是以空格作为自然分界符的，而中文只是字、句和段能通过明显的分界符来简单划界，唯独词没有一个形式上的分界符，虽然英文也同样存在短语的划分问题，不过在词这一层上，中文比之英文要复杂得多、困难得多。

s = '南京市长江大桥'

# jieba
# https://github.com/fxsjy/jieba
import jieba

list(jieba.cut(s, cut_all=False))
# ['南京市', '长江大桥']

list(jieba.cut(s, cut_all=True))
# ['南京', '南京市', '京市', '市长', '长江', '长江大桥', '大桥']

list(jieba.cut_for_search(s))
# ['南京', '京市', '南京市', '长江', '大桥', '长江大桥']

# THULAC
# https://github.com/thunlp/THULAC-Python
import thulac

thulac_ins = thulac.thulac()

thulac_ins.cut(s)
# [['南京市', 'ns'], ['长江', 'ns'], ['大桥', 'n']]

# PKUSEG
# https://github.com/lancopku/PKUSeg-python
import pkuseg

seg = pkuseg.pkuseg(postag=True)

seg.cut(s)
# [('南京市', 'ns'), ('长江', 'ns'), ('大桥', 'n')]

# HanLP
# https://github.com/hankcs/HanLP
import hanlp

tokenizer = hanlp.load('LARGE_ALBERT_BASE')

tokenizer(s)
# ['南京市', '长江', '大桥']

主题模型

除了对文本进行切分将切分后结果全部用于表示文本外，还可以用部分字词表示一篇文档。主题模型（Topic Model）在机器学习和自然语言处理等领域是用来在一系列文档中发现抽象主题的一种统计模型。

直观来讲，如果一篇文章有一个中心思想，那么一些特定词语会更频繁的出现。比方说，如果一篇文章是在讲狗的，那“狗”和“骨头”等词出现的频率会高些。如果一篇文章是在讲猫的，那“猫”和“鱼”等词出现的频率会高些。而有些词例如“这个”、“和”大概在两篇文章中出现的频率会大致相等。但真实的情况是，一篇文章通常包含多种主题，而且每个主题所占比例各不相同。因此，如果一篇文章 10% 和猫有关，90% 和狗有关，那么和狗相关的关键字出现的次数大概会是和猫相关的关键字出现次数的 9 倍。

一个主题模型试图用数学框架来体现文档的这种特点。主题模型自动分析每个文档，统计文档内的词语，根据统计的信息来断定当前文档含有哪些主题，以及每个主题所占的比例各为多少 ¹。

• TF-IDF

TF-IDF 是 Term Frequency - Inverse Document Frequency 的缩写，即“词频-逆文本频率”。TF-IDF 可以用于评估一个字词在语料中的一篇文档中的重要程度，基本思想是如果某个字词在一篇文档中出现的频率较高，而在其他文档中出现频率较低，则认为这个字词更能够代表这篇文档。

形式化地，对于文档 $y$ 中的字词 $x$ 的 TF-IDF 重要程度可以表示为：

$$ w_{x, y} = tf_{x, y} \times \log \left(\dfrac{N}{df_{x}}\right) $$

其中，$tf_{x, y}$ 表示字词 $x$ 在文档 $y$ 中出现的频率，$df_x$ 为包含字词 $x$ 的文档数量，$N$ 为语料中文档的总数量。

以 14 万歌词语料 为例，通过 TF-IDF 计算周杰伦的《简单爱》中最重要的 3 个词为 ['睡着', '放开', '棒球']。

• BM25

BM25 算法的全称为 Okapi BM25，是一种搜索引擎用于评估查询和文档之间相关程度的排序算法，其中 BM 是 Best Match 的缩写。

对于一个给定的查询 $Q$，包含的关键词为 $q_1, \cdots, q_n$，一个文档 $D$ 的 BM25 值定义为：

$$ \operatorname{score}(D, Q)=\sum_{i=1}^{n} \operatorname{IDF}\left(q_{i}\right) \cdot \frac{f\left(q_{i}, D\right) \cdot\left(k_{1}+1\right)}{f\left(q_{i}, D\right)+k_{1} \cdot\left(1-b+b \cdot \frac{|D|}{\text { avgdl }}\right)} $$

其中，$f\left(q_{i}, D\right)$ 表示 $q_i$ 在文档 $D$ 中的词频，$|D|$ 表示文档 $D$ 中的词数，$\text{avgdl}$ 表示语料中所有文档的平均长度。$k_1$ 和 $b$ 为自由参数，通常取值为 $k_1 \in \left[1.2, 2.0\right], b = 0.75$ ²。$\operatorname{IDF} \left(q_i\right)$ 表示词 $q_i$ 的逆文档频率，通常计算方式如下：

$$ \operatorname{IDF}\left(q_{i}\right)=\ln \left(\frac{N-n\left(q_{i}\right)+0.5}{n\left(q_{i}\right)+0.5}+1\right) $$

其中，$N$ 为语料中文档的总数量，$n \left(q_i\right)$ 表示包含 $q_i$ 的文档数量。

BM25 算法是对 TF-IDF 算法的优化，在词频的计算上，BM25 限制了文档 $D$ 中关键词 $q_i$ 的词频对评分的影响。为了防止词频过大，BM25 将这个值的上限设置为 $k_1 + 1$。

同时，BM25 还引入了平均文档长度 $\text{avgdl}$，不同的平均文档长度 $\text{avgdl}$ 对 TF 分值的影响如下图所示：

• TextRank

TextRank ³ 是基于 PageRank ⁴ 算法的一种关键词提取算法。PageRank 最早是用于 Google 的网页排名，因此以公司创始人拉里·佩奇（Larry Page）的姓氏来命名。PageRank 的计算公式如下：

$$ S\left(V_{i}\right)=(1-d)+d * \sum_{V_{j} \in I n\left(V_{i}\right)} \frac{1}{\left|O u t\left(V_{j}\right)\right|} S\left(V_{j}\right) $$

其中，$V_i$ 表示任意一个网页，$V_j$ 表示链接到网页 $V_i$ 的网页，$S \left(V_i\right)$ 表示网页 $V_i$ 的 PageRank 值，$In \left(V_i\right)$ 表示网页 $V_i$ 所有的入链集合，$Out \left(V_j\right)$ 表示网页 $V_j$ 所有的出链集合，$|\cdot|$ 表示集合的大小，$d$ 为阻尼系数，是为了确保每个网页的 PageRank 值都大于 0。

TextRank 由 PageRank 改进而来，计算公式如下：

$$ WS \left(V_{i}\right)=(1-d)+d * \sum_{V_{j} \in In\left(V_{i}\right)} \frac{w_{j i}}{\sum_{V_{k} \in Out\left(V_{j}\right)} w_{j k}} WS \left(V_{j}\right) $$

相比于 PageRank 公式增加了权重项 $W_{ji}$，用来表示两个节点之间的边的权重。TextRank 提取关键词的算法流程如下：

1. 将文本进行切分得到 $S_i = \left[t_{i1}, t_{i2}, \cdots, t_{in}\right]$。
2. 将 $S_i$ 中大小为 $k$ 的滑动窗口中的词定义为共现关系，构建关键词图 $G = \left(V, E\right)$。
3. 根据 TextRank 的计算公式对每个节点的值进行计算，直至收敛。
4. 对节点的 TextRank 的值进行倒叙排序，获取前 $n$ 个词作为关键词。

• LSA, PLSA, LDA & HDP

潜在语义分析（LSA, Latent Semantic Analysis）⁵ 的核心思想是将文本的高维词空间映射到一个低维的向量空间，我们称之为隐含语义空间。降维可以通过奇异值分解（SVD）实现，令 $X$ 表示语料矩阵，元素 $\left(i, j\right)$ 表示词 $i$ 和文档 $j$ 的共现情况（例如：词频）：

$$ X = \mathbf{d}_{j} \cdot \mathbf{t}_{i}^{T} = \left[\begin{array}{c} x_{1, j} \\ \vdots \\ x_{i, j} \\ \vdots \\ x_{m, j} \end{array}\right] \cdot \left[\begin{array}{ccccc} x_{i, 1} & \ldots & x_{i, j} & \ldots & x_{i, n} \end{array}\right] = \left[\begin{array}{ccccc} x_{1,1} & \ldots & x_{1, j} & \ldots & x_{1, n} \\ \vdots & \ddots & \vdots & \ddots & \vdots \\ x_{i, 1} & \ldots & x_{i, j} & \ldots & x_{i, n} \\ \vdots & \ddots & \vdots & \ddots & \vdots \\ x_{m, 1} & \ldots & x_{m, j} & \ldots & x_{m, n} \end{array}\right] $$

利用奇异值分解：

$$ X = U \Sigma V^{T} $$

取最大的 $K$ 个奇异值，则可以得到原始矩阵的近似矩阵：

$$ \widetilde{X} =U \widetilde{\Sigma} V^{T} $$

在处理一个新的文档时，可以利用下面的公式将原始的词空间映射到潜在语义空间：

$$ \tilde{x} =\tilde{\Sigma} ^{-1} V^{T} x_{test} $$

LSA 的优点：

1. 低维空间可以刻画同义词
2. 无监督模型
3. 降维可以减少噪声，使特征更加鲁棒

LSA 的缺点：

1. 未解决多义词问题
2. 计算复杂度高，增加新文档时需要重新训练
3. 没有明确的物理解释
4. 高斯分布假设不符合文本特征（词频不为负）
5. 维度的确定是 Ad hoc 的

概率潜语义分析（Probabilistic Latent Semantic Analysis, PLSA）⁶ 相比于 LSA 增加了概率模型，每个变量以及相应的概率分布和条件概率分布都有明确的物理解释。

PLSA 认为一篇文档可以由多个主题混合而成，而每个主题都是词上的概率分布，文章中的每个词都是由一个固定的主题生成的，如下图所示：

针对第 $m$ 篇文档 $d_m$ 中的每个词的生成概率为：

$$ p\left(w \mid d_{m}\right)=\sum_{z=1}^{K} p(w \mid z) p\left(z \mid d_{m}\right)=\sum_{z=1}^{K} \varphi_{z w} \theta_{m z} $$

因此整篇文档的生成概率为：

$$ p\left(\vec{w} \mid d_{m}\right)=\prod_{i=1}^{n} \sum_{z=1}^{K} p\left(w_{i} \mid z\right) p\left(z \mid d_{m}\right)=\prod_{i=1}^{n} \sum_{z=1}^{K} \varphi_{z w_{i}} \theta_{d z} $$

PLSA 可以利用 EM 算法求得局部最优解。

PLSA 优点：

1. 定义了概率模型，有明确的物理解释
2. 多项式分布假设更加符合文本特征
3. 可以通过模型选择和复杂度控制来确定主题的维度
4. 解决了同义词和多义词的问题

PLSA 缺点：

1. 随着文本和词的增加，PLSA 模型参数也随之线性增加
2. 可以生成语料中的文档的模型，但不能生成新文档的模型
3. EM 算法求解的计算量较大

隐含狄利克雷分布（Latent Dirichlet Allocation, LDA）⁷ 在 PLSA 的基础上增加了参数的先验分布。在 PLSA 中，对于一个新文档，是无法获取 $p \left(d\right)$ 的，因此这个概率模型是不完备的。LDA 对于 $\vec{\theta}_m$ 和 $\vec{\phi}_k$ 都增加了多项式分布的共轭分布狄利克雷分布作为先验，整个 LDA 模型如下图所示：

LDA 的参数估计可以通过吉布斯采样实现。PLSA 和 LDA 的更多细节请参见《LDA 数学八卦》⁸。

LDA 在使用过程中仍需要指定主题的个数，而层次狄利克雷过程（Hierarchical Dirichlet Processes, HDP）⁹ 通过过程的构造可以自动训练出主题的个数，更多实现细节请参考论文。

LSA，PLSA，LDA 和 HDP 之间的演化关系如下图所示：

本节相关代码详见 这里。

距离度量

本节内容源自 相似性和距离度量 (Similarity & Distance Measurement)。

相似性度量 (Similarity Measurement) 用于衡量两个元素之间的相似性程度或两者之间的距离 (Distance)。距离衡量的是指元素之间的不相似性 (Dissimilarity)，通常情况下我们可以利用一个距离函数定义集合 $X$ 上元素间的距离，即：

$$ d: X \times X \to \mathbb{R} $$

• Jaccard 系数

$$ s = \dfrac{\left|X \cap Y\right|}{\left| X \cup Y \right|} = \dfrac{\left|X \cap Y\right|}{\left|X\right| + \left|Y\right| - \left|X \cap Y\right|} $$

Jaccard 系数的取值范围为：$\left[0, 1\right]$，0 表示两个集合没有重合，1 表示两个集合完全重合。

• Dice 系数

$$ s = \dfrac{2 \left| X \cap Y \right|}{\left|X\right| + \left|Y\right|} $$

与 Jaccard 系数相同，Dice 系数的取值范围为：$\left[0, 1\right]$，两者之间可以相互转换 $s_d = 2 s_j / \left(1 + s_j\right), s_j = s_d / \left(2 - s_d\right)$。不同于 Jaccard 系数，Dice 系数的差异函数 $d = 1 - s$ 并不是一个合适的距离度量，因为其并不满足距离函数的三角不等式。

• Tversky 系数

$$ s = \dfrac{\left| X \cap Y \right|}{\left| X \cap Y \right| + \alpha \left| X \setminus Y \right| + \beta \left| Y \setminus X \right|} $$

其中，$X \setminus Y$ 表示集合的相对补集。Tversky 系数可以理解为 Jaccard 系数和 Dice 系数的一般化，当 $\alpha = \beta = 1$ 时为 Jaccard 系数，当 $\alpha = \beta = 0.5$ 时为 Dice 系数。

• Levenshtein 距离

Levenshtein 距离是 编辑距离 (Editor Distance) 的一种，指两个字串之间，由一个转成另一个所需的最少编辑操作次数。允许的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。例如将 kitten 转成 sitting，转换过程如下：

$$ \begin{equation*} \begin{split} \text{kitten} \to \text{sitten} \left(k \to s\right) \\ \text{sitten} \to \text{sittin} \left(e \to i\right) \\ \text{sittin} \to \text{sitting} \left(\ \to g\right) \end{split} \end{equation*} $$

编辑距离的求解可以利用动态规划的思想优化计算的时间复杂度。

• Jaro-Winkler 距离

对于给定的两个字符串 $s_1$ 和 $s_2$，Jaro 相似度定义为：

$$ sim = \begin{cases} 0 & \text{if} \ m = 0 \\ \dfrac{1}{3} \left(\dfrac{m}{\left|s_1\right|} + \dfrac{m}{\left|s_2\right|} + \dfrac{m-t}{m}\right) & \text{otherwise} \end{cases} $$

其中，$\left|s_i\right|$ 为字符串 $s_i$ 的长度，$m$ 为匹配的字符的个数，$t$ 换位数目的一半。如果字符串 $s_1$ 和 $s_2$ 相差不超过 $\lfloor \dfrac{\max \left(\left|s_1\right|, \left|s_2\right|\right)}{2} \rfloor - 1$，我们则认为两个字符串是匹配的。例如，对于字符串 CRATE 和 TRACE，仅 R, A, E 三个字符是匹配的，因此 $m = 3$，尽管 C, T 均出现在两个字符串中，但是他们的距离超过了 1 (即，$\lfloor \dfrac{5}{2} \rfloor - 1$)，因此 $t = 0$。

Jaro-Winkler 相似度给予了起始部分相同的字符串更高的分数，其定义为：

$$ sim_w = sim_j + l p \left(1 - sim_j\right) $$

其中，$sim_j$ 为字符串 $s_1$ 和 $s_2$ 的 Jaro 相似度，$l$ 为共同前缀的长度 (规定不超过 $4$)，$p$ 为调整系数 (规定不超过 $0.25$)，Winkler 将其设置为 $p = 0.1$。

• 汉明距离

汉明距离为两个等长字符串对应位置的不同字符的个数，也就是将一个字符串变换成另外一个字符串所需要替换的字符个数。例如：1011101 与 1001001 之间的汉明距离是 2，“toned” 与 “roses” 之间的汉明距离是 3。

import textdistance as td

s1 = '南京市长江大桥'
s2 = '北京市三元桥'

td.jaccard(s1, s2)
# 0.6666666666666666

td.sorensen_dice(s1, s2)
# 0.46153846153846156

td.tversky(s1, s2)
# 0.3

td.levenshtein(s1, s2)
# 4

td.jaro(s1, s2)
# 0.6428571428571429

td.hamming(s1, s2)
# 5

表示学习

基于表示学习的文本相似度计算方法的思路如下：

1. 利用表示学习方法将不定长的文本表示为定长的实值向量。
2. 计算转换后的实值向量相似度，用于表示两个文本的相似度。

关于文本表示学习和实值向量相似度计算请参见之前博客：词向量 (Word Embeddings)，相似性和距离度量 (Similarity & Distance Measurement)，预训练自然语言模型 (Pre-trained Models for NLP)。

文本词法，句法和语义角度

本节主要参考自《基于词法、句法和语义的句子相似度计算方法》¹⁰。

一段文本的内容分析由浅及深可以分为词法，句法和语义三个层次。

1. 词法，以词为对象，研究包括分词，词性和命名实体等。
2. 句法，以句子为对象，研究包括句子成分和句子结构等。
3. 语义，研究文字所表达的含义和蕴含的知识等。

词法和句法可以统一成为语法，如下图所示：

词法

词法层以单个句子作为输入，其输出为已标记（词性，命名实体等）的词汇序列。

词汇序列的相似度计算可以采用上文中的距离度量等方式实现。

句法

句法层用于研究句子各个组成部分及其排列顺序，将文本分解为句法单位，以理解句法元素的排列方式。句法层接收词法层分析后的将其转化为依存图。

对于依存图，我们可以利用三元组 $S = \left(V_1, E, V_2\right)$ 表示任意一个依存关系，然后通过统计计算两个文本的依存图的三元组集合之间的相似度来评价句法层的相似度。此外，也可以从树结构的角度直接评价依存句法的相似度，更多细节可参考相关论文 ^{11 12}。

语义

语义层用于研究文本所蕴含的意义。例如“父亲”和“爸爸”在词法层完全不同，但在语义层却具有相同的含义。针对语义相似度的两种深度学习范式如下：

第一种范式首先通过神经网络获取文本的向量表示，再通过向量之间的相似度来衡量文本的语义相似度。这种范式在提取特征时不考虑另一个文本的信息，更适合做大规模的语义相似召回，例如：DSSM ¹³，ARC-I ¹⁴，CNTN ¹⁵，LSTM-RNN ¹⁶ 等。

第二种范式首先通过深度模型提取两个文本的交叉特征，得到匹配信号张量，再聚合为匹配分数。这种范式同时考虑两个文本的输入信息，更适合做小规模的语义相似精排，例如：ARC-II ¹⁴，MatchPyramid ¹⁷，Match-SRNN ¹⁸，Duet ¹⁹ 等。

文本长度角度

从文本长度角度出发，我们可以粗略的将文本分类为短文本和长文本。短文本包括“字词”，“短语”，“句子”等相对比较短的文本形式，长文本包括“段落”，“篇章”等相对比较长的文本形式。

短文本 v.s. 短文本

短文本同短文本的常见比较形式有：关键词（字词）同文本标题（句子）的匹配，相似查询（句子）的匹配等。如果单纯的希望获取字符层面的差异，可以通过距离度量进行相似度比较。如果需要从语义的角度获取相似度，则可以利用表示学习对需要比对的文本进行表示，在通过语义向量之间的相似程度来衡量原始文本之间的相似度，详情可参见上文。

短文本 v.s. 长文本

短文本同长文本的比较多见于文档的搜索，即给定相关的查询（字词），给出最相关的文档（段落和篇章）。对于这类问题常见的解决方式是对长文本利用 TF-IDF，BM25等方法或进行主题建模后，再同查询的关键词进行匹配计算相似度度。

长文本 v.s. 长文本

长文本同长文本的比较多见于文档的匹配和去重，对于这类问题常见的解决方式是利用关键词提取获取长文本的特征向量，然后利用特征向量之间的相似度衡量对应文本的相似程度。在针对海量文本的去重，还以应用 SimHash 等技术对文本生成一个指纹，从而实现快速去重。

通常定义一个图 $G = \left(V, E\right)$，其中 $V$ 为顶点（Vertices）集合，$E$ 为边（Edges）集合。对于一条边 $e = u, v$ 包含两个端点（Endpoints） $u$ 和 $v$，同时 $u$ 可以称为 $v$ 的邻居（Neighbor）。当所有的边为有向边时，图称之为有向（Directed）图，当所有边为无向边时，图称之为无向（Undirected）图。对于一个顶点 $v$，令 $d \left(v\right)$ 表示连接的边的数量，称之为度（Degree）。对于一个图 $G = \left(V, E\right)$，其邻接矩阵（Adjacency Matrix） $A \in \mathbb{A}^{|V| \times |V|}$ 定义为：

$$ A_{i j}=\left\{\begin{array}{ll} 1 & \text { if }\left\{v_{i}, v_{j}\right\} \in E \text { and } i \neq j \\ 0 & \text { otherwise } \end{array}\right. $$

作为一个典型的非欧式数据，对于图数据的分析主要集中在节点分类，链接预测和聚类等。对于图数据而言，**图嵌入（Graph / Network Embedding）和图神经网络（Graph Neural Networks, GNN）**是两个类似的研究领域。图嵌入旨在将图的节点表示成一个低维向量空间，同时保留网络的拓扑结构和节点信息，以便在后续的图分析任务中可以直接使用现有的机器学习算法。一些基于深度学习的图嵌入同时也属于图神经网络，例如一些基于图自编码器和利用无监督学习的图卷积神经网络等。下图描述了图嵌入和图神经网络之间的差异：

图嵌入

本节内容主要参考自：
A Comprehensive Survey of Graph Embedding: Problems, Techniques and Applications ¹
Graph Embedding Techniques, Applications, and Performance: A Survey ²
Representation Learning on Graphs: Methods and Applications ³

使用邻接矩阵的网络表示存在计算效率的问题，邻接矩阵 $A$ 使用 $|V| \times |V|$ 的存储空间表示一个图，随着节点个数的增长，这种表示所需的空间成指数增长。同时，在邻接矩阵中绝大多数是 0，数据的稀疏性使得快速有效的学习方式很难被应用。

网路表示学习是指学习得到网络中节点的低维向量表示，形式化地，网络表示学习的目标是对每个节点 $v \in V$ 学习一个实值向量 $R_v \in \mathbb{R}^k$，其中 $k \ll |V|$ 表示向量的维度。经典的 Zachary’s karate club 网络的嵌入可视化如下图所示：

Random Walk

基于随机游走的图嵌入通过使得图上一个短距的随机游走中共现的节点具有更相似的表示的方式来优化节点的嵌入。

DeepWalk

DeepWalk ⁴ 算法主要包含两个部分：一个随机游走序列生成器和一个更新过程。随机游走序列生成器首先在图 $G$ 中均匀地随机抽样一个随机游走 $\mathcal{W}_{v_i}$ 的根节点 $v_i$，接着从节点的邻居中均匀地随机抽样一个节点直到达到设定的最大长度 $t$。对于一个生成的以 $v_i$ 为中心左右窗口为 $w$ 的随机游走序列 $v_{i-w}, \dotsc, v_{i-1}, v_i, v_{i+1}, \dotsc, v_{i+m}$，DeepWalk 利用 SkipGram 算法通过最大化以 $v_i$ 为中心，左右 $w$ 为窗口的同其他节点共现概率来优化模型：

$$ \text{Pr} \left(\left\{v_{i-w}, \dotsc, v_{i+w}\right\} \setminus v_i \mid \Phi \left(v_i\right)\right) = \prod_{j=i-w, j \neq i}^{i+w} \text{Pr} \left(v_j \mid \Phi \left(v_i\right)\right) $$

DeepWalk 和 Word2Vec 的类比如下表所示：

node2vec

node2vec ⁵ 通过改变随机游走序列生成的方式进一步扩展了 DeepWalk 算法。DeepWalk 选取随机游走序列中下一个节点的方式是均匀随机分布的，而 node2vec 通过引入两个参数 $p$ 和 $q$，将宽度优先搜索和深度优先搜索引入了随机游走序列的生成过程。 宽度优先搜索注重邻近的节点并刻画了相对局部的一种网络表示， 宽度优先中的节点一般会出现很多次，从而降低刻画中心节点的邻居节点的方差， 深度优先搜索反映了更高层面上的节点之间的同质性。

node2vec 中的两个参数 $p$ 和 $q$ 控制随机游走序列的跳转概率。假设上一步游走的边为 $\left(t, v\right)$， 那么对于节点 $v$ 的不同邻居，node2vec 根据 $p$ 和 $q$ 定义了不同的邻居的跳转概率，$p$ 控制跳向上一个节点的邻居的概率，$q$ 控制跳向上一个节点的非邻居的概率，具体的未归一的跳转概率值 $\pi_{vx} = \alpha_{pq} \left(t, x\right)$ 如下所示：

$$ \alpha_{p q}(t, x)=\left\{\begin{array}{cl} \dfrac{1}{p}, & \text { if } d_{t x}=0 \\ 1, & \text { if } d_{t x}=1 \\ \dfrac{1}{q}, & \text { if } d_{t x}=2 \end{array}\right. $$

其中，$d_{tx}$ 表示节点 $t$ 和 $x$ 之间的最短距离。为了获得最优的超参数 $p$ 和 $q$ 的取值，node2vec 通过半监督形式，利用网格搜索最合适的参数学习节点表示。

APP

之前的基于随机游走的图嵌入方法，例如：DeepWalk，node2vec 等，都无法保留图中的非对称信息。然而非对称性在很多问题，例如：社交网络中的链路预测、电商中的推荐等，中至关重要。在有向图和无向图中，非对称性如下图所示：

为了保留图的非对称性，对于每个节点 $v$ 设置两个不同的角色：源和目标，分别用 $\overrightarrow{s_{v}}$ 和 $\overrightarrow{t_{v}}$ 表示。对于每个从 $u$ 开始以 $v$ 结尾的采样序列，利用 $(u, v)$ 表示采样的节点对。则利用源节点 $u$ 预测目标节点 $v$ 的概率如下：

$$ p(v | u)=\frac{\exp (\overrightarrow{s_{u}} \cdot \overrightarrow{t_{v}})}{\sum_{n \in V} \exp (\overrightarrow{s_{u}} \cdot \overrightarrow{t_{n}})} $$

通过 Skip-Gram 和负采样对模型进行优化，损失函数如下：

$$ \begin{aligned} \ell &= \log \sigma(\overrightarrow{s_{u}} \cdot \overrightarrow{t_{v}})+k \cdot E_{t_{n} \sim P_{D}}[\log \sigma(-\overrightarrow{s_{u}} \cdot \overrightarrow{t_{n}})] \\ &= \sum_{u} \sum_{v} \# \text {Sampled}_{u}(v) \cdot \left(\log \sigma(\overrightarrow{s_{u}} \cdot \overrightarrow{t_{v}}) + k \cdot E_{t_{n} \sim P_{D}}[\log \sigma(-\overrightarrow{s_{u}} \cdot \overrightarrow{t_{n}})]\right) \end{aligned} $$

其中，我们根据分布 $P_D \left(n\right) \sim \dfrac{1}{|V|}$ 随机负采样 $k$ 个节点对，$\# \text{Sampled}_{u}(v)$ 为采样的 $\left(u, v\right)$ 对的个数，$\sigma$ 为 sigmoid 函数。通常情况下，$\# \text{Sampled}_{u}(v) \neq \# \text{Sampled}_{v}(u)$，即 $\left(u, v\right)$ 和 $\left(v, u\right)$ 的观测数量是不同的。模型利用 Monte-Carlo End-Point 采样方法 ⁶ 随机的以 $v$ 为起点和 $\alpha$ 为停止概率采样 $p$ 条路径。这种采样方式可以用于估计任意一个节点对之间的 Rooted PageRank ⁷ 值，模型利用这个值估计由 $v$ 到达 $u$ 的概率。

Matrix Fractorization

GraRep

GraRep ⁸ 提出了一种基于矩阵分解的图嵌入方法。对于一个图 $G$，利用邻接矩阵 $S$ 定义图的度矩阵：

$$ D_{i j}=\left\{\begin{array}{ll} \sum_{p} S_{i p}, & \text { if } i=j \\ 0, & \text { if } i \neq j \end{array}\right. $$

则一阶转移概率矩阵定义如下：

$$ A = D^{-1} S $$

其中，$A_{i, j}$ 表示通过一步由 $v_i$ 转移到 $v_j$ 的概率。所谓的全局特征包含两个部分：

1. 捕获两个节点之间的长距离特征
2. 分别考虑按照不同转移步数的连接

下图展示了 $k = 1, 2, 3, 4$ 情况下的强（上）弱（下）关系：

利用 Skip-Gram 和 NCE（noise contrastive estimation）方法，对于一个 $k$ 阶转移，可以将模型归结到一个矩阵 $Y_{i, j}^k$ 的分解问题：

$$ Y_{i, j}^{k}=W_{i}^{k} \cdot C_{j}^{k}=\log \left(\frac{A_{i, j}^{k}}{\sum_{t} A_{t, j}^{k}}\right)-\log (\beta) $$

其中，$W$ 和 $C$ 的每一行分别为节点 $w$ 和 $c$ 的表示，$\beta = \lambda / N$，$\lambda$ 为负采样的数量，$N$ 为图中边的个数。

之后为了减少噪音，模型将 $Y^k$ 中所有的负值替换为 0，通过 SVD（方法详情见参见之前博客）得到节点的 $d$ 维表示：

$$ \begin{aligned} X_{i, j}^{k} &= \max \left(Y_{i, j}^{k}, 0\right) \\ X^{k} &= U^{k} \Sigma^{k}\left(V^{k}\right)^{T} \\ X^{k} \approx X_{d}^{k} &= U_{d}^{k} \Sigma_{d}^{k}\left(V_{d}^{k}\right)^{T} \\ X^{k} \approx X_{d}^{k} &= W^{k} C^{k} \\ W^{k} &= U_{d}^{k}\left(\Sigma_{d}^{k}\right)^{\frac{1}{2}} \\ C^{k} &= \left(\Sigma_{d}^{k}\right)^{\frac{1}{2}} V_{d}^{k T} \end{aligned} $$

最终，通过对不同 $k$ 的表示进行拼接得到节点最终的表示。

HOPE

HOPE ⁹ 对于每个节点最终生成两个嵌入表示：一个是作为源节点的嵌入表示，另一个是作为目标节点的嵌入表示。模型通过近似高阶相似性来保留非对称传递性，其优化目标为：

$$ \min \left\|\mathbf{S}-\mathbf{U}^{s} \cdot \mathbf{U}^{t^{\top}}\right\|_{F}^{2} $$

其中，$\mathbf{S}$ 为相似矩阵，$\mathbf{U}^s$ 和 $\mathbf{U}^t$ 分别为源节点和目标节点的向量表示。下图展示了嵌入向量可以很好的保留非对称传递性：

对于 $\mathbf{S}$ 有多种可选近似度量方法：Katz Index，Rooted PageRank（RPR），Common Neighbors（CN），Adamic-Adar（AA）。这些度量方法可以分为两类：全局近似（Katz Index 和 RPR）和局部近似（CN 和 AA）。

算法采用了一个广义 SVD 算法（JDGSVD）来解决使用原始 SVD 算法计算复杂度为$O \left(N^3\right)$ 过高的问题，从而使得算法可以应用在更大规模的图上。

Meta Paths

matapath2vec

matapath2vec ¹⁰ 提出了一种基于元路径的异构网络表示学习方法。在此我们引入 3 个定义：

1. **异构网络（(Heterogeneous information network，HIN）**可以定义为一个有向图 $G = \left(V, E\right)$，一个节点类型映射 $\tau: V \to A$ 和一个边类型映射 $\phi: E \to R$，其中对于 $v \in V$ 有 $\tau \left(v\right) \in A$，$e \in E$ 有 $\phi \left(e\right) \in R$，且 $|A| + |R| > 1$。
2. **网络模式（Network schema）**定义为 $T_G = \left(A, R\right)$，为一个包含节点类型映射 $\tau \left(v\right) \in A$ 和边映射 $\phi \left(e\right) \in R$ 异构网络的 $G = \left(V, E\right)$ 的元模板。
3. **元路径（Meta-path）**定义为网络模式 $T_G = \left(A, R\right)$ 上的一条路径 $P$，形式为 $A_{1} \stackrel{R_{1}}{\longrightarrow} A_{2} \stackrel{R_{2}}{\longrightarrow} \cdots \stackrel{R_{l}}{\longrightarrow} A_{l+1}$。

下图展示了一个学术网络和部分元路径：

其中，APA 表示一篇论文的共同作者，APVPA 表示两个作者在同一个地方发表过论文。

metapath2vec 采用了基于元路径的随机游走来生成采样序列，这样就可以保留原始网络中的语义信息。对于一个给定的元路径模板 $P: A_{1} \stackrel{R_{1}}{\longrightarrow} A_{2} \stackrel{R_{2}}{\longrightarrow} \cdots A_{t} \stackrel{R_{t}}{\longrightarrow} A_{t+1} \cdots \stackrel{R_{l}}{\longrightarrow} A_{l}$，第 $i$ 步的转移概率为：

$$ p\left(v^{i+1} | v_{t}^{i}, P\right)=\left\{\begin{array}{ll} \dfrac{1}{\left|N_{t+1}\left(v_{t}^{i}\right)\right|} & \left(v_{t}^{i}, v^{i+1}\right) \in E, \phi\left(v^{i+1}\right)=A_{t+1} \\ 0 & \left(v_{t}^{i}, v^{i+1}\right) \in E, \phi\left(v^{i+1}\right) \neq A_{t+1} \\ 0 & \left(v_{t}^{i}, v^{i+1}\right) \notin E \end{array}\right. $$

其中，$v^i_t \in A_t$，$N_{t+1} \left(v^i_t\right)$ 表示节点 $v^i_t$ 类型为 $A_{t+1}$ 的邻居。之后，则采用了类似 DeepWalk 的方式进行训练得到节点表示。

HIN2Vec

HIN2Vec ¹¹ 提出了一种利用多任务学习通过多种关系进行节点和元路径表示学习的方法。模型最初是希望通过一个多分类模型来预测任意两个节点之间所有可能的关系。假设对于任意两个节点，所有可能的关系集合为 $R = \{\text{P-P, P-A, A-P, P-P-P, P-P-A, P-A-P, A-P-P, A-P-A}\}$。假设一个实例 $P_1$ 和 $A_1$ 包含两种关系：$\text{P-A}$ 和 $\text{P-P-A}$，则对应的训练数据为 $\langle x: P_1, y: A_1, output: \left[0, 1, 0, 0, 1, 0, 0, 0\right] \rangle$。

但实际上，扫描整个网络寻找所有可能的关系是不现实的，因此 HIN2Vec 将问题简化为一个给定两个节点判断之间是否存在一个关系的二分类问题，如下图所示：

模型的三个输入分别为节点 $x$ 和 $y$，以及关系 $r$。在隐含层输入被转换为向量 $W_{X}^{\prime} \vec{x}, W_{Y}^{\prime} \vec{y}$ 和 $f_{01}\left(W_{R}^{\prime} \vec{r}\right)$。需要注意对于关系 $r$，模型应用了一个正则化函数 $f_{01} \left(\cdot\right)$ 使得 $r$ 的向量介于 $0$ 和 $1$ 之间。之后采用逐元素相乘对三个向量进行汇总 $W_{X}^{\prime} \vec{x} \odot W_{Y}^{\prime} \vec{y} \odot f_{01}\left(W_{R}^{\prime} \vec{r}\right)$。在最后的输出层，通过计算 $sigmoid \left(\sum W_{X}^{\prime} \vec{x} \odot W_{Y}^{\prime} \vec{y} \odot f_{01}\left(W_{R}^{\prime} \vec{r}\right)\right)$ 得到最终的预测值。

在生成训练数据时，HIN2Vec 采用了完全随机游走进行节点采样，而非 metapath2vec 中的按照给定的元路径的方式。通过随机替换 $x, y, r$ 中的任何一个可以生成负样本，但当网络中的关系数量较少，节点数量远远大于关系数量时，这种方式很可能产生错误的负样本，因此 HIN2Vec 只随机替换 $x, y$，保持 $r$ 不变。

Deep Learning

SDNE

SDNE ¹² 提出了一种利用自编码器同时优化一阶和二阶相似度的图嵌入算法，学习得到的向量能够保留局部和全局的结构信息。SDNE 使用的网络结构如下图所示：

对于二阶相似度，自编码器的目标是最小化输入和输出的重构误差。SDNE 采用邻接矩阵作为自编码器的输入，$\mathbf{x}_i = \mathbf{s}_i$，每个 $\mathbf{s}_i$ 包含了节点 $v_i$ 的邻居结构信息。模型的损失函数如下：

$$ \mathcal{L}=\sum_{i=1}^{n}\left\|\hat{\mathbf{x}}_{i}-\mathbf{x}_{i}\right\|_{2}^{2} $$

由于网络的稀疏性，邻接矩阵中的非零元素远远少于零元素，因此模型采用了一个带权的损失函数：

$$ \begin{aligned} \mathcal{L}_{2nd} &=\sum_{i=1}^{n}\left\|\left(\hat{\mathbf{x}}_{i}-\mathbf{x}_{i}\right) \odot \mathbf{b}_{i}\right\|_{2}^{2} \\ &=\|(\hat{X}-X) \odot B\|_{F}^{2} \end{aligned} $$

其中，$\odot$ 表示按位乘，$\mathbf{b}_i = \left\{b_{i, j}\right\}_{j=1}^{n}$，如果 $s_{i, j} = 0$ 则 $b_{i, j} = 1$ 否则 $b_{i, j} = \beta > 1$。

对于一阶相似度，模型利用了一个监督学习模块最小化节点在隐含空间中距离。损失函数如下：

$$ \begin{aligned} \mathcal{L}_{1st} &=\sum_{i, j=1}^{n} s_{i, j}\left\|\mathbf{y}_{i}^{(K)}-\mathbf{y}_{j}^{(K)}\right\|_{2}^{2} \\ &=\sum_{i, j=1}^{n} s_{i, j}\left\|\mathbf{y}_{i}-\mathbf{y}_{j}\right\|_{2}^{2} \end{aligned} $$

最终，模型联合损失函数如下：

$$ \begin{aligned} \mathcal{L}_{mix} &=\mathcal{L}_{2nd}+\alpha \mathcal{L}_{1st}+\nu \mathcal{L}_{reg} \\ &=\|(\hat{X}-X) \odot B\|_{F}^{2}+\alpha \sum_{i, j=1}^{n} s_{i, j}\left\|\mathbf{y}_{i}-\mathbf{y}_{j}\right\|_{2}^{2}+\nu \mathcal{L}_{reg} \end{aligned} $$

其中，$\mathcal{L}_{reg}$ 为 L2 正则项。

DNGR

DNGR ¹³ 提出了一种利用基于 Stacked Denoising Autoencoder（SDAE）提取特征的网络表示学习算法。算法的流程如下图所示：

模型首先利用 Random Surfing 得到一个概率共现（PCO）矩阵，之后利用其计算得到 PPMI 矩阵，最后利用 SDAE 进行特征提取得到节点的向量表示。

对于传统的将图结构转换为一个线性序列方法存在几点缺陷：

1. 采样序列边缘的节点的上下文信息很难被捕捉。
2. 很难直接确定游走的长度和步数等超参数，尤其是对于大型网络来说。

受 PageRank 思想影响，作者采用了 Random Surfing 模型。定义转移矩阵 $A$，引入行向量 $p_k$，第 $j$ 个元素表示通过 $k$ 步转移之后到达节点 $j$ 的概率。$p_0$ 为一个初始向量，其仅第 $i$ 个元素为 1，其它均为 0。在考虑以 $1 - \alpha$ 的概率返回初始节点的情况下有：

$$ p_{k}=\alpha \cdot p_{k-1} A+(1-\alpha) p_{0} $$

在不考虑返回初始节点的情况下有：

$$ p_{k}^{*}=p_{k-1}^{*} A=p_{0} A^{k} $$

直观而言，两个节点越近，两者的关系越亲密，因此通过同当前节点的相对距离来衡量上下文节点的重要性是合理的。基于此，第 $i$ 个节点的表示可以用如下方式构造：

$$ r=\sum_{k=1}^{K} w(k) \cdot p_{k}^{*} $$

其中，$w \left(\cdot\right)$ 是一个衰减函数。

利用 PCO 计算得到 PPMI 后，再利用一个 SDAE 进行特征提取。Stacking 策略可以通过不同的网络层学习得到不同层级的表示，Denoising 策略则通过去除数据中的噪声，增加结果的鲁棒性。同时，SNGR 相比基于 SVD 的方法效率更高。

Others

LINE

LINE ¹⁴ 提出了一个用于大规模网络嵌入的方法，其满足如下 3 个要求：

1. 同时保留节点之间的一阶相似性（first-order proximity）和二阶相似性（second-order proximity）。
2. 可以处理大规模网络，例如：百万级别的顶点和十亿级别的边。
3. 可以处理有向，无向和带权的多种类型的图结构。

给定一个无向边 $\left(i, j\right)$，点 $v_i$ 和 $v_j$ 的联合概率如下：

$$ p_{1}\left(v_{i}, v_{j}\right)=\frac{1}{1+\exp \left(-\vec{u}_{i}^{T} \cdot \vec{u}_{j}\right)} $$

其中，$\vec{u}_{i} \in R^{d}$ 为节点 $v_i$ 的低维向量表示。在空间 $V \times V$ 上，分布 $p \left(\cdot, \cdot\right)$ 的经验概率为 $\hat{p}_1 \left(i, j\right) = \dfrac{w_{ij}}{V}$，其中 $W = \sum_{\left(i, j\right) \in E} w_{ij}$。通过最小化两个分布的 KL 散度来优化模型，则目标函数定义如下：

$$ O_{1}=-\sum_{(i, j) \in E} w_{i j} \log p_{1}\left(v_{i}, v_{j}\right) $$

需要注意的是一阶相似度仅可用于无向图，通过最小化上述目标函数，我们可以将任意顶点映射到一个 $d$ 维空间向量。

二阶相似度既可以用于无向图，也可以用于有向图。二阶相似度假设共享大量同其他节点连接的节点之间是相似的，每个节点被视为一个特定的上下文，则在上下文上具有类似分布的节点是相似的。在此，引入两个向量 $\vec{u}_{i}$ 和 $\vec{u}_{\prime i}$，其中 $\vec{u}_{i}$ 是 $v_i$ 做为节点的表示，$\vec{u}_{\prime i}$ 是 $v_i$ 做为上下文的表示。对于一个有向边 $\left(i, j\right)$，由 $v_i$ 生成上下文 $v_j$ 的概率为：

$$ p_{2}\left(v_{j} | v_{i}\right)=\frac{\exp \left(\vec{u}_{j}^{\prime T} \cdot \vec{u}_{i}\right)}{\sum_{k=1}^{|V|} \exp \left(\vec{u}_{k}^{\prime T} \cdot \vec{u}_{i}\right)} $$

其中，$|V|$ 为节点或上下文的数量。在此我们引入一个参数 $\lambda_i$ 用于表示节点 $v_i$ 的重要性程度，重要性程度可以利用度或者 PageRank 算法进行估计。经验分布 $\hat{p}_{2}\left(\cdot \mid v_{i}\right)$ 定义为 $\hat{p}_{2}\left(v_{j} \mid v_{i}\right)=\dfrac{w_{i j}}{d_{i}}$，其中 $w_{ij}$ 为边 $\left(i, j\right)$ 的权重，$d_i$ 为节点 $v_i$ 的出度。LINE 中采用 $d_i$ 作为节点的重要性 $\lambda_i$，利用 KL 散度同时忽略一些常量，目标函数定义如下：

$$ O_{2}=-\sum_{(i, j) \in E} w_{i j} \log p_{2}\left(v_{j} \mid v_{i}\right) $$

LINE 采用负采样的方式对模型进行优化，同时利用 Alias 方法 ^{15 16} 加速采样过程。

图神经网络

本节内容主要参考自：
Deep Learning on Graphs: A Survey ¹⁷
A Comprehensive Survey on Graph Neural Networks ¹⁸
Graph Neural Networks: A Review of Methods and Applications ¹⁹
Introduction to Graph Neural Networks ²⁰

图神经网络（Graph Neural Network，GNN）最早由 Scarselli 等人 ²¹ 提出。图中的一个节点可以通过其特征和相关节点进行定义，GNN 的目标是学习一个状态嵌入 $\mathbf{h}_v \in \mathbb{R}^s$ 用于表示每个节点的邻居信息。状态嵌入 $\mathbf{h}_v$ 可以生成输出向量 $\mathbf{o}_v$ 用于作为预测节点标签的分布等。

下面三张图分别从图的类型，训练方法和传播过程角度列举了不同 GNN 的变种 ¹⁹。

下面我们主要从模型的角度分别介绍不同种类的 GNN。

Graph Neural Networks

为了根据邻居更新节点的状态，定义一个用于所有节点的函数 $f$，称之为 local transition function。定义一个函数 $g$，用于生成节点的输出，称之为 local output function。有：

$$ \begin{array}{c} \mathbf{h}_{v}=f\left(\mathbf{x}_{v}, \mathbf{x}_{co[v]}, \mathbf{h}_{ne[v]}, \mathbf{x}_{ne[v])}\right. \\ \mathbf{o}_{v}=g\left(\mathbf{h}_{v}, \mathbf{x}_{v}\right) \end{array} $$

其中，$\mathbf{x}$ 表示输入特征，$\mathbf{h}$ 表示隐含状态。$co[v]$ 为连接到节点 $v$ 的边集，$ne[v]$ 为节点 $v$ 的邻居。

上图中，$\mathbf{x}_1$ 表示 $l_1$ 的输入特征，$co[l_1]$ 包含了边 $l_{(1, 4)}, l_{(6, 1)}, l_{(1, 2)}$ 和 $l_{(3, 1)}$，$ne[l_1]$ 包含了节点 $l_2, k_3, l_4$ 和 $l_6$。

令 $\mathbf{H}, \mathbf{O}, \mathbf{X}$ 和 $\mathbf{X}_N$ 分别表示状态、输出、特征和所有节点特征的向量，有：

$$ \begin{aligned} &\mathbf{H}=F(\mathbf{H}, \mathbf{X})\\ &\mathbf{O}=G\left(\mathbf{H}, \mathbf{X}_{N}\right) \end{aligned} $$

其中，$F$ 为 global transition function，$G$ 为 global output function，分别为图中所有节点的 local transition function $f$ 和 local output function $g$ 的堆叠版本。依据 Banach 的 Fixed Point Theorem ²²，GNN 利用传统的迭代方式计算状态：

$$ \mathbf{H}^{t+1}=F\left(\mathbf{H}^{t}, \mathbf{X}\right) $$

其中，$\mathbf{H}^t$ 表示第 $t$ 论循环 $\mathbf{H}$ 的值。

介绍完 GNN 的框架后，下一个问题就是如果学习得到 local transition function $f$ 和 local output function $g$。在包含目标信息（$\mathbf{t}_v$ 对于特定节点）的监督学习情况下，损失为：

$$ loss = \sum_{i=1}^{p} \left(\mathbf{t}_i - \mathbf{o}_i\right) $$

其中，$p$ 为用于监督学习的节点数量。利用基于梯度下降的学习方法优化模型后，我们可以得到针对特定任务的训练模型和图中节点的隐含状态。

尽管实验结果表明 GNN 是一个用于建模结构数据的强大模型，但对于一般的 GNN 模型仍存在如下缺陷：

1. 对于固定点，隐含状态的更新是低效地。
2. GNN 在每一轮计算中共享参数，而常见的神经网络结构在不同层使用不同的参数。同时，隐含节点状态的更新可以进一步应用 RNN 的思想。
3. 边上的一些信息特征并没有被有效的建模，同时如何学习边的隐含状态也是一个重要问题。
4. 如果我们更关注节点的表示而非图的表示，当迭代轮数 $T$ 很大时使用固定点是不合适的。这是因为固定点表示的分布在数值上会更加平滑，从而缺少用于区分不同节点的信息。

Graph Convolutional Networks

图卷积神经网络是将用于传统数据（例如：图像）的卷积操作应用到图结构的数据中。核心思想在于学习一个函数 $f$，通过聚合节点 $v_i$ 自身的特征 $\mathbf{X}_i$ 和邻居的特征 $\mathbf{X}_j$ 获得节点的表示，其中 $j \in N\left(v_i\right)$ 为节点的邻居。

下图展示了一个用于节点表示学习的 GCN 过程：

GCN 在构建更复杂的图神经网路中扮演了一个核心角色：

GCN 方法可以分为两大类：基于频谱（Spectral Methods）和基于空间（Spatial Methods）的方法。

基于频谱的方法（Spectral Methods）

基于频谱的方法将图视为无向图进行处理，图的一种鲁棒的数学表示为标准化的图拉普拉斯矩阵：

$$ \mathbf{L}=\mathbf{I}_{\mathbf{n}}-\mathbf{D}^{-\frac{1}{2}} \mathbf{A} \mathbf{D}^{-\frac{1}{2}} $$

其中，$\mathbf{A}$ 为图的邻接矩阵，$\mathbf{D}$ 为节点度的对角矩阵，$\mathbf{D}_{ii} = \sum_{j} \left(\mathbf{A}_{i, j}\right)$。标准化的拉普拉斯矩阵具有实对称半正定的性质，因此可以分解为：

$$ \mathbf{L}=\mathbf{U} \mathbf{\Lambda} \mathbf{U}^{T} $$

其中，$\mathbf{U}=\left[\mathbf{u}_{\mathbf{0}}, \mathbf{u}_{\mathbf{1}}, \cdots, \mathbf{u}_{\mathbf{n}-\mathbf{1}}\right] \in \mathbf{R}^{N \times N}$ 是由 $\mathbf{L}$ 的特征向量构成的矩阵，$\mathbf{\Lambda}$ 为特征值的对角矩阵，$\mathbf{\Lambda}_{ii} = \lambda_i$。在图信号处理过程中，一个图信号 $\mathbf{x} \in \mathbb{R}^N$ 是一个由图的节点构成的特征向量，其中 $\mathbf{x}_i$ 表示第 $i$ 个节点的值。对于信号 $\mathbf{x}$，图上的傅里叶变换可以定义为：

$$ \mathscr{F}(\mathbf{x})=\mathbf{U}^{T} \mathbf{x} $$

傅里叶反变换定义为：

$$ \mathscr{F}^{-1}(\hat{\mathbf{x}})=\mathbf{U} \hat{\mathbf{x}} $$

其中，$\hat{\mathbf{x}}$ 为傅里叶变换后的结果。

转变后信号 $\hat{\mathbf{x}}$ 的元素为新空间图信号的坐标，因此输入信号可以表示为：

$$ \mathbf{x}=\sum_{i} \hat{\mathbf{x}}_{i} \mathbf{u}_{i} $$

这正是傅里叶反变换的结果。那么对于输入信号 $\mathbf{x}$ 的图卷积可以定义为：

$$ \begin{aligned} \mathbf{x} *_{G} \mathbf{g} &=\mathscr{F}^{-1}(\mathscr{F}(\mathbf{x}) \odot \mathscr{F}(\mathbf{g})) \\ &=\mathbf{U}\left(\mathbf{U}^{T} \mathbf{x} \odot \mathbf{U}^{T} \mathbf{g}\right) \end{aligned} $$

其中，$\mathbf{g} \in \mathbb{R}^N$ 为滤波器，$\odot$ 表示逐元素乘。假设定义一个滤波器 $\mathbf{g}_{\theta}=\operatorname{diag}\left(\mathbf{U}^{T} \mathbf{g}\right)$，则图卷积可以简写为：

$$ \mathbf{x} *_{G} \mathbf{g}_{\theta}=\mathbf{U} \mathbf{g}_{\theta} \mathbf{U}^{T} \mathbf{x} $$

基于频谱的图卷积网络都遵循这样的定义，不同之处在于不同滤波器的选择。

一些代表模型及其聚合和更新方式如下表所示：

基于空间的方法（Spatial Methods）

基于空间的方法通过节点的空间关系来定义图卷积操作。为了将图像和图关联起来，可以将图像视为一个特殊形式的图，每个像素点表示一个节点，如下图所示：

每个像素同周围的像素相连，以 $3 \times 3$ 为窗口，每个节点被 8 个邻居节点所包围。通过对中心节点和周围邻居节点的像素值进行加权平均来应用一个 $3 \times 3$ 大小的滤波器。由于邻居节点的特定顺序，可以在不同位置共享权重。同样对于一般的图，基于空间的图卷积通过对中心和邻居节点的聚合得到节点新的表示。

为了使节点可以感知更深和更广的范围，通常的做法是将多个图卷积层堆叠在一起。根据堆叠方式的不同，基于空间的图卷积可以进一步分为两类：基于循环（Recurrent-based）和基于组合（Composition-based）的。基于循环的方法使用相同的图卷积层来更新隐含表示，基于组合的方式使用不同的图卷积层更新隐含表示，两者差异如下图所示：

一些代表模型及其聚合和更新方式如下表所示：

Graph Recurrent Networks

一些研究尝试利用门控机制（例如：GRU 或 LSTM）用于减少之前 GNN 模型在传播过程中的限制，同时改善在图结构中信息的长距离传播。GGNN ²⁸ 提出了一种使用 GRU 进行传播的方法。它将 RNN 展开至一个固定 $T$ 步，然后通过基于时间的传导计算梯度。传播模型的基础循环方式如下：

$$ \begin{aligned} &\mathbf{a}_{v}^{t}=\mathbf{A}_{v}^{T}\left[\mathbf{h}_{1}^{t-1} \ldots \mathbf{h}_{N}^{t-1}\right]^{T}+\mathbf{b}\\ &\mathbf{z}_{v}^{t}=\sigma\left(\mathbf{W}^{z} \mathbf{a}_{v}^{t}+\mathbf{U}^{z} \mathbf{h}_{v}^{t-1}\right)\\ &\mathbf{r}_{v}^{t}=\sigma\left(\mathbf{W}^{r} \mathbf{a}_{v}^{t}+\mathbf{U}^{r} \mathbf{h}_{v}^{t-1}\right)\\ &\begin{array}{l} \widetilde{\mathbf{h}}_{v}^{t}=\tanh \left(\mathbf{W} \mathbf{a}_{v}^{t}+\mathbf{U}\left(\mathbf{r}_{v}^{t} \odot \mathbf{h}_{v}^{t-1}\right)\right) \\ \mathbf{h}_{v}^{t}=\left(1-\mathbf{z}_{v}^{t}\right) \odot \mathbf{h}_{v}^{t-1}+\mathbf{z}_{v}^{t} \odot \widetilde{\mathbf{h}}_{v}^{t} \end{array} \end{aligned} $$

节点 $v$ 首先从邻居汇总信息，其中 $\mathbf{A}_v$ 为图邻接矩阵 $\mathbf{A}$ 的子矩阵表示节点 $v$ 及其邻居的连接。类似 GRU 的更新函数，通过结合其他节点和上一时间的信息更新节点的隐状态。$\mathbf{a}$ 用于获取节点 $v$ 邻居的信息，$\mathbf{z}$ 和 $\mathbf{r}$ 分别为更新和重置门。

GGNN 模型设计用于解决序列生成问题，而之前的模型主要关注单个输出，例如：节点级别或图级别的分类问题。研究进一步提出了 Gated Graph Sequence Neural Networks（GGS-NNs），使用多个 GGNN 产生一个输出序列 $\mathbf{o}^{(1)}, \cdots, \mathbf{o}^{(K)}$，如下图所示：

上图中使用了两个 GGNN，$\mathcal{F}_o^{(k)}$ 用于从 $\mathcal{\boldsymbol{X}}^{(k)}$ 预测 $\mathbf{o}^{(k)}$，$\mathcal{F}_x^{(k)}$ 用于从 $\mathcal{\boldsymbol{X}}^{(k)}$ 预测 $\mathcal{\boldsymbol{X}}^{(k+1)}$。令 $\mathcal{\boldsymbol{H}}^{(k, t)}$ 表示第 $k$ 步输出的第 $t$ 步传播，$\mathcal{\boldsymbol{H}}^{(k, 1)}$ 在任意 $k$ 步初始化为 $\mathcal{\boldsymbol{X}}^{(k)}$，$\mathcal{\boldsymbol{H}}^{(t, 1)}$ 在任意 $t$ 步初始化为 $\mathcal{\boldsymbol{X}}^{(t)}$，$\mathcal{F}_o^{(k)}$ 和 $\mathcal{F}_x^{(k)}$ 可以为不同模型也可以共享权重。

一些代表模型及其聚合和更新方式如下表所示：

Graph Attention Networks

与 GCN 对于节点所有的邻居平等对待相比，注意力机制可以为每个邻居分配不同的注意力评分，从而识别更重要的邻居。

GAT ³¹ 将注意力机制引入传播过程，其遵循自注意力机制，通过对每个节点邻居的不同关注更新隐含状态。GAT 定义了一个图注意力层（graph attentional layer），通过堆叠构建图注意力网络。对于节点对 $\left(i, j\right)$，基于注意力机制的系数计算方式如下：

$$ \alpha_{i j}=\frac{\exp \left(\text { LeakyReLU }\left(\overrightarrow{\mathbf{a}}^{T}\left[\mathbf{W} \vec{h}_{i} \| \mathbf{W} \vec{h}_{j}\right]\right)\right)}{\sum_{k \in N_{i}} \exp \left(\text { LeakyReLU }\left(\overrightarrow{\mathbf{a}}^{T}\left[\mathbf{W} \vec{h}_{i} \| \mathbf{W} \vec{h}_{k}\right]\right)\right)} $$

其中，$\alpha_{i j}$ 表示节点 $j$ 对 $i$ 的注意力系数，$N_i$ 表示节点 $i$ 的邻居。令 $\mathbf{h}=\left\{\vec{h}_{1}, \vec{h}_{2}, \ldots, \vec{h}_{N}\right\}, \vec{h}_{i} \in \mathbb{R}^{F}$ 表示输入节点特征，其中 $N$ 为节点的数量，$F$ 为特征维度，则节点的输出特征（可能为不同维度 $F^{\prime}$）为 $\mathbf{h}^{\prime}=\left\{\vec{h}_{1}^{\prime}, \vec{h}_{2}^{\prime}, \ldots, \vec{h}_{N}^{\prime}\right\}, \vec{h}_{i}^{\prime} \in \mathbb{R}^{F^{\prime}}$。$\mathbf{W} \in \mathbb{R}^{F^{\prime} \times F}$ 为所有节点共享的线性变换的权重矩阵，$a: \mathbb{R}^{F^{\prime}} \times \mathbb{R}^{F^{\prime}} \rightarrow \mathbb{R}$ 用于计算注意力系数。最后的输出特征计算方式如下：

$$ \vec{h}_{i}^{\prime}=\sigma\left(\sum_{j \in \mathcal{N}_{i}} \alpha_{i j} \mathbf{W} \vec{h}_{j}\right) $$

注意力层采用多头注意力机制来稳定学习过程，之后应用 $K$ 个独立的注意力机制计算隐含状态，最后通过拼接或平均得到输出表示：

$$ \vec{h}_{i}^{\prime}=\Vert_{k=1}^{K} \sigma\left(\sum_{j \in \mathcal{N}_{i}} \alpha_{i j}^{k} \mathbf{W}^{k} \vec{h}_{j}\right) $$

$$ \vec{h}_{i}^{\prime}=\sigma\left(\frac{1}{K} \sum_{k=1}^{K} \sum_{j \in \mathcal{N}_{i}} \alpha_{i j}^{k} \mathbf{W}^{k} \vec{h}_{j}\right) $$

其中，$\Vert$ 表示连接操作，$\alpha_{ij}^k$ 表示第 $k$ 个注意力机制计算得到的标准化的注意力系数。整个模型如下图所示：

GAT 中的注意力架构有如下几个特点：

1. 针对节点对的计算是并行的，因此计算过程是高效的。
2. 可以处理不同度的节点并对邻居分配对应的权重。
3. 可以容易地应用到归纳学习问题中去。

应用

图神经网络已经被应用在监督、半监督、无监督和强化学习等多个领域。下图列举了 GNN 在不同领域内相关问题中的应用，具体模型论文请参考 Graph Neural Networks: A Review of Methods and Applications 原文 ¹⁹。

开放资源

开源实现

论文列表和评测

• Must-read papers on network representation learning (NRL) / network embedding (NE)
• Must-read papers on graph neural networks (GNN)
• DeepGraphLearning/LiteratureDL4Graph
• nnzhan/Awesome-Graph-Neural-Networks
• graphdeeplearning/benchmarking-gnns
• Open Graph Benchmark

本文为 Pre-trained Models for Natural Language Processing: A Survey 和相关模型的读书笔记 ¹。

在当下的 NLP 研究领域，随着计算机算力的不断增强，越来越多的通用语言表征的预训练模型（Pre-trained Models，PTMs）逐渐涌现出来。这对下游的 NLP 任务非常有帮助，可以避免大量从零开始训练新的模型。PTM 大致可以分为两代：

• 第一代 PTM 旨在学习词嵌入。由于下游任务不在需要这些模型，因此为了计算效率，这些模型往往采用浅层模型，例如 Skip-Gram ²，GloVe ³ 等。尽管这些模型可以捕获词的语义，但由于未基于上下文环境，因此不能够捕捉到更深层次的概念，例如：句法结构，语义角色，指代等等。
• 第二代 PTM 专注于学习基于上下文的词嵌入，例如 CoVe ⁴，ELMo ⁵，OpenAI GPT ⁶ 和 BERT ⁷ 等。这些学习到的编码器在下游任务中仍会用于词在上下文中的语义表示。

预训练原理

语言表示学习

分布式表示的核心思想为用一个低维的实值向量表示一段文本，向量单独每个维度不具有任何实质含义，但整个向量表示了一个具体的概念。下图展示了一个 NLP 任务的一般神经网络架构：

词嵌入包含两种类型：上下文无关的词嵌入和基于上下文的词嵌入。两者的不同点在于一个词的嵌入是够会随着上下文的不同而随之改变。

• 上下文无关的词嵌入

为了表征语义，我们需要将离散的语言符号映射到一个分布式嵌入空间中。对于词典 $\mathcal{V}$ 中的一个词 $x$，我们将其映射为查询表 $\mathbf{E} \in \mathbb{R}^{D_e \times \|\mathcal{V}\|}$ 中的一个向量 $\mathbf{e}_x \in \mathbb{R}^{D_e}$，其中 $D_e$ 为嵌入的维度。

这种类型的嵌入主要有两个缺陷：一是嵌入是静态的，词在不同的上下文中的嵌入表示是相同的，因此无法处理一词多义；二是未登录词（out-of-vocabulary，OOV）问题，通常可以采用字符级嵌入表示解决该问题。更多上下文无关的词嵌入模型，请参见之前的博客 词向量。

• 基于上下文的词嵌入

为了解决上述问题，我们需要区分在不同上下文下词的含义。给定一段文本 $x_1, x_2, \dotsc, x_T$ 其中每段标记 $x_t \in \mathcal{V}$ 为一个词或子词，$x_t$ 基于上下文的表示依赖于整段文本。

$$ \left[\mathbf{h}_1, \mathbf{h}_2, \dotsc, \mathbf{h}_T\right] = f_{\text{enc}} \left(x_1, x_2, \dotsc, x_T\right) $$

其中，$f_{\text{enc}} \left(\cdot\right)$ 为神经编码器，$\mathbf{h}_t$ 为标记 $x_t$ 的基于上下文的嵌入或动态嵌入。

神经上下文编码器

神经上下文编码器大致可以分为 3 类：

1. 基于卷积的模型：基于卷积的模型通过卷积操作从一个词的邻居中聚合局部信息来捕获这个词的含义 ⁸。

2. 基于序列的模型：基于序列的模型采用 RNNs（LSTM ⁹ 和 GRU ¹⁰） 来捕获词的上下文信息。实际中，我们采用双向的 RNNs 从词的两端收集信息，不过整体效果容易收到长期依赖问题的影响。

3. 基于图的模型：基于图的模型将字作为图中的一个节点来学习上下文表示，这个图通常是一个词之间预定义的语言结构，例如：语法结构 ^{11 12} 或语义关系 ¹³。尽管基于语言学的图结构能提供有用的信息，但如何构建一个好的图结构则成为了难题。除此之外，基于语言学的图结构需要依赖专家知识和外部工具，例如：依存句法分析等。事实上，我们会采用一个更直接的方式去学习任意两个词之间的关系，通常连接的权重可以通过自注意力机制自动计算得出。Transformer ¹⁴ 是一个采用了全链接自注意力架构的实现，同时也采用了位置嵌入（positional embedding），层标准化（layer normalization）和残差连接（residual connections）等网络设计理念。

为什么预训练

对于大多数的 NLP 任务，构建一个大规模的有标签的数据集是一项很大的挑战。相反，大规模的无标签语料是相对容易构建的，为了充分利用这些无标签数据，我们可以先利用它们获取一个好的语言表示，再将这些表示用于其他任务。预训练的好处如下：

1. 预训练可以从大规模语料中学习得到通用的语言表示，并用于下游任务。
2. 预训练提供了更优的模型初始化方法，有助于提高模型的泛化能力和加速模型收敛。
3. 预训练可以当作是在小数据集上一种避免过拟合的正则化方法。

预训练任务

预训练任务对于学习语言的通用表示来说至关重要。通常情况下，预训练任务具有挑战性，同时需要大量训练数据。我们将预训练任务划分为 3 类：

1. 监督学习，即从包含输入输出对的训练数据中学习一个由输入到输出的映射函数。
2. 非监督学习，即从无标签数据获取一些固有的知识，例如：聚类，密度，潜在表征等。
3. 自监督学习，是监督学习和非监督学习的混合体，核心思想是对于输入的一部分利用其他部分进行预测。

语言模型（Language Modeling，LM）

NLP 中最常见的非监督任务为概率语言建模，这是一个经典的概率密度估计问题。给定一个文本序列 $x_{1:T} = \left[x_1, x_2, \dotsc, x_T\right]$，他的联合概率 $p \left(x_{1:T}\right)$ 可以分解为：

$$ p \left(x_{1:T}\right) = \prod_{t=1}^{y}{p \left(x_t \mid x_{0:t-1}\right)} $$

其中 $x_0$ 为序列开始的特殊标记。条件概率 $p \left(x_t \mid x_{0:t-1}\right)$ 可以通过给定的语言上下文 $x_{0:t-1}$ 词的概率分布进行建模估计。上下文 $x_{0:t-1}$ 可以通过神经编码器 $f_{\text{enc}} \left(\cdot\right)$ 进行建模，则条件概率可以表示为：

$$ p \left(x_t | x_{0:t-1}\right) = g_{\text{LM}} \left(f_{\text{enc}} \left(x_{0:t-1}\right)\right) $$

其中，$g_{\text{LM}}$ 为预测层。

遮罩语言模型（Masked Language Modeling，MLM）

大致上来说，MLM 首先将输入句子的一些词条进行遮挡处理，其次再训练模型利用剩余的部分预测遮挡的部分。这种预训练方法会导致在预训练（pre-training）阶段和微调（fine-tuning）阶段的不一致，因为在微调阶段遮挡标记并未出现，BERT ¹⁵ 通过一个特殊的符号 [MASK] 对其进行处理。

Sequence-to-Sequence MLM (Seq2Seq MLM)

MLM 通常以一个分类问题进行求解，我们将遮挡后的序列输入到一个神经编码器，再将输出向量传给一个 Softmax 分类器来预测遮挡的字符。我们可以采用 Encoder-Decoder（Seq2Seq）网络结构，将遮挡的序列输入到 Encoder，Decoder 则会循序的产生被遮挡的字符。MASS ¹⁶ 和 T5 ¹⁷ 均采用了这种序列到序列的 MLM 结构，这种结构对 Seq2Seq 风格的下游任务很有帮助，例如：问答，摘要和机器翻译。

Enhanced Masked Language Modeling (E-MLM)

同时，大量研究对于 BERT 所使用的遮罩处理进行了改进。RoBERTa ¹⁸ 采用了一种动态的遮罩处理。UniLM 将遮罩任务拓展到 3 种不同的类型：单向的，双向的和 Seq2Seq 类型的。

排列语言模型（Permuted Language Modeling，PLM）

在 MLM 中一些特殊字符（例如：[MASK]）在下游任务中是无用的，为了解决这个问题，XLNet ¹⁹ 提出了一种排列语言模型（Permuted Language Modeling，PLM）用于替代 MLM。简言之，PLM 是对输入序列的排列进行语言建模。给定一个序列，从所有可能的排列中随机抽样得到一个排列，将排列后的序列中的一些字符作为模型的预测目标，利用其他部分和目标的自然位置进行训练。需要注意的是这种排列并不会影响序列的自然位置，其仅用于定义字符预测的顺序。

去噪自编码（Denoising Autoencoder，DAE）

DAE 旨在利用部分有损的输入恢复原始无损的输入。对于语言模型，例如 Seq2Seq 模型，可以采用标准的 Transformer 来重构原始文本。有多种方式可以对文本进行破坏 ²⁰：

1. 字符遮罩：随机采样字符并将其替换为 [MASK]。
2. 字符删除：随机的从输入中删除字符，不同于字符遮罩，模型需要确定丢失字符的位置。
3. 文本填充：采样一段文本并将其替换为一个 [MASK]，每段文本的长度服从泊松分布（$\lambda = 3$），模型需要确定这段文本中缺失的字符个数。
4. 句子重排：将文档以终止标点进行分割，再进行随机排序。
5. 文档旋转：随机均匀地选择一个字符，对文档进行旋转使得这个字符作为文档的起始字符，模型需要确定文档真实的起始位置。

对比学习（Contrastive Learning，CTL）

对比学习 ²¹ 假设一些观测到的文本对比随机采样的文本具有更相似的语义。对于文本对 $\left(x, y\right)$ 通过最小化如下目标函数来学习评分函数 $s \left(x, y\right)$：

$$ \mathbb{E}_{x, y^+, y^-} \left[- \log \dfrac{\exp \left(s \left(x, y^+\right)\right)}{\exp \left(s \left(x, y^+\right)\right) + \exp \left(s \left(x, y^-\right)\right)}\right] $$

其中，$\left(x, y^+\right)$ 为一个相似对，$y^-$ 对于 $x$ 而言假定为不相似，$y^+$ 和 $y^-$ 通常称之为正样本和负样本。评分函数 $s \left(x, y\right)$ 通过一个神经编码器计算可得，$s \left(x, y\right) = f^{\top}_{\text{enc}} \left(x\right) f_{\text{enc}} \left(y\right)$ 或 $s \left(x, y\right) = f_{\text{enc}} \left(x \oplus y\right)$。CTL 的核心思想是“通过对比进行学习”。

下图展示了预训练模型的分类和部分代表模型：

应用于下游任务

如何迁移

选择合适的预训练任务，模型架构和语料

不同的 PTMs 在相同的下游任务上有着不同的效果，这是因为 PTMs 有着不同的预训练任务，模型架构和语料。

1. 目前，语言模型是最流行的预训练任务，同时也可以有效地解决很多 NLP 问题。但是不同的预训练任务有着自己的侧重，在不同的任务上会有不同的效果。例如：NSP 任务使得 PTM 可以理解两句话之间的关系，因此 PTM 可以在例如问答（Question Answering，QA）和自然语言推理（Natural Language Inference，NLI）等下游任务上表现更好。
2. PTM 的网络架构对下游任务也至关重要。例如：尽管 BERT 可以处理大多数自然语言理解任务，对其很难生成语言。
3. 下游任务的数据分布应该和 PTM 训练所用语料相似。目前，大量现成的 PTM 仅可以快速地用于特定领域或特定语言的下游任务上。

选择合适的网络层

给定一个预训练的模型，不同的网络层捕获了不同的信息，例如：词性标记（POS tagging），语法（parsing），长期依赖（long-term dependencies），语义角色（semantic roles），指代（coreference）等。Tenney ²² 等人发现 BERT 表示方式类似传统的 NLP 流程：基础的句法信息出现在浅层的网络中，高级的语义信息出现在更高的层级中。

令 $\mathbf{H}^{\left(l\right)} \left(1 \leq l \leq L\right)$ 表示共 $L$ 层的预训练模型的第 $l$ 层表示，$g \left(\cdot\right)$ 表示用于特定任务的的模型。一般有 3 中情况选择表示：

1. Embedding Only：一种情况是仅选用预训练模型的静态嵌入，模型的其他部分仍需作为一个任务从头训练。这种情况不能够获取到一些有用的深层信息，词嵌入仅能够捕获词的语义信息。
2. Top Layer：最简单有效的方式是将网络的顶层表示输入到模型中 $g \left(\mathbf{H}^{\left(L\right)}\right)$。
3. All Layers：另一种更灵活的方式是自动选择最合适的层，例如 ELMo： $$ \mathbf{r}_t = \gamma \sum_{l=1}^{L}{\alpha_l \mathbf{h}^{\left(l\right)}_t} $$ 其中 $\alpha_l$ 是层 $l$ 的 softmax 归一的权重，$\gamma$ 是用于缩放预训练模型输出向量的一个标量值，再将不同层的混合输出输入到后续模型中 $g \left(\mathbf{r}_t\right)$。

是否微调

目前，主要有两种方式进行模型迁移：特征提取（预训练模型的参数是固定的）和模型微调（预训练模型的参数是经过微调的）。当采用特征提取时，预训练模型可以被看作是一个特征提取器。除此之外，我们应该采用内部层作为特征，因为他们通常是最适合迁移的特征。尽管两种不同方式都能对大多数 NLP 任务效果有显著提升，但以特征提取的方式需要更复杂的特定任务的架构。因此，微调是一种更加通用和方便的处理下游任务的方式。

微调策略

随着 PTMs 网络层数的加深，其捕获的表示使得下游任务变得越来越简单，因此整个模型中用于特定任务的网络层一般比较简单，微调已经成为了采用 PTMs 的主要方式。但是微调的过程通常是比较不好预估的，即使采用相同的超参数，不同的随机数种子也可能导致差异较大的结果。除了标准的微调外，如下为一些有用的微调策略：

两步骤微调

一种方式是两阶段的迁移，在预训练和微调之间引入了一个中间阶段。在第一个阶段，PTM 通过一个中间任务或语料转换为一个微调后的模型，在第二个阶段，再利用目标任务进行微调。

多任务微调

在多任务学习框架下对其进行微调。

利用额外模块进行微调

微调的主要缺点就是其参数的低效性。每个下游模型都有其自己微调好的参数，因此一个更好的解决方案是将一些微调好的适配模块注入到 PTMs 中，同时固定原始参数。

开放资源

PTMs 开源实现：

论文列表和 PTMs 相关资源：

预训练模型

CoVe (2017) ⁴

首先，给定一个源语言序列 $w^x = \left[w^x_1, \dotsc, w^x_n\right]$ 和一个翻译目标语言序列 $w^z = \left[w^z_1, \dotsc, w^z_n\right]$。令 $\text{GloVe} \left(w^x\right)$ 为词 $w^x$ 对应的 GloVe 向量，$z$ 为 $w^z$ 中的词随机初始化的词向量。将 $\text{GloVe} \left(w^x\right)$ 输入到一个标准的两层 biLSTM 网络中，称之为 MT-LSTM，MT-LSTM 用于计算序列的隐含状态如下：

$$ h = \text{MT-LSTM} \left(\text{GloVe} \left(w^x\right)\right) $$

对于机器翻译，MT-LSTM 的注意力机制的解码器可以对于输出的词在每一步产生一个分布 $p \left(\hat{w}^z_t \mid H, w^z_1, \dotsc, w^z_{t-1}\right)$。在 $t$ 步，解码器利用一个两层的单向 LSTM 基于之前目标词嵌入 $z_{t-1}$ 和一个基于上下文调整的隐含状态 $\tilde{h}_{t-1}$ 生成一个隐含状态 $h^{\text{dec}}_t$：

$$ h^{\text{dec}}_t = \text{LSTM} \left(\left[z_{t-1}; \tilde{h}_{t-1}\right], h^{\text{dec}}_{t-1}\right) $$

之后解码器计算每一步编码到当前解码状态的注意力权重 $\alpha$：

$$ \alpha_t = \text{softmax} \left(H \left(W_1 h^{\text{dec}}_t + b_1\right)\right) $$

其中 $H$ 表示 $h$ 按照时间维度的堆叠。之后解码器将这些权重作为相关性用于计算基于上下文调整的隐含状态 $\tilde{h}$：

$$ \tilde{h}_t = \text{tanh} \left(W_2 \left[H^{\top} \alpha_t; h^{\text{dec}}_t\right] + b_2\right) $$

最后，输出词的分布通过基于上下文调整的隐含状态计算可得：

$$ p \left(\hat{w}^z_t \mid H, w^z_1, \dotsc, w^z_{t-1}\right) = \text{softmax} \left(W_{\text{out}} \tilde{h}_t + b_{\text{out}}\right) $$

CoVe 将 MT-LSTM 学习到的表示迁移到下游任务中，令 $w$ 表示文字序列，$\text{GloVe} \left(w\right)$ 表示对应的 GloVe 向量，则：

$$ \text{CoVe} \left(w\right) = \text{MT-LSTM} \left(\text{GloVe} \left(w\right)\right) $$

表示由 MT-LSTM 产生的上下文向量，对于分类和问答任务，有一个输入序列 $w$，我们可以将 GloVe 和 CoVe 向量进行拼接作为其嵌入表示：

$$ \tilde{w} = \left[\text{GloVe} \left(w\right); \text{CoVe} \left(w\right)\right] $$

CoVe 网络架构示意图如下：

ELMo (2018) ⁵

在 ELMo 模型中，对于每个词条 $t_k$，一个 $L$ 层的 biLM 可以计算得到 $2L + 1$ 个表示：

$$ \begin{aligned} R_k &= \left\{\mathbf{x}^{LM}_k, \overrightarrow{\mathbf{h}}^{LM}_{k, j}, \overleftarrow{\mathbf{h}}^{LM}_{k, j} \mid j = 1, \dotsc, L \right\} \\ &= \left\{\mathbf{h}^{LM}_{k, j} \mid j = 0, \dotsc, L\right\} \end{aligned} $$

其中 $\mathbf{h}^{LM}_{k, 0}$ 为词条的嵌入层，$\mathbf{h}^{LM}_{k, j} = \left[\overrightarrow{\mathbf{h}}^{LM}_{k, j}; \overleftarrow{\mathbf{h}}^{LM}_{k, j}\right]$ 为每个 biLSTM 层。

对于下游任务，ELMo 将 $R$ 中的所有层汇总成一个向量 $\mathbf{ELMo}_k = E \left(R_k; \mathbf{\Theta}_e\right)$。在一些简单的案例中，ELMo 仅选择顶层，即：$E \left(R_k\right) = \mathbf{h}^{LM}_{k, L}$。更通用的，对于一个特定的任务，我们可以计算一个所有 biLM 层的加权：

$$ \mathbf{ELMo}^{task}_k = E \left(R_k; \Theta^{task}\right) = \gamma^{task} \sum_{j=0}^{L}{s^{task}_j \mathbf{h}^{LM}_{k, j}} $$

其中，$s^{task}$ 表示 softmax 归一化后的权重，$\gamma^{task}$ 允许模型对整个 ELMo 向量进行缩放。$\gamma$ 对整个优化过程具有重要意义，考虑每个 biLM 层的激活具有不同的分布，在一些情况下这相当于在进行加权之前对每一个 biLM 层增加了层标准化。

ELMo 网络架构示意图如下 ²³：

GPT (2018) ⁶

给定一个语料 $\mathcal{U} = \left\{u_1, \dotsc, u_n\right\}$，使用标准的语言建模目标来最大化如下似然：

$$ L_1 \left(\mathcal{U}\right) = \sum_{i} \log P \left(u_i \mid u_{i-k}, \dotsc, u_{i-1}; \Theta\right) $$

其中，$k$ 为上下文窗口的大小，条件概率 $P$ 通过参数为 $\Theta$ 的神经网络进行建模。GPT 中使用了一个多层的 Transformer Decoder 作为语言模型。模型首先对输入上下文词条应用多头自注意力机制，再通过按位置的前馈层产生目标词条的输出分布：

$$ \begin{aligned} h_0 &= UW_e + W_p \\ h_l &= \text{transformer_black} \left(h_{l-1}\right), \forall i \in \left[1, n\right] \\ P \left(u\right) &= \text{softmax} \left(h_n W^{\top}_e\right) \end{aligned} $$

其中，$U = \left(u_{-k}, \dotsc, u_{-1}\right)$ 为词条的上下文向量，$n$ 为网络层数，$W_e$ 为词条的嵌入矩阵，$W_p$ 为位置嵌入矩阵。

给定一个有标签的数据集 $\mathcal{C}$，其中包含了输入词条序列 $x^1, \dotsc, x^m$ 和对应的标签 $y$。利用上述预训练的模型获得输入对应的最后一个 Transformer 的激活输出 $h^m_l$，之后再将其输入到一个参数为 $W_y$ 的线性输入层中预测 $y$：

$$ P \left(y \mid x^1, \dotsc, x^m\right) = \text{softmax} \left(h^m_l W_y\right) $$

模型通过最小化如下损失进行优化：

$$ L_2 \left(\mathcal{C}\right) = \sum_{\left(x, y\right)} \log P \left(y \mid x^1, \dotsc, x^m\right) $$

研究还发现将语言建模作为微调的附加目标可以帮助提高模型的泛化能力，同时可以加速模型收敛。GPT 中采用如下的优化目标：

$$ L_3 \left(\mathcal{C}\right) = L_2 \left(\mathcal{C}\right) + \lambda L_1 \left(\mathcal{C}\right) $$

GPT 网络架构示意图如下：

BERT (2018) ⁷

BERT 采用了一中基于 Vaswani ¹⁴ 所提出模型的多层双向 Transformer 编码器。在 BERT 中，令 $L$ 为 Transformer Block 的层数，$H$ 为隐层大小，$A$ 为自注意力头的数量。在所有情况中，设置前馈层的大小为 $4H$，BERT 提供了两种不同大小的预训练模型：

• $\text{BERT}_{\text{BASE}}$：$L=12, H=768, A=12$，参数总量为 100 M。
• $\text{BERT}_{\text{LARGE}}$：$L=24, H=1024, A=16$，参数总量为 340 M。

$\text{BERT}_{\text{BASE}}$ 采用了同 GPT 相同的模型大小用于比较，不同与 GPT，BERT 使用了双向的注意力机制。在文献中，双向 Transformer 通常称之为 Transformer 编码器，仅利用左边上下文信息的 Transformer 由于可以用于文本生成被称之为 Transformer 解码器。BERT，GPT 和 ELMo 之间的不同如下图所示：

BERT 的输入表示既可以表示一个单独的文本序列，也可以表示一对文本序列（例如：问题和答案）。对于一个给定的词条，其输入表示由对应的词条嵌入，分割嵌入和位置嵌入三部分加和构成，如下图所示：

具体的有：

• 采用一个包含 30,000 个词条的 WordPiece 嵌入 ²⁴。
• 位置嵌入最大支持 512 个词条。
• 序列的第一字符采用特殊的分类嵌入 [CLS]，其最终的隐含状态在分类任务中用于汇总整个序列的表示，对于非分类任务则忽视该向量。
• 句子对被整合成一个序列，首先利用一个特殊词条 [SEP] 对句子进行分割，其次对于第一个句子中的每个词条叠加一个学习到的 A 句子嵌入，对于第二个句子中的每个词条叠加一个学习到的 B 句子嵌入。
• 对于一个单独的句子，仅使用 A 句子嵌入。

在预训练阶段，BERT 采用了两个无监督预测任务：

1. 遮罩的语言模型（Masked LM，MLM）
   不同于一般的仅利用 [MASK] 进行遮挡，BERT 选择采用 80% 的 [MASK]，10% 的随机词和 10% 保留原始词的方式对随机选择的 15% 的词条进行遮挡处理。由于编码器不知会预测哪个词或哪个词被随机替换了，这迫使其必须保留每个输入词条的分布式上下文表示。同时 1.5% 的随机替换也不会过多的损害模型的理解能力。
2. 预测是否为下一个句子（Next Sentence Prediction）
   一些重要的下游任务，例如问答（Question Answering，QA）和自然语言推断（Natural Language Inference，NLI）是基于两个句子之间关系的理解，这是语言建模无法直接捕获的。BERT 通过训练一个预测是否为下一个句子的二分类任务来实现，对于一个句子对 A 和 B，50% 的 B 是句子 A 真实的下一句，剩余 50% 为随机抽取的。

基于 BERT 的不同下游任务的实现形式如下图所示：

UniLM (2019) ²⁵

给定一个输入序列 $x = x_1 \cdots x_{|x|}$，UniLM 通过下图的方式获取每个词条的基于上下文的向量表示。整个预训练过程利用单向的语言建模（unidirectional LM），双向的语言建模（bidirectional LM）和 Seq2Seq 语言建模（sequence-to-sequence LM）优化共享的 Transformer 网络。

输入序列 $x$ 对于单向语言模型而言是一个分割的文本，对于双向语言模型和 Seq2Seq 语言模型而言是一对打包的分割文本。UniLM 在输入的起始位置添加特殊的 [SOS] （start-of-sequence），在结尾处添加 [EOS]（end-of-sequence）。[EOS] 对于自然语言理解（NLU）任务可以标记句子之间的界线，对于自然语言生成（NLG）任务可以确定解码过程停止的时间。输入的表示同 BERT 一样，文本利用 WordPiece 进行分割，对于每个输入词条，其向量表示为对应的词条嵌入，位置嵌入和分割嵌入的汇总。

对于输入向量 $\left\{\mathbf{x}_i\right\}^{|x|}_{i=1}$ 首先将其输入到隐层 $\mathbf{H}^0 = \left[\mathbf{x}_1, \dotsc, \mathbf{x}_{|x|}\right]$，之后使用一个 $L$ 层的 Transformer $\mathbf{H}^l = \text{Transformer}_l \left(\mathbf{H}^{l-1}\right), l \in \left[1, L\right]$ 对每一层 $\mathbf{H}^l = \left[\mathbf{h}^l_1, \dotsc, \mathbf{h}^l_{|x|}\right]$ 进行上下文表示编码。在每个 Tansformer 块中，使用多头自注意力机制对输出向量和上一层进行汇总，第 $l$ 层 Transformer 自注意力头 $\mathbf{A}_l$ 的输入通过如下方式计算：

`$$ \begin{aligned} \mathbf{Q} &= \mathbf{H}^{l-1} \mathbf{W}^Q_l, \mathbf{K} = \mathbf{H}^{l-1} \mathbf{W}^K_l, \mathbf{V} = \mathbf{H}^{l-1} \mathbf{W}^W_l \ \mathbf{M}_{ij} &= \begin{cases} 0, & \text{allow to attend} \

• \infty, & \text{prevent from attending} \end{cases} \ \mathbf{A}_l &= \text{softmax} \left(\dfrac{\mathbf{Q} \mathbf{K}^{\top}}{\sqrt{d_k}} + \mathbf{M}\right) \mathbf{V}_l \end{aligned} $$`

其中，上一层的输出 $\mathbf{H}^{l-1} \in \mathbb{R}^{|x| \times d_h}$ 通过参数矩阵 $\mathbf{W}^Q_l, \mathbf{W}^K_l, \mathbf{W}^V_l \in \mathbb{R}^{d_h \times d_k}$ 线性地映射为相应的 Query，Key 和 Value，遮罩矩阵 $\mathbf{M} \in \mathbb{R}^{|x| \times |x|}$ 用于确定一对词条是否可以被相互连接。

Transformer-XL (2019) ²⁶

将 Transformer 或注意力机制应用到语言建模中的核心问题是如何训练 Transformer 使其有效地将一个任意长文本编码为一个固定长度的表示。Transformer-XL 将整个语料拆分为较短的段落，仅利用每段进行训练并忽略之前段落的上下文信息。这种方式称之为 Vanilla Model ²⁷，如下图所示：

在这种训练模式下，无论是前向还是后向信息都不会跨越分割的段落进行传导。利用固定长度的上下文主要有两个弊端：

1. 这限制了最大依赖的长度，虽然自注意力机制不会像 RNN 一样受到梯度弥散的影响，但 Vanilla Model 也不能完全利用到这个优势。
2. 虽然可以利用补全操作来实现句子或其他语义的分割，但实际上通常会简单的将一个长文本截断成一个固定长度的分割，这样会产生上下文分裂破碎的问题。

为了解决这个问题，Transformer-XL 采用了一种循环机制的 Transformer。在训练阶段，在处理新的分割段落时，之前分割分部分的隐含状态序列将被**固定（fixed）和缓存（cached）**下来作为一个扩展的上下文被复用参与计算，如下图所示：

虽然梯度仍仅限于这个分割段落内部，但网络可以从历史中获取信息，从而实现对长期依赖的建模。令两个长度为 $L$ 的连续分割段落为 $\mathbf{s}_{\tau} = \left[x_{\tau, 1}, \dotsc, x_{\tau, L}\right]$ 和 $\mathbf{s}_{\tau + 1} = \left[x_{\tau + 1, 1}, \dotsc, x_{\tau + 1, L}\right]$，第 $\tau$ 段分割 $\mathbf{s}_{\tau}$ 的第 $n$ 层隐含状态为 $\mathbf{h}^n_{\tau} \in \mathbb{R}^{L \times d}$，其中 $d$ 为隐含维度。则对于分割段落 $\mathbf{s}_{\tau + 1}$ 的第 $n$ 层隐含状态通过如下方式进行计算：

$$ \begin{aligned} \tilde{\mathbf{h}}^{n-1}_{\tau + 1} &= \left[\text{SG} \left(\mathbf{h}^{n-1}_{\tau}\right) \circ \mathbf{h}^{n-1}_{\tau + 1} \right] \\ \mathbf{q}^{n}_{\tau + 1}, \mathbf{k}^{n}_{\tau + 1}, \mathbf{v}^{n}_{\tau + 1} &= \mathbf{h}^{n-1}_{\tau + 1} \mathbf{W}^{\top}_{q}, \tilde{\mathbf{h}}^{n-1}_{\tau + 1} \mathbf{W}^{\top}_{k}, \tilde{\mathbf{h}}^{n-1}_{\tau + 1} \mathbf{W}^{\top}_{v} \\ \mathbf{h}^{n}_{\tau + 1} &= \text{Transformer-Layer} \left(\mathbf{q}^{n}_{\tau + 1}, \mathbf{k}^{n}_{\tau + 1}, \mathbf{v}^{n}_{\tau + 1}\right) \end{aligned} $$

其中，$\text{SG} \left(\cdot\right)$ 表示停止梯度，$\left[\mathbf{h}_u \circ \mathbf{h}_v\right]$ 表示将两个隐含序列按照长度维度进行拼接，$\mathbf{W}$ 为模型的参数。与一般的 Transformer 相比，最大的不同在于 $\mathbf{k}^n_{\tau + 1}$ 和 $\mathbf{v}^n_{\tau + 1}$ 不仅依赖于 $\tilde{\mathbf{h}}^{n-1}_{\tau - 1}$ 还依赖于之前分割段落的 $\mathbf{h}^{n-1}_{\tau}$ 缓存。

在标准的 Transformer 中，序列的顺序信息通过位置嵌入 $\mathbf{U} \in \mathbb{R}^{L_{\max} \times d}$ 提供，其中第 $i$ 行 $\mathbf{U}_i$ 对应一个分割文本内部的第 $i$ 个绝对位置，$L_{\max}$ 为最大可能长度。在 Transformer-XL 中则是通过一种相对位置信息对其进行编码，构建一个相对位置嵌入 $\mathbf{R} \in \mathbb{R} ^{L_{\max} \times d}$，其中第 $i$ 行 $\mathbf{R}_i$ 表示两个位置之间相对距离为 $i$ 的嵌入表示。

对于一般的 Transformer，一个分割段落内部的 $q_i$ 和 $k_j$ 之间的注意力分数可以分解为：

$$ \begin{aligned} \mathbf{A}_{i, j}^{\mathrm{abs}} &=\underbrace{\mathbf{E}_{x_{i}}^{\top} \mathbf{W}_{q}^{\top} \mathbf{W}_{k} \mathbf{E}_{x_{j}}}_{(a)}+\underbrace{\mathbf{E}_{x_{i}}^{\top} \mathbf{W}_{q}^{\top} \mathbf{W}_{k} \mathbf{U}_{j}}_{(b)} \\ &+\underbrace{\mathbf{U}_{i}^{\top} \mathbf{W}_{q}^{\top} \mathbf{W}_{k} \mathbf{E}_{x_{j}}}_{(c)}+\underbrace{\mathbf{U}_{i}^{\top} \mathbf{W}_{q}^{\top} \mathbf{W}_{k} \mathbf{U}_{j}}_{(d)} \end{aligned} $$

利用相对位置思想，变化如下：

$$ \begin{aligned} \mathbf{A}_{i, j}^{\mathrm{rel}} &=\underbrace{\mathbf{E}_{x_{i}}^{\top} \mathbf{W}_{q}^{\top} \mathbf{W}_{k, E} \mathbf{E}_{x_{j}}}_{(a)}+\underbrace{\mathbf{E}_{x_{i}}^{\top} \mathbf{W}_{q}^{\top} \mathbf{W}_{k, R} \textcolor{blue}{\mathbf{R}_{i-j}}}_{(b)} \\ &+\underbrace{\textcolor{red}{u^{\top}} \mathbf{W}_{k, E} \mathbf{E}_{x_{j}}}_{(c)}+\underbrace{\textcolor{red}{v^{\top}} \mathbf{W}_{k, R} \textcolor{blue}{\mathbf{R}_{i-j}}}_{(d)} \end{aligned} $$

1. 首先，利用相对位置 $\textcolor{blue}{\mathbf{R}_{i-j}}$ 替代绝对位置嵌入 $\mathbf{U}_j$，这里 $\mathbf{R}$ 采用的是无需学习的 sinusoid 编码矩阵 ¹⁴。
2. 其次，引入了一个可训练的参数 $\textcolor{red}{u} \in \mathbb{R}^d$ 用于替换 $\mathbf{U}^{\top}_i \mathbf{W}^{\top}_q$。类似的，对于 $\mathbf{U}^{\top} \mathbf{W}^{\top}_q$ 使用一个可训练的 $\textcolor{red}{v} \in \mathbb{R}^d$ 替换。
3. 最后，有意地划分了两个权重矩阵 $\mathbf{W}_{k, E}$ 和 $\mathbf{W}_{k, R}$ 用于生成基于内容的 Key 向量和基于位置的 Key 向量。

这样，$\left(a\right)$ 代表了基于内容的位置信息，$\left(b\right)$ 捕获了内容无关的位置偏置，$\left(c\right)$ 表示了一个全局的内容偏置，$\left(d\right)$ 捕获了一个全局的位置偏置。

利用一个自注意力头计算 $N$ 层的 Transformer-XL 的过程如下，对于 $n = 1, \dotsc, N$ 有：

$$ \begin{aligned} \widetilde{\mathbf{h}}_{\tau}^{n-1}=&\left[\mathrm{SG}\left(\mathbf{m}_{\tau}^{n-1}\right) \circ \mathbf{h}_{\tau}^{n-1}\right] \\ \mathbf{q}_{\tau}^{n}, \mathbf{k}_{\tau}^{n}, \mathbf{v}_{\tau}^{n}=& \mathbf{h}_{\tau}^{n-1} {\mathbf{W}_{q}^{n}}^{\top}, \widetilde{\mathbf{h}}_{\tau}^{n-1} {\mathbf{W}_{k, E}^{n}}^{\top}, \widetilde{\mathbf{h}}_{\tau}^{n-1} {\mathbf{W}_{v}^{n}}^{\top} \\ \mathbf{A}_{\tau, i, j}^{n}=& {\mathbf{q}_{\tau, i}^{n}}^{\top} \mathbf{k}_{\tau, j}^{n} + {\mathbf{q}_{\tau, i}^{n}}^{\top} \mathbf{W}_{k, R}^{n} \mathbf{R}_{i-j} \\ &+u^{\top} \mathbf{k}_{\tau, j}+v^{\top} \mathbf{W}_{k, R}^{n} \mathbf{R}_{i-j} \\ \mathbf{a}_{\tau}^{n}=& \text { Masked-Softmax }\left(\mathbf{A}_{\tau}^{n}\right) \mathbf{v}_{\tau}^{n} \\ \mathbf{o}_{\tau}^{n}=& \text { LayerNorm } \left(\text{Linear}\left(\mathbf{a}_{\tau}^{n}\right)+\mathbf{h}_{\tau}^{n-1}\right) \\ \mathbf{h}_{\tau}^{n}=& \text { Positionwise-Feed-Forward }\left(\mathbf{o}_{\tau}^{n}\right) \end{aligned} $$

XLNet (2019) ¹⁹

给定一个序列 $\mathbf{X} = \left[x_1, \dotsc, x_T\right]$，AR 语言模型通过最大化如下似然进行预训练：

$$ \max_{\theta} \quad \log p_{\theta}(\mathbf{x})=\sum_{t=1}^{T} \log p_{\theta}\left(x_{t} | \mathbf{x}_{<t}\right)=\sum_{t=1}^{T} \log \frac{\exp \left(h_{\theta}\left(\mathbf{x}_{1: t-1}\right)^{\top} e\left(x_{t}\right)\right)}{\sum_{x^{\prime}} \exp \left(h_{\theta}\left(\mathbf{x}_{1: t-1}\right)^{\top} e\left(x^{\prime}\right)\right)} $$

其中，$h_{\theta}\left(\mathbf{x}_{1: t-1}\right)$ 是由 RNNs 或 Transformer 等神经网络网络模型生成的上下文表示，$e \left(x\right)$ 为 $x$ 的嵌入。对于一个文本序列 $\mathbf{x}$，BERT 首先构建了一个遮罩的数据集 $\hat{\mathbf{x}}$，令被遮挡的词条为 $\overline{\mathbf{x}}$，通过训练如下目标来利用 $\hat{\mathbf{x}}$ 重构 $\overline{\mathbf{x}}$：

$$ \max_{\theta} \quad \log p_{\theta}(\overline{\mathbf{x}} | \hat{\mathbf{x}}) \approx \sum_{t=1}^{T} m_{t} \log p_{\theta}\left(x_{t} | \hat{\mathbf{x}}\right)=\sum_{t=1}^{T} m_{t} \log \frac{\exp \left(H_{\theta}(\hat{\mathbf{x}})_{t}^{\top} e\left(x_{t}\right)\right)}{\sum_{x^{\prime}} \exp \left(H_{\theta}(\hat{\mathbf{x}})_{t}^{\top} e\left(x^{\prime}\right)\right)} $$

其中 $m_t = 1$ 表示 $x_t$ 是被遮挡的，$H_{\theta}$ 是一个 Transformer 将一个长度为 $T$ 的文本序列映射到一个隐含向量序列 $H_{\theta}(\mathbf{x})=\left[H_{\theta}(\mathbf{x})_{1}, H_{\theta}(\mathbf{x})_{2}, \cdots, H_{\theta}(\mathbf{x})_{T}\right]$。两种不同的预训练目标的优劣势如下

1. 独立假设：BERT 中联合条件概率 $p(\overline{\mathbf{x}} | \hat{\mathbf{x}})$ 假设在给定的 $\hat{\mathbf{x}}$ 下，遮挡的词条 $\overline{\mathbf{x}}$ 是相关独立的，而 AR 语言模型则没有这样的假设。
2. 输入噪声：BERT 在预训练是使用了特殊标记 [MASK]，在下游任务微调时不会出现，而 AR 语言模型则不会存在这个问题。
3. 上下文依赖：AR 语言模型仅考虑了词条左侧的上下文，而 BERT 则可以捕获两个方向的上下文。

为了利用 AR 语言模型和 BERT 的优点，XLNet 提出了排序语言模型。对于一个长度为 $T$ 序列 $\mathbf{x}$，共有 $T!$ 种不同的方式进行 AR 分解，如果模型共享不同分解顺序的参数，那么模型就能学习到两侧所有位置的信息。令 $\mathcal{Z}_T$ 为长度为 $T$ 的索引序列 $\left[1, 2, \dotsc, T\right]$ 的所有可能排列，$z_t$ 和 $\mathbf{z}_{<t}$ 分别表示一个排列 $\mathbf{z} \in \mathcal{Z}_T$ 第 $t$ 个和前 $t-1$ 个元素。则排列语言模型的优化目标为：

$$ \max_{\theta} \quad \mathbb{E}_{\mathbf{z} \sim \mathcal{Z}_{T}}\left[\sum_{t=1}^{T} \log p_{\theta}\left(x_{z_{t}} | \mathbf{x}_{\mathbf{z}_{<t}}\right)\right] $$

根据标准的 Transformer，下一个词条的分布 $p_{\theta}\left(X_{z_{t}} | \mathbf{x}_{\mathbf{z}<t}\right)$ 为：

$$ p_{\theta}\left(X_{z_{t}} = x | \mathbf{x}_{\mathbf{z}<t}\right)=\frac{\exp \left(e(x)^{\top} h_{\theta}\left(\mathbf{x}_{\mathbf{z}<t}\right)\right)}{\sum_{x^{\prime}} \exp \left(e\left(x^{\prime}\right)^{\top} h_{\theta}\left(\mathbf{x}_{\mathbf{z}<t}\right)\right)} $$

其中，$h_{\theta}\left(\mathbf{x}_{\mathbf{z}<t}\right)$ 表示通过共享的 Transformer 产生的 $\mathbf{X}_{\mathbf{Z}<t}$ 的隐含表示。该表示并不依赖于所预测的位置，为了避免这个问题，我们将位置 $z_t$ 加入到模型中：

$$ p_{\theta}\left(X_{z_{t}}=x | \mathbf{x}_{z_{<t}}\right)=\frac{\exp \left(e(x)^{\top} g_{\theta}\left(\mathbf{x}_{\mathbf{z}<t}, z_{t}\right)\right)}{\sum_{x^{\prime}} \exp \left(e\left(x^{\prime}\right)^{\top} g_{\theta}\left(\mathbf{x}_{\mathbf{z}<t}, z_{t}\right)\right)} $$

对于 $g_{\theta}\left(\mathbf{x}_{\mathbf{z}<t}, z_{t}\right)$ 进行建模需要满足如下两个要求：

1. 预测 $x_{z_t}$ 时，$g_{\theta}\left(\mathbf{x}_{\mathbf{z}<t}, z_{t}\right)$ 只能使用位置信息 $z_t$ 而不能使用内容信息 $x_{z_t}$。
2. 在预测 $x_{z_t}$ 之后的词条时，$g_{\theta}\left(\mathbf{x}_{\mathbf{z}<t}, z_{t}\right)$ 又必须包含 $x_{z_t}$ 的语义信息。

为了解决这个问题，XLNet 提供了两种隐含表示：

1. 内容隐含表示 $h_{\theta}\left(\mathbf{x}_{\mathbf{z} \leq t}\right)$，简写为 $h_{z_t}$，它和标准的 Transformer 一样，既编码上下文也编码 $x_{z_t}$ 的内容。
2. 查询隐含表示 $g_{\theta}\left(\mathbf{x}_{\mathbf{z}<t}, z_{t}\right)$，简写为 $g_{z_t}$，它仅编码上下文信息 $\mathbf{X}_{\mathbf{Z}<t}$ 和位置信息 $z_t$，不编码内容 $x_{z_t}$。

模型的整个计算过程如下图所示：

虽然排列语言模型有很多优点，但是由于计算量很大，模型很难进行优化，因此我们通过仅预测一个句子后面的一些词条解决这个问题。将 $\mathbf{z}$ 分为两部分：非目标子序列 $\mathbf{z}_{\leq c}$ 和目标子序列 $\mathbf{z}_{>c}$，其中 $c$ 为切分点。同时会设置一个超参数 $K$，表示仅 $1 / K$ 的词条会被预测，有 $|\mathbf{z}| /(|\mathbf{z}|-c) \approx K$。对于未被选择的词条，其查询隐状态无需被计算，从而节省计算时间和资源。

MASS (2019) ¹⁶

MASS 是一个专门针对序列到序列的自然语言任务设计的预训练方法，对于一个给定的原始句子 $x \in \mathcal{X}$，令 $x^{\setminus u:v}$ 表示将 $x$ 从 $u$ 到 $v$ 位置进行遮挡处理，$k = v - u + 1$ 为被遮挡词条的个数，$x^{u:v}$ 为从 $u$ 到 $v$ 位置被遮挡的部分。MASS 利用被遮挡的序列 $x^{\setminus u:v}$ 预测被遮挡的部分 $x^{u:v}$，目标函数的对数似然如下：

$$ \begin{aligned} L(\theta ; \mathcal{X}) &=\frac{1}{|\mathcal{X}|} \Sigma_{x \in \mathcal{X}} \log P\left(x^{u: v} | x^{\setminus u: v} ; \theta\right) \\ &=\frac{1}{|\mathcal{X}|} \Sigma_{x \in \mathcal{X}} \log \prod_{t=u}^{v} P\left(x_{t}^{u: v} | x_{<t}^{u: v}, x^{\setminus u: v} ; \theta\right) \end{aligned} $$

对于一个具有 8 个词条的序列，$x_3 x_4 x_5 x_6$ 被遮挡的示例如下：

模型仅预测遮挡的部分 $x_3 x_4 x_5 x_6$，对于解码器中位置 $4-6$ 利用 $x_3 x_4 x_5$ 作为输入，利用特殊遮挡符号 $\left[\mathbb{M}\right]$ 作为其他位置的输入。对于不同长度 $k$，MASS 包含了上文中提到的两种预训练模型：

对于不同 $k$ 值，实验发现当 $k$ 处于 $m$ 的 $50\%$ 至 $70\%$ 之间时下游任务性能最优。

当 $k = 0.5 m$ 时，MASS 可以很好地平衡编码器和解码器的预训练。过度地偏向编码器（$k=1$，masked LM in BERT）和过度地偏向解码器（$k=m$，masked LM in GPT）均不能在下游的自然语言生成任务中取得很好的效果。

RoBERTa (2019) ¹⁸

RoBERTa 主要围绕 BERT 进行了如下改进：

1. 模型采用了动态遮罩，不同于原始 BERT 中对语料预先进行遮罩处理，RoBERTa 在 40 轮训练过程中采用了 10 种不同的遮罩。
2. 模型去掉了 NSP 任务，发现可以略微提升下游任务的性能。
3. 模型采用了更大的训练数据和更大的 Batch 大小。
4. 原始 BERT 采用一个 30K 的 BPE 词表，RoBERTa 采用了一个更大的 50K 的词表 ²⁸。

BART (2019) ²⁰

BART 采用了一个标准的 Seq2Seq Transformer 结构，类似 GPT 将 ReLU 激活函数替换为 GeLUs。对于基线模型，采用了一个 6 层的编码和解码器，对于更大模型采用了 12 层的结构。相比于 BERT 的架构主要有以下两点不同：

1. 解码器的每一层叠加了对编码器最后一个隐含层的注意力。
2. BERT 在预测之前采用了一个前馈的网络，而 BART 没有。

BART 采用了最小化破坏后的文档和原始文档之间的重构误差的方式进行预训练。不同于其他的一些去噪自编码器，BART 可以使用任意类型的文档破坏方式。极端情况下，当源文档的所有信息均丢失时，BART 就等价与一个语言模型。BART 中采用的文本破坏方式有：字符遮罩，字符删除，文本填充，句子重排，文档旋转，如下图所示：

T5 (2019) ¹⁷

T5（Text-to-Text Transfer Transformer） 提出了一种 text-to-text 的框架，旨在利用相同的模型，损失函数和超参数等对机器翻译，文档摘要，问答和分类（例如：情感分析）等任务进行统一建模。我们甚至可以利用 T5 通过预测一个数字的文本表示而不是数字本身来建模一个回归任务。模型及其输入输出如下图所示：

Google 的这项研究并不是提出一种新的方法，而是从全面的视角来概述当前 NLP 领域迁移学习的发展现状。T5 还公开了一个名为 C4（Colossal Clean Crawled Corpus）的数据集，该数据集是一个比 Wikipedia 大两个数量级的 Common Crawl 的清洗后版本的数据。更多模型的细节请参见源论文和 Google 的 官方博客。

ERNIE (Baidu, 2019) ^{29 30}

ERNIE 1.0 ²⁹ 通过建模海量数据中的词、实体及实体关系，学习真实世界的语义知识。相较于 BERT 学习原始语言信号，ERNIE 直接对先验语义知识单元进行建模，增强了模型语义表示能力。例如：

BERT ：哈 [mask] 滨是 [mask] 龙江的省会，[mask] 际冰 [mask] 文化名城。
ERNIE：[mask] [mask] [mask] 是黑龙江的省会，国际 [mask] [mask] 文化名城。

在 BERT 模型中，我们通过『哈』与『滨』的局部共现，即可判断出『尔』字，模型没有学习与『哈尔滨』相关的任何知识。而 ERNIE 通过学习词与实体的表达，使模型能够建模出『哈尔滨』与『黑龙江』的关系，学到『哈尔滨』是 『黑龙江』的省会以及『哈尔滨』是个冰雪城市。

训练数据方面，除百科类、资讯类中文语料外，ERNIE 还引入了论坛对话类数据，利用 DLM（Dialogue Language Model）建模 Query-Response 对话结构，将对话 Pair 对作为输入，引入 Dialogue Embedding 标识对话的角色，利用 Dialogue Response Loss 学习对话的隐式关系，进一步提升模型的语义表示能力。

ERNIE 2.0 ³⁰ 是基于持续学习的语义理解预训练框架，使用多任务学习增量式构建预训练任务。ERNIE 2.0 中，新构建的预训练任务类型可以无缝的加入训练框架，持续的进行语义理解学习。 通过新增的实体预测、句子因果关系判断、文章句子结构重建等语义任务，ERNIE 2.0 语义理解预训练模型从训练数据中获取了词法、句法、语义等多个维度的自然语言信息，极大地增强了通用语义表示能力。

State-of-Art

NLP 任务的 State-of-Art 模型详见：

• GLUE Leaderboard
• SuperGLUE Leaderboard
• SQuAD
• NLP-progress
• 中文任务基准测评

Encoder-Decoder 是一种包含两个神经网络的模型，两个网络分别扮演编码器和解码器的角色。Cho 等人 ¹ 提出了一个基于 RNN 的 Encoder-Decoder 神经网络用于机器翻译。网络结构如下图所示：

整个模型包含编码器 (Encoder) 和解码器 (Decoder) 两部分：Encoder 将一个可变长度的序列转换成为一个固定长度的向量表示，Decoder 再将这个固定长度的向量表示转换为一个可变长度的序列。这使得模型可以处理从一个可变长度序列到另一个可变长度序例的转换，即学习到对应的条件概率 $p \left(y_1, \dotsc, y_{T'} | x_1, \dotsc, x_T\right)$，其中 $T$ 和 $T'$ 可以为不同的值，也就是说输入和输出的序列的长度不一定相同。

在模型中，Encoder 为一个 RNN，逐次读入输入序列 $\mathbf{x}$ 中的每个元素，其中 RNN 隐状态的更新方式如下：

$$ \mathbf{h}_{\langle t \rangle} = f \left(\mathbf{h}_{\langle t-1 \rangle}, x_t\right) $$

在读入序列的最后一个元素后 (通常为一个结束标记)，RNN 的隐状态则为整个输入序列的概括信息 $\mathbf{c}$。Decoder 为另一个 RNN，用于根据隐状态 $\mathbf{h}'_{\langle t \rangle}$ 预测下一个元素 $y_t$，从而生成整个输出序列。不同于 Encoder 中的 RNN，Decoder 中 RNN 的隐状态 $\mathbf{h}'_{\langle t \rangle}$ 除了依赖上一个隐含层的状态和之前的输出外，还依赖整个输入序列的概括信息 $\mathbf{c}$，即：

$$ \mathbf{h}'_{\langle t \rangle} = f \left(\mathbf{h}'_{\langle t-1 \rangle}, y_{t-1}, \mathbf{c}\right) $$

类似的，下一个输出元素的条件分布为：

$$ P \left(y_t | y_{t-1}, y_{t-2}, \dotsc, y_1, \mathbf{c}\right) = g \left(\mathbf{h}_{\langle t \rangle}, y_{t-1}, \mathbf{c}\right) $$

RNN Encoder-Decoder 的两部分通过最大化如下的对数似然函数的联合训练进行优化：

$$ \max_{\theta} \dfrac{1}{N} \sum_{n=1}^{N}{\log p_{\theta} \left(\mathbf{y}_n | \mathbf{x}_n\right)} $$

其中，$\theta$ 为模型的参数，$\mathbf{x}_n$ 和 $\mathbf{y}_n$ 分别为输入和输出序列的成对样本。当模型训练完毕后，我们可以利用模型根据给定的输入序列生成相应的输出序列，或是根据给定的输入和输出序列对计算概率得分 $p_{\theta} \left(\mathbf{y} | \mathbf{x}\right)$。同时，作者还提出了一种新的 RNN 单元 GRU (Gated Recurrent Unit)，有关 GRU 的更多介绍请参见 之前的博客。

序列到序列 (Sequence to Sequence, Seq2Seq) 模型从名称中不难看出来是一种用于处理序列数据到序列数据转换问题 (例如：机器翻译等) 的方法。Sutskever 等人 ² 提出了一种基于 Encoder-Decoder 网络结构的 Seq2Seq 模型用于机器翻译，网络结构细节同 RNN Encoder-Decoder 略有不同，如下图所示：

模型的相关细节如下：

1. 对数据进行预处理，在每个句子的结尾添加特殊字符 <EOS>，如上图所示。首先计算 A, B, C, <EOS> 的表示，再利用该表示计算 W, X, Y, Z, <EOS> 的条件概率。
2. 利用两个不同的 LSTM，一个用于输入序列，另一个用于输出序列。
3. 选用一个较深的 LSTM 模型 (4 层) 提升模型效果。
4. 对输入序列进行倒置处理，例如对于输入序列 $a, b, c$ 和对应的输出序列 $\alpha, \beta, \gamma$，LSTM 需要学习的映射关系为 $c, b, a \to \alpha, \beta, \gamma$。

在模型的解码阶段，模型采用简单的从左到右的 Beam Search，该方法维护一个大小为 $B$ 的集合保存最好的结果。下图展示了 $B = 2$ 情况下 Beam Search 的具体工作方式：

其中，红色的虚线箭头表示每一步可能的搜索方向，绿色的实线箭头表示每一步概率为 Top $B$ 的方向。例如，从 S 开始搜索：

1. 第一步搜索的可能结果为 SA 和 SB，保留 Top 2，结果为 SA 和 SB。
2. 第二步搜索的可能结果为 SAC，SAD，SBE 和 SBF，保留 Top 2，结果为 SAC 和 SBE。
3. 第三步搜索的可能结果为 SACG，SACH，SBEK 和 SBEL，保留 Top 2，结果为 SACH 和 SBEK。至此，整个搜索结束。

Bahdanau 等人 ³ 提出了一种基于双向 RNN (Bidirectional RNN, BiRNN) 结合注意力机制 (Attention Mechanism) 的网络结构用于机器翻译。网络结构如下：

模型的编码器使用了一个双向的 RNN，前向的 RNN $\overrightarrow{f}$ 以从 $x_1$ 到 $x_T$ 的顺序读取输入序列并计算前向隐状态 $\left(\overrightarrow{h}_1, \dotsc, \overrightarrow{h}_T\right)$，后向的 RNN $\overleftarrow{f}$ 以从 $x_T$ 到 $x_1$ 的顺序读取输入序列并计算后向隐状态 $\left(\overleftarrow{h}_1, \dotsc, \overleftarrow{h}_T\right)$。对于一个词 $x_j$，通过将对应的前向隐状态 $\overrightarrow{h}_j$ 和后向隐状态 $\overleftarrow{h}_j$ 进行拼接得到最终的隐状态 $h_j = \left[\overrightarrow{h}_j^{\top}; \overleftarrow{h}_j^{\top}\right]^{\top}$。这样的操作使得隐状态 $h_j$ 既包含了前面词的信息也包含了后面词的信息。

在模型的解码器中，对于一个给定的序例 $\mathbf{x}$，每一个输出的条件概率为：

$$ p \left(y_i | y_1, \dotsc, y_{i-1}, \mathbf{x}\right) = g \left(y_{i-1}, s_i, c_i\right) $$

其中，$s_i$ 为 $i$ 时刻 RNN 隐含层的状态，即：

$$ s_i = f \left(s_{i-1}, y_{i-1}, c_i\right) $$

这里需要注意的是不同于之前的 Encoder-Decoder 模型，此处每一个输出词 $y_i$ 的条件概率均依赖于一个单独的上下文向量 $c_i$。该部分的改进即结合了注意力机制，有关注意力机制的详细内容将在下个小节中展开说明。

注意力机制 (Attention Mechanism)

Bahdanau 等人在文中 ³ 提出传统的 Encoder-Decoder 模型将输入序列压缩成一个固定长度的向量 $c$，但当输入的序例很长时，尤其是当比训练集中的语料还长时，模型的的效果会显著下降。针对这个问题，如上文所述，上下文向量 $c_i$ 依赖于 $\left(h_1, \dotsc, h_T\right)$。其中，每个 $h_i$ 都包含了整个序列的信息，同时又会更多地关注第 $i$ 个词附近的信息。对于 $c_i$，计算方式如下：

$$ c_i = \sum_{j=1}^{T}{\alpha_{ij} h_j} $$

对于每个 $h_j$ 的权重 $\alpha_{ij}$，计算方式如下：

$$ \alpha_{ij} = \dfrac{\exp \left(e_{ij}\right)}{\sum_{k=1}^{T}{\exp \left(e_{ik}\right)}} $$

其中，$e_{ij} = a \left(s_{i-1}, h_j\right)$ 为一个 Alignment 模型，用于评价对于输入的位置 $j$ 附近的信息与输出的位置 $i$ 附近的信息的匹配程度。Alignment 模型 $a$ 为一个用于评分的前馈神经网络，与整个模型进行联合训练，计算方式如下：

$$ a \left(s_{i-1}, h_j\right) = v_a^{\top} \tanh \left(W_a s_{i-1} + U_a h_j\right) $$

其中，$W_a \in \mathbb{R}^{n \times n}, U_a \in \mathbb{R}^{n \times 2n}，v_a \in \mathbb{R}^n$ 为网络的参数。

Hard & Soft Attention

Xu 等人 ⁴ 在图像标题生成 (Image Caption Generation) 任务中引入了注意力机制。在文中作者提出了 Hard Attenttion 和 Soft Attention 两种不同的注意力机制。

对于 Hard Attention 而言，令 $s_t$ 表示在生成第 $t$ 个词时所关注的位置变量，$s_{t, i} = 1$ 表示当第 $i$ 个位置用于提取视觉特征。将注意力位置视为一个中间潜变量，可以以一个参数为 $\left\{\alpha_i\right\}$ 的多项式分布表示，同时将上下文向量 $\hat{\mathbf{z}}_t$ 视为一个随机变量：

$$ \begin{equation} \begin{split} & p \left(s_{t, i} = 1 | s_{j < t}, \mathbf{a}\right) = \alpha_{t, i} \\ & \hat{\mathbf{z}}_t = \sum_{i}{s_{t, i} \mathbf{a}_i} \end{split} \end{equation} $$

因此 Hard Attention 可以依据概率值从隐状态中进行采样计算得到上下文向量，同时为了实现梯度的反向传播，需要利用蒙特卡罗采样的方法来估计梯度。

对于 Soft Attention 而言，则直接计算上下文向量 $\hat{\mathbf{z}}_t$ 的期望，计算方式如下：

$$ \mathbb{E}_{p \left(s_t | a\right)} \left[\hat{\mathbf{z}}_t\right] = \sum_{i=1}^{L}{\alpha_{t, i} \mathbf{a}_i} $$

其余部分的计算方式同 Bahdanau 等人 ³ 的论文类似。Soft Attention 模型可以利用标准的反向传播算法进行求解，直接嵌入到整个模型中一同训练，相对更加简单。

下图展示了一些图片标题生成结果的可视化示例，其中图片内 白色 为关注的区域，画线的文本 即为生成的标题中对应的词。

Global & Local Attention

Luong 等人 ⁵ 提出了 Global Attention 和 Local Attention 两种不同的注意力机制用于机器翻译。Global Attention 的思想是在计算上下文向量 $c_t$ 时将编码器的所有隐状态均考虑在内。对于对齐向量 $\boldsymbol{a}_t$，通过比较当前目标的隐状态 $\boldsymbol{h}_t$ 与每一个输入的隐状态 $\bar{\boldsymbol{h}}_s$ 得到，即：

$$ \begin{equation} \begin{split} \boldsymbol{a}_t &= \text{align} \left(\boldsymbol{h}_t, \bar{\boldsymbol{h}}_s\right) \\ &= \dfrac{\exp \left(\text{score} \left(\boldsymbol{h}_t, \bar{\boldsymbol{h}}_s\right)\right)}{\sum_{s'}{\exp \left(\text{score} \left(\boldsymbol{h}_t, \bar{\boldsymbol{h}}_{s'}\right)\right)}} \end{split} \end{equation} $$

其中 $\text{score}$ 为一个基于内容 (content-based) 的函数，可选的考虑如下三种形式：

$$ \text{score} \left(\boldsymbol{h}_t, \bar{\boldsymbol{h}}_s\right) = \begin{cases} \boldsymbol{h}_t^{\top} \bar{\boldsymbol{h}}_s & dot \\ \boldsymbol{h}_t^{\top} \boldsymbol{W}_a \bar{\boldsymbol{h}}_s & general \\ \boldsymbol{W}_a \left[\boldsymbol{h}_t; \bar{\boldsymbol{h}}_s\right] & concat \end{cases} $$

我们利用一个基于位置 (location-based) 的函数构建注意力模型，其中对齐分数通过目标的隐状态计算得到：

$$ \boldsymbol{a}_t = \text{softmax} \left(\boldsymbol{W}_a \boldsymbol{h}_t\right) $$

Global Attention 模型的网络结构如下所示：

Global Attention 的一个问题在于任意一个输出都需要考虑输入端的所有隐状态，这对于很长的文本 (例如：一个段落或一篇文章) 计算量太大。Local Attention 为了解决这个问题，首先在 $t$ 时刻对于每个目标词生成一个对齐位置 $p_t$，其次上下文向量 $\boldsymbol{c}_t$ 则由以 $p_t$ 为中心前后各 $D$ 大小的窗口 $\left[p_t - D, p_t + D\right]$ 内的输入的隐状态计算得到。不同于 Global Attention，Local Attention 的对齐向量 $\boldsymbol{a}_t \in \mathbb{R}^{2D + 1}$ 为固定维度。

一个比较简单的做法是令 $p_t = t$，也就是假设输入和输出序列是差不多是单调对齐的，我们称这种做法为 Monotonic Alignment (local-m)。另一种做法是预测 $p_t$，即：

$$ p_t = S \cdot \text{sigmoid} \left(\boldsymbol{v}_p^{\top} \tanh \left(\boldsymbol{W}_p \boldsymbol{h}_t\right)\right) $$

其中，$\boldsymbol{W}_p$ 和 $\boldsymbol{h}_t$ 为预测位置模型的参数，$S$ 为输入句子的长度。我们称这种做法为 Predictive Alignment (local-p)。作为 $\text{sigmoid}$ 函数的结果，$p_t \in \left[0, S\right]$，则通过一个以 $p_t$ 为中心的高斯分布定义对齐权重：

$$ \boldsymbol{a}_t \left(s\right) = \text{align} \left(\boldsymbol{h}_t, \bar{\boldsymbol{h}}_s\right) \exp \left(- \dfrac{\left(s - p_t\right)^2}{2 \sigma^2}\right) $$

其中，根据经验设置 $\sigma = \dfrac{D}{2}$，$s$ 为在窗口大小内的一个整数。

Local Attention 模型的网络结构如下所示：

Self Attention

Vaswani 等人 ⁶ 提出了一种新的网络结构，称之为 Transformer，其中采用了自注意力 (Self-attention) 机制。自注意力是一种将同一个序列的不同位置进行自我关联从而计算一个句子表示的机制。Transformer 利用堆叠的 Self Attention 和全链接网络构建编码器 (下图左) 和解码器 (下图右)，整个网络架构如下图所示：

编码器和解码器

编码器 是由 $N = 6$ 个相同的网络层构成，每层中包含两个子层。第一层为一个 Multi-Head Self-Attention 层，第二层为一个 Position-Wise 全链接的前馈神经网络。每一层再应用一个残差连接 (Residual Connection) ⁷ 和一个层标准化 (Layer Normalization) ⁸。则每一层的输出为 $\text{LayerNorm} \left(x + \text{Sublayer} \left(x\right)\right)$，其中 $\text{Sublayer} \left(x\right)$ 为子层本身的函数实现。为了实现残差连接，模型中所有的子层包括 Embedding 层的输出维度均为 $d_{\text{model}} = 512$。

解码器 也是由 $N = 6$ 个相同的网络层构成，但每层中包含三个子层，增加的第三层用于处理编码器的输出。同编码器一样，每一层应用一个残差连接和一个层标准化。除此之外，解码器对 Self-Attention 层进行了修改，确保对于位置 $i$ 的预测仅依赖于位置在 $i$ 之前的输出。

Scaled Dot-Product & Multi-Head Attention

一个 Attention 函数可以理解为从一个序列 (Query) 和一个键值对集合 (Key-Value Pairs Set) 到一个输出的映射。文中提出了一种名为 Scaled Dot-Product Attention (如下图所示)，其中输入包括 queries，维度为 $d_k$ 的 keys 和维度为 $d_v$ 的 values。通过计算 queries 和所有 keys 的点积，除以 $\sqrt{d_k}$，再应用一个 softmax 函数获取 values 的权重。

实际中，我们会同时计算一个 Queries 集合中的 Attention，并将其整合成一个矩阵 $Q$。Keys 和 Values 也相应的整合成矩阵 $K$ 和 $V$，则有：

$$ \text{Attention} \left(Q, K, V\right) = \text{softmax} \left(\dfrac{Q K^{\top}}{\sqrt{d_k}}\right) V $$

其中，$Q \in \mathbb{R}^{n \times d_k}$，$Q$ 中的每一行为一个 query，$K \in \mathbb{R}^{n \times d_k}, V \in \mathbb{R}^{n \times d_v}$。$\dfrac{1}{\sqrt{d_k}}$ 为一个归一化因子，避免点积的值过大导致 softmax 之后的梯度过小。

Multi-Head Attention 的做法并不直接对原始的 keys，values 和 queries 应用注意力函数，而是学习一个三者各自的映射再应用 Atteneion，同时将这个过程重复 $h$ 次。Multi-Head Attention 的网路结构如下图所示：

Multi-Head Attention 的计算过程如下所示：

$$ \begin{equation} \begin{split} \text{MultiHead} \left(Q, K, V\right) &= \text{Concat} \left(\text{head}_1, \dotsc, \text{head}_h\right) W^O \\ \textbf{where } \text{head}_i &= \text{Attention} \left(QW_i^Q, KW_i^K, VW_i^V\right) \end{split} \end{equation} $$

其中，$W_i^Q \in \mathbb{R}^{d_{\text{model}} \times d_k}, W_i^K \in \mathbb{R}^{d_{\text{model}} \times d_k}, W_i^V \in \mathbb{R}^{d_{\text{model}} \times d_v}, W_i^O \in \mathbb{R}^{h d_v \times d_{\text{model}}}, $ 为映射的参数，$h = 8$ 为重复的次数，则有 $d_k = d_v = d_{\text{model}} / h = 64$。

整个 Transformer 模型在三处使用了 Multi-Head Attention，分别是：

1. Encoder-Decoder Attention Layers，其中 queries 来自于之前的 Decoder 层，keys 和 values 来自于 Encoder 的输出，该部分同其他 Seq2Seq 模型的 Attention 机制类似。
2. Encoder Self-Attention Layers，其中 queries，keys 和 values 均来自之前的 Encoder 层的输出，同时 Encoder 层中的每个位置都能够从之前层的所有位置获取到信息。
3. Decoder Self-Attention Layers，其中 queries，keys 和 values 均来自之前的 Decoder 层的输出，但 Decoder 层中的每个位置仅可以从之前网络层的包含当前位置之前的位置获取信息。

Position-wise Feed-Forward Networks

在 Encoder 和 Decoder 中的每一层均包含一个全链接的前馈神经网络，其使用两层线性变换和一个 ReLU 激活函数实现：

$$ \text{FFN} \left(x\right) = \max \left(0, x W_1 + b_1\right) W_2 + b_2 $$

全链接层的输入和输出的维度 $d_{\text{model}} = 512$，内层的维度 $d_{ff} = 2048$。

Positional Encoding

Transformer 模型由于未使用任何循环和卷积组件，因此为了利用序列的位置信息则在模型的 Embedding 输入中添加了 Position Encoding。Position Encoding 的维度同 Embedding 的维度相同，从而可以与 Embedding 进行加和，文中使用了如下两种形式：

$$ \begin{equation} \begin{split} PE_{\left(pos, 2i\right)} &= \sin \left(pos / 10000^{2i / d_{\text{model}}}\right) \\ PE_{\left(pos, 2i+1\right)} &= \cos \left(pos / 10000^{2i / d_{\text{model}}}\right) \end{split} \end{equation} $$

其中，$pos$ 为位置，$i$ 为对应的维度，选用这种表示形式的原因是对于一个固定的偏移 $k$，$PE_{pos + k}$ 都可以利用 $PE_{pos}$ 线性表示。这是因为对于正弦和余弦函数有：

$$ \begin{equation} \begin{split} \sin \left(\alpha + \beta\right) &= \sin \alpha \cos \beta + \cos \alpha \sin \beta \\ \cos \left(\alpha + \beta\right) &= \cos \alpha \sin \beta - \sin \alpha \sin \beta \end{split} \end{equation} $$

Why Self-Attention

相比于循环和卷积层，Transformer 模型利用 Self-Attention 层用于一个序列 $\left(x_1, \dotsc, x_n\right)$ 到另一个等长序例 $\left(z_1, \dotsc, z_n\right)$ 的映射，其中 $x_i, z_i \in \mathbb{R}^d$。Self-Attention 与循环和卷积的对比如下表所示：

1. 对于每层的复杂度，当序例的长度 $n$ 比表示的维度 $d$ 小时，Self-Attention 要比循环结构计算复杂度小。为了改进在长序列上 Self-Attention 的计算性能，Self-Attention 可以被限制成仅考虑与输出位置对应的输入序列位置附近 $r$ 窗口大小内的信息。
2. Recurrent 层的最小序列操作数为 $O \left(n\right)$，其他情况为 $O \left(1\right)$，这使得 Recurrent 的并行能力较差，即上表中的 Self-Attention (restricted)。
3. 学习到长距离依赖是很多序列任务的关键，影响该能力的一个重要因素就是前向和后向信号穿越整个网络的路径长度，这个路径长度越短，越容易学习到长距离依赖。

Attention Visualizations

第一张图展示了 Self-Attention 学到的句子内部的一个长距离依赖 “making … more diffcult”，图中不同的颜色表示不同 Head 的 Attention，颜色越深表示 Attention 的值越大。

第二张图展示了 Self-Attention 学到的一个指代消解关系 (Anaphora Resolution)，its 指代的为上文中的 law。下图 (上) 为 Head 5 的所有 Attention，下图 (下) 为 Head 5 和 6 关于词 its 的 Attention，不难看出模型学习到了 its 和 law 之间的依赖关系 (指代消解关系)。

Hierarchical Attention

Yang 等人 ⁹ 提出了一种层级的注意力 (Hierarchical Attention) 网络用于文档分类。Hierarchical Attention 共包含 4 层：一个词编码器 (Word Encoder)，一个词级别的注意力层 (Word Attention)，一个句子编码器 (Sentence Encoder) 和一个句子级别的注意力层 (Sentence Attention)。网络架构如下图所示：

Word Encoder

对于一个给定的句子 $w_{it}, t \in \left[0, T\right]$，通过一个 Embedding 矩阵 $W_e$ 得到每个词的向量表示，再应用一个双向的 GRU，即：

$$ \begin{equation} \begin{split} x_{it} &= W_e w_{it}, t \in \left[1, T\right] \\ \overrightarrow{h}_{it} &= \overrightarrow{\text{GRU}} \left(x_{it}\right), t \in \left[1, T\right] \\ \overleftarrow{h}_{it} &= \overleftarrow{\text{GRU}} \left(x_{it}\right), t \in \left[T, 1\right] \end{split} \end{equation} $$

最后将前向的隐状态 $\overrightarrow{h}_{it}$ 和后向的隐状态 $\overleftarrow{h}_{it}$ 进行拼接，得到 $h_{ij} = \left[\overrightarrow{h}_{it}, \overleftarrow{h}_{it}\right]$ 为整个句子在词 $w_{ij}$ 附近的汇总信息。

Word Attention

Word Attention 同一般的 Attention 机制类似，计算方式如下：

$$ \begin{equation} \begin{split} u_{it} &= \tanh \left(W_w h_{it} + b_w\right) \\ a_{it} &= \dfrac{\exp \left(u_{it}^{\top} u_w\right)}{\sum_{t}{\exp \left(u_{it}^{\top} u_w\right)}} \\ s_i &= \sum_{t}{a_{it} h_{it}} \end{split} \end{equation} $$

Sentence Encoder

在 Word Attention 之后，我们得到了一个句子的表示 $s_i$，类似的我们利用一个双向的 GRU 编码文档中的 $L$ 个句子：

$$ \begin{equation} \begin{split} \overrightarrow{h}_i &= \overrightarrow{\text{GRU}} \left(s_i\right), i \in \left[1, L\right] \\ \overleftarrow{h}_i &= \overleftarrow{\text{GRU}} \left(s_i\right), i \in \left[L, 1\right] \end{split} \end{equation} $$

最后将前向的隐状态 $\overrightarrow{h}_i$ 和后向的隐状态 $\overleftarrow{h}_i$ 进行拼接，得到 $h_i = \left[\overrightarrow{h}_i, \overleftarrow{h}_i\right]$ 为整个文档关于句子 $s_i$ 的注意力汇总信息。

Sentence Attention

同理可得 Sentence Attention 的计算方式如下：

$$ \begin{equation} \begin{split} u_i &= \tanh \left(W_s h_i + b_s\right) \\ a_i &= \dfrac{\exp \left(u_i^{\top} u_s\right)}{\sum_{i}{\exp \left(u_i^{\top} u_s\right)}} \\ v &= \sum_{i}{a_i h_i} \end{split} \end{equation} $$

最终得到整个文档的向量表示 $v$。

Attention-over-Attention

Cui 等人 ¹⁰ 提出了 Attention-over-Attention 的模型用于阅读理解 (Reading Comprehension)。网络结构如下图所示：

对于一个给定的训练集 $\langle \mathcal{D}, \mathcal{Q}, \mathcal{A} \rangle$，模型包含两个输入，一个文档 (Document) 和一个问题序列 (Query)。网络的工作流程如下：

1. 先获取 Document 和 Query 的 Embedding 结果，再应用一个双向的 GRU 得到对应的隐状态 $h_{doc}$ 和 $h_{query}$。
2. 计算一个 Document 和 Query 的匹配程度矩阵 $M \in \mathbb{R}^{\lvert \mathcal{D} \rvert \times \lvert \mathcal{Q} \rvert}$，其中第 $i$ 行第 $j$ 列的值计算方式如下： $$ M \left(i, j\right) = h_{doc} \left(i\right)^{\top} \cdot h_{query} \left(j\right) $$
3. 按照 列 的方向对矩阵 $M$ 应用 softmax 函数，矩阵中的每一列为考虑一个 Query 中的词的 Document 级别的 Attention，因此定义 $\alpha \left(t\right) \in \mathbb{R}^{\lvert \mathcal{D} \rvert}$ 为 $t$ 时刻的 Document 级别 Attention (query-to-document attention)。计算方式如下： $$ \begin{equation} \begin{split} \alpha \left(t\right) &= \text{softmax} \left(M \left(1, t\right), \dotsc, M \left(\lvert \mathcal{D} \rvert, t\right)\right) \\ \alpha &= \left[\alpha \left(1\right), \alpha \left(2\right), \dotsc, \alpha \left(\lvert \mathcal{Q} \rvert\right)\right] \end{split} \end{equation} $$
4. 同理按照 行 的方向对矩阵 $M$ 应用 softmax 函数，可以得到 $\beta \left(t\right) \in \mathbb{R}^{\lvert \mathcal{Q} \rvert}$ 为 $t$ 时刻的 Query 级别的 Attention (document-to-query attention)。计算方式如下： $$ \beta \left(t\right) = \text{softmax} \left(M \left(t, 1\right), \dotsc, M \left(t, \lvert \mathcal{Q} \rvert\right)\right) $$
5. 对于 document-to-query attention，我们对结果进行平均得到： $$ \beta = \dfrac{1}{n} \sum_{t=1}^{\lvert \mathcal{D} \rvert}{\beta \left(t\right)} $$
6. 最终利用 $\alpha$ 和 $\beta$ 的点积 $s = \alpha^{\top} \beta \in \mathbb{R}^{\lvert \mathcal{D} \rvert}$ 得到 attended document-level attention (即 attention-over-attention)。

Multi-step Attention

Gehring 等人 ¹¹ 提出了基于 CNN 和 Multi-step Attention 的模型用于机器翻译。网络结构如下图所示：

Position Embeddings

模型首先得到序列 $\mathbf{x} = \left(x_1, \dotsc, x_m\right)$ 的 Embedding $\mathbf{w} = \left(w_1, \dotsc , w_m\right), w_j \in \mathbb{R}^f$。除此之外还将输入序列的位置信息映射为 $\mathbf{p} = \left(p_1, \dotsc, p_m\right), p_j \in \mathbb{R}^f$，最终将两者进行合并得到最终的输入 $\mathbf{e} = \left(w_1 + p_1, \dotsc, w_m + p_m\right)$。同时在解码器部分也采用类似的操作，将其与解码器网络的输出表示合并之后再喂入解码器网络 $\mathbf{g} = \left(g_1, \dotsc, g_n\right)$ 中。

Convolutional Block Structure

编码器和解码器均由多个 Convolutional Block 构成，每个 Block 包含一个卷积计算和一个非线性计算。令 $\mathbf{h}^l = \left(h_1^l, \dotsc, h_n^l\right)$ 表示解码器第 $l$ 个 Block 的输出，$\mathbf{z}^l = \left(z_1^l, \dotsc, z_m^l\right)$ 表示编码器第 $l$ 个 Block 的输出。对于一个大小 $k = 5$ 的卷积核，其结果的隐状态包含了这 5 个输入，则对于一个 6 层的堆叠结构，结果的隐状态则包含了输入中的 25 个元素。

在每一个 Convolutional Block 中，卷积核的参数为 $W \in \mathbb{R}^{2d \times kd}, b_w \in \mathbb{R}^{2d}$，其中 $k$ 为卷积核的大小，经过卷积后的输出为 $Y \in \mathbb{R}^{2d}$。之后的非线性层采用了 Dauphin 等人 ¹² 提出的 Gated Linear Units (GLU)，对于卷积后的输出 $Y = \left[A, B\right]$ 有：

$$ v \left(\left[A, B\right]\right) = A \otimes \sigma \left(B\right) $$

其中，$A, B \in \mathbb{R}^d$ 为非线性单元的输入，$\otimes$ 为逐元素相乘，$\sigma \left(B\right)$ 为用于控制输入 $A$ 与当前上下文相关度的门结构。

模型中还加入了残差连接，即：

$$ h_i^l = v \left(W^l \left[h_{i-k/2}^{l-1}, \dotsc, h_{i+k/2}^{l-1}\right] + b_w^l\right) + h_i^{l-1} $$

为了确保网络卷积层的输出同输入的长度相匹配，模型对输入数据的前后填补 $k - 1$ 个零值，同时为了避免解码器使用当前预测位置之后的信息，模型删除了卷积输出尾部的 $k$ 个元素。在将 Embedding 喂给编码器网络之前，在解码器输出应用 softmax 之前以及所有解码器层计算 Attention 分数之前，建立了一个从 Embedding 维度 $f$ 到卷积输出大小 $2d$ 的线性映射。最终，预测下一个词的概率计算方式如下：

$$ p \left(y_{i+1} | y_1, \dotsc, y_i, \mathbf{x}\right) = \text{softmax} \left(W_o h_i^L + b_o\right) \in \mathbb{R}^T $$

Multi-step Attention

模型的解码器网络中引入了一个分离的注意力机制，在计算 Attention 时，将解码器当前的隐状态 $h_i^l$ 同之前输出元素的 Embedding 进行合并：

$$ d_i^l = W_d^l h_i^l + b_d^l + g_i $$

对于解码器网络层 $l$ 中状态 $i$ 和输入元素 $j$ 之间的的 Attention $a_{ij}^l$ 通过解码器汇总状态 $d_i^l$ 和最后一个解码器 Block $u$ 的输出 $z_j^u$ 进行点积运算得到：

$$ a_{ij}^l = \dfrac{\exp \left(d_i^l \cdot z_j^u\right)}{\sum_{t=1}^{m}{\exp \left(d_i^l \cdot z_t^u\right)}} $$

条件输入 $c_i^l$ 的计算方式如下：

$$ c_i^l = \sum_{j=1}^{m}{a_{ij}^l \left(z_j^u + e_j\right)} $$

其中，$e_j$ 为输入元素的 Embedding。与传统的 Attention 不同，$e_j$ 的加入提供了一个有助于预测的具体输入元素信息。

最终将 $c_i^l$ 加到对应的解码器层的输出 $h_i^l$。这个过程与传统的单步 Attention 不同，被称之为 Multiple Hops ¹³。这种方式使得模型在计算 Attention 时会考虑之前已经注意过的输入信息。

文本表示是计算机处理自然语言的核心，我们希望计算机能够同人类一样对自然语言能够实现语义层面的理解，但这并非易事。在中文和拉丁语系中，文本的直观表示就存在一定的差异，拉丁语系中词与词之间存在天然的分隔符，而中文则没有。

I can eat glass, it doesn’t hurt me.
我能吞下玻璃而不伤身体。

所以，在处理中文之前我们往往需要对原始文本进行分词，在此我们不谈这部分工作，假设我们已经得到了分词完的文本，即我们后续需要处理的“词”。早期的词表示方法多采用独热编码 (One-Hot Encoding)，对于每一个不同的词都使用一个单独的向量进行表示。对于一个包含 $n$ 个词的语料而言，一个词的向量表示 $\text{word}_i \in \left\{0, 1\right\}^n$ 仅在第 $i$ 的位置值为 1，其他位置的值均为 0。例如，我们可以将“父亲”表示为：

$$ \left[1, 0, 0, 0, 0, 0, ...\right] \nonumber $$

One-Hot Encoding 的表示方法十分简洁，但也存在着一些问题。

维数灾难 (The Curse of Dimensionality)

在很多现实问题中，我们仅用少数的特征是很难利用一个线性模型将数据区分开来的，也就是线性不可分问题。一个有效的方法是利用核函数实现一个非线性变换，将非线性问题转化成线性问题，通过求解变换后的线性问题进而求解原来的非线性问题。

假设 $\mathcal{X}$ 是输入空间（欧式空间 $\mathbb{R}^n$ 的子集或离散结合），$\mathcal{H}$ 为特征空间（希尔伯特空间），若存在一个从 $\mathcal{X}$ 到 $ \mathcal{H}$ 的映射：

$$\phi \left(x\right): \mathcal{X} \rightarrow \mathcal{H}$$

使得对所有 $x, z \in \mathcal{X}$ ，函数 $K\left(x, z\right)$ 满足条件：

$$K\left(x, z\right) = \phi \left(x\right) \cdot \phi \left(z\right)$$

则 $K\left(x, z\right)$ 为核函数， $\phi \left(x\right)$ 为映射函数，其中 $\phi \left(x\right) \cdot \phi \left(z\right)$ 为 $\phi \left(x\right)$ 和 $\phi \left(z\right)$ 的内积。

例如，对于一个下图所示的二维数据，显然是线性不可分的。

构建一个映射 $\phi: \mathbb{R}^2 \rightarrow \mathbb{R}^3$ 经 $X$ 映射为： $x = x^2, y = y^2, z = y$ ，则通过变换后的数据通过可视化可以明显地看出，数据是可以通过一个超平面来分开的。

可以说随着维度的增加，我们更有可能找到一个超平面（线性模型）将数据划分开来。尽管看起来，随着维度的增加似乎有助于我们构建模型，但是同时数据在高维空间的分布变得越来越稀疏。因此，在构建机器学习模型时，当我们需要更好的覆盖数据的分布时，我们需要的数据量就更大，这也就会导致需要更多的时间去训练模型。例如，假设所有特征均为0到1之间连续分布的数据，针对1维的情况，当覆盖50%的数据时，仅需全体50%的样本即可；针对2维的情况，当覆盖50%的数据时，则需全体71% ( $0.71^2 \approx 0.5$ ) 的样本；针对3维的情况，当覆盖50%的数据时，则需全体79% ( $0.79^3 \approx 0.5$ )，这就是我们所说的维数灾难。

分散式表示 (Distributed Representations)

分散式表示（Distributed Representations）¹ 最早由 Hiton 提出，对比于传统的 One-Hot Representation ，Distributed Representations 可以将数据表示为低维，稠密，连续的向量，也就是说将原始空间中的潜在信息分散的表示在低维空间的不同维度上。

传统的 One-Hot Representation 会将数据表示成一个很长的向量，例如，在 NLP 中，利用 One-Hot Representation 表示一个单词：

父亲: [1, 0, 0, 0, 0, 0, ...]
爸爸: [0, 1, 0, 0, 0, 0, ...]
母亲: [0, 0, 1, 0, 0, 0, ...]
妈妈: [0, 0, 0, 1, 0, 0, ...]

这种表示形式很简介，但也很稀疏，相当于语料库中有多少个词，则表示空间的维度就需要多少。那么，对于传统的聚类算法，高斯混合模型，最邻近算法，决策树或高斯 SVM 需要 $O\left(N\right)$ 个参数 (或 $O\left(N\right)$ 个样本) 将能够将 $O\left(N\right)$ 的输入区分开来。而像 RBMs ，稀疏编码，Auto-Encoder 或多层神经网络则可以利用 $O\left(N\right)$ 个参数表示 $O\left(2^k\right)$ 的输入，其中 $k \leq N$ 为稀疏表示中非零元素的个数 ²。

采用 Distributed Representation，则可以将单词表示为：

父亲: [0.12, 0.34, 0.65, ...]
爸爸: [0.11, 0.33, 0.58, ...]
母亲: [0.34, 0.98, 0.67, ...]
妈妈: [0.29, 0.92, 0.66, ...]

利用这种表示，我们不仅可以将稀疏的高维空间转换为稠密的低维空间，同时我们还能学习出文本间的语义相似性来，例如实例中的 父亲 和 爸爸，从语义上看其均表示 父亲 的含义，但是如果利用 One-Hot Representation 编码则 父亲 与 爸爸 的距离同其与 母亲 或 妈妈 的距离时相同的，而利用 Distributed Representation 编码，则 父亲 同 爸爸 之间的距离要远小于其同 母亲 或 妈妈 之间的距离。

Word Embedding 之路

N-gram 模型

N-gram (N 元语法) 是一种文本表示方法，指文中连续出现的 $n$ 个词语。N-gram 模型是基于 $n-1$ 阶马尔科夫链的一种概率语言模型，可以通过前 $n-1$ 个词对第 $n$ 个词进行预测。Bengio 等人 ³ 提出了一个三层的神经网络的概率语言模型，其网络结构如下图所示：

模型的最下面为前 $n-1$ 个词 $w_{t-n+1}, ..., w_{t-2}, w_{t-1}$，每个词 $w_i$ 通过查表的方式同输入层对应的词向量 $C \left(w_i\right)$ 相连。词表 $C$ 为一个 $\lvert V\rvert \times m$ 大小的矩阵，其中 $\lvert V\rvert$ 表示语料中词的数量，$m$ 表示词向量的维度。输入层则为前 $n-1$ 个词向量拼接成的向量 $x$，其维度为 $m \left(n-1\right) \times 1$。隐含层直接利用 $d + Hx$ 计算得到，其中 $H$ 为隐含层的权重，$d$ 为隐含层的偏置。输出层共包含 $\lvert V\rvert$ 个神经元，每个神经元 $y_i$ 表示下一个词为第 $i$ 个词的未归一化的 log 概率，即：

$$ y = b + Wx + U \tanh \left(d + Hx\right) $$

对于该问题，我们的优化目标为最大化如下的 log 似然函数：

$$ L = \dfrac{1}{T} \sum_{t}{f \left(w_t, w_{t-1}, ..., w_{t-n+1}\right) + R \left(\theta\right)} $$

其中，$f \left(w_t, w_{t-1}, ..., w_{t-n+1}\right)$ 为利用前 $n-1$ 个词预测当前词 $w_t$ 的条件概率，$R \left(\theta\right)$ 为参数的正则项，$\theta = \left(b, d, W, U, H, C\right)$。$C$ 作为模型的参数之一，随着模型的训练不断优化，在模型训练完毕后，$C$ 中保存的即为词向量。

Continuous Bag-of-Words (CBOW) 和 Skip-gram 模型

CBOW 和 Skip-gram 均考虑一个词的上下文信息，两种模型的结构如下图所示：

两者在给定的上下文信息中 (即前后各 $m$ 个词) 忽略了上下文环境的序列信息，CBOW (上图左) 是利用上下文环境中的词预测当前的词，而 Skip-gram (上图右) 则是用当前词预测上下文中的词。

对于 CBOW，$x_{1k}, x_{2k}, ..., x_{Ck}$ 为上下文词的 One-Hot 表示，$\mathbf{W}_{V \times N}$ 为所有词向量构成的矩阵 (词汇表)，$y_j$ 为利用上下文信息预测得到的当前词的 One-Hot 表示输出，其中 $C$ 为上下文词汇的数量，$V$ 为词汇表中词的总数量，$N$ 为词向量的维度。从输入层到隐含层，我们对输入层词对应的词向量进行简单的加和，即：

$$ h_i = \sum_{c=1}^{C}{x_{ck} \mathbf{W}_{V \times N}} $$

对于 Skip-gram，$x_k$ 为当前词的 One-Hot 表示，$\mathbf{W}_{V \times N}$ 为所有词向量构成的矩阵 (词汇表)，$y_{1j}, y_{2j}, ..., y_{Cj}$ 为预测的上次文词汇的 One-Hot 表示输出。从输入层到隐含层，直接将 One-Hot 的输入向量转换为词向量表示即可。

除此之外两者还有一些其他的区别：

1. CBOW 要比 Skip-gram 模型训练快。从模型中我们不难发现：从隐含层到输出层，CBOW 仅需要计算一个损失，而 Skip-gram 则需要计算 $C$ 个损失再进行平均进行参数优化。
2. Skip-gram 在小数量的数据集上效果更好，同时对于生僻词的表示效果更好。CBOW 在从输入层到隐含层时，对输入的词向量进行了平均 (可以理解为进行了平滑处理)，因此对于生僻词，平滑后则容易被模型所忽视。

Word2Vec

Mikolov 等人 ⁴ 利用上面介绍的 CBOW 和 Skip-gram 两种模型提出了经典的 Word2Vec 算法。Word2Vec 中针对 CBOW 和 Skip-gram 又提出了两种具体的实现方案 Hierarchical Softmax (层次 Softmax) 和 Negative Sampling (负采样)，因此共有 4 种不同的模型。

• 基于 Hierarchical Softmax 的模型

基于 Hierarchical Softmax 的 CBOW 模型如下：

其中：

1. 输入层：包含了 $C$ 个词的词向量，$\mathbf{v} \left(w_1\right), \mathbf{v} \left(w_2\right), ..., \mathbf{v} \left(w_C\right) \in \mathbb{R}^N$，$N$ 为词向量的维度。
2. 投影层：将输入层的向量进行加和，即：$\mathbf{x}_w = \sum_{i=1}^{C}{\mathbf{v} \left(w_i\right)} \in \mathbb{R}^N$。
3. 输出层：输出为一颗二叉树，是根据语料构建出来的 Huffman 树 ⁵，其中每个叶子节点为词汇表中的一个词。

Hierarchical Softmax 是解决概率语言模型中计算效率的关键，CBOW 模型去掉了隐含层，同时将输出层改为了 Huffman 树。对于该模型的优化求解，我们首先引入一些符号，对于 Huffman 树的一个叶子节点 (即词汇表中的词 $w$)，记：

• $p^w$：从根节点出发到达 $w$ 对应的叶子节点的路径。
• $l^w$：路径 $p^w$ 包含的节点的个数。
• $p_1^w, p_1^w, ..., p_{l^w}^w$：路径 $p^w$ 中的 $l^w$ 个节点，其中 $p_1^w$ 表示根节点，$p_{l^w}^w$ 表示词 $w$ 对应的叶子节点。
• $d_2^w, d_3^w, ..., d_{l^w}^w \in \{0, 1\}$：词 $w$ 的 Huffman 编码，由 $l^w - 1$ 位编码构成，$d_j^w$ 表示路径 $p^w$ 中第 $j$ 个结点对应的编码。
• $\theta_1^w, \theta_1^w, ..., \theta_{l^w - 1}^w \in \mathbb{R}^N$：路径 $p^w$ 中非叶子节点对应的向量，$\theta_j^w$ 表示路径 $p^w$ 中第 $j$ 个非叶子节点对应的向量。

首先我们需要根据向量 $\mathbf{x}_w$ 和 Huffman 树定义条件概率 $p \left(w | Context\left(w\right)\right)$。我们可以将其视为一系列的二分类问题，在到达对应的叶子节点的过程中，经过的每一个非叶子节点均为对应一个取值为 0 或 1 的 Huffman 编码。因此，我们可以将编码为 1 的节点定义为负类，将编码为 0 的节点定义为正类 (即分到左边为负类，分到右边为正类)，则这条路径上对应的标签为：

$$ Label \left(p_i^w\right) = 1 - d_i^w, i = 2, 3, ..., l^w $$

则对于一个节点被分为正类的概率为 $\sigma \left(\mathbf{x}_w^{\top} \theta\right)$，被分为负类的概率为 $1 - \sigma \left(\mathbf{x}_w^{\top} \theta\right)$。则条件概率可以表示为：

$$ p \left(w | Context\left(w\right)\right) = \prod_{j=2}^{l^w}{p \left(d_j^w | \mathbf{x}_w, \theta_{j-1}^w\right)} $$

其中

$$ p \left(d_j^w | \mathbf{x}_w, \theta_{j-1}^w\right) = \begin{cases} \sigma \left(\mathbf{x}_w^{\top} \theta\right) & d_j^w = 0 \\ 1 - \sigma \left(\mathbf{x}_w^{\top} \theta\right) & d_j^w = 1 \end{cases} $$

或表示为：

$$ p \left(d_j^w | \mathbf{x}_w, \theta_{j-1}^w\right) = \left[\sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}\right)\right]^{1 - d_j^w} \cdot \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}\right)\right]^{d_j^w} $$

则对数似然函数为：

$$ \begin{equation} \begin{split} \mathcal{L} &= \sum_{w \in \mathcal{C}}{\log \prod_{j=2}^{l^w}{\left\{\left[\sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}\right)\right]^{1 - d_j^w} \cdot \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}\right)\right]^{d_j^w}\right\}}} \\ &= \sum_{w \in \mathcal{C}}{\sum_{j=2}^{l^w}{\left\{\left(1 - d_j^w\right) \cdot \log \left[\sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right] + d_j^w \cdot \log \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right]\right\}}} \end{split} \end{equation} $$

记上式花括号中的内容为 $\mathcal{L} \left(w, j\right)$，则 $\mathcal{L} \left(w, j\right)$ 关于 $\theta_{j-1}^w$ 的梯度为：

$$ \begin{equation} \begin{split} \dfrac{\partial \mathcal{L} \left(w, j\right)}{\partial \theta_{j-1}^w} &= \dfrac{\partial}{\partial \theta_{j-1}^w} \left\{\left(1 - d_j^w\right) \cdot \log \left[\sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right] + d_j^w \cdot \log \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right]\right\} \\ &= \left(1 - d_j^w\right) \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right] \mathbf{x}_w - d_j^w \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right) \mathbf{x}_w \\ &= \left\{\left(1 - d_j^w\right) \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right] - d_j^w \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right\} \mathbf{x}_w \\ &= \left[1 - d_j^w - \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right] \mathbf{x}_w \end{split} \end{equation} $$

则 $\theta_{j-1}^w$ 的更新方式为：

$$ \theta_{j-1}^w \gets \theta_{j-1}^w + \eta \left[1 - d_j^w - \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right] \mathbf{x}_w $$

同理可得，$\mathcal{L} \left(w, j\right)$ 关于 $\mathbf{x}_w$ 的梯度为：

$$ \dfrac{\partial \mathcal{L} \left(w, j\right)}{\partial \mathbf{x}_w} = \left[1 - d_j^w - \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)\right] \theta_{j-1}^w $$

但 $\mathbf{x}_w$ 为上下文词汇向量的加和，Word2Vec 的做法是将梯度贡献到上下文中的每个词向量上，即：

$$ \mathbf{v} \left(u\right) \gets \mathbf{v} \left(u\right) + \eta \sum_{j=2}^{l^w}{\dfrac{\partial \mathcal{L} \left(w, j\right)}{\partial \mathbf{x}_w}}, u \in Context \left(w\right) $$

基于 Hierarchical Softmax 的 CBOW 模型的随机梯度上升算法伪代码如下：

\begin{algorithm}
\caption{基于 Hierarchical Softmax 的 CBOW 随机梯度上升算法}
\begin{algorithmic}
\STATE $\mathbf{e} = 0$
\STATE $\mathbf{x}_w = \sum_{u \in Context \left(w\right)}{\mathbf{v} \left(u\right)}$
\FOR{$j = 2, 3, ..., l^w$}
    \STATE $q = \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^w\right)$
    \STATE $g = \eta \left(1 - d_j^w - q\right)$
    \STATE $\mathbf{e} \gets \mathbf{e} + g \theta_{j-1}^w$
    \STATE $\theta_{j-1}^w \gets \theta_{j-1}^w + g \mathbf{x}_w$
\ENDFOR
\FOR{$u \in Context \left(w\right)$}
    \STATE $\mathbf{v} \left(u\right) \gets \mathbf{v} \left(u\right) + \mathbf{e}$
\ENDFOR
\end{algorithmic}
\end{algorithm}

基于 Hierarchical Softmax 的 Skip-gram 模型如下：

对于 Skip-gram 模型，是利用当前词 $w$ 对上下文 $Context \left(w\right)$ 中的词进行预测，则条件概率为：

$$ p \left(Context \left(w\right) | w\right) = \prod_{u \in Context \left(w\right)}{p \left(u | w\right)} $$

类似于 CBOW 模型的思想，有：

$$ p \left(u | w\right) = \prod_{j=2}^{l^u}{p \left(d_j^u | \mathbf{v} \left(w\right), \theta_{j-1}^u\right)} $$

其中

$$ p \left(d_j^u | \mathbf{v} \left(w\right), \theta_{j-1}^u\right) = \left[\sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^u\right)\right]^{1 - d_j^u} \cdot \left[1 - \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^u\right)\right]^{d_j^u} $$

可得对数似然函数为：

$$ \begin{equation} \begin{split} \mathcal{L} &= \sum_{w \in \mathcal{C}}{\log \prod_{u \in Context \left(w\right)}{\prod_{j=2}^{l^u}{\left\{\left[\sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right]^{1 - d_j^u} \cdot \left[1 - \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^u\right)\right]^{d_j^u}\right\}}}} \\ &= \sum_{w \in \mathcal{C}}{\sum_{u \in Context \left(w\right)}{\sum_{j=2}^{l^u}{\left\{\left(1 - d_j^u\right) \cdot \log \left[\sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right] + d_j^u \cdot \log \left[1 - \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right]\right\}}}} \end{split} \end{equation} $$

记上式花括号中的内容为 $\mathcal{L} \left(w, u, j\right)$，在 $\mathcal{L} \left(w, u, j\right)$ 关于 $\theta_{j-1}^u$ 的梯度为：

$$ \begin{equation} \begin{split} \dfrac{\partial \mathcal{L} \left(w, u, j\right)}{\partial \theta_{j-1}^{u}} &= \dfrac{\partial}{\partial \theta_{j-1}^{u}} \left\{\left(1 - d_j^u\right) \cdot \log \left[\sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right] + d_j^u \cdot \log \left[1 - \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right]\right\} \\ &= \left(1 - d_j^u\right) \cdot \left[1 - \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right] \mathbf{v} \left(w\right) - d_j^u \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right) \mathbf{v} \left(w\right) \\ &= \left\{\left(1 - d_j^u\right) \cdot \left[1 - \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right] - d_j^u \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right\} \mathbf{v} \left(w\right) \\ &= \left[1 - d_j^u - \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right] \mathbf{v} \left(w\right) \end{split} \end{equation} $$

则 $\theta_{j-1}^u$ 的更新方式为：

$$ \theta_{j-1}^u \gets \theta_{j-1}^u + \eta \left[1 - d_j^u - \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right] \mathbf{v} \left(w\right) $$

同理可得，$\mathcal{L} \left(w, u, j\right)$ 关于 $\mathbf{v} \left(w\right)$ 的梯度为：

$$ \dfrac{\partial \mathcal{L} \left(w, u, j\right)}{\partial \mathbf{v} \left(w\right)} = \left[1 - d_j^u - \sigma \left(\mathbf{v} \left(w\right)^{\top} \theta_{j-1}^{u}\right)\right] \theta_{j-1}^u $$

则 $\mathbf{v} \left(w\right)$ 的更新方式为：

$$ \mathbf{v} \left(w\right) \gets \mathbf{v} \left(w\right) + \eta \sum_{u \in Context \left(w\right)}{\sum_{j=2}^{l^u}{\dfrac{\partial \mathcal{L} \left(w, u, j\right)}{\partial \mathbf{v} \left(w\right)}}} $$

基于 Hierarchical Softmax 的 Skip-gram 模型的随机梯度上升算法伪代码如下：

\begin{algorithm}
\caption{基于 Hierarchical Softmax 的 Skig-gram 随机梯度上升算法}
\begin{algorithmic}
\STATE $\mathbf{e} = 0$
\FOR{$u \in Context \left(w\right)$}
    \FOR{$j = 2, 3, ..., l^u$}
        \STATE $q = \sigma \left(\mathbf{x}_w^{\top} \theta_{j-1}^u\right)$
        \STATE $g = \eta \left(1 - d_j^u - q\right)$
        \STATE $\mathbf{e} \gets \mathbf{e} + g \theta_{j-1}^u$
        \STATE $\theta_{j-1}^u \gets \theta_{j-1}^u + g \mathbf{v} \left(w\right)$
    \ENDFOR
\ENDFOR
\STATE $\mathbf{v} \left(w\right) \gets \mathbf{v} \left(w\right) + \mathbf{e}$
\end{algorithmic}
\end{algorithm}

• 基于 Negative Sampling 的模型

基于 Negative Sampling (NEG) 的模型相比于基于 Hierarchical Softmax 的模型不再使用复杂的 Huffman 树，而是使用简单的随机负采样，从而大幅的提高了模型的性能。

基于 Negative Sampling 的 CBOW 模型如下：

对于基于 Negative Sampling CBOW 模型，已知词 $w$ 的上下文 $Context \left(w\right)$，预测词 $w$，则词 $w$ 即为一个正样本，其他词则为负样本。对于一个给定 $Context \left(w\right)$ 的负样本集合 $NEG \left(w\right) \neq \varnothing$，词典中的任意词 $\forall \tilde{w} \in \mathcal{D}$，其样本的标签定义为：

$$ L^w \left(\tilde{w}\right) = \begin{cases} 1, & \tilde{w} = w \\ 0, & \tilde{w} \neq w \end{cases} $$

则对于一个正样本 $\left(Context, \left(w\right)\right)$，我们希望最大化：

$$ g \left(w\right) = \prod_{u \in \left\{w\right\} \cup NEG \left(w\right)}{p \left(u | Context \left(w\right)\right)} $$

或表示为：

$$ p \left(u | Context \left(w\right)\right) = \left[\sigma \left(\mathbf{x}_w^{\top} \theta^u\right)\right]^{L^w \left(w\right)} \cdot \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta^u\right)\right]^{1 - L^w \left(w\right)} $$

即增大正样本概率的同时减少负样本的概率。对于一个给定的语料库 $\mathcal{C}$，对数似然函数为：

$$ \begin{equation} \begin{split} \mathcal{L} &= \sum_{w \in \mathcal{C}}{\log g \left(w\right)} \\ &= \sum_{w \in \mathcal{C}}{\log \prod_{u \in \left\{w\right\} \cup NEG \left(w\right)}{\left\{\left[\sigma \left(\mathbf{x}_w^{\top} \theta^u\right)\right]^{L^w \left(u\right)} \cdot \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta^u\right)\right]^{1 - L^w \left(u\right)}\right\}}} \\ &= \sum_{w \in \mathcal{C}}{\sum_{u \in \left\{w\right\} \cup NEG \left(w\right)}{\left\{L^w \left(u\right) \cdot \log \left[\sigma \left(\mathbf{x}_w^{\top} \theta^u\right)\right] + \left[1 - L^w \left(u\right)\right] \cdot \log \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta^u\right)\right]\right\}}} \end{split} \end{equation} $$

记上式花括号中的内容为 $\mathcal{L} \left(w, u\right)$，则 $\mathcal{L} \left(w, u\right)$ 关于 $\theta^u$ 的梯度为：

$$ \begin{equation} \begin{split} \dfrac{\partial \mathcal{L} \left(w, u\right)}{\partial \theta^u} &= \dfrac{\partial}{\partial \theta^u} \left\{L^w \left(u\right) \cdot \log \left[\sigma \left(\mathbf{x}_w^{\top} \theta^u\right)\right] + \left[1 - L^w \left(u\right)\right] \cdot \log \left[1 - \sigma \left(\mathbf{x}_w^{\top} \theta^u\right)\right]\right\} \\ &= L^w \left(u\right) \left[1 - \sigma \left(\mathbf{w}_w^{\top} \theta^u\right)\right] \mathbf{x}_w - \left[1 - L^w \left(u\right)\right] \sigma \left(\mathbf{x}_w^{\top} \theta^u\right) \mathbf{x}_w \\ &= \left\{L^w \left(u\right) \left[1 - \sigma \left(\mathbf{w}_w^{\top} \theta^u\right)\right] - \left[1 - L^w \left(u\right)\right] \sigma \left(\mathbf{x}_w^{\top} \theta^u\right)\right\} \mathbf{x}_w \\ &= \left[L^w \left(u\right) - \sigma \left(\mathbf{w}_w^{\top} \theta^u\right)\right] \mathbf{x}_w \end{split} \end{equation} $$

则 $\theta^u$ 的更新方式为：

$$ \theta^u \gets \theta^u + \eta \left[L^w \left(u\right) - \sigma \left(\mathbf{w}_w^{\top} \theta^u\right)\right] \mathbf{x}_w $$

同理可得，$\mathcal{L} \left(w, u\right)$ 关于 $\mathbf{x}_w$ 的梯度为：

$$ \dfrac{\partial \mathcal{L} \left(w, u\right)}{\partial \mathbf{x}_w} = \left[L^w \left(u\right) - \sigma \left(\mathbf{w}_w^{\top} \theta^u\right)\right] \theta^u $$

则 $\mathbf{v} \left(\tilde{w}\right), \tilde{w} \in Context \left(w\right)$ 的更新方式为：

$$ \mathbf{v} \left(\tilde{w}\right) \gets \mathbf{v} \left(\tilde{w}\right) + \eta \sum_{u \in \left\{w\right\} \cup NEG \left(w\right)}{\dfrac{\partial \mathcal{L} \left(w, u\right)}{\partial \mathbf{x}_w}}, \tilde{w} \in Context \left(w\right) $$

基于 Negative Sampling 的 CBOW 模型的随机梯度上升算法伪代码如下：

\begin{algorithm}
\caption{基于 Negative Sampling 的 CBOW 随机梯度上升算法}
\begin{algorithmic}
\STATE $\mathbf{e} = 0$
\STATE $\mathbf{x}_w = \sum_{u \in Context \left(w\right)}{\mathbf{v} \left(u\right)}$
\FOR{$u \in Context \left\{w\right\} \cup NEG \left(w\right)$}
    \STATE $q = \sigma \left(\mathbf{x}_w^{\top} \theta^u\right)$
    \STATE $g = \eta \left(L^w \left(u\right) - q\right)$
    \STATE $\mathbf{e} \gets \mathbf{e} + g \theta^u$
    \STATE $\theta^u \gets \theta^u + g \mathbf{x}_w$
\ENDFOR
\FOR{$u \in Context \left(w\right)$}
    \STATE $\mathbf{v} \left(u\right) \gets \mathbf{v} \left(u\right) + \mathbf{e}$
\ENDFOR
\end{algorithmic}
\end{algorithm}

基于 Negative Sampling 的 Skip-gram 模型如下：

对于 Skip-gram 模型，利用当前词 $w$ 对上下文 $Context \left(w\right)$ 中的词进行预测，则对于一个正样本 $\left(Context, \left(w\right)\right)$，我们希望最大化：

$$ g \left(w\right) = \prod_{\tilde{w} \in Context \left(w\right)}{\prod_{u \in \left\{w\right\} \cup NEG^{\tilde{w}} \left(w\right)}{p \left(u | \tilde{w}\right)}} $$

其中，$NEG^{\tilde{w}} \left(w\right)$ 为处理词 $\tilde{w}$ 时生成的负样本集合，且：

$$ p \left(u | \tilde{w}\right) = \begin{cases} \sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right) & L^w \left(u\right) = 1 \\ 1 - \sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right) & L^w \left(u\right) = 0 \end{cases} $$

或表示为：

$$ p \left(u | \tilde{w}\right) = \left[\sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right)\right]^{L^w \left(u\right)} \cdot \left[1 - \sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right)\right]^{1 - L^w \left(u\right)} $$

对于一个给定的语料库 $\mathcal{C}$，对数似然函数为：

$$ \begin{equation} \begin{split} \mathcal{L} &= \sum_{w \in \mathcal{C}}{\log g \left(w\right)} \\ &= \sum_{w \in \mathcal{C}}{\log \prod_{\tilde{w} \in Context \left(w\right)}{\prod_{u \in \left\{w\right\} \cup NEG^{\tilde{w}} \left(w\right)}{\left\{\left[\sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right)\right]^{L^w \left(u\right)} \cdot \left[1 - \sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right)\right]^{1 - L^w \left(u\right)}\right\}}}} \\ &= \sum_{w \in \mathcal{C}}{\sum_{\tilde{w} \in Context \left(w\right)}{\sum_{u \in \left\{w\right\} \cup NEG^{\tilde{w}} \left(w\right)}{\left\{L^w \left(u\right) \cdot \log \left[\sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right)\right] + \left[1 - L^w \left(u\right)\right] \cdot \log \left[1 - \sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right)\right]\right\}}}} \end{split} \end{equation} $$

记上式花括号中的内容为 $\mathcal{L} \left(w, \tilde{w}, u\right)$，则 $\mathcal{L} \left(w, \tilde{w}, u\right)$ 关于 $\theta^u$ 的梯度为：

$$ \begin{equation} \begin{split} \dfrac{\partial \mathcal{L} \left(w, \tilde{w}, u\right)}{\partial \theta^u} &= \dfrac{\partial}{\partial \theta^u} \left\{L^w \left(u\right) \cdot \log \left[\sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right)\right] + \left[1 - L^w \left(u\right)\right] \cdot \log \left[1 - \sigma \left(\mathbf{v}\left(\tilde{w}\right)^{\top} \theta^u\right)\right]\right\} \\ &= L^w \left(u\right) \left[1 - \sigma \left(\mathbf{v} \left(\tilde{w}\right)^{\top} \theta^u\right)\right] \mathbf{v} \left(\tilde{w}\right) - \left[1 - L^w \left(u\right)\right] \sigma \left(\mathbf{v} \left(\tilde{w}\right)^{\top} \theta^u\right) \mathbf{v} \left(\tilde{w}\right) \\ &= \left\{L^w \left(u\right) \left[1 - \sigma \left(\mathbf{v} \left(\tilde{w}\right)^{\top} \theta^u\right)\right] - \left[1 - L^w \left(u\right)\right] \sigma \left(\mathbf{v} \left(\tilde{w}\right)^{\top} \theta^u\right)\right\} \mathbf{v} \left(\tilde{w}\right) \\ &= \left[L^w \left(u\right) - \sigma \left(\mathbf{v} \left(\tilde{w}\right)^{\top} \theta^u\right)\right] \mathbf{v} \left(\tilde{w}\right) \end{split} \end{equation} $$

则 $\theta^u$ 的更新方式为：

$$ \theta^u \gets \theta^u + \eta \left[L^w \left(u\right) - \sigma \left(\mathbf{v} \left(\tilde{w}\right)^{\top} \theta^u\right)\right] \mathbf{v} \left(\tilde{w}\right) $$

同理可得，$\mathcal{L} \left(w, \tilde{w}, u\right)$ 关于 $\mathbf{v} \left(\tilde{w}\right)$ 的梯度为：

$$ \dfrac{\partial \mathcal{L} \left(w, \tilde{w}, u\right)}{\partial \mathbf{v} \left(\tilde{w}\right)} = \left[L^w \left(u\right) - \sigma \left(\mathbf{v} \left(\tilde{w}\right)^{\top} \theta^u\right)\right] \theta^u $$

则 $\mathbf{v} \left(\tilde{w}\right)$ 的更新方式为：

$$ \mathbf{v} \left(\tilde{w}\right) \gets \mathbf{v} \left(\tilde{w}\right) + \eta \sum_{u \in \left\{w\right\} \cup NEG^{\tilde{w}} \left(w\right)}{\dfrac{\partial \mathcal{L} \left(w, \tilde{w}, u\right)}{\partial \mathbf{v} \left(\tilde{w}\right)}} $$

基于 Negative Sampling 的 Skig-gram 模型的随机梯度上升算法伪代码如下：

\begin{algorithm}
\caption{基于 Negative Sampling 的 Skig-gram 随机梯度上升算法}
\begin{algorithmic}
\STATE $\mathbf{e} = 0$
\FOR{$\tilde{w} \in Context \left(w\right)$}
    \FOR{$u \in \left\{w\right\} \cup NEG^{\tilde{w}} \left(w\right)$}
        \STATE $q = \sigma \left(\mathbf{v} \left(\tilde{w}\right)^{\top} \theta^u\right)$
        \STATE $g = \eta \left(L^w \left(u\right) - q\right)$
        \STATE $\mathbf{e} \gets \mathbf{e} + g \theta^u$
        \STATE $\theta^u \gets \theta^u + g \mathbf{v} \left(\tilde{w}\right)$
    \ENDFOR
\ENDFOR
\STATE $\mathbf{v} \left(\tilde{w}\right) \gets \mathbf{v} \left(\tilde{w}\right) + \mathbf{e}$
\end{algorithmic}
\end{algorithm}

无论是基于 Negative Sampling 的 CBOW 模型还是 Skip-gram 模型，我们都需要对于给定的词 $w$ 生成 $NEG \left(w\right)$，对于一个词典 $\mathcal{D}$ 和给定的语料 $\mathcal{C}$，一个词被选择中的概率为：

$$ p_{NEG} \left(w\right) = \dfrac{\#w}{\sum_{u \in \mathcal{D}}{\#u}} $$

其中 $\#w$ 和 $\#u$ 表示词 $w$ 和 $u$ 在语料 $\mathcal{C}$ 中出现的频次。在 Word2Vec 的 C 代码中 ⁶，并没有使用词的原始频次，而是对其做了 0.75 次幂，即：

$$ p_{NEG} \left(w\right) = \dfrac{\left(\#w\right)^{0.75}}{\sum_{u \in \mathcal{D}}{\left(\#u\right)^{0.75}}} $$

其他 Embedding 方法

GloVe

GloVe (Global Vector 的简写) 是由 Pennington 等人 ⁷ 提出了一种词向量生成方法，该方法利用了语料的全局统计信息。

令 $X$ 表示词与词之间的共现矩阵，$X_{ij}$ 表示词 $j$ 在词 $i$ 为上下文的情况下出现的频次。则 $X_i = \sum_{k}{X_{ik}}$ 表示在词$i$ 为上下文的情况任意词出现的总次数。令 $P_{ij} = P \left(j | i\right) = X_{ij} / X_i$ 表示词 $j$ 在词 $i$ 出现前提下出现的条件概率。

例如，我们令 $i = ice, j = steam$，则这两个词之间的关系可以利用同其他词 $k$ 共现概率的比率学习得出。则有：

1. 与词 ice 相关，但与词 steam 不太相关，例如 $k = solid$，则比率 $P_{ik} / P_{jk}$ 应该较大；类似的当词 $k$ 与 steam 相关，但与词 ice 不太相关，则比率 $P_{ik} / P_{jk}$ 应该较小。
2. 当与词 ice 和词 steam 均相关或者均不太相关时，例如 $k = water$ 或 $k = fashion$，则比率 $P_{ik} / P_{jk}$ 应该和 1 接近。

下表展示了在一个大量语料上的概率及其比率：

根据如上的假设，我们可以得到一个最基础的模型：

$$ F \left(w_i, w_j, \tilde{w}_k\right) = \dfrac{P_{ik}}{P_{jk}} $$

其中 $w \in \mathbb{R}^d$ 为词向量，$\tilde{w}_k \in \mathbb{R}^d$ 为单独的上下文词的词向量。假设向量空间是一个线性结构，因此 $F$ 仅依赖于两个向量之间的差异，则模型可以改写为：

$$ F \left(w_i - w_j, \tilde{w}_k\right) = \dfrac{P_{ik}}{P_{jk}} $$

上式中右面是一个标量，如果左面的参数利用一个复杂的模型进行计算，例如神经网络，则会破坏我们希望保留的线性结构。因此，我们对参数采用点积运算，即：

$$ F \left(\left(w_i - w_j\right)^{\top} \tilde{w}_k\right) = \dfrac{P_{ik}}{P_{jk}} $$

在词之间的共现矩阵中，一个词和其上下文中的一个词之间应该是可以互换角色的。首先我们要保证 $F$ 在 $\left(\mathbb{R}, +\right)$ 和 $\left(\mathbb{R}_{>0}, \times\right)$ 上是同态的 (homomorphism)，例如：

$$ F \left(\left(w_i - w_j\right)^{\top} \tilde{w}_k\right) = \dfrac{F \left(w_i^{\top} \tilde{w}_k\right)}{F \left(w_j^{\top} \tilde{w}_k\right)} $$

其中 $F \left(w_i^{\top} \tilde{w}_k\right) = P_{ik} = \dfrac{X_{ik}}{X_i}$，则上式的一个解为 $F = \exp$，或：

$$ w_i^{\top} \tilde{w}_k = \log \left(P_{ik}\right) = \log \left(X_{ik}\right) - \log \left(X_i\right) $$

其中 $\log \left(X_i\right)$ 与 $k$ 无关记为 $b_i$，同时为了对称性添加 $\tilde{b}_k$，则上式改写为：

$$ w_i^{\top} \tilde{w}_k + b_i + \tilde{b}_k = \log \left(X_{ik}\right) $$

上式中，左侧为词向量的相关运算，右侧为共现矩阵的常量信息，则给出模型的损失函数如下：

$$ J = \sum_{i,j=1}^{V}{f \left(X_{ij}\right) \left(w_i^{\top} \tilde{w}_k + b_i + \tilde{b}_k - \log X_{ij}\right)^2} $$

其中，$V$ 为词典中词的个数，$f$ 为一个权重函数，其应具有如下特点：

1. $f \left(0\right) = 0$。如果 $f$ 为一个连续函数，则当 $x \to 0$ 时 $\lim_{x \to 0}{f \left(x\right) \log^2 x}$ 应足够快地趋近于无穷。
2. $f \left(x\right)$ 应为非减函数，以确保稀少的共现不会权重过大。
3. $f \left(x\right)$ 对于较大的 $x$ 应该相对较小，以确保过大的共现不会权重过大。

文中给出了一个符合要求的函数如下：

$$ f \left(x\right) = \begin{cases} \left(x / x_{\max}\right)^{\alpha} & \text{if} \ x < x_{\max} \\ 1 & \text{otherwise} \end{cases} $$

其中两个超参数的值建议为 $x_{\max} = 100, \alpha = 0.75$。

fastText

fastText 是由 Bojanowski 和 Grave 等人 ⁸ 提出的一种词向量表示方法。原始的 Skip-gram 模型忽略了词语内部的结构信息，fastText 利用 N-gram 方法将其考虑在内。

对于一个词 $w$，利用一系列的 N-gram 进行表示，同时在词的前后添加 < 和 > 边界符号以同其他文本序列进行区分。同时还将词语本身也包含在这个 N-gram 集合中，从而学习到词语的向量表示。例如，对于词 $where$ 和 $n = 3$，则 N-gram 集合为：<wh, whe, her, ere, re>，同时包含词本身 <where>。需要注意的是，序列 <her> 与词 $where$ 中的 tri-gram her 是两个不同的概念。模型提取所有 $3 \leq n \leq 6$ 的 N-gram 序列。

假设 N-gram 词典的大小为 $G$，对于一个词 $w$，$\mathcal{G}_w \subset \left\{1, ..., G\right\}$ 表示词中出现的 N-gram 的集合。针对任意一个 N-gram $g$，用向量 $\mathbf{z}_g$ 表示，则我们利用一个词的所有 N-gram 的向量的加和表示该词。可以得到该模型的评分函数为：

$$ s \left(w, c\right) = \sum_{g \in \mathcal{G}_w}{\mathbf{z}_g^{\top} \mathbf{v}_c} $$

模型在学习不同词向量时可以共享权重 (不同词的可能包含相同的 N-gram)，使得在学习低频词时也可得到可靠的向量表示。

WordRank

WordRank 是由 Ji 等人 ⁹ 提出的一种词向量表示方法，其将词向量学习问题转换成一个排序问题。

我们令 $\mathbf{u}_w$ 表示当前词 $w$ 的 $k$ 维词向量，$\mathbf{v}_c$ 表示当前词上下文 $c$ 的词向量。通过两者的内积 $\langle \mathbf{u}_w, \mathbf{v}_c \rangle$ 来捕获词 $w$ 和上下文 $c$ 之间的关系，两者越相关则该内积越大。对于一个给定的词 $w$，利用上下文集合 $\mathcal{C}$ 同词的内积分数进行排序，对于一个给定的上下文 $c$，排序为：

$$ \begin{equation} \begin{split} \text{rank} \left(w, c\right) &= \sum_{c' \in \mathcal{C} \setminus \left\{c\right\}}{I \left(\langle \mathbf{u}_w, \mathbf{v}_c \rangle - \langle \mathbf{u}_w, \mathbf{v}_{c'} \rangle \leq 0\right)} \\ &= \sum_{c' \in \mathcal{C} \setminus \left\{c\right\}}{I \left(\langle \mathbf{u}_w, \mathbf{v}_c - \mathbf{v}_{c'} \rangle \leq 0\right)} \end{split} \end{equation} $$

其中，$I \left(x \leq 0\right)$ 为一个 0-1 损失函数，当 $x \leq 0$ 时为 1 其他情况为 0。由于 $I \left(x \leq 0\right)$ 为一个非连续函数，因此我们可以将其替换为一个凸上限函数 $\ell \left(\cdot\right)$，其可以为任意的二分类损失函数，构建排序的凸上限如下：

$$ \text{rank} \left(w, c\right) \leq \overline{\text{rank}} \left(w, c\right) = \sum_{c' \in \mathcal{C} \setminus \left\{c\right\}}{\ell \left(\langle \mathbf{u}_w, \mathbf{v}_c - \mathbf{v}_{c'} \rangle\right)} $$

我们期望排序模型将更相关的上下文排在列表的顶部，基于此构建损失函数如下：

$$ J \left(\mathbf{U}, \mathbf{V}\right) := \sum_{w \in \mathcal{W}}{\sum_{c \in \Omega_w}{r_{w, c} \cdot \rho \left(\dfrac{\overline{\text{rank}} \left(w, c\right) + \beta}{\alpha}\right)}} $$

其中，$\mathcal{W}$ 表示词典，$\mathbf{U} := \left\{\mathbf{u}_w\right\}_{w \in \mathcal{W}}$ 和 $\mathbf{V} := \left\{\mathbf{c}_w\right\}_{c \in \mathcal{C}}$ 分别表示词及其上下文词向量的参数，$\Omega_w$ 表示与词 $w$ 共现的上下文的集合，$r_{w, c}$ 为衡量 $w$ 和 $c$ 之间关系的权重，$\rho \left(\cdot\right)$ 为用于衡量排序好坏的单调递增的损失函数，$\alpha \geq 0, \beta \geq 0$ 为超参数。可选的有：

$$ r_{w, c} = \begin{cases} \left(X_{w, c} / x_{\max}\right)^{\epsilon} & \text{if} \ X_{w, c} < x_{\max} \\ 1 & \text{otherwise} \end{cases} $$

其中 $x_{\max} = 100, \epsilon = 0.75$。根据 $\rho \left(\cdot\right)$ 的要求，损失函数在排序的顶部 (rank 值小) 的地方更加敏感，同时对于 rank 值较大的地方不敏感。这可以使得模型变得更加稳健 (避免语法错误和语言的非常规使用造成干扰)，因此可选的有：

$$ \begin{equation} \begin{split} \rho \left(x\right) &:= \log_2 \left(1 + x\right) \\ \rho \left(x\right) &:= 1 - \dfrac{1}{\log_2 \left(2 + x\right)} \\ \rho \left(x\right) &:= \dfrac{x^{1 - t} - 1}{1 - t}, t \neq 1 \end{split} \end{equation} $$

损失函数可以等价的定义为：

$$ J \left(\mathbf{U}, \mathbf{V}\right) := \sum_{\left(w, c\right) \in \Omega}{r_{w, c} \cdot \rho \left(\dfrac{\overline{\text{rank}} \left(w, c\right) + \beta}{\alpha}\right)} $$

在训练过程中，外层的求和符号容易利用 SDG 算法解决，但对于内层的求和符号除非 $\rho \left(\cdot\right)$ 是一个线性函数，否则难以求解。然而，$\rho \left(\cdot\right)$ 函数的性质要求其不能是一个线性函数，但我们可以利用其凹函数的特性对其进行一阶泰勒分解，有：

$$ \rho \left(x\right) \leq \rho \left(\xi^{-1}\right) + \rho' \left(\xi^{-1}\right) \cdot \left(x - \xi^{-1}\right) $$

对于任意 $x$ 和 $\xi \neq 0$ 均成立，同时当且仅当 $\xi = x^{-1}$ 时等号成立。因此，令 $\Xi := \left\{\xi_{w, c}\right\}_{\left(w, c\right) \in \Sigma}$，则可以得到 $J \left(\mathbf{U}, \mathbf{V}\right)$ 的一个上界：

$$ \begin{equation} \begin{split} \overline{J} \left(\mathbf{U}, \mathbf{V}, \Xi\right) &:= \sum_{\left(w, c\right) \in \Omega}{r_{w, c} \cdot \left\{\rho \left(\xi_{wc}^{-1}\right) + \rho' \left(\xi_{wc}^{-1}\right) \cdot \left(\alpha^{-1} \beta + \alpha^{-1} \sum_{c' \in \mathcal{C} \setminus \left\{c\right\}}{\ell \left(\langle \mathbf{u}_w, \mathbf{v}_c - \mathbf{v}_{c'} \rangle\right) - \xi_{w, c}^{-1}}\right)\right\}} \\ &= \sum_{\left(w, c, c'\right)}{r_{w, c} \cdot \left(\dfrac{\rho \left(\xi_{w, c}^{-1}\right) + \rho' \left(\xi_{w, c}^{-1}\right) \cdot \left(\alpha^{-1} \beta - \xi_{w, c}^{-1}\right)}{\lvert \mathcal{C} \rvert - 1} + \dfrac{1}{\alpha} \rho' \left(\xi_{w, c}^{-1}\right) \cdot \ell \left(\langle \mathbf{u}_w, \mathbf{v}_c - \mathbf{v}_{c'} \rangle\right)\right)} \end{split} \end{equation} $$

其中，$\left(w, c, c'\right) \in \Omega \times \left(\mathcal{C} \setminus \left\{c\right\}\right)$，至此我们可以通过均匀采样 $\left(w, c\right) \in \Sigma$ 和 $c' \in \mathcal{C} \setminus \left\{c\right\}$ 解决训练问题。

整个 WordRank 算法的伪代码如下：

\begin{algorithm}
\caption{WordRank 算法}
\begin{algorithmic}
\STATE $\eta$ 为学习率
\WHILE{$\mathbf{U}$，$\mathbf{V}$ 和 $\Xi$ 未收敛}
    \STATE \COMMENT{阶段1：更新 $\mathbf{U}$ 和 $\mathbf{V}$}
    \WHILE{$\mathbf{U}$ 和 $\mathbf{V}$ 未收敛}
        \STATE 从 $\Omega$ 中均匀采样 $\left(w, c\right)$
        \STATE 从 $\mathcal{C} \setminus \left\{c\right\}$ 中均匀采样 $c'$
        \STATE \COMMENT{同时更新如下 3 个参数}
        \STATE $\mathbf{u}_w \gets \mathbf{u}_w - \eta \cdot r_{w, c} \cdot \rho' \left(\xi_{w, c}^{-1}\right) \cdot \ell' \left(\langle \mathbf{u}_w, \mathbf{v}_c - \mathbf{v}_{c'} \rangle\right) \cdot \left(\mathbf{v}_c - \mathbf{v}_{c'}\right)$
        \STATE $\mathbf{v}_c \gets \mathbf{v}_c - \eta \cdot r_{w, c} \cdot \rho' \left(\xi_{w, c}^{-1}\right) \cdot \ell' \left(\langle \mathbf{u}_w, \mathbf{v}_c - \mathbf{v}_{c'} \rangle\right) \cdot \mathbf{u}_w$
        \STATE $\mathbf{v}_{c'} \gets \mathbf{v}_{c'} - \eta \cdot r_{w, c} \cdot \rho' \left(\xi_{w, c}^{-1}\right) \cdot \ell' \left(\langle \mathbf{u}_w, \mathbf{v}_c - \mathbf{v}_{c'} \rangle\right) \cdot \mathbf{u}_w$
    \ENDWHILE
    \STATE \COMMENT{阶段2：更新 $\Xi$}
    \FOR{$w \in \mathcal{W}$}
        \FOR{$c \in \mathcal{C}$}
            \STATE $\xi_{w, c} = \alpha / \left(\sum_{c' \in \mathcal{C} \setminus \left\{c\right\}}{\ell \left(\langle \mathbf{u}_w, \mathbf{v}_c - \mathbf{v}_{c'} \rangle\right) + \beta}\right)$
        \ENDFOR
    \ENDFOR
\ENDWHILE
\end{algorithmic}
\end{algorithm}

cw2vec

cw2vec 是由 Cao 等人 ¹⁰ 提出的一种基于汉字笔画 N-gram 的中文词向量表示方法。该方法根据汉字作为象形文字具有笔画信息的特点，提出了笔画 N-gram 的概念。针对一个词的笔画 N-gram，其生成过程如下图所示：

共包含 4 个步骤：

1. 将一个词拆解成单个的汉字，例如：“大人” 拆解为 “大” 和 “人”。
2. 将每个汉字拆解成笔画，例如：“大” 和 “人” 拆解为 “一，丿，乀，丿，乀”。
3. 将每个笔画映射到对应的编码序列，例如： “一，丿，乀，丿，乀” 映射为 13434。
4. 利用编码序列生成笔画 N-gram，例如：134，343，434；1343，3434；13434。

模型中定义一个词 $w$ 及其上下文 $c$ 的相似度如下：

$$ sim \left(w, c\right) = \sum_{q \in S\left(w\right)}{\vec{q} \cdot \vec{c}} $$

其中，$S$ 为由笔画 N-gram 构成的词典，$S \left(w\right)$ 为词 $w$ 对应的笔画 N-gram 集合，$q$ 为该集合中的一个笔画 N-gram，$\vec{q}$ 为 $q$ 对应的向量。

该模型的损失函数为：

$$ \mathcal{L} = \sum_{w \in D}{\sum_{c \in T \left(w\right)}{\log \sigma \left(sim \left(w, c\right)\right) + \lambda \mathbb{E}_{c' \sim P} \left[\log \sigma \left(- sim \left(w, c'\right)\right)\right]}} $$

其中，$D$ 为语料中的全部词语，$T \left(w\right)$ 为给定的词 $w$ 和窗口内的所有上次文词，$\sigma \left(x\right) = \left(1 + \exp \left(-x\right)\right)^{-1}$，$\lambda$ 为负采样的个数，$\mathbb{E}_{c' \sim P} \left[\cdot\right]$ 表示负样本 $c'$ 按照 $D$ 中词的分布 $P$ 进行采样，该分布可以为词的一元模型的分布 $U$，同时为了避免数据的稀疏性问题，类似 Word2Vec 中的做法采用 $U^{0.75}$。

在之前的 博客 中，我们曾经介绍过 PCA 方法及其降维的作用。在原始数据中各个特征之间存在着一定的信息冗余，随着特征的不断增加就容易出现“维数灾难”的问题，因此降维的目的就是在尽可能多的保留原始信息的同时减少数据的维度。一般情况下我们将降维方法分为：线性降维方法和非线性降维方法，线性降维方法的典型算法有：

• 主成份分析 (PCA, Principal Component Analysis) ¹
• 线性判别分写 (LDA, Linear Discriminant Analysis) ²
• 多尺度变换 (MDS, Multi-Dimensional Scaling) ³

非线性降维方法中在此我们仅列举一些基于流行学习的算法：

• 保距特征映射 (ISOMAP) ⁴
• 局部线性嵌入 (LLE, Locally Linear Embedding) ⁵
• 拉普拉斯特征映射 (LE, Laplacian Eigenmap) ⁶

在现实数据中，很多情况数据是无法通过线性的方法进行降维表示的，因此就需要非线性的降维算法出马了。

流形

在调研流形相关概念时，发现要想深一步的理解这些概念还是需要详细的了解微分几何相关的内容，鉴于本文的目的主要是介绍流形学习 (主要是降维角度) 的相关内容，因此我们对流形仅做一些粗略的介绍。

“流形”是英文单词 Manifold 的中文译名，它源于德文术语 Mannigfaltigkeit，最早出现在 Riemann 1851 年的博士论文中，用来表示某种属性所能取到的所有值 ⁷。为了更好的理解流形，我们先引入几个概念：

拓扑结构 (拓扑) 任意给定集合 $X$ 上的一个拓扑结构 (拓扑) 是 $X$ 的某些特定子集组成的集合 $\tau \subset 2^X$，其中那些特定子集称为 $\tau$ 所声明的开集，同时满足如下性质：

1. 空集和全集是开集，即 $\varnothing, X \in \tau$
2. 任意多个开集的并集是开集
3. 有限多个开集的交集是开集

拓扑空间 指定了拓扑结构的集合就称为一个拓扑空间。

上图中给出了一些拓扑空间的示例，其中左侧 4 个为正确示例，右侧 2 个为错误示例。右上角的缺少了 {2} 和 {3} 的并集 {2, 3}，右下角的缺少了 {1, 2} 和 {2, 3} 的交集 {2}。

同胚 两个拓扑空间 $\left(X, \tau_X\right)$ 和 $\left(Y, \tau_Y\right)$ 之间的函数 $f: X \to Y$ 称为同胚，如果它具有下列性质：

1. $f$ 是双射 (单射和满射)
2. $f$ 是连续的
3. 反函数 $f^{−1}$ 也是连续的 ($f$ 是开映射)

如果拓扑空间是一个几何物体，同胚就是把物体连续延展和弯曲，使其成为一个新的物体。因此，正方形和圆是同胚的，但球面和环面就不是。用一幅图形象的理解同胚，例如下图所示的咖啡杯和甜甜圈 ⁸：

最后我们回过头来解释到底什么是流形？流形并不是一个“形状”，而是一个“空间” ⁹。最容易定义的流形是拓扑流形，它局部看起来象一些“普通”的欧几里得空间 $\mathbb{R}^n$，一个拓扑流形是一个局部同胚于一个欧几里得空间的拓扑空间。根据 Whitney 嵌入理论 ¹⁰，任何一个流形都可以嵌入到高维的欧氏空间中。例如，地球的表面可以理解为一个嵌入 3 维空间的 2 维流形，其局部同胚于 2 维的欧式空间，对于一个球体的表面，用极坐标的形式可以表示为

$$ \begin{equation} \begin{split} x &= r \sin \theta \cos \phi \\ y &= r \sin \theta \sin \phi \\ z &= r \cos \theta \end{split} \end{equation} $$

也就是说其 3 个维度实际上是由 2 个变量控制的。

流形学习

假设 $Y$ 为一个欧式空间 $\mathbb{R}^d$ 的一个 $d$ 维流形，$f: Y \to \mathbb{R}^D$ 为一个光滑嵌入，对于 $D > d$，流形学习的目的就是根据空间 $\mathbb{R}^D$ 中的观测数据 $\{x_i\}$ 重构 $Y$ 和 $f$ 的过程。隐含数据 $\{y_i\}$ 由 $Y$ 随机生成，通过光滑嵌入 $f$ 生成观测数据，即 $\{x_i = f\left(y_i\right)\}$，所以我们可以将流形学习的问题看做是对于一个给定的观测数据一个生成模型的反向过程 ¹¹。

在介绍具体的流形学习算法前，我们先引入几个 3 维数据用于解释后续的具体算法

第一个为瑞士卷 (Swiss Roll)，其形状和我们日常生活中的瑞士卷相似；第二个为 S 形曲线 (S Curve)；第三个为一个被切断的球面 (Severed Sphere)。

MDS

多尺度变换 (MDS, Multi-Dimensional Scaling) ³ 是一种通过保留样本在高维空间中的不相似性 (Dissimilarity) 降低数据维度的方法，在这里不相似性可以理解为样本之间的距离。因此，根据距离的度量方式不同可以将其分为度量型 (metric) MDS 和 非度量型 (non-metric) MDS。度量型 MDS 通过计算不同样本之间距离的度量值进行降维，而非度量型则仅考虑距离的排序信息，在此我们仅对度量型 MDS 做简单介绍。

MDS 的目标是保留样本在高维空间中的不相似性，假设 $x \in \mathbb{R}^D, x' \in \mathbb{R}^d, D > d$，则 MDS 的目标函数可以写为

$$ \min \sum_{i, j} \lvert dist \left(x_i, x_j\right) - dist \left(x'_i, x'_j\right) \rvert $$

则，度量型 MDS 的算法的步骤如下：

1. 计算样本的距离矩阵 $\boldsymbol{D} = \left[d_{i, j}\right] = \left[dist \left(x_i, x_j\right)\right]$。
2. 构造矩阵 $\boldsymbol{A} = \left[a_{i, j}\right] = \left[- \dfrac{1}{2} d_{i, j}^2\right]$。
3. 通过中心矫正的方法构造矩阵 $\boldsymbol{B} = \boldsymbol{J} \boldsymbol{D} \boldsymbol{J}, \boldsymbol{J} = \boldsymbol{I} - \dfrac{1}{n} \boldsymbol{O}$，其中 $\boldsymbol{I}$ 为 $n \times n$ 的单位阵，$\boldsymbol{O}$ 为 $n \times n$ 的值均为 $1$ 的矩阵。
4. 计算矩阵 $\boldsymbol{B}$ 的特征向量 $e_1, e_2, ..., e_m$ 及其对应的特征值 $\lambda_1, \lambda_2, ..., \lambda_m$。
5. 确定维度 $k$，重构数据 $\boldsymbol{X}' = \boldsymbol{E}_k \boldsymbol{\Lambda}_k^{1/2}$，其中 $\boldsymbol{\Lambda}_k$ 为前 $k$ 个值最大的 $k$ 个特征值构成的对角矩阵，$\boldsymbol{E}_k$ 是对应的 $k$ 个特征向量构成的矩阵。

在《多元统计分析》¹²一书中证明了，$\boldsymbol{X}$ 的 $k$ 维主坐标正好是将 $\boldsymbol{X}$ 中心化后 $n$ 个样本的前 $k$ 个主成份的值，由此可见 MDS 和 PCA 的作用是类似的。

我们利用中国省会的地理位置给出 MDS 的一个示例，首先我们获取中国省会共 34 个点的坐标，其次我们计算两两之间的距离，我们仅利用距离信息利用 MDS 还原出 2 维空间中的坐标，可视化结果如下所示

其中，黑色的点为省会的真实位置，蓝色的点为利用距离矩阵和 MDS 还原出来的位置，为了绘制还原出的位置我们对 MDS 的结果做出了适当的翻转和变换。从结果中不难看出，尽管每个点的坐标相比真实坐标都有一定的偏离，但是其很好的保持了相对距离，这也正是 MDS 算法的要求。

ISOMAP

对于一些非线性的流形，如果使用线性的降维方法得到的效果就不尽人意了，例如上文中提到的瑞士卷。在 ISOMAP 中，我们首先引入一个测地线的概念，在距离度量定义时，测地线可以定义为空间中两点的局域最短路径。形象的，在一个球面上，两点之间的测地线就是过这两个点的大圆的弧线

那么，对于非线性流形，ISOMAP 则是通过构建邻接图，利用图上的最短距离来近似测地线。在构造邻接图时，我们使用最近邻算法，对于一个点 $x_i$ 连接距离其最近的 $k$ 个点，两点之间的距离我们则一般使用传统的欧式距离。则任意两点之间的测地线距离则可以利用构建的邻接图上的最短路径进行估计，图上的最短路问题我们可以通过 Dijkstra 或 Floyd-Warshall 算法计算。得到样本的距离矩阵后，ISOMAP 算法则使用 MDS 方法计算得到低维空间的座标映射。

上图中，我们给出了利用 ISOMAP 对瑞士卷降至 2 维的一个格式化过程。第一幅图中，我们标注了 2 个蓝色的点，其中蓝色的直线为这 2 个点在三维空间中的欧式距离。第二幅图中，同样是相同的两个点，我们首先利用最近邻算法 ($k = 10$) 将瑞士卷所有的点连接为一个邻接图，其中红色的路径为这 2 个点在邻接图上的最短路。第三幅图是通过 ISOMAP 算法降维至 2 维的结果，其中蓝色的直线是这两个点在 2 维空间中的欧式距离，红色的路径是 3 维最短路在 2 维结果中的连线，可以看出两者是很相近的。

LLE

局部线性嵌入 (LLE, Locally Linear Embedding) ⁵，从这个名称上我们不难看出其不同与 ISOMAP 那种通过都建邻接图保留全局结构的，而是从局部结构出发对数据进行降维。在 LLE 方法中，主要有如下的基本假设：

• 一个流形的局部可以近似于一个欧式空间
• 每个样本均可以利用其邻居进行线性重构

基于上面的假设，LLE 算法的流程如下：

1. 对于点 $X_i$，计算距离其最近的 $k$ 个点，$X_j, j \in N_i$。
2. 计算权重 $W_{ij}$ 是的能够通过点 $X_i$ 的邻居节点最优的重构该点，即最小化 $$ \epsilon \left(W\right) = \sum_i \left\lVert X_i - \sum_j W_{ij} X_j \right\rVert ^2 $$
3. 通过权重 $W_{ij}$ 计算 $X$ 的低维最优重构 $Y$，即最小化 $$ \phi \left(Y\right) = \sum_i \left\lVert Y_i - \sum_j W_{ij} Y_j \right\rVert ^2 $$

具体上述问题的优化求解过程在此就不在详细描述。针对 LLE 算法，后续很多人从不同方面对其进行了改进：

1. Hessian LLE ¹³ 在局部中不再考虑局部的线性关系，而是保持局部的 Hessian 矩阵的二次型的关系。
2. Modified LLE ¹⁴ 则是修改了寻找最临近的 $k$ 个样本的方案，其在寻找 $k$ 近邻时希望找到的近邻尽量分布在样本的各个方向，而不是集中在一侧。
3. LTSA (Local Tangent Space Alignment) ¹⁵ 则是除了保留了局部的几何性质，同时使用的一个从局部几何到整体性质过渡的 alignment 方法，因此可以理解为是一个局部和整体的组合。

LE

LE (Laplacian Eigenmap) ⁶ 的基本思想是认为在高维空间中距离近的点映射到低维空间中后其位置也相距很近。LE 从这个思想出发，最终将问题转化为求解图拉普拉斯算子的广义特征值问题，具体的一些证明不在这里详细展开说明，具体请参见原文，下面仅给出 LE 算法的流程：

1. 构建邻接图。
2. 构建邻接矩阵 $W$，构建邻接矩阵有两种方法：对于点 $i$ 和点 $j$ 相连，如果利用 Hear Kernel (参数 $t \in \mathbb{R}$)，则令 $W_{ij} = \exp \left(\dfrac{- \left\lVert x_i - x_j \right\rVert ^ 2}{t}\right)$；如果使用简介方案，则令 $W_{ij} = 1$，对于不相连的点，则令 $W_{ij} = 0$。
3. 进行特征映射，通过上面构造的图 $G$，计算如下广义特征值和特征向量 $$ L f = \lambda D f $$ 其中 $D$ 是一个对角矩阵，$D_{ii} = \sum_{j} W_{ji}$，$L = D - W$ 即为拉普拉斯矩阵。对于上式的解 $f_0, .., f_{k-1}$ 为根据特征值从小到大的排序，其中 $0 = \lambda_0 \leq \lambda_1 \leq ... \leq \lambda_{k-1}$，则降维至 $d$ 维的后的特征即为 $\left(f_1, f_2, ..., f_d\right)$。

SNE 和 t-SNE

SNE

SNE (Stochastic Neighbor Embedding) ¹⁶ 是由 Hinton 等人提出的一种降维算法，其方法的基本假设如下：

1. 对象之间的相似度可以用概率进行表示，即：相似的对象有更高的概率被同时选择，不相似的对象有较低的概率被同时选择。
2. 在高维空间中构建的这种概率分布应该尽可能的同低维空间中的概率分布相似。

对于两个点 $x_i, x_j$，假设 $x_i$ 以条件概率 $p_{j∣i}$ 选择 $x_j$ 作为它的邻近点，因此如果两者距离更近 (更相似)，则概率值越大，反之概率值越小，则我们定义 $p_{j∣i}$ 如下：

$$ p_{j∣i} = \dfrac{\exp \left(\dfrac{- \left\lVert x_i - x_j \right\rVert ^ 2}{2 \sigma_i^2}\right)}{\sum_{k \neq i} \exp \left(\dfrac{- \left\lVert x_i - x_k \right\rVert ^ 2}{2 \sigma_i^2}\right)} $$

其中，$\sigma_i$ 为参数，同时我们设置 $p_{i∣i} = 0$，因为我们仅需衡量不同对象之间的相似度。

类似的，根据 SNE 的基本思想，当数据被映射到低维空间中后，其概率分布应同高维空间中的分布尽可能的相似，假设点 $x_i, x_j$ 在低维空间中的映射点为 $y_i, y_j$，则在低维空间中的条件概率 $q_{j∣i}$ 定义为：

$$ q_{j∣i} = \dfrac{\exp \left(- \left\lVert y_i - y_j \right\rVert ^ 2\right)}{\sum_{k \neq i} \exp \left(- \left\lVert y_i - y_k \right\rVert ^ 2\right)} $$

同样，我们设置 $q_{i∣i} = 0$。从 SNE 的基本假设出发，我们的目的是使得数据在高维空间中的条件概率尽可能的和其在低维空间中的条件概率相同，因此对于全部点样本点而言，就是保证高维空间的概率分布 $P_i$ 和低维空间的概率分布 $Q_i$ 尽量形同。在这里我们利用 KL 散度衡量这两个概率分布的差异，则 SNE 的损失函数可以写为：

$$ C = \sum_{i} KL \left(P_i \Vert Q_i\right) = \sum_{i} \sum_{j} p_{j∣i} \log \dfrac{p_{j∣i}}{q_{j∣i}} $$

因为 KL 散度具有不对称性可知，当在原始空间中两点距离较远而降维后的空间中距离较近 (即，$q_{j|i} < p_{j|i}$) 时，会产生较大的 cost，相反则会产生较小的 cost。正是这种不对称性的损失函数导致了 SNE 算法更加关注局部结构，相比忽略了全局结构。

上文中，对于不同的点，$\sigma_i$ 具有不同的值，SNE 算法利用困惑度 (Perplexity) 对其进行优化寻找一个最佳的 $\sigma$，对于一个随机变量 $P_i$，困惑度定义如下：

$$ Perp \left(P_i\right) = 2^{H \left(P_i\right)} $$

其中，$H \left(P_i\right) = \sum_{j} p_{j|i} \log_2 p_{j|i}$ 表示 $P_i$ 的熵。困惑度可以解释为一个点附近的有效近邻点个数。SNE 对困惑度的调整比较有鲁棒性，通常选择 5-50 之间，给定之后，使用二分搜索的方式寻找合适的 $\sigma$。

SNE 的损失函数对 $y_i$ 求梯度后，可得：

$$ \dfrac{\delta C}{\delta y_i} = 2 \sum_j \left(p_{j|i} - q_{j|i} + p_{i|j} - q_{i|j}\right) \left(y_i - y_j\right) $$

t-SNE

SNE 为我们提供了一种很好的降维方法，但是其本身也存在一定的问题，主要有如下两点：

• 不对称问题：损失函数中的 KL 散度具有不对称性，导致 SNE 更加关注局部结构，相比忽略了全局结构。
• 拥挤问题：从高维空间映射到低维空间后，不同类别的簇容易挤在一起，无法较好地区分开。

针对这两个问题，Maaten 等人又提出了 t-SNE 算法对其进行优化 ¹⁷。

针对不对称问题，Maaten 采用的方法是用联合概率分布来替代条件概率分布。高维控件中的联合概率分布为 $P$，低维空间中的联合概率分布为 $Q$，则对于任意的 $i, j$，有 $p_{ij} = p_{ji}, q_{ij} = q_{ji}$，联合概率定义为：

$$ \begin{align} p_{ij} &= \dfrac{\exp \left(\dfrac{- \left\lVert x_i - x_j \right\rVert ^ 2}{2 \sigma^2}\right)}{\sum_{k \neq l} \exp \left(\dfrac{- \left\lVert x_k - x_l \right\rVert ^ 2}{2 \sigma^2}\right)} \\ q_{ij} &= \dfrac{\exp \left(- \left\lVert y_i - y_j \right\rVert ^ 2\right)}{\sum_{k \neq l} \exp \left(- \left\lVert y_k - y_l \right\rVert ^ 2\right)} \end{align} $$

虽然这样保证了对称性，但是对于异常的情况，例如数据点 $x_i$ 在距离群簇较远，则 $\lVert x_i − x_j \rVert ^ 2$ 的值会很大，而 $p_{ij}$ 会相应变得非常小，也就是说 $x_i$ 的位置很远这件事情对损失函数影响很小 (惩罚过小)，那这个点在低维空间中将无法从其他点中区分出来。因此 Maaten 提出了对称的条件概率来重新定义上述联合概率 $p_{ij}$ ，对于数量为 $n$ 的数据点，新的概率公式是：

$$ p_{ij} = \dfrac{p_{j|i} + p_{i|j}}{2n} $$

则损失函数更新为：

$$ C = \sum_{i} KL \left(P_i \Vert Q_i\right) = \sum_{i} \sum_{j} p_{ij} \log \dfrac{p_{ij}}{q_{ij}} $$

梯度更新为：

$$ \dfrac{\delta C}{\delta y_i} = 4 \sum_j \left(p_{ij} - q_{ij}\right) \left(y_i - y_j\right) $$

拥挤问题 (Crowding) 就是从高维空间映射到低维空间后，不同类别的簇容易挤在一起，不能很好的地区分开。t-SNE 则是利用了 t 分布重新定义 $q_{ij}$，t 分布具有长尾特性，相比于高斯分布，其在尾部趋向于 0 的速度更慢，对比如图所示：

利用 t 分布重新定义的 $q_{ij}$ 为：

$$ q_{ij} = \dfrac{\left(1 + \lVert y_i - y_j \rVert ^ 2\right) ^ {-1}}{\sum_{k \neq l} \left(1 + \lVert y_k - y_l \rVert ^ 2\right) ^ {-1}} $$

梯度更新为：

$$ \dfrac{\delta C}{\delta y_i} = 4 \sum_j \left(p_{ij} - q_{ij}\right) \left(y_i - y_j\right) \left(1 + \lVert y_i - y_j \rVert ^ 2\right) ^ {-1} $$

利用 t-SNE 对 MNIST 数据集进行降维可视化结果如下：

方法比较

针对上述的若干算法，我们简单列举一下每个算法的优缺点

对于瑞士卷 (Swiss Roll)，S 形曲线 (S Curve) 和切断的球面 (Severed Sphere)，我们利用不同的流形算法对其进行降维，可视化的对比结果如下面 3 张图所示，图中同时标注了算法的运行时间，实现主要参照了 scikit-learn 关于流形学习算法的比较 ¹⁸。

文中相关图片绘制实现详见代码，本文部分内容参考了流形学习专题介绍 ¹⁹， 流形学习 ²⁰，Chrispher ²¹ 的博客和 bingo ²² 的博客。

Ising 模型

Ising 模型最早是由物理学家威廉·冷次在 1920 年发明的，他把该模型当成是一个给他学生恩斯特·易辛的问题。易辛在他一篇 1924 年的论文 ¹ 中求得了一维易辛模型的解析解，并且证明它不会产生相变。 二维方晶格易辛模型相对于一维的难出许多，因此其解析的描述在一段时间之后才在 1943 年由拉斯·昂萨格给出 ²。

Ising 模型假设铁磁物质是由一堆规则排列的小磁针构成，每个磁针只有上下两个方向。相邻的小磁针之间通过能量约束发生相互作用，同时受到环境热噪声的干扰而发生磁性的随机转变。涨落的大小由关键的温度参数决定，温度越高，随机涨落干扰越强，小磁针越容易发生无序而剧烈地状态转变，从而让上下两个方向的磁性相互抵消，整个系统消失磁性，如果温度很低，则小磁针相对宁静，系统处于能量约束高的状态，大量的小磁针方向一致，铁磁系统展现出磁性。而当系统处于临界温度 $T_C$ 时，Ising 模型表现出一系列幂律行为和自相似现象 ³。

由于 Ising 模型的高度抽象，可以很容易地将它应用到其他领域之中。例如，将每个小磁针比喻为某个村落中的村民，而将小磁针上下的两种状态比喻成个体所具备的两种政治观点，相邻小磁针之间的相互作用比喻成村民之间观点的影响，环境的温度比喻成每个村民对自己意见不坚持的程度，这样 Ising 模型就可以建模该村落中不同政治见解的动态演化。在社会科学中，人们已经将 Ising 模型应用于股票市场、种族隔离、政治选择等不同的问题。另一方面，如果将小磁针比喻成神经元细胞，向上向下的状态比喻成神经元的激活与抑制，小磁针的相互作用比喻成神经元之间的信号传导，那么，Ising 模型的变种还可以用来建模神经网络系统，从而搭建可适应环境、不断学习的机器，例如 Hopfield 网络或 Boltzmann 机。

考虑一个二维的情况

如图所示，每个节点都有两种状态 $s_i \in \{+1, -1\}$，则我们可以定义这个系统的能量为

$$ E = -H \sum_{i=1}^{N}{s_i} - J \sum_{<i, j>}{s_i s_j} $$

其中 $H$ 为外界磁场的强度，$J$ 为能量耦合常数，$\sum_{<i, j>}$表示对于相邻的两个节点的函数值求和。因此，可以得出

1. 当每个节点的方向同外部磁场一致时，系统能量越小；反之系统能量越大。
2. 对于 $J > 0$，当相邻的节点方向相同时，系统能量越小；反之系统能量越大。

对于整个系统的演变，除了系统的总能量以外，还受到节点所处环境的热噪声影响。我们利用温度 $T$ 表示环境对节点的影响，当 $T$ 越高时，节点状态发生变化的可能性越大。此时，则有两种力量作用在每个节点上

1. 节点邻居和外部磁场的影响，这种影响使得当前节点尽可能的同其邻居和外部磁场保持一致，即尽可能是系统的总能量达到最小。
2. 环境的影响，这种影响使得每个节点的状态以一定的概率发生随机变化。

不难想像，当 $T = 0$ 时，节点状态完全受其邻居和外部磁场影响，当 $J = 0, H = 0$ 时，节点处于完全的随机状态。

对于 Ising 模型，我们利用蒙特卡罗方法进行模拟。初始化系统状态为 $s_i^{\left(0\right)}$，对于任意时刻 $t$，对其状态 $s_i^{\left(t\right)}$进行一个改变，将其中一个节点变为相反的状态，得到新的状态 $s'_i$

$$ s_i^{\left(t+1\right)} = \begin{cases} s'_i & \text{with probablity of } \mu \\ s_i^{\left(t\right)} & \text{with probablity of } 1-\mu \end{cases} $$

其中 $\mu = \min\left\lbrace\dfrac{e^{E\left(s_i^{\left(t\right)}\right) - E\left(s'_i\right)}}{kT}, 1\right\rbrace$ 表示接受转移的概率；$k \approx 1.38 \times 10^{23}$ 为玻尔兹曼常数。我们利用蒙特卡罗方法对其进行模拟 $T = 4J/k$的情况，我们分别保留第 $0, 1, 5, 50, 500, 5000$ 步的模拟结果

# 每一轮状态转移
each_round <- function(current_matrix, ising_config) {
    n_row <- nrow(current_matrix)
    n_col <- ncol(current_matrix)
    
    for (i in 1:n_row) {
        for (j in 1:n_col) {
            current_row <- sample(1:n_row, 1)
            current_col <- sample(1:n_col, 1)
            s <- current_matrix[current_row, current_col]
            e <- -(current_matrix[(current_row-1-1)%%n_row+1, current_col] +
                current_matrix[current_row, (current_col-1-1)%%n_col+1] +
                current_matrix[(current_row+1)%%n_row, current_col] +
                current_matrix[current_row, (current_col+1)%%n_col]) *
                s * ising_config$j
            mu <- min(exp((e + e) / (ising_config$k * ising_config$t)), 1)
            mu_random <- runif(1)
            
            if (mu_random < mu) {
                s <- -1 * s
            }
            
            current_matrix[current_row, current_col] <- s
        }
    }
    
    current_matrix
}

# Ising 模拟
ising_simulation <- function(N, iter, ising_config, saved_steps) {
    set.seed(112358)
    current_matrix <- matrix(sample(0:1, N^2, replace = T), N, N)*2-1
    saved_matrix <- list()
    
    if (0 %in% saved_steps) {
        saved_matrix <- c(saved_matrix, list(current_matrix))
    }
    
    for (i in 1:iter) {
        if (i %in% saved_steps) {
            saved_matrix <- c(saved_matrix, list(current_matrix))
        }
        
        current_matrix <- each_round(current_matrix, ising_config)
        
        if (i %% 1000 == 0) {
            cat(paste0("Steps: ", i, '\n'))
        }
    }
    
    saved_matrix
}

# T = 4J/K，方便模拟取 j = 1, k = 1, t = 4
ising_config <- list(j = 1, k = 1, t = 4)
diff_steps_matrix <- ising_simulation(100, 5000, ising_config,
                                      c(0, 1, 5, 50, 500, 5000))

模拟结果可视化效果如图所示

对于二维的 Ising 模型，存在一个相变点，在相变点上的温度 $T_c$ 满足

$$ \sinh\left(\dfrac{2J_1}{kT_c}\right) \sinh\left(\dfrac{2J_2}{kT_c}\right) = 1 $$

若 $J_1 = J_2$，则

$$ T_c = \dfrac{2J}{k \ln\left(1 + \sqrt{2}\right)} \approx 2.27 \dfrac{J}{k} $$

称之为临界温度。当温度小于临界值的时候，Ising 模型中大多数节点状态相同，系统处于较为秩序的状态。当温度大于临界值的时候，大多数节点的状态较为混乱，系统处于随机的状态。而当温度接近临界的时候，系统的运行介于随机与秩序之间，也就是进入了混沌的边缘地带，这种状态称为临界状态。

我们模拟不同温度下，系统在运行 $50$ 步时的状态

ising_config_t <- c(1, 2, 2.27, 2.5, 3, 6)
diff_t_matrix <- lapply(ising_config_t, function(t) {
    ising_config <- list(j = 1, k = 1, t = t)
    ising_simulation(100, 50, ising_config, c(50))
})

模拟结果可视化效果如图所示

Hopfield 神经网络

Hopfield 神经网络 ⁴ 是一种基于能量的反馈人工神经网络。Hopfield 神经网络分为离散型 (Discrete Hopfield Neural Network, DHNN) 和 连续性 (Continues Hopfield Neural Network, CHNN)。

离散型 Hopfield 神经网络

网络结构

对于离散型 Hopfield 神经网络，其网络结果如下

对于具有 $n$ 个神经元的网络，我们设 $t$ 时刻的网络状态为 $\boldsymbol{X}^{\left(t\right)} = \left(x_1^{\left(t\right)}, x_2^{\left(t\right)}, ..., x_n^{\left(t\right)}\right)^T$，对于 $t+1$ 时刻网络的状态

$$ x_i^{\left(t+1\right)} = f \left(net_i\right) $$

其中，DHNN 中 $f$ 多为符号函数，即

$$ x_i = \sign \left(net_i\right) = \begin{cases} 1, net_i \geq 0 \\ -1, net_i < 0 \end{cases} $$

$net_i$ 为一个节点的输入，为

$$ net_i = \sum_{j=1}^{n}{\left(w_{ij}x_j - T_i\right)} $$

其中 $T_i$ 为每个神经元的阈值，对于 DHNN，一般有 $w_{ii} = 0, w_{ij} = w_{ji}$，当反馈网络稳定后，稳定后的状态即为网络的输出。网络的更新主要有两种状态，异步方式和同步方式。

对于异步方式的更新方法，每一次仅改变一个神经元 $j$ 的状态，即

$$ x_i^{\left(t+1\right)} = \begin{cases} \sign\left(net_i^{\left(t\right)}\right), i = j \\ x_i^{\left(t\right)}, i \neq j \end{cases} $$

对于同步方式的更新方法，每一次需改变所有神经元的状态，即

$$ x_i^{\left(t+1\right)} = \sign\left(net_i^{\left(t\right)}\right) $$

网络稳定性

我们可以将反馈网络看做一个非线性动力学系统，因此这个系统最后可能会收敛到一个稳态，或在有限状态之间振荡，亦或是状态为无穷多个即混沌现象。对于 DHNN 因为其网络状态是有限的，因此不会出现混沌的现象。若一个反馈网络达到一个稳态状态 $\boldsymbol{X}$ 时，即 $\boldsymbol{X}^{\left(t+1\right)} = \boldsymbol{X}^{\left(t\right)}$ ，则称这个状态为一个吸引子。在 Hopfield 网络结构和权重确定的情况下，其具有 $M$ 个吸引子，因此我们可以认为这个网络具有存储 $M$ 个记忆的能力。

设 $\boldsymbol{X}$ 为网络的一个吸引子，权重矩阵 $\boldsymbol{W}$ 是一个对称阵，则定义 $t$ 时刻网络的能量函数为

$$ E\left(t\right) = -\dfrac{1}{2} \boldsymbol{X}^{\left(t\right)T} \boldsymbol{W} \boldsymbol{X}^{\left(t\right)} + \boldsymbol{X}^{\left(t\right)T} \boldsymbol{T} $$

则定义网络能量的变化量

$$ \Delta E\left(t\right) = E\left(t+1\right) - E\left(t\right) $$

则以异步更新方式，不难推导得出

$$ \begin{equation} \begin{split} \Delta E\left(t\right) = -\Delta x_i^{\left(t\right)} \left(\sum_{j=1}^{n}{\left(w_{ij}x_j - T_j\right)}\right) - \dfrac{1}{2} \Delta x_i^{\left(t\right)2} w_{ii} \end{split} \end{equation} $$

由于网络中的神经元不存在自反馈，即 $w_{ii} = 0$，则上式可以化简为

$$ \Delta E\left(t\right) = -\Delta x_i^{\left(t\right)} net_i^{\left(t\right)} $$

因此，对于如上的能量变化，可分为 3 中情况：

1. 当 $x_i^{\left(t\right)} = -1, x_i^{\left(t+1\right)} = 1$ 时，$\Delta x_i^{\left(t\right)} = 2, net_i^{\left(t\right)} \geq 0$，则可得 $\Delta E \left(t\right) \leq 0$。
2. 当 $x_i^{\left(t\right)} = 1, x_i^{\left(t+1\right)} = -1$ 时，$\Delta x_i^{\left(t\right)} = -2, net_i^{\left(t\right)} < 0$，则可得 $\Delta E \left(t\right) < 0$。
3. 当 $x_i^{\left(t\right)} = x_i^{\left(t+1\right)}$ 时，$\Delta x_i^{\left(t\right)} = 0$，则可得 $\Delta E \left(t\right) = 0$。

则对于任何情况，$\Delta E \left(t\right) \leq 0$，也就是说在网络不断变化的过程中，网络的总能量是一直下降或保持不变的，因此网络的能量最终会收敛到一个常数。

设 $\boldsymbol{X}'$ 为吸引子，对于异步更新方式，若存在一个变换顺序，使得网络可以从状态 $\boldsymbol{X}$ 转移到 $\boldsymbol{X}'$，则称 $\boldsymbol{X}$ 弱吸引到 $\boldsymbol{X}'$，这些 $\boldsymbol{X}$ 的集合称之为 $\boldsymbol{X}$ 的弱吸引域；若对于任意变换顺序，都能够使得网络可以从状态 $\boldsymbol{X}$ 转移到 $\boldsymbol{X}'$，则称 $\boldsymbol{X}$ 强吸引到 $\boldsymbol{X}'$，对于这些 $\boldsymbol{X}$ 称之为 $\boldsymbol{X}$ 的强吸引域。

对于 Hopfield 网络的权重，我们利用 Hebbian 规则进行设计。Hebbian 规则认为如果两个神经元同步激发，则它们之间的权重增加；如果单独激发，则权重减少。则对于给定的 $p$ 个模式样本 $\boldsymbol{X}^k, k = 1, 2, ..., p$，其中 $x \in \{-1, 1\}^n$ 且样本之间两两正交，则权重计算公式为

$$ w_{ij} = \dfrac{1}{n} \sum_{k=1}^{p}{x_i^k x_j^k} $$

则对于给定的样本 $\boldsymbol{X}$ 确定为网络的吸引子，但对于有些非给定的样本也可能是网络的吸引子，这些吸引子称之为伪吸引子。以上权重的计算是基于两两正交的样本得到的，但真实情况下很难保证样本两两正交，对于非正交的模式，网络的存储能力则会大大下降。根据 Abu-Mostafa⁵ 的研究表明，当模式的数量 $p$ 大于 $0.15 n$ 时，网络的推断就很可能出错，也就是结果会收敛到伪吸引子上。

示例

我们通过一个手写数字识别的例子介绍一些 Hopfield 网络的功能，我们存在如下 10 个数字的图片，每张为像素 16*16 的二值化图片，其中背景色为白色，前景色为黑色 (每个图片的名称为 num.png，图片位于 /images/cn/2018-01-17-ising-hopfield-and-rbm 目录)。

首先我们载入每张图片的数据

library(EBImage)

# 载入数据
digits <- lapply(0:9, function(num) {
    readImage(paste0(num, '.png'))
})

# 转换图像为 16*16 的一维向量
# 将 (0, 1) 转换为 (-1, 1)
digits_patterns <- lapply(digits, function(digit) {
    pixels <- c(digit)
    pixels * 2 - 1
})

接下来利用这 10 个模式训练一个 Hopfield 网络

#' 训练 Hopfield 网络
#' 
#' @param n 网络节点个数
#' @param pattern_list 模式列表
#' @return 训练好的 Hopfield 网络
train_hopfield <- function(n, pattern_list) {
    weights <- matrix(rep(0, n*n), n, n)
    n_patterns <- length(pattern_list)
    
    for (i in 1:n_patterns) {
        weights <- weights + pattern_list[[i]] %o% pattern_list[[i]]
    }
    diag(weights) <- 0
    weights <- weights / n_patterns
    
    list(weights = weights, n = n)
}

# 训练 Hopfield 网络
digits_hopfield_network <- train_hopfield(16*16, digits_patterns)

为了测试 Hopfiled 网络的记忆能力，我们利用 10 个模式生成一些测试数据，我们分别去掉图像的右边或下边的 5 个像素，生成新的 20 张测试图片

# 构造测试数据
digits_test_remove_right <- lapply(0:9, function(num) {
    digit_test <- digits[[num+1]]
    digit_test[12:16, ] <- 1
    digit_test
})
digits_test_remove_bottom <- lapply(0:9, function(num) {
    digit_test <- digits[[num+1]]
    digit_test[, 12:16] <- 1
    digit_test
})
digits_test <- c(digits_test_remove_right, digits_test_remove_bottom)

# 转换图像为 16*16 的一维向量
# 将 (0, 1) 转换为 (-1, 1)
digits_test_patterns <- lapply(digits_test, function(digit) {
    pixels <- c(digit)
    pixels * 2 - 1
})

我们利用训练好的 Hopfield 网络运行测试数据，我们迭代 300 次并保存最后的网络输出

#' 运行 Hopfiled 网络
#' @param hopfield_network 训练好的 Hopfield 网络
#' @param pattern 输入的模式
#' @param max_iter 最大迭代次数
#' @param save_history 是否保存状态变化历史
#' @return 最终的模式 (以及历史模式)
run_hopfield <- function(hopfield_network, pattern,
                         max_iter = 100, save_history = T) {
    last_pattern <- pattern
    history_patterns <- list()
    
    for (iter in 1:max_iter) {
        current_pattern <- last_pattern
        
        i <- round(runif(1, 1, hopfield_network$n))
        net_i <- hopfield_network$weights[i, ] %*% current_pattern
        current_pattern[i] <- ifelse(net_i < 0, -1, 1)
        
        if (save_history) {
            history_patterns[[iter]] <- last_pattern
        }
        
        last_pattern <- current_pattern
    }
    
    list(history_patterns = history_patterns,
         final_pattern = last_pattern)
}

# 运行 Hopfield 网络，获取测试数据结果
digits_test_results_patterns <- lapply(digits_test_patterns,
                                       function(pattern) {
    run_hopfield(digits_hopfield_network, pattern, max_iter = 300)
})

# 转换测试数据结果为图片
digits_test_results <- lapply(digits_test_results_patterns,
                              function(result) {
    each_dim <- sqrt(digits_hopfield_network$n)
    Image((result$final_pattern + 1) / 2,
          dim = c(each_dim, each_dim),
          colormode = 'Grayscale')
})

网络变换过程中，图像的变换如图所示

最终网络的输出如图所示

从结果中可以看出，部分测试图片还是得到了比较好的恢复，但如上文所说，由于我们给定的模式之间并不是两两正交的，因此，网络的推断就很可能出错 (例如：数字 5 恢复的结果更像 9 多一些)，甚至结果会收敛到伪吸引子上。

连续型 Hopfield 神经网络

网络结构

连续型 Hopfield 网络相比于离散型 Hopfield 网络的主要差别在于：

1. 网络中所有的神经元随时间 $t$ 同时更新，网络状态随时间连续变化。
2. 神经元的状态转移函数为一个 S 型函数，例如 $$ v_i = f\left(u_i\right) = \dfrac{1}{1 + e^{\dfrac{-2 u_i}{\gamma}}} = \dfrac{1}{2} \left(1 + \tanh \dfrac{u_i}{\gamma}\right) $$ 其中，$v_i$ 表示一个神经元的输出，$u_i$ 表示一个神经元的输入。

对于理想情况，网络的能量函数可以写为⁶

$$ E = -\dfrac{1}{2} \sum_{i=1}^{n}{\sum_{j=1}^{n}{w_{ij} v_i v_j}} - \sum_{i=1}^{n} v_i I_i $$

可以得出，随着网络的演变，网络的总能量是降低的，随着网络中节点的不断变化，网络最终收敛到一个稳定的状态。

TSP 问题求解

旅行推销员问题 (Travelling salesman problem, TSP) 是指给定一系列城市和每对城市之间的距离，求解访问每一座城市一次并回到起始城市的最短路径 ⁷。TSP 问题是一个 NP-hard 问题 ⁸。

对于 TSP 问题，我们给定一个城市指之间的距离矩阵

$$ D = \left\lgroup \begin{array}{cccc} d_{11} & d_{12} & \cdots & d_{1n} \\ d_{21} & d_{22} & \cdots & d_{2n} \\ \vdots & \vdots & & \vdots \\ d_{n1} & d_{n2} & \cdots & d_{nn} \end{array} \right\rgroup $$

其中 $d_{ij} = d_{ji}, i \neq j$ 表示城市 $i$ 和城市 $j$ 之间的距离，$d_{ij} = 0, i = j$。TSP 问题的优化目标是找到一条路径访问每一座城市一次并回到起始城市，我们利用一个矩阵表示访问城市的路径

$$ V = \left\lgroup \begin{array}{cccc} v_{11} & v_{12} & \cdots & v_{1n} \\ v_{21} & v_{22} & \cdots & v_{2n} \\ \vdots & \vdots & & \vdots \\ v_{n1} & v_{n2} & \cdots & v_{nn} \end{array} \right\rgroup $$

其中 $v_{xi} = 1$ 表示第 $i$ 次访问城市 $x$，因此对于矩阵 $V$，其每一行每一列仅有一个元素值为 $1$，其他元素值均为 $0$。

对于 TSP 问题，我们可以得到如下约束条件

• 城市约束

因为每个城市只能访问一次，因此对于第 $x$ 行仅能有一个元素是 $1$，其他均为 $0$，即任意两个相邻元素的乘积为 $0$

$$ \sum_{i=1}^{n-1}{\sum_{j=i+1}^{n}{v_{xi}v_{xj}}} = 0 $$

则对于城市约束，我们得到该约束对应的能量分量为

$$ E_1 = \dfrac{1}{2} A \sum_{x=1}^{n}{\sum_{i=1}^{n-1}{\sum_{j=i+1}^{n}{v_{xi}v_{xj}}}} $$

• 时间约束

因为每一时刻仅能够访问一个城市，因此对于第 $i$ 行仅能有一个元素是 $1$，其他均为 $0$，即任意两个相邻元素的乘积为 $0$

$$ \sum_{x=1}^{n-1}{\sum_{y=x+1}^{n}{v_{xi}v_{yi}}} = 0 $$

则对于时间约束，我们得到该约束对应的能量分量为

$$ E_2 = \dfrac{1}{2} B \sum_{i=1}^{n}{\sum_{x=1}^{n-1}{\sum_{y=x+1}^{n}{v_{xi}v_{yi}}}} $$

• 有效性约束

当矩阵 $V$ 中所有的元素均为 $0$ 的时候，可得 $E_1 = 0, E_2 = 0$，但显然这并不是一个有效的路径，因此我们需要保证矩阵 $V$ 中元素值为 $1$ 的个数为 $n$，即

$$ \sum_{x=1}^{n}{\sum_{i=1}^{n}{v_{xi}}} = n $$

则对于有效性约束，我们得到该约束对应的能量分量为

$$ E_3 = \dfrac{1}{2} C \left(\sum_{x=1}^{n}{\sum_{i=1}^{n}{v_{xi}}} - n\right)^2 $$

• 路径长度约束

如上三个约束仅能够保证我们的路径是有效的，但并不一定是最优的。根绝 TSP 问题的优化目标，我们需要引入一个反映路径长度的能量分量，并保证该能量分量随着路径长度的减小而减小。访问两个城市 $x, y$ 有两种形式，$x \to y$ 或 $y \to x$，如果城市 $x$ 和城市 $y$ 在旅行中顺序相邻，则 $v_{xi}v_{y,i+1} = 1, v_{xi}v_{y,i-1} = 0$，反之亦然。则反映路径长度的能量分量可以定义为

$$ E_4 = \dfrac{1}{2} D \sum_{x=1}^{n}{\sum_{y=1}^{n}{\sum_{i=1}^{n}{d_{xy}\left(v_{xi}v_{y,i+1} + v_{xi}v_{y,i-1}\right)}}} $$

综上所述，TSP 问题的能量函数定义为

$$ E = E_1 + E_2 + E_3 + E_4 $$

其中，$A, B, C, D > 0$ 分别为每个能量分量的权重。针对这样的能量函数，我们可得对应神经元 $x_i$ 和 $y_i$ 之间的权重为

$$ \begin{equation} \begin{split} w_{x_i, y_i} = &-2A \delta_{xy} \left(1-\delta_{xy}\right) - 2B \delta_{ij} \left(1-\delta_{xy}\right) \\ &- 2C -2D d_{xy} \left(\delta_{j, i+1} + \delta_{i, j+1}\right) \end{split} \end{equation} $$

其中

$$ \delta_{xy} = \begin{cases} 1, x = y \\ 0, x \neq y \end{cases} , \delta_{ij} = \begin{cases} 1, i = j \\ 0, i \neq j \end{cases} $$

因此可以得到网络关于时间的导数

$$ \begin{equation} \begin{split} \dfrac{d u_{xi}}{d t} = &-2A \sum_{j \neq i}^{n}{v_{xj}} - 2B \sum_{y \neq x}^{n}{v_{yi}} - 2C \left(\sum_{x=1}^{n}{\sum_{j=1}^{n}{v_{xj}}} - n\right) \\ &- 2D \sum_{y \neq x}^{n}{d_{xy}\left(v_{y, i+1} + v_{y, i-1}\right)} - \dfrac{u_{xi}}{\tau} \end{split} \end{equation} $$

据此，我们以一个 10 个城市的数据为例，利用 CHNN 求解 TSP 问题，其中 10 个城市的座标为

已知的最优路线为 $A \to D \to E \to F \to G \to H \to I \to J \to B \to C \to A$，最优路线的路径长度为 $2.6907$。我们使用如下参数求解 TSP 问题，初始化 $u_{init} = -\dfrac{\gamma}{2} \ln\left(n - 1\right)$，$\gamma = 0.02$，学习率 $\alpha = 0.0001$，神经元激活阈值 $\theta = 0.7$，$\tau = 1$，能量分量权重参数 $A = 500, B = 500, C = 1000, D = 500$，单次迭代最大次数为 1000，共模拟 100 次。

# 城市座标
cities <- data.frame(
    l = LETTERS[1:10],
    x = c(0.4000, 0.2439, 0.1707, 0.2293, 0.5171,
          0.8732, 0.6878, 0.8488, 0.6683, 0.6195),
    y = c(0.4439, 0.1463, 0.2293, 0.7610, 0.9414,
          0.6536, 0.5219, 0.3609, 0.2536, 0.2634)
)

# 通过城市座标构建距离矩阵
distance_matrix <- function(points) {
    n <- nrow(points)
    d <- matrix(rep(0, n^2), n, n)
    
    for (i in 1:n) {
        for (j in i:n) {
            distance <- sqrt((points[i, ]$x - points[j, ]$x)^2 +
                                 (points[i, ]$y - points[j, ]$y)^2)
            d[i, j] <- distance
            d[j, i] <- distance
        }
    }
    
    d
}

# 结果约束校验
check_path_valid <- function(v, n) {
    # 城市约束
    c1 <- 0
    for (x in 1:n) {
        for (i in 1:(n-1)) {
            for (j in (i+1):n) {
                c1 <- c1 + v[x, i] * v[x, j]
            }
        }
    }
    
    # 时间约束
    c2 <- 0
    for (i in 1:n) {
        for (x in 1:(n-1)) {
            for (y in (x+1):n) {
                c2 <- c2 + v[x, i] * v[y, i]
            }
        }
    }
    
    # 有效性约束
    c3 <- sum(v)
    
    ifelse(c1 == 0 & c2 == 0 & c3 == n, T, F)
}

# 根据结果矩阵获取路径
v_to_path <- function(v, n) {
    p <- c()
    
    for (i in 1:n) {
        for (x in 1:n) {
            if (v[x, i] == 1) {
                p <- c(p, x)
                break
            }
        }
    }
    
    p
}

# 计算结果矩阵的路径长度
path_distance <- function(v, n, d) {
    p <- v_to_path(v, n)
    p <- c(p, p[1])
    distance <- 0 
    for (i in 1:(length(p)-1)) {
        distance <- distance + d[p[i], p[i+1]]
    }
    
    distance
}

# 构建 Hopfield 网络
tsp_chnn <- function(d, n, gamma = 0.02, alpha = 0.0001,
                     theta = 0.7, tau = 1,
                     A = 500, B = 500, C = 1000, D = 500,
                     max_iter = 1000) {
    v <- matrix(runif(n^2), n, n)
    u <- matrix(rep(1, n^2), n, n) * (-gamma * log(n-1) / 2)
    du <- matrix(rep(0, n^2), n, n)
    
    for (iter in 1:max_iter) {
        for (x in 1:n) {
            for (i in 1:n) {
                # E1
                e1 <- 0
                for (j in 1:n) {
                    if (j != i) {
                        e1 <- e1 + v[x, j]
                    }
                }
                e1 <- -A * e1
                
                # E2
                e2 <- 0
                for (y in 1:n) {
                    if (y != x) {
                        e2 <- e2 + v[y, i]
                    }
                }
                e2 <- -B * e2
                
                # E3
                e3 <- -C * (sum(v) - n)
                
                # E4
                e4 <- 0
                for (y in 1:n) {
                    if (y != x) {
                        e4 <- e4 + d[x, y] *
                            (v[y, (i+1-1)%%n+1] + v[y, (i-1-1)%%n+1])
                    }
                }
                e4 <- -D * e4
                
                du[x, i] <- e1 + e2 + e3 + e4 - u[x, i] / tau
            }
        }
        
        u <- u + alpha * du
        v <- (1 + tanh(u / gamma)) / 2
        v <- ifelse(v >= theta, 1, 0)
    }
    
    v
}

# 利用 Hopfiled 网络求解 TSP 问题
set.seed(112358)

n <- 10
d <- distance_matrix(cities)

# 模拟 100 次并获取最终结果
tsp_solutions <- lapply(1:100, function(round) {
    v <- tsp_chnn(d, n)
    valid <- check_path_valid(v, n)
    distance <- ifelse(valid, path_distance(v, n, d), NA)
    
    list(round = round, valid = valid,
         distance = distance, v = v)
})

# 获取最优结果
best_tsp_solution <- NA
for (tsp_solution in tsp_solutions) {
    if (tsp_solution$valid) {
        if (!is.na(best_tsp_solution)) {
            if (tsp_solution$distance < best_tsp_solution$distance) {
                best_tsp_solution <- tsp_solution
            }
        } else {
            best_tsp_solution <- tsp_solution
        }
    }
}

# 可视化最优结果
best_tsp_solution_path <- v_to_path(best_tsp_solution$v, n)
ordered_cities <- cities[best_tsp_solution_path, ] %>%
    mutate(ord = seq(1:10))

best_tsp_solution_path_p <- ggplot(ordered_cities) +
    geom_polygon(aes(x, y), color = 'black', fill = NA) +
    geom_point(aes(x, y)) +
    geom_text(aes(x, y, label = l), vjust = -1) +
    geom_text(aes(x, y, label = ord), vjust = 2) +
    coord_fixed() + ylim(c(0, 1)) + xlim(c(0, 1)) +
    theme(axis.title = element_blank())
print(best_tsp_solution_path_p)

受限的玻尔兹曼机 (RBM)

网络结构及其概率表示

受限的玻尔兹曼机 (Restricted Boltzmann Machine, RBM) 或簧风琴 (harmonium) 是由 Smolensky 与 1986年在玻尔兹曼机 (Boltzmann Machine, BM) 基础上提出的一种随机神经网络 (Stochastic Neural Networks) ⁹。受限的玻尔兹曼机对于原始的玻尔兹曼机做了相应的限制，在其网络结构中包含可见节点和隐藏节点，并且可见节点和隐藏节点内部不允许存在连接，更加形象的可以将其理解为一个二分图。

对于二值版本的 RBM 而言，其中可见层 $\mathbf{v} = \left(v_1, v_2, ..., v_{n_v}\right)^T$ 由 $n_v$ 个二值随机变量构成；隐藏层 $\mathbf{h} = \left(h_1, h_2, ..., h_{n_h}\right)^T$ 由 $n_h$ 个二值随机变量构成。

RBM 同样作为一个基于能量的模型，其能量函数定义为：

$$ E \left(\boldsymbol{v}, \boldsymbol{h}\right) = -\sum_{i=1}^{n_v}{b_i v_i} -\sum_{j=1}^{n_h}{c_j h_j} - \sum_{i=1}^{n_v}{\sum_{j=1}^{n_h}{v_i w_{i,j} h_i}} $$

将其表示成矩阵向量的形式，可记为：

$$ E \left(\boldsymbol{v}, \boldsymbol{h}\right) = -\boldsymbol{b}^T \boldsymbol{v} - \boldsymbol{c}^T \boldsymbol{h} - \boldsymbol{v}^T \boldsymbol{W} \boldsymbol{h} $$

其中 $\boldsymbol{b} \in \mathbb{R}^{n_v}$ 为可见层的偏置向量；$\boldsymbol{c} \in \mathbb{R}^{n_h}$ 为隐含层的偏置向量；$\boldsymbol{W} \in \mathbb{R}^{n_v \times n_h}$ 为可见层和隐含层之间的权重矩阵。根据能量函数，可得其联合概率分布为：

$$ P \left(\mathbf{v} = \boldsymbol{v}, \mathbf{h} = \boldsymbol{h}\right) = \dfrac{1}{Z} e^{-E \left(\boldsymbol{v}, \boldsymbol{h}\right)} $$

其中 $Z$ 为归一化常数，成为配分函数：

$$ Z = \sum_{\boldsymbol{v}}{\sum_{\boldsymbol{h}}{e^{-E \left(\boldsymbol{v}, \boldsymbol{h}\right)}}} $$

对于 RBM 我们更加关注的的为边缘分布，即：

$$ P \left(\boldsymbol{v}\right) = \sum_{h}{P\left(\boldsymbol{v}, \boldsymbol{h}\right)} = \dfrac{1}{Z} \sum_{h}{e^{-E\left(\boldsymbol{v}, \boldsymbol{h}\right)}} $$

因为概率中包含归一化常数，我们需要计算 $Z$，从其定义可得，当穷举左右可能性的化，我们需要计算 $2^{n_v + n_h}$ 个项，其计算复杂度很大。尽管 $P\left(\boldsymbol{v}\right)$ 计算比较困难，但是其条件概率 $P\left(\mathbf{h} | \mathbf{v}\right)$ 和 $P\left(\mathbf{v} | \mathbf{h}\right)$ 计算和采样相对容易。为了便于推导，我们定义如下记号：

$$ \boldsymbol{h}_{-k} = \left(h_1, h_2, ..., h_{k-1}, h_{k+1}, ..., h_{n_h}\right)^T $$

则 $P\left(h_k = 1 | \boldsymbol{v}\right)$ 定义如下：

$$ \begin{equation} \begin{split} &P\left(h_k = 1 | \boldsymbol{v}\right) \\ = &P\left(h_k = 1 | h_{-k}, \boldsymbol{v}\right) \\ = &\dfrac{P\left(h_k = 1, h_{-k}, \boldsymbol{v}\right)}{P\left(h_{-k}, \boldsymbol{v}\right)} \\ = &\dfrac{P\left(h_k = 1, h_{-k}, \boldsymbol{v}\right)}{P\left(h_k = 1 | h_{-k}, \boldsymbol{v}\right) + P\left(h_k = 0 | h_{-k}, \boldsymbol{v}\right)} \\ = &\dfrac{\dfrac{1}{Z} e^{-E\left(h_k = 1, h_{-k}, \boldsymbol{v}\right)}}{\dfrac{1}{Z} e^{-E\left(h_k = 1, h_{-k}, \boldsymbol{v}\right)} + \dfrac{1}{Z} e^{-E\left(h_k = 0, h_{-k}, \boldsymbol{v}\right)}} \\ = &\dfrac{e^{-E\left(h_k = 1, h_{-k}, \boldsymbol{v}\right)}}{e^{-E\left(h_k = 1, h_{-k}, \boldsymbol{v}\right)} + e^{-E\left(h_k = 0, h_{-k}, \boldsymbol{v}\right)}} \\ = &\dfrac{1}{1 + e^{E\left(h_k = 1, h_{-k}, \boldsymbol{v}\right) - E\left(h_k = 0, h_{-k}, \boldsymbol{v}\right)}} \\ \end{split} \end{equation} $$

其中：

$$ \begin{equation} \begin{split} &E\left(h_k = 1, h_{-k}, \boldsymbol{v}\right) \\ = &E\left(h_k = 1, \boldsymbol{v}\right) \\ = &-\sum_{i=1}^{n_v}{b_i v_i} - \sum_{j=1, j \neq k}^{n_h}{c_j h_j} - \sum_{i=1}^{n_v}{\sum_{j=1, j \neq k}^{n_h}{v_i W_{i, j} h_i}} - c_k - \sum_{i=1}^{n_v}{v_i W_{i, k}} \\ &E\left(h_k = 0, h_{-k}, \boldsymbol{v}\right) \\ = &E\left(h_k = 0, \boldsymbol{v}\right) \\ = &-\sum_{i=1}^{n_v}{b_i v_i} - \sum_{j=1, j \neq k}^{n_h}{c_j h_j} - \sum_{i=1}^{n_v}{\sum_{j=1, j \neq k}^{n_h}{v_i W_{i, j} h_i}} \end{split} \end{equation} $$

因此，$P\left(h_k = 1 | \boldsymbol{v}\right)$ 可以化简为：

$$ \begin{equation} \begin{split} &P\left(h_k = 1 | \boldsymbol{v}\right) \\ = &\dfrac{1}{1 + e^{-\left(c_k + \sum_{i=1}^{n_v}{v_i W_{i, k}}\right)}} \\ = &\sigma\left(c_k + \sum_{i=1}^{n_v}{v_i W_{i, k}}\right) \\ = &\sigma\left(c_k + \boldsymbol{v}^T \boldsymbol{W}_{:, k}\right) \end{split} \end{equation} $$

其中，$\sigma$ 为 sigmoid 函数。因此，我们可以将条件分布表示为连乘的形式：

$$ \begin{equation} \begin{split} P\left(\boldsymbol{h} | \boldsymbol{v}\right) &= \prod_{j=1}^{n_h}{P\left(h_j | \boldsymbol{v}\right)} \\ &= \prod_{j=1}^{n_h}{\sigma\left(\left(2h - 1\right) \odot \left(\boldsymbol{c} + \boldsymbol{W}^T \boldsymbol{v}\right)\right)_j} \end{split} \end{equation} $$

同理可得：

$$ \begin{equation} \begin{split} P\left(\boldsymbol{v} | \boldsymbol{h}\right) &= \prod_{i=1}^{n_v}{P\left(v_i | \boldsymbol{h}\right)} \\ &= \prod_{i=1}^{n_v}{\sigma\left(\left(2v - 1\right) \odot \left(\boldsymbol{b} + \boldsymbol{W} \boldsymbol{h}\right)\right)_i} \end{split} \end{equation} $$

模型训练 ¹⁰

对于 RBM 模型的训练，假设训练样本集合为 $S = \left\lbrace{\boldsymbol{v^1}, \boldsymbol{v^2}, ..., \boldsymbol{v^{n_s}}}\right\rbrace$，其中 $\boldsymbol{v^i} = \left(v_{1}^{i}, v_{2}^{i}, ..., v_{n_v}^{i}\right), i = 1, 2, ..., n_s$。则训练 RBM 的目标可以定义为最大化如下似然：

$$ \mathcal{L}_{\theta, S} = \prod_{i=1}^{n_s}{P\left(\boldsymbol{v}^i\right)} $$

其中 $\theta$ 为待优化的参数，为了方便计算，等价目标为最大化其对数似然：

$$ \ln\mathcal{L}_{\theta, S} = \ln\prod_{i=1}^{n_s}{P\left(\boldsymbol{v}^i\right)} = \sum_{i=1}^{n_s}{\ln P\left(\boldsymbol{v}^i\right)} $$

我们将其对数似然简写为 $\ln\mathcal{L}_S$ ，通过梯度上升方法，我们可以得到参数的更新公式：

$$ \theta = \theta + \eta \dfrac{\partial \ln\mathcal{L}_S}{\partial \theta} $$

对于单个样本 $\boldsymbol{\color{red}{v'}}$ ，有：

$$ \begin{equation} \begin{split} \dfrac{\partial \ln\mathcal{L}_S}{\partial \theta} &= \dfrac{\partial \ln P\left(\boldsymbol{\color{red}{v'}}\right)}{\partial \theta} = \dfrac{\partial \ln \left(\dfrac{1}{Z} \sum_{\boldsymbol{h}}{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)}}\right)}{\partial \theta} \\ &= \dfrac{\partial \left(\ln \sum_{\boldsymbol{h}}{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)}} - \ln Z\right)}{\partial \theta} = \dfrac{\partial \left(\ln \sum_{\boldsymbol{h}}{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)}} - \ln \sum_{\boldsymbol{v, h}}{e^{-E\left(\boldsymbol{v, h}\right)}}\right)}{\partial \theta} \\ &= \dfrac{\partial}{\partial \theta} \left(\ln \sum_{\boldsymbol{h}}{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)}}\right) - \dfrac{\partial}{\partial \theta} \left(\ln \sum_{\boldsymbol{v, h}}{e^{-E\left(\boldsymbol{v, h}\right)}}\right) \\ &= -\dfrac{1}{\sum_{\boldsymbol{h}}{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)}}} \sum_{\boldsymbol{h}}{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)} \dfrac{\partial E\left(\boldsymbol{\color{red}{v'}, h}\right)}{\partial \theta}} + \dfrac{1}{\sum_{\boldsymbol{v, h}}{e^{-E\left(\boldsymbol{v, h}\right)}}} \sum_{\boldsymbol{v, h}}{e^{-E\left(\boldsymbol{v, h}\right)} \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial \theta}} \\ &= -\sum_{\boldsymbol{h}}{\dfrac{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)}}{\sum_{\boldsymbol{h}}{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)}}} \dfrac{\partial E\left(\boldsymbol{\color{red}{v'}, h}\right)}{\partial \theta}} + \sum_{\boldsymbol{v, h}}{\dfrac{e^{-E\left(\boldsymbol{v, h}\right)}}{\sum_{\boldsymbol{v, h}}{e^{-E\left(\boldsymbol{v, h}\right)}}} \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial \theta}} \\ &= -\sum_{\boldsymbol{h}}{\dfrac{\dfrac{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)}}{Z}}{\dfrac{\sum_{\boldsymbol{h}}{e^{-E\left(\boldsymbol{\color{red}{v'}, h}\right)}}}{Z}} \dfrac{\partial E\left(\boldsymbol{\color{red}{v'}, h}\right)}{\partial \theta}} + \sum_{\boldsymbol{v, h}}{\dfrac{e^{-E\left(\boldsymbol{v, h}\right)}}{\sum_{\boldsymbol{v, h}}{e^{-E\left(\boldsymbol{v, h}\right)}}} \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial \theta}} \\ &= -\sum_{\boldsymbol{h}}{\dfrac{P\left(\boldsymbol{\color{red}{v'}, h}\right)}{P\left(\boldsymbol{\color{red}{v'}}\right)} \dfrac{\partial E\left(\boldsymbol{\color{red}{v'}, h}\right)}{\partial \theta}} + \sum_{\boldsymbol{v, h}}{\dfrac{e^{-E\left(\boldsymbol{v, h}\right)}}{\sum_{\boldsymbol{v, h}}{e^{-E\left(\boldsymbol{v, h}\right)}}} \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial \theta}} \\ &= -\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h | \color{red}{v'}}\right) \dfrac{\partial E\left(\boldsymbol{\color{red}{v'}, h}\right)}{\partial \theta}} + \sum_{\boldsymbol{v, h}}{P\left(\boldsymbol{h | v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial \theta}} \end{split} \end{equation} $$

其中：

$$ \begin{equation} \begin{split} \sum_{\boldsymbol{v, h}}{P\left(\boldsymbol{h | v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial \theta}} &= \sum_{\boldsymbol{v}}{\sum_{\boldsymbol{h}}{P\left(\boldsymbol{v}\right) P\left(\boldsymbol{h | v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial \theta}}} \\ &= \sum_{\boldsymbol{v}}{P\left(\boldsymbol{v}\right) \sum_{\boldsymbol{h}}{P \left(\boldsymbol{h | v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial \theta}}} \end{split} \end{equation} $$

则对于参数 $w_{i, j}$ 可得：

$$ \begin{equation} \begin{split} &\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h|v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial w_{i, j}}} \\ = &-\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h|v}\right) h_i v_j} \\ = &-\sum_{\boldsymbol{h}}{\prod_{k=1}^{n_h}{P\left(h_k | \boldsymbol{v}\right) h_i v_j}} \\ = &-\sum_{\boldsymbol{h}}{P\left(h_i | \boldsymbol{v}\right) P\left(h_{-i} | \boldsymbol{v}\right) h_i v_j} \\ = &-\sum_{\boldsymbol{h_i}}{\sum_{h_{-i}}{P\left(h_i | \boldsymbol{v}\right) P\left(\boldsymbol{h_{-i}} | \boldsymbol{v}\right) h_i v_j}} \\ = &-\sum_{\boldsymbol{h_i}}{P\left(h_i | \boldsymbol{v}\right) h_i v_j} \sum_{\boldsymbol{h_{-i}}}{P\left(h_{-i} | \boldsymbol{v}\right)} \\ = &-\sum_{\boldsymbol{h_i}}{P\left(h_i | \boldsymbol{v}\right) h_i v_j} \\ = &-\left(P\left(h_i = 0 | \boldsymbol{v}\right) \cdot 0 \cdot v_j + P\left(h_i = 1 | \boldsymbol{v}\right) \cdot 1 \cdot v_j\right) \\ = &-P\left(h_i = 1 | \boldsymbol{v}\right) v_j \end{split} \end{equation} $$

则对于参数 $b_i$ 可得：

$$ \begin{equation} \begin{split} &\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h|v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial b_i}} \\ = &-\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h|v}\right) v_i} \\ = &-v_i \sum_{\boldsymbol{h}}{P\left(\boldsymbol{h|v}\right)} \\ = &-v_i \end{split} \end{equation} $$

则对于参数 $c_j$ 可得：

$$ \begin{equation} \begin{split} &\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h|v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial c_j}} \\ = &-\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h|v}\right) h_j} \\ = &-\sum_{\boldsymbol{h}}{\prod_{k=1}^{n_h}{P\left(h_k | \boldsymbol{v}\right) h_j}} \\ = &-\sum_{\boldsymbol{h}}{P\left(h_j | \boldsymbol{v}\right) P\left(h_{-j} | \boldsymbol{v}\right) h_j} \\ = &-\sum_{h_j}{\sum_{h_{-j}}{P\left(h_i | \boldsymbol{v}\right) P\left(h_{-j} | \boldsymbol{v}\right) h_j}} \\ = &-\sum_{h_j}{P\left(h_i | \boldsymbol{v}\right) h_j} \sum_{h_{-j}}{P\left(h_{-j} | \boldsymbol{v}\right)} \\ = &-\sum_{h_j}{P\left(h_i | \boldsymbol{v}\right) h_j} \\ = &-\left(P\left(h_j = 0 | \boldsymbol{v}\right) \cdot 0 + P\left(h_j = 1 | \boldsymbol{v}\right) \cdot 1\right) \\ = &-P\left(h_j = 1 | \boldsymbol{v}\right) \end{split} \end{equation} $$

综上所述，可得：

$$ \begin{equation} \begin{split} \dfrac{\partial \ln P\left(\color{red}{\boldsymbol{v'}}\right)}{\partial w_{i, j}} &= -\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h | \color{red}{v'}}\right) \dfrac{\partial E\left(\boldsymbol{\color{red}{v'}, h}\right)}{\partial w_{i, j}}} + \sum_{\boldsymbol{v, h}}{P\left(\boldsymbol{h | v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial w_{i, j}}} \\ &= P\left(h_i = 1 | \boldsymbol{\color{red}{v'}}\right) \color{red}{v'_j} - \sum_{\boldsymbol{v}}{P\left(\boldsymbol{v}\right) P\left(h_i = 1 | \boldsymbol{v}\right) v_j}\\ \dfrac{\partial \ln P\left(\color{red}{\boldsymbol{v'}}\right)}{\partial b_i} &= -\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h | \color{red}{v'}}\right) \dfrac{\partial E\left(\boldsymbol{\color{red}{v'}, h}\right)}{\partial b_i}} + \sum_{\boldsymbol{v, h}}{P\left(\boldsymbol{h | v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial b_i}} \\ &= \color{red}{v'_i} - \sum_{\boldsymbol{v}}{P\left(\boldsymbol{v}\right) v_i} \\ \dfrac{\partial \ln P\left(\color{red}{\boldsymbol{v'}}\right)}{\partial c_j} &= -\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h | \color{red}{v'}}\right) \dfrac{\partial E\left(\boldsymbol{\color{red}{v'}, h}\right)}{\partial c_j}} + \sum_{\boldsymbol{v, h}}{P\left(\boldsymbol{h | v}\right) \dfrac{\partial E\left(\boldsymbol{v, h}\right)}{\partial c_j}} \\ &= P\left(h_j = 1 | \boldsymbol{\color{red}{v'}}\right) - \sum_{\boldsymbol{v}}{P\left(\boldsymbol{v}\right) P\left(h_j = 1 | \boldsymbol{v}\right)} \\ \end{split} \end{equation} $$

对于多个样本 $S = \left\lbrace{\boldsymbol{v^1}, \boldsymbol{v^2}, ..., \boldsymbol{v^{n_s}}}\right\rbrace$，有：

$$ \begin{equation} \begin{split} \dfrac{\partial \ln \mathcal{L}_S}{\partial w_{i, j}} &= \sum_{m=1}^{n_S}{\left[P\left(h_i = 1 | \boldsymbol{v^m}\right) v_j^m - \sum_{\boldsymbol{v}}{P\left(\boldsymbol{v}\right) P\left(h_i = 1 | \boldsymbol{v} v_j\right)}\right]} \\ \dfrac{\partial \ln \mathcal{L}_S}{\partial b_i} &= \sum_{m=1}^{n_S}{\left[v_i^m - \sum_{\boldsymbol{v}}{P\left(\boldsymbol{v}\right) v_i}\right]} \\ \dfrac{\partial \ln \mathcal{L}_S}{\partial c_j} &= \sum_{m=1}^{n_S}{\left[P\left(h_j = 1 | \boldsymbol{v^m}\right) - \sum_{\boldsymbol{v}}{P\left(\boldsymbol{v}\right) P\left(h_j = 1 | \boldsymbol{v}\right)}\right]} \end{split} \end{equation} $$

针对如上方法，我们需要计算 $\sum_{\boldsymbol{v}}$ 相关项，如上文所述，其计算复杂度为 $O\left(2^{n_v + n_h}\right)$，因为其条件概率计算比较容易，因此我们可以用 Gibbs 采样的方法进行估计，但由于 Gibbs 采样方法存在 burn-in period，因此需要足够次数的状态转移后才能够收敛到目标分布，因此这就增大了利用这种方法训练 RBM 模型的时间。

针对这个问题，Hinton 于 2002 年提出了对比散度 (Contrastive Divergence, CD) 算法 ¹¹，基本思想为将训练样本作为采样的初始值，因为目标就是让 RBM 去拟合这些样本的分布，因此这样则可以通过更少的状态转移就收敛到平稳分布。$k$ 步 CD 算法大致步骤为：

1. 对 $\forall \boldsymbol{v} \in \boldsymbol{S}$，初始化 $\boldsymbol{v}^{\left(0\right)} = \boldsymbol{v}$。
2. 执行 $k$ 步 Gibbs 采样，对于第 $t$ 步，分别利用 $P\left(\boldsymbol{h} | \boldsymbol{v}^{\left(t-1\right)}\right)$ 和 $P\left(\boldsymbol{v} | \boldsymbol{h}^{\left(t-1\right)}\right)$ 采样出 $\boldsymbol{h}^{\left(t-1\right)}$ 和 $\boldsymbol{v}^{\left(t\right)}$。
3. 利用采样得到的 $\boldsymbol{v}^{\left(k\right)}$ 近似估计 $\sum_{\boldsymbol{v}}$ 相关项： $$ \begin{equation} \begin{split} \dfrac{\partial \ln P\left(\boldsymbol{v}\right)}{\partial w_{i, j}} &\approx P\left(h_i=1|\boldsymbol{v}^{\left(0\right)}\right) v_j^{\left(0\right)} - P\left(h_i=1|\boldsymbol{v}^{\left(k\right)}\right) v_j^{\left(k\right)} \\ \dfrac{\partial \ln P\left(\boldsymbol{v}\right)}{\partial b_i} &\approx v_i^{\left(0\right)} - v_i^{\left(k\right)} \\ \dfrac{\partial \ln P\left(\boldsymbol{v}\right)}{\partial c_j} &\approx P\left(h_j=1|\boldsymbol{v}^{\left(0\right)}\right) - P\left(h_j=1|\boldsymbol{v}^{\left(k\right)}\right) \end{split} \end{equation} $$

近似估计可以看做是利用

$$ CDK\left(\theta, \boldsymbol{v}\right) = -\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h} | \boldsymbol{v}^{\left(0\right)}\right) \dfrac{\partial E\left(\boldsymbol{v}^{\left(0\right)}, h\right)}{\partial \theta}} + \sum_{\boldsymbol{h}}{P\left(\boldsymbol{h} | \boldsymbol{v}^{\left(k\right)}\right) \dfrac{\partial E\left(\boldsymbol{v}^{\left(k\right)}, \boldsymbol{h}\right)}{\partial \theta}} $$

近似

$$ \dfrac{\partial \ln P\left(\boldsymbol{v}\right)}{\partial \theta} = -\sum_{\boldsymbol{h}}{P\left(\boldsymbol{h} | \boldsymbol{v}^{\left(0\right)}\right) \dfrac{\partial E\left(\boldsymbol{v}^{\left(0\right)}, h\right)}{\partial \theta}} + \sum_{\boldsymbol{v, h}}{P\left(\boldsymbol{v, h}\right) \dfrac{\partial E\left(\boldsymbol{v}, \boldsymbol{h}\right)}{\partial \theta}} $$

的过程。

基于对比散度的 RBM 训练算法可以描述为：

\begin{algorithm}
\caption{CDK 算法}
\begin{algorithmic}
\REQUIRE $k, \boldsymbol{S}, \text{RBM}\left(\boldsymbol{W, b, c}\right)$
\ENSURE $\Delta \boldsymbol{W}, \Delta \boldsymbol{b}, \Delta \boldsymbol{c}$
\PROCEDURE{CDK}{$k, \boldsymbol{S}, \text{RBM}\left(\boldsymbol{W, b, c}\right)$}
    \STATE $\Delta \boldsymbol{W} \gets 0, \Delta \boldsymbol{b} \gets 0, \Delta \boldsymbol{c} \gets 0$
    \FORALL{$\boldsymbol{v \in S}$}
        \STATE $\boldsymbol{v}^{\left(0\right)} \gets \boldsymbol{v}$
        \FOR{$t = 0, 1, ..., k-1$}
            \STATE $\boldsymbol{h}^{\left(t\right)} \gets \text{sample_h_given_v} \left(\boldsymbol{v}^{\left(t\right)}, \text{RBM}\left(W, b, c\right)\right)$
            \STATE $\boldsymbol{v}^{\left(t+1\right)} \gets \text{sample_v_given_h} \left(\boldsymbol{h}^{\left(t\right)}, \text{RBM}\left(W, b, c\right)\right)$
        \ENDFOR
        \FOR{$i = 1, 2, ..., n_h; j = 1, 2, ..., n_v$}
            \STATE $\Delta w_{i, j} \gets \Delta w_{i, j} + \left[P\left(h_i=1|\boldsymbol{v}^{\left(0\right)}\right) v_j^{\left(0\right)} - P\left(h_i=1|\boldsymbol{v}^{\left(k\right)}\right) v_j^{\left(k\right)}\right]$
            \STATE $\Delta b_i \gets \Delta b_i = \left[v_i^{\left(0\right)} - v_i^{\left(k\right)}\right]$
            \STATE $\Delta c_j \gets \Delta c_j = \left[P\left(h_j=1|\boldsymbol{v}^{\left(0\right)}\right) - P\left(h_j=1|\boldsymbol{v}^{\left(k\right)}\right)\right]$
        \ENDFOR
    \ENDFOR
\ENDPROCEDURE
\end{algorithmic}
\end{algorithm}

其中，sample_h_given_v 和 sample_v_given_h 分别表示在已知可见层时采样隐含层和在已知隐含层时采样可见层。对于 sample_h_given_v 其算法流程如下：

\begin{algorithm}
\caption{sample\_h\_given\_v 算法}
\begin{algorithmic}
\FOR{$j = 1, 2, ..., n_h$}
    \STATE sample $r_j \sim Uniform[0, 1]$
    \IF{$r_j < P\left(h_j = 1 | \boldsymbol{v}\right)$}
        \STATE $h_j \gets 1$
    \ELSE
        \STATE $h_j \gets 0$
    \ENDIF
\ENDFOR
\end{algorithmic}
\end{algorithm}

类似的，对于 sample_v_given_h 其算法流程如下：

\begin{algorithm}
\caption{sample\_v\_given\_h 算法}
\begin{algorithmic}
\FOR{$j = 1, 2, ..., n_h$}
    \STATE sample $r_j \sim Uniform[0, 1]$
    \IF{$r_i < P\left(v_i = 1 | \boldsymbol{h}\right)$}
        \STATE $v_i \gets 1$
    \ELSE
        \STATE $v_i \gets 0$
    \ENDIF
\ENDFOR
\end{algorithmic}
\end{algorithm}

至此，我们可以得到 RBM 模型训练的整个流程：

\begin{algorithm}
\caption{RBM 训练算法}
\begin{algorithmic}
\FOR{$iter = 1, 2, ..., \text{max\_iter}$}
    \STATE $\Delta \boldsymbol{W}, \Delta \boldsymbol{b}, \Delta \boldsymbol{c} \gets \text{CDK} \left(k, \boldsymbol{S}, \text{RBM}\left(\boldsymbol{W, b, c}\right)\right)$
    \STATE $\boldsymbol{W} \gets \boldsymbol{W} + \eta \left(\dfrac{1}{n_s} \Delta \boldsymbol{W}\right)$
    \STATE $\boldsymbol{b} \gets \boldsymbol{b} + \eta \left(\dfrac{1}{n_s} \Delta \boldsymbol{b}\right)$
    \STATE $\boldsymbol{c} \gets \boldsymbol{c} + \eta \left(\dfrac{1}{n_s} \Delta \boldsymbol{c}\right)$
\ENDFOR
\end{algorithmic}
\end{algorithm}

其中，$k$ 为 CDK 算法参数，$\text{max_iter}$ 为最大迭代次数，$\boldsymbol{S}$ 为训练样本，$n_s = |\boldsymbol{S}|$，$\eta$ 为学习率。

对于模型的评估，最简单的是利用 RBM 模型的似然或对数似然，但由于涉及到归一化因子 $Z$ 的计算，其复杂度太高。更常用的方式是利用重构误差 (reconstruction error)，即输入数据和利用 RBM 模型计算得到隐含节点再重构回可见节点之间的误差。

MNIST 示例

我们利用经典的 MNIST 数据作为示例，我们利用基于 tensorflow 的扩展包 tfrbm ¹²。tfrbm 实现了 Bernoulli-Bernoulli RBM 和 Gaussian-Bernoulli RBM 两种不同的 RBM，两者的比较详见 ^{13 14}。

import numpy as np
from matplotlib import pyplot as plt, gridspec
from tfrbm import BBRBM, GBRBM
from tensorflow.examples.tutorials.mnist import input_data

# 读入训练数据和测试数据
mnist = input_data.read_data_sets('MNIST', one_hot=True)
mnist_train_images = mnist.train.images
mnist_test_images = mnist.test.images
mnist_test_labels = mnist.test.labels

MNIST 数据集中，训练集共包含 55000 个样本，每个样本的维度为 784，我们构建 Bernoulli-Bernoulli RBM，设置隐含节点个数为 64，学习率为 0.01，epoches 为 30，batch size 为 10。

bbrbm = BBRBM(n_visible=784,
              n_hidden=64,
              learning_rate=0.01,
              use_tqdm=True)

bbrbm_errs = bbrbm.fit(mnist_train_images, n_epoches=30, batch_size=10)

# Epoch: 0: 100%|##########| 5500/5500 [00:11<00:00, 480.39it/s]
# Train error: 0.1267
# 
# ......
# 
# Epoch: 29: 100%|##########| 5500/5500 [00:11<00:00, 482.15it/s]
# Train error: 0.0347

训练误差变化如下

plt.style.use('ggplot')
plt.plot(bbrbm_errs)

我们从 MNIST 的测试集中针对每个数字选取 10 个样本，共 100 个样本作为测试数据，利用训练好的 RBM 模型重构这 100 个样本

mnist_test_images_samples = np.zeros([10 * 10, 784])
mnist_test_images_samples_rec = np.zeros([10 * 10, 784])
mnist_test_images_samples_plt = np.zeros([10 * 10 * 2, 784])

digits_current_counts = np.zeros(10, dtype=np.int32)
digits_total_counts = np.ones(10, dtype=np.int32) * 10

for idx in range(mnist_test_images.shape[0]):
    image = mnist_test_images[idx, ]
    label = mnist_test_labels[idx, ]

    for digit in range(10):
        digit_label = np.zeros(10)
        digit_label[digit] = 1

        if (label == digit_label).all() and
               digits_current_counts[digit] < 10:
            nrow = digits_current_counts[digit]
            sample_idx = nrow * 10 + digit
            mnist_test_images_samples[sample_idx, ] = image
            mnist_test_images_samples_rec[sample_idx, ] = \
                bbrbm.reconstruct(image.reshape([1, -1]))
            mnist_test_images_samples_plt[sample_idx * 2, ] = \
                mnist_test_images_samples[sample_idx, ]
            mnist_test_images_samples_plt[sample_idx * 2 + 1, ] = \
                mnist_test_images_samples_rec[sample_idx, ]
            digits_current_counts[digit] += 1

    if (digits_current_counts == digits_total_counts).all():
        break

对比测试输入数据和重构结果，奇数列为输入数据，偶数列为重构数据

def plot_mnist(mnist_images, nrows, ncols, cmap='gray'):
    fig = plt.figure(figsize=(ncols, nrows))
    gs = gridspec.GridSpec(nrows, ncols)
    gs.update(wspace=0.025, hspace=0.025)

    for nrow in range(nrows):
        for ncol in range(ncols):
            ax = plt.subplot(gs[nrow, ncol])
            idx = nrow * ncols + ncol
            minist_image = mnist_images[idx, ].reshape([28, 28])
            ax.imshow(minist_image, cmap=cmap)
            ax.axis('off')

    return fig
    
plot_mnist(mnist_test_images_samples_plt, 10, 20)

测试集上的重构误差为

gbrbm.get_err(mnist_test_images_samples)

# 0.035245348