Skip to content

M
mtbookv2
Commit 1d2b410c by zengxin
Options

合并分支 'caorunzhe' 到 'zengxin' 

Caorunzhe

查看合并请求 !793
parents 35c8bb91 9a27b499
正在显示 包含 1300 行增加 和 294 行删除
Chapter13/Figures/figure-framework-of-Adversarial-Neural-machine-translation.tex
......@@ -4,25 +4,25 @@
\begin{tikzpicture}
\tikzstyle{rnnnode} = [draw,inner sep=2pt,minimum width=4em,minimum height=2em,rounded corners=1pt,fill=yellow!20]
\tikzstyle{snode} = [draw,inner sep=2pt,minimum width=4em,minimum height=2em,rounded corners=1pt,fill=red!20]
\tikzstyle{wode} = [inner sep=0pt,minimum width=4em,minimum height=2em,rounded corners=0pt]
\node [anchor=west,wode] (n1) at (0,0) {${y}_1,{y}_2,\ldots,{y}_n$};
\node [anchor=north west,wode] (n2) at ([xshift=1em,yshift=0.5em]n1.south east) {${x}_1,{x}_2,\ldots,{x}_m$};
\node [anchor=south west,rnnnode] (n3) at ([xshift=8em,yshift=0.5em]n2.north east) {生成模型G};
\node [anchor=south east,wode] (n4) at ([xshift=-2em,yshift=0em]n3.north west) {$\tilde{{y}}_{1},\tilde{{y}}_{2},...,\tilde{{y}}_{J}$};
\node [anchor=south,snode] (n5) at ([xshift=0em,yshift=6em]n2.north) {判别网络D};
\tikzstyle{rnnnode} = [draw,inner sep=4pt,minimum width=2em,minimum height=2em,rounded corners=1pt,fill=yellow!20]
\tikzstyle{snode} = [draw,inner sep=4pt,minimum width=2em,minimum height=2em,rounded corners=1pt,fill=red!20]
\tikzstyle{wode} = [inner sep=0pt,minimum width=2em,minimum height=2em,rounded corners=0pt]
\node [anchor=west,wode] (n1) at (0,0) {$y$};
\node [anchor=north west,wode] (n2) at ([xshift=3em,yshift=-2.5em]n1.south east) {$x$};
\node [anchor=south west,rnnnode] (n3) at ([xshift=8em,yshift=0.5em]n2.north east) {生成模型$G$};
\node [anchor=south east,wode] (n4) at ([xshift=-2em,yshift=0em]n3.north west) {$\tilde{y}$};
\node [anchor=south,snode] (n5) at ([xshift=0em,yshift=6em]n2.north) {判别网络$D$};
\node [anchor=west,align=left,font=\small] (n6) at ([xshift=15em,yshift=-3em]n5.east) {根据$(\seq{x},\seq{\tilde{y}})$生\\成奖励信号};
\draw [->,thick] ([xshift=0em,yshift=0em]n1.north)--([xshift=0em,yshift=0em]n5.south);
\draw [->,thick] ([xshift=0em,yshift=0em]n2.north)--([xshift=0em,yshift=0em]n5.south);
\draw [->,thick] ([xshift=0em,yshift=0em]n4.west)--([xshift=0em,yshift=0em]n5.south);
\draw [->,thick] ([xshift=0em,yshift=-0.3em]n1.north)--([xshift=-0.3em,yshift=-0.1em]n5.south);
\draw [->,thick] ([xshift=0em,yshift=0em]n2.north)--([xshift=0em,yshift=-0.1em]n5.south);
\draw [->,thick] ([xshift=0em,yshift=-0.5em]n4.north west)--([xshift=0.3em,yshift=-0.1em]n5.south);
\draw [->,thick] ([xshift=0em,yshift=0em]n3.north)--([xshift=0em,yshift=1em]n3.north)--([xshift=0em,yshift=0em]n4.east);
\draw [->,thick] ([xshift=0em,yshift=0em]n5.east) -- ([xshift=14.5em,yshift=0em]n5.east) -- ([xshift=1em,yshift=0em]n3.east) -- ([xshift=0em,yshift=0em]n3.east);
\draw [->,thick] ([xshift=0em,yshift=0em]n5.east) -- ([xshift=12.9em,yshift=0em]n5.east) -- ([xshift=1em,yshift=0em]n3.east) -- ([xshift=0em,yshift=0em]n3.east);
\draw [->,thick] ([xshift=0em,yshift=0em]n2.east) -- ([xshift=0em,yshift=-1.5em]n3.south) -- ([xshift=0em,yshift=0em]n3.south);
......
Chapter13/Figures/figure-of-scheduling-sampling-method.tex
......@@ -31,9 +31,9 @@
\node [anchor=south,inner sep=2pt] (st2) at (n8.north) {\scriptsize{\textbf{[step $j$]}}};
\node [anchor=south,inner sep=2pt] (st3) at (n14.north) {\scriptsize{\textbf{[step $1$]}}};
\node [anchor=north,font=\tiny,rotate=90] (e1) at ([xshift=-2.7em,yshift=-1.1em]n3.south) {${(1-\epsilon_i)}^2$};
\node [anchor=north,font=\tiny,rotate=90] (e1) at ([xshift=-2.7em,yshift=-1.1em]n3.south) {${1-\epsilon_i}$};
%\node [anchor=north,font=\scriptsize] (e2) at ([xshift=2em,yshift=-0.1em]n3.south) {$\funp{P}=\epsilon_i$};
%\node [anchor=north,font=\scriptsize] (e3) at ([xshift=-2em,yshift=-1em]n4.south) {$\funp{P}={(1-\epsilon_i)}^2$};
%\node [anchor=north,font=\scriptsize] (e3) at ([xshift=-2em,yshift=-1em]n4.south) {$\funp{P}={1-\epsilon_i}$};
\node [anchor=north,font=\tiny,rotate=90] (e4) at ([xshift=1.5em,yshift=-1.2em]n4.south) {$\epsilon_i$};
%\node [anchor=south east,font=\small] (l1) at ([xshift=-1em,yshift=0.5em]n5.north west) {Loss};
......
Chapter13/Figures/figure-reinforcement-learning-method-based-on-actor-critic.tex
\begin{tikzpicture}
\node[anchor=west,inner sep=0mm,minimum height=4em,minimum width=5.5em,rounded corners=15pt,align=left,draw] (n1) at (0,0) {Decoder\\Encoder};
\node[anchor=west,inner sep=0mm,minimum height=4em,minimum width=5.5em,rounded corners=15pt,align=left,draw,fill=red!20] (n1) at (0,0) {Decoder\\Encoder};
\node[anchor=west,inner sep=0mm,minimum height=4em,minimum width=5.5em,rounded corners=15pt,align=left,draw] (n2) at ([xshift=10em,yshift=0em]n1.east) {Decoder\\Encoder};
\node[anchor=west,inner sep=0mm,minimum height=4em,minimum width=5.5em,rounded corners=15pt,align=left,draw,fill=green!20] (n2) at ([xshift=10em,yshift=0em]n1.east) {Decoder\\Encoder};
\node[anchor=south,inner sep=0mm,font=\small] (a1) at ([xshift=0em,yshift=1em]n1.north) {演员$p_{\theta}$};
\node[anchor=south,inner sep=0mm,font=\small] (a1) at ([xshift=0em,yshift=1em]n1.north) {演员$p$};
\node[anchor=north,inner sep=0mm] (a2) at ([xshift=0em,yshift=-1em]n1.south) {${x}_1,{x}_2,\ldots,{x}_m$};
\node[anchor=north,inner sep=0mm] (a2) at ([xshift=0em,yshift=-1em]n1.south) {$x$};
\node[anchor=south,inner sep=0mm,font=\small] (c1) at ([xshift=0em,yshift=1em]n2.north) {评论家$Q$};
\node[anchor=north,inner sep=0mm] (c2) at ([xshift=0em,yshift=-1em]n2.south) {${y}_1,{y}_2,\ldots,{y}_J$};
\node[anchor=north,inner sep=0mm] (c2) at ([xshift=0em,yshift=-1em]n2.south) {$y$};
% \node[anchor=west,inner sep=0mm] (n3) at ([xshift=2.1em,yshift=2em]n1.east) {$Q_1,Q_2,\ldots,Q_J$};
% \node[anchor=west,inner sep=0mm] (n4) at ([xshift=2.9em,yshift=-0.4em]n1.east) {$\hat{\mathbi{y}}_1,\hat{\mathbi{y}}_2,\ldots,\hat{\mathbi{y}}_J$};
......@@ -27,8 +27,8 @@
\node[anchor=west,inner sep=0mm] (n3) at ([xshift=2.1em,yshift=1em]n1.east) {$Q_1,Q_2,\ldots,Q_J$};
\node[anchor=west,inner sep=0mm] (n4) at ([xshift=2.9em,yshift=-1em]n1.east) {$\tilde{{y}}_1,\tilde{{y}}_2,\ldots,\tilde{{y}}_J$};
\draw [->,thick] ([xshift=0em,yshift=0.2em]n2.west) -- ([xshift=0em,yshift=0.2em]n1.east);
\draw [->,thick] ([xshift=0em,yshift=-0.2em]n1.east) -- ([xshift=0em,yshift=-0.2em]n2.west);
\draw [->,thick] ([xshift=-0.1em,yshift=0.6em]n2.west) -- ([xshift=0.1em,yshift=0.6em]n1.east);
\draw [->,thick] ([xshift=0.1em,yshift=-0.6em]n1.east) -- ([xshift=-0.1em,yshift=-0.6em]n2.west);
\end{tikzpicture}
\ No newline at end of file
Chapter13/chapter13.tex
......@@ -459,7 +459,7 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\subsection{非Teacher-forcing方法}
\parinterval 所谓Teacher-forcing，即要求模型预测的结果和标准答案完全对应。Teacher-forcing是一种深度学习训练策略，在序列处理任务上被广泛使用（{\color{red} deep learning}）。以序列生成任务为例，Teacher-forcing要求模型在训练时不是使用上一个时刻的模型输出作为下一个时刻的输入，而是使用训练数据中上一时刻的标准答案作为下一个时刻的输入。显然这会导致曝光偏置问题。为了解决这个问题，可以使用非Teacher-forcing方法，主要包括调度采样和生成对抗网络。
\parinterval 所谓Teacher-forcing，即要求模型预测的结果和标准答案完全对应。Teacher-forcing是一种深度学习训练策略，在序列处理任务上被广泛使用（{\color{red} deep learning}）。以序列生成任务为例，Teacher-forcing要求模型在训练时不是使用上一个时刻的模型输出作为下一个时刻的输入，而是使用训练数据中上一时刻的标准答案作为下一个时刻的输入。显然这会导致曝光偏置问题。为了解决这个问题，可以使用非Teacher-forcing方法。比如，在训练中使用束搜索，这样可以让训练过程模拟推断时的行为。具体来说，非Teacher-forcing方法可以用调度采样和生成对抗网络进行实现。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -467,9 +467,7 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\subsubsection{1. 调度采样}
\parinterval 对于曝光偏置问题，一般可以使用束搜索等启发式搜索方法来进行缓解。也就是，训练过程可以模拟推断时的行为。
\parinterval 对于一个目标序列$\seq{y}=\{{y}_1,{y}_2,\ldots,{y}_n\}$，在预测第$j$个单词${y}_j$时，训练过程与推断过程之间的主要区别在于：训练过程中使用标准答案$\{{y}_{1},...,{y}_{j-1}\}$，而推断过程使用的是来自模型本身的预测结果$\{\tilde{{y}}_{1},...,\tilde{{y}}_{j-1}\}$。此时可以采取一种{\small\bfnew{调度采样}}\index{调度采样}（Scheduled Sampling\index{Scheduled Sampling}）机制（{\color{red} Scheduled Sampling for Sequence Prediction with Recurrent Neural Networks}），在训练中随机决定使用${y}_{j-1}$还是$\tilde{{y}}_{j-1}$。 假设训练时使用的是基于小批量的随机梯度下降方法，在第$i$ 个批次中，对序列每一个位置进行预测时以概率$\epsilon_i$使用标准答案，或以概率${(1-\epsilon_i)}^2$使用来自模型本身的预测。具体到序列中的一个位置$j$，可以根据模型单词预测的概率进行采样，在$\epsilon_i$控制的调度策略下，同${y}_{j-1}$一起作为输入。此过程如图\ref{fig:13-22}所示，并且这个过程可以很好地与束搜索融合。
\parinterval 对于一个目标序列$\seq{y}=\{{y}_1,\ldots,{y}_n\}$，在预测第$j$个单词${y}_j$时，训练过程与推断过程之间的主要区别在于：训练过程中使用标准答案$\{{y}_{1},...,{y}_{j-1}\}$，而推断过程使用的是来自模型本身的预测结果$\{\tilde{{y}}_{1},...,\tilde{{y}}_{j-1}\}$。此时可以采取一种{\small\bfnew{调度采样}}\index{调度采样}（Scheduled Sampling\index{Scheduled Sampling}）机制（{\color{red} Scheduled Sampling for Sequence Prediction with Recurrent Neural Networks}），在训练中随机决定使用${y}_{j-1}$还是$\tilde{{y}}_{j-1}$。 假设训练时使用的是基于小批量的随机梯度下降方法，在第$i$ 个批次中，对序列每一个位置进行预测时以概率$\epsilon_i$使用标准答案，或以概率${1-\epsilon_i}$使用来自模型本身的预测。具体到序列中的一个位置$j$，可以根据模型单词预测的概率进行采样，在$\epsilon_i$控制的调度策略下，同${y}_{j-1}$一起作为输入。此过程如图\ref{fig:13-22}所示，并且这个过程可以很好地与束搜索融合。
%----------------------------------------------
\begin{figure}[htp]
......@@ -501,9 +499,9 @@ Translation}嚗砲蝑霈支蛹摮虫砲敺芸蝘
\subsubsection{2. 生成对抗网络}
\parinterval 调度采样解决曝光偏置的方法是：把模型历史预测的结果作为输入，并用于预测下一时刻的输出。但是，如果模型预测的结果中有错误，再使用错误的结果预测未来的序列也会产生问题。这里面的核心问题是，如何知道模型预测的好与坏，进而在训练中有效的使用它们。如果生成好的结果，那么可以使用它进行模型训练，否则就不使用。生成对抗网络就是这样一种技术，它引入了一个额外的模型（判别器）来对原有模型（生成器）的生成结果进行评价，并根据评价结果同时训练两个模型。
\parinterval 调度采样解决曝光偏置的方法是：把模型前$j-1$步的预测结果作为输入预测第$j$步的输出。但是，如果模型预测的结果中有错误，再使用错误的结果预测未来的序列也会产生问题。这里面的核心问题是，如何知道模型预测的好与坏，进而在训练中有效的使用它们。如果生成好的结果，那么可以使用它进行模型训练，否则就不使用。生成对抗网络就是这样一种技术，它引入了一个额外的模型（判别器）来对原有模型（生成器）的生成结果进行评价，并根据评价结果同时训练两个模型。
\parinterval 在\ref{sec:adversarial-examples}小节已经提到了生成对抗网络，这里进行一些展开。 在机器翻译中，基于对抗神经网络的架构被命名为{\small\bfnew{对抗神经机器翻译}}\index{对抗神经机器翻译}（Adversarial-NMT）\index{Adversarial-NMT}（{\color{red} Adversarial Neural Machine Translation}）。对于训练用双语句对$(\seq{x},\seq{y})=(\{{x}_1,{x}_2,\ldots,{x}_m\},\{{y}_1,{y}_2,\ldots,{y}_n\})$，其中${x}_i$ 是源句子中的第$i$个单词的表示向量，${y}_j$是目标句子中的第$j$个单词的表示向量。令$\tilde{\seq{y}} = \{\tilde{{y}}_{1},\tilde{{y}}_{2},...,\tilde{{y}}_{J}\}$表示神经机器翻译系统对源语言句子$\seq{x}$的翻译结果。此时，对抗神经机器翻译的总体框架可以表示为图\ref{fig:13-23}，其中。黄色部分表示神经机器翻译模型$G$，该模型将源语言句子$\seq{x}$映射为目标语言句子。红色部分是对抗网络$D$，该网络预测目标语言句子是否是源语言句子$\seq{x}$的真实翻译。$G$和$D$相互对抗，同时生成翻译结果$\tilde{\seq{y}}$来训练$D$，并生成奖励信号来通过策略梯度训练$G$。
\parinterval 在\ref{sec:adversarial-examples}小节已经提到了生成对抗网络，这里进行一些展开。 在机器翻译中，基于对抗神经网络的架构被命名为{\small\bfnew{对抗神经机器翻译}}\index{对抗神经机器翻译}（Adversarial-NMT）\index{Adversarial-NMT}（{\color{red} Adversarial Neural Machine Translation}）。这里，令$(\seq{x},\seq{y})$表示一个训练样本，，令$\tilde{\seq{y}}$ 表示神经机器翻译系统对源语言句子$\seq{x}$ 的翻译结果。此时，对抗神经机器翻译的总体框架可以表示为图\ref{fig:13-23}，其中。黄色部分表示神经机器翻译模型$G$，该模型将源语言句子$\seq{x}$翻译为目标语言句子$\tilde{\seq{y}}$。红色部分是对抗网络$D$，它的作用是判断目标语言句子是否是源语言句子$\seq{x}$ 的真实翻译。$G$ 和$D$相互对抗，同时生成翻译结果$\tilde{\seq{y}}$来训练$D$，并生成奖励信号来通过策略梯度训练$G$。
%----------------------------------------------
\begin{figure}[htp]
......@@ -516,52 +514,55 @@ Translation}嚗砲蝑霈支蛹摮虫砲敺芸蝘
\parinterval 实际上，对抗神经机器翻译的训练目标就是强制$\tilde{\seq{y}}$ 与$\seq{y}$ 相似。在理想情况下，$\tilde{\seq{y}}$与人类标注的答案$\seq{y}$非常相似，以至于人类也无法分辨$\tilde{\seq{y}}$是由机器还是人类产生的。
\parinterval 为了实现这一目标，需要引入一个额外的对抗网络\upcite{DBLP:conf/nips/GoodfellowPMXWOCB14}。在这个框架中，原始的神经机器翻译模型为生成网络，其训练由对抗网络协助。对抗网络的目标是将神经机器翻译模型生成的翻译结果与人的翻译结果区分开，而生成网络的目标是产生高质量的翻译，以欺骗对抗网络。生成网络和对抗网络作为对手，由策略梯度方法来共同训练。为了使得生成网络和对抗网络能够提高彼此性能，可以通过学习人为产生的正例和从神经机器翻译取得的负例来提高对手的辨别力。通过这种方式，神经机器翻译的结果可以尽可能接近真实答案。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
%----------------------------------------------------------------------------------------
\subsection{强化学习方法}
\parinterval {\small\bfnew{强化学习}}\index{强化学习}（Reinforcement Learning，RL\index{Reinforcement Learning，RL}）方法是机器学习中的经典方法，它可以同时解决\ref{subsec-15.3.1}节提到的曝光偏置问题和训练- 推断评价指标不一致问题。本节主要介绍基于策略的方法和基于演员-评论家的方法（{\color{red} An Actor-Critic Algorithm for Sequence Prediction}）。
\parinterval {\small\bfnew{强化学习}}\index{强化学习}（Reinforcement Learning，RL\index{Reinforcement Learning，RL}）方法是机器学习中的经典方法，它可以同时解决\ref{subsec-15.3.1}节提到的曝光偏置问题和训练- 推断评价指标不一致问题。本节主要介绍基于策略的方法和基于演员-评论家的强化学习方法（{\color{red} An Actor-Critic Algorithm for Sequence Prediction}）。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{1. 基于策略的强化学习方法}
\subsubsection{1. 基于策略的方法}
\parinterval {\small\bfnew{最小风险训练}}\index{最小风险训练}（Minimum Risk Training\index{Minimum Risk Training}，MRT）可以被看作是一种基于策略的方法。与极大似然估计不同，最小风险训练引入了评价指标作为损失函数，并优化模型将预期风险降至最低\upcite{DBLP:conf/acl/ShenCHHWSL16}。
\parinterval 假设有$N$个训练样本$\{(x^1,y^1),...,(x^N,y^N)\}$，最小风险训练的目标是找到模型参数$\hat{\theta}_{\textrm{MRT}} $，满足如下公式：
\parinterval {\small\bfnew{最小风险训练}}\index{最小风险训练}（Minimum Risk Training\index{Minimum Risk Training}，MRT）可以被看作是一种基于策略的方法。与传统的极大似然估计不同，最小风险训练引入了评价指标作为损失函数，目标是将模型的预期风险降至最低，这里预期风险通常用风险函数的期望表示\upcite{DBLP:conf/acl/ShenCHHWSL16}。
\begin{eqnarray}
\hat{\theta}_{\textrm{MRT}} & = & \arg\max_{\theta}\{\funp{R}(\theta)\} \label{eq:13-13a}
\end{eqnarray}
\parinterval 最小风险训练的训练目标是最小化训练数据$\{(x_1,\widetilde{y}_1),...,(x_N,\widetilde{y}_N)\}$上的风险$\funp{R}(\theta)$，如公式\eqref{eq:13-13}所示：
\noindent 其中，$\funp{R}(\theta)$表示预期风险，通常用风险函数的期望表示，公式如下：
\begin{eqnarray}
\hat{\theta}_{\textrm{MRT}} & = & \arg\max_{\theta}\{\funp{R}(\theta)\} \\
\funp{R}(\theta) & = & \sum_{k=1}^N \mathbb{E}_{\tilde{\seq{y}}|\seq{x}_k;\theta}[\vartriangle(\tilde{\seq{y}},\seq{y}_k)] \nonumber \\
& = & \sum_{k=1}^N \sum_{\tilde{\seq{y}} \in \chi(\seq{x}_k)}\funp{P}(\tilde{\seq{y}}|\seq{x}_k;\theta)\vartriangle(\tilde{\seq{y}},\seq{y}_k)
\funp{R}(\theta) & = & \sum_{k=1}^N \mathbb{E}_{\tilde{\seq{y}}|\seq{x}^k;\theta}[\vartriangle(\tilde{\seq{y}},\seq{y}^k)] \nonumber \\
& = & \sum_{k=1}^N \sum_{\tilde{\seq{y}} \in \chi(\seq{x}^k)}\funp{P}(\tilde{\seq{y}}|\seq{x}^k;\theta)\vartriangle(\tilde{\seq{y}},\seq{y}^k)
\label{eq:13-13}
\end{eqnarray}
\noindent 这里，$\tilde{\seq{y}}$是模型预测的译文，$\chi(\seq{x}_k)$是$\seq{x}_k$所对应的所有候选翻译的集合，损失函数$\vartriangle(\tilde{\seq{y}},\seq{y}_k)$用来衡量模型预测$\tilde{\seq{y}}$与标准答案$\seq{y}_k$间的差异，损失函数一般用翻译质量评价指标定义，例如，BLEU，TER等。在MRT中，对模型参数$\theta$的偏导数公式\eqref{eq:13-14}所示，
\noindent 这里，$\tilde{\seq{y}}$是模型预测的译文，$\chi(\seq{x}^k)$是$\seq{x}^k$所对应的所有候选翻译的集合。损失函数$\vartriangle(\tilde{\seq{y}},\seq{y}^k)$用来衡量模型预测$\tilde{\seq{y}}$与标准答案$\seq{y}^k$间的差异，损失函数一般用翻译质量评价指标定义，例如，BLEU，TER等。在最小风险训练中，对模型参数$\theta$的偏导数为：
\begin{eqnarray}
\frac{\partial \funp{R}(\theta)}{\partial \theta} & = & \sum_{k=1}^N \mathbb{E}_{\tilde{\seq{y}}|\seq{x}_k;\theta}[\vartriangle(\tilde{\seq{y}},\seq{y}_k) \times \frac{\partial \funp{P}(\tilde{\seq{y}}|\seq{x}_k;\theta)/\partial \theta}{\funp{P}(\tilde{\seq{y}}|\seq{x}_k;\theta)}]
\frac{\partial \funp{R}(\theta)}{\partial \theta} & = & \sum_{k=1}^N \mathbb{E}_{\tilde{\seq{y}}|\seq{x}^k;\theta}[\vartriangle(\tilde{\seq{y}},\seq{y}^k) \times \frac{\partial \funp{P}(\tilde{\seq{y}}|\seq{x}^k;\theta)/\partial \theta}{\funp{P}(\tilde{\seq{y}}|\seq{x}^k;\theta)}]
\label{eq:13-14}
\end{eqnarray}
\noindent 公式\eqref{eq:13-14}使用了{\small\bfnew{策略梯度}}\index{策略梯度}（Policy Gradient\index{Policy Gradient}）的手段将$\vartriangle(\tilde{\seq{y}},\seq{y}_k)$提到微分操作之外（{\color{red} A natural policy gradient
Where did my optimum go?: An empiricalanalysis of gradient descent optimization in policy gradient methods}）。这样，就无需对$\vartriangle(\tilde{\seq{y}},\seq{y}_k)$进行微分，因此最小风险训练允许任意不可微的损失函数，包括BLEU等常用的评价函数。
\noindent 公式\eqref{eq:13-14}使用了{\small\bfnew{策略梯度}}\index{策略梯度}（Policy Gradient\index{Policy Gradient}）的手段将$\vartriangle(\tilde{\seq{y}},\seq{y}^k)$提到微分操作之外（{\color{red} A natural policy gradient
Where did my optimum go?: An empiricalanalysis of gradient descent optimization in policy gradient methods}）。这样，就无需对$\vartriangle(\tilde{\seq{y}},\seq{y}^k)$进行微分，因此最小风险训练允许任意不可微的损失函数，包括BLEU等常用的评价函数。使用公式\eqref{eq:13-14}就可以求出模型参数的相对于风险函数的损失，进而进行基于梯度的优化。这里需要注意的是，公式\eqref{eq:13-14}中求期望的过程是无法直接实现的，因为无法遍历所有的译文句子。通常，会使用采样的方法搜集一定数量的译文，来模拟译文空间。例如，可以使用推断系统生成若干译文。同时，为了保证生成的译文之间具有一定的差异性，也可以对推断过程进行一些“干扰”。从实践的角度看，采样方法是影响强化学习系统的重要因素，因此往往需要对不同的任务设计相适应的采样方法（{\color{red} 参考文献！我记得李炎洋以前写过一个文章介绍采样方法，可以问问他，或者在这里再多说两句，采样还是很重要的。}）。
\parinterval 相比于最大似然估计，最小风险训练有着以下优点：
\begin{itemize}
\vspace{0.5em}
\item 最小风险训练通过使用模型自身产生的数据进行训练，从而解决了曝光偏置问题。
\item 最小风险训练使用模型自身产生的数据进行训练，从而避免了曝光偏置问题。
\vspace{0.5em}
\item 最小风险训练通过直接优化BLEU等评价指标，从而解决了训练-推断评价指标不一致问题。
\item 最小风险训练直接优化BLEU等评价指标，从而解决了训练-推断评价指标不一致问题。
\vspace{0.5em}
\item 最小风险训练方法只涉及到模型输出而不涉及具体的模型结构，因此其对体系结构是透明的，可以应用于任意的机器翻译模型。
\item 最小风险训练方法不涉及具体的模型结构，可以应用于任意的机器翻译模型。
\vspace{0.5em}
\end{itemize}
......@@ -569,34 +570,36 @@ Where did my optimum go?: An empiricalanalysis of gradient descent optimization
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{2. 基于演员-评论家的强化学习方法}
\subsubsection{2. 演员-评论家方法}
\parinterval 基于策略的强化学习是要寻找一个策略$\funp{p}(a|\tilde{{y}}_{1 \ldots j},\seq{x})$，使得该策略选择的行动$a$未来可以获得的奖励期望（也被称为{\small\bfnew{动作价值函数}}\index{动作价值函数}（Action-value Function）\index{Action-value Function}）最大化。这个过程通常用函数$Q$来描述：
\begin{eqnarray}
\funp{Q}(a;\tilde{\mathbi{y}}_{1 \ldots j},\seq{y}) & = & \mathbb{E}_{\tilde{\mathbi{y}}_{j+1 \ldots J} \sim \funp{p}(a|\tilde{\mathbi{y}}_{1 \ldots j} a,\seq{x})}[\funp{r}_j(a;\tilde{\mathbi{y}}_{1 \ldots j-1},\seq{y}) + \nonumber \\
& & \sum_{i=j+1}^J\funp{r}_i(\tilde{{y}}_i;\tilde{{y}}_{1 \ldots i-1}a\tilde{{y}}_{j+1 \ldots i},\seq{y})]
\funp{Q}(a;\tilde{y}_{1 \ldots j},\seq{y}) & = & \mathbb{E}_{\tilde{y}_{j+1 \ldots J} \sim \funp{p}(a|\tilde{y}_{1 \ldots j} a,\seq{x})}[\funp{r}_j(a;\tilde{y}_{1 \ldots j-1},\seq{y}) + \nonumber \\
& & \sum_{i=j+1}^J\funp{r}_i(\tilde{{y}}_i;\tilde{{y}}_{1 \ldots j-1}a\tilde{{y}}_{j+1 \ldots i-1},\seq{y})]
\label{eq:13-35}
\end{eqnarray}
\noindent 其中，$\funp{r}_j(a;\tilde{{y}}_{1 \ldots j-1},\seq{y})$是$j$时刻做出行动$a$获得的奖励，$\seq{x}$是源语言句子，$\seq{y}$是正确译文，$\tilde{{y}}_{1 \ldots j}$是策略$\funp{p}$产生的译文的前$j$个词，$J$是生成译文的长度。其（在一个源语句子$x$上的）定义的目标为：
\noindent 其中，$\funp{r}_j(a;\tilde{{y}}_{1 \ldots j-1},\seq{y})$是$j$时刻做出行动$a$获得的奖励，$\funp{r}_i(\tilde{{y}}_i;\tilde{{y}}_{1 \ldots j-1}a\tilde{{y}}_{j+1 \ldots i-1},\seq{y})$是$j$时刻的行动为$a$的前提下$i$时刻的做出行动$\tilde{{y}}_i$获得的奖励。$\seq{x}$是源语言句子，$\seq{y}$是正确译文，$\tilde{{y}}_{1 \ldots j}$是策略$\funp{p}$产生的译文的前$j$个词，$J$是生成译文的长度。对于源语句子$x$，最优策略$\hat{p}$可以被定义为：
\begin{eqnarray}
\hat{p} & = & \max_{\funp{p}}\mathbb{E}_{\tilde{\seq{y}} \sim \funp{p}(\tilde{\seq{y}} | \seq{x})}\sum_{j=1}^J\sum_{a \in A}\funp{p}(a|\tilde{{y}}_{1 \ldots j},\seq{x})\funp{Q}(a;\tilde{{y}}_{1 \ldots j},\seq{y})
\hat{p} & = & \argmax_{\funp{p}}\mathbb{E}_{\tilde{\seq{y}} \sim \funp{p}(\tilde{\seq{y}} | \seq{x})}\sum_{j=1}^J\sum_{a \in A}\funp{p}(a|\tilde{{y}}_{1 \ldots j},\seq{x})\funp{Q}(a;\tilde{{y}}_{1 \ldots j},\seq{y})
\label{eq:13-15}
\end{eqnarray}
\noindent 其中，$A$表示所有可能的行动组成的空间，也就是词表$V$。公式\eqref{eq:13-15}的含义是，计算动作价值函数$\funp{Q}$需要枚举$j$时刻以后所有可能的序列，而可能的序列数目是随着其长度呈指数级增长，因此只能估计的方法计算$\funp{Q}$的值。基于策略的强化学习方法，如最小风险训练（风险$\vartriangle=-\funp{Q}$）等都使用了采样的方法来估计$\funp{Q}$。尽管采样估计的结果是$\funp{Q}$的无偏估计，但是它的缺点在于估计的方差比较大。而$\funp{Q}$直接关系到梯度更新的大小，不稳定的数值会导致模型更新不稳定，难以优化。
\noindent 其中，$A$表示所有可能的行动组成的空间，也就是词表$V$。公式\eqref{eq:13-15}的含义是，最优策略$\hat{p}$的选择需要同时考虑当前决策的“信心”（即$\funp{p}(a|\tilde{{y}}_{1 \ldots j},\seq{x})$）和未来可以获得的“价值”（即$\funp{Q}(a;\tilde{{y}}_{1 \ldots j},\seq{y})$）。
\parinterval 为了避免采样的开销和随机性带来的不稳定，基于{\small\bfnew{演员-评论家}}\index{演员-评论家}（Actor-critic\index{Actor-critic}）的强化学习方法\upcite{DBLP:conf/iclr/BahdanauBXGLPCB17}引入一个可学习的函数$\tilde{\funp{Q}}$，通过函数$\tilde{\funp{Q}}$来逼近动作价值函数$\funp{Q}$。但是由于$\tilde{\funp{Q}}$是人工设计的一个函数，该函数有着自身的偏置，因此$\tilde{\funp{Q}}$不是$\funp{Q}$的一个无偏估计，所以使用$\tilde{\funp{Q}}$来指导$\funp{p}$的优化无法到达理论上的最优解。尽管如此，得益于神经网络强大的拟合能力，基于演员-评论家的强化学习方法仍更具优势。
\parinterval 计算动作价值函数$\funp{Q}$需要枚举$j$时刻以后所有可能的序列，而可能的序列数目是随着其长度呈指数级增长，因此只能估计的方法计算$\funp{Q}$的值。基于策略的强化学习方法，如最小风险训练（风险$\vartriangle=-\funp{Q}$）等都使用了采样的方法来估计$\funp{Q}$。尽管采样估计的结果是$\funp{Q}$的无偏估计，但是它的缺点在于估计的方差比较大。而$\funp{Q}$直接关系到梯度更新的大小，不稳定的数值会导致模型更新不稳定，难以优化。
\parinterval 对于基于演员-评论家的强化学习方法，演员就是策略$\funp{p}$，而评论家就是动作价值函数$\funp{Q}$的估计$\tilde{\funp{Q}}$。对于演员，它的目标函数如下：
\parinterval 为了避免采样的开销和随机性带来的不稳定，基于{\small\bfnew{演员-评论家}}\index{演员-评论家}（Actor-critic\index{Actor-critic}）的强化学习方法引入一个可学习的函数$\tilde{\funp{Q}}$，通过函数$\tilde{\funp{Q}}$来逼近动作价值函数$\funp{Q}$\upcite{DBLP:conf/iclr/BahdanauBXGLPCB17}。但是由于$\tilde{\funp{Q}}$是人工设计的一个函数，该函数有着自身的偏置，因此$\tilde{\funp{Q}}$不是$\funp{Q}$的一个无偏估计，所以使用$\tilde{\funp{Q}}$来指导$\funp{p}$的优化无法到达理论上的最优解。尽管如此，得益于神经网络强大的拟合能力，基于演员-评论家的强化学习方法在实践中仍然非常流行。
\parinterval 对于基于演员-评论家的强化学习方法，演员就是策略$\funp{p}$，而评论家就是动作价值函数$\funp{Q}$的估计$\tilde{\funp{Q}}$。对于演员，它的目标是找到最有的决策：
\begin{eqnarray}
\hat{p} & = & \max_{\funp{p}}\mathbb{E}_{\tilde{\seq{y}} \sim \funp{p}(\tilde{\seq{y}} | \seq{x})}\sum_{j=1}^J\sum_{a \in A}\funp{p}(a|\tilde{{y}}_{1 \ldots j},\seq{x})\tilde{\funp{Q}}(a;\tilde{{y}}_{1 \ldots j},\seq{y})
\hat{p} & = & \argmax_{\funp{p}}\mathbb{E}_{\tilde{\seq{y}} \sim \funp{p}(\tilde{\seq{y}} | \seq{x})}\sum_{j=1}^J\sum_{a \in A}\funp{p}(a|\tilde{{y}}_{1 \ldots j},\seq{x})\tilde{\funp{Q}}(a;\tilde{{y}}_{1 \ldots j},\seq{y})
\label{eq:13-16}
\end{eqnarray}
\parinterval 与公式\eqref{eq:13-15}对比可以发现，基于演员-评论家的强化学习方法与基于策略的强化学习方法类似，公式\eqref{eq:13-16}对动作价值函数$\funp{Q}$的估计从采样换成了一个函数$\tilde{\funp{Q}}$。对于目标函数里的期望，通常使用采样对方式来进行逼近，例如，选择一定量的$\tilde{y}$来计算期望，而不是遍历所有的$\tilde{y}$。借助与最小风险训练类似的方法，可以计算对$\funp{p}$的梯度来优化演员。
\parinterval 与公式\eqref{eq:13-15}对比可以发现，基于演员-评论家的强化学习方法与基于策略的强化学习方法类似，公式\eqref{eq:13-16}对动作价值函数$\funp{Q}$的估计从采样换成了一个函数$\tilde{\funp{Q}}$。对于目标函数里期望的计算，通常使用采样的方式来进行逼近，这与最小风险训练也是十分类似的，例如，选择一定量的$\tilde{y}$来计算期望，而不是遍历所有的$\tilde{y}$。借助与最小风险训练类似的方法，可以计算对$\funp{p}$的梯度来优化演员。
\parinterval 而对于评论家，它的优化目标并不是那么显而易见。尽管可以通过采样得方式来估计$\funp{Q}$，然后使用该估计作为目标让$\tilde{\funp{Q}}$进行拟合，但是这样会导致非常高的（采样）代价，同时可以想象，既然有了一个无偏估计，为什么还要用有偏估计$\tilde{\funp{Q}}$呢？
\parinterval 而对于评论家，它的优化目标并不是那么显而易见。尽管可以通过采样的方式来估计$\funp{Q}$，然后使用该估计作为目标让$\tilde{\funp{Q}}$进行拟合，但是这样会导致非常高的（采样）代价。同时可以想象，既然有了一个无偏估计，为什么还要用有偏估计$\tilde{\funp{Q}}$呢？
\parinterval 回顾动作价值函数的定义，可以对它做适当的展开，可以得到如下等式：
\begin{eqnarray}
......@@ -605,17 +608,16 @@ Where did my optimum go?: An empiricalanalysis of gradient descent optimization
\label{eq:13-17}
\end{eqnarray}
\parinterval 这个等式也被称为{\small\bfnew{贝尔曼方程}}\index{贝尔曼方程}（Bellman Equation\index{Bellman Equation}）\upcite{sutton2018reinforcement}。这个等式告诉我们$j-1$时刻的动作价值函数$\funp{Q}(\tilde{{y}}_j;\tilde{{y}}_{1 \ldots j-1},\seq{y})$跟下一时刻$j$的动作价值函数$\funp{Q}(a;\tilde{{y}}_{1 \ldots j},\seq{y})$之间的关系。因此可以很自然的使用等式右部作为等式左部$\funp{Q}(\tilde{{y}}_j;\tilde{{y}}_{1 \ldots j-1},\seq{y})$的目标。而由于动作价值函数的输出是连续的数值，因此通常会选用均方误差来计算目标函数值。
\parinterval 这个等式也被称为{\small\bfnew{贝尔曼方程}}\index{贝尔曼方程}（Bellman Equation\index{Bellman Equation}）\upcite{sutton2018reinforcement}。这个等式告诉我们$j-1$时刻的动作价值函数$\funp{Q}(\tilde{{y}}_j;\tilde{{y}}_{1 \ldots j-1},\seq{y})$跟下一时刻$j$的动作价值函数$\funp{Q}(a;\tilde{{y}}_{1 \ldots j},\seq{y})$之间的关系。因此可以很自然的使用等式右部作为等式左部$\funp{Q}(\tilde{{y}}_j;\tilde{{y}}_{1 \ldots j-1},\seq{y})$的等价形式。于是，可以定义$j$时刻动作价值函数为：
\parinterval 进一步，可以定义$j$时刻动作价值函数的目标如下：
\begin{eqnarray}
\funp{q}_j & = & \funp{r}_j(\tilde{{y}}_j;\tilde{{y}}_{1 \ldots j-1},\seq{y}) + \sum_{a \in A}\funp{p}(a|\tilde{{y}}_{1 \ldots j},\seq{x})\tilde{\funp{Q}}(a;\tilde{{y}}_{1 \ldots j},\seq{y})
\label{eq:13-18}
\end{eqnarray}
\parinterval 而评论家对应的目标函数定义如下：
\parinterval 而评论家对应的目标定义如下：
\begin{eqnarray}
\hat{\tilde{\funp{Q}}} & = & \min_{\tilde{\funp{Q}}}\sum_{j=1}^J{(\tilde{\funp{Q}}(\tilde{{y}}_j;\tilde{{y}}_{1 \ldots j-1},\seq{y}) - \funp{q}_j)}^2
\hat{\tilde{\funp{Q}}} & = & \argmin_{\tilde{\funp{Q}}}\sum_{j=1}^J{(\tilde{\funp{Q}}(\tilde{{y}}_j;\tilde{{y}}_{1 \ldots j-1},\seq{y}) - \funp{q}_j)}^2
\label{eq:13-19}
\end{eqnarray}
......@@ -636,9 +638,9 @@ Where did my optimum go?: An empiricalanalysis of gradient descent optimization
\vspace{0.5em}
\item 多目标学习：演员的优化通常会引入额外的极大似然估计目标函数，同时会使用极大似然估计进行预训练。这样会简化训练，因为随机初始化的演员性能很差，很难获得有效的奖励。同时极大似然估计作为一个额外的正则项也防止模型跑偏，加速收敛。
\vspace{0.5em}
\item 优化目标：评论家的优化目标是由自身输出所构造。当模型更新比较快的时候模型的输出变化也会很快，导致构造的优化目标不稳定，影响模型收敛。一个解决方案是在一定更新次数内固定构造优化目标使用的模型，然后再使用比较新的模型来构造后续一定更新次数内的优化目标，如此往复\upcite{DBLP:journals/nature/SilverHMGSDSAPL16}。
\item 优化目标：评论家的优化目标是由自身输出所构造。当模型更新比较快的时候模型的输出变化也会很快，导致构造的优化目标不稳定，影响模型收敛效果。一个解决方案是，在一定更新次数内固定构造优化目标使用的模型，然后再使用比较新的模型来构造后续一定更新次数内的优化目标，如此往复\upcite{DBLP:journals/nature/SilverHMGSDSAPL16}。
\vspace{0.5em}
\item 方差惩罚：在机器翻译中使用强化学习方法一个问题是动作空间过大，这是由词表过大造成的。因为模型只根据被采样到的结果来进行更新，很多动作很难得到更新，因此对不同动作的动作价值函数估计值会有很大差异。通常会引入一个正则项$C_j = \sum_{a \in A}{(\tilde{\funp{Q}}(a;\tilde{{y}}_{1 \ldots j-1},\seq{y}) - \frac{1}{|A|} \sum_{b \in A}\tilde{\funp{Q}}(b;\tilde{{y}}_{1 \ldots j-1},\seq{y}))}^2$来约束不同动作的动作函数估计值，使其不会偏离他们的均值太远\upcite{DBLP:conf/icml/ZarembaMJF16}。
\item 方差惩罚：在机器翻译中使用强化学习方法一个问题是动作空间过大，这是由词表过大造成的。因为模型只根据被采样到的结果来进行更新，很多动作很难得到更新，因此对不同动作的动作价值函数估计值会有很大差异。通常会引入一个正则项$C_j = \sum_{a \in A}{(\tilde{\funp{Q}}(a;\tilde{{y}}_{1 \ldots j-1},\seq{y}) - \frac{1}{|A|} \sum_{b \in A}\tilde{\funp{Q}}(b;\tilde{{y}}_{1 \ldots j-1},\seq{y}))}^2$来约束不同动作的动作函数估计值，使其不会偏离均值太远\upcite{DBLP:conf/icml/ZarembaMJF16}。
\vspace{0.5em}
\item 函数塑形：在机器翻译里面使用强化学习方法另一个问题就是奖励的稀疏性。评价指标如BLEU等只能对完整的句子进行打分，也就是奖励只有在句子结尾有值，而在句子中间只能为0。这种情况意味着模型在生成句子的过程中没有任何信号来指导它的行为，从而大大增加了学习难度。常见的解决方案是进行{\small\bfnew{函数塑形}}\index{函数塑形}（Reward Shaping\index{Reward Shaping}），使得奖励在生成句子的过程中变得稠密，同时也不会改变模型的最优解\upcite{DBLP:conf/icml/NgHR99}。
\vspace{0.5em}
......@@ -651,11 +653,9 @@ Where did my optimum go?: An empiricalanalysis of gradient descent optimization
\sectionnewpage
\section{知识蒸馏}\label{subsection-7.5.3}
\parinterval 理想的机器翻译系统应该是品质好、速度块、存储占用少。不过，为了追求更好的翻译品质，往往需要更大的模型以及更慢的翻译速度，例如，可以通过增加模型参数量来达到更好的函数拟合效果，但是这也导致系统变得更加笨拙。在很多场景下，这样的模型甚至无法使用。比如，Transformer-Big等“大”模型通常在专用GPU服务器上运行，在手机等受限环境下仍很难应用。
\parinterval 另一方面，直接训练“小”模型的效果往往并不理想，其翻译品质与“大”模型相比仍有比较明显的差距。比如，在Transformer中，使用一个48层的编码器要比传统的6层编码器有更好的品质。
\parinterval 理想的机器翻译系统应该是品质好、速度块、存储占用少。不过，为了追求更好的翻译品质，往往需要更大的模型，但是相应的翻译速度会降低。在很多场景下，这样的模型无法直接使用。比如，Transformer-Big等“大”模型通常在专用GPU服务器上运行，在手机等受限环境下仍很难应用。
\parinterval 既然直接训练小模型无法达到更好的效果，一种有趣的想法是把“大”模型的知识传递给“小”模型，让“小”模型可以更好的进行学习。这类似于，教小孩子学习数学，是请一个权威数学家（数据中的标准答案），还是请一个小学数学教师（“大”模型）。这就是知识蒸馏的基本思想。
\parinterval 另一方面，直接训练“小”模型的效果往往并不理想，其翻译品质与“大”模型相比仍有比较明显的差距。既然直接训练小模型无法达到更好的效果，一种有趣的想法是把“大”模型的知识传递给“小”模型。这类似于，教小孩子学习数学，是请一个权威数学家（数据中的标准答案），还是请一个小学数学教师（“大”模型）。这就是知识蒸馏的基本思想。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -675,7 +675,7 @@ Where did my optimum go?: An empiricalanalysis of gradient descent optimization
\vspace{0.5em}
\end{itemize}
\parinterval 这里所说的第二个假设对应了机器学习中的一大类问题\ \dash \ {\small\bfnew{学习难度}}\index{学习难度}（Learning Difficulty）\index{Learning Difficulty}。所谓难度是指：在给定一个模型的情况下，需要花费多少代价对目标任务进行学习。如果目标任务很简单，同时模型与任务很匹配，那学习难度就会降低。如果目标任务很复杂，同时模型与其匹配程度很低，那学习难度就会很大。在自然语言处理任务中，这个问题的一种表现是：在很好的数据中学习的模型的翻译质量可能仍然很差。即使训练数据是完美的，但是模型仍然无法做到完美的学习。这可能是因为建模的不合理，导致模型无法描述目标任务中复杂的规律。也就是，纵然数据很好，但是模型学不到其中的“知识”。在机器翻译中这个问题体现的尤为明显。比如，在机器翻译系统$n$-best结果中挑选最好的译文（成为Oracle）作为训练样本让系统重新学习，系统仍然达不到Oracle的水平。
\parinterval 这里所说的第二个假设对应了机器学习中的一大类问题\ \dash \ {\small\bfnew{学习难度}}\index{学习难度}（Learning Difficulty）\index{Learning Difficulty}。所谓难度是指：在给定一个模型的情况下，需要花费多少代价对目标任务进行学习。如果目标任务很简单，同时模型与任务很匹配，那学习难度就会降低。如果目标任务很复杂，同时模型与其匹配程度很低，那学习难度就会很大。在自然语言处理任务中，这个问题的一种表现是：在很好的数据中学习的模型的翻译质量可能仍然很差。即使训练数据是完美的，但是模型仍然无法做到完美的学习。这可能是因为建模的不合理，导致模型无法描述目标任务中复杂的规律。也就是，纵然数据很好，但是模型学不到其中的“知识”。在机器翻译中这个问题体现的尤为明显。比如，在机器翻译系统$n$-best结果中挑选最好的译文（称为Oracle）作为训练样本让系统重新学习，系统仍然达不到Oracle的水平。
\parinterval 知识蒸馏本身也体现了一种“自学习”的思想。即利用模型（自己）的预测来教模型（自己）。这样既保证了知识可以向更轻量的模型迁移，同时也避免了模型从原始数据中学习难度大的问题。虽然“大”模型的预测中也会有错误，但是这种预测是更符合建模的假设的，因此“小”模型反倒更容易从不完美的信息中学习到更多的知识\footnote[15]{很多时候，“大”模型和“小”模型都是基于同一种架构，因此二者对问题的假设和模型结构都是相似的。}。类似于，刚开始学习围棋的人从职业九段身上可能什么也学不到，但是向一个业余初段的选手学习可能更容易入门。另外，也有研究表明：在机器翻译中，相比于“小”模型，“大”模型更容易进行优化，也更容易找到更好的模型收敛状态。因此在需要一个性能优越，存储较小的模型时，也会考虑将大模型压缩得到更轻量模型\upcite{DBLP:journals/corr/abs-2002-11794}。
......@@ -687,7 +687,7 @@ Where did my optimum go?: An empiricalanalysis of gradient descent optimization
\subsection{知识蒸馏的基本方法}
\parinterval 知识蒸馏的基本思路是让学生模型所表示的函数尽可能去拟合教师模型所表示的函数\upcite{Hinton2015Distilling}，通常有两种实现方式\upcite{kim-rush-2016-sequence}：
\parinterval 知识蒸馏的基本思路是让学生模型尽可能去拟合教师模型\upcite{Hinton2015Distilling}，通常有两种实现方式\upcite{kim-rush-2016-sequence}：
\begin{itemize}
\vspace{0.5em}
......@@ -697,21 +697,21 @@ L_{\textrm{word}} = - \sum_{j=1}^n \sum_{y_j \in V} \textrm{P}_{\textrm{t}} (y_{
\label{eq:13-28}
\end{eqnarray}
这里， $\textrm{P}_{\textrm{s}}(y_j|\seq{x})$和$\textrm{P}_{\textrm{t}} (y_i|\seq{x})$分别表示学生模型和教师模型在$j$位置的输出的概率。公式\ref{eq:13-28}实际上在最小化教师模型和学生模型输出分布之间的交叉熵。
这里， $\textrm{P}_{\textrm{s}}(y_j|\seq{x})$和$\textrm{P}_{\textrm{t}} (y_i|\seq{x})$分别表示学生模型和教师模型在$j$位置输出的概率。公式\eqref{eq:13-28}实际上在最小化教师模型和学生模型输出分布之间的交叉熵。
\vspace{0.5em}
\item {\small\bfnew{基于序列的知识蒸馏}}\index{基于序列的知识蒸馏}（Sequence-level Knowledge Distillation）\index{Sequence-level Knowledge Distillation}。除了单词一级的拟合，基于序列的知识蒸馏希望在序列整体上进行拟合。其损失函数被定义为：
\item {\small\bfnew{基于序列的知识蒸馏}}\index{基于序列的知识蒸馏}（Sequence-level Knowledge Distillation）\index{Sequence-level Knowledge Distillation}。除了单词一级输出的拟合，基于序列的知识蒸馏希望在序列整体上进行拟合。其损失函数被定义为：
\begin{eqnarray}
L_{\textrm{seq}} = - \sum_{\seq{y}}\textrm{P}_{\textrm{t}} (\seq{y}|\seq{x})\textrm{logP}_{\textrm{s}}(\seq{y}|\seq{x})
\label{eq:13-29}
\end{eqnarray}
公式\ref{eq:13-29}要求遍历所有可能的译文序列，并进行求和，当词表大小为$V$，序列长度为$n$时，则可能的序列的数量有$V$的$n$次幂，这么多的译文将消耗大量的计算资源。因此，会考虑用教师模型的真实输出序列$\tilde{\seq{y}}$来代替整个空间，即假设$\textrm{P}_{\textrm{t}}(\tilde{\seq{y}}|\seq{x})=1$。于是，目标函数变为：
公式\eqref{eq:13-29}要求遍历所有可能的译文序列，并进行求和，当词表大小为$V$，序列长度为$n$时，则序列的数量有$V$的$n$次幂，这么多的译文将消耗大量的计算资源。因此，会考虑用教师模型的真实输出序列$\tilde{\seq{y}}$来代替整个空间，即假设$\textrm{P}_{\textrm{t}}(\tilde{\seq{y}}|\seq{x})=1$。于是，目标函数变为：
\begin{eqnarray}
L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\label{eq:13-30}
\end{eqnarray}
这样的损失函数带来最直接的好处是，知识蒸馏的流程会非常简单。因为只需要利用教师模型将训练数据（源语言）翻译一遍，之后把它的输出替换为训练数据的目标语言部分。之后，利用得到的新的双语数据训练学生模型即可，图\ref{fig:13-41}展示了简化后词级和序列级的不同，其中词级知识蒸馏的解码端输入为真实双语数据的目标语言，并以教师模型输出的概率分布作为学习目标，而序列级则直接将教师模型推断后得到的结果作为解码端的输入，并将解码结果的One-hot向量作为学习目标。
这样的损失函数最直接的好处是，知识蒸馏的流程会非常简单。因为只需要利用教师模型将训练数据（源语言）翻译一遍，之后把它的输出替换为训练数据的目标语言部分。之后，利用得到的新的双语数据训练学生模型即可。图\ref{fig:13-41}对比了词级和序列级知识蒸馏方法。
\vspace{0.5em}
\end{itemize}
......@@ -724,10 +724,9 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\end{figure}
%-------------------------------------------
\parinterval 本质上，基于单词的知识蒸馏和语言建模等问题的建模方式是一致的。在传统方法中，训练数据中的答案会被看作是一个One-hot分布，之后让模型去尽可能拟合这种分布。而这里，答案不再是一个One-hot分布，而是由教师模型生成的真实分布，但是损失函数的形式是一模一样的。在具体实现时，一个容易出现的问题是在词级别的知识蒸馏中，教师模型的Softmax可能会生成非常尖锐的分布。这时需要考虑对分布进行平滑，提高模型的泛化能力\footnote[16]{比如，可以在Softmax函数中加入一个参数$\alpha$，如$\textrm{Softmax}(s_i)=\frac{\exp(s_i/\alpha)}{\sum_j \exp(s_i/\alpha)}$。这样可以通过$\alpha$ 控制分布的平滑程度。
}。
\parinterval 本质上，基于单词的知识蒸馏与语言建模等问题的建模方式是一致的。在传统方法中，训练数据中的答案会被看作是一个One-hot分布，之后让模型去尽可能拟合这种分布。而这里，答案不再是一个One-hot分布，而是由教师模型生成的真实分布，但是损失函数的形式是一模一样的。在具体实现时，一个容易出现的问题是在词级别的知识蒸馏中，教师模型的Softmax可能会生成非常尖锐的分布。这时需要考虑对分布进行平滑，提高模型的泛化能力，比如，可以在Softmax函数中加入一个参数$\alpha$，如$\textrm{Softmax}(s_i)=\frac{\exp(s_i/\alpha)}{\sum_j \exp(s_j/\alpha)}$。这样可以通过$\alpha$ 控制分布的平滑程度。
\parinterval 除了在模型最后输出的分布上进行知识蒸馏，同样可以使用教师模型对学生模型的{\small\bfnew{中间层输出}}\index{中间层输出}（Hint-based Knowledge Transfer）\index{Hint-based Knowledge Transfer}和{\small\bfnew{注意力分布}}\index{注意力分布}（Attention To Attention Transfer）\index{Attention To Attention Transfer}进行约束。而对翻译常用的Transformer架构，也可以使用更精细的精炼方式对模型各个位置的知识重新设计了知识迁移的方法\upcite{Jiao2020TinyBERTDB}。
\parinterval 除了在模型最后输出的分布上进行知识蒸馏，同样可以使用教师模型对学生模型的中间层输出和注意力分布进行约束。而对翻译常用的Transformer架构，也可以使用更精细的精炼方式对模型各个位置的知识重新设计了知识迁移的方法\upcite{Jiao2020TinyBERTDB}。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -735,7 +734,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\subsection{机器翻译中的知识蒸馏}
\parinterval 在神经机器翻译中，通常使用公式\ref{eq:13-30}的方法进行知识蒸馏，即通过教师模型构造伪数据，之后让学生模型从伪数据中学习。这样做的好处在于，系统研发人员不需要对系统进行任何修改，整个过程只需要调用教师模型和学生模型标准的训练和推断模块即可。
\parinterval 在神经机器翻译中，通常使用公式\eqref{eq:13-30}的方法进行知识蒸馏，即通过教师模型构造伪数据，之后让学生模型从伪数据中学习。这样做的好处在于，系统研发人员不需要对系统进行任何修改，整个过程只需要调用教师模型和学生模型标准的训练和推断模块即可。
\parinterval 另一个问题是如何构造教师模型和学生模型。以Transformer为例，通常有两种思路：
......@@ -779,7 +778,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\parinterval 类别不平衡在分类任务中更为常见，可以通过重采样、代价敏感训练等手段来解决。数据选择则是缓解领域差异和标签噪声等问题的一种有效手段，它的学习策略是让模型有选择的使用样本进行学习。此外，在一些稀缺资源场景下还会面临标注数据稀少的情况，此时可以利用主动学习选择那些最有价值的样本让人工优先进行标注，从而降低标注成本。
\parinterval 显然，上述方法都基于一个假设：在训练过程中，每个样本是有价值的，这种价值可以计算。基于这个假设，定义价值本质上是在定义一个评价函数。价值在不同任务背景下有不同的含义，这与任务的特性有关。比如，在领域相关数据选择中，价值表示样本与领域的相关性；在数据降噪中，价值表示样本的可信度；在主动学习中，价值表示样本的难易程度。
\parinterval 显然，上述方法都基于一个假设：在训练过程中，每个样本都是有价值的，且这种价值可以计算。价值在不同任务背景下有不同的含义，这与任务的特性有关。比如，在领域相关数据选择中，样本的价值表示这个样本与领域的相关性；在数据降噪中，价值表示样本的可信度；在主动学习中，价值表示样本的难易程度。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -789,21 +788,21 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\parinterval 当机器翻译系统应用于不同领域时，训练语料与所应用领域的相关性就显得非常重要\upcite{DBLP:journals/mt/EetemadiLTR15,britz2017effective}。不同领域往往具有自己独特的属性，比如语言风格、句子结构、专业术语等，例如，“bank”这个英语单词，在金融领域通常被翻译为“银行”，而在计算机领域，一般被解释为“库”、“存储体”等。这也会导致，使用通用领域数据训练出来的模型在特定领域上的翻译效果往往不理想，这本质上是训练数据和测试数据的领域属性不匹配造成的。
\parinterval 一种解决办法是只使用特定领域的数据进行模型训练，然而这种数据往往比较稀缺。那能不能利用通用领域数据来帮助数据稀少的领域呢？这个研究方向被称为机器翻译的{\small\bfnew{领域适应}}\index{领域适应}（Domain Adaptation\index{Domain Adaptation}），即从资源丰富的领域（称为源领域， Source Domain）向资源稀缺的领域（称为目标领域， Target Domain）迁移。这本身也对应着资源稀缺场景下的机器翻译问题，这类问题会在{\chaptersixteen}进行详细讨论。本章更加关注如何有效地利用训练样本以更好地适应目标领域。具体来说，可以使用{\small\bfnew{数据选择}}\index{数据选择}（Data Selection\index{Selection}）从源领域训练数据中选择与目标领域更加相关的样本进行模型训练。这样做的一个好处是，源领域中混有大量与目标领域不相关的样本，数据选择可以有效的降低这部分数据的比例，这样可以更加突出与领域相关样本的作用。
\parinterval 一种解决办法是只使用特定领域的数据进行模型训练，然而这种数据往往比较稀缺。那能不能利用通用领域数据来帮助数据稀少的领域呢？这个研究方向被称为机器翻译的{\small\bfnew{领域适应}}\index{领域适应}（Domain Adaptation\index{Domain Adaptation}），即从资源丰富的领域（称为源领域， Source Domain）向资源稀缺的领域（称为目标领域， Target Domain）迁移。这本身也对应着资源稀缺场景下的机器翻译问题，这类问题会在{\chaptersixteen}进行详细讨论。本章更加关注如何有效地利用训练样本以更好地适应目标领域。具体来说，可以使用{\small\bfnew{数据选择}}\index{数据选择}（Data Selection\index{Selection}）从源领域训练数据中选择与目标领域更加相关的样本进行模型训练。这样做的一个好处是，源领域中混有大量与目标领域不相关的样本，数据选择可以有效降低这部分数据的比例，这样可以更加突出与领域相关样本的作用。
\parinterval 数据选择所要解决的核心问题是：给定一个目标领域/任务数据集（如，目标任务的开发集），如何衡量原始训练样本与目标领域/任务的相关性？主要方法可以分为以下几类：
\begin{itemize}
\vspace{0.5em}
\item 基于{\small\bfnew{交叉熵差}}\index{交叉熵差}（Cross-entropy difference\index{Cross-entropy difference}，CED）的方法\upcite{DBLP:conf/emnlp/AxelrodHG11,DBLP:conf/wmt/AxelrodRHO15,DBLP:conf/emnlp/WangULCS17,DBLP:conf/iwslt/MansourWN11}。该方法在目标领域数据和通用数据上分别训练语言模型，然后用两个语言模型来给句子打分并做差，分数越低说明句子与目标领域越相关。
\item 基于{\small\bfnew{交叉熵差}}\index{交叉熵差}（Cross-entropy Difference\index{Cross-entropy Difference}，CED）的方法\upcite{DBLP:conf/emnlp/AxelrodHG11,DBLP:conf/wmt/AxelrodRHO15,DBLP:conf/emnlp/WangULCS17,DBLP:conf/iwslt/MansourWN11}。该方法在目标领域数据和通用数据上分别训练语言模型，然后用两个语言模型来给句子打分并做差，分数越低说明句子与目标领域越相关。
\vspace{0.5em}
\item 基于文本分类的方法\upcite{DBLP:conf/conll/ChenH16,chen2016bilingual,DBLP:conf/aclnmt/ChenCFL17,DBLP:conf/wmt/DumaM17}。将问题转化为文本分类问题，先构造一个领域分类器，之后利用分类器对给定的句子进行领域分类，最后用输出的概率来打分，选择得分高的样本。
\vspace{0.5em}
\item 基于{\small\bfnew{特征衰减算法}}\index{特征衰减算法}（Feature Decay Algorithms\index{Feature Decay Algorithms}，FDA）的方法\upcite{DBLP:conf/wmt/BiciciY11,poncelas2018feature,DBLP:conf/acl/SotoSPW20,DBLP:journals/corr/abs-1811-03039}。该算法基于特征匹配，试图从源领域中提取出一个句子集合，这些句子能够最大程度覆盖目标领域的语言特征。
\item 基于{\small\bfnew{特征衰减算法}}\index{特征衰减算法}（Feature Decay Algorithms\index{Feature Decay Algorithms}，FDA）的方法\upcite{DBLP:conf/wmt/BiciciY11,poncelas2018feature,DBLP:conf/acl/SotoSPW20}。该算法基于特征匹配，试图从源领域中提取出一个句子集合，这些句子能够最大程度覆盖目标领域的语言特征。
\vspace{0.5em}
\end{itemize}
\parinterval 上述方法实际上描述了一种静态的学习策略，即首先利用评分函数对源领域的数据进行打分排序，然后选取一定数量的数据合并到目标领域数据集中共同训练模型\upcite{DBLP:conf/emnlp/AxelrodHG11,DBLP:conf/wmt/AxelrodRHO15,chen2016bilingual,DBLP:conf/wmt/BiciciY11,DBLP:conf/conll/ChenH16}，这个过程其实是扩大了目标领域的数据规模，模型的收益主要来自于数据的增加。但是研究人员也发现静态方法会存在两方面的缺陷：
\parinterval 上述方法实际上描述了一种静态的学习策略，即首先利用评分函数对源领域的数据进行打分排序，然后选取一定数量的数据合并到目标领域数据集中，并共同训练模型\upcite{DBLP:conf/emnlp/AxelrodHG11,DBLP:conf/wmt/AxelrodRHO15,chen2016bilingual,DBLP:conf/conll/ChenH16}，这个过程其实是扩大了目标领域的数据规模，模型的收益主要来自于数据的增加。但是研究人员也发现静态方法会存在两方面的缺陷：
\begin{itemize}
\vspace{0.5em}
......@@ -813,7 +812,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\vspace{0.5em}
\end{itemize}
\parinterval 使用动态学习策略可以有效地缓解上述问题。这里的动态主要体现在模型训练过程中，训练数据是以某种策略进行动态的组织。它的基本想法是：不完全抛弃领域相关性低的样本，而只是使模型给予相关性高的样本更高的关注度，使得它更容易参与到训练过程中。具体在实现上，主要有两种方法，一种是将句子的领域相似性表达成概率分布，然后在训练过程中根据该分布对数据进行动态采样\upcite{DBLP:conf/emnlp/WeesBM17,DBLP:conf/acl/WangUS18}， 一种是在计算损失函数时根据句子的领域相似性以加权的方式进行训练\upcite{DBLP:conf/emnlp/WangULCS17,DBLP:conf/aclnmt/ChenCFL17}。相比于静态方法的二元选择方式，动态方法是一种“软”选择方式，这使得模型有机会使用到其它数据，提高了训练数据的多样性，因此性能也更稳定。
\parinterval 使用动态学习策略可以有效地缓解上述问题。它的基本想法是：不完全抛弃领域相关性低的样本，而只是使模型给予相关性高的样本更高的关注度，使得它更容易参与到训练过程中。具体在实现上，主要有两种方法，一种是将句子的领域相似性表达成概率分布，然后在训练过程中根据该分布对数据进行动态采样\upcite{DBLP:conf/emnlp/WeesBM17,DBLP:conf/acl/WangUS18}， 另一种是在计算损失函数时根据句子的领域相似性以加权的方式进行训练\upcite{DBLP:conf/emnlp/WangULCS17,DBLP:conf/aclnmt/ChenCFL17}。 相比于静态方法的二元选择方式，动态方法是一种“软”选择的方式，这使得模型有机会使用到其它数据，提高了训练数据的多样性，因此性能也更稳定。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -841,7 +840,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
}\end{table}
%-------------------------------------------
\parinterval 一方面来说，虽然表\ref{tab:13-4}中这两个句子都很流畅，但是由于汉语句子中缺少了一部分翻译，因此简单的基于长度或双语词典的方法可以很容易将其过滤掉。从另一方面来说，这个样本对于训练机器翻译模型仍然有用，特别是在数据稀缺的情况下，因为汉语句子和英语句子的前半部分仍然是正确的互译结果。这表明了噪声数据的微妙之处，它不是对应着简单的二元分类问题：一些训练样本可能部分有用，而它们的价值也可能随着训练的进展而改变。因此简单的过滤并不一种很好的办法，一种更加理想的学习策略应该是既可以合理的利用这些数据，又不让其对模型产生负面影响。直觉上，这是一个动态的过程，当模型能力较弱时（比如在训练初期），这些数据就能对模型起到正面作用，反之亦然。受课程学习、微调等方法的启发，研究人员也提出了类似的学习策略，它的主要思想是：在训练过程中对批量数据的噪声水平进行{\small\bfnew{退火}}\index{退火}（Anneal）\index{Anneal}，使得模型在越来越干净的数据上进行训练\upcite{DBLP:conf/wmt/WangWHNC18,DBLP:conf/acl/WangCC19}。从宏观上看，整个训练过程其实是一个持续微调的过程，这和微调的思想基本一致。这种学习策略一方面充分利用了训练数据，一方面又避免了噪声数据对模型的负面影响，因此取得了不错的效果。
\parinterval 一方面来说，虽然{\color{red} 图XXX}中这两个句子都很流畅，但是由于汉语句子中缺少了一部分翻译，因此简单的基于长度或双语词典的方法可以很容易将其过滤掉。从另一方面来说，这个样本对于训练机器翻译模型仍然有用，特别是在数据稀缺的情况下，因为汉语句子和英语句子的前半部分仍然是正确的互译结果。这表明了噪声数据的微妙之处，它不是对应着简单的二元分类问题：一些训练样本可能部分有用，而它们的价值也可能随着训练的进展而改变。因此简单的过滤并不一种很好的办法，一种更加理想的学习策略应该是既可以合理的利用这些数据，又不让其对模型产生负面影响。直觉上，这是一个动态的过程，当模型能力较弱时（比如在训练初期），这些数据就能对模型起到正面作用，反之亦然。例如，在训练过程中对批量数据的噪声水平进行{\small\bfnew{退火}}\index{退火}（Anneal）\index{Anneal}，使得模型在越来越干净的数据上进行训练\upcite{DBLP:conf/wmt/WangWHNC18,DBLP:conf/acl/WangCC19}。从宏观上看，整个训练过程其实是一个持续微调的过程，这和微调的思想基本一致。这种学习策略一方面充分利用了训练数据，一方面又避免了噪声数据对模型的负面影响，因此取得了不错的效果。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -897,7 +896,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\parinterval 评估样本的难度和具体的任务相关，在神经机器翻译中，有很多种评估方法，可以利用语言学上的困难准则，比如句子长度、句子平均词频、句法树深度等\upcite{DBLP:conf/naacl/PlataniosSNPM19,DBLP:conf/ranlp/KocmiB17}。这些准则本质上属于人类的先验知识，符合人类的直觉，但不一定和模型相匹配。对人类来说简单的句子对模型来说可能并不简单，所以研究学者们也提出了基于模型的方法，比如：语言模型\upcite{DBLP:conf/acl/WangCC19,DBLP:conf/naacl/ZhangSKMCD19}，或者神经机器翻译模型\upcite{zhang2018empirical,DBLP:conf/coling/XuHJFWHJXZ20}都可以用于评价样本的难度。值得注意的是，利用神经机器翻译来打分的方法分为静态和动态两种。静态的方法是利用在小数据集上训练的、更小的翻译模型模型来打分\upcite{zhang2018empirical}。动态的方法则是利用当前模型的状态来打分，这在广义上也叫作{\small\bfnew{自步学习}}\index{自步学习}（Self-Paced Learning\index{Self-Paced Learning}），通常可以利用模型的训练误差或变化率等指标进行样本难度的估计\upcite{DBLP:conf/coling/XuHJFWHJXZ20}。
\parinterval 虽然样本难度的度量在不同的数据类型和任务中有所不同，但课程规划通常与数据和任务无关。在各种场景中，大多数课程学习都利用了类似的调度策略。具体而言，调度策略可以分为预定义的和自动两种。预定义的调度策略通常按照难易程度排序好的样本划分为块，每个块中包含一定数量的难度相似的样本。然后按照“先易后难”的原则人工定义一个调度策略，比如，一种较为流行的方法是：在训练早期，模型只在简单块中进行采样，随着训练过程的进行，将下一个块的样本合并到当前训练子集中，继续训练，直到合并了整个数据块，即整个训练集可见为止，之后再继续进行几个额外轮次的训练直到收敛。这个过程如图\ref{fig:13-55}所示。类似的还有一些其他变体，比如，训练到模型可见整个数据集之后，将最难的样本块复制并添加到训练集中，或者是将最容易的数据块逐渐删除，然后再添加回来等，这些方法的基本想法都是想让模型在具备一定的能力之后更多关注于困难样本。
\parinterval 虽然样本难度的度量在不同任务中有所不同，但课程规划通常与数据和任务无关。在各种场景中，大多数课程学习都利用了类似的调度策略。具体而言，调度策略可以分为预定义的和自动两种。预定义的调度策略通常按照难易程度排序好的样本划分为块，每个块中包含一定数量的难度相似的样本。然后按照“先易后难”的原则人工定义一个调度策略，比如，一种较为流行的方法是：在训练早期，模型只在简单块中进行采样，随着训练过程的进行，将下一个块的样本合并到当前训练子集中，继续训练，直到合并了整个数据块，即整个训练集可见为止，之后再继续进行几个额外轮次的训练直到收敛。这个过程如图\ref{fig:13-55}所示。类似的还有一些其他变体，比如，训练到模型可见整个数据集之后，将最难的样本块复制并添加到训练集中，或者是将最容易的数据块逐渐删除，然后再添加回来等，这些方法的基本想法都是想让模型在具备一定的能力之后更多关注于困难样本。
%----------------------------------------------
\begin{figure}[htp]
......@@ -908,7 +907,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\end{figure}
%-------------------------------------------
\parinterval 尽管预定义的调度策略简单有效，但也会面临着方法不够灵活、数据块划分不合理等问题，而且这种策略在一定程度上也忽略了当前模型的反馈。因此另一种方法是自动的方法，根据模型的反馈来动态调整样本的难度或调度策略，模型的反馈可以是模型的不确定性\upcite{DBLP:conf/acl/ZhouYWWC20}、模型的能力\upcite{DBLP:conf/naacl/PlataniosSNPM19,DBLP:conf/coling/XuHJFWHJXZ20}等。这些方法在一定程度上使得整个训练过程和模型的状态相匹配，使得样本的选择过渡得更加平滑，因此在实践中取得了不错的效果。
\parinterval 尽管预定义的调度策略简单有效，但也会面临着方法不够灵活、数据块划分不合理等问题，而且这种策略在一定程度上也忽略了当前模型的反馈。因此另一种方法是自动的方法，根据模型的反馈来动态调整样本的难度或调度策略，模型的反馈可以是模型的不确定性\upcite{DBLP:conf/acl/ZhouYWWC20}、模型的能力\upcite{DBLP:conf/naacl/PlataniosSNPM19,DBLP:conf/coling/XuHJFWHJXZ20}等。这些方法在一定程度上使得整个训练过程和模型的状态相匹配，同时样本的选择过渡得更加平滑，因此在实践中取得了不错的效果。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -916,9 +915,9 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\subsection{持续学习}
\parinterval 人类具有不断学习、调整和转移知识的能力，这种能力被称为{\small\bfnew{持续学习}}\index{持续学习}（Continual Learning\index{Continual Learning}），也叫{\small\bfnew{终生学习}}（Lifelong Learning\index{Lifelong Learning}）、{\small\bfnew{增量式学习}}\index{增量式学习}（Incremental Learning\index{Incremental Learning}）。人类学习的新任务时，会很自然的利用以前的知识并将新学习的知识整合到以前的知识中。然而对于机器学习系统来说，尤其在连接主义的范式下（如深度神经网络模型），这是一个很大的挑战，这是由神经网络的特性所决定的。当前的神经网络模型依赖于标注的训练样本，通过反向传播算法对模型参数进行训练更新，最终达到拟合数据分布的目的。当把模型切换到新的任务时，本质上是数据的分布发生了变化，从这种分布差异过大的数据中不断增量获取可用信息很容易导致{\small\bfnew{灾难性遗忘}}\index{灾难性遗忘}（Catastrophic Forgetting\index{Catastrophic Forgetting}）问题，即用新数据训练模型的时候会干扰先前学习的知识。这是因为模型在学习新任务时，会用新训练数据对整个网络权重进行更新，这很容易造成模型过分拟合新的数据，忘记旧数据中的知识。甚至，这在最坏的情况下会导致旧知识被新知识完全重写。在机器翻译领域，类似的问题经常发生不断增加数据的场景中，因为当用户使用少量数据对模型进行更新之后，发现在旧的数据上的性能下降了（见{\chaptereighteen}）。
\parinterval 人类具有不断学习、调整和转移知识的能力，这种能力被称为{\small\bfnew{持续学习}}\index{持续学习}（Continual Learning\index{Continual Learning}），也叫{\small\bfnew{终生学习}}（Lifelong Learning\index{Lifelong Learning}）、{\small\bfnew{增量式学习}}\index{增量式学习}（Incremental Learning\index{Incremental Learning}）。人类学习的新任务时，会很自然的利用以前的知识并将新学习的知识整合到以前的知识中。然而对于机器学习系统来说，尤其在连接主义的范式下（如深度神经网络模型），这是一个很大的挑战，这是由神经网络的特性所决定的。当前的神经网络模型依赖于标注的训练样本，通过反向传播算法对模型参数进行训练更新，最终达到拟合数据分布的目的。当把模型切换到新的任务时，本质上是数据的分布发生了变化，从这种分布差异过大的数据中不断增量获取可用信息很容易导致{\small\bfnew{灾难性遗忘}}\index{灾难性遗忘}（Catastrophic Forgetting\index{Catastrophic Forgetting}）问题，即用新数据训练模型的时候会干扰先前学习的知识。这是因为模型在学习新任务时，会用新训练数据对整个网络权重进行更新，这很容易造成模型过分拟合新的数据，忘记旧数据中的知识。甚至，这在最坏的情况下会导致旧知识被新知识完全重写。在机器翻译领域，类似的问题经常发生在不断增加数据的场景中，因为当用户使用少量数据对模型进行更新之后，发现在旧数据上的性能下降了（见{\chaptereighteen}）。
\parinterval 为克服灾难性遗忘问题，学习系统一方面必须能连续获取新知识和完善现有知识，另一方面，还应防止新数据输入明显干扰现有的知识，这个问题称作{\small\bfnew{稳定性-可塑性}}\index{稳定性- 可塑性}（Stability-Plasticity\index{Stability-Plasticity}）问题。可塑性指整合新知识的能力，稳定性指在编码时会保留先前的知识不至于遗忘。要解决这些问题，就需要模型在保留先前任务的知识与学习当前任务的新知识之间取得平衡。目前的解决方法可以分为以下几类：
\parinterval 为克服灾难性遗忘问题，学习系统一方面必须能连续获取新知识和完善现有知识，另一方面，还应防止新数据输入明显干扰现有的知识，这个问题称作{\small\bfnew{稳定性-可塑性}}\index{稳定性- 可塑性}（Stability-Plasticity\index{Stability-Plasticity}）问题。可塑性指整合新知识的能力，稳定性指保留先前的知识不至于遗忘。要解决这些问题，就需要模型在保留先前任务的知识与学习当前任务的新知识之间取得平衡。目前的解决方法可以分为以下几类：
\begin{itemize}
\vspace{0.5em}
......@@ -926,11 +925,11 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\vspace{0.5em}
\item 基于实例的方法。以原始格式存储样本，或使用生成模型生成伪样本，在学习新任务的同时重放先前的任务样本以减轻遗忘\upcite{DBLP:conf/cvpr/RebuffiKSL17,DBLP:conf/eccv/CastroMGSA18}。
\vspace{0.5em}
\item 基于动态模型架构的方法。例如，增加神经元或网络层进行重新训练，或者是在新任务训练时只更新部分参数\upcite{rusu2016progressive,DBLP:journals/corr/FernandoBBZHRPW17}。
\item 基于动态模型架构的方法。例如，增加神经元或新的神经网络层进行重新训练，或者是在新任务训练时只更新部分参数\upcite{rusu2016progressive,DBLP:journals/corr/FernandoBBZHRPW17}。
\vspace{0.5em}
\end{itemize}
\parinterval 从某种程度上看，机器翻译中的多领域、多语言等都属于持续学习的场景。在多领域神经机器翻译中，我们期望模型既有通用领域的性能，并且在特定领域也表现良好，然而事实上，适应特定领域往往是以牺牲通用领域的性能为代价的\upcite{DBLP:conf/naacl/ThompsonGKDK19,DBLP:conf/coling/GuF20}。在多语言神经翻译中，最理想的情况是一个模型就能够实现在多个语言之间的映射，然而由于数据分布的极大不同，实际情况往往是：多语言模型能够提高低资源语言对互译的性能，但同时也会降低高资源语言对的性能。因此如何让模型从多语言训练数据中持续受益就是一个关键的问题。以上这些问题在{\chaptersixteen}和{\chaptereighteen}中还会有详细讨论。
\parinterval 从某种程度上看，多领域、多语言机器翻译等都属于持续学习的场景。在多领域神经机器翻译中，我们期望模型既有通用领域的性能，并且在特定领域也表现良好，然而事实上，适应特定领域往往是以牺牲通用领域的性能为代价的\upcite{DBLP:conf/naacl/ThompsonGKDK19,DBLP:conf/coling/GuF20}。在多语言神经翻译中，最理想的情况是一个模型就能够实现在多个语言之间的映射，然而由于数据分布的极大不同，实际情况往往是：多语言模型能够提高低资源语言对互译的性能，但同时也会降低高资源语言对的性能。因此如何让模型从多语言训练数据中持续受益就是一个关键的问题。以上这些问题在{\chaptersixteen}和{\chaptereighteen}中还会有详细讨论。
%----------------------------------------------------------------------------------------
% NEW SECTION
......@@ -939,17 +938,17 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\tilde{\seq{y}} | \seq{x})
\sectionnewpage
\section{小结及深入阅读}
\parinterval 本章以不同的角度讨论了神经机器翻译模型的训练问题。一方面，可以作为{\chapternine}$\sim${\chaptertwelve}内容的扩展，另一方面，也为本书后续章节的内容进行铺垫。从机器学习的角度看，本章介绍的很多内容并不仅仅使用在机器翻译中，大多数的内容同样适用于其它自然语言处理任务。此外，本章也讨论许多与机器翻译相关的问题（如大词表），这又使得本章的内容具有机器翻译的特性。总的来说，模型训练是一个非常开放的问题，在后续章节中还会频繁涉及。同时，也有一些方向可以关注：
\parinterval 本章以不同的角度讨论了神经机器翻译模型的训练问题。一方面，可以作为{\chapternine}$\sim${\chaptertwelve}内容的扩展，另一方面，也为本书后续章节的内容进行铺垫。从机器学习的角度看，本章介绍的很多内容并不仅仅使用在机器翻译中，大多数的内容同样适用于其它自然语言处理任务。此外，本章也讨论了许多与机器翻译相关的问题（如大词表），这又使得本章的内容具有机器翻译的特性。总的来说，模型训练是一个非常开放的问题，在后续章节中还会频繁涉及。同时，也有一些方向可以关注：
\begin{itemize}
\vspace{0.5em}
\item 对抗样本除了用于提高模型的健壮性之外，还有很多其他的应用场景。其中最主要的便是用于评估模型。通过构建由对抗样本构造的数据集，可以验证模型对于不同类型噪声健壮性\upcite{DBLP:conf/emnlp/MichelN18}。正是由于对抗样本在检测和提高模型健壮性具有明显的效果，因此很多的研究人员在针对不同的任务提出了很多有效的方法。但是在生成对抗样本时常常要注意或考虑很多问题，比如扰动是否足够细微，在人类难以察觉的同时做到欺骗模型的目的，对抗样本在不同的模型结构或数据集上是否具有足够的泛化能力。生成的方法是否足够高效等等。（{\color{red}参考文献是不是有些少？加个2-3篇？} ）
\item 对抗样本除了用于提高模型的健壮性之外，还有很多其他的应用场景，比如评估模型。通过构建由对抗样本构造的数据集，可以验证模型对于不同类型噪声健壮性\upcite{DBLP:conf/emnlp/MichelN18}。但是在生成对抗样本时常常要注意或考虑很多问题，比如扰动是否足够细微\upcite{DBLP:conf/cvpr/Moosavi-Dezfooli16,DBLP:conf/cvpr/NguyenYC15}，在人类难以察觉的同时做到欺骗模型的目的，对抗样本在不同的模型结构或数据集上是否具有足够的泛化能力\upcite{DBLP:conf/iclr/LiuCLS17,DBLP:journals/tnn/YuanHZL19}。生成的方法是否足够高效等等\upcite{DBLP:conf/emnlp/JiaL17,DBLP:conf/infocom/YuanHL020}。
\vspace{0.5em}
\item 强化学习在机器翻译里的应用除了前面提到的方法外还有很多，比如MIXER算法用混合策略梯度和极大似然估计目标函数来更新模型{\red Sequence Level Training with Recurrent Neural Networks}，DAgger{\red A Reduction of Imitation Learning and Structured Prediction to No-Regret Online Learning}以及DAD{\red Improving Multi-step Prediction of Learned Time Series Models}等算法在训练过程之中逐渐让模型适应推断阶段的模式。此外，强化学习的效果目前还相当不稳定，研究人员提出了大量的方法来进行改善，比如降低方差{\red An Actor-Critic Algorithm for Sequence Prediction;Reinforcement Learning for Bandit Neural Machine Translation with Simulated Human Feedback}、使用单语语料{\red Improving Neural Machine Translation Models with Monolingual Data;A Study of Reinforcement Learning for Neural Machine Translation}等等。由于强化学习能从反馈的奖励中学习的特性，有不少研究探究如何在交互式场景中使用强化学习来提升系统性能。在交互式的场景下，系统能够直接和人类进行交互，在这种情况下人类的回复可以被视作是一种较弱的信号，能够用来提升系统的性能。典型的例子就是对话系统，人类的反馈可以被用来训练系统，例如small-talk{\red A Deep Reinforcement Learning Chatbot}以及task-oriented dialogue{\red Continuously Learning Neural Dialogue Management}。另外，强化学习也被应用在领域适应上，需要根据用户或是领域进行客制化的系统，用户偏好或者是评分可以用来调整系统。在工业界，大范围的收集用户反馈意见被应用在个性化新闻推荐{\red A contextual-bandit approach to personalized news article recommendation}或是电子商务推荐系统之中{\red Can Neural Machine Translation be Improved with User Feedback?}。
\item 在机器翻译中，强化学习的应用还有很多，比如，MIXER算法用混合策略梯度和极大似然估计的目标函数来更新模型\upcite{Ranzato2016SequenceLT}，DAgger\upcite{DBLP:journals/jmlr/RossGB11}以及DAD\upcite{DBLP:conf/aaai/VenkatramanHB15}等算法在训练过程之中逐渐让模型适应推断阶段的模式。此外，强化学习的效果目前还相当不稳定，研究人员提出了大量的方法来进行改善，比如降低方差\upcite{DBLP:conf/iclr/BahdanauBXGLPCB17,DBLP:conf/emnlp/NguyenDB17}、使用单语语料\upcite{Sennrich2016ImprovingNM,DBLP:conf/emnlp/WuTQLL18}等等。由于强化学习能从反馈的奖励中学习的特性，有不少研究探究如何在交互式场景中使用强化学习来提升系统性能。典型的例子就是对话系统，人类的反馈可以被用来训练系统，例如small-talk\upcite{DBLP:journals/corr/abs-1709-02349}以及面向任务的对话\upcite{DBLP:journals/corr/SuGMRUVWY16a}。
\vspace{0.5em}
\item 从广义上说，大多数课程学习方法都是遵循由易到难的原则，然而在实践过程中人们逐渐赋予了课程学习更多的内涵，课程学习的含义早已超越了最原始的定义。一方面，课程学习可以与许多任务相结合，此时，评估准则并不一定总是样本的困难度，这取决于具体的任务，比如在{\small\bfnew{多任务学习}}\index{多任务学习}（multi-task learning）\index{multi-task learning}中\upcite{DBLP:conf/cvpr/PentinaSL15,DBLP:conf/iccvw/SarafianosGNK17}，指的任务的难易程度或相关性；在领域适应任务中\upcite{DBLP:conf/naacl/ZhangSKMCD19}，指的是数据与领域的相似性；在噪声数据场景中，指的是样本的可信度\upcite{DBLP:conf/acl/WangCC19}。另一方面，在一些任务或数据中，由易到难并不总是有效，有时困难优先反而会取得更好的效果\upcite{DBLP:conf/medprai/SurendranathJ18,zhang2018empirical}，实际上这和我们的直觉不太符合，一种合理的解释是课程学习更适合标签噪声、离群值较多或者是目标任务困难的场景，能提高模型的健壮性和收敛速度，而困难优先则更适合数据集干净的场景，能使随机梯度下降更快更稳定\upcite{DBLP:conf/nips/ChangLM17}。
\item 从广义上说，大多数课程学习方法都是遵循由易到难的原则，然而在实践过程中人们逐渐赋予了课程学习更多的内涵，课程学习的含义早已超越了最原始的定义。一方面，课程学习可以与许多任务相结合，此时，评估准则并不一定总是样本的困难度，这取决于具体的任务。另一方面，在一些任务或数据中，由易到难并不总是有效，有时困难优先反而会取得更好的效果\upcite{DBLP:conf/medprai/SurendranathJ18,zhang2018empirical}，实际上这和我们的直觉不太符合，一种合理的解释是课程学习更适合标签噪声、离群值较多或者是目标任务困难的场景，能提高模型的健壮性和收敛速度，而困难优先的策略则更适合数据集干净的场景\upcite{DBLP:conf/nips/ChangLM17}。
\vspace{0.5em}
\end{itemize}
Chapter14/Figures/figure-beamsize-bleu.tex
......@@ -6,7 +6,7 @@ width=8cm,
height=5cm,
yticklabel style={/pgf/number format/.cd,fixed,precision=2},
xticklabel style={/pgf/number format/.cd,fixed,precision=2},
xlabel={\footnotesize{$\log$\;(束大小)}},ylabel={\footnotesize{BLEU\ (\%)}},
xlabel={\footnotesize{搜索束大小（取log）}},ylabel={\footnotesize{BLEU\ (\%)}},
ymin=28.8,ymax=30.4,
xmin=0,xmax=7,
xtick={0,1,2,3,4,5,6,7},
......
Chapter14/Figures/figure-different-softmax.tex
......@@ -57,7 +57,7 @@
\node [font=\small] (label2) at ([yshift=0.6cm]out2.north) {Softmax};
\node [anchor=west,layer,fill=orange!15!white] (net3) at ([xshift=2cm]net2.east) {};
\node [anchor=north,font=\scriptsize] (input3) at ([yshift=-0.5cm]net3.south) {源语};
\node [anchor=north,font=\scriptsize] (input3) at ([yshift=-0.5cm]net3.south) {源语言};
\node [anchor=south,layer,align=center,font=\scriptsize,fill=yellow!10!white] (out3) at ([yshift=0.9cm]net3.north) {候选\\列表};
\draw [->,line width=1pt] (input3) to (net3);
......
Chapter14/chapter14.tex
......@@ -23,7 +23,7 @@
\chapter{神经机器翻译模型推断}
\parinterval 与模型训练不同，神经机器翻译的推断要对新的句子进行翻译。由于训练时双语句子对模型是可见的，但是在推断阶段，模型需要根据输入的源语言句子预测译文，因此神经机器翻译的推断和训练过程有着很大的不同。特别是，推断系统往往对应着机器翻译实际部署的需要，因此推断系统的翻译精度和翻译速度等也是需要考虑的因素。
\parinterval 推断是神经机器翻译中的核心问题。由于训练时双语句子对模型是可见的，但是在推断阶段，模型需要根据输入的源语言句子预测译文，因此神经机器翻译的推断和训练过程有着很大的不同。特别是，推断系统往往对应着机器翻译实际部署的需要，因此机器翻译推断系统的精度和速度等也是实践中需要考虑的。
\parinterval 本章对神经机器翻译模型推断的若干问题进行讨论。主要涉及三方面内容：1）神经机器翻译的基本问题，如推断方向、译文长度控制等；2）神经机器翻译的推断加速方法，如轻量模型、非自回归模型等；3）多模型集成推断。
......@@ -71,23 +71,23 @@
\end{figure}
%----------------------------------------------
\parinterval 这是一个非常通用的框架，同样适用基于统计的机器翻译模型。因此，神经机器翻译推断中的很多问题与统计机器翻译是一致的，比如：束搜索的宽度、解码终止条件等等。
\parinterval 这是一个非常通用的框架，同样适用于统计机器翻译模型。因此，神经机器翻译推断中的很多问题与统计机器翻译是一致的，比如：束搜索的宽度、解码终止条件等等。
\parinterval 一般来说，机器翻译推断系统的设计要考虑三个因素：搜索的准确性、搜索的时延、搜索所需要的存储。通常，准确性是研究人员最关心的问题，比如可以通过增大搜索空间来找到模型得分更高的结果。而搜索的时延和存储消耗是实践中必须要考虑的问题，因此可以设计合理的搜索终止条件降低搜索时延。
\parinterval 一般来说，设计机器翻译推断系统需要考虑三个因素：搜索的准确性、搜索的时延、搜索所需要的存储。通常，准确性是研究人员最关心的问题，比如可以通过增大搜索空间来找到模型得分更高的结果。而搜索的时延和存储消耗是实践中必须要考虑的问题，比如可以设计更小的模型和更高效的推断方法来提高系统的可用性。
\parinterval 虽然，上述问题在统计机器翻译中都有讨论，但是在神经机器翻译中又面临着新的挑战。
\parinterval 虽然，上述问题在统计机器翻译中均有讨论，但是在神经机器翻译中又面临着新的挑战。
\begin{itemize}
\vspace{0.5em}
\item 搜索的基本问题在神经机器翻译中有着特殊的现象。比如，在统计机器翻译中，降低搜索错误是提升翻译品质的一种手段。但是神经机器翻译中，简单的降低搜索错误可能无法带来性能的提升，甚至会造成翻译品质的下降\upcite{li-etal-2018-simple,Stahlberg2019OnNS}；
\vspace{0.5em}
\item 搜索的时延很高，系统实际部署的成本很高。与统计机器翻译系统不同的是，神经机器翻译依赖大量的浮点运算。这导致神经机器翻译系统的推断会比统计机器翻译系统慢很多。虽然可以使用GPU来加快神经机器翻译的推断速度，但是也大大增加了成本；
\item 搜索的时延很高，系统实际部署的成本很高。与统计机器翻译系统不同的是，神经机器翻译依赖大量的浮点运算。这导致神经机器翻译系统的推断会比统计机器翻译系统慢很多。虽然可以使用GPU来提高神经机器翻译的推断速度，但是也大大增加了成本；
\vspace{0.5em}
\item 神经机器翻译在优化过程中容易陷入局部最优，单模型的表现并不稳定。由于神经机器翻译优化的目标函数非常不光滑，每次训练得到的模型往往只是一个局部最优解。在新数据上使用这个局部最优模型进行推断时，模型的表现可能不稳定。
\vspace{0.5em}
\end{itemize}
\parinterval 研究人员也针对以上问题开展了大量的研究工作。在\ref{sec:14-2}节中，会对神经机器翻译推断中所涉及的一些基本问题进行讨论。虽然这些问题在统计机器翻译中均有涉及，但是在神经机器翻译中却有着不同的现象和解决思路。在\ref{sec:14-3}-\ref{sec:14-5}节中，会针对如何改进神经机器翻译推断效率和怎样进行多模型融合这两个问题展开讨论。
\parinterval 研究人员也针对以上问题开展了大量的研究工作。在\ref{sec:14-2}节中，会对神经机器翻译推断中所涉及的一些基本问题进行讨论。虽然这些问题在统计机器翻译中也有涉及，但是在神经机器翻译中却有着不同的现象和解决思路。在\ref{sec:14-3}-\ref{sec:14-5}节中，会围绕如何改进神经机器翻译推断效率和怎样进行多模型融合这两个问题展开讨论。
%----------------------------------------------------------------------------------------
% NEW SECTION
......@@ -95,7 +95,7 @@
\section{基本问题}\label{sec:14-2}
\parinterval 下面将就神经机器翻译推断中的若干基本问题进行讨论，包括：推断方向、译文长度控制、搜索终止条件、{\small\sffamily\bfseries{译文多样性}}\index{译文多样性}（Translation Diversity）\index{Translation Diversity}、搜索错误等。
\parinterval 下面将就神经机器翻译推断中的若干基本问题进行讨论，包括：推断方向、译文长度控制、搜索终止条件、译文多样性、搜索错误五个方面。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -105,20 +105,20 @@
\parinterval 机器翻译有两种常用的推断方式\ \dash \ 自左向右推断和自右向左推断。自左向右推断符合现实世界中人类的语言使用规律，因为人在翻译一个句子时，总是习惯从句子开始的部分往后生成\footnote{有些语言中，文字是自右向左书写，这时自右向左推断更符合人类使用这种语言的习惯。}。不过，有时候人也会使用当前单词后面的译文信息。也就是说，翻译也需要“未来” 的文字信息。于是很容易想到使用自右向左的方法对译文进行生成。
\parinterval 以上两种推断方式在神经机器翻译中都有应用，对于源语言句子$\seq{x}=\{x_1,x_2,\dots,x_m\}$和目标语言句子$\seq{y}=\{y_1,y_2,\dots,y_n\}$，自左向右的翻译可以被描述为公式\eqref{eq:14-1}：
\parinterval 以上两种推断方式在神经机器翻译中都有应用，对于源语言句子$\seq{x}=\{x_1,\dots,x_m\}$和目标语言句子$\seq{y}=\{y_1,\dots,y_n\}$，自左向右的翻译可以被描述为：
\begin{eqnarray}
\funp{P}(\seq{y}\vert\seq{x}) &=& \prod_{j=1}^n \funp{P}(y_j\vert\seq{y}_{<j},\seq{x})
\label{eq:14-1}
\end{eqnarray}
\parinterval 自右向左的翻译可以被描述为公式\eqref{eq:14-2}：
\parinterval 自右向左的翻译可以被描述为：
\begin{eqnarray}
\funp{P}(\seq{y}\vert\seq{x}) &=&\prod_{j=1}^n \funp{P}(y_{n+1-j}\vert\seq{y}_{>n+1-j},\seq{x})
\label{eq:14-2}
\end{eqnarray}
\noindent 其中，$\seq{y}_{<j}=\{y_1,y_2,\dots,y_{j-1}\}$，$\seq{y}_{>j}=\{y_{j+1},y_{j+2},\dots,y_n\}$。可以看到，自左向右推断和自右向左推断本质上是一样的。{\chapterten}到{\chaptertwelve}均使用了自左向右的推断方法。自右向左推断比较简单的实现方式是：在训练过程中直接将双语数据中的目标语言句子进行反转，之后仍然使用原始的模型进行训练即可。在推断的时候，生成的目标语言词串也需要进行反转得到最终的译文。有时候，使用自右向左的推断方式会取得更好的效果\upcite{DBLP:conf/wmt/SennrichHB16}。不过更多情况下需要同时使用词串左端（历史）和右端（未来）的信息。有多种思路可以融合左右两端信息：
\noindent 其中，$\seq{y}_{<j}=\{y_1,\dots,y_{j-1}\}$，$\seq{y}_{>j}=\{y_{j+1},\dots,y_n\}$。可以看到，自左向右推断和自右向左推断本质上是一样的。{\chapterten}到{\chaptertwelve}均使用了自左向右的推断方法。自右向左推断比较简单的实现方式是：在训练过程中直接将双语数据中的目标语言句子进行反转，之后仍然使用原始的模型进行训练即可。在推断的时候，生成的目标语言词串也需要进行反转得到最终的译文。有时候，使用自右向左的推断方式会取得更好的效果\upcite{DBLP:conf/wmt/SennrichHB16}。不过更多情况下需要同时使用词串左端（历史）和右端（未来）的信息。有多种思路可以融合左右两端信息：
\begin{itemize}
\vspace{0.5em}
......@@ -130,9 +130,9 @@
\vspace{0.5em}
\end{itemize}
\parinterval 不论是自左向右还是自右向左推断，本质上都是在对上下文信息进行建模。除了自左向右和自右向左的推断策略，研究人员也提出了许多新的译文生成策略，比如，从中部向外生成\upcite{DBLP:conf/nips/MehriS18}、按源语言顺序生成\upcite{Stahlberg2018AnOS}、基于插入的方式生成\upcite{Stern2019InsertionTF,stling2017NeuralMT}等。或者将翻译问题松弛化为一个连续空间模型的优化问题，进而在推断的过程中同时使用译文左右两端的信息\upcite{Geng2018AdaptiveMD}。
\parinterval 不论是自左向右推断还是自右向左推断，本质上都是在对上下文信息进行建模。此外，研究人员也提出了许多新的译文生成策略，比如，从中部向外生成\upcite{DBLP:conf/nips/MehriS18}、按源语言顺序生成\upcite{Stahlberg2018AnOS}、基于插入的方式生成\upcite{Stern2019InsertionTF,stling2017NeuralMT}等。或者将翻译问题松弛化为一个连续空间模型的优化问题，进而在推断的过程中同时使用译文左右两端的信息\upcite{Geng2018AdaptiveMD}。
\parinterval 最近，以BERT 为代表的预训练语言模型已经证明，一个单词的“历史” 和“未来” 信息对于生成当前单词都是有帮助的\upcite{devlin2019bert}。类似的观点也在神经机器翻译编码器设计中得到验证。比如，在基于循环神经网络的模型中，经常同时使用自左向右和自右向左的方式对源语言句子进行编码。还有，Transformer 编码器会使用整个句子的信息对每一个源语言位置进行表示。因此，在神经机器翻译的解码器采用类似的策略是有其合理性的。
\parinterval 最近，以BERT 为代表的预训练语言模型已经证明，一个单词的“历史” 和“未来” 信息对于生成当前单词都是有帮助的\upcite{devlin2019bert}。类似的观点也在神经机器翻译编码器设计中得到验证。比如，在基于循环神经网络的模型中，经常同时使用自左向右和自右向左的方式对源语言句子进行编码。还有，Transformer 编码器会使用整个句子的信息对每一个源语言位置进行表示。因此，神经机器翻译的推断采用类似的策略是有其合理性的。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -140,7 +140,7 @@
\subsection{译文长度控制}
\parinterval 机器翻译推断的一个特点是译文长度需要额外的机制进行控制\upcite{Kikuchi2016ControllingOL,Takase2019PositionalET,Murray2018CorrectingLB,Sountsov2016LengthBI}。这是因为机器翻译在建模时仅考虑了将训练样本（即标准答案）上的损失最小化，但是推断的时候会看到从未见过的样本，而且这些未见样本占据了样本空间的绝大多数。这时，模型会产生偏置，即模型仅仅能够对见过的样本进行准确建模，而对于未见样本的建模并不准确。该问题导致的一个现象是：直接使用训练好的模型会翻译出长度短得离谱的译文。神经机器翻译模型使用单词概率的乘积表示整个句子的翻译概率，它天然就倾向生成短译文，因为概率为大于0小于1的常数，短译文会使用更少的概率因式相乘，倾向于得到更高的句子得分，而模型只关心每个目标语言位置是否被正确预测，对于译文长度没有考虑。译文长度不合理的问题也出现在统计机器翻译模型中，当时的策略是在推断过程中引入译文长度控制机制\upcite{Koehn2007Moses}。神经机器翻译也借用了类似的思想来控制译文长度，有以下几种方法：
\parinterval 机器翻译推断的一个特点是译文长度需要额外的机制进行控制\upcite{Kikuchi2016ControllingOL,Takase2019PositionalET,Murray2018CorrectingLB,Sountsov2016LengthBI}。这是因为机器翻译在建模时仅考虑了将训练样本（即标准答案）上的损失最小化，但是推断的时候会看到从未见过的样本，而且这些未见样本占据了样本空间的绝大多数。该问题会导致的一个现象是：直接使用训练好的模型会翻译出长度短得离谱的译文。神经机器翻译模型使用单词概率的乘积表示整个句子的翻译概率，它天然就倾向生成短译文，因为概率为大于0小于1的常数，短译文会使用更少的概率因式相乘，倾向于得到更高的句子得分，而模型只关心每个目标语言位置是否被正确预测，对于译文长度没有考虑。译文长度不合理的问题也出现在统计机器翻译模型中，常见的策略是在推断过程中引入译文长度控制机制\upcite{Koehn2007Moses}。神经机器翻译也借用了类似的思想来控制译文长度，有以下几种方法：
\begin{itemize}
\vspace{0.5em}
......@@ -151,7 +151,7 @@
\label{eq:14-12}
\end{eqnarray}
通常$\textrm{lp}(\seq{y})$随$\vert\seq{y}\vert$的增大而增大，（其中$\vert\seq{y}\vert$表示译文长度），因此这种方式相当于对$\log \funp{P}(\seq{y}\vert\seq{x})$按长度进行归一化\upcite{Jean2015MontrealNM}。$\textrm{lp}(\seq{y})$的定义方式有很多，表\ref{tab:14-1}列出了一些常用的形式，其中$\alpha$是需要人为设置的参数。
通常$\textrm{lp}(\seq{y})$随译文长度$\vert\seq{y}\vert$的增大而增大，因此这种方式相当于对$\log \funp{P}(\seq{y}\vert\seq{x})$按长度进行归一化\upcite{Jean2015MontrealNM}。$\textrm{lp}(\seq{y})$的定义方式有很多，表\ref{tab:14-1}列出了一些常用的形式，其中$\alpha$是需要人为设置的参数。
%----------------------------------------------------------------------------------------------------
\begin{table}[htp]
......@@ -178,13 +178,13 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\vspace{0.5em}
\noindent 其中，$\omega_{\textrm{low}}$和$\omega_{\textrm{high}}$分别表示译文长度的下限和上限，比如，很多系统中设置为$\omega_{\textrm{low}}=1/2$，$\omega_{\textrm{high}}=2$，表示译文至少有源语言句子一半长，最多有源语言句子两倍长。$\omega_{\textrm{low}}$和$\omega_{\textrm{high}}$的设置对推断效率影响很大，$\omega_{\textrm{high}}$可以被看作是一个推断的终止条件，最理想的情况是$\omega_{\textrm{high}} \cdot |\seq{x}|$恰巧就等于最佳译文的长度，这时没有浪费任何计算资源。反过来的一种情况，$\omega_{\textrm{high}} \cdot |\seq{x}|$远大于最佳译文的长度，这时很多计算都是无用的。为了找到长度预测的准确率和召回率之间的平衡，一般需要大量的实验最终确定$\omega_{\textrm{low}}$和$\omega_{\textrm{high}}$。当然，利用统计模型预测$\omega_{\textrm{low}}$ 和$\omega_{\textrm{high}}$也是非常值得探索的方向，比如基于繁衍率的模型\upcite{Gu2017NonAutoregressiveNM,Feng2016ImprovingAM}。
\vspace{0.5em}
\item 覆盖度模型。译文长度过长或过短的问题，本质上对应着 {\small\sffamily\bfseries{过翻译}}\index{过翻译}（Over Translation）\index{Over Translation}和{\small\sffamily\bfseries{欠翻译}}\index{欠翻译}（Under Translation）\index{Under Translation}的问题\upcite{Yang2018OtemUtemOA}。这两种问题出现的原因主要在于：神经机器翻译没有对过翻译和欠翻译建模，即机器翻译覆盖度问题\upcite{TuModeling}。针对此问题，最常用的方法是在推断的过程中引入一个度量覆盖度的模型。比如，使用GNMT 覆盖度模型定义模型得分\upcite{Wu2016GooglesNM}，如\eqref{eq:14-5}\eqref{eq:14-6}所示：
\item 覆盖度模型。译文长度过长或过短的问题，本质上对应着 {\small\sffamily\bfseries{过翻译}}\index{过翻译}（Over Translation）\index{Over Translation}和{\small\sffamily\bfseries{欠翻译}}\index{欠翻译}（Under Translation）\index{Under Translation}的问题\upcite{Yang2018OtemUtemOA}。这两种问题出现的原因主要在于：神经机器翻译没有对过翻译和欠翻译建模，即机器翻译覆盖度问题\upcite{TuModeling}。针对此问题，最常用的方法是在推断的过程中引入一个度量覆盖度的模型。比如，使用GNMT 覆盖度模型定义模型得分\upcite{Wu2016GooglesNM}，如下：
\begin{eqnarray}
\textrm{score}(\seq{x},\seq{y}) &=& \frac{\log \funp{P}(\seq{y} | \seq{x})}{\textrm{lp}(\seq{y})} + \textrm{cp}(\seq{x},\seq{y}) \label {eq:14-5}\\
\textrm{cp}(\seq{x},\seq{y}) &=& \beta \cdot \sum_{i=1}^{|\seq{x}|} \log(\textrm{min} (\sum_{j}^{|\seq{y}|} a_{ij} , 1))
\label{eq:14-6}
\end{eqnarray}
\noindent 其中，$\textrm{cp}(\seq{x},\seq{y}) $表示覆盖度模型，它度量了译文对源语言每个单词的覆盖程度。$\textrm{cp}(\seq{x},\seq{y}) $的定义中，$\beta$是一需要自行设置的超参数，$a_{ij}$表示源语言第$i$个位置与译文 第$j$个位置的注意力权重，这样$\sum \limits_{j}^{|\seq{y}|} a_{ij}$就可以用来衡量源语言第$i$个单词被翻译了“多少”，如果它大于1，表明翻译多了；如果小于1，表明翻译少了。公式\eqref{eq:14-6}会惩罚那些欠翻译的翻译假设。公式\eqref{eq:14-7}时覆盖度模型的一种改进形式\upcite{li-etal-2018-simple}：
\noindent 其中，$\textrm{cp}(\seq{x},\seq{y}) $表示覆盖度模型，它度量了译文对源语言每个单词的覆盖程度。$\textrm{cp}(\seq{x},\seq{y}) $的定义中，$\beta$是一需要自行设置的超参数，$a_{ij}$表示源语言第$i$个位置与译文 第$j$个位置的注意力权重，这样$\sum \limits_{j}^{|\seq{y}|} a_{ij}$就可以用来衡量源语言第$i$个单词被翻译了“多少”，如果它大于1，表明翻译多了；如果小于1，表明翻译少了。公式\eqref{eq:14-6}会惩罚那些欠翻译的翻译假设。对覆盖度模型的一种改进形式是\upcite{li-etal-2018-simple}：
\begin{eqnarray}
\textrm{cp}(\seq{x},\seq{y}) &=& \sum_{i=1}^{|\seq{x}|} \log( \textrm{max} ( \sum_{j}^{|\seq{y}|} a_{ij},\beta))
......@@ -244,9 +244,9 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{搜索错误}
\parinterval 机器翻译的错误分为两类：搜索错误和模型错误。搜索错误是指由于搜索算法的限制，即使潜在的搜索空间中有更好的解，模型也无法找到。比较典型的例子是，在对搜索结果进行剪枝的时候，如果剪枝过多，找到的结果很有可能不是最优的。这时就出现了搜索错误。而模型错误则是指由于模型学习能力的限制，潜在的搜索空间过小而无法将最优解包含其中。
\parinterval 机器翻译的错误分为两类：搜索错误和模型错误。搜索错误是指由于搜索算法的限制，即使潜在的搜索空间中有更好的解，模型也无法找到。比较典型的例子是，在对搜索结果进行剪枝的时候，如果剪枝过多，找到的结果很有可能不是最优的。这时就出现了搜索错误。而模型错误则是指由于模型学习能力的限制无法将好的结果排序在前面，即使这个结果在搜索空间中被覆盖到。
\parinterval 在统计机器翻译中，搜索错误可以通过减少剪枝进行缓解。比较简单的方式是增加搜索束宽度，这往往会带来一定的性能提升\upcite{Xiao2016ALA}。也可以对搜索问题进行单独建模，以保证学习到的模型出现更少的搜索错误\upcite{Liu2014SearchAwareTF,Yu2013MaxViolationPA}。但是，在神经机器翻译中，这个问题却表现出不同的现象：在很多神经机器翻译系统中，随着搜索束的增大，系统的BLEU不升反降。图\ref{fig:14-3}展示了BLEU随束大小的变化曲线\footnote{为了使该图更加规整直观，横坐标处将束大小进行了取对数操作。}。这个现象与传统的常识是相违背的，因此也有一些研究尝试解释这个现象\upcite{Stahlberg2019OnNS,Niehues2017AnalyzingNM}。在实验中，研究人员也发现增加搜索束的大小会导致翻译生成的结果变得更短。他们将这个现象归因于：神经机器翻译的建模基于局部归一的最大似然估计，增加搜索束的大小，会导致更多的模型错误\upcite{Sountsov2016LengthBI,Murray2018CorrectingLB,StahlbergNeural}。此外，也有研究人员把这种翻译过短的现象归因于搜索错误\upcite{Stahlberg2019OnNS}。由于搜索时所面临的搜索空间是十分巨大的，因此搜索时可能无法找到模型定义的“最好”的译文。在某种意义上，这也体现了训练和推断不一致的问题。
\parinterval 在统计机器翻译中，搜索错误可以通过减少剪枝进行缓解。比较简单的方式是增加搜索束宽度，这往往会带来一定的性能提升\upcite{Xiao2016ALA}。也可以对搜索问题进行单独建模，以保证学习到的模型出现更少的搜索错误\upcite{Liu2014SearchAwareTF,Yu2013MaxViolationPA}。但是，在神经机器翻译中，这个问题却表现出不同的现象：在很多神经机器翻译系统中，随着搜索束的增大，系统的BLEU不升反降。图\ref{fig:14-3}展示了BLEU随束大小的变化曲线，这里为了使该图更加规整直观，横坐标处将束大小进行了取对数操作。这个现象与传统的常识是相违背的，因此也有一些研究尝试解释这个现象\upcite{Stahlberg2019OnNS,Niehues2017AnalyzingNM}。在实验中，研究人员发现增加搜索束的大小会导致翻译生成的结果变得更短。他们将这个现象归因于：神经机器翻译的建模基于局部归一的最大似然估计，增加搜索束的大小，会导致更多的模型错误\upcite{Sountsov2016LengthBI,Murray2018CorrectingLB,StahlbergNeural}。此外，也有研究人员把这种翻译过短的现象归因于搜索错误\upcite{Stahlberg2019OnNS}。 由于搜索时所面临的搜索空间是十分巨大的，因此搜索时可能无法找到模型定义的“最好”的译文。在某种意义上，这也体现了训练和推断不一致的问题（见{\chapterthirteen}）。
%----------------------------------------------------------------------
\begin{figure}[htp]
......@@ -257,7 +257,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\end{figure}
%----------------------------------------------------------------------
\parinterval 一种解决问题的思路是从训练和推断的行为和目标不一致的角度切入。比如，为了解决曝光偏置问题\upcite{Ranzato2016SequenceLT}，可以让系统使用前面步骤的预测结果作为预测下一个词所需要的历史信息，而不是依赖于标准答案\upcite{Bengio2015ScheduledSF,Zhang2019BridgingTG}。为了解决训练和推断目标不一致的问题，可以在训练的时候模拟推断的行为，同时让模型训练的目标与评价系统的标准尽可能一致\upcite{DBLP:conf/acl/ShenCHHWSL16}。
\parinterval 一种解决问题的思路是从训练和推断行为不一致的角度切入。比如，为了解决曝光偏置问题\upcite{Ranzato2016SequenceLT}，可以让系统使用前面步骤的预测结果作为预测下一个词所需要的历史信息，而不是依赖于标准答案\upcite{Bengio2015ScheduledSF,Zhang2019BridgingTG}。为了解决训练和推断目标不一致的问题，可以在训练的时候模拟推断的行为，同时让模型训练的目标与评价系统的标准尽可能一致\upcite{DBLP:conf/acl/ShenCHHWSL16}。
\parinterval 需要注意的是，前面提到的搜索束变大造成的翻译品质下降的问题还有其它解决方法。比如，可以通过对结果重排序来缓解这个问题\upcite{DBLP:conf/emnlp/Yang0M18}，也可以通过设计更好的覆盖度模型来生成长度更加合理的译文\upcite{li-etal-2018-simple}。从这个角度说，上述问题的成因也较为复杂，因此需要同时考虑模型错误和搜索错误。
......@@ -267,7 +267,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\section{轻量模型}\label{sec:14-3}
\parinterval 翻译速度和翻译精度之间的平衡是机器翻译系统研发中的常见问题。即使是以提升翻译品质为目标的任务（如用BLEU进行评价），也不得不考虑翻译速度的影响。比如，在很多任务中会使用反向翻译构造伪数据，涉及对大规模单语数据的翻译；无监督机器翻译中也会频繁地使用神经机器翻译系统构造训练数据。如果翻译速度过慢会增大实验的周期。从应用的角度看，在很多场景下翻译速度甚至比翻译品质更重要。比如，在线翻译和一些小设备上的机器翻译系统都需要保证相对低的翻译时延，以满足用户体验的最基本要求。虽然，我们希望能有一套又好又快的翻译系统，但是现实的情况是：往往需要通过牺牲一些翻译品质来换取翻译速度的提升。下面就列举一些常用的神经机器翻译轻量模型和加速方法。这些方法通常是应用在解码器，因为相比编码器，神经机器翻译的解码器是推断过程中最耗时的部分。
\parinterval 翻译速度和翻译精度之间的平衡是机器翻译系统研发中的常见问题。即使是以提升翻译品质为目标的任务（如用BLEU进行评价），也不得不考虑翻译速度的影响。比如，在很多任务中会构造伪数据，涉及对大规模单语数据的翻译；无监督机器翻译中也会频繁地使用神经机器翻译系统构造训练数据。如果翻译速度过慢会增大实验的周期。从应用的角度看，在很多场景下翻译速度甚至比翻译品质更重要。比如，在线翻译和一些小设备上的机器翻译系统都需要保证相对低的翻译时延，以满足用户体验的最基本要求。虽然，我们希望能有一套又好又快的翻译系统，但是现实的情况是：往往需要通过牺牲一些翻译品质来换取翻译速度的提升。下面就列举一些常用的神经机器翻译轻量模型和加速方法。这些方法通常是应用在神经机器翻译的解码器，因为相比编码器，解码器是推断过程中最耗时的部分。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -275,9 +275,9 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{输出层的词汇选择}
\parinterval 神经机器翻译需要对输入和输出的单词进行分布式表示，比如，每一个单词都用一个512 维向量进行表示。但是，由于真实的词表通常很大，因此计算并保存这些单词的向量表示会消耗较多的计算和存储资源。特别是对于基于Softmax 的输出层，使用大词表往往会占用较多的系统运算时间。虽然可以通过BPE 和限制词汇表规模的方法降低输出层计算的负担\upcite{DBLP:conf/acl/SennrichHB16a}，但是为了获得可接受的翻译品质，词汇表也不能过小，因此输出层的计算仍然十分耗时。
\parinterval 神经机器翻译需要对输入和输出的单词进行分布式表示。但是，由于真实的词表通常很大，因此计算并保存这些单词的向量表示会消耗较多的计算和存储资源。特别是对于基于Softmax 的输出层，大词表的计算十分耗时。虽然可以通过BPE 和限制词汇表规模的方法降低输出层计算的负担\upcite{DBLP:conf/acl/SennrichHB16a}，但是为了获得可接受的翻译品质，词汇表也不能过小，因此输出层的计算代价仍然很高。
\parinterval 通过改变输出层的网络结构，可以一定程度上缓解这个问题\upcite{DBLP:conf/acl/JeanCMB15}。一种比较简单的方法是对可能输出的单词进行筛选，简称词汇选择。这里，可以利用类似于统计机器翻译的翻译表，获得每个源语言单词最可能的译文。在翻译过程中，利用注意力机制找到每个目标语言位置对应的源语言位置，之后获得这些源语言单词最可能的翻译候选。之后，Softmax 只需要在这个有限的翻译候选单词集合上进行计算，大大降低了输出层的计算量。尤其对于CPU 上的系统，这个方法往往会带来明显的速度提升，同时保证翻译品质。图\ref{fig:14-4}给出了词汇选择方法的示意图。
\parinterval 通过改变输出层的结构，可以一定程度上缓解这个问题\upcite{DBLP:conf/acl/JeanCMB15}。一种比较简单的方法是对可能输出的单词进行筛选，即词汇选择。这里，可以利用类似于统计机器翻译的翻译表，获得每个源语言单词最可能的译文。在翻译过程中，利用注意力机制找到每个目标语言位置对应的源语言位置，之后获得这些源语言单词最可能的翻译候选。之后，Softmax 只需要在这个有限的翻译候选单词集合上进行计算，大大降低了输出层的计算量。尤其对于CPU 上的系统，这个方法往往会带来明显的速度提升。图\ref{fig:14-4}给出了词汇选择方法的示意图。
%----------------------------------------------
\begin{figure}[htp]
......@@ -296,7 +296,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{消除冗余计算}
\parinterval 消除不必要的计算是加速机器翻译系统的另一种方法。比如，在统计机器翻译时代，假设重组就是一种典型的避免冗余计算的手段（见\chapterseven）。对于神经机器翻译中的Transformer 模型，消除冗余计算的一种简单有效的方法是对解码器的注意力结果进行缓存。在生成每个译文时，Transformer 模型会对当前位置之前的所有位置进行自注意力操作，但是这些计算里只有和当前位置相关的计算是“新” 的，前面位置之间的注意力结果已经在之前的解码步骤里计算过，因此可以对其进行缓存。
\parinterval 消除不必要的计算是加速机器翻译系统的另一种方法。比如，在统计机器翻译时代，假设重组就是一种典型的避免冗余计算的手段（见{\chapterseven}）。对于神经机器翻译中，消除冗余计算的一种简单有效的方法是对解码器的注意力结果进行缓存。以Transformer为例，在生成每个译文时，Transformer 模型会对当前位置之前的所有位置进行自注意力操作，但是这些计算里只有和当前位置相关的计算是“新” 的，前面位置之间的注意力结果已经在之前的解码步骤里计算过，因此可以对其进行缓存。
\parinterval 此外，由于Transformer 模型较为复杂，还存在很多冗余。比如，Transformer 的每一层会包含自注意力机制、层正则化、残差连接、前馈神经网络等多种不同的结构。同时，不同结构之间还会包含一些线性变换。多层Transformer模型会更加复杂。但是，这些层可能在做相似的事情，甚至有些计算根本就是重复的。图\ref{fig:14-5}中展示了解码器自注意力和编码-解码注意力中不同层的注意力权重的相似性，这里的相似性利用Jensen-Shannon散度进行度量\upcite{61115}。可以看到，自注意力中，2-6层之间的注意力权重的分布非常相似。编码-解码注意力也有类似的现象，临近的层之间有非常相似的注意力权重。这个现象说明：在多层神经网络中有些计算是冗余的，因此很自然的想法是消除这些冗余使得机器翻译变得更“轻”。
......@@ -331,13 +331,13 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\parinterval 在推断时，神经机器翻译的解码器是最耗时的，因为每个目标语言位置需要单独输出单词的分布，同时在搜索过程中每一个翻译假设都要被扩展成多个翻译假设，进一步增加了计算量。因此，另一种思路是使用更加轻量的解码器加快翻译假设的生成速度\upcite{Hinton2015Distilling,Munim2019SequencelevelKD}。
\parinterval 比较简单的做法是把解码器的网络变得更“浅”、更“窄”。所谓浅网络是指使用更少的层构建神经网络，比如，使用3 层，甚至1 层网络的Transformer 解码器。所谓窄网络是指将网络中某些层中神经元的数量减少。不过，直接训练这样的小模型会带来翻译品质的下降。这时会考虑使用知识蒸馏（也称作知识精炼）等技术来提升小模型的品质。
\parinterval 比较简单的做法是把解码器的网络变得更“浅”、更“窄”。所谓浅网络是指使用更少的层构建神经网络，比如，使用3 层，甚至1 层网络的Transformer 解码器。所谓窄网络是指将网络中某些层中神经元的数量减少。不过，直接训练这样的小模型会带来翻译品质的下降。这时会考虑使用知识蒸馏等技术来提升小模型的品质（见{\chapterthirteen}）。
\parinterval 另一种思路是化简Transformer 解码器的神经网络。比如，可以使用平均注意力机制代替原始Transformer 中的自注意力机制\upcite{DBLP:journals/corr/abs-1805-00631}，也可以使用运算更轻的卷积操作代替注意力模块\upcite{Wu2019PayLA}。前面提到的基于共享注意力机制的模型也是一种典型的轻量模型\upcite{Xiao2019SharingAW}。这些方法本质上也是对注意力模型结构的优化，这类思想在近几年也受到了很多关注 \upcite{Kitaev2020ReformerTE,Katharopoulos2020TransformersAR,DBLP:journals/corr/abs-2006-04768}。
\parinterval 另一种思路是化简Transformer 解码器的神经网络。比如，可以使用平均注意力机制代替原始Transformer 中的自注意力机制\upcite{DBLP:journals/corr/abs-1805-00631}，也可以使用运算更轻的卷积操作代替注意力模块\upcite{Wu2019PayLA}。前面提到的基于共享注意力机制的模型也是一种典型的轻量模型\upcite{Xiao2019SharingAW}。这些方法本质上也是对注意力模型结构的优化，这类思想在近几年也受到了很多关注 \upcite{Kitaev2020ReformerTE,Katharopoulos2020TransformersAR,DBLP:journals/corr/abs-2006-04768}，在{\chapterfifteen}也会有进一步讨论。
\parinterval 此外，使用异构神经网络也是一种平衡精度和速度的有效方法。在很多研究中发现，基于Transformer 的编码器对翻译品质的影响更大，而解码器的作用会小一些。因此，一种想法是使用速度更快的解码器结构，比如，用基于循环神经网络的解码器代替Transformer模型中基于注意力机制的解码器\upcite{Chen2018TheBO}。这样，既能发挥Transformer 在编码上的优势，同时也能利用循环神经网络在解码器速度上的优势。使用类似的思想，也可以用卷积神经网络等结构进行解码器的设计。
\parinterval 针对轻量级Transformer模型的设计也包括层级的结构剪枝，这类方法试图通过跳过某些操作或者某些层来降低计算量。典型的相关工作是样本自适应网络结构，如 FastBERT\upcite{Liu2020FastBERTAS}、Depth Adaptive Transformer\upcite{Elbayad2020DepthAdaptiveT}等，与传统的Transformer的解码过程不同，这类网络结构在推断时不需要计算全部的解码层，而是根据输入自动选择模型的部分层进行计算，达到加速和减少参数量的目的。
\parinterval 针对轻量级Transformer模型的设计也包括层级的结构剪枝，这类方法试图通过跳过某些操作或者某些层来降低计算量。典型的相关工作是样本自适应神经网络结构，如 FastBERT\upcite{Liu2020FastBERTAS}、Depth Adaptive Transformer\upcite{Elbayad2020DepthAdaptiveT}等，与传统的Transformer的解码过程不同，这类神经网络结构在推断时不需要计算全部的解码层，而是根据输入自动选择模型的部分层进行计算，达到加速和减少参数量的目的。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -353,7 +353,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\vspace{0.5em}
\item 批次生成策略。对于源语言文本预先给定的情况，通常是按句子长度组织每个批次，即：把长度相似的句子放到一个批次里。这样做的好处是可以尽可能保证一个批次中的内容是“满” 的，否则如果句长差异过大会造成批次中有很多位置用占位符填充，产生无用计算。对于实时翻译的情况，批次的组织较为复杂。由于有翻译时延的限制，可能无法等到有足够多的句子就要进行翻译。常见的做法是，设置一个等待的时间，在同一个时间段中的句子可以放到一个批次中（或者几个批次中）。对于高并发的情况，也可以考虑使用不同的{\small\sffamily\bfseries{桶}}\index{桶}（Bucket\index{Bucket}）保存不同长度范围的句子，之后将同一个桶中的句子进行批量推断。这个问题在{\chaptereighteen}中还会做进一步讨论。
\vspace{0.5em}
\item 批次大小的选择。一个批次中的句子数量越多，GPU 设备的利用率越高，系统吞吐越大。但是，一个批次中所有句子翻译结束后才能拿到翻译结果，因此批次中有些句子即使已经翻译结束也要等待其它没有完成的句子。也就是说，从单个句子来看，批次越大翻译的延时越长，这也导致在翻译实时性要求较高的场景中，不能使用过大的批次。而且，大批次对GPU 显存的消耗更大，因此也需要根据具体任务合理选择批次大小。为了说明这些问题，图\ref{fig:14-7}展示了不同批次大小下的吞吐、时延和显存消耗。
\item 批次大小的选择。一个批次中的句子数量越多，GPU 设备的利用率越高，系统吞吐越大。但是，一个批次中所有句子翻译结束后才能拿到翻译结果，因此批次中有些句子即使已经翻译结束也要等待其它没有完成的句子。也就是说，从单个句子来看，批次越大翻译的延时越长，这也导致在翻译实时性要求较高的场景中，不能使用过大的批次。而且，大批次对GPU 显存的消耗更大，因此也需要根据具体任务合理选择批次大小。为了说明这些问题，图\ref{fig:14-7}展示了不同批次大小下的时延和显存消耗。
\vspace{0.5em}
\end{itemize}
......@@ -361,7 +361,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\begin{figure}[htp]
\centering
\input{./Chapter14/Figures/figure-batch-time-mem}
\caption{Transformer系统在不同批次大小下的吞吐、延时和显存消耗}
\caption{神经机器翻译系统在不同批次大小下的延时和显存消耗}
\label{fig:14-7}
\end{figure}
%----------------------------------------------
......@@ -378,7 +378,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\vspace{0.5em}
\item 半精度浮点运算。半精度浮点运算是随着近几年GPU 技术发展而逐渐流行的一种运算方式。简单来说，半精度的表示要比单精度需要更少的存储单元，所表示的浮点数范围也相应的变小。不过，实践中已经证明神经机器翻译中的许多运算用半精度计算就可以满足对精度的要求。因此，直接使用半精度运算可以大大加速系统的训练和推断进程，同时对翻译品质的影响很小。不过，需要注意的是，在分布式训练的时候，由于参数服务器需要对多个计算节点上的梯度进行累加，因此保存参数时仍然会使用单精度浮点以保证多次累加之后不会造成过大的精度损失。
\vspace{0.5em}
\item 整型运算。整型运算是一种比浮点运算“轻” 很多的运算。无论是芯片占用面积、能耗还是处理单次运算的时钟周期数，整型运算相比浮点运算都有着明显的优势。因此，使用整型运算也是很有潜力的加速手段。不过，整数的表示和浮点数有着很大的不同。一个基本的问题是，整数是不连续的，因此无法准确的刻画浮点数中很小的小数。对于这个问题，一种解决方法是利用“量化+ 反量化+ 缩放” 的策略让整型运算达到近似浮点运算的效果\upcite{DBLP:journals/corr/abs-1906-00532,DBLP:conf/cvpr/JacobKCZTHAK18,DBLP:journals/corr/abs-1910-10485}。所谓“量化” 就是把一个浮点数离散化为一个整数，“反量化” 是这个过程的逆过程。由于浮点数可能超出整数的范围，因此会引入一个缩放因子。在量化前将浮点数缩放到整数可以表示的范围，反量化前再缩放回原始浮点数的表示范围。这种方法在理论上可以带来很好的加速效果。不过由于量化和反量化的操作本身也有时间消耗，而且在不同处理器上的表现差异较大。因此不同的实现方式带来的加速效果并不相同，需要通过实验测算。
\item 整型运算。整型运算是一种比浮点运算“轻” 很多的运算。无论是芯片占用面积、能耗还是处理单次运算的时钟周期数，整型运算相比浮点运算都有着明显的优势。不过，整数的表示和浮点数有着很大的不同。一个基本的问题是，整数是不连续的，因此无法准确的刻画浮点数中很小的小数。对于这个问题，一种解决方法是利用“量化+ 反量化+ 缩放” 的策略让整型运算达到近似浮点运算的效果\upcite{DBLP:journals/corr/abs-1906-00532,DBLP:conf/cvpr/JacobKCZTHAK18,DBLP:journals/corr/abs-1910-10485}。所谓“量化” 就是把一个浮点数离散化为一个整数，“反量化” 是这个过程的逆过程。由于浮点数可能超出整数的范围，因此会引入一个缩放因子。在量化前将浮点数缩放到整数可以表示的范围，反量化前再缩放回原始浮点数的表示范围。这种方法在理论上可以带来很好的加速效果。不过由于量化和反量化的操作本身也有时间消耗，而且在不同处理器上的表现差异较大。因此不同的实现方式带来的加速效果并不相同，需要通过实验测算。
\vspace{0.5em}
\item 低精度整型运算。使用更低精度的整型运算是进一步加速的手段之一。比如使用16 位整数、8 位整数，甚至4 位整数在理论上都会带来速度的提升，如表\ref{tab:14-3}所示。不过，并不是所有处理器都支持低精度整型的运算。开发这样的系统，一般需要硬件和特殊低精度整型计算库的支持。而且相关计算大多是在CPU 上实现，应用会受到一定的限制。
\vspace{0.5em}
......@@ -397,7 +397,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\footnotetext{表中比较了几种通用数据类型的乘法运算速度，不同硬件和架构上不同类型的数据的计算速度略有不同。总体来看整型数据类型和浮点型数据相比具有显著的计算速度优势，INT4相比于FP32数据类型的计算最高能达到8倍的速度提升。}
%--------------------------------------
\parinterval 实际上，低精度表示的另一个好处是可以减少模型存储的体积。比如，如果要把机器翻译模型作为软件的一部分打包存储，这时可以考虑用低精度的方式保存模型参数，使用时再恢复成原始精度的参数。值得注意的是，参数的离散化表示（比如整型表示）的一个极端例子是{\small\sffamily\bfseries{二值网络}}\index{二值网络}（Binarized Neural Networks）\index{Binarized Neural Networks}\upcite{DBLP:conf/nips/HubaraCSEB16}，即只用−1和+1 表示神经网络的每个参数\footnote{也存在使用0或1表示神经网络参数的二值网络。}。二值化可以被看作是一种极端的量化手段。不过，这类方法还没有在机器翻译中得到大规模验证。
\parinterval 实际上，低精度运算的另一个好处是可以减少模型存储的体积。比如，如果要把机器翻译模型作为软件的一部分打包存储，这时可以考虑用低精度的方式保存模型参数，使用时再恢复成原始精度的参数。值得注意的是，参数的离散化表示（比如整型表示）的一个极端例子是{\small\sffamily\bfseries{二值网络}}\index{二值网络}（Binarized Neural Networks）\index{Binarized Neural Networks}\upcite{DBLP:conf/nips/HubaraCSEB16}，即只用−1和+1 表示神经网络的每个参数\footnote{也存在使用0或1表示神经网络参数的二值网络。}。二值化可以被看作是一种极端的量化手段。不过，这类方法还没有在机器翻译中得到大规模验证。
%----------------------------------------------------------------------------------------
% NEW SECTION
......@@ -405,15 +405,15 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\section{非自回归翻译}
\parinterval 目前大多数神经机器翻译模型都使用了编码器-解码器框架，编码器的输出会被送入到解码器，解码器自左向右逐词生成译文，也就是，第$j$个目标语言单词的生成依赖于先前生成的$j-1$个词。这种翻译方式也被称作{\small\sffamily\bfseries{自回归解码}}\index{自回归解码}（Autoregressive Decoding）\index{Autoregressive Decoding}。虽然以Transformer为代表的模型使得训练过程高度并行化，加快了训练速度。但由于推断过程自回归的特性，模型无法同时生成译文中的所有单词，这导致模型的推断过程非常缓慢，这对于神经机器翻译的实际应用是个很大的挑战。因此，如何设计一个在训练和推断阶段都能够并行化的模型是目前研究的热点之一。
\parinterval 目前大多数神经机器翻译模型都使用自左向右逐词生成译文的策略，也就是，第$j$个目标语言单词的生成依赖于先前生成的$j-1$ 个词。这种翻译方式也被称作{\small\sffamily\bfseries{自回归解码}}\index{自回归解码}（Autoregressive Decoding）\index{Autoregressive Decoding}。虽然以Transformer为代表的模型使得训练过程高度并行化，加快了训练速度。但由于推断过程自回归的特性，模型无法同时生成译文中的所有单词，这导致模型的推断过程非常缓慢，这对于神经机器翻译的实际应用是个很大的挑战。因此，如何设计一个在训练和推断阶段都能够并行化的模型是目前研究的热点之一。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsection{自回归VS非自回归}
\subsection{自回归 vs 非自回归}
\parinterval 目前主流的神经机器翻译的推断是一种{\small\sffamily\bfseries{自回归翻译}}\index{自回归翻译}（Autoregressive Translation）\index{Autoregressive Translation}过程。所谓自回归是一种描述时间序列生成的方式。对于目标序列$\seq{y}=\{y_1,\dots,y_n\}$，自回归模型假设$j$时刻状态$y_j$的生成依赖于之前的状态$\{y_1,\dots,y_{j-1}\}$，而且$y_j$与$\{y_1,\dots,y_{j-1}\}$构成线性关系，那么生成$y_j$就是自回归的序列生成过程。神经机器翻译借用了这个概念，但是并不要求使用线性模型，\ref{sec:14-2-1}节提到的自左向右翻译模型和自右向左翻译模型都属于自回归翻译模型。自回归模型在在机器翻译等任务上也取得了较好的性能，特别是配合束搜索也能够有效地寻找近似最优译文。但是，由于解码器的每个步骤必须顺序地而不是并行地运行，自回归翻译模型会阻碍不同译文单词生成的并行化。特别是在GPU 上，翻译的自回归性会大大降低计算的并行度，导致推断过程的效率比较低下，设备利用率低。
\parinterval 目前主流的神经机器翻译的推断是一种{\small\sffamily\bfseries{自回归翻译}}\index{自回归翻译}（Autoregressive Translation）\index{Autoregressive Translation}过程。所谓自回归是一种描述时间序列生成的方式。对于目标序列$\seq{y}=\{y_1,\dots,y_n\}$，自回归模型假设$j$时刻状态$y_j$的生成依赖于之前的状态$\{y_1,\dots,y_{j-1}\}$，而且$y_j$与$\{y_1,\dots,y_{j-1}\}$构成线性关系，那么生成$y_j$就是自回归的序列生成过程。神经机器翻译借用了这个概念，但是并不要求使用线性模型，\ref{sec:14-2-1}节提到的自左向右翻译模型和自右向左翻译模型都属于自回归翻译模型。自回归模型在机器翻译任务上也有很好的表现，特别是配合束搜索也能够有效地寻找近似最优译文。但是，由于解码器的每个步骤必须顺序地而不是并行地运行，自回归翻译模型会阻碍不同译文单词生成的并行化。特别是在GPU 上，翻译的自回归性会大大降低计算的并行度，设备利用率低。
\parinterval 对于这个问题，研究人员也考虑移除翻译的自回归性，进行{\small\sffamily\bfseries{非自回归翻译}}\index{非自回归翻译}（Non-Autoregressive Translation，NAT）\index{Non-Autoregressive Translation}\upcite{Gu2017NonAutoregressiveNM}。一个简单的非自回归翻译模型将问题建模为公式\eqref{eq:14-9}：
......@@ -422,7 +422,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\label{eq:14-9}
\end{eqnarray}
\noindent 其中，位置$j$上的输出$y_j$只依赖于输入句子$\seq{x}$，与其它位置上的输出无关。于是，所有位置上${y_j}$都可以并行生成，大大提高了GPU 等并行运算设备的利用率。理想情况下，这种方式一般可以带来几倍甚至十几倍的速度提升。
\parinterval 对比公式\eqref{eq:14-1}可以看出，公式\eqref{eq:14-9}中位置$j$上的输出$y_j$只依赖于输入句子$\seq{x}$，与其它位置上的输出无关。于是，所有位置上${y_j}$都可以并行生成。理想情况下，这种方式一般可以带来几倍甚至十几倍的速度提升。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -430,20 +430,20 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{非自回归翻译模型的结构}
\parinterval 在介绍非自回归模型的具体结构之前，先来看看如何实现一个简单的非自回归翻译模型。这里用标准的Transformer来举例。首先为了一次性生成所有的词，需要丢弃解码器对未来信息屏蔽的矩阵，从而去掉模型的自回归性。此外，还要考虑生成译文的长度。自回归模型每步的输入是上一步解码出的结果，当预测到终止符<eos>时序列的生成就自动停止了，然而非自回归模型却没有这样的特性，因此还需要一个长度预测器来预测出其长度，之后再用这个长度得到每个位置的表示，进而完成整个序列的生成。
\parinterval 在介绍非自回归模型的具体结构之前，先来看看如何实现一个简单的非自回归翻译模型。这里用标准的Transformer来举例。首先为了一次性生成所有的词，需要丢弃解码器对未来信息屏蔽的矩阵，从而去掉模型的自回归性。此外，还要考虑生成译文的长度。自回归模型每步的输入是上一步解码出的结果，当预测到终止符<eos>时，序列的生成就自动停止了，然而非自回归模型却没有这样的特性，因此还需要一个长度预测器来预测出其长度，之后再用这个长度得到每个位置的表示，进而完成整个序列的生成。
\parinterval 图\ref{fig:14-12}就是一个最简单的非自回归翻译模型，它的推断过程可以一次性解码出完整的译文。但是这样得到的模型所翻译出的句子质量很低。比如，在IWSLT英德等数据上的BLEU值只有个位数，而现在最好的自回归模型已经能够达到30左右的BLEU值。这是因为每个位置词的分布$\funp{P}(y_j)$只依赖于源语言句子$\seq{x}$，使得$\funp{P}(y_j)$的预测不准确。
\parinterval 图\ref{fig:14-12}对比了自回归翻译模型和简单的非自回归翻译模型。可以看到这种自回归翻译模型可以一次性生成完整的译文。不过，高并行性也带来了翻译品质的下降。比如，在IWSLT 英德等数据上的BLEU[\%] 值只有个位数，而现在最好的自回归模型已经能够达到30左右的BLEU得分。这是因为每个位置词的预测只依赖于源语言句子$\seq{x}$，使得预测不准确。
%----------------------------------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter14/Figures/figure-non-autoregressive}
\caption{一个简单的非自回归模型}
\caption{自回归翻译模型 vs 非自回归翻译模型}
\label{fig:14-12}
\end{figure}
%----------------------------------------------------------------------
\parinterval 完全独立地对每个词建模，会出现什么问题呢？来看一个例子，将汉语句子“干/得/好/！”翻译成英文，可以翻译成“Good job !”或者“Well done !”。假设生成这两种翻译的概率是相等的，即一半的概率是“Good job !”，另一半的概率是“Well done !”。由于非自回归模型的条件独立性假设，推断时第一个词“Good”和“Well”的概率是差不多大的，第二个词“job”和“done”的概率差不多大的，会使得模型生成出“Good done !”或者“Well job !”这样错误的翻译，如图\ref{fig:14-13}所示。这便是影响句子质量的关键问题，称之为{\small\sffamily\bfseries{多峰问题}}\index{多峰问题}（Multi-modality Problem）\index{Multi-modality Problem}\upcite{Gu2017NonAutoregressiveNM}。如何有效处理非自回归模型中的多峰问题 是提升非自回归模型质量的关键。
\parinterval 完全独立地对每个词建模，会出现什么问题呢？来看一个例子，将汉语句子“干/得/好/！”翻译成英文，可以翻译成“Good job !”或者“Well done !”。假设生成这两种翻译的概率是相等的，即一半的概率是“Good job !”，另一半的概率是“Well done !”。由于非自回归模型的条件独立性假设，推断时第一个词“Good”和“Well”的概率是差不多大的，如果第二个词“job”和“done”的概率也差不多大，会使得模型生成出“Good done !”或者“Well job !”这样错误的翻译，如图\ref{fig:14-13}所示。这便是影响句子质量的关键问题，称之为{\small\sffamily\bfseries{多峰问题}}\index{多峰问题}（Multi-modality Problem）\index{Multi-modality Problem}\upcite{Gu2017NonAutoregressiveNM}。如何有效处理非自回归模型中的多峰问题 是提升非自回归模型质量的关键。
%----------------------------------------------------------------------
\begin{figure}[htp]
......@@ -454,7 +454,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\end{figure}
%----------------------------------------------------------------------
\parinterval 因此，非自回归翻译方面的研究大多集中在针对以上问题的求解。有三个角度：使用繁衍率预测译文长度、使用句子级知识蒸馏来降低学习难度、使用自回归模型进行翻译候选打分。下面将依次对这些方法进行介绍。
\parinterval 因此，非自回归翻译的研究大多集中在针对以上问题的求解。有三个角度：使用繁衍率预测译文长度、使用句子级知识蒸馏来降低学习难度、使用自回归模型进行翻译候选打分。下面将依次对这些方法进行介绍。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -462,9 +462,9 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsubsection{1. 基于繁衍率的非自回归模型}
\parinterval 图\ref{fig:14-14}给出了基于繁衍率的Transformer非自回归模型的结构\upcite{Gu2017NonAutoregressiveNM}，由三个模块组成:编码器，解码器，繁衍率预测器，其中解码器中新增了位置注意力模块。与自回归翻译模型类似，Transformer模型的编码器和解码器都完全由前馈神经网络和多头注意力模块组成。在推断开始之前，非自回归模型需要知道译文的长度，以便并行生成所有单词。更重要的是，非自回归模型需要一次性生成出所有的译文单词，因此不能像自回归模型那样用已生成的词作为第一个解码器层的输入。
\parinterval 图\ref{fig:14-14}给出了基于繁衍率的Transformer非自回归模型的结构\upcite{Gu2017NonAutoregressiveNM}，由三个模块组成:编码器，解码器，繁衍率预测器。类似于标准的Transformer模型，这里编码器和解码器都完全由前馈神经网络和多头注意力模块组成。唯一的不同是解码器中新增了位置注意力模块，用于更好的捕捉目标语言端的位置信息。
\parinterval 那么非自回归模型解码器的输入是什么呢？如果完全省略第一个解码器层的输入，或者仅使用位置嵌入，将会导致性能非常差。这里使用繁衍率来解决这个问题，繁衍率指的是：根据每个源语言单词预测出其对应的目标语言单词的个数（见\chaptersix），如图\ref{fig:14-14}所示，翻译过程中英语单词“We”对应一个汉语单词“我们”，其繁衍率为1。翻译过程取决于繁衍率序列（图\ref{fig:14-14}中的数字1\ 1\ 2\ 0\ 1），最终译文长度则由源语言单词的繁衍率之和决定。这个繁衍率序列可以通过外部词对齐工具得到， 来训练这个繁衍率预测器。但由于外部词对齐系统会出现错误，因此在模型收敛之后，需要在繁衍率预测器上加一个强化学习的损失来进行微调。
\parinterval 繁衍率预测器的一个作用是预测整个译文句子的长度，以便并行生成所有译文单词。可以通过对每个源语言单词计算繁衍率来估计最终译文的长度。具体来说，繁衍率指的是：根据每个源语言单词预测出其对应的目标语言单词的个数（见\chaptersix），如图\ref{fig:14-14}所示，翻译过程中英语单词“We”对应一个汉语单词“我们”，其繁衍率为1。于是，可以得到源语言句子对应的繁衍率序列（图\ref{fig:14-14}中的数字1\ 1\ 2\ 0\ 1），最终译文长度则由源语言单词的繁衍率之和决定。在模型训练阶段，繁衍率序列可以通过外部词对齐工具得到， 之后训练繁衍率预测器。但由于外部词对齐系统会出现错误，因此在模型收敛之后，可以对繁衍率预测器进行额外的微调。
%----------------------------------------------------------------------
\begin{figure}[htp]
......@@ -475,7 +475,9 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\end{figure}
%----------------------------------------------------------------------
\parinterval 另外，在每个解码器层中还新增了额外的位置注意力模块，该模块与Transformer模型的其它部分中使用的多头注意力机制相同。其仍然基于$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$之间的计算（见{\chaptertwelve}），只是把位置编码作为$\mathbi{Q}$ 和$\mathbi{K}$, 解码器端上一层的输出作为$\mathbi{V}$。这种方法提供了更强的位置信息。
\parinterval 实际上，使用繁衍率的另一个好处在于可以缓解多峰问题。因为，繁衍率本身可以看作是模型的一个隐变量。使用这个隐变量本质上是在对可能的译文空间进行剪枝，因为只有一部分译文满足给定的繁衍率序列。从这个角度说，在翻译率的作用下，不同单词译文组合的情况变少了，因此多峰问题也就被缓解了。
\parinterval 另外，在每个解码器层中还新增了额外的位置注意力模块，该模块与其它部分中使用的多头注意力机制相同。其仍然基于$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$之间的计算（见{\chaptertwelve}），只是把位置编码作为$\mathbi{Q}$ 和$\mathbi{K}$, 解码器端前一层的输出作为$\mathbi{V}$。这种方法提供了更强的位置信息。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -483,7 +485,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsubsection{2. 句子级知识蒸馏}
\parinterval 知识蒸馏的基本思路是把教师模型的知识传递给学生模型，让学生模型可以更好地学习（见\chapterthirteen）。通过这种方法，可以降低非自回归模型的学习难度。具体来说，可以让自回归模型作为“教师”，非自回归模型作为“学生”。把自回归神经机器翻译模型生成的句子作为新的训练样本，送给非自回归机器翻译模型进行学习\upcite{Gu2017NonAutoregressiveNM,Lee2018DeterministicNN,Zhou2020UnderstandingKD,Guo2020FineTuningBC}。这种方式能够一定程度上缓解多峰问题。因为，经过训练的自回归模型会始终将相同的源语言句子翻译成相同的译文。这样得到的数据集噪声更少，能够降低非自回归模型学习的难度。
\parinterval 知识蒸馏的基本思路是把教师模型的知识传递给学生模型，让学生模型可以更好地学习（见\chapterthirteen）。通过这种方法，可以降低非自回归模型的学习难度。具体来说，可以让自回归模型作为“教师”，非自回归模型作为“学生”。把自回归神经机器翻译模型生成的句子作为新的训练样本，送给非自回归机器翻译模型进行学习\upcite{Lee2018DeterministicNN,Zhou2020UnderstandingKD,Guo2020FineTuningBC}。有研究发现自回归模型生成的结果的“确定性”更高，也就是不同句子中相同源语言片段翻译的多样性相对低一些\upcite{Gu2017NonAutoregressiveNM}。虽然从人工翻译的角度看，这可能并不是理想的译文，但是使用这样的译文可以在一定程度上缓解多峰问题。因为，经过训练的自回归模型会始终将相同的源语言句子翻译成相同的译文。这样得到的数据集噪声更少，能够降低非自回归模型学习的难度。此外，相比人工标注的译文，自回归模型输出的译文更容易让模型进行学习，这也是句子级知识蒸馏有效的原因之一。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -499,17 +501,12 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{更好的训练目标}
\parinterval 虽然非自回归翻译可以显著提升翻译速度，但是很多情况下其翻译质量还是低于传统的自回归翻译\upcite{Gu2017NonAutoregressiveNM,Kaiser2018FastDI,Guo2020FineTuningBC}。因此，很多工作致力于缩小自回归模型和非自回归模型的性能差距\upcite{Ran2020LearningTR,Tu2020ENGINEEI,Shu2020LatentVariableNN}。其中一些通过修改训练目标来达到提升非自回归翻译品质的目的，例如：
\parinterval 虽然非自回归翻译可以显著提升翻译速度，但是很多情况下其翻译质量还是低于传统的自回归翻译\upcite{Gu2017NonAutoregressiveNM,Kaiser2018FastDI,Guo2020FineTuningBC}。因此，很多工作致力于缩小自回归模型和非自回归模型的性能差距\upcite{Ran2020LearningTR,Tu2020ENGINEEI,Shu2020LatentVariableNN}。
\parinterval 一种直接的方法是层级知识蒸馏\upcite{Li2019HintBasedTF}。由于自回归模型和非自回归模型的结构相差不大，因此可以将翻译质量更高的自回归模型作为“教师”，通过给非自回归模型提供监督信号，使其逐块地学习前者的分布。研究人员发现了两点非常有意思的现象：1）非自回归模型容易出现“重复翻译”的现象，这些相邻的重复单词所对应的位置的隐藏状态非常相似。2）非自回归模型的注意力分布比自回归模型的分布更加尖锐。这两点发现启发了研究人员使用自回归模型中的隐层状态来指导非自回归模型学习。可以计算两个模型隐层状态的距离以及注意力矩阵的KL散度\footnote{KL散度即相对熵。}，将它们作为额外的损失指导非自回归模型的训练。类似的做法也出现在基于模仿学习的方法中\upcite{Wei2019ImitationLF}，它也可以被看作是对自回归模型不同层行为的模拟。不过，基于模仿学习的方法会使用更复杂的模块来完成自回归模型对非自回归模型的指导，比如，在非自回归模型中使用一个额外的神经网络，用于接收自回归模型的层级监督信号。
\parinterval 此外，也可以使用基于正则化因子的方法\upcite{Wang2019NonAutoregressiveMT}。非自回归模型的翻译结果中存在着两种非常严重的错误：重复翻译和不完整的翻译。重复翻译问题是因为解码器隐层状态中相邻的两个位置过于相似，因此翻译出来的单词也一样。对于不完整翻译，或者说欠翻译，通常将其归咎于非自回归模型在翻译的过程中丢失了一些源语言句子的信息。针对这两个问题，可以通过在相邻隐层状态间添加相似度约束来计算一个重构损失。具体实践时，对于翻译$\seq{x}\to\seq{y}$，通过一个反向的自回归模型再将$\seq{y}$翻译成$\seq{x'}$，最后计算$\seq{x}$与$\seq{x'}$的差异性作为损失。
\begin{itemize}
\vspace{0.5em}
\item 基于层级知识蒸馏的方法\upcite{Li2019HintBasedTF}。由于自回归模型和非自回归模型的结构相差不大，因此可以将翻译质量更高的自回归模型作为“教师”，通过给非自回归模型提供监督信号，使其逐块地学习前者的分布。研究人员发现了两点非常有意思的现象：1）非自回归模型容易出现“重复翻译”的现象，这些相邻的重复单词所对应的位置的隐藏状态非常相似。2）非自回归模型的注意力分布比自回归模型的分布更加尖锐。这两点发现启发了研究人员使用自回归模型中的隐层状态来指导非自回归模型学习。通过计算两个模型隐层状态的距离以及注意力矩阵的KL散度\footnote{KL散度即相对熵。}作为额外的损失来帮助非自回归模型的训练过程。
\vspace{0.5em}
\item 基于模仿学习的方法\upcite{Wei2019ImitationLF}。这种观点认为非自回归模型可以从性能优越的自回归模型中学得知识。{\small\bfnew{模仿学习}}\index{模仿学习}（Imitation Learning\index{Imitation Learning}）是强化学习中的一个概念，即从专家那里学习正确的行为，与监督学习很相似\upcite{Ho2016ModelFreeIL,Ho2016GenerativeAI,Duan2017OneShotIL}。与其不同的是，模仿学习不是照搬专家的行为，而是学习专家为什么要那样做。换句话说，学习的不是专家的镜像，而是一个专家的行为分布。这里，可以将自回归模型作为专家，非自回归模型学习不同时间步和不同层的解码状态，最后将模仿学习的损失与交叉熵损失加权求和后作为最终的优化目标。
\vspace{0.5em}
\item 基于正则化因子的方法\upcite{Wang2019NonAutoregressiveMT}。非自回归模型的翻译结果中存在着两种非常严重的错误：重复翻译和不完整的翻译。第一种问题是因为解码器隐层状态中相邻的两个位置过于相似，因此翻译出来的单词也一样。对于第二个问题，通常将其归咎于非自回归模型在翻译的过程中丢失了一些源语言句子的信息，从而造成了翻译效果的下降。针对这两个问题，可以通过在相邻隐层状态间添加相似度约束来计算一个重构损失。具体实践时，通常将正在进行的翻译$\seq{x}\to\seq{y}$，通过利用一个反向的自回归模型再将$\seq{y}$翻译成$\seq{x'}$，最后计算$\seq{x}$与$\seq{x'}$的差异性作为损失。
\vspace{0.5em}
\end{itemize}
%----------------------------------------------------------------------------------------
% NEW SUBSECTION
......
Chapter15/Figures/figure-evolution-and-change-of-ml-methods.tex
\begin{tikzpicture}
\node[rounded corners=4pt, minimum width=10.4em, minimum height=7em,fill=yellow!15!gray!15] (box1) at (0em,0em){};
\node[anchor=west,rounded corners=4pt, minimum width=10.4em, minimum height=7em,fill=yellow!15!gray!15] (box2) at ([xshift=2.8em]box1.east){};
\node[anchor=west,rounded corners=4pt, minimum width=10.4em, minimum height=7em,fill=yellow!15!gray!15] (box3) at ([xshift=2.8em]box2.east){};
\draw[densely dotted,line width=1.2pt] ([xshift=0.8em]box1.90) -- ([xshift=0.8em]box1.-90);
\draw[densely dotted,line width=1.2pt] ([xshift=0.8em]box2.90) -- ([xshift=0.8em]box2.-90);
\draw[densely dotted,line width=1.2pt] ([xshift=0.8em]box3.90) -- ([xshift=0.8em]box3.-90);
\node[anchor=west,draw,rounded corners=2pt, minimum width=5em, minimum height=3em,font=\scriptsize,align=center,inner sep=1pt,fill=yellow!10] (n1) at ([xshift=0.5em]box1.west){机器学习算法：\\决策树、支持 \\ 向量机$\cdots$};
\node[anchor=west,draw,rounded corners=2pt, minimum width=5em, minimum height=3em,font=\scriptsize,align=center,inner sep=1pt,fill=yellow!10] (n2) at ([xshift=0.5em]box2.west){神经网络：\\RNN、CNN、 \\ Transformer$\cdots$};
\node[anchor=west,draw,rounded corners=2pt, minimum width=5em, minimum height=3em,font=\scriptsize,align=center,inner sep=1pt,fill=ugreen!10] (n3) at ([xshift=0.5em]box3.west){神经网络：\\RNN、CNN、 \\ Transformer$\cdots$};
\foreach \x/\c in {1/yellow,2/ugreen,3/ugreen}{
\node[anchor=north,font=\scriptsize,inner ysep=0.1em] (output_\x)at ([xshift=-2.2em,yshift=-0.5em]box\x.north){输出};
\node[anchor=north,inner ysep=0.1em] at ([xshift=3em,yshift=-0.5em]box\x.north){\scriptsize\bfnew{执行步骤}};
\node[anchor=south,font=\scriptsize,inner ysep=0.1em,fill=\c!10,rounded corners=2pt] at ([xshift=-2.2em,yshift=0.5em]box\x.south)(input_\x){输入};
\draw[->,thick] (input_\x.90) -- (n\x.-90);
\draw[->,thick] (n\x.90) -- (output_\x.-90);
\tikzstyle{opnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=4em,rounded corners=5pt,fill=teal!17]
\tikzstyle{cnode}=[circle,draw,minimum size=1.2em]
\tikzstyle{mnode}=[rectangle,inner sep=0mm,minimum height=5em,minimum width=11em,rounded corners=5pt,fill=yellow!20]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.5em]
\begin{pgfonlayer}{background}
\node[anchor=west,mnode] (m1) at (0em,0em){};
\node[anchor=west,mnode] (m2) at ([xshift=1em,yshift=0em]m1.east){};
\node[anchor=west,mnode] (m3) at ([xshift=1em,yshift=0em]m2.east){};
\node[anchor=north west,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=3.5em,rounded corners=5pt,fill=blue!20] (ml1) at ([xshift=0em,yshift=-0.5em]m1.south west){};
\node[anchor=west,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=3.5em,rounded corners=5pt,fill=ugreen!20] (ml2) at ([xshift=0.25em,yshift=0em]ml1.east){};
\node[anchor=north east,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=3.5em,rounded corners=5pt,fill=red!20] (ml3) at ([xshift=0em,yshift=-0.5em]m1.south east){};
\node[anchor=north west,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=5.25em,rounded corners=5pt,fill=blue!20] (mc1) at ([xshift=0em,yshift=-0.5em]m2.south west){};
\node[anchor=north east,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=5.25em,rounded corners=5pt,fill=red!20] (mc2) at ([xshift=0em,yshift=-0.5em]m2.south east){};
\node[anchor=north,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=11em,rounded corners=5pt,fill=blue!20] (mr1) at ([xshift=0em,yshift=-0.5em]m3.south){};
\end{pgfonlayer}
{\scriptsize
\node[anchor=south,opnode] (op1) at ([xshift=0em,yshift=1em]m1.north){输出};
\node[anchor=south,opnode] (op2) at ([xshift=0em,yshift=1em]m2.north){输出};
\node[anchor=south,opnode] (op3) at ([xshift=0em,yshift=1em]m3.north){输出};
\node[anchor=north west,wnode,font=\footnotesize,align=left] (w1) at ([xshift=0.3em,yshift=-0.3em]m1.north west){传统机器\\学习};
\node[anchor=north west,wnode,font=\footnotesize] (w2) at ([xshift=0.3em,yshift=-0.3em]m2.north west){深度学习};
\node[anchor=north west,wnode,align=left] (w3) at ([xshift=0.3em,yshift=-0.3em]m3.north west){深度学习和网\\络结构搜索};
{%subfigure-left
\node[anchor=north,wnode,font=\footnotesize] (wl1) at ([xshift=0em,yshift=0em]ml1.north){训练数据};
\node[anchor=north,wnode,font=\footnotesize] (wl2) at ([xshift=0em,yshift=0em]ml2.north){特征信息};
\node[anchor=north,wnode,font=\footnotesize] (wl3) at ([xshift=0em,yshift=0em]ml3.north){模型结构};
\node[anchor=south,wnode,font=\tiny] (wl4) at ([xshift=0em,yshift=0em]ml1.south){人工/自动收集};
\node[anchor=south,wnode] (wl5) at ([xshift=0em,yshift=0em]ml2.south){人工设计};
\node[anchor=south,wnode] (wl6) at ([xshift=0em,yshift=0em]ml3.south){人工设计};
\node[anchor=south,cnode,fill=white] (cl1) at ([xshift=-4em,yshift=1.5em]m1.south){};
\node[anchor=north,cnode,fill=white] (cl2) at ([xshift=0em,yshift=-1em]m1.north){};
\node[anchor=south west,wnode,align=left,font=\tiny] (wl7) at ([xshift=0.5em,yshift=0em]cl1.east){使用{\color{ugreen!60}特征}对{\color{blue!60}数据}\\中信息进行提取};
\node[anchor=west,wnode,align=right,font=\tiny] (wl8) at ([xshift=0.5em,yshift=0em]cl2.east){使用提取的信息对\\{\color{red!50}模型}中的参数\\进行训练};
\draw [-,thick,dotted] ([xshift=0em,yshift=0em]ml1.west) -- ([xshift=0em,yshift=0em]ml1.east);
\draw [-,thick,dotted] ([xshift=0em,yshift=0em]ml2.west) -- ([xshift=0em,yshift=0em]ml2.east);
\draw [-,thick,dotted] ([xshift=0em,yshift=0em]ml3.west) -- ([xshift=0em,yshift=0em]ml3.east);
\draw[->,thick] ([xshift=-1.5em,yshift=-0em]ml1.north)..controls +(north:3em) and +(west:0em)..([xshift=-0em,yshift=-0em]cl1.west) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]ml2.north)..controls +(north:3em) and +(west:0em)..([xshift=-0em,yshift=-0em]cl1.east) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]cl1.north)..controls +(north:2em) and +(west:0em)..([xshift=-0em,yshift=-0em]cl2.west) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]ml3.north)..controls +(north:6em) and +(west:0em)..([xshift=-0em,yshift=-0em]cl2.east) ;
\draw [->,thick] ([xshift=0em,yshift=0em]cl2.north) -- ([xshift=0em,yshift=0em]op1.south);
}
{%subfigure-center
\node[anchor=north,wnode,font=\footnotesize] (wc1) at ([xshift=0em,yshift=0em]mc1.north){训练数据};
\node[anchor=north,wnode,font=\footnotesize] (wc2) at ([xshift=0em,yshift=0em]mc2.north){模型结构};
\node[anchor=south,wnode] (wc3) at ([xshift=0em,yshift=0em]mc1.south){人工/自动收集};
\node[anchor=south,wnode] (wc4) at ([xshift=0em,yshift=0em]mc2.south){人工设计};
\node[anchor=south,cnode,fill=white] (cc1) at ([xshift=-4em,yshift=1.5em]m2.south){};
\node[anchor=north,cnode,fill=white] (cc2) at ([xshift=0em,yshift=-1em]m2.north){};
\node[anchor=south west,wnode,align=left,font=\tiny] (wl7) at ([xshift=0.5em,yshift=0em]cc1.east){使用{\color{red!60}模型}对{\color{blue!60}数据}\\中信息进行提取};
\node[anchor=west,wnode,align=right,font=\tiny] (wl8) at ([xshift=0.5em,yshift=0em]cc2.east){使用提取的信息对\\{\color{red!60}模型}中的参数\\进行训练};
\draw [-,thick,dotted] ([xshift=0em,yshift=0em]mc1.west) -- ([xshift=0em,yshift=0em]mc1.east);
\draw [-,thick,dotted] ([xshift=0em,yshift=0em]mc2.west) -- ([xshift=0em,yshift=0em]mc2.east);
\draw[->,thick] ([xshift=-2em,yshift=-0em]mc1.north)..controls +(north:3em) and +(west:0em)..([xshift=-0em,yshift=-0em]cc1.west) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]mc2.north)..controls +(north:2em) and +(west:0em)..([xshift=-0em,yshift=-0em]cc1.east) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]cc1.north)..controls +(north:2em) and +(west:0em)..([xshift=-0em,yshift=-0em]cc2.west) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]mc2.north)..controls +(north:6em) and +(west:0em)..([xshift=-0em,yshift=-0em]cc2.east) ;
\draw [->,thick] ([xshift=0em,yshift=0em]cc2.north) -- ([xshift=0em,yshift=0em]op2.south);
}
\node[anchor=east,font=\scriptsize,align=center,inner xsep=0pt] at ([xshift=-0.2em]box1.east){1.特征提取；\\2.模型设计； \\3.实验验证。};
\node[anchor=east,font=\scriptsize,align=center,inner xsep=0pt] at ([xshift=-0.2em]box2.east){1.模型设计； \\2.实验验证。\\ };
\node[anchor=east,font=\scriptsize,align=center,inner xsep=0pt] at ([xshift=-0.2em]box3.east){1.实验验证。 \\ \\};
{%subfigure-right
\node[anchor=north,wnode,font=\footnotesize] (wr1) at ([xshift=0em,yshift=0em]mr1.north){训练数据};
\node[anchor=south,wnode] (wr2) at ([xshift=0em,yshift=0em]mr1.south){人工/自动收集};
\node[anchor=south,cnode,fill=white] (cr1) at ([xshift=-2.5em,yshift=2.8em]m3.south){};
\node[anchor=north,cnode,fill=white] (cr2) at ([xshift=0em,yshift=-1em]m3.north){};
\node[anchor=south,cnode,fill=white] (cr3) at ([xshift=-5.8em,yshift=0.7em]m3.south){};
\node[anchor=north,wnode,align=right,font=\tiny] (wr3) at ([xshift=1em,yshift=-0.5em]cr2.south){使用{\color{red!60}模型}提\\取{\color{blue!60}数据}\\中的\\信息};
\node[anchor=west,wnode,align=right,font=\tiny] (wr4) at ([xshift=0.5em,yshift=0em]cr2.east){使用提取的信息对\\{\color{red!60}模型}中的参数\\进行训练};
\node[anchor=west,wnode,align=left,font=\tiny] (wr5) at ([xshift=0.2em,yshift=0em]cr3.east){使用{\color{blue!60}数据}对{\color{red!60}模型}\\的结构进行搜索};
\draw [-,thick,dotted] ([xshift=0em,yshift=0em]mr1.west) -- ([xshift=0em,yshift=0em]mr1.east);
\draw[->,thick] ([xshift=-5.8em,yshift=0em]mr1.north) -- ([xshift=0em,yshift=0em]cr3.south);
\draw[->,thick] ([xshift=0em,yshift=-0em]cr3.north)..controls +(north:1.3em) and +(west:0em)..([xshift=-0em,yshift=-0em]cr1.west) ;
\draw[->,thick] ([xshift=1em,yshift=-0em]mr1.north)..controls +(north:4em) and +(west:0em)..([xshift=-0em,yshift=-0em]cr1.east) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]cr1.north east)..controls +(north:1em) and +(west:0em)..([xshift=-0em,yshift=-0em]cr2.west) ;
\draw[->,thick] ([xshift=5.7em,yshift=-0em]mr1.north)..controls +(north:6em) and +(west:0em)..([xshift=-0em,yshift=-0em]cr2.east) ;
\draw[->,thick] ([xshift=0em,yshift=0em]cr2.north) -- ([xshift=0em,yshift=0em]op3.south);
}
}
\node [draw,thick,anchor=west,single arrow,minimum height=1.6em,single arrow head extend=0.4em] at ([xshift=0.6em]box1.east) {};
\node [draw,thick,anchor=west,single arrow,minimum height=1.6em,single arrow head extend=0.4em] at ([xshift=0.6em]box2.east) {};
\node[font=\footnotesize, anchor=north] at ([yshift=-0.1em]box1.south){传统机器学习};
\node[font=\footnotesize, anchor=north] at ([yshift=-0.1em]box2.south){深度学习};
\node[font=\footnotesize, anchor=north] at ([yshift=-0.1em]box3.south){深度学习\&网络结构搜索};
\end{tikzpicture}
\ No newline at end of file
Chapter15/Figures/figure-layer-fusion-method-2d.tex 0 → 100644
\begin{tikzpicture}
\begin{scope}
\tikzstyle{lnode}=[rectangle,inner sep=0mm,minimum height=1.5em,minimum width=3.5em,rounded corners=2pt,draw]
\tikzstyle{snode}=[rectangle,inner sep=0mm,minimum height=1.5em,minimum width=0.8em,rounded corners=2pt,draw]
\tikzstyle{vlnode}=[rectangle,inner sep=0mm,minimum height=1em,minimum width=5em,rounded corners=2pt,draw]
\node [anchor=west,lnode] (n1) at (0, 0) {$\mathbi{g}^3$};
\node [anchor=north west,lnode] (n2) at ([xshift=0em,yshift=-0.5em]n1.south west) {$\mathbi{g}^2$};
\node [anchor=north west,lnode] (n3) at ([xshift=0em,yshift=-0.5em]n2.south west) {$\mathbi{g}^1$};
\node [anchor=south] (d1) at ([xshift=0em,yshift=0.2em]n1.north) {1D};
\node [anchor=west,lnode] (n4) at ([xshift=1.2em,yshift=0em]n1.east) {};
\node [anchor=west,lnode] (n5) at ([xshift=1.2em,yshift=0em]n2.east) {};
\node [anchor=west,lnode] (n6) at ([xshift=1.2em,yshift=0em]n3.east) {};
\node [anchor=south,lnode] (n7) at ([xshift=0em,yshift=1em]n4.north) {$\mathbi{W}_1$};
\node [anchor=west] (sig) at ([xshift=0em,yshift=0.4em]n5.east) {$\sigma$};
\node [anchor=west,snode,fill=purple!30] (nc11) at ([xshift=1.2em,yshift=0em]n4.east) {};
\node [anchor=west,snode,fill=yellow!30] (nc12) at ([xshift=0em,yshift=0em]nc11.east) {};
\node [anchor=west,snode,fill=red!30] (nc13) at ([xshift=0em,yshift=0em]nc12.east) {};
\node [anchor=west,snode,fill=blue!30] (nc14) at ([xshift=0em,yshift=0em]nc13.east) {};
\node [anchor=west,snode,font=\footnotesize,fill=ugreen!30] (nc15) at ([xshift=0em,yshift=0em]nc14.east) {$\mathbi{o}_5^3$};
\node [anchor=west,snode,fill=purple!30] (nc21) at ([xshift=1.2em,yshift=0em]n5.east) {};
\node [anchor=west,snode,fill=yellow!30] (nc22) at ([xshift=0em,yshift=0em]nc21.east) {};
\node [anchor=west,snode,fill=red!30] (nc23) at ([xshift=0em,yshift=0em]nc22.east) {};
\node [anchor=west,snode,fill=blue!30] (nc24) at ([xshift=0em,yshift=0em]nc23.east) {};
\node [anchor=west,snode,font=\footnotesize,fill=ugreen!30] (nc25) at ([xshift=0em,yshift=0em]nc24.east) {$\mathbi{o}_5^2$};
\node [anchor=west,snode,fill=purple!30] (nc31) at ([xshift=1.2em,yshift=0em]n6.east) {};
\node [anchor=west,snode,fill=yellow!30] (nc32) at ([xshift=0em,yshift=0em]nc31.east) {};
\node [anchor=west,snode,fill=red!30] (nc33) at ([xshift=0em,yshift=0em]nc32.east) {};
\node [anchor=west,snode,fill=blue!30] (nc34) at ([xshift=0em,yshift=0em]nc33.east) {};
\node [anchor=west,snode,font=\footnotesize,fill=ugreen!30] (nc35) at ([xshift=0em,yshift=0em]nc34.east) {$\mathbi{o}_5^1$};
\node [anchor=south,lnode] (n8) at ([xshift=0em,yshift=1em]nc13.north) {$\mathbi{W}_2$};
\node [anchor=west,font=\footnotesize] (n9) at ([xshift=0.1em,yshift=0.5em]nc25.east) {Softmax};
\node [anchor=west,snode,fill=purple!30] (ns11) at ([xshift=3.5em,yshift=0em]nc15.east) {};
\node [anchor=west,snode,fill=yellow!30] (ns12) at ([xshift=0em,yshift=0em]ns11.east) {};
\node [anchor=west,snode,fill=red!30] (ns13) at ([xshift=0em,yshift=0em]ns12.east) {};
\node [anchor=west,snode,fill=blue!30] (ns14) at ([xshift=0em,yshift=0em]ns13.east) {};
\node [anchor=west,snode,font=\tiny,fill=ugreen!30] (ns15) at ([xshift=0em,yshift=0em]ns14.east) {0.3};
\node [anchor=west,snode,fill=purple!30] (ns21) at ([xshift=3.5em,yshift=0em]nc25.east) {};
\node [anchor=west,snode,fill=yellow!30] (ns22) at ([xshift=0em,yshift=0em]ns21.east) {};
\node [anchor=west,snode,fill=red!30] (ns23) at ([xshift=0em,yshift=0em]ns22.east) {};
\node [anchor=west,snode,fill=blue!30] (ns24) at ([xshift=0em,yshift=0em]ns23.east) {};
\node [anchor=west,snode,font=\tiny,fill=ugreen!30] (ns25) at ([xshift=0em,yshift=0em]ns24.east) {0.2};
\node [anchor=west,snode,fill=purple!30] (ns31) at ([xshift=3.5em,yshift=0em]nc35.east) {};
\node [anchor=west,snode,fill=yellow!30] (ns32) at ([xshift=0em,yshift=0em]ns31.east) {};
\node [anchor=west,snode,fill=red!30] (ns33) at ([xshift=0em,yshift=0em]ns32.east) {};
\node [anchor=west,snode,fill=blue!30] (ns34) at ([xshift=0em,yshift=0em]ns33.east) {};
\node [anchor=west,snode,font=\tiny,fill=ugreen!30] (ns35) at ([xshift=0em,yshift=0em]ns34.east) {0.5};
\node [anchor=west,vlnode,fill=purple!30] (ln1) at ([xshift=3.5em,yshift=-1.5em]ns15.east) {};
\node [anchor=north west,vlnode,fill=yellow!30] (ln2) at ([xshift=-0.4em,yshift=-0.4em]ln1.north west) {};
\node [anchor=north west,vlnode,fill=red!30] (ln3) at ([xshift=-0.4em,yshift=-0.4em]ln2.north west) {};
\node [anchor=north west,vlnode,fill=blue!30] (ln4) at ([xshift=-0.4em,yshift=-0.4em]ln3.north west) {};
\node [anchor=north west,vlnode,fill=ugreen!30] (ln5) at ([xshift=-0.4em,yshift=-0.4em]ln4.north west) {};
\node [anchor=south] (d2) at ([xshift=0em,yshift=0.2em]ln1.north) {2D};
\node [anchor=south,vlnode,rotate=-90] (ffn) at ([xshift=2em,yshift=0em]ln3.east) {FFN};
\node [anchor=west,rectangle,inner sep=0mm,minimum height=3.5em,minimum width=0.8em,rounded corners=2pt,draw] (fn) at ([xshift=1.5em,yshift=0em]ffn.north) {$\mathbi{g}$};
\draw [->,thick] ([xshift=0em,yshift=0em]n1.east) -- ([xshift=0em,yshift=0em]n4.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n2.east) -- ([xshift=0em,yshift=0em]n5.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n3.east) -- ([xshift=0em,yshift=0em]n6.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n4.east) -- ([xshift=0em,yshift=0em]nc11.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n5.east) -- ([xshift=0em,yshift=0em]nc21.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n6.east) -- ([xshift=0em,yshift=0em]nc31.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n7.south) -- ([xshift=0em,yshift=0em]n4.north);
\draw [->,thick] ([xshift=0em,yshift=0em]n8.south) -- ([xshift=0em,yshift=0em]nc13.north);
\draw [->,thick] ([xshift=0em,yshift=0em]nc25.east) -- ([xshift=0em,yshift=0em]ns21.west);
\draw[->,thick,dotted] ([xshift=0em,yshift=-0em]ns15.east)..controls +(east:1.5em) and +(west:1.5em)..([xshift=-0em,yshift=-0em]ln5.west) ;
\draw[->,thick,dotted] ([xshift=0em,yshift=-0em]ns25.east)..controls +(east:1em) and +(west:1em)..([xshift=-0em,yshift=-0em]ln5.west) ;
\draw[->,thick,dotted] ([xshift=0em,yshift=-0em]ns35.east)..controls +(east:1.5em) and +(west:1.5em)..([xshift=-0em,yshift=-0em]ln5.west) ;
\draw [->,thick] ([xshift=0.8em,yshift=0em]ln3.east) -- ([xshift=0em,yshift=0em]ffn.south);
\draw [->,thick] ([xshift=0em,yshift=0em]ffn.north) -- ([xshift=0em,yshift=0em]fn.west);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]n3.south west) to node [midway,font=\small,align=center,xshift=0em,yshift=-0.8em] {$d$} ([xshift=0em]n3.south east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]n6.south west) to node [midway,font=\small,align=center,xshift=0em,yshift=-0.8em] {$d_a$} ([xshift=0em]n6.south east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]n7.north west) to node [midway,font=\small,align=center,xshift=-0.7em,yshift=-0em] {$d$} ([xshift=0em]n7.south west);
\draw [decorate,decoration={brace}] ([xshift=0em]n7.north west) to node [midway,font=\small,align=center,xshift=0em,yshift=0.7em] {$d$} ([xshift=0em]n7.north east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]n8.north west) to node [midway,font=\small,align=center,xshift=-0.8em,yshift=-0em] {$d_a$} ([xshift=0em]n8.south west);
\draw [decorate,decoration={brace}] ([xshift=0em]n8.north west) to node [midway,font=\small,align=center,xshift=0em,yshift=0.8em] {$n_{hop}$} ([xshift=0em]n8.north east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]nc31.south west) to node [midway,font=\small,align=center,xshift=0em,yshift=-0.8em] {$n_{hop}$} ([xshift=0em]nc35.south east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]ln5.south west) to node [midway,font=\small,align=center,xshift=0em,yshift=-0.8em] {$d$} ([xshift=0em]ln5.south east);
\draw [decorate] ([xshift=0em]ln5.south east) to node [midway,font=\footnotesize,align=center,xshift=1em,yshift=-0.5em] {$n_{hop}$} ([xshift=0em]ln1.south east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]fn.south east) to node [midway,font=\small,align=center,xshift=0.7em,yshift=-0em] {$d$} ([xshift=0em]fn.north east);
\end{scope}
\end{tikzpicture}
\ No newline at end of file
Chapter15/Figures/figure-light-weight-transformer-module.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
%%% 调序模型1：基于距离的调序
\begin{center}
\begin{tikzpicture}
\tikzstyle{manode}=[rectangle,inner sep=0mm,minimum height=4em,minimum width=4em,rounded corners=5pt,thick,draw,fill=blue!20]
\tikzstyle{ffnnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=6em,rounded corners=5pt,thick,fill=red!20,draw]
\tikzstyle{ebnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=10em,rounded corners=5pt,thick,fill=green!20,draw]
\begin{scope}[]
\node [anchor=west,ffnnode] (f1) at (0, 0){FFN};
\node [anchor=south,ebnode] (e1) at ([xshift=0em,yshift=1em]f1.north){Embedding};
\node [anchor=south west,manode] (a1) at ([xshift=0em,yshift=1em]e1.north west){Attention};
\node [anchor=south east,manode] (c1) at ([xshift=0em,yshift=1em]e1.north east){Conv};
\node [anchor=south west,ebnode] (e2) at ([xshift=0em,yshift=1em]a1.north west){Embedding};
\node [anchor=south,draw,circle,inner sep=4pt] (add1) at ([xshift=0em,yshift=0.5em]e2.north){};
\node [anchor=south,ffnnode] (f2) at ([xshift=0em,yshift=0.5em]add1.north){FFN};
\draw[->,thick] ([xshift=0em,yshift=0em]f1.north)--([xshift=0em,yshift=0em]e1.south);
\draw[->,thick] ([xshift=0em,yshift=-1em]a1.south)--([xshift=0em,yshift=0em]a1.south);
\draw[->,thick] ([xshift=0em,yshift=-1em]c1.south)--([xshift=0em,yshift=0em]c1.south);
\draw[->,thick] ([xshift=0em,yshift=0em]a1.north)--([xshift=0em,yshift=1em]a1.north);
\draw[->,thick] ([xshift=0em,yshift=0em]c1.north)--([xshift=0em,yshift=1em]c1.north);
\draw[-,thick] ([xshift=0em,yshift=0em]e2.north)--([xshift=0em,yshift=0em]add1.south);
\draw[->,thick] ([xshift=0em,yshift=0em]add1.north)--([xshift=0em,yshift=0em]f2.south);
\draw[-] ([xshift=0em,yshift=0em]add1.west)--([xshift=-0em,yshift=0em]add1.east);
\draw[-] ([xshift=0em,yshift=0em]add1.south)--([xshift=-0em,yshift=-0em]add1.north);
\draw[->,thick,rectangle,rounded corners=5pt] ([xshift=0em,yshift=0.5em]f1.north)--([xshift=-6em,yshift=0.5em]f1.north)--([xshift=-5.45em,yshift=0em]add1.west)--([xshift=0em,yshift=0em]add1.west);
\end{scope}
\end{tikzpicture}
\end{center}
\ No newline at end of file
Chapter15/Figures/figure-multi-branch-attention-model.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
%%% 调序模型1：基于距离的调序
\begin{center}
\begin{tikzpicture}
\tikzstyle{manode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=10em,rounded corners=5pt,thick,draw,fill=teal!20]
\tikzstyle{ffnnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,thick,fill=red!20,draw]
\tikzstyle{lnnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=2.5em,rounded corners=5pt,thick,fill=green!20,draw]
\begin{scope}[]
\node [anchor=east,circle,fill=black,inner sep = 2pt] (n1) at (-0, 0) {};
\node [anchor=west,draw,circle,inner sep=5pt] (n2) at ([xshift=13em,yshift=0em]n1.east){};
\node [anchor=west,lnnode] (n3) at ([xshift=1.5em,yshift=0em]n2.east){LN};
\node [anchor=west,circle,fill=black,inner sep=2pt] (n4) at ([xshift=1.5em,yshift=0em]n3.east){};
\node [anchor=west,draw,circle,inner sep=5pt] (n5) at ([xshift=5em,yshift=0em]n4.east){};
\node [anchor=west,lnnode] (n6) at ([xshift=1.5em,yshift=0em]n5.east){LN};
\node [anchor=west,manode] (a1) at ([xshift=1.5em,yshift=2em]n1.east){Multi-Head Attention};
\node [anchor=south] (a2) at ([xshift=0em,yshift=0.2em]a1.north){$\cdots$};
\node [anchor=south,manode] (a3) at ([xshift=0em,yshift=0.2em]a2.north){Multi-Head Attention};
\node [anchor=west,ffnnode] (f1) at ([xshift=1em,yshift=2em]n4.east){FFN};
\draw[->,thick] ([xshift=-1em,yshift=0em]n1.west)--([xshift=0em,yshift=0em]n1.west);
\draw[->,thick] ([xshift=0em,yshift=0em]n1.east)--([xshift=0em,yshift=0em]n2.west);
\draw[->,thick] ([xshift=0em,yshift=0em]n2.east)--([xshift=0em,yshift=0em]n3.west);
\draw[->,thick] ([xshift=0em,yshift=0em]n3.east)--([xshift=0em,yshift=0em]n4.west);
\draw[->,thick] ([xshift=0em,yshift=0em]n4.east)--([xshift=0em,yshift=0em]n5.west);
\draw[->,thick] ([xshift=0em,yshift=0em]n5.east)--([xshift=0em,yshift=0em]n6.west);
\draw[->,thick] ([xshift=0em,yshift=0em]n6.east)--([xshift=1em,yshift=0em]n6.east);
\draw[->,thick] ([xshift=0em,yshift=0em]n1.east)--([xshift=0em,yshift=0em]a1.west);
\draw[->,thick] ([xshift=0em,yshift=0em]n1.east)--([xshift=0em,yshift=0em]a3.west);
\draw[->,thick] ([xshift=0em,yshift=0em]n4.east)--([xshift=0em,yshift=0em]f1.west);
\draw[->,thick,ublue,dashed] ([xshift=0em,yshift=0em]a1.east)--([xshift=0em,yshift=0em]n2.west);
\draw[->,thick,ublue,dashed] ([xshift=0em,yshift=0em]a3.east)--([xshift=0em,yshift=0em]n2.west);
\draw[->,thick,ublue,dashed] ([xshift=0em,yshift=0em]f1.east)--([xshift=0em,yshift=0em]n5.west);
\node [anchor=west,ublue,font=\footnotesize,align=left] (w1) at ([xshift=5em,yshift=-0.5em]a2.east){以概率\\$p$丢弃};
\node [anchor=west,ublue,font=\footnotesize,align=left] (w2) at ([xshift=0.5em,yshift=0em]f1.east){以概率\\$p$丢弃};
\draw[-] ([xshift=0em,yshift=0em]n2.west)--([xshift=-0em,yshift=0em]n2.east);
\draw[-] ([xshift=0em,yshift=0em]n2.south)--([xshift=-0em,yshift=-0em]n2.north);
\draw[-] ([xshift=0em,yshift=0em]n5.west)--([xshift=-0em,yshift=0em]n5.east);
\draw[-] ([xshift=0em,yshift=0em]n5.south)--([xshift=-0em,yshift=-0em]n5.north);
\end{scope}
\end{tikzpicture}
\end{center}
\ No newline at end of file
Chapter15/Figures/figure-parallel-RNN-structure.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
\begin{center}
\begin{tikzpicture}
\tikzstyle{wrnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=4em,rounded corners=5pt,fill=blue!30]
\tikzstyle{arnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=4em,rounded corners=5pt,fill=red!30]
\tikzstyle{dotnode}=[inner sep=0mm,minimum height=0.5em,minimum width=1.5em]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.8em]
{\small
\begin{scope}[]
\node [anchor=north west,wnode] (w1) at (0,0) {词预测模型};
\node [anchor=west,wrnode] (w2) at ([xshift=1.5em,yshift=0em]w1.east) {$\mathbi{h}_{1}^{\textrm{word}}$};
\node [anchor=west,wrnode] (w3) at ([xshift=1.5em,yshift=0em]w2.east) {$\mathbi{h}_{2}^{\textrm{word}}$};
\node [anchor=west,wrnode] (w4) at ([xshift=7em,yshift=0em]w3.east) {$\mathbi{h}_{4}^{\textrm{word}}$};
\node [anchor=west,dotnode] (dot1) at ([xshift=1.5em,yshift=0em]w4.east) {$\cdots$};
\node [anchor=north east,wnode] (a1) at ([xshift=0em,yshift=-6.6em]w1.south east) {动作模型};
\node [anchor=west,arnode] (a2) at ([xshift=1.5em,yshift=0em]a1.east) {$\mathbi{h}_{1}^{\textrm{action}}$};
\node [anchor=west,arnode] (a3) at ([xshift=1.5em,yshift=0em]a2.east) {$\mathbi{h}_{2}^{\textrm{action}}$};
\node [anchor=west,arnode] (a4) at ([xshift=1.5em,yshift=0em]a3.east) {$\mathbi{h}_{3}^{\textrm{action}}$};
\node [anchor=west,arnode] (a5) at ([xshift=1.5em,yshift=0em]a4.east) {$\mathbi{h}_{4}^{\textrm{action}}$};
\node [anchor=west,arnode] (a6) at ([xshift=1.5em,yshift=0em]a5.east) {$\mathbi{h}_{5}^{\textrm{action}}$};
\node [anchor=south,wnode] (word1) at ([xshift=0em,yshift=1em]w2.north) {你};
\node [anchor=south,wnode] (word2) at ([xshift=0em,yshift=1em]w3.north) {是};
\node [anchor=south,wnode] (word3) at ([xshift=0em,yshift=1em]w4.north) {谁};
\node [anchor=north,wnode] (word4) at ([xshift=0em,yshift=-1em]w2.south) {$\langle$sos$\rangle$};
\node [anchor=north,wnode] (word5) at ([xshift=0em,yshift=-1em]w3.south) {你};
\node [anchor=north,wnode] (word6) at ([xshift=0em,yshift=-1em]w4.south) {谁};
\node [anchor=south,wnode] (word7) at ([xshift=0em,yshift=1em]a2.north) {移位};
\node [anchor=south,wnode] (word8) at ([xshift=0em,yshift=1em]a3.north) {移位};
\node [anchor=south,wnode] (word9) at ([xshift=0em,yshift=1em]a4.north) {左规约};
\node [anchor=south,wnode] (word10) at ([xshift=0em,yshift=1em]a5.north) {移位};
\node [anchor=south,wnode] (word11) at ([xshift=0em,yshift=1em]a6.north) {右规约};
\node [anchor=north,wnode] (word12) at ([xshift=0em,yshift=-1em]a2.south) {$\langle$sos$\rangle$};
\node [anchor=north,wnode] (word13) at ([xshift=0em,yshift=-1em]a3.south) {移位};
\node [anchor=north,wnode] (word14) at ([xshift=0em,yshift=-1em]a4.south) {移位};
\node [anchor=north,wnode] (word15) at ([xshift=0em,yshift=-1em]a5.south) {左规约};
\node [anchor=north,wnode] (word16) at ([xshift=0em,yshift=-1em]a6.south) {移位};
\node [anchor=south,wnode] (wl1) at ([xshift=6em,yshift=-1em]dot1.north) {是};
\node [anchor=north,wnode] (wl2) at ([xshift=-2em,yshift=-2em]wl1.south) {你};
\node [anchor=north,wnode] (wl3) at ([xshift=2em,yshift=-2em]wl1.south) {谁};
\node [anchor=north,font=\tiny,rotate=45] (e1) at ([xshift=-2.2em,yshift=-0.4em]wl1.south) {左规约生成};
\node [anchor=north,font=\tiny,rotate=-45] (e2) at ([xshift=2.2em,yshift=-0.4em]wl1.south) {右规约生成};
\draw [->,thick] ([xshift=0em,yshift=0em]wl1.south) -- ([xshift=0em,yshift=0em]wl2.north);
\draw [->,thick] ([xshift=0em,yshift=0em]wl1.south) -- ([xshift=0em,yshift=0em]wl3.north);
\draw [->,thick] ([xshift=0em,yshift=0em]w1.east) -- ([xshift=0em,yshift=0em]w2.west);
\draw [->,thick] ([xshift=0em,yshift=0em]w2.east) -- ([xshift=0em,yshift=0em]w3.west);
\draw [->,thick] ([xshift=0em,yshift=0em]w3.east) -- ([xshift=0em,yshift=0em]w4.west);
\draw [->,thick] ([xshift=0em,yshift=0em]w4.east) -- ([xshift=0em,yshift=0em]dot1.west);
\draw [->,thick] ([xshift=0em,yshift=0em]a1.east) -- ([xshift=0em,yshift=0em]a2.west);
\draw [->,thick] ([xshift=0em,yshift=0em]a2.east) -- ([xshift=0em,yshift=0em]a3.west);
\draw [->,thick] ([xshift=0em,yshift=0em]a3.east) -- ([xshift=0em,yshift=0em]a4.west);
\draw [->,thick] ([xshift=0em,yshift=0em]a4.east) -- ([xshift=0em,yshift=0em]a5.west);
\draw [->,thick] ([xshift=0em,yshift=0em]a5.east) -- ([xshift=0em,yshift=0em]a6.west);
\draw [->,thick] ([xshift=0em,yshift=0em]w2.north) -- ([xshift=0em,yshift=0em]word1.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w3.north) -- ([xshift=0em,yshift=0em]word2.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w4.north) -- ([xshift=0em,yshift=0em]word3.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word4.north) -- ([xshift=0em,yshift=0em]w2.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word5.north) -- ([xshift=0em,yshift=0em]w3.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word6.north) -- ([xshift=0em,yshift=0em]w4.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word7.north) -- ([xshift=0em,yshift=0em]word4.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word8.north) -- ([xshift=0em,yshift=0em]word5.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word10.north) -- ([xshift=0em,yshift=0em]word6.south);
\draw [->,thick] ([xshift=0em,yshift=0em]a2.north) -- ([xshift=0em,yshift=0em]word7.south);
\draw [->,thick] ([xshift=0em,yshift=0em]a3.north) -- ([xshift=0em,yshift=0em]word8.south);
\draw [->,thick] ([xshift=0em,yshift=0em]a4.north) -- ([xshift=0em,yshift=0em]word9.south);
\draw [->,thick] ([xshift=0em,yshift=0em]a5.north) -- ([xshift=0em,yshift=0em]word10.south);
\draw [->,thick] ([xshift=0em,yshift=0em]a6.north) -- ([xshift=0em,yshift=0em]word11.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word12.north) -- ([xshift=0em,yshift=0em]a2.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word13.north) -- ([xshift=0em,yshift=0em]a3.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word14.north) -- ([xshift=0em,yshift=0em]a4.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word15.north) -- ([xshift=0em,yshift=0em]a5.south);
\draw [->,thick] ([xshift=0em,yshift=0em]word16.north) -- ([xshift=0em,yshift=0em]a6.south);
\draw[->,thick,dashed] ([xshift=0em,yshift=-0em]word1.east)..controls +(east:4em) and +(west:3em)..([xshift=-0em,yshift=-0em]a3.west) ;
\draw[->,thick,dashed] ([xshift=0em,yshift=-0em]word2.east)..controls +(east:4em) and +(west:3em)..([xshift=-0em,yshift=-0em]a4.west) ;
\draw[->,thick,dashed] ([xshift=0em,yshift=-0em]word2.east)..controls +(east:10em) and +(west:4em)..([xshift=-0em,yshift=-0em]a5.west) ;
\draw[->,thick,dashed] ([xshift=0em,yshift=-0em]word3.east)..controls +(east:4em) and +(west:3em)..([xshift=-0em,yshift=-0em]a6.west) ;
\end{scope}
}
\end{tikzpicture}
\end{center}
\ No newline at end of file
Chapter15/Figures/figure-parsing-tree-of-a-sentence.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
\begin{center}
\begin{tikzpicture}
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.5em,minimum width=2em]
\begin{scope}[sibling distance=15pt, level distance = 30pt]
\Tree[.\node(n1){{S}};
[.\node(n2){{NP}};
[.\node(n3){{PRN}}; \node(w1){{I}};]
]
[.\node(n4){{VP}};
[. \node(n5){VBP}; \node(w2){{love}};]
[. \node(cw4){NP};
[. \node(n6){NNS}; \node(w3){{dogs}};]
]
]
]
]
\node [anchor=north] (label1) at ([xshift=0em,yshift=-4em]w2.south) {(a)句法树};
\end{scope}
\begin{scope}[xshift=1.8in,yshift=0em]
\node [anchor=west,wnode] (w1) at (0,0) {I};
\node [anchor=west,wnode] (w2) at ([xshift=3em,yshift=0em]w1.east) {love};
\node [anchor=west,wnode] (w3) at ([xshift=3em,yshift=0em]w2.east) {dogs};
\node [anchor=north,wnode] (w4) at ([xshift=0em,yshift=-2em]w1.south) {$w_1$};
\node [anchor=north,wnode] (w5) at ([xshift=0em,yshift=-2em]w2.south) {$w_2$};
\node [anchor=north,wnode] (w6) at ([xshift=0em,yshift=-2em]w3.south) {$w_3$};
\node [anchor=north] (label2) at ([xshift=0em,yshift=-1.5em]w5.south) {(b)词序列};
\end{scope}
\begin{scope}[xshift=1.2in,yshift=-1.5in]
\node [anchor=west,wnode] (l1) at (0,0) {S};
\node [anchor=west,wnode] (l2) at ([xshift=1em,yshift=0em]l1.east) {NP};
\node [anchor=west,wnode] (l3) at ([xshift=1em,yshift=0em]l2.east) {PRN};
\node [anchor=west,wnode] (l4) at ([xshift=1em,yshift=0em]l3.east) {VP};
\node [anchor=west,wnode] (l5) at ([xshift=1em,yshift=0em]l4.east) {VBP};
\node [anchor=west,wnode] (l6) at ([xshift=1em,yshift=0em]l5.east) {NP};
\node [anchor=west,wnode] (l7) at ([xshift=1em,yshift=0em]l6.east) {NNS};
\node [anchor=north,wnode] (l8) at ([xshift=0em,yshift=-1em]l1.south) {$l_1$};
\node [anchor=north,wnode] (l9) at ([xshift=0em,yshift=-1em]l2.south) {$l_2$};
\node [anchor=north,wnode] (l10) at ([xshift=0em,yshift=-1em]l3.south) {$l_3$};
\node [anchor=north,wnode] (l11) at ([xshift=0em,yshift=-1em]l4.south) {$l_4$};
\node [anchor=north,wnode] (l12) at ([xshift=0em,yshift=-1em]l5.south) {$l_5$};
\node [anchor=north,wnode] (l13) at ([xshift=0em,yshift=-1em]l6.south) {$l_6$};
\node [anchor=north,wnode] (l14) at ([xshift=0em,yshift=-1em]l7.south) {$l_7$};
\node [anchor=north] (label3) at ([xshift=0em,yshift=-1.5em]l11.south) {(c)句法序列};
\end{scope}
\end{tikzpicture}
\end{center}
\ No newline at end of file
Chapter15/Figures/figure-syntax-tree-linearization-example.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
\begin{center}
\begin{tikzpicture}
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.5em,minimum width=2em]
{\small
\begin{scope}[sibling distance=15pt, level distance = 30pt]
\Tree[.\node(n1){{S}};
[.\node(n2){{NP}}; \node(w1){{Jane}};]
[.\node(n3){{VP}};
[. \node(w2){had};]
[. \node(n4){NP}; \node(w3){{a cat}};]
]
[. \node(w4){.};]
]
\end{scope}
}
{\small
\begin{scope}[xshift=1in,yshift=-0.7in]
\node [anchor=west] (n1) at (0.5em,0em) {(Root(S(NP Jane)NP(VP had(NP a cat)NP)VP .)S)Root};
\draw [->,very thick] ([xshift=-2.3em,yshift=0em]n1.west) -- ([xshift=-0.5em,yshift=0em]n1.west);
\end{scope}
}
\end{tikzpicture}
\end{center}
\ No newline at end of file
Chapter15/Figures/figure-three-fusion-methods-of-tree-structure-information-1.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
\begin{center}
\begin{tikzpicture}
\tikzstyle{wrnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,fill=blue!30]
\tikzstyle{srnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,fill=yellow!30]
\tikzstyle{dotnode}=[inner sep=0mm,minimum height=0.5em,minimum width=1.5em]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.8em]
{\small
\begin{scope}[]
\node [anchor=west,wrnode] (wr1) at (0,0) {$\mathbi{h}_{w_1}$};
\node [anchor=west,wrnode] (wr2) at ([xshift=1em,yshift=0em]wr1.east) {$\mathbi{h}_{w_2}$};
\node [anchor=west,wrnode] (wr3) at ([xshift=1em,yshift=0em]wr2.east) {$\mathbi{h}_{w_3}$};
\node [anchor=west,srnode] (sr1) at ([xshift=2em,yshift=0em]wr3.east) {$\mathbi{h}_{l_1}$};
\node [anchor=west,dotnode] (dot1) at ([xshift=0.8em,yshift=0em]sr1.east) {$\cdots$};
\node [anchor=west,srnode] (sr2) at ([xshift=0.8em,yshift=0em]dot1.east) {$\mathbi{h}_{l_3}$};
\node [anchor=west,dotnode] (dot2) at ([xshift=0.8em,yshift=0em]sr2.east) {$\cdots$};
\node [anchor=west,srnode] (sr3) at ([xshift=0.8em,yshift=0em]dot2.east) {$\mathbi{h}_{l_5}$};
\node [anchor=west,dotnode] (dot3) at ([xshift=0.8em,yshift=0em]sr3.east) {$\cdots$};
\node [anchor=west,srnode] (sr4) at ([xshift=0.8em,yshift=0em]dot3.east) {$\mathbi{h}_{l_7}$};
\node [anchor=north,wnode,font=\footnotesize] (w1) at ([xshift=0em,yshift=-1em]wr1.south) {$w_1$\ :\ I};
\node [anchor=north,wnode,font=\footnotesize] (w2) at ([xshift=0em,yshift=-1em]wr2.south) {$w_2$\ :\ love};
\node [anchor=north,wnode,font=\footnotesize] (w3) at ([xshift=0em,yshift=-1em]wr3.south) {$w_3$\ :\ dogs};
\node [anchor=north,wnode,font=\footnotesize] (w4) at ([xshift=0em,yshift=-1em]sr1.south) {$l_1$\ :\ S};
\node [anchor=north,dotnode] (dot4) at ([xshift=0em,yshift=-2.4em]dot1.south) {$\cdots$};
\node [anchor=north,wnode,font=\footnotesize] (w5) at ([xshift=0em,yshift=-1em]sr2.south) {$l_3$\ :\ PRN};
\node [anchor=north,dotnode] (dot5) at ([xshift=0em,yshift=-2.2em]dot2.south) {$\cdots$};
\node [anchor=north,wnode,font=\footnotesize] (w6) at ([xshift=0em,yshift=-1em]sr3.south) {$l_5$\ :\ VBP};
\node [anchor=north,dotnode] (dot6) at ([xshift=0em,yshift=-2.3em]dot3.south) {$\cdots$};
\node [anchor=north,wnode,font=\footnotesize] (w7) at ([xshift=0em,yshift=-1em]sr4.south) {$l_7$\ :\ NNS};
\node [anchor=south,circle,draw,minimum size=1.2em] (c1) at ([xshift=2.5em,yshift=2em]wr2.north){};
\node [anchor=west,circle,draw,minimum size=1.2em] (c2) at ([xshift=8em,yshift=0em]c1.east){};
\node [anchor=west,circle,draw,minimum size=1.2em] (c3) at ([xshift=8em,yshift=0em]c2.east){};
\node [anchor=south,srnode] (m1) at ([xshift=0em,yshift=2em]c1.north) {$\mathbi{h}_{l_1}$};
\node [anchor=south,wrnode] (m2) at ([xshift=0em,yshift=0em]m1.north) {$\mathbi{h}_{w_1}$};
\node [anchor=south,srnode] (m3) at ([xshift=0em,yshift=2em]c2.north) {$\mathbi{h}_{l_5}$};
\node [anchor=south,wrnode] (m4) at ([xshift=0em,yshift=0em]m3.north) {$\mathbi{h}_{w_2}$};
\node [anchor=south,srnode] (m5) at ([xshift=0em,yshift=2em]c3.north) {$\mathbi{h}_{l_7}$};
\node [anchor=south,wrnode] (m6) at ([xshift=0em,yshift=0em]m5.north) {$\mathbi{h}_{w_3}$};
\draw[-] (c1.west)--(c1.east);
\draw[-] (c1.north)--(c1.south);
\draw[-] (c2.west)--(c2.east);
\draw[-] (c2.north)--(c2.south);
\draw[-] (c3.west)--(c3.east);
\draw[-] (c3.north)--(c3.south);
\begin{pgfonlayer}{background}
\node [rectangle,inner sep=0.5em,draw=blue!80,dashed,very thick,rounded corners=10pt] [fit = (wr1) (wr3) (w1) (w3)] (box1) {};
\node [rectangle,inner sep=0.5em,draw=yellow!80,dashed,very thick,rounded corners=10pt] [fit = (sr1) (sr4) (w4) (w7)] (box2) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=gray!20,draw=black,dashed,very thick,rounded corners=8pt] [fit = (m1) (m2)] (box3) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=gray!20,draw=black,dashed,very thick,rounded corners=8pt] [fit = (m3) (m4)] (box4) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=gray!20,draw=black,dashed,very thick,rounded corners=8pt] [fit = (m5) (m6)] (box5) {};
\end{pgfonlayer}
\node [anchor=south,wnode] (h1) at ([xshift=0em,yshift=0.1em]box3.north) {${\mathbi{h}'}_1$\ :\ };
\node [anchor=south,wnode] (h2) at ([xshift=0em,yshift=0.1em]box4.north) {${\mathbi{h}'}_2$\ :\ };
\node [anchor=south,wnode] (h3) at ([xshift=0em,yshift=0.1em]box5.north) {${\mathbi{h}'}_3$\ :\ };
\draw [->,thick] ([xshift=0em,yshift=0em]w1.north) -- ([xshift=0em,yshift=0em]wr1.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w2.north) -- ([xshift=0em,yshift=0em]wr2.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w3.north) -- ([xshift=0em,yshift=0em]wr3.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w4.north) -- ([xshift=0em,yshift=0em]sr1.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w5.north) -- ([xshift=0em,yshift=0em]sr2.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w6.north) -- ([xshift=0em,yshift=0em]sr3.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w7.north) -- ([xshift=0em,yshift=0em]sr4.south);
\draw [->,thick] ([xshift=0em,yshift=0.7em]dot4.north) -- ([xshift=0em,yshift=-0.7em]dot1.south);
\draw [->,thick] ([xshift=0em,yshift=0.7em]dot5.north) -- ([xshift=0em,yshift=-0.7em]dot2.south);
\draw [->,thick] ([xshift=0em,yshift=0.7em]dot6.north) -- ([xshift=0em,yshift=-0.7em]dot3.south);
\draw [<->,thick] ([xshift=0em,yshift=0em]wr1.east) -- ([xshift=0em,yshift=0em]wr2.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]wr2.east) -- ([xshift=0em,yshift=0em]wr3.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]sr1.east) -- ([xshift=0em,yshift=0em]dot1.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]dot1.east) -- ([xshift=0em,yshift=0em]sr2.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]sr2.east) -- ([xshift=0em,yshift=0em]dot2.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]dot2.east) -- ([xshift=0em,yshift=0em]sr3.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]sr3.east) -- ([xshift=0em,yshift=0em]dot3.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]dot3.east) -- ([xshift=0em,yshift=0em]sr4.west);
\draw[->,thick] ([xshift=0em,yshift=-0em]wr1.north)..controls +(north:2em) and +(west:0em)..([xshift=-0em,yshift=-0em]c1.west) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]sr2.north)..controls +(north:2em) and +(south:1em)..([xshift=-0em,yshift=-0em]c1.south east) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]wr2.north)..controls +(north:2em) and +(west:0em)..([xshift=-0em,yshift=-0em]c2.west) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]sr3.north)..controls +(north:2em) and +(east:0em)..([xshift=-0em,yshift=-0em]c2.east) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]wr3.north)..controls +(north:2em) and +(south:1em)..([xshift=-0em,yshift=-0em]c3.south west) ;
\draw[->,thick] ([xshift=0em,yshift=-0em]sr4.north)..controls +(north:2em) and +(east:0em)..([xshift=-0em,yshift=-0em]c3.east) ;
\draw [->,thick] ([xshift=0em,yshift=0em]c1.north) -- ([xshift=0em,yshift=0em]box3.south);
\draw [->,thick] ([xshift=0em,yshift=0em]c2.north) -- ([xshift=0em,yshift=0em]box4.south);
\draw [->,thick] ([xshift=0em,yshift=0em]c3.north) -- ([xshift=0em,yshift=0em]box5.south);
\node [anchor=north] (r1) at ([xshift=0em,yshift=-1em]w2.south) {词语RNN};
\node [anchor=north] (r2) at ([xshift=3em,yshift=-1em]w5.south) {句法RNN};
\node [anchor=north] (label1) at ([xshift=0em,yshift=-4em]dot4.south) {(a)平行结构};
\end{scope}
}
\end{tikzpicture}
\end{center}
\ No newline at end of file
Chapter15/Figures/figure-three-fusion-methods-of-tree-structure-information-2.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
\begin{center}
\begin{tikzpicture}
\tikzstyle{wrnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,fill=blue!30]
\tikzstyle{srnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,fill=yellow!30]
\tikzstyle{dotnode}=[inner sep=0mm,minimum height=0.5em,minimum width=1.5em]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.8em]
{\small
\begin{scope}[]
\node [anchor=west,srnode] (sr1) at (0,0) {$\mathbi{h}_{l_1}$};
\node [anchor=west,dotnode] (dot1) at ([xshift=0.8em,yshift=0em]sr1.east) {$\cdots$};
\node [anchor=west,srnode] (sr2) at ([xshift=0.8em,yshift=0em]dot1.east) {$\mathbi{h}_{l_3}$};
\node [anchor=west,dotnode] (dot2) at ([xshift=0.8em,yshift=0em]sr2.east) {$\cdots$};
\node [anchor=west,srnode] (sr3) at ([xshift=0.8em,yshift=0em]dot2.east) {$\mathbi{h}_{l_5}$};
\node [anchor=west,dotnode] (dot3) at ([xshift=0.8em,yshift=0em]sr3.east) {$\cdots$};
\node [anchor=west,srnode] (sr4) at ([xshift=0.8em,yshift=0em]dot3.east) {$\mathbi{h}_{l_7}$};
\node [anchor=north,wnode,font=\footnotesize] (w4) at ([xshift=0em,yshift=-1em]sr1.south) {$l_1$\ :\ S};
\node [anchor=north,dotnode] (dot4) at ([xshift=0em,yshift=-2.4em]dot1.south) {$\cdots$};
\node [anchor=north,wnode,font=\footnotesize] (w5) at ([xshift=0em,yshift=-1em]sr2.south) {$l_3$\ :\ PRN};
\node [anchor=north,dotnode] (dot5) at ([xshift=0em,yshift=-2.2em]dot2.south) {$\cdots$};
\node [anchor=north,wnode,font=\footnotesize] (w6) at ([xshift=0em,yshift=-1em]sr3.south) {$l_5$\ :\ VBP};
\node [anchor=north,dotnode] (dot6) at ([xshift=0em,yshift=-2.3em]dot3.south) {$\cdots$};
\node [anchor=north,wnode,font=\footnotesize] (w7) at ([xshift=0em,yshift=-1em]sr4.south) {$l_7$\ :\ NNS};
\node [anchor=south,circle,draw,minimum size=1.2em] (c1) at ([xshift=0em,yshift=4.5em]sr2.north){};
\node [anchor=south,circle,draw,minimum size=1.2em] (c2) at ([xshift=0em,yshift=4.5em]sr3.north){};
\node [anchor=south,circle,draw,minimum size=1.2em] (c3) at ([xshift=0em,yshift=4.5em]sr4.north){};
\draw[-] (c1.west)--(c1.east);
\draw[-] (c1.north)--(c1.south);
\draw[-] (c2.west)--(c2.east);
\draw[-] (c2.north)--(c2.south);
\draw[-] (c3.west)--(c3.east);
\draw[-] (c3.north)--(c3.south);
\node [anchor=north east,wnode,font=\footnotesize] (w1) at ([xshift=-1em,yshift=-1em]c1.south west) {$w_1$\ :\ I};
\node [anchor=north east,wnode,font=\footnotesize] (w2) at ([xshift=-1em,yshift=-1em]c2.south west) {$w_2$\ :\ love};
\node [anchor=north east,wnode,font=\footnotesize] (w3) at ([xshift=-1em,yshift=-1em]c3.south west) {$w_3$\ :\ dogs};
\node [anchor=south,wnode] (w8) at ([xshift=0em,yshift=0.5em]c1.north) {$\mathbi{e}_{w_1}$};
\node [anchor=south,wnode] (w9) at ([xshift=0em,yshift=0.5em]c2.north) {$\mathbi{e}_{w_2}$};
\node [anchor=south,wnode] (w10) at ([xshift=0em,yshift=0.5em]c3.north) {$\mathbi{e}_{w_2}$};
\begin{pgfonlayer}{background}
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=ugreen!20,rounded corners=8pt] [fit = (c1) (w8)] (box6) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=ugreen!20,rounded corners=8pt] [fit = (c2) (w9)] (box7) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=ugreen!20,rounded corners=8pt] [fit = (c3) (w10)] (box8) {};
\end{pgfonlayer}
\node [anchor=south,wrnode] (wr1) at ([xshift=0em,yshift=1em]box6.north) {$\mathbi{h}_{w_1}$};
\node [anchor=south,wrnode] (wr2) at ([xshift=0em,yshift=1em]box7.north) {$\mathbi{h}_{w_2}$};
\node [anchor=south,wrnode] (wr3) at ([xshift=0em,yshift=1em]box8.north) {$\mathbi{h}_{w_3}$};
\node [anchor=south,wnode] (h1) at ([xshift=0em,yshift=0.3em]wr1.north) {${\mathbi{h}'}_1$\ :\ };
\node [anchor=south,wnode] (h2) at ([xshift=0em,yshift=0.3em]wr2.north) {${\mathbi{h}'}_2$\ :\ };
\node [anchor=south,wnode] (h3) at ([xshift=0em,yshift=0.3em]wr3.north) {${\mathbi{h}'}_3$\ :\ };
\begin{pgfonlayer}{background}
\node [rectangle,minimum width=20em,minimum height=13em,inner sep=0.5em,draw=blue!80,dashed,very thick,rounded corners=10pt] [fit = (h1) (w1) (h3) (c3)] (box1) {};
\node [rectangle,inner sep=0.5em,draw=yellow!80,dashed,very thick,rounded corners=10pt] [fit = (sr1) (sr4) (w4) (w7)] (box2) {};
\node [rectangle,inner sep=0.4em,fill=gray!20,draw=black,dashed,very thick,rounded corners=8pt] [fit = (wr1)] (box3) {};
\node [rectangle,inner sep=0.4em,fill=gray!20,draw=black,dashed,very thick,rounded corners=8pt] [fit = (wr2)] (box4) {};
\node [rectangle,inner sep=0.4em,fill=gray!20,draw=black,dashed,very thick,rounded corners=8pt] [fit = (wr3)] (box5) {};
\end{pgfonlayer}
\draw [->,thick] ([xshift=0em,yshift=0em]w4.north) -- ([xshift=0em,yshift=0em]sr1.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w5.north) -- ([xshift=0em,yshift=0em]sr2.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w6.north) -- ([xshift=0em,yshift=0em]sr3.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w7.north) -- ([xshift=0em,yshift=0em]sr4.south);
\draw [->,thick] ([xshift=0em,yshift=0.7em]dot4.north) -- ([xshift=0em,yshift=-0.7em]dot1.south);
\draw [->,thick] ([xshift=0em,yshift=0.7em]dot5.north) -- ([xshift=0em,yshift=-0.7em]dot2.south);
\draw [->,thick] ([xshift=0em,yshift=0.7em]dot6.north) -- ([xshift=0em,yshift=-0.7em]dot3.south);
\draw [<->,thick] ([xshift=0em,yshift=0em]wr1.east) -- ([xshift=0em,yshift=0em]wr2.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]wr2.east) -- ([xshift=0em,yshift=0em]wr3.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]sr1.east) -- ([xshift=0em,yshift=0em]dot1.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]dot1.east) -- ([xshift=0em,yshift=0em]sr2.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]sr2.east) -- ([xshift=0em,yshift=0em]dot2.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]dot2.east) -- ([xshift=0em,yshift=0em]sr3.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]sr3.east) -- ([xshift=0em,yshift=0em]dot3.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]dot3.east) -- ([xshift=0em,yshift=0em]sr4.west);
\draw [->,thick] ([xshift=0em,yshift=0em]sr2.north) -- ([xshift=0em,yshift=0em]c1.south);
\draw [->,thick] ([xshift=0em,yshift=0em]sr3.north) -- ([xshift=0em,yshift=0em]c2.south);
\draw [->,thick] ([xshift=0em,yshift=0em]sr4.north) -- ([xshift=0em,yshift=0em]c3.south);
\draw [->,thick] ([xshift=0em,yshift=0em]box6.north) -- ([xshift=0em,yshift=0em]wr1.south);
\draw [->,thick] ([xshift=0em,yshift=0em]box7.north) -- ([xshift=0em,yshift=0em]wr2.south);
\draw [->,thick] ([xshift=0em,yshift=0em]box8.north) -- ([xshift=0em,yshift=0em]wr3.south);
\node [anchor=east] (r2) at ([xshift=-2em,yshift=0em]box2.west) {句法RNN};
\node [anchor=south] (r1) at ([xshift=0em,yshift=8em]r2.north) {词语RNN};
\node [anchor=north] (label2) at ([xshift=0em,yshift=-2em]w5.south) {(b)分层结构};
\end{scope}
}
\end{tikzpicture}
\end{center}
\ No newline at end of file
Chapter15/Figures/figure-three-fusion-methods-of-tree-structure-information-3.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
\begin{center}
\begin{tikzpicture}
\tikzstyle{hnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,fill=red!30]
\tikzstyle{dotnode}=[inner sep=0mm,minimum height=0.5em,minimum width=1.5em]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.8em]
{\small
\begin{scope}[]
\node [anchor=west,hnode] (n1) at (0,0) {$\mathbi{h}_{1}$};
\node [anchor=west,hnode] (n2) at ([xshift=1em,yshift=0em]n1.east) {$\mathbi{h}_{2}$};
\node [anchor=west,dotnode] (dot1) at ([xshift=1em,yshift=0em]n2.east) {$\cdots$};
\node [anchor=west,hnode] (n3) at ([xshift=1em,yshift=0em]dot1.east) {$\mathbi{h}_{4}$};
\node [anchor=west,dotnode] (dot2) at ([xshift=1em,yshift=0em]n3.east) {$\cdots$};
\node [anchor=west,hnode] (n4) at ([xshift=1em,yshift=0em]dot2.east) {$\mathbi{h}_{7}$};
\node [anchor=west,dotnode] (dot3) at ([xshift=1em,yshift=0em]n4.east) {$\cdots$};
\node [anchor=west,hnode] (n5) at ([xshift=1em,yshift=0em]dot3.east) {$\mathbi{h}_{10}$};
\node [anchor=north,wnode,font=\footnotesize] (w1) at ([xshift=0em,yshift=-1em]n1.south) {$l_1$\ :\ S};
\node [anchor=north,wnode,font=\footnotesize] (w2) at ([xshift=0em,yshift=-1em]n2.south) {$l_3$\ :\ NP};
\node [anchor=north,dotnode] (dot4) at ([xshift=0em,yshift=-2.4em]dot1.south) {$\cdots$};
\node [anchor=north,wnode,font=\footnotesize] (w3) at ([xshift=0em,yshift=-1em]n3.south) {$w_1$\ :\ I};
\node [anchor=north,dotnode] (dot5) at ([xshift=0em,yshift=-2.2em]dot2.south) {$\cdots$};
\node [anchor=north,wnode,font=\footnotesize] (w4) at ([xshift=0em,yshift=-1em]n4.south) {$w_2$\ :\ love};
\node [anchor=north,dotnode] (dot6) at ([xshift=0em,yshift=-2.3em]dot3.south) {$\cdots$};
\node [anchor=north,wnode,font=\footnotesize] (w5) at ([xshift=0em,yshift=-1em]n5.south) {$w_3$\ :\ dogs};
\node [anchor=south,wnode] (h1) at ([xshift=0em,yshift=0.3em]n3.north) {${\mathbi{h}'}_1$\ :\ };
\node [anchor=south,wnode] (h2) at ([xshift=0em,yshift=0.3em]n4.north) {${\mathbi{h}'}_2$\ :\ };
\node [anchor=south,wnode] (h3) at ([xshift=0em,yshift=0.3em]n5.north) {${\mathbi{h}'}_3$\ :\ };
\begin{pgfonlayer}{background}
\node [rectangle,inner sep=0.5em,draw=red!80,dashed,very thick,rounded corners=10pt] [fit = (w1) (w5) (n1) (h3)] (box1) {};
\node [rectangle,inner sep=0.4em,fill=gray!20,draw=black,dashed,very thick,rounded corners=8pt] [fit = (n3)] (box3) {};
\node [rectangle,inner sep=0.4em,fill=gray!20,draw=black,dashed,very thick,rounded corners=8pt] [fit = (n4)] (box4) {};
\node [rectangle,inner sep=0.4em,fill=gray!20,draw=black,dashed,very thick,rounded corners=8pt] [fit = (n5)] (box5) {};
\end{pgfonlayer}
\node [anchor=east] (r1) at ([xshift=-2em,yshift=0em]box1.west) {词语RNN};
\node [anchor=south west,wnode] (l1) at ([xshift=1em,yshift=6em]r1.north west) {先序遍历句法树，得到序列：};
\node [anchor=north west,wnode,align=center] (l2) at ([xshift=0.5em,yshift=-0.6em]l1.north east) {S\\[0.5em]$l_1$};
\node [anchor=north west,wnode,align=center] (l3) at ([xshift=0.5em,yshift=0em]l2.north east) {NP\\[0.5em]$l_2$};
\node [anchor=north west,wnode,align=center] (l4) at ([xshift=0.5em,yshift=0em]l3.north east) {PRN\\[0.5em]$l_3$};
\node [anchor=north west,wnode,align=center] (l5) at ([xshift=0.5em,yshift=0em]l4.north east) {I\\[0.5em]$w_1$};
\node [anchor=north west,wnode,align=center] (l6) at ([xshift=0.5em,yshift=0em]l5.north east) {VP\\[0.5em]$l_4$};
\node [anchor=north west,wnode,align=center] (l7) at ([xshift=0.5em,yshift=0em]l6.north east) {VBP\\[0.5em]$l_5$};
\node [anchor=north west,wnode,align=center] (l8) at ([xshift=0.5em,yshift=0em]l7.north east) {love\\[0.5em]$w_2$};
\node [anchor=north west,wnode,align=center] (l9) at ([xshift=0.5em,yshift=0em]l8.north east) {NP\\[0.5em]$l_6$};
\node [anchor=north west,wnode,align=center] (l10) at ([xshift=0.5em,yshift=0em]l9.north east) {NNS\\[0.5em]$l_7$};
\node [anchor=north west,wnode,align=center] (l11) at ([xshift=0.5em,yshift=0em]l10.north east) {dogs\\[0.5em]$w_3$};
\draw [->,thick] ([xshift=0em,yshift=0em]w1.north) -- ([xshift=0em,yshift=0em]n1.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w2.north) -- ([xshift=0em,yshift=0em]n2.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w3.north) -- ([xshift=0em,yshift=0em]n3.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w4.north) -- ([xshift=0em,yshift=0em]n4.south);
\draw [->,thick] ([xshift=0em,yshift=0em]w5.north) -- ([xshift=0em,yshift=0em]n5.south);
\draw [->,thick] ([xshift=0em,yshift=0.7em]dot4.north) -- ([xshift=0em,yshift=-0.7em]dot1.south);
\draw [->,thick] ([xshift=0em,yshift=0.7em]dot5.north) -- ([xshift=0em,yshift=-0.7em]dot2.south);
\draw [->,thick] ([xshift=0em,yshift=0.7em]dot6.north) -- ([xshift=0em,yshift=-0.7em]dot3.south);
\draw [<->,thick] ([xshift=0em,yshift=0em]n1.east) -- ([xshift=0em,yshift=0em]n2.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]n2.east) -- ([xshift=0em,yshift=0em]dot1.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]dot1.east) -- ([xshift=0em,yshift=0em]n3.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]n3.east) -- ([xshift=0em,yshift=0em]dot2.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]dot2.east) -- ([xshift=0em,yshift=0em]n4.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]n4.east) -- ([xshift=0em,yshift=0em]dot3.west);
\draw [<->,thick] ([xshift=0em,yshift=0em]dot3.east) -- ([xshift=0em,yshift=0em]n5.west);
\node [anchor=north] (label2) at ([xshift=-2em,yshift=-2em]w3.south) {(c)混合结构};
\end{scope}
}
\end{tikzpicture}
\end{center}
\ No newline at end of file
Chapter15/chapter15.tex
This source diff could not be displayed because it is too large. You can view the blob instead.
Chapter16/Figures/figure-data-based-domain-adaptation-approach.tex 0 → 100644
\begin{tikzpicture}[scale=0.8]
\begin{scope}
\tikzstyle{data} = [draw,black,very thick,inner sep=2pt,rounded corners=0pt,minimum width=2.5em,minimum height=1.5em,anchor=west]
\tikzstyle{model} = [draw,black,very thick,inner sep=3.5pt,rounded corners=0pt,fill=red!20,minimum width=3em,minimum height=1.5em,font=\footnotesize]
\tikzstyle{word} = [inner sep=3.5pt,align=left,font=\scriptsize]
\tikzstyle{more} = [inner sep=2pt,rounded corners=0pt,minimum width=2.5em,minimum height=1.5em,anchor=west]
\node[data,fill=blue!20] (one) at (0,0) {};
\node[data,fill=green!20] (two) at ([xshift=-0.2em]one.east) {};
\node[data,fill=yellow!20] (three) at ([xshift=-0.2em]two.east) {};
\node[data,fill=blue!20,minimum width=1em] (one_) at ([yshift=-6em]one.south west) {};
\node[data,fill=green!20,minimum width=4.5em] (two_) at ([xshift=-0.2em]one_.east) {};
\node[data,fill=yellow!20,minimum width=2em] (three_) at ([xshift=-0.2em]two_.east) {};
\node[model] (mo) at ([xshift=0.5em,yshift=-5em]two_.south){模型};
\node[word] at ([xshift=-1.5em]one.west) {原始 \\ 数据};
\node[word] at ([xshift=-1.5em]one_.west) {加权};
\node[word,font=\tiny] at ([yshift=1em]one.north) {$(x_1,y_1)$};
\node[word,font=\tiny] at ([yshift=1em]two.north) {$(x_2,y_2)$};
\node[word,font=\tiny] at ([yshift=1em]three.north) {$(x_3,y_3)$};
\node[word,font=\tiny] at ([yshift=1em]one_.north) {$(x_1,y_1)$};
\node[word,font=\tiny] at ([yshift=1em]two_.north) {$(x_2,y_2)$};
\node[word,font=\tiny] at ([yshift=1em]three_.north) {$(x_3,y_3)$};
\draw [->,thick] ([yshift=-0.2em]one.south) .. controls +(south:2.5em) and +(north:2.5em) .. ([yshift=1.5em]one_.north);
\draw [->,thick] ([yshift=-0.2em]two.south) .. controls +(south:2.5em) and +(north:2.5em) .. ([yshift=1.5em]two_.north);
\draw [->,thick] ([yshift=-0.2em]three.south) .. controls +(south:2.5em) and +(north:2.5em) .. ([yshift=1.5em]three_.north);
\draw [->,thick] ([xshift=0.5em,yshift=-0.2em]two_.south) -- ([yshift=0.2em]mo.north) node[pos=0.5,left,align=center,font=\footnotesize]{训练};
\node[font=\small] at ([yshift=-4em]mo.south){(a)数据加权};
\end{scope}
\begin{scope}
\tikzstyle{data} = [draw,black,very thick,inner sep=2pt,rounded corners=0pt,minimum width=2.5em,minimum height=1.5em,anchor=west]
\tikzstyle{model} = [draw,black,very thick,inner sep=3.5pt,rounded corners=0pt,fill=red!20,minimum width=3em,minimum height=1.5em,font=\footnotesize]
\tikzstyle{word} = [inner sep=3.5pt,align=left,font=\scriptsize]
\tikzstyle{more} = [inner sep=2pt,rounded corners=0pt,minimum width=2.5em,minimum height=1.5em,anchor=west]
\node[data,fill=blue!20] (one-2) at ([xshift=10.0em]one.east) {};
\node[data,fill=green!20] (two-2) at ([xshift=-0.2em]one-2.east) {};
\node[data,fill=yellow!20] (three-2) at ([xshift=-0.2em]two-2.east) {};
\node[data,fill=blue!20] (one_-2) at ([yshift=-6em]one-2.south west) {};
\node[data,fill=yellow!20] (three_-2) at ([xshift=-0.2em]one_-2.east) {};
\node[model] (mo-2) at ([xshift=1.7em,yshift=-5em]one_-2.south){模型};
\node[word] at ([xshift=-1.5em]one-2.west) {原始 \\ 数据};
\node[word] at ([xshift=-1.5em]one_-2.west) {选择};
\node[word,font=\tiny] at ([yshift=1em]one-2.north) {$(x_1,y_1)$};
\node[word,font=\tiny] at ([yshift=1em]two-2.north) {$(x_2,y_2)$};
\node[word,font=\tiny] at ([yshift=1em]three-2.north) {$(x_3,y_3)$};
\node[word,font=\tiny] at ([yshift=1em]one_-2.north) {$(x_1,y_1)$};
\node[word,font=\tiny] at ([yshift=1em]three_-2.north) {$(x_3,y_3)$};
\draw [->,thick] ([yshift=-0.2em]one-2.south) .. controls +(south:2.5em) and +(north:2.5em) .. ([yshift=1.5em]one_-2.north);
\draw [->,thick] ([yshift=-0.2em]three-2.south) .. controls +(south:2.5em) and +(north:2.5em) .. ([yshift=1.5em]three_-2.north);
\draw [->,thick] ([xshift=1.7em,yshift=-0.2em]one_-2.south) -- ([yshift=0.2em]mo-2.north) node[pos=0.5,left,align=center,font=\footnotesize]{训练};
\node[font=\small] at ([yshift=-4em]mo-2.south){(b)数据选择};
\end{scope}
\begin{scope}
\tikzstyle{data} = [draw,black,very thick,inner sep=2pt,rounded corners=0pt,minimum width=2.5em,minimum height=1.5em,anchor=west]
\tikzstyle{model} = [draw,black,very thick,inner sep=3.5pt,rounded corners=0pt,fill=red!20,minimum width=3em,minimum height=1.5em,font=\footnotesize]
\tikzstyle{word} = [inner sep=3.5pt,align=left,font=\scriptsize]
\tikzstyle{more} = [inner sep=2pt,rounded corners=0pt,minimum width=2.5em,minimum height=1.5em,anchor=west]
\node[data,fill=blue!20] (one-3) at ([xshift=10.0em]one-2.east) {};
\node[data,fill=green!20] (two-3) at ([xshift=-0.2em]one-3.east) {};
\node[data,fill=yellow!20] (three-3) at ([xshift=-0.2em]two-3.east) {};
\node[data,fill=blue!20] (one_-3) at ([yshift=-6em]one-3.south west) {};
\node[data,fill=green!20] (two_-3) at ([xshift=-0.2em]one_-3.east) {};
\node[data,fill=yellow!20] (three_-3) at ([xshift=-0.2em]two_-3.east) {};
\node[data,fill=black!10] (new_-3) at ([xshift=-0.2em]three_-3.east) {};
\node[model] (mo-3) at ([xshift=1.7em,yshift=-5em]two_-3.south){模型};
\node[word] at ([xshift=-1.5em]one-3.west) {原始 \\ 数据};
\node[word] at ([xshift=-1.5em]one_-3.west) {伪数据};
\node[word,font=\tiny] at ([yshift=1em]one-3.north) {$(x_1,y_1)$};
\node[word,font=\tiny] at ([yshift=1em]two-3.north) {$(x_2,y_2)$};
\node[word,font=\tiny] at ([yshift=1em]three-3.north) {$(x_3,y_3)$};
\node[word,font=\scriptsize] (monolingual-3) at ([xshift=5em]three-3.south) {$x_4$};
\node[word,font=\tiny] at ([yshift=1em]one_-3.north) {$(x_1,y_1)$};
\node[word,font=\tiny] at ([yshift=1em]two_-3.north) {$(x_2,y_2)$};
\node[word,font=\tiny] at ([yshift=1em]three_-3.north) {$(x_3,y_3)$};
\node[word,font=\tiny] at ([yshift=1em]new_-3.north) {{\red $(x_4,y_4^*)$}};
\draw [->,thick] ([yshift=-0.2em]one-3.south) .. controls +(south:2.5em) and +(north:2.5em) .. ([yshift=1.5em]one_-3.north);
\draw [->,thick] ([yshift=-0.2em]two-3.south) .. controls +(south:2.5em) and +(north:2.5em) .. ([yshift=1.5em]two_-3.north);
\draw [->,thick] ([yshift=-0.2em]three-3.south) .. controls +(south:2.5em) and +(north:2.5em) .. ([yshift=1.5em]three_-3.north);
\draw [->,thick] ([yshift=-0.2em]monolingual-3.south) .. controls +(south:2.5em) and +(north:2.5em) .. ([xshift=0.8em,yshift=1.6em]new_-3.north);
\draw [->,thick] ([xshift=1.7em,yshift=-0.2em]two_-3.south) -- ([yshift=0.2em]mo-3.north) node[pos=0.5,left,align=center,font=\footnotesize]{训练};
\node[font=\small] at ([yshift=-4em]mo-3.south){(c)伪数据};
\end{scope}
\end{tikzpicture}
Chapter16/Figures/figure-mass.tex
......@@ -7,12 +7,12 @@
\node [anchor=center,model,fill=blue!20] (decoder) at ([xshift=7.5em]ate.east) {\small{解码器}};
\node [anchor=north,word] (w1) at ([yshift=-1.5em,xshift=0em]decoder.south) {\small{$x_3$}};
\node [anchor=west,word] (w2) at ([xshift=0em]w1.east) {\small{$x_4$}};
\node [anchor=west,word] (w3) at ([xshift=0em]w2.east) {[M]};
\node [anchor=west,word] (w3) at ([xshift=0em]w2.east) {<M>};
\node [anchor=east,word] (w4) at ([xshift=0em]w1.west) {[M]};
\node [anchor=east,word] (w5) at ([xshift=0em]w4.west) {[M]};
\node [anchor=east,word] (w6) at ([xshift=0em]w5.west) {[M]};
\node [anchor=west,word] (w7) at ([xshift=0em]w3.east) {[M]};
\node [anchor=east,word] (w4) at ([xshift=0em]w1.west) {<M>};
\node [anchor=east,word] (w5) at ([xshift=0em]w4.west) {<M>};
\node [anchor=east,word] (w6) at ([xshift=0em]w5.west) {<M>};
\node [anchor=west,word] (w7) at ([xshift=0em]w3.east) {<M>};
\node [anchor=south,word] (w8) at ([yshift=1.5em,xshift=0em]decoder.north) {\small{$x_4$}};
\node [anchor=east,word] (w9) at (w8.west) {\small{$x_3$}};
......@@ -33,11 +33,11 @@
%encoder
\node [model] (encoder) at ([xshift=-7.5em]ate.west) {\small{编码器}};
\node [anchor=north,word] (we1) at ([yshift=-1.5em,xshift=0em]encoder.south) {[M]};
\node [anchor=west,word] (we2) at ([xshift=0em]we1.east) {[M]};
\node [anchor=north,word] (we1) at ([yshift=-1.5em,xshift=0em]encoder.south) {<M>};
\node [anchor=west,word] (we2) at ([xshift=0em]we1.east) {<M>};
\node [anchor=west,word] (we3) at ([xshift=0em]we2.east) {\small{$x_6$}};
\node [anchor=east,word] (we4) at ([xshift=0em]we1.west) {[M]};
\node [anchor=east,word] (we4) at ([xshift=0em]we1.west) {<M>};
\node [anchor=east,word] (we5) at ([xshift=0em]we4.west) {\small{$x_2$}};
\node [anchor=east,word] (we6) at ([xshift=0em]we5.west) {\small{$x_1$}};
\node [anchor=west,word] (we7) at ([xshift=0em]we3.east) {\small{$x_7$}};
......@@ -51,5 +51,5 @@
\draw [->,thick] (we7.north) -- ([yshift=1.35em]we7.north);
\draw [->,very thick] ([xshift=0.5em]encoder)--([xshift=-0.3em]decoder);
\node [anchor=south] (ex) at ([xshift=-4.0em,yshift=1.0em]encoder.north) {\small{[M]：Mask}};
\node [anchor=south] (ex) at ([xshift=-4.0em,yshift=1.0em]encoder.north) {\small{<M>：<Mask>}};
\end{tikzpicture}
\ No newline at end of file
Chapter16/Figures/figure-multi-language-single-model-system-diagram.tex
......@@ -3,13 +3,13 @@
%-------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{lan}=[font=\footnotesize,inner ysep=2pt,minimum height=1em]
\node[minimum height=3em,minimum width=8em,fill=orange!20,draw,rounded corners=2pt,align=center,line width=0.6pt] (sys) at (0,0){多语言 \\ 单模型系统};
\node[draw,font=\footnotesize,minimum width=4em,fill=red!20,rounded corners=1pt,line width=0.6pt] (en) at (-3em,4em){英语};
\node[draw,font=\footnotesize,minimum width=4em,fill=red!20,rounded corners=1pt,line width=0.6pt] (fr) at (3em,4em){法语};
\node[minimum width=4em] at (6.6em,4em){$\dots$};
\node[draw,font=\footnotesize,minimum width=4em,fill=blue!20,rounded corners=1pt,line width=0.6pt] (de) at (-3em,-4em){德语};
\node[draw,font=\footnotesize,minimum width=4em,fill=blue!20,rounded corners=1pt,line width=0.6pt] (sp) at (3em,-4em){西班牙语};
\node[minimum width=4em] at (6.6em,-4em){$\dots$};
\node[minimum height=4em,minimum width=8em,fill=orange!20,draw,rounded corners=2pt,align=center,line width=0.6pt,font=\small] (sys) at (0,0){多语言 \\ 单模型系统};
\node[draw,font=\footnotesize,minimum width=4em,fill=red!20,rounded corners=1pt,line width=0.6pt] (en) at (-3em,5em){英语};
\node[draw,font=\footnotesize,minimum width=4em,fill=red!20,rounded corners=1pt,line width=0.6pt] (fr) at (3em,5em){法语};
\node[minimum width=4em] at (6.6em,5em){$\dots$};
\node[draw,font=\footnotesize,minimum width=4em,fill=blue!20,rounded corners=1pt,line width=0.6pt] (de) at (-3em,-5em){德语};
\node[draw,font=\footnotesize,minimum width=4em,fill=blue!20,rounded corners=1pt,line width=0.6pt] (sp) at (3em,-5em){西班牙语};
\node[minimum width=4em] at (6.6em,-5em){$\dots$};
\draw[->,thick] (en.-90) -- ([xshift=-1em]sys.90);
\draw[->,thick] (fr.-90) -- ([xshift=1em]sys.90);
......
Chapter16/Figures/figure-parameter-initialization-method-diagram.tex
......@@ -12,10 +12,10 @@
\node[node,anchor=west,minimum width=6em,minimum height=2.4em,fill=blue!20,line width=0.6pt] (decoder2) at ([xshift=4em,yshift=0em]decoder1.east){\small 解码器};
\node[node,anchor=west,minimum width=6em,minimum height=2.4em,fill=blue!30,line width=0.6pt] (decoder3) at ([xshift=3em]decoder2.east){\small 解码器};
\node[anchor=north,font=\scriptsize,fill=yellow!20] (w1) at ([yshift=-1.6em]decoder1.south){知识 \ 就是 \ 力量 \ 。 \ <eos>};
\node[anchor=north,font=\scriptsize,fill=green!20] (w3) at ([yshift=-1.6em]decoder3.south){Wissen \ ist \ Machit \ . \ <eos>};
\node[anchor=south,font=\scriptsize,fill=orange!20] (w2) at ([yshift=1.6em]encoder1.north){Knowledge \ is \ power \ . };
\node[anchor=south,font=\scriptsize,fill=orange!20] (w4) at ([yshift=1.6em]encoder3.north){Knowledge \ is \ power \ . };
\node[anchor=north,font=\scriptsize,fill=yellow!20,drop shadow,draw] (w1) at ([yshift=-1.6em]decoder1.south){知识 \ 就是 \ 力量 \ 。 \ <eos>};
\node[anchor=north,font=\scriptsize,fill=green!20,drop shadow,draw] (w3) at ([yshift=-1.6em]decoder3.south){El conocimiento es poder . <eos>};
\node[anchor=south,font=\scriptsize,fill=orange!20,drop shadow,draw] (w2) at ([yshift=1.6em]encoder1.north){Knowledge \ is \ power \ . };
\node[anchor=south,font=\scriptsize,fill=orange!20,drop shadow,draw] (w4) at ([yshift=1.6em]encoder3.north){Knowledge \ is \ power \ . };
\draw[->,thick] (decoder1.-90) -- (w1.north);
......
Chapter16/chapter16.tex
......@@ -62,7 +62,7 @@
\parinterval 围绕如何利用回译方法生成伪双语数据这一问题，研究人员进行了详细地分析探讨。一般观点认为，反向翻译模型的性能越好，生成的伪数据质量也就越高，对正向翻译模型的性能提升也就越大\upcite{Sennrich2016ImprovingNM,DBLP:conf/aclnmt/HoangKHC18}。不过，在实践中发现，即使一些简单的策略也能带来性能的增长。比如，对于一些低资源翻译任务，通过将目标语言句子复制到源语言端构造伪数据便能带来增益\upcite{DBLP:conf/wmt/CurreyBH17}。原因在于，即使构造的双语伪数据是不准确的，其目标语言端仍然是真实数据，可以使解码器训练得更加充分，进而提升神经机器翻译模型生成结果的流畅度。但是，相比这些简单的伪数据生成策略，利用目标语言单语数据进行回译可以带来更大的性能提升\upcite{DBLP:conf/wmt/CurreyBH17}。一种可能的解释是，双语伪数据的源语言是模型生成的翻译结果，保留了两种语言之间的互译信息，相比真实数据又存在一定的噪声。神经机器翻译模型在伪双语句对上进行训练，可以学习到如何处理带有噪声的输入，提高了模型的健壮性。
\parinterval 在回译方法中，反向翻译模型的训练只依赖于有限的双语数据，因此生成的源语言端伪数据的质量难以保证。为此，可以采用{\small\sffamily\bfnew{迭代式回译}}\index{迭代式回译}（Iterative Back Translation）\index{Iterative Back Translation}的方法\upcite{DBLP:conf/aclnmt/HoangKHC18}，同时利用源语言端和目标语言端的单语数据，不断通过回译的方式来提升正向和反向翻译模型的性能。图\ref{fig:16-2}展示了迭代式回译的框架。首先，使用双语数据训练一个正向翻译模型，然后利用额外的源语言单语数据通过回译的方式生成伪双语数据，来提升反向翻译模型的性能。之后，再利用反向翻译模型和额外的目标语言单语数据生成伪双语数据，用于提升正向翻译模型的性能。可以看出，迭代式回译的过程是完全闭环的，因此可以一直重复进行，直到正向和反向翻译模型的性能均不再提升。
\parinterval 在回译方法中，反向翻译模型的训练只依赖于有限的双语数据，因此生成的源语言端伪数据的质量难以保证。为此，可以采用{\small\sffamily\bfnew{迭代式回译}}\index{迭代式回译}（Iterative Back Translation）\index{Iterative Back Translation}的方法\upcite{DBLP:conf/aclnmt/HoangKHC18}，同时利用源语言端和目标语言端的单语数据，不断通过回译的方式来提升正向和反向翻译模型的性能。图\ref{fig:16-2}展示了迭代式回译的框架，图中带圈的数字代表了迭代式回译方法执行的顺序。首先，使用双语数据训练一个正向翻译模型，然后利用额外的源语言单语数据通过回译的方式生成伪双语数据，来提升反向翻译模型的性能。之后，再利用反向翻译模型和额外的目标语言单语数据生成伪双语数据，用于提升正向翻译模型的性能。可以看出，迭代式回译的过程是完全闭环的，因此可以一直重复进行，直到正向和反向翻译模型的性能均不再提升。
%----------------------------------------------
\begin{figure}[htp]
......@@ -90,7 +90,7 @@
\vspace{0.5em}
\item 丢掉单词：句子中的每个词均有$\funp{P}_{\rm{Drop}}$的概率被丢弃。
\vspace{0.5em}
\item 掩码单词：句子中的每个词均有$\funp{P}_{\rm{Mask}}$的概率被替换为一个额外的[Mask]词。[Mask]的作用类似于占位符，可以理解为一个句子中的部分词被屏蔽掉，无法得知该位置词的准确含义。
\item 掩码单词：句子中的每个词均有$\funp{P}_{\rm{Mask}}$的概率被替换为一个额外的<Mask>词。<Mask>的作用类似于占位符，可以理解为一个句子中的部分词被屏蔽掉，无法得知该位置词的准确含义。
\vspace{0.5em}
\item 打乱顺序：将句子中距离较近的某些词的位置进行随机交换。
\vspace{0.5em}
......@@ -207,7 +207,7 @@
\parinterval GPT\upcite{radford2018improving}通过Transformer模型自回归地训练单向语言模型，类似于神经机器翻译模型的解码器，相比双向LSTM等模型，Tranformer模型的表示能力更强。在大规模单语数据上预训练得到的模型结构只需要进行简单的修改，再通过任务特定的训练数据进行微调，就可以很好地适配到下游任务中。之后提出的BERT模型更是将预训练的作用提升到了新的水平\upcite{devlin2019bert}。GPT模型的一个缺陷在于模型只能进行单向编码，也就是前面的文本在建模时无法获取到后面的信息。而BERT提出了一种自编码的方式，使模型在预训练阶段可以通过双向编码的方式进行建模，进一步增强了模型的表示能力。
\parinterval BERT的核心思想是通过{\small\bfnew{掩码语言模型}}（Masked Language Model，MLM）\index{掩码语言模型}\index{MLM}任务进行预训练。掩码语言模型的思想类似于完形填空，随机选择输入句子中的部分词掩码，之后让模型预测这些被掩码的词。掩码的具体做法是将被选中的词替换为一个特殊的词[Mask]，这样模型在训练过程中，无法得到掩码位置词的信息，需要联合上下文内容进行预测，因此提高了模型对上下文的特征提取能力。实验表明，相比在下游任务中仅利用上下文词嵌入，在大规模单语数据上预训练的模型具有更强的表示能力。而使用掩码的方式进行训练也给神经机器翻译提供了新的思路，在本章中也会使用到类似方法。
\parinterval BERT的核心思想是通过{\small\bfnew{掩码语言模型}}（Masked Language Model，MLM）\index{掩码语言模型}\index{MLM}任务进行预训练。掩码语言模型的思想类似于完形填空，随机选择输入句子中的部分词掩码，之后让模型预测这些被掩码的词。掩码的具体做法是将被选中的词替换为一个特殊的词<Mask>，这样模型在训练过程中，无法得到掩码位置词的信息，需要联合上下文内容进行预测，因此提高了模型对上下文的特征提取能力。实验表明，相比在下游任务中仅利用上下文词嵌入，在大规模单语数据上预训练的模型具有更强的表示能力。而使用掩码的方式进行训练也给神经机器翻译提供了新的思路，在本章中也会使用到类似方法。
\parinterval 在神经机器翻译任务中，预训练模型可以用于初始化编码器的模型参数\upcite{DBLP:conf/emnlp/ClinchantJN19,DBLP:conf/emnlp/ImamuraS19,DBLP:conf/naacl/EdunovBA19}。之所以用在编码器端而不是解码器端，主要原因是编码器的作用主要在于特征提取，训练难度相对较高，而解码器的作用主要在于生成，和编码器提取到的表示是强依赖的，相对比较脆弱\upcite{DBLP:journals/corr/abs-1908-06259}。
......@@ -215,7 +215,7 @@
\parinterval 因此，一种做法将预训练模型和翻译模型进行融合，把预训练模型作为一个独立的模块来为编码器或者解码器提供句子级表示信息\upcite{DBLP:journals/corr/abs-2002-06823,DBLP:conf/aaai/YangW0Z00020}。另外一种做法是针对生成任务进行预训练。机器翻译是一种典型的语言生成任务，不仅包含源语言表示学习的问题，还有序列到序列的映射，以及目标语言端序列生成的问题，这些知识是无法单独通过（源语言）单语数据学习到的。因此，可以使用单语数据对编码器-解码器结构进行预训练\upcite{song2019mass,DBLP:conf/acl/LewisLGGMLSZ20,DBLP:conf/emnlp/QiYGLDCZ020}。
\parinterval 以{\small\bfnew{掩码端到端预训练}}（Masked Sequence to Sequence Pre-training，MASS）\index{掩码端到端预训练}\index{MASS}方法为例\upcite{song2019mass}，其思想与BERT十分相似，也是在预训练过程中采用掩码的方式，随机选择编码器输入句子中的连续片段替换为特殊词[Mask]，然后在解码器预测这个连续片段，如图\ref{fig:16-6} 所示。这种做法可以使得编码器捕捉上下文信息，同时迫使解码器依赖于编码器进行自回归的生成，从而学习到编码器和解码器之间的注意力。为了适配下游的机器翻译任务，使预训练模型可以学习到不同语言的表示，MASS对不同语言的句子采用共享词汇表和模型参数的方法，利用同一个预训练模型来进行不同语言句子的预训练。通过这种方式，模型既学到了对源语言句子的编码，也学习到了对目标语言句子的生成方法，之后通过使用双语句对来对预训练模型的参数进行微调，模型可以快速收敛到较好的水平。
\parinterval 以{\small\bfnew{掩码端到端预训练}}（Masked Sequence to Sequence Pre-training，MASS）\index{掩码端到端预训练}\index{MASS}方法为例\upcite{song2019mass}，其思想与BERT十分相似，也是在预训练过程中采用掩码的方式，随机选择编码器输入句子中的连续片段替换为特殊词<Mask>，然后在解码器预测这个连续片段，如图\ref{fig:16-6} 所示。这种做法可以使得编码器捕捉上下文信息，同时迫使解码器依赖于编码器进行自回归的生成，从而学习到编码器和解码器之间的注意力。为了适配下游的机器翻译任务，使预训练模型可以学习到不同语言的表示，MASS对不同语言的句子采用共享词汇表和模型参数的方法，利用同一个预训练模型来进行不同语言句子的预训练。通过这种方式，模型既学到了对源语言句子的编码，也学习到了对目标语言句子的生成方法，之后通过使用双语句对来对预训练模型的参数进行微调，模型可以快速收敛到较好的水平。
%----------------------------------------------
\begin{figure}[htp]
......@@ -335,7 +335,7 @@
\parinterval 有监督的对偶学习需要使用双语数据来训练两个翻译模型，但是有些低资源语言仅有少量双语数据可以训练。因此，如何使用资源相对丰富的单语数据来提升翻译模型的性能也是一个关键问题。
\parinterval 无监督对偶学习提供了一个解决问题的思路\upcite{qin2020dual}。假设目前有两个比较弱的翻译模型，一个原始翻译模型$f$将源语言句子$\seq{x}$翻译成目标语言句子$\seq{y}$，一个对偶任务模型$g$将目标语言句子$\seq{y}$翻译成源语言句子$\seq{x}$。翻译模型可由有限的双语训练或者使用无监督机器翻译的方法得到。如图\ref{fig:16-10}所示，无监督对偶学习的做法是，先通过原始任务模型$f$将一个源语言单语句子$x$翻译为目标语言句子$y$，由于没有参考译文，无法判断$y$的正确性。但通过语言模型，可以判断这个句子是否通顺、符合语法规范，这些信息可用来评估翻译模型$f$的翻译流畅性。随后，再通过对偶任务模型$g$将目标语言句子$y$翻译为源语言句子$x^{'}$。如果模型$f$和$g$的翻译性能较好，那么$x^{'}$和$x$会十分相似。通过计算二者的{\small\bfnew{重构损失}}\index{重构损失}（Reconstruction Loss）\index{Reconstruction Loss}，就可以优化模型$f$和$g$的参数。这个过程可以多次迭代，从大量的无标注单语数据上不断提升性能。
\parinterval 无监督对偶学习提供了一个解决问题的思路\upcite{qin2020dual}。假设目前有两个比较弱的翻译模型，一个原始翻译模型$f$将源语言句子$\seq{x}$翻译成目标语言句子$\seq{y}$，一个对偶任务模型$g$将目标语言句子$\seq{y}$翻译成源语言句子$\seq{x}$。翻译模型可由有限的双语训练或者使用无监督机器翻译的方法得到。如图\ref{fig:16-10}所示，无监督对偶学习的做法是，先通过原始任务模型$f$将一个源语言单语句子$x$翻译为目标语言句子$y$，随后，再通过对偶任务模型$g$将目标语言句子$y$翻译为源语言句子$x^{'}$。如果模型$f$和$g$的翻译性能较好，那么$x^{'}$和$x$会十分相似。通过计算二者的{\small\bfnew{重构损失}}\index{重构损失}（Reconstruction Loss）\index{Reconstruction Loss}，就可以优化模型$f$和$g$的参数。这个过程可以多次迭代，从大量的无标注单语数据上不断提升性能。
%----------------------------------------------
\begin{figure}[htp]
......@@ -440,7 +440,7 @@
%----------------------------------------------------------------------------------------
\subsubsection{1. 参数初始化方法}
\parinterval 在解决多语言翻译问题时，首先需要在富资源语言上训练一个翻译模型，将其称之为{\small\bfnew{父模型}}\index{父模型}（Parent Model）\index{Parent Model}。在对父模型的参数进行初始化的基础上，训练低资源语言的翻译模型，称之为{\small\bfnew{子模型}}\index{子模型}（Child Model）\index{Child Model}，这意味着低资源翻译模型将不会从随机初始化的参数开始学习，而是从父模型的参数开始\upcite{gu2018meta,DBLP:conf/icml/FinnAL17,DBLP:conf/naacl/GuHDL18}。这时，也可以把参数初始化看作是迁移学习。在图\ref{fig:16-14}中，左侧模型为父模型，右侧模型为子模型。这里假设从英语到汉语的翻译为富资源翻译，从英语到德语的翻译为低资源翻译，则首先用英中双语平行语料库训练出一个父模型，之后再用英语到德语的数据在父模型上微调得到子模型，这个子模型即为迁移学习的模型。此过程可以看作是在富资源语言训练模型上使用低资源语言的数据进行微调，将富资源语言中的知识迁移到低资源语言中，从而提升低资源语言的模型性能。
\parinterval 在解决多语言翻译问题时，首先需要在富资源语言上训练一个翻译模型，将其称之为{\small\bfnew{父模型}}\index{父模型}（Parent Model）\index{Parent Model}。在对父模型的参数进行初始化的基础上，训练低资源语言的翻译模型，称之为{\small\bfnew{子模型}}\index{子模型}（Child Model）\index{Child Model}，这意味着低资源翻译模型将不会从随机初始化的参数开始学习，而是从父模型的参数开始\upcite{gu2018meta,DBLP:conf/icml/FinnAL17,DBLP:conf/naacl/GuHDL18}。这时，也可以把参数初始化看作是迁移学习。在图\ref{fig:16-14}中，左侧模型为父模型，右侧模型为子模型。这里假设从英语到汉语的翻译为富资源翻译，从英语到西班牙语的翻译为低资源翻译，则首先用英中双语平行语料库训练出一个父模型，之后再用英语到西班牙语的数据在父模型上微调得到子模型，这个子模型即为迁移学习的模型。此过程可以看作是在富资源语言训练模型上使用低资源语言的数据进行微调，将富资源语言中的知识迁移到低资源语言中，从而提升低资源语言的模型性能。
%----------------------------------------------
\begin{figure}[h]
......@@ -484,7 +484,7 @@
\section{无监督机器翻译}
\parinterval 低资源机器翻译的一种极端情况是：没有任何可以用于模型训练的双语平行数据。一种思路是借用多语言翻译方面的技术（见\ref{multilingual-translation-model}节），利用基于枢轴语言或者零资源的方法构建翻译系统。但是，这类方法仍然需要多个语种的平行数据。对于某一个语言对，在只有源语言和目标语言单语数据的前提下，是否仍然可以训练一个有效的翻译模型呢？这里称这种不需要双语数据的机器翻译方法为{\small\bfnew{无监督机器翻译}}\index{无监督机器翻译}（Unsupervised Machine Translation\index{Un-supervised Machine Translation}）。
\parinterval 低资源机器翻译的一种极端情况是：没有任何可以用于模型训练的双语平行数据。一种思路是借用多语言翻译方面的技术（见\ref{multilingual-translation-model}节），利用基于枢轴语言或者零资源的方法构建翻译系统。但是，这类方法仍然需要多个语种的平行数据。对于某一个语言对，在只有源语言和目标语言单语数据的前提下，是否仍然可以训练一个有效的翻译模型呢？这里称这种不需要双语数据的机器翻译方法为{\small\bfnew{无监督机器翻译}}\index{无监督机器翻译}（Unsupervised Machine Translation\index{Unsupervised Machine Translation}）。
\parinterval 直接进行无监督机器翻译是很困难的。一个简单可行的思路是把问题进行分解，然后分别解决各个子问题，最后形成完整的解决方案。放到无监督机器翻译里面，可以首先使用无监督方法寻找词与词之间的翻译，然后在此基础上，进一步得到句子到句子的翻译模型。这种“由小到大”的建模思路十分类似于统计机器翻译中的方法（见\chapterseven）。
......@@ -552,7 +552,7 @@
\vspace{0.5em}
\end{itemize}
\parinterval 在得到映射$\mathbi{W}$之后，对于$\mathbi{X}$中的任意一个单词$x_{i}$，通过$\mathbi{W} \mathbi{E}({x}_{i})$将其映射到空间$\mathbi{y}$中（$\mathbi{E}({x}_{i})$表示的是单词$x_{i}$的词嵌入向量），然后在$\mathbi{Y}$中找到该点的最近邻点$y_{j}$，于是$y_{j}$就是$x_{i}$的翻译词，重复该过程即可归纳出种子词典$D$，第一阶段结束。事实上，由于第一阶段缺乏监督信号，得到的种子词典$D$会包含大量的噪音，因此需要进行进一步的微调。
\parinterval 在得到映射$\mathbi{W}$之后，对于$\mathbi{X}$中的任意一个单词$x_{i}$，通过$\mathbi{W} \mathbi{E}({x}_{i})$将其映射到空间$\mathbi{Y}$中（$\mathbi{E}({x}_{i})$表示的是单词$x_{i}$的词嵌入向量），然后在$\mathbi{Y}$中找到该点的最近邻点$y_{j}$，于是$y_{j}$就是$x_{i}$的翻译词，重复该过程即可归纳出种子词典$D$，第一阶段结束。事实上，由于第一阶段缺乏监督信号，得到的种子词典$D$会包含大量的噪音，因此需要进行进一步的微调。
\parinterval 微调的原理普遍基于普氏分析\upcite{DBLP:journals/corr/MikolovLS13}。假设现在有一个种子词典$D=\left\{x_{i}, y_{i}\right\}$其中${i \in\{1, n\}}$，和两个单语词嵌入$\mathbi{X}$和$\mathbi{Y}$，那么就可以将$D$作为{\small\bfnew{映射锚点}}\index{映射锚点}（Anchor\index{Anchor}）学习一个转移矩阵$\mathbi{W}$，使得$\mathbi{W} \mathbi{X}$与$\mathbi{Y}$这两个空间尽可能相近，此外通过对$\mathbi{W}$施加正交约束可以显著提高性能\upcite{DBLP:conf/naacl/XingWLL15}，于是这个优化问题就转变成了{\small\bfnew{普鲁克问题}}\index{普鲁克问题}（Procrustes Problem\index{Procrustes Problem}）\upcite{DBLP:conf/iclr/SmithTHH17}，可以通过{\small\bfnew{奇异值分解}}\index{奇异值分解}（Singular Value Decomposition，SVD\index{Singular Value Decomposition}）来获得近似解：
......@@ -565,8 +565,7 @@
\noindent 其中， $\|\cdot\|_{\mathrm{F}}$表示矩阵的Frobenius范数，即矩阵元素绝对值的平方和再开方，$d$是词嵌入的维度，$\mathbb{R}$是实数，$O_d(\mathbb{R})$表示$d\times d$的实数空间，$\operatorname{SVD}(\cdot)$表示奇异值分解，$\mathbi{Y}'$和$\mathbi{X}'$中的单词来自$D$且行对齐。利用上式可以获得新的$\mathbi{W}$，通过$\mathbi{W}$可以归纳出新的$D$，如此迭代进行微调最后即可以得到收敛的$D$。
\parinterval 较早的无监督方法是基于GAN的方法\upcite{DBLP:conf/acl/ZhangLLS17,DBLP:conf/emnlp/ZhangLLS17,DBLP:conf/iclr/LampleCRDJ18}，这是一个很自然的想法，利用生成器产生映射然后用判别器来区别两个空间。然而研究表明GAN缺乏稳定性，容易在低资源语言对上失败\upcite{hartmann2018empirical}，因此有不少改进的工作，比如：利用{\small\bfnew{变分自编码器}}\index{变分自编码器}（Variational Autoencoders，VAEs）\index{Variational Autoencoders}来捕获更深层次的语义信息并结合对抗训练的方法\upcite{DBLP:conf/emnlp/DouZH18,DBLP:conf/naacl/MohiuddinJ19}；通过改进最近邻点的度量函数来提升性能的方法\upcite{DBLP:conf/acl/HuangQC19,DBLP:conf/emnlp/JoulinBMJG18}；利用多语言信号来提升性能的方法\upcite{DBLP:conf/emnlp/ChenC18,DBLP:conf/emnlp/TaitelbaumCG19,DBLP:journals/corr/abs-1811-01124,DBLP:conf/naacl/HeymanVVM19}；也有一些工作舍弃GAN，通过直接优化空间距离来进行单词的匹配\upcite{DBLP:conf/emnlp/HoshenW18,DBLP:conf/emnlp/XuYOW18,DBLP:conf/emnlp/Alvarez-MelisJ18,DBLP:conf/emnlp/MukherjeeYH18}。此外，也有一些工作旨在分析或提升无监督词典归纳的健壮性，例如，通过大量实验来分析无监督词典归纳任务的局限性、难点以及挑战\upcite{DBLP:conf/acl/SogaardVR18,DBLP:conf/acl/OrmazabalALSA19,DBLP:conf/emnlp/VulicGRK19,DBLP:conf/emnlp/HartmannKS18}；分析和对比目前各种无监督方法的性能\upcite{DBLP:conf/nips/HartmannKS19}；通过实验分析目前所用的数据集存在的问题\upcite{DBLP:conf/emnlp/Kementchedjhieva19}。
\parinterval 较早的无监督方法是基于GAN的方法\upcite{DBLP:conf/acl/ZhangLLS17,DBLP:conf/emnlp/ZhangLLS17,DBLP:conf/iclr/LampleCRDJ18}，这是一个很自然的想法，利用生成器产生映射然后用判别器来区别两个空间。然而研究表明GAN缺乏稳定性，容易在低资源语言对上失败\upcite{hartmann2018empirical}，因此有不少改进的工作，比如：利用{\small\bfnew{变分自编码器}}\index{变分自编码器}（Variational Autoencoders，VAEs）\index{Variational Autoencoders}来捕获更深层次的语义信息并结合对抗训练的方法\upcite{DBLP:conf/emnlp/DouZH18,DBLP:conf/naacl/MohiuddinJ19}；通过改进最近邻点的度量函数来提升性能的方法\upcite{DBLP:conf/acl/HuangQC19,DBLP:conf/emnlp/JoulinBMJG18}；利用多语言信号来提升性能的方法\upcite{DBLP:conf/emnlp/ChenC18,DBLP:conf/emnlp/TaitelbaumCG19,DBLP:journals/corr/abs-1811-01124,DBLP:conf/naacl/HeymanVVM19}；也有一些工作舍弃GAN，通过直接优化空间距离来进行单词的匹配\upcite{DBLP:conf/emnlp/HoshenW18,DBLP:conf/emnlp/XuYOW18,DBLP:conf/emnlp/Alvarez-MelisJ18,DBLP:conf/emnlp/MukherjeeYH18}。
%----------------------------------------------------------------------------------------
% NEW SUB-SUB-SECTION
......@@ -768,7 +767,16 @@
\label{sec:domain-adaptatoin-data-based-method}
\parinterval 在统计机器翻译时代，如何有效利用外部数据来改善目标领域的翻译效果已经备受关注
。其中的绝大多数思想和方法和翻译模型无关，因此这些方法也同样适用于神经机器翻译。基于数据的领域适应可以分为基于数据加权的方法、基于数据选择的方法、基于伪数据的方法和使用多领域数据。图XX展示了这几种方法的示意图。
。其中的绝大多数思想和方法和翻译模型无关，因此这些方法也同样适用于神经机器翻译。基于数据的领域适应可以分为基于数据加权的方法、基于数据选择的方法、基于伪数据的方法和使用多领域数据。图\ref{fig:16-20}展示了这几种方法的示意图。
%----------------------------------------------
\begin{figure}[h]
\centering
\input{Chapter16/Figures/figure-data-based-domain-adaptation-approach}
\caption{基于数据的领域适应方法}
\label{fig:16-20}
\end{figure}
%----------------------------------------------
%----------------------------------------------------------------------------------------
% NEW SUB-SUB-SECTION
......@@ -786,9 +794,7 @@
%----------------------------------------------------------------------------------------
\subsubsection{2. 基于伪数据的方法}
\parinterval 数据选择方法可以从源领域中选择出和目标领域相似的训练数据用于训练，但可用的数据是较为有限的。因此，另外一种思路是对现有的双语数据进行修改\upcite{DBLP:conf/acl/UtiyamaI03}（如抽取双语短语对等）或通过单语数据生成伪数据来增加数据量\upcite{DBLP:conf/wmt/BertoldiF09}。这个问题和\ref{effective-use-of-data}节所面临的场景是基本一致的，因此可以直接复用\ref{effective-use-of-data}所描述的方法。
{\color{red} 图XX：基于数据的领域适应方法，三个子图分别描述上面三个方法，找孟霞、曾信讨论}
\parinterval 数据选择方法可以从源领域中选择出和目标领域相似的训练数据用于训练，但可用的数据是较为有限的。因此，另外一种思路是对现有的双语数据进行修改\upcite{DBLP:conf/acl/UtiyamaI03}（如抽取双语短语对等）或通过单语数据生成伪数据来增加数据量\upcite{DBLP:conf/wmt/BertoldiF09}。这个问题和\ref{effective-use-of-data}小节所面临的场景是基本一致的，因此可以直接复用\ref{effective-use-of-data}小节所描述的方法。
%----------------------------------------------------------------------------------------
% NEW SUB-SUB-SECTION
......@@ -812,7 +818,7 @@
%----------------------------------------------------------------------------------------
\subsubsection{1. 多目标学习}
\parinterval 在使用多领域数据时，混合多个相差较大的领域数据进行训练会使单个领域的翻译性能下降\upcite{DBLP:conf/eacl/NegriTFBF17}。 为了解决这一问题，可以对所有训练数据的来源领域进行区分，一个比较典型的做法是在使用多领域数据训练时，在神经机器翻译模型的编码器顶部中添加一个判别器\upcite{britz2017effective}，该判别器使用源语言句子$x$的编码器表示作为输入，预测句子所属的领域标签$d$，如图\ref{fig:16-20}所示。为了使预测领域标签$d$的正确概率$\funp{P(d|\mathbi{H})}$最大（其中$\mathbi{H}$为编码器的隐藏状态），模型在训练过程中最小化如下损失函数$\funp{L}_{\rm{disc}}$：
\parinterval 在使用多领域数据时，混合多个相差较大的领域数据进行训练会使单个领域的翻译性能下降\upcite{DBLP:conf/eacl/NegriTFBF17}。 为了解决这一问题，可以对所有训练数据的来源领域进行区分，一个比较典型的做法是在使用多领域数据训练时，在神经机器翻译模型的编码器顶部中添加一个判别器\upcite{britz2017effective}，该判别器使用源语言句子$x$的编码器表示作为输入，预测句子所属的领域标签$d$，如图\ref{fig:16-21}所示。为了使预测领域标签$d$的正确概率$\funp{P(d|\mathbi{H})}$最大（其中$\mathbi{H}$为编码器的隐藏状态），模型在训练过程中最小化如下损失函数$\funp{L}_{\rm{disc}}$：
\begin{eqnarray}
\funp{L}_{\rm{disc}}& = &-\log\funp{P}(d|\mathbi{H})
......@@ -837,14 +843,14 @@
\centering
\input{Chapter16/Figures/figure-schematic-of-the-domain-discriminator}
\caption{领域判别器示意图}
\label{fig:16-20}
\label{fig:16-21}
\end{figure}
%----------------------------------------------
%----------------------------------------------------------------------------------------
% NEW SUB-SUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{2. 训练策略优化}{\red 为了前后的呼应，这里改成训练阶段领域适应，或者后面改成推断策略优化会不会更好？}
\subsubsection{2. 训练阶段的领域适应}
\parinterval 实际上，\ref{sec:domain-adaptatoin-data-based-method}节所描述的数据加权和数据选择方法本身也与模型训练相关的，例如，数据选择方法会降低训练数据的数据量。所以具体实现时，需要对训练策略进行调整。一种方法是在不同的训练轮次动态地改变训练数据子集。动态数据选择既可以使得每轮的训练数据均小于全部数据量，从而加快训练进程，又可以缓解训练数据覆盖度不足的问题，具体做法有两种：
......
Chapter17/Figures/figure-picture-translation.tex
\begin{tikzpicture}[node distance = 0]
\tikzstyle{every node}=[scale=0.9]
\tikzstyle{every node}=[scale=0.85]
\begin {scope}
\node[draw=white,scale=0.6] (input) at (0,0){\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-bank-without-attention.png}};(1.9,-1.4);
\node[anchor=south] (english1) at ([xshift=-0.4em,yshift=-3.5em]input.south) {\begin{tabular}{l}{\normalsize\bfnew{英语}}{\large{：A medium sized child}}\end{tabular}};
\node[anchor=south] (english2) at ([xshift=1.8em,yshift=-1.2em]english1.south) {\begin{tabular}{l}{\large{jumps off a dusty {\red{\underline{bank}}}.}} \end{tabular}};
\draw[decorate,decoration={brace,amplitude=4mm},very thick] ([xshift=7em]input.90) -- ([xshift=5.7em,yshift=0.5em]english2.270);
\node[anchor=west] (label1) at ([xshift=-3.5em]input.west) {\begin{tabular}{l}{\normalsize{图片：}}\end{tabular}};
\node[anchor=south] (label2) at ([yshift=-7.15em]label1.south) {\begin{tabular}{l}{\normalsize{源文：}}\end{tabular}};
\node[anchor=south] (english1) at ([xshift=-0.1em,yshift=-3.5em]input.south) {\begin{tabular}{l}{\large{A\,medium\,sized\,child\,jumps\,off}}\end{tabular}};
\node[anchor=south] (english2) at ([xshift=-3.3em,yshift=-1.2em]english1.south) {\begin{tabular}{l}{\large{a dusty {\red{\underline{bank}}}.}} \end{tabular}};
\draw[decorate,decoration={brace,amplitude=4mm},very thick] ([xshift=7em]input.90) -- ([xshift=10.4em,yshift=0.5em]english2.270);
\node[anchor=east,rectangle,thick,rounded corners,minimum width=3.5em,minimum height=2.5em,text centered,draw=black!70,fill=red!25](trans)at ([xshift=8em,yshift=5.3em]english1.east){\normalsize{翻译模型}};
\node[anchor=east,rectangle,thick,rounded corners,minimum width=3.5em,minimum height=2.5em,text centered,draw=black!70,fill=red!25](trans)at ([xshift=7.5em,yshift=5.1em]english1.east){\normalsize{翻译模型}};
\draw[->,very thick]([xshift=-1.65em]trans.west) to (trans.west);
\draw[->,very thick](trans.east) to ([xshift=1.65em]trans.east);
\node[anchor=east] (de1) at ([xshift=5.85cm,yshift=-0.1em]trans.east) {\begin{tabular}{l}{\normalsize\bfnew{汉语}}{\normalsize{：一个半大孩子从尘土飞扬}}\end{tabular}};
\node[anchor=south] (de2) at ([xshift=0em,yshift=-1.5em]de1.south) {\begin{tabular}{l}{\normalsize{的{\red{\underline{河床}}}上跳下来。}} \end{tabular}};
\draw[->,very thick]([xshift=-1.4em]trans.west) to (trans.west);
\draw[->,very thick](trans.east) to ([xshift=1.4em]trans.east);
\node[anchor=east] (de1) at ([xshift=4.9cm,yshift=-0.1em]trans.east) {\begin{tabular}{l}{\normalsize{译文：}}{\normalsize{一个半大孩子从尘土}}\end{tabular}};
\node[anchor=south] (de2) at ([xshift=1.65em,yshift=-1.5em]de1.south) {\begin{tabular}{l}{\normalsize{飞扬的{\red{\underline{河床}}}上跳下来。}} \end{tabular}};
\end {scope}
\end{tikzpicture}
\ No newline at end of file
Chapter17/chapter17.tex
......@@ -495,7 +495,7 @@
\parinterval
区别于篇章级统计机器翻译，篇章级神经机器翻译不需要针对某一具体的上下文现象构造相应的特征，而是通过翻译模型本身从上下文句子中抽取和融合的上下文信息。通常情况下，篇章级机器翻译可以采用局部建模的手段将前一句或者周围几句作为上下文送入模型。针对需要长距离上下文的情况，也可以使用全局建模的手段直接从篇章中所有句子中提取上下文信息。近几年多数研究工作都在探索更有效的局部建模或全局建模方法，主要包括改进输入\upcite{DBLP:conf/discomt/TiedemannS17,DBLP:conf/naacl/BawdenSBH18,DBLP:conf/wmt/GonzalesMS17,DBLP:journals/corr/abs-1910-07481}、多编码器结构\upcite{DBLP:journals/corr/JeanLFC17,DBLP:journals/corr/abs-1805-10163,DBLP:conf/emnlp/ZhangLSZXZL18}、层次结构\upcite{DBLP:conf/naacl/MarufMH19,DBLP:conf/acl/HaffariM18,DBLP:conf/emnlp/YangZMGFZ19,DBLP:conf/ijcai/ZhengYHCB20}以及基于缓存的方法\upcite{DBLP:conf/coling/KuangXLZ18,DBLP:journals/tacl/TuLSZ18}四类。
\parinterval 此外，篇章级机器翻译面临的另外一个挑战是数据稀缺。篇章级机器翻译所需要的双语数据需要保留篇章边界，数量相比于句子级双语数据要少很多。除了在之前提到的端到端方法中采用预训练或者参数共享的手段（见{\chaptersixteen}），也可以采用新的建模手段来缓解数据稀缺问题。比如，在句子级翻译模型的推断过程中，通过篇章级语言模型在目标端引入上下文信息\upcite{DBLP:conf/discomt/GarciaCE19,DBLP:journals/tacl/YuSSLKBD20,DBLP:journals/corr/abs-2010-12827}，或者对句子级的翻译结果进行修正\upcite{DBLP:conf/aaai/XiongH0W19,DBLP:conf/acl/VoitaST19,DBLP:conf/emnlp/VoitaST19}（{\color{red} 如何修正？用什么修正？修正什么？感觉这句话没有信息量}）。
\parinterval 此外，篇章级机器翻译面临的另外一个挑战是数据稀缺。篇章级机器翻译所需要的双语数据需要保留篇章边界，数量相比于句子级双语数据要少很多。除了在之前提到的端到端方法中采用预训练或者参数共享的手段（见{\chaptersixteen}），也可以采用新的建模手段来缓解数据稀缺问题。这类方法通常将篇章级翻译流程进行分离：先训练一个句子级的翻译模型，再通过一些额外的模块来引入上下文信息，从而达到“充分利用句子级的双语数据，提升模型性能”的目的。比如，在句子级翻译模型的推断过程中，通过在目标端结合篇章级语言模型引入上下文信息\upcite{DBLP:conf/discomt/GarciaCE19,DBLP:journals/tacl/YuSSLKBD20,DBLP:journals/corr/abs-2010-12827}，或者基于句子级的翻译结果，使用两阶段解码等手段引入上下文信息，进而对句子级翻译结果进行修正\upcite{DBLP:conf/aaai/XiongH0W19,DBLP:conf/acl/VoitaST19,DBLP:conf/emnlp/VoitaST19}。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -505,7 +505,7 @@
\parinterval BLEU等自动评价指标能够在一定程度上反映译文的整体质量，但是并不能有效地评估篇章级翻译模型的性能。这是由于传统测试数据中出现篇章上下文现象的比例相对较少，并且$n$-gram的匹配很难检测到一些具体的语言现象，这使得研究人员很难通过BLEU得分来判断篇章级翻译模型的效果。
\parinterval 为此，研究人员总结了机器翻译任务中存在的上下文现象，并基于此设计了相应的自动评价指标。比如针对篇章中代词的翻译问题，首先借助词对齐工具确定源语言中的代词在译文和参考答案中的对应位置，然后通过计算{\color{red} 谁的？}准确率和召回率等指标对代词翻译质量进行评价\upcite{DBLP:conf/iwslt/HardmeierF10,DBLP:conf/discomt/WerlenP17}。针对篇章中的词汇衔接，使用{\small\sffamily\bfseries{词汇链}}\index{词汇链}（Lexical Chain\index{Lexical Chain}）\footnote{词汇链指篇章中语义相关的词所构成的序列。}等来获取能够反映词汇衔接质量的分数，然后通过加权的方式与常规的BLEU或METEOR等指标结合在一起\upcite{DBLP:conf/emnlp/WongK12,DBLP:conf/discomt/GongZZ15}。针对篇章中的连接词，使用候选词典和词对齐工具对源语中连接词的正确翻译结果进行计数，计算其准确率\upcite{DBLP:conf/cicling/HajlaouiP13}。
\parinterval 为此，研究人员总结了机器翻译任务中存在的上下文现象，并基于此设计了相应的自动评价指标。比如针对篇章中代词的翻译问题，首先借助词对齐工具确定源语言中的代词在译文和参考答案中的对应位置，然后通过计算译文中代词的准确率和召回率等指标对代词翻译质量进行评价\upcite{DBLP:conf/iwslt/HardmeierF10,DBLP:conf/discomt/WerlenP17}。针对篇章中的词汇衔接，使用{\small\sffamily\bfseries{词汇链}}\index{词汇链}（Lexical Chain\index{Lexical Chain}）\footnote{词汇链指篇章中语义相关的词所构成的序列。}等来获取能够反映词汇衔接质量的分数，然后通过加权的方式与常规的BLEU或METEOR等指标结合在一起\upcite{DBLP:conf/emnlp/WongK12,DBLP:conf/discomt/GongZZ15}。针对篇章中的连接词，使用候选词典和词对齐工具对源语中连接词的正确翻译结果进行计数，计算其准确率\upcite{DBLP:conf/cicling/HajlaouiP13}。
\parinterval 除了直接对译文打分，也有一些工作针对特有的上下文现象手工构造了相应的测试套件用于评价翻译质量。测试套件中每一个测试样例都包含一个正确翻译的结果，以及多个错误结果，一个理想的翻译模型应该对正确的翻译结果评价最高，排名在所有错误结果之上,此时就可以根据模型是否能挑选出正确翻译结果来评估其性能。这种方法可以很好地衡量翻译模型在某一特定上下文现象上的处理能力，比如词义消歧\upcite{DBLP:conf/wmt/RiosMS18}、代词翻译\upcite{DBLP:conf/naacl/BawdenSBH18,DBLP:conf/wmt/MullerRVS18}和一些衔接问题\upcite{DBLP:conf/acl/VoitaST19}等。但是该方法也存在使用范围受限于测试集的语种和规模的缺点，因此扩展性较差。
......@@ -572,7 +572,7 @@
\mathbi{d}&=&\textrm{Attention}(\mathbi{h},\mathbi{h}^{\textrm pre},\mathbi{h}^{\textrm pre})
\label{eq:17-3-3}
\end{eqnarray}
其中，$\mathbi{h}$作为Query（查询），$\mathbi{h}^{\textrm pre}$作为Key（键）和Value（值）。然后通过门控机制将待翻译句子中每个位置的编码表示和上下文中对应位置（{\color{red} 什么叫上下文中对应位置？}）的信息进行融合，具体方式如下：
其中，$\mathbi{h}$作为Query（查询），$\mathbi{h}^{\textrm pre}$作为Key（键）和Value（值）。然后通过门控机制将待翻译句子中每个位置的编码表示和该位置对应的上下文信息进行融合，具体方式如下：
\begin{eqnarray}
\widetilde{\mathbi{h}_{t}}&=&\lambda_{t}\mathbi{h}_{t}+(1-\lambda_{t})\mathbi{d}_{t}
\label{eq:17-3-4}\\
......@@ -631,9 +631,9 @@
\subsubsection{4. 基于缓存的方法}
\parinterval 除了以上提到的建模方法，还有一类基于缓存的方法\upcite{DBLP:journals/tacl/TuLSZ18,DBLP:conf/coling/KuangXLZ18}。这类方法最大的特点在于将篇章翻译看作一个连续的过程（{\color{red} 如何理解连续的过程？}），然后在这个过程中通过一个额外的缓存来记录一些相关信息，最后在每个句子解码的过程中使用这个缓存来提供上下文信息。图\ref{fig:17-20}描述了一种基于缓存的篇章级翻译模型结构\upcite{DBLP:journals/tacl/TuLSZ18}。 在这里，翻译模型基于循环神经网络（见{\chapterten}），但是这种方法同样适用于包括Transformer在内的其他神经机器翻译模型。
\parinterval 除了以上提到的建模方法，还有一类基于缓存的方法\upcite{DBLP:journals/tacl/TuLSZ18,DBLP:conf/coling/KuangXLZ18}。这类方法最大的特点在于将篇章翻译看作一个连续的过程，即依次翻译篇章中的每一个句子，该过程中通过一个额外的缓存来记录一些相关信息，且在每个句子的推断过程中都使用这个缓存来提供上下文信息。图\ref{fig:17-20}描述了一种基于缓存的篇章级翻译模型结构\upcite{DBLP:journals/tacl/TuLSZ18}。 在这里，翻译模型基于循环神经网络（见{\chapterten}），但是这种方法同样适用于包括Transformer在内的其他神经机器翻译模型。
\parinterval 模型中篇章上下文的建模依赖于缓存的读和写操作。缓存的写操作指的是：按照一定规则将翻译历史中一些译文单词对应的上下文向量$\mathbi{C}_r$作为键，而将其解码器端的隐藏状态$\mathbi{s}_r$ 对应的值写入到缓存中（{\color{red} 为啥变量下标用$r$}）。而缓存的读操作是指将待翻译句子中第$t$个单词的上下文向量$\mathbi{C}_t$作为查询，与缓存中的所有键分别进行匹配，并根据其匹配程度进行带权相加，最后得到当前待翻译句子的篇章上下文信息 $\mathbi{d}$。该方法中单词的解码器端隐藏状态$\mathbi{s}_t$与对应位置的上下文信息$\mathbi{d}_t$的融合也是基于门控机制。事实上，由于该方法中缓存空间是有限的，其内容的更新也存在一定的规则：在当前句子的翻译结束后，如果单词$y_t$的对应信息未曾写入缓存，则写入其中的空槽或者替换最久未使用的键值对；如果$y_t$ 已作为翻译历史存在于缓存中，则将对应的键值对按照以下规则进行更新:
\parinterval 模型中篇章上下文的建模依赖于缓存的读和写操作。缓存的写操作指的是：按照一定规则将翻译历史中一些译文单词对应的上下文向量和其解码器端的隐藏状态分别作为键和值写入到缓存中。而缓存的读操作是指将待翻译句子中第$t$个单词的上下文向量$\mathbi{C}_t$作为查询，与缓存中的所有键分别进行匹配，并根据其匹配程度进行带权相加，最后得到当前待翻译句子的篇章上下文信息 $\mathbi{d}$。该方法中单词的解码器端隐藏状态$\mathbi{s}_t$与对应位置的上下文信息$\mathbi{d}_t$的融合也是基于门控机制。事实上，由于该方法中缓存空间是有限的，其内容的更新也存在一定的规则：在当前句子的翻译结束后，如果单词$y_t$的对应信息未曾写入缓存，则写入其中的空槽或者替换最久未使用的键值对；如果$y_t$ 已作为翻译历史存在于缓存中，则将对应的键值对按照以下规则进行更新:
\begin{eqnarray}
\mathbi{k}_{i}&=&\frac{\mathbi{k}_{i}+\mathbi{c}_{t}}{2}
\label{eq:17-3-10}\\
......
bibliography.bib
......@@ -6618,6 +6618,108 @@ author = {Yoshua Bengio and
publisher = {{IEEE} International Conference on Computer Vision},
year = {2017}
}
@inproceedings{DBLP:journals/corr/SuGMRUVWY16a,
author = {Pei{-}Hao Su and
Milica Gasic and
Nikola Mrksic and
Lina Maria Rojas{-}Barahona and
Stefan Ultes and
David Vandyke and
Tsung{-}Hsien Wen and
Steve J. Young},
title = {Continuously Learning Neural Dialogue Management},
publisher = {CoRR},
volume = {abs/1606.02689},
year = {2016}
}
@inproceedings{DBLP:journals/corr/abs-1709-02349,
author = {Iulian Vlad Serban and
Chinnadhurai Sankar and
Mathieu Germain and
Saizheng Zhang and
Zhouhan Lin and
Sandeep Subramanian and
Taesup Kim and
Michael Pieper and
Sarath Chandar and
Nan Rosemary Ke and
Sai Mudumba and
Alexandre de Br{\'{e}}bisson and
Jose Sotelo and
Dendi Suhubdy and
Vincent Michalski and
Alexandre Nguyen and
Joelle Pineau and
Yoshua Bengio},
title = {A Deep Reinforcement Learning Chatbot},
publisher = {CoRR},
volume = {abs/1709.02349},
year = {2017}
}
@inproceedings{DBLP:conf/emnlp/WuTQLL18,
author = {Lijun Wu and
Fei Tian and
Tao Qin and
Jianhuang Lai and
Tie{-}Yan Liu},
title = {A Study of Reinforcement Learning for Neural Machine Translation},
pages = {3612--3621},
publisher = {Annual Meeting of the Association for Computational Linguistics},
year = {2018}
}
@inproceedings{DBLP:journals/jmlr/RossGB11,
author = {St{\'{e}}phane Ross and
Geoffrey J. Gordon and
Drew Bagnell},
title = {A Reduction of Imitation Learning and Structured Prediction to No-Regret
Online Learning},
publisher = {International Conference on Artificial Intelligence and Statistics},
series = {{JMLR} Proceedings},
volume = {15},
pages = {627--635},
publisher = {JMLR.org},
year = {2011}
}
@inproceedings{DBLP:conf/aaai/VenkatramanHB15,
author = {Arun Venkatraman and
Martial Hebert and
J. Andrew Bagnell},
title = {Improving Multi-Step Prediction of Learned Time Series Models},
publisher = {AAAI Conference on Artificial Intelligence},
pages = {3024--3030},
year = {2015}
}
@inproceedings{DBLP:conf/iclr/LiuCLS17,
author = {Yanpei Liu and
Xinyun Chen and
Chang Liu and
Dawn Song},
title = {Delving into Transferable Adversarial Examples and Black-box Attacks},
publisher = {International Conference on Learning Representations},
year = {2017}
}
@inproceedings{DBLP:journals/tnn/YuanHZL19,
author = {Xiaoyong Yuan and
Pan He and
Qile Zhu and
Xiaolin Li},
title = {Adversarial Examples: Attacks and Defenses for Deep Learning},
publisher = {IEEE Transactions on Neural Networks and Learning Systems},
volume = {30},
number = {9},
pages = {2805--2824},
year = {2019}
}
@inproceedings{DBLP:conf/infocom/YuanHL020,
author = {Xiaoyong Yuan and
Pan He and
Xiaolin Li and
Dapeng Wu},
title = {Adaptive Adversarial Attack on Scene Text Recognition},
pages = {358--363},
publisher = {IEEE Conference on Computer Communications},
year = {2020}
}
%%%%% chapter 13------------------------------------------------------
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论