卷积神经网络（CNN）在图像领域取得了很大的成功，但同时也存在一定的缺陷。卷积层中的卷积核对输入图像利用卷积运算提取其中的特征。卷积核以一个较小的尺寸并以一定的步长在图像上移动得到特征图。步长越大，特征图的尺寸就越小，过大的步长会丢失部分图像中的特征。池化层作用于产生的特征图上，使得 CNN 可以在不同形式的图像中识别出相同的物体，为 CNN 引入了空间不变性。

CNN 最大的缺陷就是忽略了不同特征之间的相对位置，从而无法从图像中识别出姿势、纹理和变化。CNN 中的池化操作使得模型具有空间不变性，因此模型就不具备等变性。以下图为例，CNN 会把第一幅和第二幅识别为人脸，而将第三幅方向翻转的图识别为不是人脸。池化操作造成了部分信息的丢失，因此需要更多的训练数据来补偿这些损失。

等变和不变

对于一个函数 $f$ 和一个变换 $g$，如果有：

$$ f \left(g \left(x\right)\right) = g \left(f \left(x\right)\right) $$

则称 $f$ 对变换 $g$ 有等变性。

例如，变换 $g$ 为将图像向左平移若干像素，函数 $f$ 表示检测一个人脸的位置。则 $f \left(g \left(x\right)\right)$ 表示先将图片左移，我们将在原图的左侧检测到人脸；$g \left(f \left(x\right)\right)$ 表示先检测人脸位置，然后将人脸位置左移。这两者的输出结果是一样的，与我们施加变换的顺序无关。CNN 中的卷积操作使得它对平移操作具有等变性。

对于一个函数 $f$ 和一个变换 $g: g \left(x\right) = x'$，如果有：

$$ f \left(x\right) = f \left(x'\right) = f \left(g \left(x\right)\right) $$

则称 $f$ 对变换 $g$ 有不变性。

例如，变换 $g$ 为旋转或平移，函数 $f$ 表示检测图中是否有黑色，那么这些变换不会对函数结果有任何影响，可以说函数对该变换具有不变性。CNN 中的池化操作对平移操作具有近似不变性。

逆图形

计算机图形学根据几何数据的内部层次结构来构造可视图像，该表示的结构将对象的相对位置考虑在内。软件采用层次的表示方式将其渲染为屏幕上的图像。人类大脑的工作原理则与渲染过程相反，我们称其为逆图形。大脑中对象的表示并不依赖于视角。

例如下图，人眼可以很容易的分辨出是自由女神像，只是角度不同，但 CNN 却很难做到，因为它不理解 3D 空间的内在。

胶囊网络

胶囊

在引入“胶囊”这个概念的第一篇文献 Transforming Auto-encoders ¹ 中，Hinton 等人对胶囊概念理解如下：

人工神经网络不应当追求“神经元”活动中的视角不变性（使用单一的标量输出来总结一个局部池中的重复特征检测器的活动），而应当使用局部的“胶囊”，这些胶囊对其输入执行一些相当复杂的内部计算，然后将这些计算的结果封装成一个包含信息丰富的输出的小向量。每个胶囊学习辨识一个有限的观察条件和变形范围内隐式定义的视觉实体，并输出实体在有限范围内存在的概率及一组“实例参数”，实例参数可能包括相对这个视觉实体的隐式定义的典型版本的精确的位姿、照明条件和变形信息。当胶囊工作正常时，视觉实体存在的概率具有局部不变性——当实体在胶囊覆盖的有限范围内的外观流形上移动时，概率不会改变。实例参数却是“等变的”——随着观察条件的变化，实体在外观流形上移动时，实例参数也会相应地变化，因为实例参数表示实体在外观流形上的内在坐标。

人造神经元输出单个标量。对于 CNN 卷积层中的每个卷积核，对整个输入图复制同一个内核的权重输出一个二维矩阵。矩阵中每个数字是该卷积核对输入图像一部分的卷积，这个二维矩阵看作是重复特征检测器的输出。所有卷积核的二维矩阵堆叠在一起得到卷积层的输出。CNN 利用最大池化实现不变性，但最大池化丢失了有价值的信息，也没有编码特征之间的相对空间关系。

胶囊将特征检测的概率作为其输出向量的长度进行编码，检测出的特征的状态被编码为该向量指向的方向。当检测出的特征在图像中移动或其状态发生变化时，概率仍然保持不变（向量的长度没有改变），但它的方向改变了。

下表总结了胶囊和神经元的不同：

		Capsule	Traditional Neuron
Input from low-level capsule/neuron		$\text{vector}\left(\mathbf{u}_i\right)$	$\text{scalar}\left(x_i\right)$
Operration	Affine Transform	$\widehat{\mathbf{u}}_{j \mid i}=\mathbf{W}_{i j} \mathbf{u}_{i}$	-
	Weighting	$\mathbf{s}_{j}=\sum_{i} c_{i j} \widehat{\mathbf{u}}_{j \mid i}$	$a_{j}=\sum_{i} w_{i} x_{i}+b$
	Sum
	Nonlinear Activation	$\mathbf{v}_{j}=\dfrac{\left\|\mathbf{s}_{j}\right\|^{2}}{1+\left\|\mathbf{s}_{j}\right\|^{2}} \dfrac{\mathbf{s}_{j}}{\left\|\mathbf{s}_{j}\right\|}$	$h_{j}=f\left(a_{j}\right)$
Output		$\text{vector}\left(\mathbf{v}_j\right)$	$\text{scalar}\left(h_j\right)$

人造神经元包含如下 3 个计算步骤：

1. 输入标量的加权
2. 加权标量的求和
3. 求和标量到输出标量的非线性变换

胶囊可以理解为上述 3 个步骤的向量版，同时增加了对输入的仿射变换：

1. 输入向量的矩阵乘法：胶囊接受的输入向量编码了低层胶囊检测出的相应对象的概率，向量的方向编码了检测出的对象的一些内部状态。接着将这些向量乘以相应的权重矩阵 $\mathbf{W}$，$\mathbf{W}$ 编码了低层特征（例如：眼睛、嘴巴和鼻子）和高层特征（例如：面部）之间的空间关系和其他重要关系。
2. 向量的标量加权：这个步骤同人造神经元对应的步骤类似，但神经元的权重是通过反向传播学习的，而胶囊则使用动态路由。
3. 加权向量的求和：这个步骤同人造神经元对应的步骤类似。
4. 求和向量到输出向量的非线性变换：胶囊神经网络的非线性激活函数接受一个向量，然后在不改变方向的前提下，将其长度压缩到 1 以下。

动态路由

胶囊网络使用动态路由算法进行训练，算法过程如下 ²：

\begin{algorithm}
\caption{Routing 算法}
\begin{algorithmic}
\PROCEDURE{Routing}{$\widehat{\mathbf{u}}_{j | i}, r, l$}
\STATE for all capsule $i$ in layer $l$ and capsule $j$ in layer $\left(l + 1\right)$: $b_{ij} \gets 0$
\FOR{$r$ iterations}
  \STATE for all capsule $i$ in layer $l$: $\mathbf{c}_i \gets \text{softmax} \left(\mathbf{b}_i\right)$
  \STATE for all capsule $j$ in layer $\left(l + 1\right)$: $\mathbf{s}_j \gets \sum_{i} c_{ij} \widehat{\mathbf{u}}_{j | i}$
  \STATE for all capsule $j$ in layer $\left(l + 1\right)$: $\mathbf{v}_j \gets \text{squash} \left(\mathbf{s}_j\right)$
  \STATE for all capsule $i$ in layer $l$ and capsule $j$ in layer $\left(l + 1\right)$: $b_{ij} \gets b_{ij} + \widehat{\mathbf{u}}_{j | i} \cdot \mathbf{v}_j$
\ENDFOR
\RETURN $\mathbf{v}_j$
\ENDPROCEDURE
\end{algorithmic}
\end{algorithm}

1. 第 1 行表示算法的输入为：低层 $l$ 中所有胶囊的输出 $\widehat{\mathbf{u}}$，以及路由迭代计数 $r$。
2. 第 2 行中的 $b_{ij}$ 为一个临时变量，其值在迭代过程中更新，算法运行完毕后其值被保存在 $c_{ij}$ 中。
3. 第 3 行表示如下步骤将会被重复 $r$ 次。
4. 第 4 行利用 $\mathbf{b}_i$ 计算低层胶囊的权重向量 $\mathbf{c}_i$。$\text{softmax}$ 确保了所有权重为非负数，且和为一。第一次迭代后，所有系数 $c_{ij}$ 的值相等，随着算法的继续，这些均匀分布将发生改变。
5. 第 5 行计算经前一步确定的路由系数 $c_{ij}$ 加权后的输入向量的线性组合。该步缩小输入向量并将他们相加，得到输出向量 $\mathbf{s}_j$。
6. 第 6 行对前一步的输出向量应用 $\text{squash}$ 非线性函数。这确保了向量的方向被保留下来，而长度被限制在 1 以下。
7. 第 7 行通过观测低层和高层的胶囊，根据公式更新相应的权重 $b_{ij}$。胶囊 $j$ 的当前输出与从低层胶囊 $i$ 处接收到的输入进行点积，再加上旧的权重作为新的权重。点积检测胶囊输入和输出之间的相似性。
8. 重复 $r$ 次，计算出所有高层胶囊的输出，并确立路由权重。之后正向传导就可以推进到更高层的网络。

点积运算接收两个向量，并输出一个标量。对于给定长度但方向不同的两个向量而言，点积有几种情况：$a$ 最大正值；$b$ 正值；$c$ 零；$d$ 负值；$e$ 最小负值，如下图所示：

我们用紫色向量 $\mathbf{v}_1$ 和 $\mathbf{v}_2$ 表示高层胶囊，橙色向量表示低层胶囊的输入，其他黑色向量表示接收自其他低层胶囊的输入，如下图所示：

左侧的紫色输出 $\mathbf{v}_1$ 和橙色输入 $\widehat{\mathbf{u}}_{1|1}$ 指向相反的方向，这意味着他们的点积是一个负数，从而路由系数 $c_{11}$ 减少；右侧的紫色输出 $\mathbf{v}_2$ 和橙色输入 $\widehat{\mathbf{u}}_{2|1}$ 指向相同的方向，从而路由系数 $c_{12}$ 增加。在所有高层胶囊及其所有输入上重复该过程，得到一个路由系数集合，达成了来自低层胶囊的输出与高层胶囊的输出的最佳匹配。

网络架构

胶囊网络由 6 层神经网络构成，前 3 层是编码器，后 3 层是解码器：

1. 卷积层
2. PrimaryCaps（主胶囊）层
3. DigitCaps（数字胶囊）层
4. 第一全连接层
5. 第二全连接层
6. 第三全连接层

编码器

编码器部分如下图所示：

卷积层用于检测 2D 图像的基本特征。PrimaryCaps 层包含 32 个主胶囊，接收卷积层检测到的基本特征，生成特征的组合。DigitCaps 层包含 10 个数字胶囊，每个胶囊对应一个数字。

对于 $k$ 个类别的数字，我们希望最高层的胶囊当且仅当一个数字出现在图像中时具有一个长的实例化向量。为了允许多个数字，对于每个 DigitCap 使用一个独立的损失函数：

$$ L_{k}=T_{k} \max \left(0, m^{+}-\left\|\mathbf{v}_{k}\right\|\right)^{2}+\lambda\left(1-T_{k}\right) \max \left(0,\left\|\mathbf{v}_{k}\right\|-m^{-}\right)^{2} $$

DigitCaps 层的输出为 10 个 16 维的向量，根据上面的公式计算每个向量的损失值，然后将 10 个损失值相加得到最终损失。

在损失函数中，当正确的标签与特定 DigitCap 的数字对应时 $T_k$ 为 1，否则为 0。加号前一项用于计算正确 DigitCap 的损失，当概率值大于 $m^{+} = 0.9$ 时为 0，当概率值小于 $m^{+} = 0.9$ 时为非零值；加号后一项用于计算错误 DigitCap 的损失，当概率值小于 $m^{-} = 0.1$ 时值为 0，当概率值大于 $m^{-} = 0.1$ 时为非零值。公式中的 $\lambda = 0.5$ 用于确保训练中数值的稳定性。

简单来说，低层的胶囊用于检测一些特定模式的出现概率和姿态，高层的胶囊用于检测更加复杂的图像，如下图所示：

解码器

解码器部分如下图所示：

解码器从正确的 DigitCap 中接收一个 16 维向量，并学习将其解码为数字图像。解码器接收正确的 DigitCap 的输出作为输入，并学习重建一张 $28 \times 28$ 像素的图像，损失函数为重建图像与输入图像之间的欧式距离。

隐马尔可夫模型（Hidden Markov Model，HMM）是一个描述包含隐含未知参数的马尔可夫过程的统计模型。马尔可夫过程（Markov Process）是因俄国数学家安德雷·安德耶维齐·马尔可夫（Андрей Андреевич Марков）而得名一个随机过程，在该随机过程中，给定当前状态和过去所有状态的条件下，其下一个状态的条件概率分布仅依赖于当前状态，通常具备离散状态的马尔可夫过程称之为马尔可夫链（Markov Chain）。因此，马尔可夫链可以理解为一个有限状态机，给定了当前状态为 $S_i$ 时，下一时刻状态为 $S_j$ 的概率，不同状态之间变换的概率称之为转移概率。下图描述了 3 个状态 $S_a, S_b, S_c$ 之间转换状态的马尔可夫链。

隐马尔可夫模型中包含两种序列：随机生成的状态构成的序列称之为状态序列（state sequence），状态序列是不可被观测到的；每个状态对应的观测值组成的序列称之为观测序列（observation sequence）。令 $I = \left(i_1, i_2, \cdots, i_T\right)$ 为状态序列，其中 $i_t$ 为第 $t$ 时刻系统的状态值，对应的有 $O = \left(o_1, o_2, \cdots, o_T\right)$ 为观测序列，其中 $o_t$ 为第 $t$ 时刻系统的观测值，系统的所有可能的状态集合为 $Q = \{q_1, q_2, \cdots, q_N\}$，所有可能的观测集合为 $V= \{v_1, v_2, \cdots, v_M\}$。

隐马尔可夫模型主要由三组参数构成：

1. 状态转移矩阵： $$ A = \left[a_{ij}\right]_{N \times N} $$ 其中， $$ a_{ij} = P \left(i_{t+1} = q_j | i_t = q_i\right), 1 \leq i, j \leq N $$ 表示 $t$ 时刻状态为 $q_i$ 的情况下，在 $t+1$ 时刻状态转移到 $q_j$ 的概率。
2. 观测概率矩阵： $$ B = \left[b_j \left(k\right)\right]_{N \times M} $$ 其中， $$ b_j \left(k\right) = P \left(o_t = v_k | i_t = q_j\right), k = 1, 2, \cdots, M, j = 1, 2, \cdots, N $$ 表示 $t$ 时刻状态为 $q_i$ 的情况下，观测值为 $v_k$ 的概率。
3. 初始状态概率向量： $$ \pi = \left(\pi_i\right) $$ 其中， $$ \pi_i = P \left(i_1 = q_i\right), i = 1, 2, \cdots, N $$ 表示 $t = 1$ 时刻，系统处于状态 $q_i$ 的概率。

初始状态概率向量 $\pi$ 和状态转移矩阵 $A$ 决定了状态序列，观测概率矩阵 $B$ 决定了状态序列对应的观测序列，因此马尔可夫模型可以表示为：

$$ \lambda = \left(A, B, \pi\right) $$

对于马尔可夫模型 $\lambda = \left(A, B, \pi\right)$，通过如下步骤生成观测序列 $\{o_1, o_2, \cdots, o_T\}$：

1. 按照初始状态分布 $\pi$ 产生状态 $i_1$.
2. 令 $t = 1$。
3. 按照状态 $i_t$ 的观测概率分布 $b_{i_t} \left(k\right)$ 生成 $o_t$。
4. 按照状态 $i_t$ 的状态转移概率分布 $\left\{a_{i_t i_{t+1}}\right\}$ 产生状态 $i_{t+1}$，$i_{t+1} = 1, 2, \cdots, N$。
5. 令 $t = t + 1$，如果 $t < T$，转步骤 3；否则，终止。

马尔可夫模型在应用过程中有 3 个基本问题 ¹：

1. 概率计算问题。给定模型 $\lambda = \left(A, B, \pi\right)$ 和观测序列 $O = \{o_1, o_2, \cdots, o_T\}$，计算在模型 $\lambda$ 下观测序列 $O$ 出现的概率 $P\left(O | \lambda \right)$。
2. 学习问题。已知观测序列 $O = \{o_1, o_2, \cdots, o_T\}$，估计模型 $\lambda = \left(A, B, \pi\right)$ 参数，使得在该模型下观测序列概率 $P\left(X | \lambda \right)$ 最大。即用极大似然估计的方法估计参数。
3. 预测问题，也称为解码（decoding）问题。已知模型 $\lambda = \left(A, B, \pi\right)$ 和观测序列 $O = \{o_1, o_2, \cdots, o_T\}$，求对给定观测序列条件概率 $P \left(I | O\right)$ 最大的状态序列 $I = \{i_1, i_2, \cdots, i_T\}$。即给定观测序列，求最有可能的对应的状态序列。

概率计算

直接计算法

给定模型 $\lambda = \left(A, B, \pi \right)$ 和观测序列 $O = \{o_1, o_2, ..., o_T\}$，计算在模型 $\lambda$ 下观测序列 $O$ 出现的概率 $P\left(O | \lambda \right)$。最简单的办法就是列举出左右可能的状态序列 $I = \{i_1, i_2, ..., i_T\}$，再根据观测概率矩阵 $B$，计算每种状态序列对应的联合概率 $P \left(O, I | \lambda\right)$，对其进行求和得到概率 $P\left(O | \lambda \right)$。

状态序列 $I = \{i_1, i_2, ..., i_T\}$ 的概率是：

$$ P \left(I | \lambda \right) = \pi_{y_1} \prod_{t = 1}^{T - 1} a_{{i_t}{i_{t+1}}} $$

对于固定的状态序列 $I = \{i_1, i_2, ..., i_T\}$，观测序列 $O = \{o_1, o_2, ..., o_T\}$ 的概率是：

$$ P \left(O | I, \lambda \right) = \prod_{t = 1}^{T} b_{i_t} \left(o_t\right) $$

$O$ 和 $I$ 同时出现的联合概率为：

$$ \begin{split} P \left(O, I | \lambda \right) &= P \left(O | I, \lambda \right) P \left(I | \lambda \right) \\ &= \pi_{y_1} \prod_{t = 1}^{T - 1} a_{{i_t}{i_{t+1}}} \prod_{t = 1}^{T} b_{i_t} \left(o_t\right) \end{split} $$

然后，对于所有可能的状态序列 $I$ 求和，得到观测序列 $O$ 的概率 $P \left(O | \lambda\right)$，即：

$$ \begin{split} P\left(O | \lambda \right) &= \sum_{I} P \left(O | I, \lambda \right) P \left(I | \lambda \right) \\ &= \sum_{i_1, i_2, \cdots, i_T} \pi_{y_1} \prod_{t = 1}^{T - 1} a_{{i_t}{i_{t+1}}} \prod_{t = 1}^{T} b_{i_t} \left(o_t\right) \end{split} $$

但利用上式的计算量很大，是 $O \left(T N^T\right)$ 阶的，这种算法不可行。

前向算法

前向概率：给定马尔可夫模型 $\lambda$，给定到时刻 $t$ 部分观测序列为 $o_1, o_2, \cdots, o_t$ 且状态为 $q_i$ 的概率为前向概率，记作：

$$ \alpha_t \left(i\right) = P \left(o_1, o_2, \cdots, o_t, i_t = q_i | \lambda\right) $$

可以递推地求得前向概率 $\alpha_t \left(i\right)$ 及观测序列概率 $P \left(O | \lambda\right)$，前向算法如下：

1. 初值 $$ \alpha_{1}(i)=\pi_{i} b_{i}\left(o_{1}\right), \quad i=1,2, \cdots, N $$
2. 递推，对 $t = 1, 2, \cdots, T-1$ $$ \alpha_{t+1}(i)=\left[\sum_{j=1}^{N} \alpha_{t}(j) a_{j i}\right] b_{i}\left(o_{t+1}\right), \quad i=1,2, \cdots, N $$
3. 终止 $$ P(O | \lambda)=\sum_{i=1}^{N} \alpha_{T}(i) $$

后向算法

后向概率：给定隐马尔可夫模型 $\lambda$，给定在时刻 $t$ 状态为 $q_i$ 的条件下，从 $t+1$ 到 $T$ 的部分观测序列为 $o_{t+1}, o_{t+2}, \cdots, o_T$ 的概率为后向概率，记作：

$$ \beta_{t}(i)=P\left(o_{t+1}, o_{t+2}, \cdots, o_{T} | i_{t}=q_{i}, \lambda\right) $$

可以递推地求得后向概率 $\alpha_t \left(i\right)$ 及观测序列概率 $P \left(O | \lambda\right)$，后向算法如下：

1. 初值 $$ \beta_{T}(i)=1, \quad i=1,2, \cdots, N $$
2. 递推，对 $t = T-1, T-2, \cdots, 1$ $$ \beta_{t}(i)=\sum_{j=1}^{N} a_{i j} b_{j}\left(o_{t+1}\right) \beta_{t+1}(j), \quad i=1,2, \cdots, N $$
3. 终止 $$ P(O | \lambda)=\sum_{i=1}^{N} \pi_{i} b_{i}\left(o_{1}\right) \beta_{1}(i) $$

学习算法

监督学习算法

假设以给训练数据包含 $S$ 个长度相同的观测序列和对应的状态序列 $\left\{\left(O_1, I_1\right), \left(O_2, I_2\right), \cdots, \left(O_S, I_S\right)\right\}$，那么可以利用极大似然估计法来估计隐马尔可夫模型的参数。

设样本中时刻 $t$ 处于状态 $i$ 时刻 $t+1$ 转移到状态 $j$ 的频数为 $A_{ij}$，那么转移概率 $a_{ij}$ 的估计是：

$$ \hat{a}_{i j}=\frac{A_{i j}}{\sum_{j=1}^{N} A_{i j}}, \quad i=1,2, \cdots, N ; \quad j=1,2, \cdots, N $$

设样本中状态为 $j$ 并观测为 $k$ 的频数是 $B_{jk}$，那么状态为 $j$ 观测为 $k$ 的概率 $b_j \left(k\right)$ 的估计是：

$$ \hat{b}_{j}(k)=\frac{B_{j k}}{\sum_{k=1}^{M} B_{j k}}, \quad j=1,2, \cdots, N ; \quad k=1,2, \cdots, M $$

初始状态概率 $\pi_i$ 的估计 $\hat{\pi}_i$ 为 $S$ 个样本中初始状态为 $q_i$ 的频率。

无监督学习算法

假设给定训练数据值包含 $S$ 个长度为 $T$ 的观测序列 $\left\{O_1, O_2, \cdots, O_S\right\}$ 而没有对应的状态序例，目标是学习隐马尔可夫模型 $\lambda = \left(A, B, \pi\right)$ 的参数。我们将观测序列数据看做观测数据 $O$，状态序列数据看作不可观测的隐数据 $I$，那么马尔可夫模型事实上是一个含有隐变量的概率模型：

$$ P(O | \lambda)=\sum_{I} P(O | I, \lambda) P(I | \lambda) $$

它的参数学习可以由 EM 算法实现。EM 算法在隐马尔可夫模型学习中的具体实现为 Baum-Welch 算法：

1. 初始化。对 $n = 0$，选取 $a_{i j}^{(0)}, b_{j}(k)^{(0)}, \pi_{i}^{(0)}$，得到模型 $\lambda^{(0)}=\left(A^{(0)}, B^{(0)}, \pi^{(0)}\right)$。
2. 递推。对 $n = 1, 2, \cdots$： $$ \begin{aligned} a_{i j}^{(n+1)} &= \frac{\sum_{t=1}^{T-1} \xi_{t}(i, j)}{\sum_{t=1}^{T-1} \gamma_{t}(i)} \\ b_{j}(k)^{(n+1)} &= \frac{\sum_{t=1, o_{t}=v_{k}}^{T} \gamma_{t}(j)}{\sum_{t=1}^{T} \gamma_{t}(j)} \\ \pi_{i}^{(n+1)} &= \gamma_{1}(i) \end{aligned} $$ 右端各按照观测 $O=\left(o_{1}, o_{2}, \cdots, o_{T}\right)$ 和模型 $\lambda^{(n)}=\left(A^{(n)}, B^{(n)}, \pi^{(n)}\right)$ 计算， $$ \begin{aligned} \gamma_{t}(i) &= \frac{\alpha_{t}(i) \beta_{t}(i)}{P(O | \lambda)}=\frac{\alpha_{t}(i) \beta_{t}(i)}{\sum_{j=1}^{N} \alpha_{t}(j) \beta_{t}(j)} \\ \xi_{t}(i, j) &= \frac{\alpha_{t}(i) a_{i j} b_{j}\left(o_{t+1}\right) \beta_{t+1}(j)}{\sum_{i=1}^{N} \sum_{j=1}^{N} \alpha_{t}(i) a_{i j} b_{j}\left(o_{t+1}\right) \beta_{t+1}(j)} \end{aligned} $$
3. 终止。得到模型参数 $\lambda^{(n+1)}=\left(A^{(n+1)}, B^{(n+1)}, \pi^{(n+1)}\right)$。

预测算法

近似算法

近似算法的思想是，在每个时刻 $t$ 选择在该时刻最有可能出现的状态 $i_t^*$，从而得到一个状态序列 $I^{*}=\left(i_{1}^{*}, i_{2}^{*}, \cdots, i_{T}^{*}\right)$，将它作为预测的结果。给定隐马尔可夫模型 $\lambda$ 和观测序列 $O$，在时刻 $t$ 处于状态 $q_i$ 的概率 $\gamma_t \left(i\right)$ 是：

$$ \gamma_{t}(i)=\frac{\alpha_{t}(i) \beta_{t}(i)}{P(O | \lambda)}=\frac{\alpha_{t}(i) \beta_{t}(i)}{\sum_{j=1}^{N} \alpha_{t}(j) \beta_{t}(j)} $$

在每一时刻 $t$ 最有可能的状态 $i_t^*$ 是：

$$ i_{t}^{*}=\arg \max _{1 \leqslant i \leqslant N}\left[\gamma_{t}(i)\right], \quad t=1,2, \cdots, T $$

从而得到状态序列 $I^{*}=\left(i_{1}^{*}, i_{2}^{*}, \cdots, i_{T}^{*}\right)$。

近似算法的优点是计算简单，其缺点是不能保证预测的状态序列整体是最有可能的状态序列，因为预测的状态序列可能有实际不发生的部分。事实上，上述方法得到的状态序列中有可能存在转移概率为0的相邻状态，即对某些 $i, j, a_{ij} = 0$ 。尽管如此，近似算法仍然是有用的。

维特比算法

维特比算法（Viterbi Algorithm）实际是用动态规划（Dynamic Programming）解隐马尔可夫模型预测问题，即用动态规划求概率最大路径（最优路径）。这时一条路径对应着一个状态序列。

首先导入两个变量 $\sigma$ 和 $\Psi$。定义在时刻 $t$ 状态为 $i$ 的所有单个路径 $\left(i_1, i_2, \cdots, i_t\right)$ 中概率最大值为：

$$ \delta_{t}(i)=\max _{i_{1}, i_{2}, \cdots, i_{t-1}} P\left(i_{t}=i, i_{t-1}, \cdots, i_{1}, o_{t}, \cdots, o_{1} | \lambda\right), \quad i=1,2, \cdots, N $$

由定义可得变量 $\sigma$ 的递推公式：

$$ \begin{aligned} \delta_{t+1}(i) &=\max _{i_{1}, i_{2}, \cdots, i_{t}} P\left(i_{t+1}=i, i_{t}, \cdots, i_{1}, o_{t+1}, \cdots, o_{1} | \lambda\right) \\ &=\max _{1 \leqslant j \leqslant N}\left[\delta_{t}(j) a_{j i}\right] b_{i}\left(o_{t+1}\right), \quad i=1,2, \cdots, N ; \quad t=1,2, \cdots, T-1 \end{aligned} $$

定义在时刻 $t$ 状态为 $i$ 的所有单个路径 $\left(i_1, i_2, \cdots, i_{t-1}, i\right)$ 中概率最大的路径的第 $t - 1$ 个结点为：

$$ \Psi_{t}(i)=\arg \max _{1 \leqslant j \leqslant N}\left[\delta_{t-1}(j) a_{j i}\right], \quad i=1,2, \cdots, N $$

维特比算法流程如下：

1. 初始化 $$ \begin{array}{c} \delta_{1}(i)=\pi_{i} b_{i}\left(o_{1}\right), \quad i=1,2, \cdots, N \\ \Psi_{1}(i)=0, \quad i=1,2, \cdots, N \end{array} $$
2. 递推。对 $t = 2, 3, \cdots, T$ $$ \begin{array}{c} \delta_{t}(i)=\max _{1 \leqslant j \leqslant N}\left[\delta_{t-1}(j) a_{j i}\right] b_{i}\left(o_{t}\right), \quad i=1,2, \cdots, N \\ \Psi_{t}(i)=\arg \max _{1 \leqslant j \leqslant N}\left[\delta_{t-1}(j) a_{j i}\right], \quad i=1,2, \cdots, N \end{array} $$
3. 终止。 $$ \begin{array}{c} P^{*}=\max _{1 \leqslant i \leqslant N} \delta_{T}(i) \\ i_{T}^{*}=\arg \max _{1 \leqslant i \leqslant N}\left[\delta_{T}(i)\right] \end{array} $$
4. 最优路径回溯。对 $t = T - 1, T - 2, \cdots, 1$ $$ i_{t}^{*}=\Psi_{t+1}\left(i_{t+1}^{*}\right) $$

求的最优路径 $I^{*}=\left(i_{1}^{*}, i_{2}^{*}, \cdots, i_{T}^{*}\right)$。

条件随机场

概率无向图模型（Probabilistic Undirected Graphical Model）又称为马尔可夫随机场（Markov Random Field），是一个可以由无向图表示的联合概率分布。概率图模型（Probabilistic Graphical Model）是由图表示的概率分布，设有联合概率分布 $P \left(Y\right), Y \in \mathcal{Y}$ 是一组随机变量。由无向图 $G = \left(V, E\right)$ 表示概率分布 $P \left(Y\right)$，即在图 $G$ 中，结点 $v \in V$ 表示一个随机变量 $Y_v, Y = \left(Y_v\right)_{v \in V}$，边 $e \in E$ 表示随机变量之间的概率依赖关系。

成对马尔可夫性：设 $u$ 和 $v$ 是无向图 $G$ 中任意两个没有边连接的结点，结点 $u$ 和 $v$ 分别对应随机变量 $Y_u$ 和 $Y_v$。其他所有结点为 $O$，对应的随机变量组是 $Y_O$。成对马尔可夫是指给定随机变量组 $Y_O$ 的条件下随机变量 $Y_u$ 和 $Y_v$ 是条件独立的，即：

$$ P\left(Y_{u}, Y_{v} | Y_{O}\right)=P\left(Y_{u} | Y_{O}\right) P\left(Y_{v} | Y_{O}\right) $$

局部马尔可夫性：设 $v \in V$ 是无向图 $G$ 中任意一个结点，$W$ 是与 $v$ 有边连接的所有结点，$O$ 是 $v$ 和 $W$ 以外的其他所有结点。$v$ 表示的随机变量是 $Y_v$，$W$ 表示的随机变量组是 $Y_W$，$O$ 表示的随机变量组是 $Y_O$。局部马尔可夫性是指在给定随机变量组 $Y_W$ 的条件下随机变量 $Y_v$ 与随机变量组 $Y_O$ 是独立的，即：

$$ P\left(Y_{v}, Y_{O} | Y_{W}\right)=P\left(Y_{v} | Y_{W}\right) P\left(Y_{O} | Y_{W}\right) $$

在 $P \left(Y_O | Y_W\right) > 0$ 时，等价地：

$$ P\left(Y_{v} | Y_{W}\right)=P\left(Y_{v} | Y_{W}, Y_{O}\right) $$

局部马尔可夫性如下图所示：

全局马尔可夫性：设结点结合 $A, B$ 是在无向图 $G$ 中被结点集合 $C$ 分开的任意结点集合，如下图所示。结点集合 $A, B$ 和 $C$ 所对应的随机变量组分别是 $Y_A, Y_B$ 和 $Y_C$。全局马尔可夫性是指给定随机变量组 $Y_C$ 条件下随机变量组 $Y_A$ 和 $Y_B$ 是条件独立的，即：

$$ P\left(Y_{A}, Y_{B} | Y_{C}\right)=P\left(Y_{A} | Y_{C}\right) P\left(Y_{B} | Y_{C}\right) $$

概率无向图模型定义为：设有联合概率分布 $P \left(Y\right)$，由无向图 $G = \left(V, E\right)$ 表示，在图 $G$ 中，结点表示随机变量，边表示随机变量之间的依赖关系。如果联合概率分布 $P \left(Y\right)$ 满足成对、局部或全局马尔可夫性，就称此联合概率分布为概率无向图模型（Probabilistic Undirected Graphical Model），或马尔可夫随机场（Markov Random Field）。

团与最大团：无向图 $G$ 中任何两个结点均有边连接的结点子集称为团（Clique）。若 $C$ 是无向图 $G$ 的一个团，并且不能再加进任何一个 $G$ 的结点时期成为一个更大的团，则称此 $C$ 为最大团（Maximal Clique）。

上图表示 4 个结点组成的无向图。图中有 2 个结点组成的团有 5 个：$\left\{Y_1, Y_2\right\}$，$\left\{Y_2, Y_3\right\}$，$\left\{Y_3, Y_4\right\}$，$\left\{Y_4, Y_2\right\}$ 和 $\left\{Y_1, Y_3\right\}$。有 2 个最大团：$\left\{Y_1, Y_2, Y_3\right\}$ 和 $\left\{Y_2, Y_3, Y_4\right\}$。而 $\left\{Y_1, Y_2, Y_3, Y_4\right\}$ 不是一个团，因为 $Y_1$ 和 $Y_4$ 没有边连接。

将概率无向图模型的联合概率分布表示为其最大团上的随机变量的函数的乘积形式的操作，称为概率无向图模型的因子分解。给定无向图模型，设其无向图为 $G$，$C$ 为 $G$ 上的最大团，$Y_C$ 表示 $C$ 对应的随机变量。那么概率无向图模型的联合概率分布 $P \left(Y\right)$ 可以写作图中所有最大团 $C$ 上的函数 $\Psi_C \left(Y_C\right)$ 的乘积形式，即：

$$ P(Y)=\frac{1}{Z} \prod_{C} \Psi_{C}\left(Y_{C}\right) $$

其中，$Z$ 是规范化因子：

$$ Z=\sum_{Y} \prod_{C} \Psi_{C}\left(Y_{C}\right) $$

规范化因子保证 $P \left(Y\right)$ 构成一个概率分布。函数 $\Psi_C \left(Y_C\right)$ 称为势函数，这里要求势函数 $\Psi_C \left(Y_C\right)$ 是严格正的，通常定义为指数函数：

$$ \Psi_{C}\left(Y_{C}\right)=\exp \left\{-E\left(Y_{C}\right)\right\} $$

概率无向图模型的因子分解由这个 Hammersley-Clifford 定理来保证。

条件随机场（Conditional Random Field）是给定随机变量 $X$ 条件下，随机变量 $Y$ 的马尔可夫随机场。设 $X$ 与 $Y$ 是随机变量，$P \left(Y | X\right)$ 是给定 $X$ 的条件下 $Y$ 的条件概率分布。若随机变量 $Y$ 构成一个有无向图 $G = \left(V, E\right)$ 表示的马尔可夫随机场，即：

$$ P\left(Y_{v} | X, Y_{w}, w \neq v\right)=P\left(Y_{v} | X, Y_{w}, w \sim v\right) $$

对任意结点 $v$ 成立，则称条件概率分布 $P \left(Y | X\right)$ 为条件随机场。其中，$w \sim v$ 表示在图 $G = \left(V, E\right)$ 中与结点 $v$ 有边连接的所有结点 $w$，$w \neq v$ 表示结点 $v$ 以外的所有结点，$Y_v, Y_u$ 与 $Y_w$ 为结点 $v, u$ 和 $w$ 对应的随机变量。

定义中并没有要求 $X$ 和 $Y$ 具有相同的结构，一般假设 $X$ 和 $Y$ 有相同的图结构，下图展示了无向图的线性链情况，即：

$$ G=(V=\{1,2, \cdots, n\}, E=\{(i, i+1)\}), \quad i=1,2, \cdots, n-1 $$

此情况下，$X=\left(X_{1}, X_{2}, \cdots, X_{n}\right), Y=\left(Y_{1}, Y_{2}, \cdots, Y_{n}\right)$，最大团是相邻两个结点的集合。

线性链条件随机场：设 $X=\left(X_{1}, X_{2}, \cdots, X_{n}\right), Y=\left(Y_{1}, Y_{2}, \cdots, Y_{n}\right)$ 均为线性链表示的随机变量序列，若在给定随机变量序列 $X$ 的条件下，随机变量序列 $Y$ 的条件概率分布 $P \left(Y | X\right)$ 构成条件随机场，即满足马尔可夫性：

$$ \begin{array}{c} P\left(Y_{i} | X, Y_{1}, \cdots, Y_{i-1}, Y_{i+1}, \cdots, Y_{n}\right)=P\left(Y_{i} | X, Y_{i-1}, Y_{i+1}\right) \\ i=1,2, \cdots, n \quad (\text { 在 } i=1 \text { 和 } n \text { 时只考虑单边 }) \end{array} $$

则称 $P \left(Y | X\right)$ 为线性链条件随机场。在标注问题中，$X$ 表示输入观测序列，$Y$ 表示对应的输出标记序列或状态序列。

根据 Hammersley-Clifford 定理，设 $P \left(Y | X\right)$ 为线性链条件随机场，则在随机变量 $X$ 取值为 $x$ 的条件下，随机变量 $Y$ 取值为 $y$ 的条件概率有如下形式：

$$ P(y | x)=\frac{1}{Z(x)} \exp \left(\sum_{i, k} \lambda_{k} t_{k}\left(y_{i-1}, y_{i}, x, i\right)+\sum_{i, l} \mu_{l} s_{l}\left(y_{i}, x, i\right)\right) $$

其中，

$$ Z(x)=\sum_{y} \exp \left(\sum_{i, k} \lambda_{k} t_{k}\left(y_{i-1}, y_{i}, x, i\right)+\sum_{i, l} \mu_{l} s_{l}\left(y_{i}, x, i\right)\right) $$

其中，$t_k$ 和 $s_l$ 是特征函数，$\lambda_k$ 和 $\mu_l$ 是对应的权值。$Z \left(x\right)$ 是规范化因子，求和是在所有可能的输出序列上进行的。

条件随机场的概率计算，学习算法和预测算法类似隐马尔可夫模型，在此不进行过多赘述，有兴趣的同学可以参见 ¹。

综上所述，隐马尔可夫模型和条件随机场的主要联系和区别如下：

1. HMM 是概率有向图，CRF 是概率无向图
2. HMM 是生成模型，CRF 是判别模型

如上图所示，上面部分为生成式模型，下面部分为判别式模型，生成式模型尝试构建联合分布 $P \left(Y, X\right)$，而判别模型则尝试构建条件分布 $P \left(Y | X\right)$。

序列标注

序列标注（Sequence Labeling）是自然语言处理中的一项重要任务，对于给定的文本序列需要给出对应的标注序列。常见的序列标注任务包含：组块分析（Chunking），词性标注（Part-of-Speech，POS）和命名实体识别（Named Entity Recognition，NER）。

上图为一段文本的词性标注和命名实体识别的结果。

词性标注

词性标注是指为分词结果中的每个单词标注一个正确的词性，即确定每个词是名词、动词、形容词或其他词性的过程。

一些常用中文标注规范如下：

1. 北京大学现代汉语语料库基本加工规范 ²
2. 北大语料库加工规范：切分·词性标注·注音 ³
3. 计算所汉语词性标记集 3.0（ICTPOS 3.0）⁴
4. The Part-Of-Speech Tagging Guidelines for the Penn Chinese Treebank (3.0) ⁵
5. 中文文本标注规范（微软亚洲研究院）⁶

命名实体识别

命名实体识别，又称作“专名识别”，是指识别文本中具有特定意义的实体，主要包括人名、地名、机构名、专有名词等。简单的讲，就是识别自然文本中的实体指称的边界和类别。

常用的标注标准有 IO，BIO，BIOES，BMEWO 和 BMEWO+ 等。（参考自：Coding Chunkers as Taggers: IO, BIO, BMEWO, and BMEWO+）

1. IO 标注标准是最简单的标注方式，对于命名实体类别 X 标注为 I_X，其他则标注为 O。由于没有标签界线表示，这种方式无法表示两个相邻的同类命名实体。
2. BIO 标注标准将命名实体的起始部分标记为 B_X，其余部分标记为 I_X。
3. BIOES 标注标准将命名实体的起始部分标记为 B_X，中间部分标记为 I_X，结尾部分标记为 E_X，对于单个字符成为命名实体的情况标记为 S_X。
4. BMEWO 标注标准将命名实体的起始部分标记为 B_X，中间部分标记为 M_X，结尾部分标记为 E_X，对于单个字符成为命名实体的情况标记为 W_X。
5. BMEWO+ 标注标准在 BMEWO 的基础上针对不同情况的非命名实体标签的标注进行了扩展，同时增加了一个句外（out-of-sentence）标签 W_OOS，句子起始标签 BB_O_OOS 和句子结束标签 WW_O_OOS，如 下表 所示：

不同标注标准的差别示例如下：

不同标准的标签数量如下表所示：

其中，N 为命名实体类型的数量。

BiLSTM CRF ⁷

本小节内容参考和修改自 CRF-Layer-on-the-Top-of-BiLSTM。

Huang 等人提出了一种基于 BiLSTM 和 CRF 的神经网络模型用于序例标注。整个网络如下图所示：

关于模型中的 BiLSTM 部分在此不过多赘述，相关细节可以参见之前的博客：循环神经网络 (Recurrent Neural Network, RNN) 和 预训练自然语言模型 (Pre-trained Models for NLP)。BiLSTM-CRF 模型的输入是词嵌入向量，输出是对应的预测标注标签，如下图所示：

BiLSTM 层的输出为每个标签的分数，对于 $w_0$，BiLSTM 的输出为 1.5 (B_PER)，0.9 (I_PER)，0.1 (B_ORG)，0.08 (I_ORG) 和 0.05 (O)，这些分数为 CRF 层的输入，如下图所示：

经过 CRF 层后，具有最高分数的预测序列被选择为最优预测结果。如果没有 CRF 层，我们可以直接选择 BiLSTM 层输出分数的最大值对应的序列为预测结果。例如，对于 $w_0$，最高分数为 1.5，对应的预测标签则为 B_PER，类似的 $w_1, w_2, w_3, w_4$ 对应的预测标签为 I_PER, O, B_ORG, O，如下图所示：

虽然我们在上例中得到了正确的结果，但通常情况下并非如此。对于如下的示例，预测结果为 I_ORG, I_PER, O, I_ORG, I_PER，这显然是不正确的。

CRF 层在进行预测时可以添加一些约束，这些约束可以在训练时被 CRF 层学习得到。可能的约束有：

• 句子的第一个词的标签可以是 B_X 或 O，而非 I_X。
• B_X, I_X 是有效的标签，而 B_X, I_Y 是无效的标签。
• 一个命名实体的起始标签应为 B_X 而非 I_X。

CRF 层的损失包含两部分，这两部分构成了 CRF 层的关键：

• 发射分数（Emission Score）

发射分数即为 BiLSTM 层的输出分数，例如 $w_0$ 对应的标签 B_PER 的分数为 1.5。为了方便起见，对于每类标签给定一个索引：

我们利用 $x_{i y_{j}}$ 表示发射分数，$i$ 为词的索引，$y_i$ 为标注标签的索引。例如：$x_{i=1, y_{j}=2} = x_{w_1, \text{B_ORG}} = 0.1$，表示 $w_1$ 为 B_ORG 的分数为 0.1。

• 转移分数（Transition Score）

我们利用 $t_{y_i, y_j}$ 表示转移分数，例如 $t_{\text{B_PER}, \text{I_PER}} = 0.9$ 表示由标签 B_PER 转移到 I_PER 的分数为 0.9。因此，需要一个转移分数矩阵用于存储所有标注标签之间的转移分数。为了使得转移分数矩阵更加鲁棒，需要添加两个标签 START 和 END，分别表示一个句子的开始和结束。下表为一个转移分数矩阵的示例：

转移分数矩阵作为 BiLSTM-CRF 模型的一个参数，随机初始化并通过模型的训练不断更新，最终学习得到约束条件。

CRF 层的损失函数包含两个部分：真实路径分数和所有可能路径的总分数。假设每个可能的路径有一个分数 $P_i$，共 $N$ 种可能的路径，所有路径的总分数为：

$$ P_{\text {total}}=P_{1}+P_{2}+\ldots+P_{N}=e^{S_{1}}+e^{S_{2}}+\ldots+e^{S_{N}} $$

则损失函数定义为：

$$ \text{Loss} = \dfrac{P_{\text{RealPath}}}{\sum_{i=1}^{N} P_i} $$

对于 $S_i$，共包含两部分：发射分数和转移分数。以路径 START -> B_PER -> I_PER -> O -> B_ORG -> O -> END 为例，发射分数为：

$$ \begin{aligned} \text{EmissionScore} = \ &x_{0, \text{START}} + x_{1, \text{B_PER}} + x_{2, \text{I_PER}} \\ &+ x_{3, \text{O}} + x_{4, \text{B_ORG}} + x_{5, \text{O}} + x_{6, \text{END}} \end{aligned} $$

其中 $x_{i, y_j}$ 表示第 $i$ 个词标签为 $y_j$ 的分数，为 BiLSTM 的输出，$x_{0, \text{START}}$ 和 $x_{6, \text{END}}$ 可以设置为 0。转换分数为：

$$ \begin{aligned} \text{TransitionScore} = \ &t_{\text{START}, \text{B_PER}} + t_{\text{B_PER}, \text{I_PER}} + t_{\text{I_PER}, \text{O}} \\ &+ t_{\text{O}, \text{B_ORG}} + t_{\text{B_ORG}, \text{O}} + t_{\text{O}, \text{END}} \end{aligned} $$

其中 $t_{y_i, y_j}$ 表示标注标签由 $y_i$ 转移至 $y_j$ 的分数。

对于所有路径的总分数的计算过程采用了类似 动态规划 的思想，整个过程计算比较复杂，在此不再详细展开，详细请参见参考文章。

利用训练好的 BiLSTM-CRF 模型进行预测时，首先我们可以得到序列的发射分数和转移分数，其次用维特比算法可以得到最终的预测标注序列。

Lattice LSTM ⁸

Zhang 等人针对中文提出了一种基于 Lattice LSTM 的命名实体识别方法，Lattice LSTM 的结构如下图所示：

模型的基本思想是将句子中的词汇（例如：南京，长江大桥等）信息融入到基于字符的 LSTM 模型中，从而可以显性地利用词汇信息。

模型的输入为一个字符序列 $c_1, c_2, \cdots, c_m$ 和词汇表 $\mathbb{D}$ 中所有匹配的字符子序列，其中词汇表 $\mathbb{D}$ 利用大量的原始文本通过分词构建。令 $w_{b, e}^d$ 表示有以第 $b$ 个字符起始，以第 $e$ 个字符结尾的子序列，例如：$w_{1,2}^d$ 表示“南京 ”，$w_{7,8}^d$ 表示“大桥”。

不同于一般的字符级模型，LSTM 单元的状态考虑了句子中的子序列 $w_{b,e}^d$，每个子序列 $w_{b,e}^d$ 表示为：

$$ \mathbf{x}_{b, e}^{w}=\mathbf{e}^{w}\left(w_{b, e}^{d}\right) $$

其中，$\mathbf{e}^{w}$ 为词向量查询表。一个词单元 $\mathbf{c}_{b,e}^w$ 用于表示 $\mathbf{x}_{b,e}^w$ 的循环状态：

$$ \begin{aligned} \left[\begin{array}{c} \mathbf{i}_{b, e}^{w} \\ \mathbf{f}_{b, e}^{w} \\ \widetilde{c}_{b, e}^{w} \end{array}\right] &=\left[\begin{array}{c} \sigma \\ \sigma \\ \tanh \end{array}\right]\left(\mathbf{W}^{w \top}\left[\begin{array}{c} \mathbf{x}_{b, e}^{w} \\ \mathbf{h}_{b}^{c} \end{array}\right]+\mathbf{b}^{w}\right) \\ \mathbf{c}_{b, e}^{w} &=\mathbf{f}_{b, e}^{w} \odot \mathbf{c}_{b}^{c}+\mathbf{i}_{b, e}^{w} \odot \widetilde{c}_{b, e}^{w} \end{aligned} $$

其中，$\mathbf{i}_{b, e}^{w}$ 和 $\mathbf{f}_{b, e}^{w}$ 分别为输入门和遗忘门。由于仅在字符级别上进行标注，因此对于词单元来说没有输出门。

对于 $\mathbf{c}_{j}^c$ 来说可能有多条信息流，例如 $\mathbf{c}_7^c$ 的输入包括 $\mathbf{x}_7^c$（桥），$\mathbf{c}_{6,7}^w$（大桥）和 $\mathbf{c}_{4,7}^w$（长江大桥）。论文采用了一个新的门 $\mathbf{i}_{b,e}^c$ 来控制所有子序列单元 $\mathbf{c}_{b,e}^w$ 对 $\mathbf{c}_{j}^c$ 的贡献：

$$ \mathbf{i}_{b, e}^{c}=\sigma\left(\mathbf{W}^{l \top}\left[\begin{array}{c} \mathbf{x}_{e}^{c} \\ \mathbf{c}_{b, e}^{w} \end{array}\right]+\mathbf{b}^{l}\right) $$

则单元状态 $\mathbf{c}_j^c$ 的计算变为：

$$ \mathbf{c}_{j}^{c}=\sum_{b \in\left\{b^{\prime} | w_{b^{\prime}, j} \in \mathbb{D}\right\}} \boldsymbol{\alpha}_{b, j}^{c} \odot \boldsymbol{c}_{b, j}^{w}+\boldsymbol{\alpha}_{j}^{c} \odot \widetilde{\boldsymbol{c}}_{j}^{c} $$

在上式中，$\mathbf{i}_{b,j}^c$ 和 $\mathbf{i}_j^c$ 标准化为 $\boldsymbol{\alpha}_{b, j}^{c}$ 和 $\boldsymbol{\alpha}_{j}^{c}$：

$$ \begin{aligned} \boldsymbol{\alpha}_{b, j}^{c} &=\frac{\exp \left(\mathbf{i}_{b, j}^{c}\right)}{\exp \left(\mathbf{i}_{j}^{c}\right)+\sum_{b^{\prime} \in\left\{b^{\prime \prime} | w_{b^{\prime \prime}, j}^{d} \in \mathbb{D}\right\}} \exp \left(\mathbf{i}_{b^{\prime}, j}^{c}\right)} \\ \boldsymbol{\alpha}_{j}^{c} &=\frac{\exp \left(\mathbf{i}_{j}^{c}\right)}{\exp \left(\mathbf{i}_{j}^{c}\right)+\sum_{b^{\prime} \in\left\{b^{\prime \prime} | w_{b^{\prime \prime}, j}^{d} \in \mathbb{D}\right\}} \exp \left(\mathbf{i}_{b^{\prime}, j}^{c}\right)} \end{aligned} $$

开放资源

标注工具

1. synyi/poplar
2. nlplab/brat
3. doccano/doccano
4. heartexlabs/label-studio
5. deepwel/Chinese-Annotator
6. jiesutd/YEDDA

开源模型，框架和代码

1. pytorch/text
2. flairNLP/flair
3. PetrochukM/PyTorch-NLP
4. allenai/allennlp
5. fastnlp/fastNLP
6. Stanford CoreNLP
7. NeuroNER
8. spaCy
9. NLTK
10. BrikerMan/Kashgari
11. Hironsan/anago
12. crownpku/Information-Extraction-Chinese
13. thunlp/OpenNRE
14. hankcs/HanLP
15. jiesutd/NCRFpp

其他资源

1. keon/awesome-nlp
2. crownpku/Awesome-Chinese-NLP
3. sebastianruder/NLP-progress
4. thunlp/NREPapers

通常定义一个图 $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
• 中文任务基准测评

模型部署和服务调用

对于做算法的同学，大家或多或少的更关心模型的性能指标多些，对于一些工程性问题考虑的较少。模型的部署是这些工程性问题中重要的一个，它直接关系到模型在生产系统的使用。一些成熟的机器学习框架会提供自己的解决方案，例如 Tensorflow 提供的 Serving 服务等。但很多情况下我们构建的工程可能不只使用了一种框架，因此一个框架自身的部署工具可能就很难满足我们的需求了。

针对此类情况，本文介绍一个 简单 的 准生产 模型部署方案。简单是指除了模型相关代码之外的工程性代码量不大，这得益于将要使用的 Flask 框架。准生产是指这种部署方案应对一般的生产环境问题不大，对于高并发的场景可以通过横向扩容并进行负载均衡解决，但对于单次调用时效性要求较高的场景则需要另寻其他解决方案。

本文方案的模型部署和服务调用框架如下图所示：

其主要特性如下：

1. 服务端采用 Python 的 Flask 框架构建，无需使用其他外部服务。Flask 框架的 微服务 (Microframework) 特性使得服务端代码简洁高效。
2. 利用 Gunicorn 提供的高性能 Python WSGI HTTP UNIX Server，方便在服务端运行 Flask 应用。
3. 客户端和服务端之间采用 RESTful API 调用方式，尽管在性能上可能不及其他一些方案 (例如：基于 RPC 的解决方案等)，但其较好地解决了跨语言交互的问题，不同语言之间交互仅需使用 HTTP 协议和 JSON 数据格式即可。

Flask 服务和 AJAX 调用

Flask 服务封装

为了将模型代码和 Flask 服务进行整合，首先假设你已经对模型部分代码做了完美的封装 😎，整个工程先叫做 model-serving-demo 吧。整理一下代码的目录结构，给一个我中意的 Python 目录结构风格：

model-serving-demo/                # 工程根目录
├── bin/                           # 可执行命令目录
|   ├─ start.sh                    # 启动脚本
|   ├─ stop.sh                     # 停止脚本
|   └─ ...
├── conf/                          # 配置文件目录
|   ├─ logging.conf                # 日志配置文件
|   ├─ xxx_model.conf              # XXX Model 配置文件
|   └─ ...
├── data/                          # 数据文件目录
├── docs/                          # 文档目录
├── model_serving/                 # 模块根目录
|   ├─ models/                     # 模型代码目录
|   |   ├─ __init__.py
|   |   ├─ xxx_model.py            # XXX Model 代码
|   |   └─ ...
|   ├─ resources/                  # Flask RESTful Resources 代码目录
|   |   ├─ __init__.py
|   |   ├─ xxx_model_resource.py   # XXX Model Flask RESTful Resources 代码
|   |   └─ ...
|   ├─ tests/                      # 测试代码根目录
|   |   ├─ models                  # 模型测试代码目录
|   |   |   ├─ __init__.py
|   |   |   ├─ test_xxx_model.py   # XXX Model 测试代码
|   |   |   └─ ...
|   |   ├─ __init__.py
|   |   └─ ...
|   ├─ tmp/                        # 临时目录
|   └─ ...
├── .gitignore                     # Git Ignore 文件
├── app.yaml                       # Google App Engine 配置文件
├── LICENSE                        # 授权协议
├── main.py                        # 主程序代码
├── README.md                      # 说明文件
└── requirements.txt               # 依赖包列表

我们利用一个极简的示例介绍整个模型部署，相关的库依赖 requirements.txt 如下：

Flask==1.0.2
Flask-RESTful==0.3.6
Flask-Cors==3.0.6
jsonschema==2.6.0
docopt==0.6.2

# 本地部署时需保留，GAE 部署时请删除
# gunicorn==19.9.0

其中：

1. Flask 用于构建 Flask 服务。
2. Flask-RESTful 用于构建 Flask RESTful API。
3. Flask-Cors 用于解决 AJAX 调用时的 跨域问题。
4. jsonschema 用于对请求数据的 JSON 格式进行校验。
5. docopt 用于从代码文档自动生成命令行参数解析器。
6. gunicorn 用于提供的高性能 Python WSGI HTTP UNIX Server。

XXX Model 的代码 xxx_model.py 如下：

from ..utils.log_utils import XXXModel_LOGGER


LOGGER = XXXModel_LOGGER


class XXXModel():
    def __init__(self):
        LOGGER.info('Initializing XXX Model ...')

        LOGGER.info('XXX Model Initialized.')

    def hello(self, name:str) -> str:
        return 'Hello, {name}!'.format(name=name)

其中 hello() 为服务使用的方法，其接受一个类型为 str 的参数 name，并返回一个类型为 str 的结果。

XXX Model 的 Flask RESTful Resource 代码 xxx_model_resource.py 如下：

from flask_restful import Resource, request

from ..models.xxx_model import XXXModel
from ..utils.validation_utils import validate_json


xxx_model_instance = XXXModel()
xxx_model_schema = {
    'type': 'object',
    'properties': {
        'name': {'type': 'string'}
    },
    'required': ['name']
}


class XXXModelResource(Resource):
    @validate_json(xxx_model_schema)
    def post(self):
        json = request.json

        return {'result': xxx_model_instance.hello(json['name'])}

我们需要从 Flask RESTful 的 Resource 类继承一个新的类 XXXModelResource 用于处理 XXX Model 的服务请求。如上文介绍，我们在整个模型服务调用中使用 POST 请求方式和 JSON 数据格式，因此我们需要在类 XXXModelResource 中实现 post() 方法，同时对于传入数据的 JSON 格式进行校验。

post() 方法用于处理整个模型的服务请求，xxx_model_instance 模型实例在类 XXXModelResource 外部进行实例化，避免每次处理请求时都进行初始化。post() 的返回结果无需处理成 JSON 格式的字符串，仅需返回词典数据即可，Flask RESTful 会自动对其进行转换。

为了方便对请求数据的 JSON 格式进行校验，我们将对 JSON 格式的校验封装成一个修饰器。使用时如上文代码中所示，在 post() 方法上方添加 @validate_json(xxx_model_schema) 即可，其中 xxx_model_schema 为一个符合 jsonschema 要求的 JSON Schema。示例代码中要求传入的 JSON 数据 必须 包含一个名为 name 类型为 string 的字段。

validate_json 修饰器的代码 validation_utils.py 如下：

from functools import wraps
from jsonschema import validate, ValidationError
from flask_restful import request


def validate_json(schema, force=False):
    def decorator(f):
        @wraps(f)
        def wrapper(*args, **kwargs):
            json_body = request.get_json(force=force)

            if json_body is None:
                return {'message': 'No JSON object'}, 400

            try:
                validate(json_body, schema)
            except ValidationError as e:
                return {'message': e.message}, 400

            return f(*args, **kwargs)
        return wrapper
    return decorator

首先我们需要验证请求包含一个 JSON 请求体，同时 JSON 请求体的内容需满足 schema 的要求。如果不满足这些条件，我们需要返回对应的错误信息 message，同时返回合理的 HTTP 状态码 (例如：400) 用于表示无法处理错误的请求。对于正常的请求响应 (即 HTTP 状态码为 200 的情况)，状态码可以省略不写。

构建完 XXX Model 的 Flask RESTful Resource 后，我们就可以构建 Flask 的主服务了，主程序代码 main.py 如下：

"""
Model Serving Demo

Usage:
    main.py [--host <host>] [--port <port>] [--debug]
    main.py (-h | --help)
    main.py --version

Options:
    --host <host>                     绑定的 Host [default: 0.0.0.0]
    --port <port>                     绑定的 Port [default: 9999]
    --debug                           是否开启 Debug [default: False]
    -h --help                         显示帮助
    -v --version                      显示版本

"""

from docopt import docopt

from flask import Flask
from flask_cors import CORS
from flask_restful import Api

from model_serving.resources.xxx_model_resource import XXXModelResource


app = Flask(__name__)
CORS(app)

api = Api(app)
api.add_resource(XXXModelResource, '/v1/XXXModel')


if __name__ == '__main__':
    args = docopt(__doc__, version='Model Serving Demo v1.0.0')
    app.run(host=args['--host'], port=args['--port'], debug=args['--debug'])

docopt 库用于从代码文档自动生成命令行参数解析器，具体使用方法请参见 官方文档。整个 Flask 主服务的构建比较简单，流程如下：

1. 构建 Flask 主程序，app = Flask(__name__)。
2. 解决 AJAX 调用的跨域问题， CORS(app)。为了方便起见，我们不加任何参数，允许任意来源的请求，详细的使用方式请参见 官方文档。
3. 构建 Flask RESTful API，api = Api(app)。
4. 将构建好的 XXX Model 的 Flask RESTful Resource 添加到 API 中，api.add_resource(XXXModelResource, '/v1/XXXModel')。 其中第二个参数为请求的 URL，对于这个 URL 的建议将在后续小节中详细说明。

Flask 主程序配置完毕后，我们通过 app.run() 在本地启动 Flask 服务，同时可以指定绑定的主机名，端口，以及是否开启调试模式等。通过 python main.py 启动 Flask 服务后，可以在命令行看到如下类似的日志：

[2018/10/21 00:00:00] - [INFO] - [XXXModel] - Initializing XXX Model ...
[2018/10/21 00:00:00] - [INFO] - [XXXModel] - XXX Model Initialized.
 * Serving Flask app "main" (lazy loading)
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: off
[2018/10/21 00:00:00] - [INFO] - [werkzeug] -  * Running on http://0.0.0.0:9999/ (Press CTRL+C to quit)

现在就可以测试调用服务了，我们用 curl 命令进行简单的测试，相关代码 request-demo.sh 如下：

host=0.0.0.0
port=9999
url=https://zeqiang.fun/v1/XXXModel
curl_url=http://${host}:${port}${url}

invalid_json='{}'
valid_json='{"name": "Leo"}'

# No JSON object
curl --request POST --url ${curl_url} --verbose

# Invalid JSON object
curl --header 'Content-Type: application/json; charset=UTF-8' \
    --request POST --data ${invalid_json} --url ${curl_url} --verbose

# Valid JSON object
curl --header 'Content-Type: application/json; charset=UTF-8' \
    --request POST --data ${valid_json} --url ${curl_url} --verbose

三种不同的请求返回的 HTTP 状态码和结果如下：

HTTP/1.0 400 BAD REQUEST
{"message": "No JSON object"}

HTTP/1.0 400 BAD REQUEST
{"message": "'name' is a required property"}

HTTP/1.0 200 OK
{"result": "Hello, Leo!"}

上文中，我们通过 python main.py 利用内置的 Server 启动了 Flask 服务，启动后日志中打印出来一条警告信息，告诉使用者不要在生产环境中使用内置的 Server。在生产环境中我们可以利用高性能 Python WSGI HTTP UNIX Server gunicorn 来启动 Flask 服务。

服务启动 (start.sh) 脚本代码如下：

cd `dirname $0`
cd ..

base_dir=`pwd`
tmp_dir=${base_dir}/tmp
pid_file_path=${tmp_dir}/model-serving-demo.pid
log_file_path=${tmp_dir}/model-serving-demo.log

bind_host=0.0.0.0
bind_port=9999
workers=2

nohup gunicorn -b ${bind_host}:${bind_port} \
  -w ${workers} -p ${pid_file_path} \
  main:app > ${log_file_path} 2>&1 &

服务停止 (stop.sh) 脚本代码如下：

cd `dirname $0`
cd ..

base_dir=`pwd`
tmp_dir=${base_dir}/tmp
pid_file_path=${tmp_dir}/model-serving-demo.pid

kill -TERM `echo ${pid_file_path}`

gunicorn 的详细参数配置和使用教程请参见 官方文档。

RESTful API 设计

RESTful API 是一种符合 REST(Representational State Transfer，表现层状态转换) 原则的框架，该框架是由 Fielding 在其博士论文 ¹ 中提出。相关的核心概念如下：

1. 资源 (Resources)，即网络中的一个实体 (文本，图片，服务等)，使用一个 URL 进行表示。
2. 表现层 (Representation)，资源具体的呈现形式即为表现层，例如图片可以表示为 PNG 文件，音乐可以表示为 MP3 文件，还有本文使用的数据格式 JSON 等。HTTP 请求的头信息中用 Accept 和 Content-Type 字段对表现层进行描述。
3. 状态转换 (State Transfer)，互联网通信协议 HTTP 协议是一个无状态协议，所有的状态都保存在服务端。因此如果客户端想要操作服务器，必须通过某种手段让服务器端发生 状态转换。客户端利用 HTTP 协议中的动作对服务器进行操作，例如：GET，POST，PUT，DELETE 等。

利用 RESTful API 构建模型服务时，需要注意如下几点：

1. 为模型服务设置专用域名，例如：https://api.example.com，并配以负载均衡。
2. 将 API 的版本号写入 URL 中，例如：https://api.example.com/v1。
3. RESTful 框架中每个 URL 表示一种资源，因此可以将模型的名称作为 URL 的终点 (Endpoint)，例如：https://api.example.com/v1/XXXModel。
4. 对于操作资源的 HTTP 方式有多种，综合考虑建议选用 POST 方式，同时建议使用 JSON 数据格式。
5. 为请求响应设置合理的状态码，例如：200 OK 表示正常返回，400 INVALID REQUEST 表示无法处理客户端的错误请求等。
6. 对于错误码为 4xx 的情况，建议在返回中添加键名为 message 的错误信息。

AJAX 调用

对于动态网页，我们可以很容易的在后端服务中发起 POST 请求调用模型服务，然后将结果在前端进行渲染。对于静态网页，我们可以利用 AJAX 进行相关操作。首先我们需要一个交互界面，如下为利用 Google Material Design 风格的 Material Design Components Web 组件设计一个交互界面，实现细节请参见 示例代码。

AJAX 服务请求代码的核心部分如下：

$(document).ready(function() {
    $("#submit").click(function() {
        $.ajax({
            url: "http://0.0.0.0:9999/v1/XXXModel",
            method: "POST",
            contentType: "application/json; charset=UTF-8",
            data: JSON.stringify({"name": $("#name").val()}),
            timeout: 3000,

            success: function (data, textStatus, jqXHR) {
                $("#result").html(data.result);
            },
            error: function (jqXHR, textStatus, errorThrown) {
                $("#result").html(errorThrown);
            }
        });
    });
});

代码使用了 jQuery 的相关函数。JSON.stringify({"name": $("#name").val()}) 获取 ID 为 name 的元素的值，并将其转换成符合服务端要求的 JSON 格式。通过 AJAX 向远程发出请求后，如果请求成功则将返回数据 data 中对应的结果 result 填充到 ID 为 result 的元素中，否则填入返回的错误信息。

Google App Engine 部署

上文中已经介绍了如何在本地利用 Flask 部署模型服务和相关调用方法，但如果希望在自己的网站中调用时，则利用 SaaS 来部署符合会是一个不二之选。国内外多个厂商均提供了相应的 SaaS 产品，例如 Google，Amazon，Microsoft 等。Google App Engine (GAE) 提供了一个 始终免费 方案，虽然部署阶段会受到 GFW 的影响，但调用阶段测试影响并不是很大 (不同地区和服务提供商会有差异)。综合考虑，本文选择 GAE 作为 SaaS 平台部署服务，各位看官请自备梯子。

环境准备

首先，在 Google Cloud Platform Console 中建立一个新的 Project，假设项目名为 YOUR_PROJECT_ID。

其次，根据 Google Cloud SDK 文档 在本地安装相应版本的 Google Cloud SDK。MacOS 下建议通过 brew cask install google-cloud-sdk 方式安装，安装完毕后确认在命令行中可以运行 gcloud 命令。

$ gcloud version
Google Cloud SDK 221.0.0
bq 2.0.35
core 2018.10.12
gsutil 4.34

构建 GAE 工程

模型服务仅作为后端应用，因此本节不介绍前端页面开发的相关部分，有兴趣的同学请参见 官方文档。GAE 部署 Python Web 应用采用了 WSGI 标准，我们构建的本地部署版本完全满足这个要求，因此仅需为项目在根目录添加一个 GAE 配置文件 app.yaml 即可，内容如下：

runtime: python37

handlers:
  - url: /.*
    script: main.app

skip_files:
  - .idea/
  - .vscode/
  - __pycache__/
  - .hypothesis/
  - .pytest_cache/
  - bin/
  - ^(.*/)?.*\.py[cod]$
  - ^(.*/)?.*\$py\.class$
  - ^(.*/)?.*\.log$

其中，runtime 指定了服务运行的环境，handlers 指定了不同的 URL 对应的处理程序，在此所有的 URL 均由 main.py 中的 app 进行处理，skip_files 用于过滤不需要上传的文件。更多关于 app.yaml 的设置信息，请参见 官方文档。

部署 GAE 工程

在部署 GAE 工程之前我们可以利用本地的开发环境对其进行测试，测试无误后，即可运行如下命令将其部署到 GAE 上：

gcloud app deploy --project [YOUR_PROJECT_ID]

然后根据命令行提示完成整个部署流程，部署完成的远程服务 URL 为 https://YOUR_PROJECT_ID.appspot.com，更多的测试和部署细节请参见 官方文档。

部署后的 GAE 服务使用了其自带的域名 appspot.com。如果你拥有自己的域名，可以根据官方文档 设置自己的域名 并 开启 SSL。

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}$。

文章部分内容参考了 Christopher 的博客 Understanding LSTM Networks，内容翻译和图片重绘已得到原作者同意，重绘后的图片源文件请参见 这里。

发展史

循环神经网络 (Recurrent Neural Network, RNN) 一般是指时间递归神经网络而非结构递归神经网络 (Recursive Neural Network)，其主要用于对序列数据进行建模。Salehinejad 等人 ¹ 的一篇综述文章列举了 RNN 发展过程中的一些重大改进，如下表所示：

RNN

网络结构

不同于传统的前馈神经网络接受特定的输入得到输出，RNN 由人工神经元和一个或多个反馈循环构成，如下图所示：

其中，$\boldsymbol{x}_t$ 为输入层，$\boldsymbol{h}_t$ 为带有循环的隐含层，$\boldsymbol{y}_t$ 为输出层。其中隐含层包含一个循环，为了便于理解我们将循环进行展开，展开后的网络结构如下图所示：

对于展开后的网络结构，其输入为一个时间序列 $\left\{\dotsc, \boldsymbol{x}_{t-1}, \boldsymbol{x}_t, \boldsymbol{x}_{t+1}, \dotsc\right\}$，其中 $\boldsymbol{x}_t \in \mathbb{R}^n$，$n$ 为输入层神经元个数。相应的隐含层为 $\left\{\dotsc, \boldsymbol{h}_{t-1}, \boldsymbol{h}_t, \boldsymbol{h}_{t+1}, \dotsc\right\}$，其中 $\boldsymbol{h}_t \in \mathbb{R}^m$，$m$ 为隐含层神经元个数。隐含层节点使用较小的非零数据进行初始化可以提升整体的性能和网络的稳定性 ²。隐含层定义了整个系统的状态空间 (state space)，或称之为 memory ¹：

$$ \boldsymbol{h}_t = f_H \left(\boldsymbol{o}_t\right) $$

其中

$$ \boldsymbol{o}_t = \boldsymbol{W}_{IH} \boldsymbol{x}_t + \boldsymbol{W}_{HH} \boldsymbol{h}_{t-1} + \boldsymbol{b}_h $$

$f_H \left(\cdot\right)$ 为隐含层的激活函数，$\boldsymbol{b}_h$ 为隐含层的偏置向量。对应的输出层为 $\left\{\dotsc, \boldsymbol{y}_{t-1}, \boldsymbol{y}_t, \boldsymbol{y}_{t+1}, \dotsc\right\}$，其中 $\boldsymbol{y}_t \in \mathbb{R}^p$，$p$ 为输出层神经元个数。则：

$$ \boldsymbol{y}_t = f_O \left(\boldsymbol{W}_{HO} \boldsymbol{h}_t + \boldsymbol{b}_o\right) $$

其中 $f_O \left(\cdot\right)$ 为隐含层的激活函数，$\boldsymbol{b}_o$ 为隐含层的偏置向量。

在 RNN 中常用的激活函数为双曲正切函数：

$$ \tanh \left(x\right) = \dfrac{e^{2x} - 1}{e^{2x} + 1} $$

Tanh 函数实际上是 Sigmoid 函数的缩放：

$$ \sigma \left(x\right) = \dfrac{1}{1 + e^{-x}} = \dfrac{\tanh \left(x / 2\right) + 1}{2} $$

梯度弥散和梯度爆炸

原始 RNN 存在的严重的问题就是梯度弥散 (Vanishing Gradients) 和梯度爆炸 (Exploding Gradients)。我们以时间序列中的 3 个时间点 $t = 1, 2, 3$ 为例进行说明，首先假设神经元在前向传导过程中没有激活函数，则有：

$$ \begin{equation} \begin{split} &\boldsymbol{h}_1 = \boldsymbol{W}_{IH} \boldsymbol{x}_1 + \boldsymbol{W}_{HH} \boldsymbol{h}_0 + \boldsymbol{b}_h, &\boldsymbol{y}_1 = \boldsymbol{W}_{HO} \boldsymbol{h}_1 + \boldsymbol{b}_o \\ &\boldsymbol{h}_2 = \boldsymbol{W}_{IH} \boldsymbol{x}_2 + \boldsymbol{W}_{HH} \boldsymbol{h}_1 + \boldsymbol{b}_h, &\boldsymbol{y}_2 = \boldsymbol{W}_{HO} \boldsymbol{h}_2 + \boldsymbol{b}_o \\ &\boldsymbol{h}_3 = \boldsymbol{W}_{IH} \boldsymbol{x}_3 + \boldsymbol{W}_{HH} \boldsymbol{h}_2 + \boldsymbol{b}_h, &\boldsymbol{y}_3 = \boldsymbol{W}_{HO} \boldsymbol{h}_3 + \boldsymbol{b}_o \end{split} \end{equation} $$

在对于一个序列训练的损失函数为：

$$ \mathcal{L} \left(\boldsymbol{y}, \boldsymbol{\hat{y}}\right) = \sum_{t=0}^{T}{\mathcal{L}_t \left(\boldsymbol{y_t}, \boldsymbol{\hat{y}_t}\right)} $$

其中 $\mathcal{L}_t \left(\boldsymbol{y_t}, \boldsymbol{\hat{y}_t}\right)$ 为 $t$ 时刻的损失。我们利用 $t = 3$ 时刻的损失对 $\boldsymbol{W}_{IH}, \boldsymbol{W}_{HH}, \boldsymbol{W}_{HO}$ 求偏导，有：

$$ \begin{equation} \begin{split} \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{W}_{HO}} &= \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{y}_3} \dfrac{\partial \boldsymbol{y}_3}{\partial \boldsymbol{W}_{HO}} \\ \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{W}_{IH}} &= \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{y}_3} \dfrac{\partial \boldsymbol{y}_3}{\partial \boldsymbol{h}_3} \dfrac{\partial \boldsymbol{h}_3}{\partial \boldsymbol{W}_{IH}} + \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{y}_3} \dfrac{\partial \boldsymbol{y}_3}{\partial \boldsymbol{h}_3} \dfrac{\partial \boldsymbol{h}_3}{\partial \boldsymbol{h}_2} \dfrac{\partial \boldsymbol{h}_2}{\partial \boldsymbol{W}_{IH}} + \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{y}_3} \dfrac{\partial \boldsymbol{y}_3}{\partial \boldsymbol{h}_3} \dfrac{\partial \boldsymbol{h}_3}{\partial \boldsymbol{h}_2} \dfrac{\partial \boldsymbol{h}_2}{\partial \boldsymbol{h}_1} \dfrac{\partial \boldsymbol{h}_1}{\partial \boldsymbol{W}_{IH}} \\ \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{W}_{HH}} &= \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{y}_3} \dfrac{\partial \boldsymbol{y}_3}{\partial \boldsymbol{h}_3} \dfrac{\partial \boldsymbol{h}_3}{\partial \boldsymbol{W}_{HH}} + \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{y}_3} \dfrac{\partial \boldsymbol{y}_3}{\partial \boldsymbol{h}_3} \dfrac{\partial \boldsymbol{h}_3}{\partial \boldsymbol{h}_2} \dfrac{\partial \boldsymbol{h}_2}{\partial \boldsymbol{W}_{HH}} + \dfrac{\partial \mathcal{L}_3}{\partial \boldsymbol{y}_3} \dfrac{\partial \boldsymbol{y}_3}{\partial \boldsymbol{h}_3} \dfrac{\partial \boldsymbol{h}_3}{\partial \boldsymbol{h}_2} \dfrac{\partial \boldsymbol{h}_2}{\partial \boldsymbol{h}_1} \dfrac{\partial \boldsymbol{h}_1}{\partial \boldsymbol{W}_{HH}} \end{split} \end{equation} $$

因此，不难得出对于任意时刻 $t$，$\boldsymbol{W}_{IH}, \boldsymbol{W}_{HH}$ 的偏导为：

$$ \dfrac{\partial \mathcal{L}_t}{\partial \boldsymbol{W}_{IH}} = \sum_{k=0}^{t}{\dfrac{\partial \mathcal{L}_t}{\partial \boldsymbol{y}_t} \dfrac{\partial \boldsymbol{y}_t}{\partial \boldsymbol{h}_t} \left(\prod_{j=k+1}^{t}{\dfrac{\partial \boldsymbol{h}_j}{\partial \boldsymbol{h}_{j-1}}}\right) \dfrac{\partial \boldsymbol{h}_k}{\partial \boldsymbol{W}_{IH}}} $$

$\dfrac{\partial \mathcal{L}_t}{\partial \boldsymbol{W}_{HH}}$ 同理可得。对于 $\dfrac{\partial \mathcal{L}_t}{\partial \boldsymbol{W}_{HH}}$，在存在激活函数的情况下，有：

$$ \prod_{j=k+1}^{t}{\dfrac{\partial \boldsymbol{h}_j}{\partial \boldsymbol{h}_{j-1}}} = \prod_{j=k+1}^{t}{f'_H \left(h_{j-1}\right) \boldsymbol{W}_{HH}} $$

假设激活函数为 $\tanh$，下图刻画了 $\tanh$ 函数及其导数的函数取值范围：

可得，$0 \leq \tanh' \leq 1$，同时当且仅当 $x = 0$ 时，$\tanh' \left(x\right) = 1$。因此：

1. 当 $t$ 较大时，$\prod_{j=k+1}^{t}{f'_H \left(h_{j-1}\right) \boldsymbol{W}_{HH}}$ 趋近于 0，则会产生梯度弥散问题。
2. 当 $\boldsymbol{W}_{HH}$ 较大时，$\prod_{j=k+1}^{t}{f'_H \left(h_{j-1}\right) \boldsymbol{W}_{HH}}$ 趋近于无穷，则会产生梯度爆炸问题。

长期依赖问题

RNN 隐藏节点以循环结构形成记忆，每一时刻的隐藏层的状态取决于它的过去状态，这种结构使得 RNN 可以保存、记住和处理长时期的过去复杂信号。但有的时候，我们仅需利用最近的信息来处理当前的任务。例如：考虑一个用于利用之前的文字预测后续文字的语言模型，如果我们想预测 “the clouds are in the sky” 中的最后一个词，我们不需要太远的上下信息，很显然这个词就应该是 sky。在这个情况下，待预测位置与相关的信息之间的间隔较小，RNN 可以有效的利用过去的信息。

但也有很多的情况需要更多的上下文信息，考虑需要预测的文本为 “I grew up in France … I speak fluent French”。较近的信息表明待预测的位置应该是一种语言，但想确定具体是哪种语言需要更远位置的“在法国长大”的背景信息。理论上 RNN 有能力处理这种长期依赖，但在实践中 RNN 却很难解决这个问题 ³。

LSTM

LSTM 网络结构

长短时记忆网络 (Long Short Term Memroy, LSTM) 是由 Hochreiter 和 Schmidhuber ⁴ 提出一种特殊的 RNN。LSTM 的目的就是为了解决长期依赖问题，记住长时间的信息是 LSTM 的基本功能。

所有的循环神经网络都是由重复的模块构成的一个链条。在标准的 RNN 中，这个重复的模块的结构比较简单，仅包含一个激活函数为 $\tanh$ 的隐含层，如下图所示：

LSTM 也是类似的链条状结构，但其重复的模块的内部结构不同。模块内部并不是一个隐含层，而是四个，并且以一种特殊的方式进行交互，如下图所示：

下面我们将一步一步的介绍 LSTM 单元 (cell) 的具体工作原理，在之前我们先对使用到的符号进行简单的说明，如下图所示：

其中，每条线都包含一个从输出节点到其他节点的整个向量，粉红色的圆圈表示逐元素的操作，黄色的矩形为学习到的神经网络层，线条的合并表示连接，线条的分叉表示内容的复制并转移到不同位置。

LSTM 单元状态和门控机制

LSTM 的关键为单元的状态 (cell state)，即下图中顶部水平穿过单元的直线。单元的状态像是一条传送带，其直接运行在整个链条上，同时仅包含少量的线性操作。因此，信息可以很容易得传递下去并保持不变。

LSTM 具有向单元状态添加或删除信息的能力，这种能力被由一种称之为“门” (gates) 的结构所控制。门是一种可选择性的让信息通过的组件，其由一层以 Sigmoid 为激活函数的网络层和一个逐元素相乘操作构成的，如下图所示：

Sigmoid 层的输出值介于 0 和 1 之间，代表了所允许通过的数据量。0 表示不允许任何数据通过，1 表示允许所有数据通过。一个 LSTM 单元包含 3 个门用于控制单元的状态。

LSTM 工作步骤

LSTM 的第一步是要决定从单元状态中所忘记的信息，这一步是通过一个称之为“遗忘门 (forget gate)”的 Sigmoid 网络层控制。该层以上一时刻隐含层的输出 $h_{t-1}$ 和当前这个时刻的输入 $x_t$ 作为输入，输出为一个介于 0 和 1 之间的值，1 代表全部保留，0 代表全部丢弃。回到之前的语言模型，单元状态需要包含主语的性别信息以便选择正确的代词。但当遇见一个新的主语后，则需要忘记之前主语的性别信息。

$$ f_t = \sigma \left(W_f \cdot \left[h_{t-1}, x_t\right] + b_f\right) $$

第二步我们需要决定要在单元状态中存储什么样的新信息，这包含两个部分。第一部分为一个称之为“输入门 (input gate)” 的 Sigmoid 网络层，其决定更新那些数据。第二部分为一个 Tanh 网络层，其将产生一个新的候选值向量 $\tilde{C}_t$ 并用于添加到单元状态中。之后会将两者进行整合，并对单元状态进行更新。在我们的语言模型中，我们希望将新主语的性别信息添加到单元状态中并替代需要忘记的旧主语的性别信息。

$$ \begin{equation} \begin{split} i_t &= \sigma \left(W_i \cdot \left[h_{t-1}, x_t\right] + b_i\right) \\ \tilde{C}_t &= \tanh \left(W_C \cdot \left[h_{t-1}, x_t\right] + b_C\right) \end{split} \end{equation} $$

接下来需要将旧的单元状态 $C_{t-1}$ 更新为 $C_t$。我们将旧的单元状态乘以 $f_t$ 以控制需要忘记多少之前旧的信息，再加上 $i_t \odot \tilde{C}_t$ 用于控制单元状态的更新。在我们的语言模型中，该操作真正实现了我们对与之前主语性别信息的遗忘和对新信息的增加。

$$ C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t $$

最后我们需要确定单元的输出，该输出将基于单元的状态，但为一个过滤版本。首先我们利用一个 Sigmoid 网络层来确定单元状态的输出，其次我们对单元状态进行 $\tanh$ 操作 (将其值缩放到 -1 和 1 之间) 并与之前 Sigmoid 层的输出相乘，最终得到需要输出的信息。

$$ \begin{equation} \begin{split} o_t &= \sigma \left(W_o \cdot \left[h_{t-1}, x_t\right] + b_o\right) \\ h_t &= o_t \odot \tanh \left(C_t\right) \end{split} \end{equation} $$

LSTM 变种

上文中介绍的基础的 LSTM 模型，事实上不同学者对 LSTM 的结构进行了或多或少的改变，其中一个比较有名的变种是由 Gers 和 Schmidhuber 提出的 ⁵。其添加了一种“窥视孔连接 (peephole connections)”，这使得每一个门结构都能够窥视到单元的状态。

$$ \begin{equation} \begin{split} f_t &= \sigma \left(W_f \cdot \left[\boldsymbol{C_{t-1}}, h_{t-1}, x_t\right] + b_f\right) \\ i_t &= \sigma \left(W_i \cdot \left[\boldsymbol{C_{t-1}}, h_{t-1}, x_t\right] + b_i\right) \\ o_t &= \sigma \left(W_o \cdot \left[\boldsymbol{C_t}, h_{t-1}, x_t\right] + b_o\right) \end{split} \end{equation} $$

另一个变种是使用了成对的遗忘门和输入门。不同于一般的 LSTM 中分别确定需要遗忘和新添加的信息，成对的遗忘门和输入门仅在需要添加新输入是才会忘记部分信息，同理仅在需要忘记信息时才会添加新的输入。

$$ C_t = f_t \odot C_{t-1} + \boldsymbol{\left(1 - f_t\right)} \odot \tilde{C}_t $$

另外一个比较有名的变种为 Cho 等人提出的 Gated Recurrent Unit (GRU) ⁶，单元结构如下：

GRU 将遗忘门和输入门整个成一层，称之为“更新门 (update gate)”，同时配以一个“重置门 (reset gate)”。具体的计算过程如下：

首先计算更新门 $z_t$ 和重置门 $r_t$：

$$ \begin{equation} \begin{split} z_t &= \sigma \left(W_z \cdot \left[h_{t-1}, x_t\right]\right) \\ r_t &= \sigma \left(W_r \cdot \left[h_{t-1}, x_t\right]\right) \end{split} \end{equation} $$

其次计算候选隐含层 (candidate hidden layer) $\tilde{h}_t$，与 LSTM 中计算 $\tilde{C}_t$ 类似，其中 $r_t$ 用于控制保留多少之前的信息：

$$ \tilde{h}_t = \tanh \left(W \cdot \left[r_t \odot h_{t-1}, x_t\right]\right) $$

最后计算需要从之前的隐含层 $h_{t-1}$ 遗忘多少信息，同时加入多少新的信息 $\tilde{h}_t$，$z_t$ 用于控制这个比例：

$$ h_t = \left(1 - z_t\right) \odot h_{t-1} + z_t \odot \tilde{h}_t $$

因此，对于短距离依赖的单元重置门的值较大，对于长距离依赖的单元更新门的值较大。如果 $r_t = 1$ 并且 $z_t = 0$，则 GRU 退化为一个标准的 RNN。

除此之外还有大量的 LSTM 变种，Greff 等人 ⁷ 对一些常见的变种进行了比较，Jozefowicz 等人 ⁸ 测试了大量的 RNN 结构在不同任务上的表现。

扩展与应用

循环神经网络在序列建模上有着天然的优势，其在自然语言处理，包括：语言建模，语音识别，机器翻译，对话与QA，文本生成等；计算视觉，包括：目标识别，视觉追踪，图像生成等；以及一些综合场景，包括：图像标题生成，视频字幕生成等，多个领域均有不错的表现，有代表性的论文请参见 awesome-rnn。

Google 的 Magenta 是一项利用机器学习创作艺术和音乐的研究，其中也包含了大量利用 RNN 相关模型构建的有趣项目。SketchRNN 是由 Ha 等人 ⁹ 提出了一种能够根据用户描绘的一些简单图形自动完成后续绘画的 RNN 网络。

Performance RNN 是由 Ian 等人 ¹⁰ 提出了一种基于时间和动态因素生成复合音乐的 LSTM 网络。

更多有趣的作品请参见 Megenta 的 Demos 页面。

卷积神经网络 (Convolutional Neural Network, CNN) 是一种目前广泛用于图像，自然语言处理等领域的深度神经网络模型。1998 年，Lecun 等人 ¹ 提出了一种基于梯度的反向传播算法用于文档的识别。在这个神经网络中，卷积层 (Convolutional Layer) 扮演着至关重要的角色。

随着运算能力的不断增强，一些大型的 CNN 网络开始在图像领域中展现出巨大的优势，2012 年，Krizhevsky 等人 ² 提出了 AlexNet 网络结构，并在 ImageNet 图像分类竞赛 ³ 中以超过之前 11% 的优势取得了冠军。随后不同的学者提出了一系列的网络结构并不断刷新 ImageNet 的成绩，其中比较经典的网络包括：VGG (Visual Geometry Group) ⁴，GoogLeNet ⁵ 和 ResNet ⁶。

CNN 在图像分类问题上取得了不凡的成绩，同时一些学者也尝试将其应用在图像的其他领域，例如：物体检测 ⁷⁸⁹，语义分割 ¹⁰，图像摘要 ¹¹，行为识别 ¹² 等。除此之外，在非图像领域 CNN 也取得了一定的成绩 ¹³。

模型原理

下图为 Lecun 等人提出的 LeNet-5 的网络架构：

下面我们针对 CNN 网络中的不同类型的网络层逐一进行介绍。

输入层

LeNet-5 解决的手写数字分类问题的输入为一张 32x32 像素的灰度图像 (Gray Scale)。日常生活中计算机常用的图像的表示方式为 RGB，即将一张图片分为红色通道 (Red Channel)，绿色通道 (Green Channel) 和蓝色通道 (Blue Channel)，其中每个通道的每个像素点的数值范围为 $\left[0, 255\right]$。灰度图像表示该图片仅包含一个通道，也就是不具备彩色信息，每个像素点的数值范围同 RGB 图像的取值范围相同。

因此，一张图片在计算机的眼里就是一个如下图所示的数字矩阵 (示例图片来自于 MNIST 数据集 ¹⁴)：

在将图像输入到 CNN 网络之前，通常我们会对其进行预处理，因为每个像素点的最大取值为 $255$，因此将每个像素点的值除以 $255$ 则可以将其归一化到 $\left[0, 1\right]$ 的范围。

卷积层

在了解卷积层之前，让我们先来了解一下什么是卷积？设 $f\left(x\right), g\left(x\right)$ 是 $\mathbb{R}$ 上的两个可积函数，则卷积定义为：

$$ \left(f * g\right) \left(x\right) = \int_{- \infty}^{\infty}{f \left(\tau\right) g \left(x - \tau\right) d \tau} $$

离散形式定义为：

$$ \left(f * g\right) \left(x\right) = \sum_{\tau = - \infty}^{\infty}{f \left(\tau\right) g \left(x - \tau\right)} $$

我们用一个示例来形象的理解一下卷积的含义，以离散的形式为例，假设我们有两个骰子，$f\left(x\right), g\left(x\right)$ 分别表示投两个骰子，$x$ 面朝上的概率。

$$ f \left(x\right) = g \left(x\right) = \begin{cases} 1/6 & x = 1, 2, 3, 4, 5, 6 \\ 0 & \text{otherwise} \end{cases} $$

卷积 $\left(f * g\right) \left(x\right)$ 表示投两个骰子，朝上数字之和为 $x$ 的概率。则和为 $4$ 的概率为：

$$ \begin{equation} \begin{split} \left(f * g\right) \left(4\right) &= \sum_{\tau = 1}^{6}{f \left(\tau\right) g \left(4 - \tau\right)} \\ &= f \left(1\right) g \left(4 - 1\right) + f \left(2\right) g \left(4 - 2\right) + f \left(3\right) g \left(4 - 3\right) \\ &= 1/6 \times 1/6 + 1/6 \times 1/6 + 1/6 \times 1/6 \\ &= 1/12 \end{split} \end{equation} $$

这是一维的情况，我们处理的图像为一个二维的矩阵，因此类似的有：

$$ \left(f * g\right) \left(x, y\right) = \sum_{v = - \infty}^{\infty}{\sum_{h = - \infty}^{\infty}{f \left(h, v\right) g \left(x - h, y - v\right)}} $$

这次我们用一个抽象的例子解释二维情况下卷积的计算，设 $f, g$ 对应的概率矩阵如下：

$$ f = \left[ \begin{array}{ccc} \color{red}{a_{0, 0}} & \color{orange}{a_{0, 1}} & \color{yellow}{a_{0, 2}} \\ \color{green}{a_{1, 0}} & \color{cyan}{a_{1, 1}} & \color{blue}{a_{1, 2}} \\ \color{purple}{a_{2, 0}} & \color{black}{a_{2, 1}} & \color{gray}{a_{2, 2}} \end{array} \right] , g = \left[ \begin{array}{ccc} \color{gray}{b_{-1, -1}} & \color{black}{b_{-1, 0}} & \color{purple}{b_{-1, 1}} \\ \color{blue}{b_{0, -1}} & \color{cyan}{b_{0, 0}} & \color{green}{b_{0, 1}} \\ \color{yellow}{b_{1, -1}} & \color{orange}{b_{1, 0}} & \color{red}{b_{1, 1}} \end{array} \right] $$

则 $\left(f * g\right) \left(1, 1\right)$ 计算方式如下：

$$ \left(f * g\right) \left(1, 1\right) = \sum_{v = 0}^{2}{\sum_{h = 0}^{2}{f \left(h, v\right) g \left(1 - h, 1 - v\right)}} $$

从这个计算公式中我们就不难看出为什么上面的 $f, g$ 两个概率矩阵的角标会写成上述形式，即两个矩阵相同位置的角标之和均为 $1$。$\left(f * g\right) \left(1, 1\right)$ 即为 $f, g$ 两个矩阵中对应颜色的元素乘积之和。

在上例中，$f, g$ 两个概率矩阵的大小相同，而在 CNN 中，$f$ 为输入的图像，$g$ 一般是一个相对较小的矩阵，我们称之为卷积核。这种情况下，卷积的计算方式是类似的，只是会将 $g$ 矩阵旋转 $180^{\circ}$ 使得相乘的元素的位置也相同，同时需要 $g$ 在 $f$ 上进行滑动并计算对应位置的卷积值。下图 ¹⁵ 展示了一步计算的具体过程：

下图 ¹⁵ 形象的刻画了利用一个 3x3 大小的卷积核的整个卷积计算过程：

一些预设的卷积核对于图片可以起到不同的滤波器效果，例如下面 4 个卷积核分别会对图像产生不同的效果：不改变，边缘检测，锐化和高斯模糊。

$$ \left[ \begin{array}{ccc} 0 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 0 \end{array} \right] , \left[ \begin{array}{ccc} -1 & -1 & -1 \\ -1 & 8 & -1 \\ -1 & -1 & -1 \end{array} \right] , \left[ \begin{array}{ccc} 0 & -1 & 0 \\ -1 & 5 & -1 \\ 0 & -1 & 0 \end{array} \right] , \dfrac{1}{16} \left[ \begin{array}{ccc} 1 & 2 & 1 \\ 2 & 4 & 2 \\ 1 & 2 & 1 \end{array} \right] $$

对 lena 图片应用这 4 个卷积核，变换后的效果如下 (从左到右，从上到下)：

在上面整个计算卷积的动图中，我们不难发现，利用 3x3 大小 (我们一般将这个参数称之为 kernel_size，即卷积核的大小，其可以为一个整数表示长宽大小相同，也可以为两个不同的整数) 的卷积核对 5x5 大小的原始矩阵进行卷积操作后，结果矩阵并没有保持原来的大小，而是变为了 (5-(3-1))x(5-(3-1)) (即 3x3) 大小的矩阵。这就需要引入 CNN 网络中卷积层的两个常用参数 padding 和 strides。

padding 是指是否对图像的外侧进行补零操作，其取值一般为 VALID 和 SAME 两种。VALID 表示不进行补零操作，对于输入形状为 $\left(x, y\right)$ 的矩阵，利用形状为 $\left(m, n\right)$ 的卷积核进行卷积，得到的结果矩阵的形状则为 $\left(x-m+1, y-n+1\right)$。SAME 表示进行补零操作，在进行卷积操作前，会对图像的四个边缘分别向左右补充 $\left(m \mid 2 \right) + 1$ 个零，向上下补充 $\left(n \mid 2 \right) + 1$ 个零 ($\mid$ 表示整除)，从而保证进行卷积操作后，结果的形状与原图像的形状保持相同，如下图 ¹⁵ 所示：

strides 是指进行卷积操作时，每次卷积核移动的步长。示例中，卷积核在横轴和纵轴方向上的移动步长均为 $1$，除此之外用于也可以指定不同的步长。移动的步长同样会对卷积后的结果的形状产生影响。

除此之外，还有另一个重要的参数 filters，其表示在一个卷积层中使用的卷积核的个数。在一个卷积层中，一个卷积核可以学习并提取图像的一种特征，但往往图片中包含多种不同的特征信息，因此我们需要多个不同的卷积核提取不同的特征。下图 ¹⁵ 是一个利用 4 个不同的卷积核对一张图像进行卷积操作的示意图：

上面我们都是以一个灰度图像 (仅包含 1 个通道) 为示例进行的讨论，那么对于一个 RGB 图像 (包含 3 个通道)，相应的，卷积核也是一个 3 维的形状，如下图 ¹⁵ 所示：

卷积层对于我们的神经网络的模型带来的改进主要包括如下三个方面：稀疏交互 (sparse interactions)，参数共享 (parameter sharing) 和等变表示 (equivariant representations)。

在全连接的神经网络中，隐含层中的每一个节点都和上一层的所有节点相连，同时有被连接到下一层的全部节点。而卷积层不同，节点之间的连接性受到卷积核大小的制约。下图 ¹⁶ 分别以自下而上 (左) 和自上而下 (右) 两个角度对比了卷积层和全连接层节点之间连接性的差异。

在上图 (右) 中，我们可以看出节点 $s_3$ 受到节点 $x_2$，$x_3$ 和 $x_4$ 的影响，这些节点被称之为 $s_3$ 的接受域 (receptive field)。稀疏交互使得在 $m$ 个输入和 $n$ 个输出的情况下，参数的个数由 $m \times n$ 个减少至 $k \times n$ 个，其中 $k$ 为卷积核的大小。尽管一个节点在一个层级之间仅与其接受域内的节点相关联，但是对于深层中的节点，其与绝大部分输入之间却存在这间接交互，如下图 ¹⁶ 所示：

节点 $g_3$ 尽管直接的连接是稀疏的，但处于更深的层中可以间接的连接到全部或者大部分的输入节点。这就使得网络可以仅通过这种稀疏交互来高效的描述多个输入变量之间的复杂关系。

除了稀疏交互带来的参数个数减少外，参数共享也起到了类似的作用。所谓参数共享就是指在进行不同操作时使用相同的参数，具体而言也就是在我们利用卷积核在图像上滑动计算卷积时，每一步使用的卷积核都是相同的。同全连接网络的情况对比如下图 ¹⁶ 所示：

在全连接网络 (上图 - 下) 中，任意两个节点之间的连接 (权重) 仅用于这两个节点之间，而在卷积层中，如上图所示，其对卷积核中间节点 (黑色箭头) 的使用方式 (权重) 是相同的。参数共享虽然对于计算的时间复杂度没有带来改进，仍然是 $O \left(k \times n\right)$，但其却将参数个数降低至 $k$ 个。

正是由于参数共享机制，使得卷积层具有平移 等变 (equivariance) 的性质。对于函数 $f\left(x\right)$ 和 $g\left(x\right)$，如果满足 $f\left(g\left(x\right)\right) = g\left(f\left(x\right)\right)$，我们就称 $f\left(x\right)$ 对于变换 $g$ 具有等变性。简言之，对于图像如果我们将所有的像素点进行移动，则卷积后的输出表示也会移动同样的量。

非线性层

非线性层并不是 CNN 特有的网络层，在此我们不再详细介绍，一般情况下我们会使用 ReLU 作为我们的激活函数。

池化层

池化层 是一个利用 池化函数 (pooling function) 对网络输出进行进一步调整的网络层。池化函数使用某一位置的相邻输出的总体统计特征来代替网络在该位置的输出。常用的池化函数包括最大池化 (max pooling) 函数 (即给出邻域内的最大值) 和平均池化 (average pooling) 函数 (即给出邻域内的平均值) 等。但无论选择何种池化函数，当对输入做出少量平移时，池化对输入的表示都近似 不变 (invariant)。局部平移不变性 是一个很重要的性质，尤其是当我们关心某个特征是否出现而不关心它出现的位置时。

池化层同卷积层类似，具有三个比较重要的参数：pool_size，strides 和 padding，分别表示池化窗口的大小，步长以及是否对图像的外侧进行补零操作。下图 ¹⁶ 是一个 pool_size=3，strides=3，padding='valid' 的最大池化过程示例：

池化层同时也能够提高网络的计算效率，例如上图中在横轴和纵轴的步长均为 $3$，经过池化后，下一层网络节点的个数降低至前一层的 $\frac{1}{3 \times 3} = \frac{1}{9}$。

全连接层

全链接层 (Fully-connected or Dense Layer) 的目的就是将我们最后一个池化层的输出连接到最终的输出节点上。例如，最后一个池化层的输出大小为 $\left[5 \times 5 \times 16\right]$，也就是有 $5 \times 5 \times 16 = 400$ 个节点，对于手写数字识别的问题，我们的输出为 0 至 9 共 10 个数字，采用 one-hot 编码的话，输出层共 10 个节点。例如在 LeNet 中有 2 个全连接层，每层的节点数分别为 120 和 84，在实际应用中，通常全连接层的节点数会逐层递减。需要注意的是，在进行编码的时候，第一个全连接层并不是直接与最后一个池化层相连，而是先对池化层进行 flatten 操作，使其变成一个一维向量后再与全连接层相连。

输出层

输出层根据具体问题的不同会略有不同，例如对于手写数字识别问题，采用 one-hot 编码的话，输出层则包含 10 个节点。对于回归或二分类问题，输出层则仅包含 1 个节点。当然对于二分类问题，我们也可以像多分类问题一样将其利用 one-hot 进行编码，例如 $\left[1, 0\right]$ 表示类型 0，$\left[0, 1\right]$ 表示类型 1。

扩展与应用

本节我们将介绍一些经典的 CNN 网络架构及其相关的改进。

AlexNet ²

AlexNet 在整体结构上同 LeNet-5 类似，其改进大致如下：

• 网络包含了 5 个卷积层和 3 个全连接层，网络规模变大。
• 使用了 ReLU 非线性激活函数。
• 应用了 Data Augmentation，Dropout，Momentum，Weight Decay 等策略改进训练。
• 在算力有限的情况下，对模型进行划分为两部分并行计算。
• 增加局部响应归一化 (LRN, Local Response Normalization)。

LRN 的思想来自与生物学中侧抑制 (Lateral Inhibition) 的概念，简单来说就是相近的神经元之间会发生抑制作用。在 AlexNet 中，给出的 LRN 计算公式如下：

$$ b_{x,y}^{i} = a_{x,y}^{i} / \left(k + \alpha \sum_{j = \max \left(0, i - n/2\right)}^{\min \left(N - 1, i + n/2\right)}{\left(a_{x,y}^{j}\right)^2}\right)^{\beta} $$

其中，$a_{x,y}^{i}$ 表示第 $i$ 个卷积核在位置 $\left(x,y\right)$ 的输出，$N$ 为卷积核的个数，$k, n, \alpha, \beta$ 均为超参数，在原文中分别初值为：$k=2, n=5, \alpha=10^{-4}, \beta=0.75$。在上式中，分母为所有卷积核 (Feature Maps) 的加和，因此 LRN 可以简单理解为一个跨 Feature Maps 的像素级归一化。

开源实现：

• tensorflow/models, tflearn/examples
• pytorch/torchvision/models
• caffe2/models
• incubator-mxnet/example

VGG Net ⁴

左图是 VGG-16 Net 的网络结构，原文中还有一个 VGG-19 Net，其差别在于后面三组卷积层中均多叠加了一个卷积层，使得网络层数由 16 增加至 19。

VGG Net 的主要改变如下：

• 网络层级更深，从 AlexNet 的 8 层增加至 16 层和 19 层，更深的网络层级意味着更强的学习能力，但也需要更多的算力对模型进行优化。
• 仅使用 3x3 大小的卷积。在 AlexNet 中，浅层部分使用了较大的卷积核，而 VGG 使用了 3x3 的小卷积核进行串联叠加，减少了参数个数。
• 卷积采样的步长为 1x1，Max Pooling 的步长为 2x2。
• 去掉了效果提升不明显的但计算耗时的 LRN。
• 增加了 Feature Maps 的个数。

开源实现：

• tensorflow/models, tflearn/examples, tensorlayer/awesome-tensorlayer
• tf/keras/applications, keras/applications
• pytorch/torchvision/models
• caffe2/models
• incubator-mxnet/example

Network in Network (NIN) ¹⁷

NIN 网络的主要改变如下：

• 利用多层的全连接网络替换线性的卷积，即 mlpconv (Conv + MLP) 层。其中卷积层为线性的操作，而 MLP 为非线性的操作，因此具有更高的抽象能力。
• 去掉了全连接层，使用 Global Average Pooling，也就是将每个 Feature Maps 上所有的值求平均，直接作为输出节点，如下图所示：

• 相比 AlexNet 简化了网络结构，仅包含 4 个 NIN 单元和一个 Global Average Pooling，整个参数空间比 AlexNet 小了一个数量级。

在 NIN 中，在跨通道的情况下，mlpconv 层又等价于传统的 Conv 层后接一个 1x1 大小的卷积层，因此 mlpconv 层有时也称为 cccp (cascaded cross channel parametric pooling) 层。1x1 大小的卷积核可以说实现了不同通道信息的交互和整合，同时对于输入通道为 $m$ 和输出通道为 $n$，1x1 大小的卷积核在不改变分辨率的同时实现了降维 ($m > n$ 情况下) 或升维 ($m < n$ 情况下) 操作。

开源实现：

• tflearn/examples

GoogLeNet (Inception V1) ⁵, Inception V3 ¹⁸, Inception V4 ¹⁹

除了 VGG 这种从网络深度方向进行优化的策略以外，Google 还提出了在同一层利用不同大小的卷积核同时提取不同特征的思路，对于这样的结构我们称之为 Inception。

上图 (左) 为原始的 Inception 结构，在这样一层中分别包括了 1x1 卷积，3x3 卷积，5x5 卷积和 3x3 Max Polling，使得网络在每一层都能学到不同尺度的特征。最后通过 Filter Concat 将其拼接为多个 Feature Maps。

这种方式虽然能够带来性能的提升，但同时也增加了计算量，因此为了进一步改善，其选择利用 1x1 大小的卷积进行降维操作，改进后的 Inception 模块如上图 (右) 所示。我们以 GoogLeNet 中的 inception (3a) 模块为例 (输入大小为 28x28x192)，解释 1x1 卷积的降维效果。

对于原始 Inception 模块，1x1 卷积的通道为 64，3x3 卷积的通道为 128，5x5 卷积的通道为 32，卷积层的参数个数为：

$$ \begin{equation} \begin{split} \# w_{\text{3a_conv_without_1x1}} =& 1 \times 1 \times 192 \times 64 \\ & + 3 \times 3 \times 192 \times 128 \\ & + 5 \times 5 \times 192 \times 32 \\ =& 387072 \end{split} \end{equation} $$

对于加上 1x1 卷积后的 Inception 模块 (通道数分别为 96 和 16) 后，卷积层的参数个数为：

$$ \begin{equation} \begin{split} \# w_{\text{3a_conv_with_1x1}} =& 1 \times 1 \times 192 \times 64 \\ & + 1 \times 1 \times 192 \times 96 + 3 \times 3 \times 96 \times 128 \\ & + 1 \times 1 \times 192 \times 16 + 5 \times 5 \times 16 \times 32 \\ =& 157184 \end{split} \end{equation} $$

可以看出，在添加 1x1 大小的卷积后，参数的个数减少了 2 倍多。通过 1x1 卷积对特征进行降维的层称之为 Bottleneck Layer 或 Bottleneck Block。

在 GoogLeNet 中，作者还提出了 Auxiliary Classifiers (AC)，用于辅助训练。AC 通过增加浅层的梯度来减轻深度梯度弥散的问题，从而加速整个网络的收敛。

随后 Google 在此对 Inception 进行了改进，同时提出了卷积神经网络的 4 项设计原则，概括如下：

1. 避免表示瓶颈，尤其是在网络的浅层部分。一般来说，在到达任务的最终表示之前，表示的大小应该从输入到输出缓慢减小。
2. 高维特征在网络的局部更容易处理。在网络中增加更多的非线性有助于获得更多的解耦特征，同时网络训练也会加快。
3. 空间聚合可以在低维嵌入中进行，同时也不会对表征能力带来太多影响。例如，再进行尺寸较大的卷积操作之前可以先对输入进行降维处理。
4. 在网络的宽度和深度之间进行权衡。通过增加网络的深度和宽度均能够带来性能的提升，在同时增加其深度和宽度时，需要综合考虑算力的分配。

Inception V3 的主要改进包括：

• 增加了 Batch Normalized 层。
• 将一个 5x5 的卷积替换为两个串联的 3x3 的卷积 (基于原则 3)，减少了网络参数，如下图所示：

• 利用串联的 1xn 和 nx1 的非对称卷积 (Asymmetric Convolutions) 替代 nxn 的卷积 (基于原则 3)，减少了网络参数，如下图 (左) 所示：
• 增加带有滤波器组 (filter bank) 的 Inception 模块 (基于原则 2)，用于提升高维空间的表示能力，如下图 (右) 所示：

• 重新探讨了 Auxiliary Classifiers 的作用，发现其在训练初期并没有有效的提高收敛速度，尽在训练快结束时会略微提高网络的精度。
• 新的下采样方案。在传统的做法中，如果先进行 Pooling，在利用 Inception 模块进行操作，如下图 (左) 所示，会造成表示瓶颈 (原则 1)；而先利用 Inception 模块进行操作，再进行 Pooling，则会增加参数数量。
  因此，借助 Inception 结构的思想，作者提出了一种新的下采样方案。下图 (左) 是利用 Inception 的思想进行下采样的内部逻辑，下图 (右) 为同时利用 Inception 思想和 Pooling 进行下采样的整体框架。

• Label Smoothing 机制。假设标签的真实分布为 $q\left(k\right)$，则对于一个真实标签 $y$ 而言，有 $q\left(y\right) = 1$，对于 $k \neq y$，有 $q\left(k\right) = 0$。这种情况会导致两个问题：一个是当模型对于每个训练样本的真实标签赋予全部的概率时，模型将会发生过拟合；另一个是其鼓励拉大最大概率标签同其他标签之间的概率差距，从而降低网络的适应性。也就是说这种情况的发生是由于网络对于其预测结果过于自信。因此，对于一个真实标签 $y$，我们将其标签的分布 $q\left(k | x\right) = \delta_{k, y}$ 替换为： $$ q' \left(k | x\right) = \left(1 - \epsilon\right) \delta_{k, y} + \epsilon u \left(k\right) $$ 其中，$u \left(k\right)$ 是一个固定的分布，文中采用了均匀分布，即 $u \left(k\right) = 1 / K$；$\epsilon$ 为权重项，试验中取为 $0.1$。

Inception V4 对于 Inception 网络做了进一步细致的调整，其主要是将 Inception V3 中的前几层网络替换为了 stem 模块，具体的 stem 模块结构就不在此详细介绍了。

开源实现：

• tensorflow/models, tflearn/examples, tensorlayer/awesome-tensorlayer
• tf/keras/applications, keras/applications
• pytorch/torchvision/models
• caffe2/models
• incubator-mxnet/example

Deep Residual Net ⁶, Identity Mapping Residual Net ²⁰, DenseNet ²¹

随着网络深度的不断增加啊，其效果并未如想象一般提升，甚至发生了退化，He 等人 ⁶ 发现在 CIFAR-10 数据集上，一个 56 层的神经网络的性能要比一个 20 层的神经网络要差。网络层级的不断增加，不仅导致参数的增加，同时也可能导致梯度弥散问题 (vanishing gradients)。

这对这些问题，He 等人提出了一种 Deep Residual Net，在这个网络结构中，残差 (residual) 的思想可以理解为：假设原始潜在的映射关系为 $\mathcal{H} \left(\mathbf{x}\right)$，对于新的网络层我们不再拟合原始的映射关系，而是拟合 $\mathcal{F} \left(\mathbf{x}\right) = \mathcal{H} \left(\mathbf{x}\right) - \mathbf{x}$，也就是说原始潜在的映射关系变为 $\mathcal{F} \left(\mathbf{x}\right) + \mathbf{x}$。新的映射关系可以理解为在网络前向传播中添加了一条捷径 (shortcut connections)，如下图所示：

增加 Short Connections 并没有增加参数个数，也没有增加计算量，与此同时模型依旧可以利用 SGD 等算法进行优化。

从 Deep Residual Net 的实验结果 (如上图) 可以看出，在没有加入残差模块的网络中 (上图 - 左) 出现了上文中描述的问题：更多层级的网络的效果反而较差；在加入了残差模块的网络中 (上图 - 右)，其整体性能均比未加入残差模块的网络要好，同时具有更多层级的网络的效果也更好。

随后 He 等人 ²⁰ 又提出了 Identity Mapping Residual Net，在原始的 ResNet 中，一个残差单元可以表示为：

$$ \begin{equation} \begin{split} \mathbb{y}_{\ell} = & h \left(\mathbb{x}_{\ell}\right) + \mathcal{F} \left(\mathbb{x}_{\ell}, \mathcal{W}_l\right) \\ \mathbb{x}_{\ell+1} = & f \left(\mathbb{y}_{\ell}\right) \end{split} \end{equation} $$

其中 $\mathbb{x}_{\ell}$ 和 $\mathbb{x}_{\ell+1}$ 为第 $\ell$ 个单元的输入和输出，$\mathcal{F}$ 为残差函数，$h \left(\mathbb{x}_{\ell}\right) = \mathbb{x}_{\ell}$ 为一个恒等映射，$f$ 为 ReLU 函数。在 Identity Mapping Residual Net，作者将 $f$ 由原来的 ReLU 函数也替换成一个恒定映射，即 $\mathbb{x}_{\ell+1} \equiv \mathbb{y}_{\ell}$，则上式可以改写为：

$$ \mathbb{x}_{\ell+1} = \mathbb{x}_{\ell} + \mathcal{F} \left(\mathbb{x}_{\ell}, \mathcal{W}_{\ell}\right) $$

则对于任意深度的单元 $L$，有如下表示：

$$ \mathbb{x}_L = \mathbb{x}_{\ell} + \sum_{i=\ell}^{L-1}{\mathcal{F} \left(\mathbb{x}_i, \mathcal{W}_i\right)} $$

上式形式的表示使得其在反向传播中具有一个很好的性质，假设损失函数为 $\mathcal{E}$，根据链式法则，对于单元 $\ell$，梯度为：

$$ \dfrac{\partial \mathcal{E}}{\partial \mathbb{x}_{\ell}} = \dfrac{\partial \mathcal{E}}{\partial \mathbb{x}_L} \dfrac{\partial \mathbb{x}_L}{\partial \mathbb{x}_{\ell}} = \dfrac{\partial \mathcal{E}}{\partial \mathbb{x}_{\ell}} \left(1 + \dfrac{\partial}{\partial \mathbb{x}_{\ell}} \sum_{i=\ell}^{L-1}{\mathcal{F} \left(\mathbb{x}_i, \mathcal{W}_i\right)}\right) $$

对于上式形式的梯度，我们可以将其拆解为两部分：$\frac{\partial \mathcal{E}}{\partial \mathbb{x}_{\ell}}$ 为不通过任何权重层的直接梯度传递，$\frac{\partial \mathcal{E}}{\partial \mathbb{x}_{\ell}} \left(\frac{\partial}{\partial \mathbb{x}_{\ell}} \sum_{i=\ell}^{L-1}{\mathcal{F} \left(\mathbb{x}_i, \mathcal{W}_i\right)}\right)$ 为通过权重层的梯度传递。前一项保证了梯度能够直接传回任意浅层 $\ell$，同时对于任意一个 mini-batch 的所有样本，$\frac{\partial}{\partial \mathbb{x}_{\ell}} \sum_{i=\ell}^{L-1}\mathcal{F}$ 不可能永远为 $-1$，所以保证了即使权重很小的情况下也不会出现梯度弥散。下图展示了原始的 ResNet 和 Identity Mapping Residual Net 之间残差单元的区别和网络的性能差异：

Huang 等人 ²¹ 在 ResNet 的基础上又提出了 DenseNet 网络，其网络结构如下所示：

DenseNet 的主要改进如下：

• Dense Connectivity：将网络中每一层都与其后续层进行直接连接。
• Growth Rate：$H_{\ell}$ 将产生 $k$ 个 Feature Maps，因此第 $\ell$ 层将包含 $k_0 + k \times \left(\ell - 1\right)$ 个 Feature Maps，其中 $k_0$ 为输入层的通道数。DenseNet 与现有框架的不同之处就是将网络限定的比较窄，例如：$k = 12$，并将该超参数称之为网络的增长率 (Growth Rate)。
• Bottleneck Layers：在 3x3 的卷积之前增加 1x1 的卷积进行降维操作。
• Compression：在两个 Dense Block 之间增加过渡层 (Transition Layer)，进一步减少 Feature Maps 个数。

开源实现：

• tensorflow/models, tflearn/examples, tensorlayer/awesome-tensorlayer
• tf/keras/applications, keras/applications
• pytorch/torchvision/models
• caffe2/models
• incubator-mxnet/example

综合比较

Canziani 等人 ²² 综合了模型的准确率，参数大小，内存占用，推理时间等多个角度对现有的 CNN 模型进行了对比分析。

上图 (左) 展示了在 ImageNet 挑战赛中不同 CNN 网络模型的 Top-1 的准确率。可以看出近期的 ResNet 和 Inception 架构以至少 7% 的显著优势超过了其他架构。上图 (右) 以另一种形式展现了除了准确率以外的更多信息，包括计算成本和网络的参数个数，其中横轴为计算成本，纵轴为 Top-1 的准确率，气泡的大小为网络的参数个数。可以看出 ResNet 和 Inception 架构相比 AlexNet 和 VGG 不仅有更高的准确率，其在计算成本和网络的参数个数 (模型大小) 方面也具有一定优势。

文章部分内容参考了 刘昕 的 CNN近期进展与实用技巧。CNN 除了在图像分类问题上取得很大的进展外，在例如：物体检测：R-CNN ²³, SPP-Net ²⁴, Fast R-CNN ²⁵, Faster R-CNN ²⁶，语义分割：FCN ²⁷ 等多个领域也取得了不俗的成绩。针对不同的应用场景，网络模型和处理方法均有一定的差异，本文就不再对其他场景一一展开说明，不同场景将在后续进行单独整理。

梯度下降

在梯度下降算法中，常用的主要包含 3 种不同的形式，分别是批量梯度下降 (Batch Gradient Descent, BGD)，随机梯度下降 (Stochastic Gradient Descent, SGD) 和小批量梯度下降 (Mini-Batch Gradient Descent, MBGD)。一般情况下，我们在谈论梯度下降时，更多的是指小批量梯度下降。

BGD

BGD 为梯度下降算法中最基础的一个算法，其损失函数定义如下：

$$ J \left(\boldsymbol{\theta}\right) = \dfrac{1}{2m} \sum_{i=1}^{m}{\left(h_{\boldsymbol{\theta}}\left(x^{\left(i\right)}\right) - y^{\left(i\right)}\right)} $$

针对任意参数 $\theta_j$ 我们可以求得其梯度为：

$$ \nabla_{\theta_j} = \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j} = - \dfrac{1}{m} \sum_{i=1}^{m}{\left(y^{\left(i\right)} - h_{\boldsymbol{\theta}} \left(x^{\left(i\right)}\right)\right) x_j^{\left(i\right)}} $$

之后，对于任意参数 $\theta_j$ 我们按照其负梯度方向进行更新：

$$ \theta_j = \theta_j + \alpha \left[\dfrac{1}{m} \sum_{i=1}^{m}{\left(y^{\left(i\right)} - h_{\boldsymbol{\theta}} \left(x^{\left(i\right)}\right)\right) x_j^{\left(i\right)}}\right] $$

整个算法流程可以表示如下：

\begin{algorithm}
\caption{BGD 算法}
\begin{algorithmic}
\FOR{$epoch = 1, 2, ...$}
    \FOR{$j = 1, 2, ..., n$}
        \STATE $J \left(\boldsymbol{\theta}\right) = \dfrac{1}{2m} \sum_{i=1}^{m}{\left(h_{\boldsymbol{\theta}}\left(x^{\left(i\right)}\right) - y^{\left(i\right)}\right)}$
        \STATE $\theta_j = \theta_j - \alpha \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j}$
    \ENDFOR
\ENDFOR
\end{algorithmic}
\end{algorithm}

从上述算法流程中我们可以看到，BGD 算法每次计算梯度都使用了整个训练集，也就是说对于给定的一个初始点，其每一步的更新都是沿着全局梯度最大的负方向。但这同样是其问题，当 $m$ 太大时，整个算法的计算开销就很高了。

SGD

SGD 相比于 BGD，其最主要的区别就在于计算梯度时不再利用整个数据集，而是针对单个样本计算梯度并更新权重，因此，其损失函数定义如下：

$$ J \left(\boldsymbol{\theta}\right) = \dfrac{1}{2} \left(h_{\boldsymbol{\theta}}\left(x^{\left(i\right)}\right) - y^{\left(i\right)}\right) $$

整个算法流程可以表示如下：

\begin{algorithm}
\caption{SGD 算法}
\begin{algorithmic}
\FOR{$epoch = 1, 2, ...$}
    \STATE Randomly shuffle dataset
    \FOR{$i = 1, 2, ..., m$}
        \FOR{$j = 1, 2, ..., n$}
            \STATE $J \left(\boldsymbol{\theta}\right) = \dfrac{1}{2} \left(h_{\boldsymbol{\theta}}\left(x^{\left(i\right)}\right) - y^{\left(i\right)}\right)$
            \STATE $\theta_j = \theta_j - \alpha \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j}$
        \ENDFOR
    \ENDFOR
\ENDFOR
\end{algorithmic}
\end{algorithm}

SGD 相比于 BGD 具有训练速度快的优势，但同时由于权重改变的方向并不是全局梯度最大的负方向，甚至相反，因此不能够保证每次损失函数都会减小。

MBGD

针对 BGD 和 SGD 的问题，MBGD 则是一个折中的方案，在每次更新参数时，MBGD 会选取 $b$ 个样本计算的梯度，设第 $k$ 批中数据的下标的集合为 $B_k$，则其损失函数定义如下：

$$ \nabla_{\theta_j} = \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j} = - \dfrac{1}{|B_k|} \sum_{i \in B_k}{\left(y^{\left(i\right)} - h_{\boldsymbol{\theta}} \left(x^{\left(i\right)}\right)\right) x_j^{\left(i\right)}} $$

整个算法流程可以表示如下：

\begin{algorithm}
\caption{MBGD 算法}
\begin{algorithmic}
\FOR{$epoch = 1, 2, ...$}
    \FOR{$k = 1, 2, ..., m / b$}
        \FOR{$j = 1, 2, ..., n$}
            \STATE $J \left(\boldsymbol{\theta}\right) = \dfrac{1}{|B_k|} \sum_{i \in B_k}{\left(y^{\left(i\right)} - h_{\boldsymbol{\theta}} \left(x^{\left(i\right)}\right)\right) x_j^{\left(i\right)}}$
            \STATE $\theta_j = \theta_j - \alpha \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j}$
        \ENDFOR
    \ENDFOR
\ENDFOR
\end{algorithmic}
\end{algorithm}

Momentum

当梯度沿着一个方向要明显比其他方向陡峭，我们可以形象的称之为峡谷形梯度，这种情况多位于局部最优点附近。在这种情况下，SGD 通常会摇摆着通过峡谷的斜坡，这就导致了其到达局部最优值的速度过慢。因此，针对这种情况，Momentum ² 方法提供了一种解决方案。针对原始的 SGD 算法，参数每 $t$ 步的变化量可以表示为

$$ \boldsymbol{v}_t = - \alpha \nabla_{\boldsymbol{\theta}} J \left(\boldsymbol{\theta}_t\right) $$

Momentum 算法则在其变化量中添加了一个动量分量，即

$$ \begin{equation} \begin{split} \boldsymbol{v}_t &= - \alpha \nabla_{\boldsymbol{\theta}} J \left(\boldsymbol{\theta}_t\right) + \gamma \boldsymbol{v}_{t-1} \\ \boldsymbol{\theta}_t &= \boldsymbol{\theta}_{t-1} + \boldsymbol{v}_t \end{split} \end{equation} $$

对于添加的动量项，当第 $t$ 步和第 $t-1$ 步的梯度方向相同时，$\boldsymbol{\theta}$ 则以更快的速度更新；当第 $t$ 步和第 $t-1$ 步的梯度方向相反时，$\boldsymbol{\theta}$ 则以较慢的速度更新。利用 SGD 和 Momentum 两种方法，在峡谷行的二维梯度上更新参数的示意图如下所示

NAG

NAG (Nesterov Accelerated Gradient) ³ 是一种 Momentum 算法的变种，其核心思想会利用“下一步的梯度”确定“这一步的梯度”，当然这里“下一步的梯度”并非真正的下一步的梯度，而是指仅根据动量项更新后位置的梯度。Sutskever ⁴ 给出了一种更新参数的方法：

$$ \begin{equation} \begin{split} \boldsymbol{v}_t &= - \alpha \nabla_{\boldsymbol{\theta}} J \left(\boldsymbol{\theta}_t + \gamma \boldsymbol{v}_{t-1}\right) + \gamma \boldsymbol{v}_{t-1} \\ \boldsymbol{\theta}_t &= \boldsymbol{\theta}_{t-1} + \boldsymbol{v}_t \end{split} \end{equation} $$

针对 Momentum 和 NAG 两种不同的方法，其更新权重的差异如下图所示：

AdaGrad

AdaGrad ⁵ 是一种具有自适应学习率的的方法，其对于低频特征的参数选择更大的更新量，对于高频特征的参数选择更小的更新量。因此，AdaGrad算法更加适用于处理稀疏数据。Pennington 等则利用该方法训练 GloVe ⁶ 词向量，因为对于出现次数较少的词应当获得更大的参数更新。

因为每个参数的学习速率不再一样，则在 $t$ 时刻第 $i$ 个参数的变化为

$$ \theta_{t, i} = \theta_{t-1, i} - \alpha \nabla_{\theta} J \left(\theta_{t-1, i}\right) $$

根据 AdaGrad 方法的更新方式，我们对学习率做出如下变化

$$ \theta_{t, i} = \theta_{t-1, i} - \dfrac{\alpha}{\sqrt{G_{t, i}} + \epsilon} \nabla_{\theta} J \left(\theta_{t-1, i}\right) $$

其中，$G_t$ 表示截止到 $t$ 时刻梯度的平方和；$\epsilon$ 为平滑项，防止除数为零，一般设置为 $10^{-8}$。AdaGrad 最大的优势就在于其能够自动调节每个参数的学习率。

Adadelta

上文中 AdaGrad 算法存在一个缺点，即其用于调节学习率的分母中包含的是一个梯度的平方累加项，随着训练的不断进行，这个值将会越来越大，也就是说学习率将会越来越小，最终导致模型不会再学习到任何知识。Adadelta ⁷ 方法针对 AdaGrad 的这个问题，做出了进一步改进，其不再计算历史所以梯度的平方和，而是使用一个固定长度 $w$ 的滑动窗口内的梯度。

因为存储 $w$ 的梯度平方并不高效，Adadelta 采用了一种递归的方式进行计算，定义 $t$ 时刻梯度平方的均值为

$$ E \left[g^2\right]_t = \rho E \left[g^2\right]_{t-1} + \left(1 - \rho\right) g^2_{t} $$

其中，$g_t$ 表示 $t$ 时刻的梯度；$\rho$ 为一个衰减项，类似于 Momentum 中的衰减项。在更新参数过程中我们需要其平方根，即

$$ \text{RMS} \left[g\right]_t = \sqrt{E \left[g^2\right]_t + \epsilon} $$

则参数的更新量为

$$ \Delta \theta_t = - \dfrac{\alpha}{\text{RMS} \left[g\right]_t} g_t $$

除此之外，作者还考虑到上述更新中更新量和参数的假设单位不一致的情况，在上述更新公式中添加了一个关于参数的衰减项

$$ \text{RMS} \left[\Delta \theta\right]_t = \sqrt{E \left[\Delta \theta^2\right]_t + \epsilon} $$

其中

$$ E \left[\Delta \theta^2\right]_t = \rho E \left[\Delta \theta^2\right]_{t-1} + \left(1 - \rho\right) \Delta \theta_t^2 $$

在原始的论文中，作者直接用 $\text{RMS} \left[\Delta \theta^2\right]_t$ 替换了学习率，即

$$ \Delta \theta_t = - \dfrac{\text{RMS} \left[\Delta \theta\right]_{t-1}}{\text{RMS} \left[g\right]_t} g_t $$

而在 Keras 源码中，则保留了固定的学习率，即

$$ \Delta \theta_t = - \alpha \dfrac{\text{RMS} \left[\Delta \theta\right]_{t-1}}{\text{RMS} \left[g\right]_t} g_t $$

RMSprop

RMSprop ⁸ 是由 Hinton 提出的一种针对 AdaGrad 的改进算法。参数的更新量为

$$ \Delta \theta_t = - \dfrac{\alpha}{\text{RMS} \left[g\right]_t} g_t $$

Adam

Adam (Adaptive Moment Estimation) ⁹ 是另一种类型的自适应学习率方法，类似 Adadelta，Adam 对于每个参数都计算各自的学习率。Adam 方法中包含一个一阶梯度衰减项 $m_t$ 和一个二阶梯度衰减项 $v_t$

$$ \begin{equation} \begin{split} m_t &= \beta_1 m_{t-1} + \left(1 - \beta_1\right) g_t \\ v_t &= \beta_2 v_{t-1} + \left(1 - \beta_2\right) g_t^2 \end{split} \end{equation} $$

算法中，$m_t$ 和 $v_t$ 初始化为零向量，作者发现两者会更加偏向 $0$，尤其是在训练的初始阶段和衰减率很小的时候 (即 $\beta_1$ 和 $\beta_2$ 趋近于1的时候)。因此，对其偏差做如下校正

$$ \begin{equation} \begin{split} \hat{m}_t &= \dfrac{m_t}{1 - \beta_1^t} \\ \hat{v}_t &= \dfrac{v_t}{1 - \beta_2^t} \end{split} \end{equation} $$

最终得到 Adam 算法的参数更新量如下

$$ \Delta \theta = - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t $$

Adamax

在 Adam 中参数的更新方法利用了 $L_2$ 正则形式的历史梯度 ($v_{t-1}$) 和当前梯度 ($|g_t|^2$)，因此，更一般的，我们可以使用 $L_p$ 正则形式，即

$$ \begin{equation} \begin{split} v_t &= \beta_2^p v_{t-1} + \left(1 - \beta_2^p\right) |g_t|^p \\ &= \left(1 - \beta_2^p\right) \sum_{i=1}^{t} \beta_2^{p\left(t-i\right)} \cdot |g_t|^p \end{split} \end{equation} $$

这样的变换对于值较大的 $p$ 而言是很不稳定的，但对于极端的情况，当 $p$ 趋近于无穷的时候，则变为了一个简单并且稳定的算法。则在 $t$ 时刻对应的我们需要计算 $v_t^{1/p}$，令 $u_t = \lim_{p \to \infty} \left(v_t\right)^{1/p}$，则有

$$ \begin{equation} \begin{split} u_t &= \lim_{p \to \infty} \left(\left(1 - \beta_2^p\right) \sum_{i=1}^{t} \beta_2^{p\left(t-i\right)} \cdot |g_t|^p\right)^{1/p} \\ &= \lim_{p \to \infty} \left(1 - \beta_2^p\right)^{1/p} \left(\sum_{i=1}^{t} \beta_2^{p\left(t-i\right)} \cdot |g_t|^p\right)^{1/p} \\ &= \lim_{p \to \infty} \left(\sum_{i=1}^{t} \beta_2^{p\left(t-i\right)} \cdot |g_t|^p\right)^{1/p} \\ &= \max \left(\beta_2^{t-1} |g_1|, \beta_2^{t-2} |g_2|, ..., \beta_{t-1} |g_t|\right) \end{split} \end{equation} $$

写成递归的形式，则有

$$ u_t = \max \left(\beta_2 \cdot u_{t-1}, |g_t|\right) $$

则 Adamax 算法的参数更新量为

$$ \Delta \theta = - \dfrac{\alpha}{u_t} \hat{m}_t $$

Nadam

Adam 算法可以看做是对 RMSprop 和 Momentum 的结合：历史平方梯度的衰减项 $v_t$ (RMSprop) 和 历史梯度的衰减项 $m_t$ (Momentum)。Nadam (Nesterov-accelerated Adaptive Moment Estimation) ¹⁰ 则是将 Adam 同 NAG 进行了进一步结合。我们利用 Adam 中的符号重新回顾一下 NAG 算法

$$ \begin{equation} \begin{split} g_t &= \nabla_{\theta} J \left(\theta_t - \gamma m_{t-1}\right) \\ m_t &= \gamma m_{t-1} + \alpha g_t \\ \theta_t &= \theta_{t-1} - m_t \end{split} \end{equation} $$

NAG 算法的核心思想会利用“下一步的梯度”确定“这一步的梯度”，在 Nadam 算法中，作者在考虑“下一步的梯度”时对 NAG 进行了改动，修改为

$$ \begin{equation} \begin{split} g_t &= \nabla_{\theta} J \left(\theta_t\right) \\ m_t &= \gamma m_{t-1} + \alpha g_t \\ \theta_t &= \theta_{t-1} - \left(\gamma m_t + \alpha g_t\right) \end{split} \end{equation} $$

对于 Adam，根据

$$ \hat{m}_t = \dfrac{\beta_1 m_{t-1}}{1 - \beta_1^t} + \dfrac{\left(1 - \beta_1\right) g_t}{1 - \beta_1^t} $$

则有

$$ \begin{equation} \begin{split} \Delta \theta &= - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t \\ &= - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \left(\dfrac{\beta_1 m_{t-1}}{1 - \beta_1^t} + \dfrac{\left(1 - \beta_1\right) g_t}{1 - \beta_1^t}\right) \end{split} \end{equation} $$

上式中，仅 $\dfrac{\beta_1 m_{t-1}}{1 - \beta_1^t}$ 和动量项相关，因此我们类似上文中对 NAG 的改动，通过简单的替换加入 Nesterov 动量项，最终得到 Nadam 方法的参数的更新量

$$ \Delta \theta = - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \left(\dfrac{\beta_1 m_{t-1}}{1 - \beta_1^{t+1}} + \dfrac{\left(1 - \beta_1\right) g_t}{1 - \beta_1^t}\right) $$

AMSGrad

对于前面提到的 Adadelta，RMSprop，Adam 和 Nadam 方法，他们均采用了平方梯度的指数平滑平均值迭代产生新的梯度，但根据观察，在一些情况下这些算法并不能收敛到最优解。Reddi 等提出了一种新的 Adam 变体算法 AMSGrad ¹¹，在文中作者解释了为什么 RMSprop 和 Adam 算法无法收敛到一个最优解的问题。通过分析表明，为了保证得到一个收敛的最优解需要保留过去梯度的“长期记忆”，因此在 AMSGrad 算法中使用了历史平方梯度的最大值而非滑动平均进行更新参数，即

$$ \begin{equation} \begin{split} m_t &= \beta_1 m_{t-1} + \left(1 - \beta_1\right) g_t \\ v_t &= \beta_2 v_{t-1} + \left(1 - \beta_2\right) g_t^2 \\ \hat{v}_t &= \max \left(\hat{v}_{t-1}, v_t\right) \\ \Delta \theta &= - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} m_t \end{split} \end{equation} $$

作者在一些小数据集和 CIFAR-10 数据集上得到了相比于 Adam 更好的效果，但与此同时一些其他的 实验 却得到了相比与 Adam 类似或更差的结果，因此对于 AMSGrad 算法的效果还有待进一步确定。

算法可视化

正所谓一图胜千言，Alec Radford 提供了 2 张图形象了描述了不同优化算法之间的区别

左图为 Beale Function 在二维平面上的等高线，从图中可以看出 AdaGrad，Adadelta 和 RMSprop 算法很快的找到正确的方向并迅速的收敛到最优解；Momentum 和 NAG 则在初期出现了偏离，但偏离之后调整了方向并收敛到最优解；而 SGD 尽管方向正确，但收敛速度过慢。

右图为包含鞍点的一个三维图像，图像函数为 $z = x^2 - y^2$，从图中可以看出 AdaGrad，Adadelta 和 RMSprop 算法能够相对很快的逃离鞍点，而 Momentum，NAG 和 SGD 则相对比较困难逃离鞍点。

很不幸没能找到 Alec Radford 绘图的原始代码，不过 Louis Tiao 在 博客 中给出了绘制类似动图的方法。因此，本文参考该博客和 Keras 源码中对不同优化算法的实现重新绘制了 2 张类似图像，详细过程参见 源代码，动图如下所示：

生成对抗网络 (Generative Adversarial Network, GAN) 是由 Goodfellow ¹ 于 2014 年提出的一种对抗网络。这个网络框架包含两个部分，一个生成模型 (generative model) 和一个判别模型 (discriminative model)。其中，生成模型可以理解为一个伪造者，试图通过构造假的数据骗过判别模型的甄别；判别模型可以理解为一个警察，尽可能甄别数据是来自于真实样本还是伪造者构造的假数据。两个模型都通过不断的学习提高自己的能力，即生成模型希望生成更真的假数据骗过判别模型，而判别模型希望能学习如何更准确的识别生成模型的假数据。

网络框架

GAN 由两部分构成，一个生成器 (Generator) 和一个判别器 (Discriminator)。对于生成器，我们需要学习关于数据 $\boldsymbol{x}$ 的一个分布 $p_g$，首先定义一个输入数据的先验分布 $p_{\boldsymbol{z}} \left(\boldsymbol{z}\right)$，其次定义一个映射 $G \left(\boldsymbol{z}; \theta_g\right): \boldsymbol{z} \to \boldsymbol{x}$。对于判别器，我们则需要定义一个映射 $D \left(\boldsymbol{x}; \theta_d\right)$ 用于表示数据 $\boldsymbol{x}$ 是来自于真实数据，还是来自于 $p_g$。GAN 的网络框架如下图所示 ²：

模型训练

Goodfellow 在文献中给出了一个重要的公式用于求解最优的生成器

$$ \min_{G} \max_{D} V\left(D, G\right) = \mathbb{E}_{\boldsymbol{x} \sim p_{data}{\left(\boldsymbol{x}\right)}}{\left[\log D\left(\boldsymbol{x}\right)\right]} + \mathbb{E}_{\boldsymbol{z} \sim p_{\boldsymbol{z}}\left(\boldsymbol{z}\right)}{\left[\log \left(1 - D\left(G\left(\boldsymbol{z}\right)\right)\right)\right]} $$

上式中，在给定的 $G$ 的情况下，$\max_{D} V\left(G, D\right)$衡量的是 $p_{data}$ 和 $p_g$ 之间的“区别”，因此我们最终的优化目标就是找到最优的 $G^*$ 使得 $p_{data}$ 和 $p_g$ 之间的“区别”最小。

首先，在给定 $G$ 的时候，我们可以通过最大化 $V \left(G, D\right)$ 得到最优 $D^*$

$$ \begin{equation} \begin{split} V \left(G, D\right) &= \mathbb{E}_{\boldsymbol{x} \sim p_{data}{\left(\boldsymbol{x}\right)}}{\left[\log D\left(\boldsymbol{x}\right)\right]} + \mathbb{E}_{\boldsymbol{z} \sim p_{\boldsymbol{z}}\left(\boldsymbol{z}\right)}{\left[\log \left(1 - D\left(G\left(\boldsymbol{z}\right)\right)\right)\right]} \\ &= \int_{\boldsymbol{x}}{p_{data}\left(\boldsymbol{x}\right) \log D\left(\boldsymbol{x}\right) dx} + \int_{\boldsymbol{z}}{p_{\boldsymbol{z}} \left(\boldsymbol{z}\right) \log \left(1 - D\left(g\left(\boldsymbol{z}\right)\right)\right) dz} \\ &= \int_{\boldsymbol{x}}{p_{data}\left(\boldsymbol{x}\right) \log D\left(\boldsymbol{x}\right) + p_g\left(\boldsymbol{x}\right) \log \left(1 - D\left(\boldsymbol{x}\right)\right) dx} \end{split} \end{equation} $$

对于给定的任意 $a, b \in \mathbb{R}^2 \setminus \{0, 0\}$，$a \log\left(x\right) + b \log\left(1 - x\right)$在 $x = \dfrac{a}{a+b}$ 处取得最大值，$D$ 的最优值为

$$ D_{G}^{*} = \dfrac{p_{data} \left(\boldsymbol{x}\right)}{p_{data} \left(\boldsymbol{x}\right) + p_g \left(\boldsymbol{x}\right)} $$

因此，$\max_{D} V \left(G, D\right)$ 可重写为

$$ \begin{equation} \begin{split} &C\left(G\right) \\ =& \max_{D} V \left(G, D\right) = V \left(G, D^*\right) \\ =& \mathbb{E}_{\boldsymbol{x} \sim p_{data}{\left(\boldsymbol{x}\right)}}{\left[\log D_{G}^{*}\left(\boldsymbol{x}\right)\right]} + \mathbb{E}_{\boldsymbol{z} \sim p_{\boldsymbol{z}}\left(\boldsymbol{z}\right)}{\left[\log \left(1 - D_{G}^{*}\left(G\left(\boldsymbol{z}\right)\right)\right)\right]} \\ =& \mathbb{E}_{\boldsymbol{x} \sim p_{data}{\left(\boldsymbol{x}\right)}}{\left[\log D_{G}^{*}\left(\boldsymbol{x}\right)\right]} + \mathbb{E}_{\boldsymbol{x} \sim p_g\left(\boldsymbol{x}\right)}{\left[\log \left(1 - D_{G}^{*}\left(\boldsymbol{x}\right)\right)\right]} \\ =& \mathbb{E}_{\boldsymbol{x} \sim p_{data}{\left(\boldsymbol{x}\right)}}{\left[\log \dfrac{p_{data} \left(\boldsymbol{x}\right)}{p_{data} \left(\boldsymbol{x}\right) + p_g \left(\boldsymbol{x}\right)} \right]} + \mathbb{E}_{\boldsymbol{x} \sim p_g\left(\boldsymbol{x}\right)}{\left[\log \dfrac{p_g \left(\boldsymbol{x}\right)}{p_{data} \left(\boldsymbol{x}\right) + p_g \left(\boldsymbol{x}\right)}\right]} \\ =& \int_{x}{p_{data} \left(\boldsymbol{x}\right) \log \dfrac{\dfrac{1}{2} p_{data} \left(\boldsymbol{x}\right)}{\dfrac{p_{data} \left(\boldsymbol{x}\right) + p_g \left(\boldsymbol{x}\right)}{2}} dx} + \int_{x}{p_g \left(\boldsymbol{x}\right) \log \dfrac{\dfrac{1}{2} p_g \left(\boldsymbol{x}\right)}{\dfrac{p_{data} \left(\boldsymbol{x}\right) + p_g \left(\boldsymbol{x}\right)}{2}} dx} \\ =& \int_{x}{p_{data} \left(\boldsymbol{x}\right) \log \dfrac{p_{data} \left(\boldsymbol{x}\right)}{\dfrac{p_{data} \left(\boldsymbol{x}\right) + p_g \left(\boldsymbol{x}\right)}{2}} dx} + \int_{x}{p_g \left(\boldsymbol{x}\right) \log \dfrac{p_g \left(\boldsymbol{x}\right)}{\dfrac{p_{data} \left(\boldsymbol{x}\right) + p_g \left(\boldsymbol{x}\right)}{2}} dx} + 2 \log \dfrac{1}{2} \\ =& KL \left(p_{data} \left(\boldsymbol{x}\right) \Vert \dfrac{p_{data} \left(\boldsymbol{x}\right) + p_g \left(\boldsymbol{x}\right)}{2}\right) + KL \left(p_g \left(\boldsymbol{x}\right) \Vert \dfrac{p_{data} \left(\boldsymbol{x}\right) + p_g \left(\boldsymbol{x}\right)}{2}\right) - 2 \log 2 \\ =& 2 JS \left(p_{data} \left(\boldsymbol{x}\right) \Vert p_g \left(\boldsymbol{x}\right) \right) - 2 \log 2 \end{split} \end{equation} $$

其中 $KL$ 表示 KL 散度 ³，$JS$ 表示 JS 散度 ⁴，因此在全局最优情况下 $p_g = p_{data}$。

整个 GAN 的训练过程如下所示：

\begin{algorithm}
\caption{Minibatch SGD for GAN 算法}
\begin{algorithmic}
\REQUIRE $iter, k, m$
\ENSURE $\theta_d, \theta_g$
\FOR{$i = 1, 2, ..., iter$}
    \FOR{$j = 1, 2, ..., k$}
        \STATE Sample minibatch of $m$ noise samples $\{z^{\left(1\right)}, ..., z^{\left(m\right)}\}$ from $p_g \left(\boldsymbol{z}\right)$
        \STATE Sample minibatch of $m$ examples $\{x^{\left(1\right)}, ..., x^{\left(m\right)}\}$ from $p_{data} \left(\boldsymbol{z}\right)$
        \STATE $\theta_d \gets \theta_d \textcolor{red}{+} \nabla_{\theta_d} \dfrac{1}{m} \sum_{i=1}^{m}{\left[\log D \left(x^{\left(i\right)}\right) + \log \left(1 - D \left(G \left(z^{\left(i\right)}\right)\right)\right)\right]}$
    \ENDFOR
    \STATE Sample minibatch of $m$ noise samples $\{z^{\left(1\right)}, ..., z^{\left(m\right)}\}$ from $p_g \left(\boldsymbol{z}\right)$
    \STATE $\theta_g \gets \theta_g \textcolor{red}{-} \nabla_{\theta_g} \dfrac{1}{m} \sum_{i=1}^{m}{\log \left(1 - D \left(G \left(z^{\left(i\right)}\right)\right)\right)}$
\ENDFOR
\end{algorithmic}
\end{algorithm}

在实际的训练过程中，我们通常不会直接训练 $G$ 最小化 $\log \left(1 - D \left(G \left(\boldsymbol{z}\right)\right)\right)$，因为其在学习过程中的早起处于饱和状态，因此我们通常会通过最大化 $\log \left(D \left(G \left(z\right)\right)\right)$。

存在的问题

针对 GAN，包括 Goodfellow 自己在内也提出了其中包含的很多问题 ²，因此后人也提出了大量的改进，衍生出了大量的 GAN 变种。本章节仅对原始的 GAN 中存在的问题进行简略介绍，相关的改进请参见后续的具体改进算法。

JS 散度问题

我们在训练判别器的时候，其目标是最大化 JS 散度，但 JS 散度真的能够很好的帮助我们训练判别器吗？ Wasserstein GAN 一文 ⁵给出了不同生成器情况下 JS 散度的变化情况。

上图中，左边为一个基于 MLP 的生成器，右边为一个 DCGAN ⁶ 生成器，两者均有一个 DCGAN 的判别器。根据上文我们可以知道判别器的目标是最大化

$$ \begin{equation} \begin{split} L \left(D, \theta_g\right) &= \mathbb{E}_{\boldsymbol{x} \sim p_{data}{\left(\boldsymbol{x}\right)}}{\left[\log D_{G}^{*}\left(\boldsymbol{x}\right)\right]} + \mathbb{E}_{\boldsymbol{x} \sim p_g\left(\boldsymbol{x}\right)}{\left[\log \left(1 - D_{G}^{*}\left(\boldsymbol{x}\right)\right)\right]} \\ &= 2 JS \left(p_{data} \left(\boldsymbol{x}\right) \Vert p_g \left(\boldsymbol{x}\right) \right) - 2 \log 2 \end{split} \end{equation} $$

上图中 Y 轴绘制的为 $\dfrac{1}{2} L \left(D, \theta_g\right) + \log 2$，因为 $-2 \log 2 \leq L \left(D, \theta_g\right) \leq 0$，因此我们可得 $0 \leq \dfrac{1}{2} L \left(D, \theta_g\right) + \log 2 \leq \log 2$。从图中我们可以看出，针对两种不同的情况，其值均很快的逼近最大值 $\log 2 \approx 0.69$，当接近最大值的时候，判别器将具有接近于零的损失，此时我们可以发现，尽管 JS 散度很快趋于饱和，但 DCGAN 生成器的效果却仍在不断的变好，因此，使用 JS 散度作为判别其的目标就显得不是很合适。

多样性问题 Mode Collapse

Mode Collapse 问题是指生成器更多的是生成了大量相同模式的数据，导致的结果就是生成的数据缺乏多样性，如下图所示 ⁷:

不难看出，其中红色方框圈出来的图像十分相似，这样的问题我们就称之为 Mode Collapse。Goolfellow 曾经从不同的 KL 散度的角度解释引起 Mode Collapse 的问题，但最后发现其并非由散度的不同所导致。对于 KL 散度，其并非是对称的，即 $D_{KL} \left(p_{data} \Vert p_{model}\right)$ 与 $D_{KL} \left(p_{model} \Vert p_{data}\right)$ 是不同的。在最大化似然估计的时候使用的是前者，而在最小化 JS 散度的时候使用的更类似于后者。如下图所示

假设我们的模型 $q$ 并没有足够能能力去拟合真实数据分布 $p$，假设真实数据由两个二维的高斯分布构成，而模型需要使用一个一维的高斯分布去拟合。在左图中，模型更倾向于覆盖两个高斯分布，也就是说其更倾向与在有真实数据的地方得到更大的概率。在右图中，模型更倾向于覆盖其中一个高斯分布，也就是说其更倾向于在没有真实数据的地方取得更小的概率。这样，如果我们用 JS 散度训练模型的时候就容易出现模式缺失的问题，但尽管我们利用前者去优化模型，但结果中仍然出现了 Mode Collapse 的问题，这也就说明并非 JS 散度问题导致的 Mode Collapse。

针对 Mode Collapse 的问题，出现了大量不同角度的优化

• 基于正则化的优化 ⁸
• 基于 Minibatch 的优化 ⁹
• 基于 Unrolled Optimization 的优化 ¹⁰
• 基于集成算法的优化 ¹¹

MNIST 示例

我们利用 MNIST 数据集测试原始的 GAN 模型的效果，代码主要参考了 Keras-GAN，最终实现代码详见 image_gan_keras.py，我们简单对其核心部分进行说明。

• 生成器

  def build_generator(self):
      model = Sequential()
  
      model.add(Dense(int(self._hidden_dim / 4),
                          input_shape=self._noise_shape))
      model.add(LeakyReLU(alpha=0.2))
      model.add(BatchNormalization(momentum=0.8))
      model.add(Dense(int(self._hidden_dim / 2)))
      model.add(LeakyReLU(alpha=0.2))
      model.add(BatchNormalization(momentum=0.8))
      model.add(Dense(self._hidden_dim))
      model.add(LeakyReLU(alpha=0.2))
      model.add(BatchNormalization(momentum=0.8))
      model.add(Dense(np.prod(self._input_shape), activation='tanh'))
      model.add(Reshape(self._input_shape))
  
      print('Generator Summary: ')
      model.summary()
  
      noise = Input(shape=self._noise_shape)
      image = model(noise)
  
      return Model(noise, image)
  

在生成器中，我们使用了一个包含3个隐含层的全链接网络，其中 self._hidden_dim 是我们定义的隐含节点最多一层的节点数；self._noise_shape 为用于生成器的噪音数据的形状；self._input_shape 为输入数据形状，即图片数据的形状，中间层次采用的激活函数为 LeakyReLU，最后一层采用的激活函数为 tanh。

• 判别器

  def build_discriminator(self):
      model = Sequential()
  
      model.add(Flatten(input_shape=self._input_shape))
      model.add(Dense(int(self._hidden_dim / 2)))
      model.add(LeakyReLU(alpha=0.2))
      model.add(Dense(int(self._hidden_dim / 4)))
      model.add(LeakyReLU(alpha=0.2))
      model.add(Dense(1, activation='sigmoid'))
  
      print('Discriminator Summary: ')
      model.summary()
  
      image = Input(shape=self._input_shape)
      label = model(image)
  
      return Model(image, label)
  

在判别器中，我们使用了一个包含2个隐含层的全链接网络，中间层次采用的激活函数为 LeakyReLU，最后一层采用的激活函数为 sigmoid。

• 对抗网络

  class ImageBasicGAN():
      def __init__(self, width, height, channels,
                   a_optimizer=Adam(1e-4, beta_1=0.5),
                   g_optimizer=Adam(1e-4, beta_1=0.5),
                   d_optimizer=Adam(1e-4, beta_1=0.5),
                   noise_dim=100, hidden_dim=1024):
          '''
  
          Args:
              width: 图像宽度
              height: 图像高度
              channels: 图像颜色通道数
              a_optimizer: 对抗网络优化器
              g_optimizer: 生成器优化器
              d_optimizer: 判别器优化器
              noise_dim: 噪音数据维度
              hidden_dim: 隐含层最大维度
          '''
  
          # 省略一大坨代码
  
          # 构建和编译判别器
          self._discriminator = self.build_discriminator()
          self._discriminator.compile(loss='binary_crossentropy',
                                      optimizer=d_optimizer,
                                      metrics=['accuracy'])
  
          # 构建和编译生成器
          self._generator = self.build_generator()
          self._generator.compile(loss='binary_crossentropy',
                                  optimizer=g_optimizer)
  
          # 生成器利用噪声数据作为输入
          noise = Input(shape=self._noise_shape)
          generated_image = self._generator(noise)
  
          # 当训练整个对抗网络时，仅训练生成器
          self._discriminator.trainable = False
  
          # 判别器将生成的图像作为输入
          label = self._discriminator(generated_image)
  
          # 构建和编译整个对抗网络
          self._adversarial = Model(noise, label)
          self._adversarial.compile(loss='binary_crossentropy',
                                    optimizer=a_optimizer)
  

在构造整个对抗网络的时候，需要注意我们训练完判别器后，通过训练整个对抗网络进而训练生成器的时候是固定住训练好的判别器的，因此在训练整个对抗网络的时候我们应该将判别器置为无需训练的状态。

• 训练过程

  def train(self, x_train, output_dir, iters,
            batch_size=32, k=1, save_interval=200):
      ''' 训练模型
  
      Args:
          x_train: 训练数据
          output_dir: 相关输出路径
          iters: 迭代次数
          batch_size: 批大小
          k: K
          save_interval: 结果保存间隔
      '''
  
      # 省略一大坨代码
  
      for iter in range(iters):
          # 训练判别器
          for _ in range(k):
              train_indices = np.random.randint(0, x_train.shape[0],
                                                batch_size)
              train_images = x_train[train_indices]
  
              noises = np.random.normal(0, 1, (batch_size, self._noise_dim))
              generated_images = self._generator.predict(noises)
  
              self._discriminator.train_on_batch(train_images,
                                                 np.ones((batch_size, 1)))
              self._discriminator.train_on_batch(generated_images,
                                                 np.zeros((batch_size, 1)))
  
          # 训练生成器
          noises = np.random.normal(0, 1, (batch_size, self._noise_dim))
          labels = np.ones(batch_size)
  
          self._adversarial.train_on_batch(noises, labels)
  
      # 再省略一大坨代码
  

在训练整个对抗网络的时候，我们对于一个给定的生成器，我们将生成器生成的数据作为负样本，将从真实数据中采样的数据作为正样本训练判别器。Goodfellow 在描述 GAN 训练的过程中，对于给定的生成器，训练判别器 $k$ 次，不过通常取 $k = 1$。训练好判别器后，再随机生成噪音数据用于训练生成器，周而复始直至达到最大迭代次数。

在整个训练过程中，我们分别记录了判别器和生成器的损失的变化，以及判别器的准确率的变化，如下图所示：

从上图中我们可以看出，在训练开始阶段，判别器能够相对容易的识别出哪些数据是来自于真实数据的采样，哪些数据是来自于生成器的伪造数据。随着训练的不断进行，判别器的准确率逐渐下降，并稳定在 60% 左右，也就是说生成器伪造的数据越来越像真实的数据，判别器越来越难进行甄别。

下图中我们展示了利用 MNIST 数据集，进行 30000 次的迭代，每 1000 次截取 100 张生成器利用相同噪音数据伪造的图像，最后合成的一张生成图片的变化动图。

Deep Convolutional GAN

DCGAN (Deep Convolutional GAN) 是由 Radford ⁶ 等人提出的一种对原始 GAN 的变种，其基本的思想就是将原始 GAN 中的全链接层用卷积神经网络代替。在文中，Radford 等人给出构建一个稳定的 DCGAN 的建议，如下：

• 在网络中不使用 pooling 层，而是使用多步长的卷积层 (判别器) 和多步长的反卷积层 (生成器)。
• 在生成器和判别器中均使用批标准化。
• 对于深层的框架，去掉全链接层。
• 在生成器中使用 ReLU 激活函数，最后一层使用 Tanh 激活函数。
• 在判别器中使用 LeakyReLU 激活函数。

我们利用 MNIST 数据集测试 DCGAN 模型的效果，最终实现代码详见 image_dcgan_keras.py。训练过程中判别器和生成器的损失的变化，以及判别器的准确率的变化，如下图所示：

下图中我们展示了利用 MNIST 数据集，进行 30000 次的迭代，每 1000 次截取 100 张生成器利用相同噪音数据伪造的图像，最后合成的一张生成图片的变化动图。

从生成的结果中可以看出，DCGAN 生成的图片的质量还是优于原始的 GAN 的，在原始的 GAN 中我们能够明显的看出其中仍旧包含大量的噪音点，而在 DCGAN 中这种情况几乎不存在了。