Skip to content

M
mtbookv2
Commit cf885060 by 孟霞
Options

合并分支 'caorunzhe' 到 'mengxia' 

Caorunzhe

查看合并请求 !725
parents cdd3d463 64600e61
正在显示 包含 837 行增加 和 780 行删除
Chapter10/Figures/figure-calculation-process-of-context-vector-c.tex
...@@ -36,7 +36,7 @@ ...@@ -36,7 +36,7 @@
\node [anchor=north] (enc2) at (h2.south) {\scriptsize{编码器输出}}; \node [anchor=north] (enc2) at (h2.south) {\scriptsize{编码器输出}};
\node [anchor=north] (enc22) at ([yshift=0.5em]enc2.south) {\scriptsize{(位置$2$)}}; \node [anchor=north] (enc22) at ([yshift=0.5em]enc2.south) {\scriptsize{(位置$2$)}};
\node [anchor=north] (enc4) at (h4.south) {\scriptsize{编码器输出}}; \node [anchor=north] (enc4) at (h4.south) {\scriptsize{编码器输出}};
\node [anchor=north] (enc42) at ([yshift=0.5em]enc4.south) {\scriptsize{(位置$4$)}}; \node [anchor=north] (enc42) at ([yshift=0.5em]enc4.south) {\scriptsize{(位置$m$)}};
{ {
\node [anchor=west] (math1) at ([xshift=5em,yshift=1em]th2.east) {$\mathbi{C}_j = \sum_{i} \alpha_{i,j} \mathbi{h}_i $ \ \ \ \ }; \node [anchor=west] (math1) at ([xshift=5em,yshift=1em]th2.east) {$\mathbi{C}_j = \sum_{i} \alpha_{i,j} \mathbi{h}_i $ \ \ \ \ };
......
Chapter10/Figures/figure-example-of-context-vector-calculation-process.tex
...@@ -38,14 +38,14 @@ ...@@ -38,14 +38,14 @@
\node[elementnode,minimum size=0.6*\hnode*\c,inner sep=0.1pt,fill=blue] (a\i\j) at (0.5*\hnode*\i-5.4*0.5*\hnode,0.5*\hnode*\j-1.05*\hnode) {}; \node[elementnode,minimum size=0.6*\hnode*\c,inner sep=0.1pt,fill=blue] (a\i\j) at (0.5*\hnode*\i-5.4*0.5*\hnode,0.5*\hnode*\j-1.05*\hnode) {};
%attention score labels %attention score labels
\node[align=center] (l17) at (a17) {\scriptsize{{\color{white} .4}}}; \node[align=center,scale=0.8] (l17) at (a17) {\scriptsize{{\color{white} 0.4}}};
\node[align=center] (l26) at (a06) {\scriptsize{{\color{white} .3}}}; \node[align=center,scale=0.7] (l26) at (a06) {\tiny{{\color{white} 0.3}}};
\node[align=center] (l26) at (a16) {\scriptsize{{\color{white} .4}}}; \node[align=center,scale=0.8] (l26) at (a16) {\scriptsize{{\color{white} 0.4}}};
\node[align=center] (l17) at (a35) {\scriptsize{{\color{white} .3}}}; \node[align=center,scale=0.7] (l17) at (a35) {\tiny{{\color{white} 0.3}}};
\node[align=center] (l17) at (a34) {\tiny{{\color{white} .3}}}; \node[align=center,scale=0.7] (l17) at (a34) {\tiny{{\color{white} 0.3}}};
\node[align=center] (l17) at (a23) {\small{{\color{white} .8}}}; \node[align=center] (l17) at (a23) {\small{{\color{white} 0.8}}};
\node[align=center] (l17) at (a41) {\small{{\color{white} .8}}}; \node[align=center] (l17) at (a41) {\small{{\color{white} 0.8}}};
\node[align=center] (l17) at (a50) {\small{{\color{white} .7}}}; \node[align=center,scale=0.9] (l17) at (a50) {\small{{\color{white} 0.7}}};
% source % source
\node[srcnode] (src1) at (-5.4*0.5*\hnode,-1.05*\hnode+7.5*0.5*\hnode) {\scriptsize{Have}}; \node[srcnode] (src1) at (-5.4*0.5*\hnode,-1.05*\hnode+7.5*0.5*\hnode) {\scriptsize{Have}};
......
Chapter10/Figures/figure-matrix-representation-of-attention-weights-between-chinese-english-sentence-pairs.tex
...@@ -30,14 +30,14 @@ ...@@ -30,14 +30,14 @@
\node[elementnode,minimum size=0.6*1.2cm*\c,inner sep=0.1pt,fill=blue] (a\i\j) at (0.5*1.2cm*\i-5.4*0.5*1.2cm,0.5*1.2cm*\j-1.05*1.2cm) {}; \node[elementnode,minimum size=0.6*1.2cm*\c,inner sep=0.1pt,fill=blue] (a\i\j) at (0.5*1.2cm*\i-5.4*0.5*1.2cm,0.5*1.2cm*\j-1.05*1.2cm) {};
%attention score labels %attention score labels
\node[align=center] (l17) at (a17) {\scriptsize{{\color{white} .4}}}; \node[align=center,scale=0.8] (l17) at (a17) {\scriptsize{{\color{white} 0.4}}};
\node[align=center] (l26) at (a06) {\scriptsize{{\color{white} .3}}}; \node[align=center,scale=0.8] (l26) at (a06) {\scriptsize{{\color{white} 0.3}}};
\node[align=center] (l26) at (a16) {\scriptsize{{\color{white} .4}}}; \node[align=center,scale=0.8] (l26) at (a16) {\scriptsize{{\color{white} 0.4}}};
\node[align=center] (l17) at (a35) {\scriptsize{{\color{white} .3}}}; \node[align=center,scale=0.8] (l17) at (a35) {\scriptsize{{\color{white} 0.3}}};
\node[align=center] (l17) at (a34) {\tiny{{\color{white} .3}}}; \node[align=center,scale=0.8] (l17) at (a34) {\scriptsize{{\color{white} 0.3}}};
\node[align=center] (l17) at (a23) {\small{{\color{white} .8}}}; \node[align=center] (l17) at (a23) {\small{{\color{white} 0.8}}};
\node[align=center] (l17) at (a41) {\small{{\color{white} .8}}}; \node[align=center] (l17) at (a41) {\small{{\color{white} 0.8}}};
\node[align=center] (l17) at (a50) {\small{{\color{white} .7}}}; \node[align=center] (l17) at (a50) {\small{{\color{white} 0.7}}};
% source % source
\node[srcnode] (src1) at (-5.4*0.5*1.2cm,-1.05*1.2cm+7.5*0.5*1.2cm) {\scriptsize{Have}}; \node[srcnode] (src1) at (-5.4*0.5*1.2cm,-1.05*1.2cm+7.5*0.5*1.2cm) {\scriptsize{Have}};
......
Chapter10/chapter10.tex
...@@ -191,7 +191,7 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -191,7 +191,7 @@ NMT & 21.7 & 18.7 & -13.7 \\
\end{table} \end{table}
%---------------------------------------------- %----------------------------------------------
\parinterval 在最近两年，神经机器翻译的发展更加迅速，新的模型及方法层出不穷。表\ref{tab:10-3}给出了到2020年为止一些主流的神经机器翻译模型的对比。可以看到，相比2017年，2018-2020年中机器翻译仍然有明显的进步。 \parinterval 在最近两年，神经机器翻译的发展更加迅速，新的模型及方法层出不穷。表\ref{tab:10-3}给出了到2020年为止，一些主流的神经机器翻译模型在WMT14英德数据集上的表现。可以看到，相比2017年，2018-2020年中机器翻译仍然有明显的进步。
\vspace{0.5em}%全局布局使用 \vspace{0.5em}%全局布局使用
%---------------------------------------------- %----------------------------------------------
...@@ -439,13 +439,13 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -439,13 +439,13 @@ NMT & 21.7 & 18.7 & -13.7 \\
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 从数学模型上看，神经机器翻译模型与统计机器翻译的目标是一样的：在给定源语言句子$\seq{x}$的情况下，找出翻译概率最大的目标语言译文$\hat{\seq{y}}$，其计算如公式\eqref{eq:10-1}所示: \parinterval 从数学模型上看，神经机器翻译模型与统计机器翻译的目标是一样的：在给定源语言句子$\seq{x}$的情况下，找出翻译概率最大的目标语言译文$\hat{\seq{y}}$，其计算如下式:
\begin{eqnarray} \begin{eqnarray}
\hat{\seq{{y}}} &=& \argmax_{\seq{{y}}} \funp{P} (\seq{{y}} | \seq{{x}}) \hat{\seq{{y}}} &=& \argmax_{\seq{{y}}} \funp{P} (\seq{{y}} | \seq{{x}})
\label{eq:10-1} \label{eq:10-1}
\end{eqnarray} \end{eqnarray}
\noindent 这里，用$\seq{{x}}=\{ x_1,x_2,..., x_m \}$表示输入的源语言单词序列，$\seq{{y}}=\{ y_1,y_2,..., y_n \}$ 表示生成的目标语言单词序列。由于神经机器翻译在生成译文时采用的是自左向右逐词生成的方式，并在翻译每个单词时考虑已经生成的翻译结果，因此对$ \funp{P} (\seq{{y}} | \seq{{x}})$的求解可以转换为公式\eqref{eq:10-2}所示过程： \noindent 这里，用$\seq{{x}}=\{ x_1,x_2,..., x_m \}$表示输入的源语言单词序列，$\seq{{y}}=\{ y_1,y_2,..., y_n \}$ 表示生成的目标语言单词序列。由于神经机器翻译在生成译文时采用的是自左向右逐词生成的方式，并在翻译每个单词时考虑已经生成的翻译结果，因此对$ \funp{P} (\seq{{y}} | \seq{{x}})$的求解可以转换为下式：
\begin{eqnarray} \begin{eqnarray}
\funp{P} (\seq{{y}} | \seq{{x}}) &=& \prod_{j=1}^{n} \funp{P} ( y_j | \seq{{y}}_{<j }, \seq{{x}} ) \funp{P} (\seq{{y}} | \seq{{x}}) &=& \prod_{j=1}^{n} \funp{P} ( y_j | \seq{{y}}_{<j }, \seq{{x}} )
\label{eq:10-2} \label{eq:10-2}
...@@ -463,12 +463,12 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -463,12 +463,12 @@ NMT & 21.7 & 18.7 & -13.7 \\
\vspace{0.5em} \vspace{0.5em}
\item 如何在词嵌入的基础上获取整个序列的表示，即句子的表示学习。可以把词嵌入的序列作为循环神经网络的输入，循环神经网络最后一个时刻的输出向量便是整个句子的表示结果。如图\ref{fig:10-10}中，编码器最后一个循环单元的输出$\mathbi{h}_m$被看作是一种包含了源语言句子信息的表示结果，记为$\mathbi{C}$。 \item 如何在词嵌入的基础上获取整个序列的表示，即句子的表示学习。可以把词嵌入的序列作为循环神经网络的输入，循环神经网络最后一个时刻的输出向量便是整个句子的表示结果。如图\ref{fig:10-10}中，编码器最后一个循环单元的输出$\mathbi{h}_m$被看作是一种包含了源语言句子信息的表示结果，记为$\mathbi{C}$。
\vspace{0.5em} \vspace{0.5em}
\item 如何得到每个目标语言单词的概率，即译文单词的{\small\sffamily\bfseries{生成}}\index{生成}（Generation）\index{Generation}。与神经语言模型一样，可以用一个Softmax输出层来获取当前时刻所有单词的分布，即利用Softmax 函数计算目标语言词表中每个单词的概率。令目标语言序列$j$时刻的循环神经网络的输出向量（或状态）为$\mathbi{s}_j$。根据循环神经网络的性质，$ y_j$ 的生成只依赖前一个状态$\mathbi{s}_{j-1}$和当前时刻的输入（即词嵌入$\textrm{e}_y (y_{j-1})$）。同时考虑源语言信息$\mathbi{C}$，$\funp{P}(y_j | \seq{{y}}_{<j},\seq{{x}})$可以被重新定义为公式\eqref{eq:10-3}： \item 如何得到每个目标语言单词的概率，即译文单词的{\small\sffamily\bfseries{生成}}\index{生成}（Generation）\index{Generation}。与神经语言模型一样，可以用一个Softmax输出层来获取当前时刻所有单词的分布，即利用Softmax 函数计算目标语言词表中每个单词的概率。令目标语言序列$j$时刻的循环神经网络的输出向量（或状态）为$\mathbi{s}_j$。根据循环神经网络的性质，$ y_j$ 的生成只依赖前一个状态$\mathbi{s}_{j-1}$和当前时刻的输入（即词嵌入$\textrm{e}_y (y_{j-1})$）。同时考虑源语言信息$\mathbi{C}$，$\funp{P}(y_j | \seq{{y}}_{<j},\seq{{x}})$可以被重新定义为：
\begin{eqnarray} \begin{eqnarray}
\funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}}) &=& \funp{P} ( {y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}} ) \funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}}) &=& \funp{P} ( {y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}} )
\label{eq:10-3} \label{eq:10-3}
\end{eqnarray} \end{eqnarray}
$\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softmax的输入是循环神经网络$j$时刻的输出。在具体实现时，$\mathbi{C}$可以被简单地作为第一个时刻循环单元的输入，即，当$j=1$ 时，解码器的循环神经网络会读入编码器最后一个隐层状态$ \mathbi{h}_m$（也就是$\mathbi{C}$），而其他时刻的隐层状态不直接与$\mathbi{C}$相关。最终，$\funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}})$ 被表示为公式\eqref{eq:10-4}： $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softmax的输入是循环神经网络$j$时刻的输出。在具体实现时，$\mathbi{C}$可以被简单地作为第一个时刻循环单元的输入，即，当$j=1$ 时，解码器的循环神经网络会读入编码器最后一个隐层状态$ \mathbi{h}_m$（也就是$\mathbi{C}$），而其他时刻的隐层状态不直接与$\mathbi{C}$相关。最终，$\funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}})$ 被表示为：
\begin{eqnarray} \begin{eqnarray}
\funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}}) &=& \funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}}) &=&
\left \{ \begin{array}{ll} \left \{ \begin{array}{ll}
...@@ -490,7 +490,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm ...@@ -490,7 +490,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
%---------------------------------------------- %----------------------------------------------
\parinterval 输入层（词嵌入）和输出层（Softmax）的内容已在{\chapternine}进行了介绍，因此这里的核心内容是设计循环神经网络结构，即设计循环单元的结构。至今，研究人员已经提出了很多优秀的循环单元结构。其中循环神经网络（RNN） \parinterval 输入层（词嵌入）和输出层（Softmax）的内容已在{\chapternine}进行了介绍，因此这里的核心内容是设计循环神经网络结构，即设计循环单元的结构。至今，研究人员已经提出了很多优秀的循环单元结构。其中循环神经网络（RNN）
是最原始的循环单元结构。在RNN中，对于序列$\seq{{x}}=\{ \mathbi{x}_1, \mathbi{x}_2,...,\mathbi{x}_m \}$，每个时刻$t$都对应一个循环单元，它的输出是一个向量$\mathbi{h}_t$，可以被描述为公式\eqref{eq:10-5}： 是最原始的循环单元结构。在RNN中，对于序列$\seq{{x}}=\{ \mathbi{x}_1, \mathbi{x}_2,...,\mathbi{x}_m \}$，每个时刻$t$都对应一个循环单元，它的输出是一个向量$\mathbi{h}_t$，可以被描述为：
\begin{eqnarray} \begin{eqnarray}
\mathbi{h}_t &=& f(\mathbi{x}_t \mathbi{U}+\mathbi{h}_{t-1} \mathbi{W}+\mathbi{b}) \mathbi{h}_t &=& f(\mathbi{x}_t \mathbi{U}+\mathbi{h}_{t-1} \mathbi{W}+\mathbi{b})
\label{eq:10-5} \label{eq:10-5}
...@@ -527,7 +527,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm ...@@ -527,7 +527,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item {\small\sffamily\bfseries{遗忘}}\index{遗忘}。顾名思义，遗忘的目的是忘记一些历史，在LSTM中通过遗忘门实现，其结构如图\ref{fig:10-11}(a)所示。$\mathbi{x}_{t}$表示时刻$t$的输入向量，$\mathbi{h}_{t-1}$是时刻$t-1$的循环单元的输出，$\mathbi{x}_{t}$和$\mathbi{h}_{t-1}$都作为$t$时刻循环单元的输入。$\sigma$将对$\mathbi{x}_{t}$和$\mathbi{h}_{t-1}$进行筛选，以决定遗忘的信息，其计算如公式\eqref{eq:10-6}所示： \item {\small\sffamily\bfseries{遗忘}}\index{遗忘}。顾名思义，遗忘的目的是忘记一些历史，在LSTM中通过遗忘门实现，其结构如图\ref{fig:10-11}(a)所示。$\mathbi{x}_{t}$表示时刻$t$的输入向量，$\mathbi{h}_{t-1}$是时刻$t-1$的循环单元的输出，$\mathbi{x}_{t}$和$\mathbi{h}_{t-1}$都作为$t$时刻循环单元的输入。$\sigma$将对$\mathbi{x}_{t}$和$\mathbi{h}_{t-1}$进行筛选，以决定遗忘的信息，其计算如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{f}_t &=& \sigma(\mathbi{W}_f [\mathbi{h}_{t-1},\mathbi{x}_{t}] + \mathbi{b}_f ) \mathbi{f}_t &=& \sigma(\mathbi{W}_f [\mathbi{h}_{t-1},\mathbi{x}_{t}] + \mathbi{b}_f )
\label{eq:10-6} \label{eq:10-6}
...@@ -556,7 +556,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm ...@@ -556,7 +556,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
\end{itemize} \end{itemize}
\parinterval LSTM的完整结构如图\ref{fig:10-12}所示，模型的参数包括：参数矩阵$\mathbi{W}_f$、$\mathbi{W}_i$ 、$\mathbi{W}_c$、\\$\mathbi{W}_o$和偏置$\mathbi{b}_f$、$\mathbi{b}_i$、$\mathbi{b}_c$、$\mathbi{b}_o$。可以看出，$\mathbi{h}_t$是由$\mathbi{c}_{t-1}$、$\mathbi{h}_{t-1}$与$\mathbi{x}_t$共同决定的。此外，上述公式中激活函数的选择是根据函数各自的特点决定的。 \parinterval LSTM的完整结构如图\ref{fig:10-12}所示，模型的参数包括：参数矩阵$\mathbi{W}_f$、$\mathbi{W}_i$ 、$\mathbi{W}_c$、\\$\mathbi{W}_o$和偏置$\mathbi{b}_f$、$\mathbi{b}_i$、$\mathbi{b}_c$、$\mathbi{b}_o$。可以看出，$\mathbi{h}_t$是由$\mathbi{c}_{t-1}$、$\mathbi{h}_{t-1}$与$\mathbi{x}_t$共同决定的。此外，本节公式中激活函数的选择是根据函数各自的特点决定的。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -592,13 +592,13 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm ...@@ -592,13 +592,13 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
\mathbi{u}_t & = & \sigma (\mathbi{W}_u [\mathbi{h}_{t-1},\mathbi{x}_{t}]) \label{eq:10-13} \mathbi{u}_t & = & \sigma (\mathbi{W}_u [\mathbi{h}_{t-1},\mathbi{x}_{t}]) \label{eq:10-13}
\end{eqnarray} \end{eqnarray}
\parinterval 当完成了重置门和更新门计算后，就需要更新当前隐藏状态，如图\ref{fig:10-13}(c)所示。在计算得到了重置门的权重$\mathbi{r}_t$后，使用其对前一时刻的状态$\mathbi{h}_{t-1}$进行重置($\mathbi{r}_t \cdot \mathbi{h}_{t-1}$)，将重置后的结果与$\mathbi{x}_t$拼接，通过Tanh激活函数将数据变换到[-1,1]范围内，具体计算如公式\eqref{eq:10-14}： \parinterval 当完成了重置门和更新门计算后，就需要更新当前隐藏状态，如图\ref{fig:10-13}(c)所示。在计算得到了重置门的权重$\mathbi{r}_t$后，使用其对前一时刻的状态$\mathbi{h}_{t-1}$进行重置($\mathbi{r}_t \cdot \mathbi{h}_{t-1}$)，将重置后的结果与$\mathbi{x}_t$拼接，通过Tanh激活函数将数据变换到[-1,1]范围内，具体计算为：
\begin{eqnarray} \begin{eqnarray}
\hat{\mathbi{h}}_t &=& \textrm{Tanh} (\mathbi{W}_h [\mathbi{r}_t \cdot \mathbi{h}_{t-1},\mathbi{x}_{t}]) \hat{\mathbi{h}}_t &=& \textrm{Tanh} (\mathbi{W}_h [\mathbi{r}_t \cdot \mathbi{h}_{t-1},\mathbi{x}_{t}])
\label{eq:10-14} \label{eq:10-14}
\end{eqnarray} \end{eqnarray}
\parinterval $\hat{\mathbi{h}}_t$在包含了输入信息$\mathbi{x}_t$的同时，引入了$\mathbi{h}_{t-1}$的信息，可以理解为，记忆了当前时刻的状态。下一步是计算更新后的隐藏状态也就是更新记忆，如公式\eqref{eq:10-15}所示： \parinterval $\hat{\mathbi{h}}_t$在包含了输入信息$\mathbi{x}_t$的同时，引入了$\mathbi{h}_{t-1}$的信息，可以理解为，记忆了当前时刻的状态。下一步是计算更新后的隐藏状态也就是更新记忆，如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{h}_t &=& (1-\mathbi{u}_t) \cdot \mathbi{h}_{t-1} +\mathbi{u}_t \cdot \hat{\mathbi{h}}_t \mathbi{h}_t &=& (1-\mathbi{u}_t) \cdot \mathbi{h}_{t-1} +\mathbi{u}_t \cdot \hat{\mathbi{h}}_t
\label{eq:10-15} \label{eq:10-15}
...@@ -614,7 +614,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm ...@@ -614,7 +614,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
\subsection{双向模型} \subsection{双向模型}
\parinterval 前面提到的循环神经网络都是自左向右运行的，也就是说在处理一个单词的时候只能访问它前面的序列信息。但是，只根据句子的前文来生成一个序列的表示是不全面的，因为从最后一个词来看，第一个词的信息可能已经很微弱了。为了同时考虑前文和后文的信息，一种解决办法是使用双向循环网络，其结构如图\ref{fig:10-14}所示。这里，编码器可以看作有两个循环神经网络，第一个网络，即红色虚线框里的网络，从句子的右边进行处理，第二个网络从句子左边开始处理，最终将正向和反向得到的结果都融合后传递给解码器。 \parinterval 前面提到的循环神经网络都是自左向右运行的，也就是说在处理一个单词的时候只能访问它前面的序列信息。但是，只根据句子的前文来生成一个序列的表示是不全面的，因为从最后一个词来看，第一个词的信息可能已经很微弱了。为了同时考虑前文和后文的信息，一种解决办法是使用双向循环网络，其结构如图\ref{fig:10-14}所示。这里，编码器可以看作由两个循环神经网络构成，第一个网络，即红色虚线框里的网络，从句子的右边进行处理，第二个网络从句子左边开始处理，最终将正向和反向得到的结果都融合后传递给解码器。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -719,7 +719,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm ...@@ -719,7 +719,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
\parinterval 神经机器翻译中，注意力机制的核心是：针对不同目标语言单词生成不同的上下文向量。这里，可以将注意力机制看做是一种对接收到的信息的加权处理。对于更重要的信息赋予更高的权重即更高的关注度，对于贡献度较低的信息分配较低的权重，弱化其对结果的影响。这样，$\mathbi{C}_j$可以包含更多对当前目标语言位置有贡献的源语言片段的信息。 \parinterval 神经机器翻译中，注意力机制的核心是：针对不同目标语言单词生成不同的上下文向量。这里，可以将注意力机制看做是一种对接收到的信息的加权处理。对于更重要的信息赋予更高的权重即更高的关注度，对于贡献度较低的信息分配较低的权重，弱化其对结果的影响。这样，$\mathbi{C}_j$可以包含更多对当前目标语言位置有贡献的源语言片段的信息。
\parinterval 根据这种思想，上下文向量$\mathbi{C}_j$被定义为对不同时间步编码器输出的状态序列$\{ \mathbi{h}_1, \mathbi{h}_2,...,\mathbi{h}_m \}$进行加权求和，如公式\eqref{eq:10-16}所示： \parinterval 根据这种思想，上下文向量$\mathbi{C}_j$被定义为对不同时间步编码器输出的状态序列$\{ \mathbi{h}_1, \mathbi{h}_2,...,\mathbi{h}_m \}$进行加权求和，如下式：
\begin{eqnarray} \begin{eqnarray}
\mathbi{C}_j&=&\sum_{i} \alpha_{i,j} \mathbi{h}_i \mathbi{C}_j&=&\sum_{i} \alpha_{i,j} \mathbi{h}_i
\label{eq:10-16} \label{eq:10-16}
...@@ -740,7 +740,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm ...@@ -740,7 +740,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 使用目标语言上一时刻循环单元的输出$\mathbi{s}_{j-1}$与源语言第$i$个位置的表示$\mathbi{h}_i$之间的相关性，其用来表示目标语言位置$j$对源语言位置$i$的关注程度，记为$\beta_{i,j}$，由函数$a(\cdot)$实现，其具体计算如公式\eqref{eq:10-17}所示： \item 使用目标语言上一时刻循环单元的输出$\mathbi{s}_{j-1}$与源语言第$i$个位置的表示$\mathbi{h}_i$之间的相关性，其用来表示目标语言位置$j$对源语言位置$i$的关注程度，记为$\beta_{i,j}$，由函数$a(\cdot)$实现，其具体计算如下：
\begin{eqnarray} \begin{eqnarray}
\beta_{i,j} &=& a(\mathbi{s}_{j-1},\mathbi{h}_i) \beta_{i,j} &=& a(\mathbi{s}_{j-1},\mathbi{h}_i)
\label{eq:10-17} \label{eq:10-17}
...@@ -760,7 +760,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -760,7 +760,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
其中$\mathbi{W}$和$\mathbi{v}$是可学习的参数。 其中$\mathbi{W}$和$\mathbi{v}$是可学习的参数。
\vspace{0.5em} \vspace{0.5em}
\item 进一步，利用Softmax函数，将相关性系数$\beta_{i,j}$进行指数归一化处理，得到注意力权重$\alpha_{i,j}$，具体计算如公式\eqref{eq:10-19}： \item 进一步，利用Softmax函数，将相关性系数$\beta_{i,j}$进行指数归一化处理，得到注意力权重$\alpha_{i,j}$，具体计算如下：
\vspace{0.5em} \vspace{0.5em}
\begin{eqnarray} \begin{eqnarray}
\alpha_{i,j} &=& \frac{\textrm{exp}(\beta_{i,j})} {\sum_{i'} \textrm{exp}(\beta_{i',j})} \alpha_{i,j} &=& \frac{\textrm{exp}(\beta_{i,j})} {\sum_{i'} \textrm{exp}(\beta_{i',j})}
...@@ -793,7 +793,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -793,7 +793,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 在\ref{sec:10.3.1}节中，公式\eqref{eq:10-4}描述了目标语言单词生成概率$ \funp{P} (y_j | \mathbi{y}_{<j},\mathbi{x})$。在引入注意力机制后，不同时刻的上下文向量$\mathbi{C}_j$替换了传统模型中固定的句子表示$\mathbi{C}$。描述如公式\eqref{eq:10-20}： \parinterval 在\ref{sec:10.3.1}节中，公式\eqref{eq:10-4}描述了目标语言单词生成概率$ \funp{P} (y_j | \mathbi{y}_{<j},\mathbi{x})$。在引入注意力机制后，不同时刻的上下文向量$\mathbi{C}_j$替换了传统模型中固定的句子表示$\mathbi{C}$。描述如下：
\begin{eqnarray} \begin{eqnarray}
\funp{P} (y_j | \mathbi{y}_{<j},\mathbi{x}) &=& \funp{P} (y_j | \mathbi{s}_{j-1},y_{j-1},\mathbi{C}_j ) \funp{P} (y_j | \mathbi{y}_{<j},\mathbi{x}) &=& \funp{P} (y_j | \mathbi{s}_{j-1},y_{j-1},\mathbi{C}_j )
\label{eq:10-20} \label{eq:10-20}
...@@ -837,7 +837,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -837,7 +837,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 也可以用这个系统描述翻译中的注意力问题，其中，$\mathrm{query}$即目标语言位置$j$的某种表示，$\mathrm{key}$和$\mathrm{value}$即源语言每个位置$i$上的${\mathbi{h}_i}$（这里$\mathrm{key}$和$\mathrm{value}$是相同的）。但是，这样的系统在机器翻译问题上并不好用，因为目标语言的表示和源语言的表示都在多维实数空间上，所以无法要求两个实数向量像字符串一样进行严格匹配，或者说这种严格匹配的模型可能会导致$\mathrm{query}$几乎不会命中任何的$\mathrm{key}$。既然无法严格精确匹配，注意力机制就采用了一个“模糊”匹配的方法。这里定义每个$\mathrm{key}_i$和$\mathrm{query}$ 都有一个0～1之间的匹配度，这个匹配度描述了$\mathrm{key}_i$和$\mathrm{query}$之间的相关程度，记为$\alpha_i$。而查询的结果（记为$\overline{\mathrm{value}}$）也不再是某一个单元的$\mathrm{value}$，而是所有单元$\mathrm{value}$用$\alpha_i$的加权和，具体计算如公式\eqref{eq:10-21}： \parinterval 也可以用这个系统描述翻译中的注意力问题，其中，$\mathrm{query}$即目标语言位置$j$的某种表示，$\mathrm{key}$和$\mathrm{value}$即源语言每个位置$i$上的${\mathbi{h}_i}$（这里$\mathrm{key}$和$\mathrm{value}$是相同的）。但是，这样的系统在机器翻译问题上并不好用，因为目标语言的表示和源语言的表示都在多维实数空间上，所以无法要求两个实数向量像字符串一样进行严格匹配，或者说这种严格匹配的模型可能会导致$\mathrm{query}$几乎不会命中任何的$\mathrm{key}$。既然无法严格精确匹配，注意力机制就采用了一个“模糊”匹配的方法。这里定义每个$\mathrm{key}_i$和$\mathrm{query}$ 都有一个0～1之间的匹配度，这个匹配度描述了$\mathrm{key}_i$和$\mathrm{query}$之间的相关程度，记为$\alpha_i$。而查询的结果（记为$\overline{\mathrm{value}}$）也不再是某一个单元的$\mathrm{value}$，而是所有单元$\mathrm{value}$用$\alpha_i$的加权和，具体计算如下：
\begin{eqnarray} \begin{eqnarray}
\overline{\mathrm{value}} &=& \sum_i \alpha_i \cdot {\mathrm{value}}_i \overline{\mathrm{value}} &=& \sum_i \alpha_i \cdot {\mathrm{value}}_i
\label{eq:10-21} \label{eq:10-21}
...@@ -856,13 +856,13 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -856,13 +856,13 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 最后，从统计学的角度，如果把$\alpha_i$作为每个$\mathrm{value}_i$出现的概率的某种估计，即：$ \funp{P} (\mathrm{value}_i$) $= \alpha_i$，于是可以把公式\eqref{eq:10-21}重写为公式\eqref{eq:10-22}： \parinterval 最后，从统计学的角度，如果把$\alpha_i$作为每个$\mathrm{value}_i$出现的概率的某种估计，即：$ \funp{P} (\mathrm{value}_i$) $= \alpha_i$，于是可以把公式\eqref{eq:10-21}重写为：
\begin{eqnarray} \begin{eqnarray}
\overline{\mathrm{value}} &=& \sum_i \funp{P} ( {\mathrm{value}}_i) \cdot {\mathrm{value}}_i \overline{\mathrm{value}} &=& \sum_i \funp{P} ( {\mathrm{value}}_i) \cdot {\mathrm{value}}_i
\label{eq:10-22} \label{eq:10-22}
\end{eqnarray} \end{eqnarray}
\noindent 显然， $\overline{\mathrm{value}}$就是$\mathrm{value}_i$在分布$ \funp{P}( \mathrm{value}_i$)下的期望，即公式\eqref{eq:10-23}： \noindent 显然， $\overline{\mathrm{value}}$就是$\mathrm{value}_i$在分布$ \funp{P}( \mathrm{value}_i$)下的期望，即：
\begin{eqnarray} \begin{eqnarray}
\mathbb{E}_{\sim \funp{P} ( {\mathrm{\mathrm{value}}}_i )} ({\mathrm{value}}_i) &=& \sum_i \funp{P} ({\mathrm{value}}_i) \cdot {\mathrm{value}}_i \mathbb{E}_{\sim \funp{P} ( {\mathrm{\mathrm{value}}}_i )} ({\mathrm{value}}_i) &=& \sum_i \funp{P} ({\mathrm{value}}_i) \cdot {\mathrm{value}}_i
\label{eq:10-23} \label{eq:10-23}
...@@ -898,7 +898,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -898,7 +898,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
\caption{GNMT与其他翻译模型对比\upcite{Wu2016GooglesNM}} \caption{GNMT与其他翻译模型对比\upcite{Wu2016GooglesNM}}
\label{tab:10-8} \label{tab:10-8}
\begin{tabular}{l l l} \begin{tabular}{l l l}
\multicolumn{1}{l|}{\multirow{3}{*}{\#}} & \multicolumn{2}{c}{BLEU[\%]} \\ \multicolumn{1}{l|}{\multirow{3}{*}{}} & \multicolumn{2}{c}{BLEU[\%]} \\
\multicolumn{1}{l|}{} & 英德 & 英法 \\ \multicolumn{1}{l|}{} & 英德 & 英法 \\
\multicolumn{1}{l|}{} & EN-DE & EN-FR \\ \hline \multicolumn{1}{l|}{} & EN-DE & EN-FR \\ \hline
\multicolumn{1}{l|}{PBMT} & 20.7 & 37.0 \\ \multicolumn{1}{l|}{PBMT} & 20.7 & 37.0 \\
...@@ -923,7 +923,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -923,7 +923,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\subsection{训练} \subsection{训练}
\parinterval 在基于梯度的方法中，模型参数可以通过损失函数$L$对参数的梯度进行不断更新。对于第$\textrm{step}$步参数更新，首先进行神经网络的前向计算，之后进行反向计算，并得到所有参数的梯度信息，再使用公式\eqref{eq:10-24}的规则进行参数更新： \parinterval 在基于梯度的方法中，模型参数可以通过损失函数$L$对参数的梯度进行不断更新。对于第$\textrm{step}$步参数更新，首先进行神经网络的前向计算，之后进行反向计算，并得到所有参数的梯度信息，再使用下面的规则进行参数更新：
\begin{eqnarray} \begin{eqnarray}
\mathbi{w}_{\textrm{step}+1} &=& \mathbi{w}_{\textrm{step}} - \alpha \cdot \frac{ \partial L(\mathbi{w}_{\textrm{step}})} {\partial \mathbi{w}_{\textrm{step}} } \mathbi{w}_{\textrm{step}+1} &=& \mathbi{w}_{\textrm{step}} - \alpha \cdot \frac{ \partial L(\mathbi{w}_{\textrm{step}})} {\partial \mathbi{w}_{\textrm{step}} }
\label{eq:10-24} \label{eq:10-24}
...@@ -939,13 +939,13 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -939,13 +939,13 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
\subsubsection{1. 损失函数} \subsubsection{1. 损失函数}
\parinterval 神经机器翻译在目标端的每个位置都会输出一个概率分布，表示这个位置上不同单词出现的可能性。设计损失函数时，需要知道当前位置输出的分布相比于标准答案的“差异”。对于这个问题，常用的是交叉熵损失函数。令$\mathbi{y}$表示机器翻译模型输出的分布，$\hat{\mathbi{y}}$ 表示标准答案，则交叉熵损失可以被定义为公式\eqref{eq:10-25}： \parinterval 神经机器翻译在目标端的每个位置都会输出一个概率分布，表示这个位置上不同单词出现的可能性。设计损失函数时，需要知道当前位置输出的分布相比于标准答案的“差异”。对于这个问题，常用的是交叉熵损失函数。令$\mathbi{y}$表示机器翻译模型输出的分布，$\hat{\mathbi{y}}$ 表示标准答案，则交叉熵损失可以被定义为：
\begin{eqnarray} \begin{eqnarray}
L_{\textrm{ce}}(\mathbi{y},\hat{\mathbi{y}}) &=& - \sum_{k=1}^{|V|} \mathbi{y}[k] \textrm{log} (\hat{\mathbi{y}}[k]) L_{\textrm{ce}}(\mathbi{y},\hat{\mathbi{y}}) &=& - \sum_{k=1}^{|V|} \mathbi{y}[k] \textrm{log} (\hat{\mathbi{y}}[k])
\label{eq:10-25} \label{eq:10-25}
\end{eqnarray} \end{eqnarray}
\noindent 其中$\mathbi{y}[k]$ 和$\hat{\mathbi{y}}[k]$分别表示向量$\mathbi{y}$和$\hat{\mathbi{y}}$的第$k$维，$|V|$表示输出向量的维度（等于词表大小）。假设有$n$个训练样本，模型输出的概率分布为$\mathbi{Y} = \{ \mathbi{y}_1,\mathbi{y}_2,..., \mathbi{y}_n \}$，标准答案的分布$\widehat{\mathbi{Y}}=\{ \hat{\mathbi{y}}_1, \hat{\mathbi{y}}_2,...,\hat{\mathbi{y}}_n \}$。这个训练样本集合上的损失函数可以被定义为公式\eqref{eq:10-26}： \noindent 其中$\mathbi{y}[k]$ 和$\hat{\mathbi{y}}[k]$分别表示向量$\mathbi{y}$和$\hat{\mathbi{y}}$的第$k$维，$|V|$表示输出向量的维度（等于词表大小）。假设有$n$个训练样本，模型输出的概率分布为$\mathbi{Y} = \{ \mathbi{y}_1,\mathbi{y}_2,..., \mathbi{y}_n \}$，标准答案的分布$\widehat{\mathbi{Y}}=\{ \hat{\mathbi{y}}_1, \hat{\mathbi{y}}_2,...,\hat{\mathbi{y}}_n \}$。这个训练样本集合上的损失函数可以被定义为：
\begin{eqnarray} \begin{eqnarray}
L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j,\hat{\mathbi{y}}_j) L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j,\hat{\mathbi{y}}_j)
\label{eq:10-26} \label{eq:10-26}
...@@ -953,7 +953,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -953,7 +953,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
\parinterval 公式\eqref{eq:10-26}是一种非常通用的损失函数形式，除了交叉熵，也可以使用其他的损失函数，这时只需要替换$L_{\textrm{ce}} (\cdot)$即可。这里使用交叉熵损失函数的好处在于，它非常容易优化，特别是与Softmax组合，其反向传播的实现非常高效。此外，交叉熵损失（在一定条件下）也对应了极大似然的思想，这种方法在自然语言处理中已经被证明是非常有效的。 \parinterval 公式\eqref{eq:10-26}是一种非常通用的损失函数形式，除了交叉熵，也可以使用其他的损失函数，这时只需要替换$L_{\textrm{ce}} (\cdot)$即可。这里使用交叉熵损失函数的好处在于，它非常容易优化，特别是与Softmax组合，其反向传播的实现非常高效。此外，交叉熵损失（在一定条件下）也对应了极大似然的思想，这种方法在自然语言处理中已经被证明是非常有效的。
\parinterval 除了交叉熵，很多系统也使用了面向评价的损失函数，比如，直接利用评价指标BLEU定义损失函数\upcite{DBLP:conf/acl/ShenCHHWSL16}。不过这类损失函数往往不可微分，因此无法直接获取梯度。这时可以引入强化学习技术，通过策略梯度等方法进行优化。不过这类方法需要采样等手段，这里不做重点讨论，相关内容会在后面技术部分进行介绍。 \parinterval 除了交叉熵，很多系统也使用了面向评价的损失函数，比如，直接利用评价指标BLEU定义损失函数\upcite{DBLP:conf/acl/ShenCHHWSL16}。不过这类损失函数往往不可微分，因此无法直接获取梯度。这时可以引入强化学习技术，通过策略梯度等方法进行优化。不过这类方法需要采样等手段，这里不做重点讨论，相关内容会在{\chapterthirteen}进行介绍。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION % NEW SUBSUB-SECTION
...@@ -971,7 +971,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -971,7 +971,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
\vspace{0.5em} \vspace{0.5em}
\item 网络中的其他偏置一般都初始化为0，可以有效防止加入过大或过小的偏置后使得激活函数的输出跑到“饱和区”，也就是梯度接近0的区域，防止训练一开始就无法跳出局部极小的区域。 \item 网络中的其他偏置一般都初始化为0，可以有效防止加入过大或过小的偏置后使得激活函数的输出跑到“饱和区”，也就是梯度接近0的区域，防止训练一开始就无法跳出局部极小的区域。
\vspace{0.5em} \vspace{0.5em}
\item 网络的权重矩阵$\mathbi{w}$一般使用Xavier参数初始化方法\upcite{pmlr-v9-glorot10a}，可以有效稳定训练过程，特别是对于比较“深”的网络。令$d_{\textrm{in}}$和$d_{\textrm{out}}$分别表示$\mathbi{w}$的输入和输出的维度大小\footnote{对于变换$\mathbi{y} = \mathbi{x} \mathbi{w}$，$\mathbi{w}$的列数为$d_{\textrm{in}}$，行数为$d_{\textrm{out}}$。}，则该方法的具体实现如公式\eqref{eq:10-27}所示： \item 网络的权重矩阵$\mathbi{w}$一般使用Xavier参数初始化方法\upcite{pmlr-v9-glorot10a}，可以有效稳定训练过程，特别是对于比较“深”的网络。令$d_{\textrm{in}}$和$d_{\textrm{out}}$分别表示$\mathbi{w}$的输入和输出的维度大小\footnote{对于变换$\mathbi{y} = \mathbi{x} \mathbi{w}$，$\mathbi{w}$的列数为$d_{\textrm{in}}$，行数为$d_{\textrm{out}}$。}，则该方法的具体实现如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{w} \sim U(-\sqrt{ \frac{6} { d_{\textrm{in}} + d_{\textrm{out}} } } , \sqrt{ \frac{6} { d_{\textrm{in}} + d_{\textrm{out}} } }) \mathbi{w} \sim U(-\sqrt{ \frac{6} { d_{\textrm{in}} + d_{\textrm{out}} } } , \sqrt{ \frac{6} { d_{\textrm{in}} + d_{\textrm{out}} } })
\label{eq:10-27} \label{eq:10-27}
...@@ -988,9 +988,9 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -988,9 +988,9 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
\subsubsection{3. 优化策略} \subsubsection{3. 优化策略}
%\vspace{0.5em} %\vspace{0.5em}
\parinterval 公式\eqref{eq:10-24}展示了最基本的优化策略，也被称为标准的SGD优化器。实际上，训练神经机器翻译模型时，还有非常多的优化器可以选择，在{\chapternine}也有详细介绍，这里考虑Adam优化器\upcite{kingma2014adam}。 Adam 通过对梯度的{\small\bfnew{一阶矩估计}}\index{一阶矩估计}（First Moment Estimation）\index{First Moment Estimation}和{\small\bfnew{二阶矩估计}}\index{二阶矩估计}（Second Moment Estimation）\index{Second Moment Estimation}进行综合考虑，计算出更新步长。 \parinterval 公式\eqref{eq:10-24}展示了最基本的优化策略，也被称为标准的SGD优化器。实际上，训练神经机器翻译模型时，还有非常多的优化器可以选择，在{\chapternine}也有详细介绍，本章介绍的循环神经网络考虑使用Adam优化器\upcite{kingma2014adam}。 Adam 通过对梯度的{\small\bfnew{一阶矩估计}}\index{一阶矩估计}（First Moment Estimation）\index{First Moment Estimation}和{\small\bfnew{二阶矩估计}}\index{二阶矩估计}（Second Moment Estimation）\index{Second Moment Estimation}进行综合考虑，计算出更新步长。
\parinterval 通常，Adam收敛地比较快，不同任务基本上可以使用一套配置进行优化，虽性能不算差，但很难达到最优效果。相反，SGD虽能通过在不同的数据集上进行调整，来达到最优的结果，但是收敛速度慢。因此需要根据不同的需求来选择合适的优化器。若需要快得到模型的初步结果，选择Adam较为合适，若是需要在一个任务上得到最优的结果，选择SGD更为合适。 \parinterval 通常，Adam收敛地比较快，不同任务基本上可以使用一套配置进行优化，虽性能不算差，但很难达到最优效果。相反，SGD虽能通过在不同的数据集上进行调整，来达到最优的结果，但是收敛速度慢。因此需要根据不同的需求来选择合适的优化器。若需要快速得到模型的初步结果，选择Adam较为合适，若是需要在一个任务上得到最优的结果，选择SGD更为合适。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION % NEW SUBSUB-SECTION
...@@ -999,7 +999,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -999,7 +999,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
\subsubsection{4. 梯度裁剪} \subsubsection{4. 梯度裁剪}
%\vspace{0.5em} %\vspace{0.5em}
\parinterval 需要注意的是，训练循环神经网络时，反向传播使得网络层之间的梯度相乘。在网络层数过深时，如果连乘因子小于1可能造成梯度指数级的减少，甚至趋近于0，导致网络无法优化，也就是梯度消失问题。当连乘因子大于1时，可能会导致梯度的乘积变得异常大，造成梯度爆炸的问题。在这种情况下需要使用“梯度裁剪”来防止梯度超过阈值。梯度裁剪在{\chapternine}已经介绍过，这里简单回顾一下。梯度裁剪的具体公式如公式\eqref{eq:10-28}所示： \parinterval 需要注意的是，训练循环神经网络时，反向传播使得网络层之间的梯度相乘。在网络层数过深时，如果连乘因子小于1可能造成梯度指数级的减少，甚至趋近于0，导致网络无法优化，也就是梯度消失问题。当连乘因子大于1时，可能会导致梯度的乘积变得异常大，造成梯度爆炸的问题。在这种情况下需要使用“梯度裁剪”来防止梯度超过阈值。梯度裁剪在{\chapternine}已经介绍过，这里简单回顾一下。梯度裁剪的具体公式如下：
\vspace{-0.5em} \vspace{-0.5em}
\begin{eqnarray} \begin{eqnarray}
\mathbi{w}' &=& \mathbi{w} \cdot \frac{\gamma} {\textrm{max}(\gamma,\| \mathbi{w} \|_2)} \mathbi{w}' &=& \mathbi{w} \cdot \frac{\gamma} {\textrm{max}(\gamma,\| \mathbi{w} \|_2)}
...@@ -1031,7 +1031,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -1031,7 +1031,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
\vspace{0.5em} \vspace{0.5em}
\parinterval 图\ref{fig:10-26}展示了一种常用的学习率调整策略。它分为两个阶段：预热阶段和衰减阶段。模型训练初期梯度通常很大，如果直接使用较大的学习率很容易让模型陷入局部最优。学习率的预热阶段便是通过在训练初期使学习率从小到大逐渐增加来减缓在初始阶段模型“跑偏”的现象。一般来说，初始学习率太高会使得模型进入一种损失函数曲面非常不平滑的区域，进而使得模型进入一种混乱状态，后续的优化过程很难取得很好的效果。一个常用的学习率预热方法是{\small\bfnew{逐渐预热}}\index{逐渐预热}（Gradual Warmup）\index{Gradual Warmup}。假设预热的更新次数为$N$，初始学习率为$\alpha_0$，则预热阶段第$\textrm{step}$次更新的学习率计算如公式\eqref{eq:10-29}所示： \parinterval 图\ref{fig:10-26}展示了一种常用的学习率调整策略。它分为两个阶段：预热阶段和衰减阶段。模型训练初期梯度通常很大，如果直接使用较大的学习率很容易让模型陷入局部最优。学习率的预热阶段便是通过在训练初期使学习率从小到大逐渐增加来减缓在初始阶段模型“跑偏”的现象。一般来说，初始学习率太高会使得模型进入一种损失函数曲面非常不平滑的区域，进而使得模型进入一种混乱状态，后续的优化过程很难取得很好的效果。一个常用的学习率预热方法是{\small\bfnew{逐渐预热}}\index{逐渐预热}（Gradual Warmup）\index{Gradual Warmup}。假设预热的更新次数为$N$，初始学习率为$\alpha_0$，则预热阶段第$\textrm{step}$次更新的学习率计算为：
%\vspace{0.5em} %\vspace{0.5em}
\begin{eqnarray} \begin{eqnarray}
\alpha_t &=& \frac{\textrm{step}}{N} \alpha_0 \quad,\quad 1 \leq t \leq T' \alpha_t &=& \frac{\textrm{step}}{N} \alpha_0 \quad,\quad 1 \leq t \leq T'
...@@ -1039,7 +1039,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -1039,7 +1039,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
\end{eqnarray} \end{eqnarray}
%------- %-------
\noindent 另一方面，当模型训练逐渐接近收敛的时候，使用太大学习率会很容易让模型在局部最优解附近震荡，从而错过局部极小，因此需要通过减小学习率来调整更新的步长，以此来不断地逼近局部最优，这一阶段也称为学习率的衰减阶段。学习率衰减的方法有很多，比如指数衰减以及余弦衰减等，图\ref{fig:10-26}右侧展示的是{\small\bfnew{分段常数衰减}}\index{分段常数衰减}（Piecewise Constant Decay）\index{Piecewise Constant Decay}，即每经过$m$次更新，学习率衰减为原来的$\beta_m$（$\beta_m<1$）倍，其中$m$和$\beta_m$为经验设置的超参。 \noindent 另一方面，当模型训练逐渐接近收敛的时候，使用太大学习率会很容易让模型在局部最优解附近震荡，从而错过局部极小，因此需要通过减小学习率来调整更新的步长，以此来不断地逼近局部最优，这一阶段也称为学习率的衰减阶段。学习率衰减的方法有很多，比如指数衰减以及余弦衰减等，图\ref{fig:10-26}右侧下降部分的曲线展示了{\small\bfnew{分段常数衰减}}\index{分段常数衰减}（Piecewise Constant Decay）\index{Piecewise Constant Decay}，即每经过$m$次更新，学习率衰减为原来的$\beta_m$（$\beta_m<1$）倍，其中$m$和$\beta_m$为经验设置的超参。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -1110,9 +1110,9 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -1110,9 +1110,9 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\begin{tabular}{l l} \begin{tabular}{l l}
\subfigure[{\small }]{\input{./Chapter10/Figures/figure-process01}} &\subfigure[{\small }]{\input{./Chapter10/Figures/figure-process02}} \\ \subfigure[{\small 第一步\qquad }]{\input{./Chapter10/Figures/figure-process01}} &\subfigure[{\small 第二步\qquad }]{\input{./Chapter10/Figures/figure-process02}} \\
\subfigure[{\small }]{\input{./Chapter10/Figures/figure-process03}} &\subfigure[{\small }]{\input{./Chapter10/Figures/figure-process04}} \\ \subfigure[{\small 第三步}]{\input{./Chapter10/Figures/figure-process03}} &\subfigure[{\small 第四步}]{\input{./Chapter10/Figures/figure-process04}} \\
\subfigure[{\small }]{\input{./Chapter10/Figures/figure-process05}} &\subfigure[{\small }]{\input{./Chapter10/Figures/figure-process06}} \subfigure[{\small 第五步\qquad }]{\input{./Chapter10/Figures/figure-process05}} &\subfigure[{\small 第六步\qquad }]{\input{./Chapter10/Figures/figure-process06}}
\end{tabular} \end{tabular}
\caption{一个三层循环神经网络的模型并行过程} \caption{一个三层循环神经网络的模型并行过程}
\label{fig:10-28} \label{fig:10-28}
...@@ -1124,20 +1124,20 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -1124,20 +1124,20 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\subsection{推断} \subsection{推断}
\parinterval 神经机器翻译的推断是一个典型的搜索问题（见{\chaptertwo}）。这个过程是指：利用已经训练好的模型对新的源语言句子进行翻译的过程。具体来说，首先利用编码器生成源语言句子的表示，之后利用解码器预测目标语言译文。也就是，对于源语言句子$\seq{{x}}$，生成一个使翻译概率$\funp{P}(\seq{{y}} | \seq{{x}})$最大的目标语言译文$\hat{\seq{{y}}}$，具体计算如公式\eqref{eq:10-30}（详细过程见\ref{sec:10.3.1} 节）： \parinterval 神经机器翻译的推断是一个典型的搜索问题（见{\chaptertwo}）。这个过程是指：利用已经训练好的模型对新的源语言句子进行翻译的过程。具体来说，首先利用编码器生成源语言句子的表示，之后利用解码器预测目标语言译文。也就是，对于源语言句子$\seq{{x}}$，生成一个使翻译概率$\funp{P}(\seq{{y}} | \seq{{x}})$最大的目标语言译文$\hat{\seq{{y}}}$，具体计算如下（详细过程见\ref{sec:10.3.1} 节）：
\begin{eqnarray} \begin{eqnarray}
\hat{\seq{{y}}} & = & \argmax_{\seq{{y}}} \funp{P}(\seq{{y}} | \seq{{x}}) \nonumber \\ \hat{\seq{{y}}} & = & \argmax_{\seq{{y}}} \funp{P}(\seq{{y}} | \seq{{x}}) \nonumber \\
& = & \argmax_{\seq{{y}}} \prod_{j=1}^n \funp{P}(y_j | \seq{{y}}_{<j},\seq{{x}}) & = & \argmax_{\seq{{y}}} \prod_{j=1}^n \funp{P}(y_j | \seq{{y}}_{<j},\seq{{x}})
\label{eq:10-30} \label{eq:10-30}
\end{eqnarray} \end{eqnarray}
\parinterval 在具体实现时，由于当前目标语言单词的生成需要依赖前面单词的生成，因此无法同时生成所有的目标语言单词。理论上，可以枚举所有的$\seq{{y}}$，之后利用$\funp{P}(\seq{{y}} | \seq{{x}})$ 的定义对每个$\seq{{y}}$进行评价，然后找出最好的$\seq{{y}}$。这也被称作{\small\bfnew{全搜索}}\index{全搜索}（Full Search）\index{Full Search}。但是，枚举所有的译文单词序列显然是不现实的。因此，在具体实现时，并不会访问所有可能的译文单词序列，而是用某种策略进行有效的搜索。常用的做法是自左向右逐词生成。比如，对于每一个目标语言位置$j$，可以执行公式\eqref{eq:10-31}的过程： \parinterval 在具体实现时，由于当前目标语言单词的生成需要依赖前面单词的生成，因此无法同时生成所有的目标语言单词。理论上，可以枚举所有的$\seq{{y}}$，之后利用$\funp{P}(\seq{{y}} | \seq{{x}})$ 的定义对每个$\seq{{y}}$进行评价，然后找出最好的$\seq{{y}}$。这也被称作{\small\bfnew{全搜索}}\index{全搜索}（Full Search）\index{Full Search}。但是，枚举所有的译文单词序列显然是不现实的。因此，在具体实现时，并不会访问所有可能的译文单词序列，而是用某种策略进行有效的搜索。常用的做法是自左向右逐词生成。比如，对于每一个目标语言位置$j$，可以执行：
\begin{eqnarray} \begin{eqnarray}
\hat{y}_j &=& \argmax_{y_j} \funp{P}(y_j | \hat{\seq{{y}}}_{<j} , \seq{{x}}) \hat{y}_j &=& \argmax_{y_j} \funp{P}(y_j | \hat{\seq{{y}}}_{<j} , \seq{{x}})
\label{eq:10-31} \label{eq:10-31}
\end{eqnarray} \end{eqnarray}
\noindent 其中，$\hat{y}_j$表示位置$j$概率最高的单词，$\hat{\seq{{y}}}_{<j} = \{ \hat{y}_1,...,\hat{y}_{j-1} \}$表示已经生成的最优译文单词序列。也就是，把最优的译文看作是所有位置上最优单词的组合。显然，这是一种贪婪搜索，因为无法保证$\{ \hat{y}_1,...,\hat{y}_{n} \}$是全局最优解。一种缓解这个问题的方法是，在每步中引入更多的候选。这里定义$\hat{y}_{jk} $ 表示在目标语言第$j$个位置排名在第$k$位的单词。在每一个位置$j$，可以生成$k$个最可能的单词，而不是1个，这个过程可以被描述为公式\eqref{eq:10-32}： \noindent 其中，$\hat{y}_j$表示位置$j$概率最高的单词，$\hat{\seq{{y}}}_{<j} = \{ \hat{y}_1,...,\hat{y}_{j-1} \}$表示已经生成的最优译文单词序列。也就是，把最优的译文看作是所有位置上最优单词的组合。显然，这是一种贪婪搜索，因为无法保证$\{ \hat{y}_1,...,\hat{y}_{n} \}$是全局最优解。一种缓解这个问题的方法是，在每步中引入更多的候选。这里定义$\hat{y}_{jk} $ 表示在目标语言第$j$个位置排名在第$k$位的单词。在每一个位置$j$，可以生成$k$个最可能的单词，而不是1个，这个过程可以被描述为：
\begin{eqnarray} \begin{eqnarray}
\{ \hat{y}_{j1},...,\hat{y}_{jk} \} &=& \argmax_{ \{ \hat{y}_{j1},...,\hat{y}_{jk} \} } \{ \hat{y}_{j1},...,\hat{y}_{jk} \} &=& \argmax_{ \{ \hat{y}_{j1},...,\hat{y}_{jk} \} }
\funp{P}(y_j | \{ \hat{\seq{{y}}}_{<{j\ast}} \},\seq{{x}}) \funp{P}(y_j | \{ \hat{\seq{{y}}}_{<{j\ast}} \},\seq{{x}})
...@@ -1216,13 +1216,13 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -1216,13 +1216,13 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 为了解决上面提到的问题，可以使用其他特征与$\textrm{log } \funp{P} (\seq{{y}} | \seq{{x}})$一起组成新的模型得分$\textrm{score} ( \seq{{y}} , \seq{{x}})$。针对模型倾向于生成短句子的问题，常用的做法是引入惩罚机制。比如，可以定义一个惩罚因子，具体如公式\eqref{eq:10-33}： \parinterval 为了解决上面提到的问题，可以使用其他特征与$\textrm{log } \funp{P} (\seq{{y}} | \seq{{x}})$一起组成新的模型得分$\textrm{score} ( \seq{{y}} , \seq{{x}})$。针对模型倾向于生成短句子的问题，常用的做法是引入惩罚机制。比如，可以定义一个惩罚因子，形式如下：
\begin{eqnarray} \begin{eqnarray}
\textrm{lp}(\seq{{y}}) &=& \frac {(5+ |\seq{{y}}|)^{\alpha}} {(5+1)^{\alpha}} \textrm{lp}(\seq{{y}}) &=& \frac {(5+ |\seq{{y}}|)^{\alpha}} {(5+1)^{\alpha}}
\label{eq:10-33} \label{eq:10-33}
\end{eqnarray} \end{eqnarray}
\noindent 其中，$|\seq{{y}}|$代表已经得到的译文长度，$\alpha$是一个固定的常数，用于控制惩罚的强度。同时在计算句子得分时，额外引入表示覆盖度的因子，如公式\eqref{eq:10-34}所示： \noindent 其中，$|\seq{{y}}|$代表已经得到的译文长度，$\alpha$是一个固定的常数，用于控制惩罚的强度。同时在计算句子得分时，额外引入表示覆盖度的因子，如下：
\begin{eqnarray} \begin{eqnarray}
\textrm{cp}(\seq{{y}} , \seq{{x}}) &=& \beta \cdot \sum_{i=1}^{|\seq{{x}}|} \textrm{log} \big(\textrm{min}(\sum_j^{|\seq{{y}}|} \alpha_{ij},1 ) \big) \textrm{cp}(\seq{{y}} , \seq{{x}}) &=& \beta \cdot \sum_{i=1}^{|\seq{{x}}|} \textrm{log} \big(\textrm{min}(\sum_j^{|\seq{{y}}|} \alpha_{ij},1 ) \big)
\label{eq:10-34} \label{eq:10-34}
...@@ -1230,7 +1230,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j ...@@ -1230,7 +1230,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
\noindent $\textrm{cp}(\cdot)$会惩罚把某些源语言单词对应到很多目标语言单词的情况（覆盖度），被覆盖的程度用$\sum_j^{|\seq{{y}}|} \alpha_{ij}$度量。$\beta$也是需要经验性设置的超参数，用于对覆盖度惩罚的强度进行控制。 \noindent $\textrm{cp}(\cdot)$会惩罚把某些源语言单词对应到很多目标语言单词的情况（覆盖度），被覆盖的程度用$\sum_j^{|\seq{{y}}|} \alpha_{ij}$度量。$\beta$也是需要经验性设置的超参数，用于对覆盖度惩罚的强度进行控制。
\parinterval 最终，模型得分定义如公式\eqref{eq:10-35}所示： \parinterval 最终，模型得分定义如下：
\begin{eqnarray} \begin{eqnarray}
\textrm{score} ( \seq{{y}} , \seq{{x}}) &=& \frac{\textrm{log} \funp{P}(\seq{{y}} | \seq{{x}})} {\textrm{lp}(\seq{{y}})} + \textrm{cp}(\seq{{y}} , \seq{{x}}) \textrm{score} ( \seq{{y}} , \seq{{x}}) &=& \frac{\textrm{log} \funp{P}(\seq{{y}} | \seq{{x}})} {\textrm{lp}(\seq{{y}})} + \textrm{cp}(\seq{{y}} , \seq{{x}})
\label{eq:10-35} \label{eq:10-35}
......
Chapter11/chapter11.tex
...@@ -85,13 +85,13 @@ ...@@ -85,13 +85,13 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 在卷积计算中，不同深度下卷积核不同但是执行操作相同，这里以二维卷积核为例展示具体卷积计算。若设输入矩阵为$\mathbi{x}$，输出矩阵为$\mathbi{y}$，卷积滑动步幅为$\textrm{stride}$，卷积核为$\mathbi{w}$，且$\mathbi{w} \in \mathbb{R}^{Q \times U} $，那么卷积计算过程如公式\eqref{eq:11-1}所示： \parinterval 在卷积计算中，不同深度下卷积核不同但是执行操作相同，这里以二维卷积核为例展示具体卷积计算。若设输入矩阵为$\mathbi{x}$，输出矩阵为$\mathbi{y}$，卷积滑动步幅为$\textrm{stride}$，卷积核为$\mathbi{w}$，且$\mathbi{w} \in \mathbb{R}^{Q \times U} $，那么卷积计算过程如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{y}_{i,j} &=& \sum \sum ( \mathbi{x}_{[j\times \textrm{stride}:j\times \textrm{stride}+U-1,i\times \textrm{stride}:i\times \textrm{stride}+Q-1]} \odot \mathbi{w} ) \mathbi{y}_{i,j} &=& \sum \sum ( \mathbi{x}_{[j\times \textrm{stride}:j\times \textrm{stride}+U-1,i\times \textrm{stride}:i\times \textrm{stride}+Q-1]} \odot \mathbi{w} )
\label{eq:11-1} \label{eq:11-1}
\end{eqnarray} \end{eqnarray}
\noindent 其中$i$是输出矩阵的行下标，$j$是输出矩阵的列下标，$\odot$表示矩阵点乘，具体见{\chapternine}。图\ref{fig:11-4}展示了一个简单的卷积操作示例，其中$Q$为2，$U$为2，$\textrm{stride}$为1，根据公式\eqref{eq:11-1}，图中蓝色位置$\mathbi{y}_{0,0}$的计算如公式\eqref{eq:11-2}所示： \noindent 其中$i$是输出矩阵的行下标，$j$是输出矩阵的列下标，$\odot$表示矩阵点乘，具体见{\chapternine}。图\ref{fig:11-4}展示了一个简单的卷积操作示例，其中$Q$为2，$U$为2，$\textrm{stride}$为1，根据公式\eqref{eq:11-1}，图中蓝色位置$\mathbi{y}_{0,0}$的计算如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{y}_{0,0} &=& \sum \sum ( \mathbi{x}_{[0\times 1:0\times 1+2-1,0\times 1:0\times 1+2-1]} \odot \mathbi{w}) \nonumber \\ \mathbi{y}_{0,0} &=& \sum \sum ( \mathbi{x}_{[0\times 1:0\times 1+2-1,0\times 1:0\times 1+2-1]} \odot \mathbi{w}) \nonumber \\
&=& \sum \sum ( \mathbi{x}_{[0:1,0:1]} \odot \mathbi{w} ) \nonumber \\ &=& \sum \sum ( \mathbi{x}_{[0:1,0:1]} \odot \mathbi{w} ) \nonumber \\
...@@ -201,9 +201,9 @@ ...@@ -201,9 +201,9 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 针对不定长序列，一种可行的方法是使用之前介绍过的循环神经网络，其本质也是基于权重共享的想法，在不同的时间步复用相同的循环神经网络单元进行处理。但是，循环神经网络最大的弊端在于每一时刻的计算都依赖于上一时刻的结果，因此只能对序列进行串行处理，无法充分利用硬件设备进行并行计算，导致效率相对较低。此外，在处理较长的序列时，这种串行的方式很难捕捉长距离的依赖关系。相比之下，卷积神经网络采用共享参数的方式处理固定大小窗口内的信息，且不同位置的卷积操作之间没有相互依赖，因此可以对序列进行高效地并行处理。同时，针对序列中距离较长的依赖关系，可以通过堆叠多层卷积层来扩大{\small\bfnew{感受野}}\index{感受野} (Receptive Field)\index{Receptive Field} ，这里感受野指能够影响神经元输出的原始输入数据区域的大小。图\ref{fig:11-9}对比了这两种结构，可以看出，为了捕捉$\mathbi{e}_2$ 和$\mathbi{e}_8$ 之间的联系，串行结构需要顺序的6次操作，和序列长度相关。而该卷积神经网络中，卷积操作每次对三个词进行计算，仅需要4层卷积计算就能得到$\mathbi{e}_2$ 和$\mathbi{e}_8$之间的联系，其操作数和卷积核的大小相关，相比于串行的方式具有更短的路径和更少的非线性计算，更容易进行训练。因此，也有许多研究人员在许多自然语言处理任务上尝试使用卷积神经网络进行序列建模\upcite{Kim2014ConvolutionalNN,Santos2014DeepCN,Kalchbrenner2014ACN,DBLP:conf/naacl/Johnson015,DBLP:conf/naacl/NguyenG15}。 \parinterval 针对不定长序列，一种可行的方法是使用之前介绍过的循环神经网络进行信息提取，其本质也是基于权重共享的想法，在不同的时间步复用相同的循环神经网络单元进行处理。但是，循环神经网络最大的弊端在于每一时刻的计算都依赖于上一时刻的结果，因此只能对序列进行串行处理，无法充分利用硬件设备进行并行计算，导致效率相对较低。此外，在处理较长的序列时，这种串行的方式很难捕捉长距离的依赖关系。相比之下，卷积神经网络采用共享参数的方式处理固定大小窗口内的信息，且不同位置的卷积操作之间没有相互依赖，因此可以对序列进行高效地并行处理。同时，针对序列中距离较长的依赖关系，可以通过堆叠多层卷积层来扩大{\small\bfnew{感受野}}\index{感受野} (Receptive Field)\index{Receptive Field} ，这里感受野指能够影响神经元输出的原始输入数据区域的大小。图\ref{fig:11-9}对比了这两种结构，可以看出，为了捕捉$\mathbi{e}_2$ 和$\mathbi{e}_8$ 之间的联系，串行结构需要顺序地进行6次操作，和序列长度相关。而该卷积神经网络中，卷积操作每次对三个词进行计算，仅需要4层卷积计算就能得到$\mathbi{e}_2$ 和$\mathbi{e}_8$之间的联系，其操作数和卷积核的大小相关，相比于串行的方式具有更短的路径和更少的非线性计算，更容易进行训练。因此，也有许多研究人员在许多自然语言处理任务上尝试使用卷积神经网络进行序列建模\upcite{Kim2014ConvolutionalNN,Santos2014DeepCN,Kalchbrenner2014ACN,DBLP:conf/naacl/Johnson015,DBLP:conf/naacl/NguyenG15}。
\parinterval 区别于传统图像上的卷积操作，在面向序列的卷积操作中，卷积核只在序列这一维度进行移动，用来捕捉连续的多个词之间的特征。需要注意的是，由于单词通常由一个实数向量表示（词嵌入），因此可以将词嵌入的维度看作是卷积操作中的通道数。图\ref{fig:11-10}就是一个基于序列卷积的文本分类模型，模型的输入是维度大小为$m\times O $的句子表示，$m$表示句子长度，$O$表示卷积核通道数，其值等于词嵌入维度，模型使用多个不同（对应图中不同的颜色）的卷积核来对序列进行特征提取，得到了多个不同的特征序列。然后使用池化层降低表示维度，得到了一组和序列长度无关的特征表示。基于这组压缩过的特征表示，模型再通过全连接网络和Softmax函数作为相应类别的预测。在这其中卷积层和池化层分别起到了特征提取和特征压缩的作用，将一个不定长的序列转化到一组固定大小的特征表示。 \parinterval 区别于传统图像上的卷积操作，在面向序列的卷积操作中，卷积核只在序列这一维度进行移动，用来捕捉连续的多个词之间的特征。需要注意的是，由于单词通常由一个实数向量表示（词嵌入），因此可以将词嵌入的维度看作是卷积操作中的通道数。图\ref{fig:11-10}就是一个基于序列卷积的文本分类模型，模型的输入是维度大小为$m\times O $的句子表示，$m$表示句子长度，$O$表示卷积核通道数，其值等于词嵌入维度，模型使用多个不同（对应图中不同的颜色）的卷积核来对序列进行特征提取，得到了多个不同的特征序列。然后使用池化层降低表示维度，得到了一组和序列长度无关的特征表示。最后模型基于这组压缩过的特征表示，使用全连接网络和Softmax函数进行类别预测。在这过程中卷积层和池化层分别起到了特征提取和特征压缩的作用，将一个不定长的序列转化为一组固定大小的特征表示。
%---------------------------------------------- %----------------------------------------------
% 图10. % 图10.
...@@ -244,9 +244,9 @@ ...@@ -244,9 +244,9 @@
\item {\small\bfnew{卷积层}}与{\small\bfnew{门控线性单元}}（Gated Linear Units, GLU\index{Gated Linear Units, GLU}）：黄色背景框是卷积模块，这里使用门控线性单元作为非线性函数，之前的研究工作\upcite{Dauphin2017LanguageMW} 表明这种非线性函数更适合于序列建模任务。图中为了简化，只展示了一层卷积，但在实际中为了更好地捕获句子信息，通常使用多层卷积的叠加。 \item {\small\bfnew{卷积层}}与{\small\bfnew{门控线性单元}}（Gated Linear Units, GLU\index{Gated Linear Units, GLU}）：黄色背景框是卷积模块，这里使用门控线性单元作为非线性函数，之前的研究工作\upcite{Dauphin2017LanguageMW} 表明这种非线性函数更适合于序列建模任务。图中为了简化，只展示了一层卷积，但在实际中为了更好地捕获句子信息，通常使用多层卷积的叠加。
\item {\small\bfnew{残差连接}}\index{残差连接}（Residual Connection）\index{Residual Connection}：对于源语言端和目标语言端的卷积层网络之间，都存在一个从输入到输出的额外连接，即跳接\upcite{DBLP:journals/corr/HeZRS15}。该连接方式确保每个隐层输出都能包含输入序列中的更多信息，同时能够有效提高深层网络的信息传递效率（该部分在图\ref{fig:11-12}中没有显示，具体结构详见\ref{sec:11.2.3}节）。 \item {\small\bfnew{残差连接}}\index{残差连接}（Residual Connection）\index{Residual Connection}：源语言端和目标语言端的卷积层网络之间，都存在一个从输入到输出的额外连接，即跳接\upcite{DBLP:journals/corr/HeZRS15}。该连接方式确保每个隐层输出都能包含输入序列中的更多信息，同时能够有效提高深层网络的信息传递效率（该部分在图\ref{fig:11-12}中没有显示，具体结构详见\ref{sec:11.2.3}节）。
\item {\small\bfnew{多跳注意力机制}}\index{多跳注意力机制}（Multi-step Attention/Multi-hop Attention）\index{Multi-step Attention}\index{Multi-hop Attention}：蓝色框内部展示了基于多跳结构的注意力机制模块\upcite{Sukhbaatar2015EndToEndMN}。ConvS2S模型同样使用注意力机制来捕捉两个序列之间不同位置的对应关系。区别于之前的做法，多跳注意力在解码端每一个层都会执行注意力操作。下面将以此模型为例对基于卷积神经网络的机器翻译模型进行介绍。 \item {\small\bfnew{多跳注意力机制}}\index{多跳注意力机制}（Multi-step Attention/Multi-hop Attention）\index{Multi-step Attention}\index{Multi-hop Attention}：蓝色框内部展示了基于多跳结构的注意力机制模块\upcite{Sukhbaatar2015EndToEndMN}。ConvS2S模型同样使用注意力机制来捕捉两个序列之间不同位置的对应关系。区别于之前的做法，多跳注意力在解码器端每一个层都会执行注意力操作。下面将以此模型为例对基于卷积神经网络的机器翻译模型进行介绍。
\end{itemize} \end{itemize}
%---------------------------------------------- %----------------------------------------------
...@@ -311,7 +311,7 @@ ...@@ -311,7 +311,7 @@
\mathbi{B} & = & \mathbi{x} * \mathbi{V} + \mathbi{b}_\mathbi{V} \label{eq:11-4} \mathbi{B} & = & \mathbi{x} * \mathbi{V} + \mathbi{b}_\mathbi{V} \label{eq:11-4}
\end{eqnarray} \end{eqnarray}
\noindent 其中，$\mathbi{A},\mathbi{B}\in \mathbb{R}^d$，$\mathbi{W}\in \mathbb{R}^{K\times d \times d}$、$\mathbi{V}\in \mathbb{R}^{K\times d \times d}$、$\mathbi{b}_\mathbi{W}$，$\mathbi{b}_\mathbi{V} \in \mathbb{R}^d $，$\mathbi{W}$、$\mathbi{V}$在此表示卷积核，$\mathbi{b}_\mathbi{W}$，$\mathbi{b}_\mathbi{V}$为偏置矩阵。在卷积操作之后，引入非线性变换，具体计算如公式\eqref{eq:11-5}所示： \noindent 其中，$\mathbi{A},\mathbi{B}\in \mathbb{R}^d$，$\mathbi{W}\in \mathbb{R}^{K\times d \times d}$、$\mathbi{V}\in \mathbb{R}^{K\times d \times d}$、$\mathbi{b}_\mathbi{W}$，$\mathbi{b}_\mathbi{V} \in \mathbb{R}^d $，$\mathbi{W}$、$\mathbi{V}$在此表示卷积核，$\mathbi{b}_\mathbi{W}$，$\mathbi{b}_\mathbi{V}$为偏置矩阵。在卷积操作之后，引入非线性变换，具体计算如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{y} & = & \mathbi{A} \otimes \sigma ( \mathbi{B} ) \mathbi{y} & = & \mathbi{A} \otimes \sigma ( \mathbi{B} )
\label{eq:11-5} \label{eq:11-5}
...@@ -338,7 +338,7 @@ ...@@ -338,7 +338,7 @@
\subsection{残差网络} \subsection{残差网络}
\label{sec:11.2.3} \label{sec:11.2.3}
\parinterval 残差连接是一种训练深层网络的技术，其内容在{\chapternine}已经进行了介绍，即在多层神经网络之间通过增加直接连接的方式，从而将底层信息直接传递给上层。通过增加这样的直接连接，可以让不同层之间的信息传递更加高效，有利于深层神经网络的训练，其计算如公式\eqref{eq:11-6}所示： \parinterval 残差连接是一种训练深层网络的技术，其内容在{\chapternine}已经进行了介绍，即在多层神经网络之间通过增加直接连接的方式，从而将底层信息直接传递给上层。通过增加这样的直接连接，可以让不同层之间的信息传递更加高效，有利于深层神经网络的训练，其计算公式为：
\begin{eqnarray} \begin{eqnarray}
\mathbi{h}^{l+1} &=& F (\mathbi{h}^l) + \mathbi{h}^l \mathbi{h}^{l+1} &=& F (\mathbi{h}^l) + \mathbi{h}^l
\label{eq:11-6} \label{eq:11-6}
...@@ -346,7 +346,7 @@ ...@@ -346,7 +346,7 @@
\noindent 其中，$\mathbi{h}^l$表示$l$层神经网络的输入向量，${F} (\mathbi{h}^l)$是$l$层神经网络的运算。如果$l=2$，那么公式\eqref{eq:11-6}可以解释为：第3层的输入$\mathbi{h}^3$等于第2层的输出${F}(\mathbi{h}^2)$加上第2层的输入$\mathbi{h}^2$。 \noindent 其中，$\mathbi{h}^l$表示$l$层神经网络的输入向量，${F} (\mathbi{h}^l)$是$l$层神经网络的运算。如果$l=2$，那么公式\eqref{eq:11-6}可以解释为：第3层的输入$\mathbi{h}^3$等于第2层的输出${F}(\mathbi{h}^2)$加上第2层的输入$\mathbi{h}^2$。
\parinterval 在ConvS2S中残差连接主要应用于门控卷积神经网络和多跳自注意力机制中，比如在编码器的多层门控卷积神经网络中，在每一层的输入和输出之间增加残差连接，具体的数学描述如公式\eqref{eq:11-7}所示： \parinterval 在ConvS2S中残差连接主要应用于门控卷积神经网络和多跳自注意力机制中，比如在编码器的多层门控卷积神经网络中，在每一层的输入和输出之间增加残差连接，具体的数学描述如下：
\begin{eqnarray} \begin{eqnarray}
%\mathbi{h}_i^l = \funp{v} (\mathbi{W}^l [\mathbi{h}_{i-\frac{k}{2}}^{l-1},...,\mathbi{h}_{i+\frac{k}{2}}^{l-1}] + b_{\mathbi{W}}^l ) + \mathbi{h}_i^{l-1} %\mathbi{h}_i^l = \funp{v} (\mathbi{W}^l [\mathbi{h}_{i-\frac{k}{2}}^{l-1},...,\mathbi{h}_{i+\frac{k}{2}}^{l-1}] + b_{\mathbi{W}}^l ) + \mathbi{h}_i^{l-1}
\mathbi{h}^{l+1} &=& \mathbi{A}^{l} \otimes \sigma ( \mathbi{B}^{l} ) + \mathbi{h}^{l} \mathbi{h}^{l+1} &=& \mathbi{A}^{l} \otimes \sigma ( \mathbi{B}^{l} ) + \mathbi{h}^{l}
...@@ -381,7 +381,7 @@ ...@@ -381,7 +381,7 @@
\noindent 其中，$\mathbi{h}_i$表示源语言端第$i$个位置的隐层状态，即编码器在第$i$个位置的输出。$\mathbi{s}_j$表示目标端第$j$个位置的隐层状态。给定$\mathbi{s}_j$和$\mathbi{h}_i$，注意力机制通过函数$\funp{a}(\cdot)$计算目标语言表示$\mathbi{s}_j$与源语言表示$\mathbi{h}_i$之间的注意力权重$\alpha_{i,j}$，通过加权平均得到当前目标语言端位置所需的上下文表示$\mathbi{C}_j$。其中$\funp{a}(\cdot)$的具体计算方式在{\chapterten}已经详细讨论。 \noindent 其中，$\mathbi{h}_i$表示源语言端第$i$个位置的隐层状态，即编码器在第$i$个位置的输出。$\mathbi{s}_j$表示目标端第$j$个位置的隐层状态。给定$\mathbi{s}_j$和$\mathbi{h}_i$，注意力机制通过函数$\funp{a}(\cdot)$计算目标语言表示$\mathbi{s}_j$与源语言表示$\mathbi{h}_i$之间的注意力权重$\alpha_{i,j}$，通过加权平均得到当前目标语言端位置所需的上下文表示$\mathbi{C}_j$。其中$\funp{a}(\cdot)$的具体计算方式在{\chapterten}已经详细讨论。
\parinterval 在ConvS2S模型中，解码器同样采用堆叠的多层门控卷积网络来对目标语言进行序列建模。区别于编码器，解码器在每一层卷积网络之后引入了注意力机制，用来参考源语言信息。ConvS2S选用了点乘注意力，并且通过类似残差连接的方式将注意力操作的输入与输出同时作用于下一层计算，称为多跳注意力。其具体计算方式如公式\eqref{eq:11-10}所示： \parinterval 在ConvS2S模型中，解码器同样采用堆叠的多层门控卷积网络来对目标语言进行序列建模。区别于编码器，解码器在每一层卷积网络之后引入了注意力机制，用来参考源语言信息。ConvS2S选用了点乘注意力，并且通过类似残差连接的方式将注意力操作的输入与输出同时作用于下一层计算，称为多跳注意力。其具体计算方式如下：
\begin{eqnarray} \begin{eqnarray}
\alpha_{ij}^l &=& \frac{ \textrm{exp} (\mathbi{d}_{j}^l\mathbi{h}_i) }{\sum_{i^{'}=1}^m \textrm{exp} (\mathbi{d}_{j}^l\mathbi{h}_{i^{'}})} \alpha_{ij}^l &=& \frac{ \textrm{exp} (\mathbi{d}_{j}^l\mathbi{h}_i) }{\sum_{i^{'}=1}^m \textrm{exp} (\mathbi{d}_{j}^l\mathbi{h}_{i^{'}})}
\label{eq:11-10} \label{eq:11-10}
...@@ -393,13 +393,13 @@ ...@@ -393,13 +393,13 @@
\mathbi{z}_j^l &=& \textrm{Conv}(\mathbi{s}_j^l) \label{eq:11-12} \mathbi{z}_j^l &=& \textrm{Conv}(\mathbi{s}_j^l) \label{eq:11-12}
\end{eqnarray} \end{eqnarray}
\noindent 其中，$\mathbi{z}_j^l$表示第$l$层卷积网络输出中第$j$个位置的表示，$\mathbi{W}_{d}^{l}$和$\mathbi{b}_{d}^{l}$是模型可学习的参数，$\textrm{Conv}(\cdot)$表示卷积操作。在获得第$l$层的注意力权重之后，就可以得到对应的一个上下文表示$\mathbi{C}_j^l$，具体计算如公式\eqref{eq:11-13}所示： \noindent 其中，$\mathbi{z}_j^l$表示第$l$层卷积网络输出中第$j$个位置的表示，$\mathbi{W}_{d}^{l}$和$\mathbi{b}_{d}^{l}$是模型可学习的参数，$\textrm{Conv}(\cdot)$表示卷积操作。在获得第$l$层的注意力权重之后，就可以得到对应的一个上下文表示$\mathbi{C}_j^l$，具体计算如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{C}_j^l &=& \sum_i \alpha_{ij}^l (\mathbi{h}_i + \mathbi{e}_i) \mathbi{C}_j^l &=& \sum_i \alpha_{ij}^l (\mathbi{h}_i + \mathbi{e}_i)
\label{eq:11-13} \label{eq:11-13}
\end{eqnarray} \end{eqnarray}
\noindent 模型使用了更全面的源语言信息，同时考虑了源语言端编码表示$\mathbi{h}_i$以及词嵌入表示$\mathbi{e}_i$。在获得第$l$层的上下文向量$\mathbi{C}_j^l$后，模型将其与$\mathbi{z}_j^l$相加后送入下一层网络，这个过程可以被描述为公式\eqref{eq:11-14}： \noindent 模型使用了更全面的源语言信息，同时考虑了源语言端编码表示$\mathbi{h}_i$以及词嵌入表示$\mathbi{e}_i$。在获得第$l$层的上下文向量$\mathbi{C}_j^l$后，模型将其与$\mathbi{z}_j^l$相加后送入下一层网络，这个过程可以被描述为：
\begin{eqnarray} \begin{eqnarray}
\mathbi{s}_j^{l+1} &=& \mathbi{C}_j^l + \mathbi{z}_j^l \mathbi{s}_j^{l+1} &=& \mathbi{C}_j^l + \mathbi{z}_j^l
\label{eq:11-14} \label{eq:11-14}
...@@ -434,13 +434,13 @@ ...@@ -434,13 +434,13 @@
\noindent 其中，$\mathbi{w}_t$表示第$t$步更新时的模型参数；$J(\mathbi{w}_t)$表示损失函数均值期望的估计；$\frac{\partial J(\mathbi{w}_t)}{\partial \mathbi{w}_t}$将指向$J(\mathbi{w}_t)$在$\mathbi{w}_t$处变化最大的方向，即梯度方向；$\alpha$ 为学习率；$\mathbi{v}_t$为损失函数在前$t-1$步更新中累积的梯度动量，利用超参数$\beta$控制累积的范围。 \noindent 其中，$\mathbi{w}_t$表示第$t$步更新时的模型参数；$J(\mathbi{w}_t)$表示损失函数均值期望的估计；$\frac{\partial J(\mathbi{w}_t)}{\partial \mathbi{w}_t}$将指向$J(\mathbi{w}_t)$在$\mathbi{w}_t$处变化最大的方向，即梯度方向；$\alpha$ 为学习率；$\mathbi{v}_t$为损失函数在前$t-1$步更新中累积的梯度动量，利用超参数$\beta$控制累积的范围。
\parinterval 而在Nesterov加速梯度下降法中，使用的梯度不是来自于当前参数位置，而是按照之前梯度方向更新一小步的位置，以便于更好地“预测未来”，提前调整更新速率，因此，其动量的更新方式如公式\eqref{eq:11-17}： \parinterval 而在Nesterov加速梯度下降法中，使用的梯度不是来自于当前参数位置，而是按照之前梯度方向更新一小步的位置，以便于更好地“预测未来”，提前调整更新速率，因此，其动量的更新方式如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{v}_t & = & \beta \mathbi{v}_{t-1} + (1-\beta)\frac{\partial J(\mathbi{w}_t)}{\partial (\mathbi{w}_{t} -\alpha \beta \mathbi{v}_{t-1} )} \mathbi{v}_t & = & \beta \mathbi{v}_{t-1} + (1-\beta)\frac{\partial J(\mathbi{w}_t)}{\partial (\mathbi{w}_{t} -\alpha \beta \mathbi{v}_{t-1} )}
\label{eq:11-17} \label{eq:11-17}
\end{eqnarray} \end{eqnarray}
\parinterval Nesterov加速梯度下降法其实是利用了二阶导数的信息，因此可以做到“向前看”，加速收敛过程\upcite{Bengio2013AdvancesIO}。为了模型的稳定训练。ConvS2S模型也采用了一些网络正则化和参数初始化的策略，使得模型在前向计算和反向计算过程中方差尽可能保持一致。 \parinterval Nesterov加速梯度下降法利用了二阶导数的信息，可以做到“向前看”，加速收敛过程\upcite{Bengio2013AdvancesIO}。为了模型的稳定训练。ConvS2S模型也采用了一些网络正则化和参数初始化的策略，使得模型在前向计算和反向计算过程中方差尽可能保持一致。
\parinterval 此外，ConvS2S模型为了进一步提升训练效率及性能，还使用了小批量训练，即每次从样本中选择出一小部分数据进行训练。同时，ConvS2S模型中也使用了Dropout方法\upcite{JMLR:v15:srivastava14a}。除了在词嵌入层和解码器输出层应用Dropout外，ConvS2S模型还对卷积块的输入层应用了Dropout。 \parinterval 此外，ConvS2S模型为了进一步提升训练效率及性能，还使用了小批量训练，即每次从样本中选择出一小部分数据进行训练。同时，ConvS2S模型中也使用了Dropout方法\upcite{JMLR:v15:srivastava14a}。除了在词嵌入层和解码器输出层应用Dropout外，ConvS2S模型还对卷积块的输入层应用了Dropout。
...@@ -476,7 +476,7 @@ ...@@ -476,7 +476,7 @@
\parinterval 深度可分离卷积由深度卷积和逐点卷积两部分结合而成\upcite{sifre2014rigid}。图\ref{fig:11-17}对比了标准卷积、深度卷积和逐点卷积，为了方便显示，图中只画出了部分连接。 \parinterval 深度可分离卷积由深度卷积和逐点卷积两部分结合而成\upcite{sifre2014rigid}。图\ref{fig:11-17}对比了标准卷积、深度卷积和逐点卷积，为了方便显示，图中只画出了部分连接。
\parinterval 给定输入序列表示$\seq{x} = \{ \mathbi{x}_1,\mathbi{x}_2,...,\mathbi{x}_m \}$，其中$m$为序列长度，$\mathbi{x}_i \in \mathbb{R}^{O} $ ，$O$ 即输入序列的通道数。为了获得与输入序列长度相同的卷积输出结果，首先需要进行填充。为了方便描述，这里在输入序列尾部填充 $K-1$ 个元素（$K$为卷积核窗口的长度），其对应的卷积结果为$\seq{z} = \{ \mathbi{z}_1,\mathbi{z}_2,...,\mathbi{z}_m \}$。 \parinterval 给定输入序列表示$\seq{x} = \{ \mathbi{x}_1,\mathbi{x}_2,...,\mathbi{x}_m \}$，其中$m$为序列长度，$\mathbi{x}_i \in \mathbb{R}^{O} $ ，$O$ 即输入序列的通道数。为了获得与输入序列长度相同的卷积输出结果，首先需要进行填充。为了方便描述，这里在输入序列尾部填充 $K-1$ 个元素（$K$为卷积核窗口的长度），其对应的卷积结果为$\seq{z} = \{ \mathbi{z}_1,\mathbi{z}_2,...,\mathbi{z}_m \}$。
在标准卷积中，若使用N表示卷积核的个数，也就是标准卷积输出序列的通道数，那么对于第$i$个位置的第$n$个通道$ \mathbi{z}_{i,n}^\textrm{\,std}$，其标准卷积具体计算如公式\eqref{eq:11-18}所示： 在标准卷积中，若使用N表示卷积核的个数，也就是标准卷积输出序列的通道数，那么对于第$i$个位置的第$n$个通道$ \mathbi{z}_{i,n}^\textrm{\,std}$，其标准卷积具体计算如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{z}_{i,n}^\textrm{\,std} &=& \sum_{o=1}^{O} \sum_{k=0}^{K-1} \mathbi{W}_{k,o,n}^\textrm{\,std} \mathbi{x}_{i+k,o} \mathbi{z}_{i,n}^\textrm{\,std} &=& \sum_{o=1}^{O} \sum_{k=0}^{K-1} \mathbi{W}_{k,o,n}^\textrm{\,std} \mathbi{x}_{i+k,o}
\label{eq:11-18} \label{eq:11-18}
...@@ -486,7 +486,7 @@ ...@@ -486,7 +486,7 @@
\noindent 其中，$ \mathbi{z}^\textrm{\,std}$表示标准卷积的输出，$ \mathbi{z}_i^\textrm{\,std} \in \mathbb{R}^N$， $\mathbi{W}^\textrm{\,std} \in \mathbb{R}^{K \times O \times N} $ 为标准卷积的参数。可以看出，标准卷积中每个输出元素需要考虑卷积核尺度内所有词的所有特征，参数量相对较多，对应图\ref{fig:11-17}中的连接数也最多。 \noindent 其中，$ \mathbi{z}^\textrm{\,std}$表示标准卷积的输出，$ \mathbi{z}_i^\textrm{\,std} \in \mathbb{R}^N$， $\mathbi{W}^\textrm{\,std} \in \mathbb{R}^{K \times O \times N} $ 为标准卷积的参数。可以看出，标准卷积中每个输出元素需要考虑卷积核尺度内所有词的所有特征，参数量相对较多，对应图\ref{fig:11-17}中的连接数也最多。
\parinterval 相应的，深度卷积只考虑不同词之间的依赖性，而不考虑不同通道之间的关系，相当于使用$O$个卷积核逐个通道对不同的词进行卷积操作。因此深度卷积不改变输出的表示维度，输出序列表示的通道数与输入序列一致，其计算如公式\eqref{eq:11-19}所示： \parinterval 相应的，深度卷积只考虑不同词之间的依赖性，而不考虑不同通道之间的关系，相当于使用$O$个卷积核逐个通道对不同的词进行卷积操作。因此深度卷积不改变输出的表示维度，输出序列表示的通道数与输入序列一致，其计算如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{z}_{i,o}^\textrm{\,dw} &=& \sum_{k=0}^{K-1} \mathbi{W}_{k,o}^\textrm{\,dw} \mathbi{x}_{i+k,o} \mathbi{z}_{i,o}^\textrm{\,dw} &=& \sum_{k=0}^{K-1} \mathbi{W}_{k,o}^\textrm{\,dw} \mathbi{x}_{i+k,o}
\label{eq:11-19} \label{eq:11-19}
...@@ -494,7 +494,7 @@ ...@@ -494,7 +494,7 @@
\noindent 其中，$\mathbi{z}^\textrm{\,dw}$表示深度卷积的输出，$\mathbi{z}_i^\textrm{\,dw} \in \mathbb{R}^{O}$ ，$\mathbi{W}^\textrm{\,dw} \in \mathbb{R}^{K \times O}$为深度卷积的参数，参数量只涉及卷积核大小及输入表示维度。 \noindent 其中，$\mathbi{z}^\textrm{\,dw}$表示深度卷积的输出，$\mathbi{z}_i^\textrm{\,dw} \in \mathbb{R}^{O}$ ，$\mathbi{W}^\textrm{\,dw} \in \mathbb{R}^{K \times O}$为深度卷积的参数，参数量只涉及卷积核大小及输入表示维度。
\parinterval 与深度卷积互为补充的是，逐点卷积只考虑不同通道之间的依赖性，而不考虑不同词之间的依赖。换句话说，逐点卷积对每个词表示做了一次线性变换，将输入表示$\mathbi{x}_i$从 $\mathbb{R}^{O}$ 的空间映射到 $\mathbb{R}^{N}$的空间，其具体计算如公式\eqref{eq:11-20}所示： \parinterval 与深度卷积互为补充的是，逐点卷积只考虑不同通道之间的依赖性，而不考虑不同词之间的依赖。换句话说，逐点卷积对每个词表示做了一次线性变换，将输入表示$\mathbi{x}_i$从 $\mathbb{R}^{O}$ 的空间映射到 $\mathbb{R}^{N}$的空间，其具体计算如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{z}_{i,n}^\textrm{\,pw} &=& \sum\limits_{o=1}^{O} \mathbi{x}_{i,o} \mathbi{W}_{o,n}^\textrm{\,pw} \nonumber \\ \mathbi{z}_{i,n}^\textrm{\,pw} &=& \sum\limits_{o=1}^{O} \mathbi{x}_{i,o} \mathbi{W}_{o,n}^\textrm{\,pw} \nonumber \\
&=& \mathbi{x}_i \mathbi{W}^\textrm{\,pw} &=& \mathbi{x}_i \mathbi{W}^\textrm{\,pw}
...@@ -547,7 +547,7 @@ ...@@ -547,7 +547,7 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 此外，和标准卷积不同的是，轻量卷积之前需要先对卷积参数进行归一化，具体计算过程如公式\eqref{eq:11-21}所示： \parinterval 此外，和标准卷积不同的是，轻量卷积之前需要先对卷积参数进行归一化，具体计算过程为：
\begin{eqnarray} \begin{eqnarray}
\mathbi{z}_{i,o}^\textrm{\,lw} &=& \sum_{k=0}^{K-1} \textrm{Softmax}(\mathbi{W}^\textrm{\,lw})_{k,[\frac{oa}{d}]} \mathbi{x}_{i+k,o} \mathbi{z}_{i,o}^\textrm{\,lw} &=& \sum_{k=0}^{K-1} \textrm{Softmax}(\mathbi{W}^\textrm{\,lw})_{k,[\frac{oa}{d}]} \mathbi{x}_{i+k,o}
\label{eq:11-21} \label{eq:11-21}
...@@ -562,7 +562,7 @@ ...@@ -562,7 +562,7 @@
\parinterval 轻量卷积和动态卷积的概念最早都是在图像领域被提出，大大减少了卷积神经网络模型中的参数和计算量\upcite{726791,Taigman2014DeepFaceCT,Chen2015LocallyconnectedAC}。虽然轻量卷积在存储和速度上具有优势，但其参数量的减少也导致了表示能力的下降，损失了一部分模型性能。为此，研究人员提出了动态卷积，旨在不增加网络深度和宽度的情况下来增强模型的表示能力，其思想就是根据输入来动态地生成卷积参数\upcite{Wu2019PayLA,Chen2020DynamicCA}。 \parinterval 轻量卷积和动态卷积的概念最早都是在图像领域被提出，大大减少了卷积神经网络模型中的参数和计算量\upcite{726791,Taigman2014DeepFaceCT,Chen2015LocallyconnectedAC}。虽然轻量卷积在存储和速度上具有优势，但其参数量的减少也导致了表示能力的下降，损失了一部分模型性能。为此，研究人员提出了动态卷积，旨在不增加网络深度和宽度的情况下来增强模型的表示能力，其思想就是根据输入来动态地生成卷积参数\upcite{Wu2019PayLA,Chen2020DynamicCA}。
\parinterval 在轻量卷积中，模型使用的卷积参数是静态的，与序列位置无关， 维度大小为$K\times a$；而在动态卷积中，为了增强模型的表示能力，卷积参数来自于当前位置输入的变换，具体如公式\eqref{eq:11-22}： \parinterval 在轻量卷积中，模型使用的卷积参数是静态的，与序列位置无关， 维度大小为$K\times a$；而在动态卷积中，为了增强模型的表示能力，卷积参数来自于当前位置输入的变换，具体计算为：
\begin{eqnarray} \begin{eqnarray}
\funp{f} (\mathbi{x}_{i}) &=& \sum_{c=1}^d \mathbi{W}_{:,:,c} \odot \mathbi{x}_{i,c} \funp{f} (\mathbi{x}_{i}) &=& \sum_{c=1}^d \mathbi{W}_{:,:,c} \odot \mathbi{x}_{i,c}
\label{eq:11-22} \label{eq:11-22}
......
Chapter12/chapter12.tex
...@@ -56,7 +56,7 @@ ...@@ -56,7 +56,7 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 自注意力机制也可以被看作是一个序列表示模型。比如，对于每个目标位置$j$，都生成一个与之对应的源语言句子表示，它的形式如公式\eqref{eq:12-1}所示： \parinterval 自注意力机制也可以被看作是一个序列表示模型。比如，对于每个目标位置$j$，都生成一个与之对应的源语言句子表示，它的形式如下：
\begin{eqnarray} \begin{eqnarray}
\mathbi{C}_j & = & \sum_i \alpha_{i,j}\mathbi{h}_i \mathbi{C}_j & = & \sum_i \alpha_{i,j}\mathbi{h}_i
\label{eq:12-1} \label{eq:12-1}
...@@ -73,7 +73,7 @@ ...@@ -73,7 +73,7 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 举个例子，如图\ref{fig:12-3}所示，一个汉语句子包含5个词。这里，用$h$(他)表示“他”当前的表示结果，其中$h(\cdot)$是一个函数，用于返回输入单词所在位置对应的表示结果（向量）。如果把“他”看作目标，这时$\mathrm{query}$ 就是$h$(他)，$\mathrm{key}$和$\mathrm{value}$是图中所有位置的表示，即：{$h$(他)、$h$(什么)、$h$(也)、$h$(没)、$h$(学)}。在自注意力模型中，首先计算$\mathrm{query}$ 和$\mathrm{key}$的相关度，这里用$\alpha_i$表示$h$(他)和位置$i$的表示之间的相关性。然后，把$\alpha_i$作为权重，对不同位置上的$\mathrm{value}$进行加权求和。最终，得到新的表示结果$\tilde{h}$ (他)，其具体计算如公式\eqref{eq:12-2}所示： \parinterval 举个例子，如图\ref{fig:12-3}所示，一个汉语句子包含5个词。这里，用$h$(他)表示“他”当前的表示结果，其中$h(\cdot)$是一个函数，用于返回输入单词所在位置对应的表示结果（向量）。如果把“他”看作目标，这时$\mathrm{query}$ 就是$h$(他)，$\mathrm{key}$和$\mathrm{value}$是图中所有位置的表示，即：{$h$(他)、$h$(什么)、$h$(也)、$h$(没)、$h$(学)}。在自注意力模型中，首先计算$\mathrm{query}$ 和$\mathrm{key}$的相关度，这里用$\alpha_i$表示$h$(他)和位置$i$的表示之间的相关性。然后，把$\alpha_i$作为权重，对不同位置上的$\mathrm{value}$进行加权求和。最终，得到新的表示结果$\tilde{h}$ (他)，其具体计算如下：
\begin{eqnarray} \begin{eqnarray}
\tilde{h} (\textrm{他} ) & = & \alpha_1 {h} (\textrm{他} ) + \alpha_2 {h} (\textrm{什么}) + \alpha_3 {h} (\textrm{也} ) + \nonumber \\ \tilde{h} (\textrm{他} ) & = & \alpha_1 {h} (\textrm{他} ) + \alpha_2 {h} (\textrm{什么}) + \alpha_3 {h} (\textrm{也} ) + \nonumber \\
...@@ -102,7 +102,7 @@ ...@@ -102,7 +102,7 @@
\parinterval 首先再来回顾一下{\chapterten}介绍的循环神经网络，虽然它很强大，但是也存在一些弊端。其中比较突出的问题是，循环神经网络每个循环单元都有向前依赖性，也就是当前时间步的处理依赖前一时间步处理的结果。这个性质可以使序列的“历史”信息不断被传递，但是也造成模型运行效率的下降。特别是对于自然语言处理任务，序列往往较长，无论是传统的RNN结构，还是更为复杂的LSTM结构，都需要很多次循环单元的处理才能够捕捉到单词之间的长距离依赖。由于需要多个循环单元的处理，距离较远的两个单词之间的信息传递变得很复杂。 \parinterval 首先再来回顾一下{\chapterten}介绍的循环神经网络，虽然它很强大，但是也存在一些弊端。其中比较突出的问题是，循环神经网络每个循环单元都有向前依赖性，也就是当前时间步的处理依赖前一时间步处理的结果。这个性质可以使序列的“历史”信息不断被传递，但是也造成模型运行效率的下降。特别是对于自然语言处理任务，序列往往较长，无论是传统的RNN结构，还是更为复杂的LSTM结构，都需要很多次循环单元的处理才能够捕捉到单词之间的长距离依赖。由于需要多个循环单元的处理，距离较远的两个单词之间的信息传递变得很复杂。
\parinterval 针对这些问题，研究人员提出了一种全新的模型$\ \dash\ $Transformer\index{Transformer}\upcite{vaswani2017attention}。与循环神经网络等传统模型不同，Transformer模型仅仅使用自注意力机制和标准的前馈神经网络，完全不依赖任何循环单元或者卷积操作。自注意力机制的优点在于可以直接对序列中任意两个单元之间的关系进行建模，这使得长距离依赖等问题可以更好地被求解。此外，自注意力机制非常适合在GPU 上进行并行化，因此模型训练的速度更快。表\ref{tab:12-1}对比了RNN、CNN和Transformer层类型的复杂度\footnote{顺序操作数指模型处理一个序列所需要的操作数，由于Transformer和CNN都可以并行计算，所以是1；路径长度指序列中任意两个单词在网络中的距离。}。 \parinterval 针对这些问题，研究人员提出了一种全新的模型$\ \dash\ $Transformer\index{Transformer}\upcite{vaswani2017attention}。与循环神经网络等传统模型不同，Transformer模型仅仅使用自注意力机制和标准的前馈神经网络，完全不依赖任何循环单元或者卷积操作。自注意力机制的优点在于可以直接对序列中任意两个单元之间的关系进行建模，这使得长距离依赖等问题可以更好地被求解。此外，自注意力机制非常适合在GPU 上进行并行化，因此模型训练的速度更快。表\ref{tab:12-1}对比了RNN、CNN和Transformer的层类型复杂度\footnote{顺序操作数指模型处理一个序列所需要的操作数，由于Transformer和CNN都可以并行计算，所以是1；路径长度指序列中任意两个单词在网络中的距离。}。
%---------------------------------------------- %----------------------------------------------
\begin{table}[htp] \begin{table}[htp]
...@@ -271,7 +271,7 @@ ...@@ -271,7 +271,7 @@
% NEW SUB-SECTION % NEW SUB-SECTION
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\subsection{点乘注意力} \subsection{点乘注意力机制}
\parinterval 在\ref{sec:12.1}节中已经介绍，自注意力机制中至关重要的是获取相关性系数，也就是在融合不同位置的表示向量时各位置的权重。Transformer模型采用了一种基于点乘的方法来计算相关性系数。这种方法也称为{\small\bfnew{缩放的点乘注意力}}\index{缩放的点乘注意力}（Scaled Dot-product Attention）\index{Scaled Dot-product Attention}机制。它的运算并行度高，同时并不消耗太多的存储空间。 \parinterval 在\ref{sec:12.1}节中已经介绍，自注意力机制中至关重要的是获取相关性系数，也就是在融合不同位置的表示向量时各位置的权重。Transformer模型采用了一种基于点乘的方法来计算相关性系数。这种方法也称为{\small\bfnew{缩放的点乘注意力}}\index{缩放的点乘注意力}（Scaled Dot-product Attention）\index{Scaled Dot-product Attention}机制。它的运算并行度高，同时并不消耗太多的存储空间。
...@@ -279,7 +279,7 @@ ...@@ -279,7 +279,7 @@
\parinterval 在自注意力机制中，$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$都是相同的，对应着源语言或目标语言序列的表示。而在编码-解码注意力机制中，由于要对双语之间的信息进行建模，因此，将目标语言每个位置的表示视为编码-解码注意力机制的$\mathbi{Q}$，源语言句子的表示视为$\mathbi{K}$ 和$\mathbi{V}$。 \parinterval 在自注意力机制中，$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$都是相同的，对应着源语言或目标语言序列的表示。而在编码-解码注意力机制中，由于要对双语之间的信息进行建模，因此，将目标语言每个位置的表示视为编码-解码注意力机制的$\mathbi{Q}$，源语言句子的表示视为$\mathbi{K}$ 和$\mathbi{V}$。
\parinterval 在得到$\mathbi{Q}$，$\mathbi{K}$和$\mathbi{V}$后，便可以进行注意力机制的运算，这个过程可以被形式化为公式\eqref{eq:12-9}： \parinterval 在得到$\mathbi{Q}$，$\mathbi{K}$和$\mathbi{V}$后，便可以进行注意力的运算，这个过程可以被形式化为：
\begin{eqnarray} \begin{eqnarray}
\textrm{Attention}(\mathbi{Q},\mathbi{K},\mathbi{V}) &=& \textrm{Softmax} \textrm{Attention}(\mathbi{Q},\mathbi{K},\mathbi{V}) &=& \textrm{Softmax}
( \frac{\mathbi{Q}\mathbi{K}^{\textrm{T}}} {\sqrt{d_k}} + \mathbi{Mask} ) \mathbi{V} ( \frac{\mathbi{Q}\mathbi{K}^{\textrm{T}}} {\sqrt{d_k}} + \mathbi{Mask} ) \mathbi{V}
...@@ -302,7 +302,7 @@ ...@@ -302,7 +302,7 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 下面举个简单的例子介绍点乘注意力的具体计算过程。如图\ref{fig:12-11}所示，用黄色、蓝色和橙色的矩阵分别表示$\mathbi{Q}$、$\mathbi{K}$和$\mathbi{V}$。$\mathbi{Q}$、$\mathbi{K}$ 和$\mathbi{V}$中的每一个小格都对应一个单词在模型中的表示（即一个向量）。首先，通过点乘、放缩、掩码等操作得到相关性矩阵，即粉色部分。其次，将得到的中间结果矩阵（粉色）的每一行使用Softmax激活函数进行归一化操作，得到最终的权重矩阵，也就是图中的红色矩阵。红色矩阵中的每一行都对应一个注意力分布。最后，按行对$\mathbi{V}$进行加权求和，便得到了每个单词通过点乘注意力机制计算得到的表示。这里面，主要的计算消耗是两次矩阵乘法，即$\mathbi{Q}$与$\mathbi{K}^{\textrm{T}}$的乘法、相关性矩阵和$\mathbi{V}$的乘法。这两个操作都可以在GPU上高效地完成，因此可以一次性计算出序列中所有单词之间的注意力权重，并完成所有位置表示的加权求和过程，这样大大提高了模型计算的并行度。 \parinterval 下面举个简单的例子介绍点乘注意力的具体计算过程。如图\ref{fig:12-11}所示，用黄色、蓝色和橙色的矩阵分别表示$\mathbi{Q}$、$\mathbi{K}$和$\mathbi{V}$。$\mathbi{Q}$、$\mathbi{K}$ 和$\mathbi{V}$中的每一个小格都对应一个单词在模型中的表示（即一个向量）。首先，通过点乘、放缩、掩码等操作得到相关性矩阵，即粉色部分。其次，将得到的中间结果矩阵（粉色）的每一行使用Softmax激活函数进行归一化操作，得到最终的权重矩阵，也就是图中的红色矩阵。红色矩阵中的每一行都对应一个注意力分布。最后，按行对$\mathbi{V}$进行加权求和，便得到了每个单词通过点乘注意力计算得到的表示。这里面，主要的计算消耗是两次矩阵乘法，即$\mathbi{Q}$与$\mathbi{K}^{\textrm{T}}$的乘法、相关性矩阵和$\mathbi{V}$的乘法。这两个操作都可以在GPU上高效地完成，因此可以一次性计算出序列中所有单词之间的注意力权重，并完成所有位置表示的加权求和过程，这样大大提高了模型计算的并行度。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -317,9 +317,9 @@ ...@@ -317,9 +317,9 @@
% NEW SUB-SECTION % NEW SUB-SECTION
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\subsection{多头注意力} \subsection{多头注意力机制}
\parinterval Transformer中使用的另一项重要技术是{\small\sffamily\bfseries{多头注意力}}\index{多头注意力}（Multi-head Attention）\index{Multi-head Attention}。“多头”可以理解成将原来的$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$按照隐层维度平均切分成多份。假设切分$h$份，那么最终会得到$\mathbi{Q} = \{ \mathbi{Q}_1, \mathbi{Q}_2,...,\mathbi{Q}_h \}$，$\mathbi{K}=\{ \mathbi{K}_1,\mathbi{K}_2,...,\mathbi{K}_h \}$，$\mathbi{V}=\{ \mathbi{V}_1, \mathbi{V}_2,...,\mathbi{V}_h \}$。多头注意力机制就是用每一个切分得到的$\mathbi{Q}$，$\mathbi{K}$，$\mathbi{V}$独立的进行注意力计算，即第$i$个头的注意力计算结果$\mathbi{head}_i = \textrm{Attention}(\mathbi{Q}_i,\mathbi{K}_i, \mathbi{V}_i)$。 \parinterval Transformer中使用的另一项重要技术是{\small\sffamily\bfseries{多头注意力机制}}\index{多头注意力机制}（Multi-head Attention）\index{Multi-head Attention}。“多头”可以理解成将原来的$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$按照隐层维度平均切分成多份。假设切分$h$份，那么最终会得到$\mathbi{Q} = \{ \mathbi{Q}_1, \mathbi{Q}_2,...,\mathbi{Q}_h \}$，$\mathbi{K}=\{ \mathbi{K}_1,\mathbi{K}_2,...,\mathbi{K}_h \}$，$\mathbi{V}=\{ \mathbi{V}_1, \mathbi{V}_2,...,\mathbi{V}_h \}$。多头注意力就是用每一个切分得到的$\mathbi{Q}$，$\mathbi{K}$，$\mathbi{V}$独立的进行注意力计算，即第$i$个头的注意力计算结果$\mathbi{head}_i = \textrm{Attention}(\mathbi{Q}_i,\mathbi{K}_i, \mathbi{V}_i)$。
\parinterval 下面根据图\ref{fig:12-12}详细介绍多头注意力的计算过程： \parinterval 下面根据图\ref{fig:12-12}详细介绍多头注意力的计算过程：
...@@ -342,14 +342,14 @@ ...@@ -342,14 +342,14 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 多头机制可以被形式化描述为公式\eqref{eq:12-10}和\eqref{eq:12-11}： \parinterval 多头注意力机制可以被形式化描述为公式\eqref{eq:12-10}和\eqref{eq:12-11}：
\begin{eqnarray} \begin{eqnarray}
\textrm{MultiHead}(\mathbi{Q}, \mathbi{K} , \mathbi{V})& = & \textrm{Concat} (\mathbi{head}_1, ... , \mathbi{head}_h ) \mathbi{W}^{\,o} \label{eq:12-10} \\ \textrm{MultiHead}(\mathbi{Q}, \mathbi{K} , \mathbi{V})& = & \textrm{Concat} (\mathbi{head}_1, ... , \mathbi{head}_h ) \mathbi{W}^{\,o} \label{eq:12-10} \\
\mathbi{head}_i & = &\textrm{Attention} (\mathbi{Q}\mathbi{W}_i^{\,Q} , \mathbi{K}\mathbi{W}_i^{\,K} , \mathbi{V}\mathbi{W}_i^{\,V} ) \mathbi{head}_i & = &\textrm{Attention} (\mathbi{Q}\mathbi{W}_i^{\,Q} , \mathbi{K}\mathbi{W}_i^{\,K} , \mathbi{V}\mathbi{W}_i^{\,V} )
\label{eq:12-11} \label{eq:12-11}
\end{eqnarray} \end{eqnarray}
\parinterval 多头机制的好处是允许模型在不同的表示子空间里学习。在很多实验中发现，不同表示空间的头捕获的信息是不同的，比如，在使用Transformer处理自然语言时，有的头可以捕捉句法信息，有的头可以捕捉词法信息。 \parinterval 多头注意力机制的好处是允许模型在不同的表示子空间里学习。在很多实验中发现，不同表示空间的头捕获的信息是不同的，比如，在使用Transformer处理自然语言时，有的头可以捕捉句法信息，有的头可以捕捉词法信息。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
...@@ -414,14 +414,14 @@ ...@@ -414,14 +414,14 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 在Transformer的训练过程中，由于引入了残差操作，将前面所有层的输出加到一起，如公式\eqref{eq:12-12}所示： \parinterval 在Transformer的训练过程中，由于引入了残差操作，将前面所有层的输出加到一起，如下：
\begin{eqnarray} \begin{eqnarray}
%x_{l+1} = x_l + F (x_l) %x_{l+1} = x_l + F (x_l)
\mathbi{x}^{l+1} &=& F (\mathbi{x}^l) + \mathbi{x}^l \mathbi{x}^{l+1} &=& F (\mathbi{x}^l) + \mathbi{x}^l
\label{eq:12-12} \label{eq:12-12}
\end{eqnarray} \end{eqnarray}
\noindent 其中$\mathbi{x}^l$表示第$l$层网络的输入向量，$F (\mathbi{x}^l)$是子层运算，这样会导致不同层（或子层）的结果之间的差异性很大，造成训练过程不稳定、训练时间较长。为了避免这种情况，在每层中加入了层标准化操作\upcite{Ba2016LayerN}。图\ref{fig:12-14} 中的红色方框展示了Transformer中残差和层标准化的位置。层标准化的计算如公式\eqref{eq:12-13}所示： \noindent 其中$\mathbi{x}^l$表示第$l$层网络的输入向量，$F (\mathbi{x}^l)$是子层运算，这样会导致不同层（或子层）的结果之间的差异性很大，造成训练过程不稳定、训练时间较长。为了避免这种情况，在每层中加入了层标准化操作\upcite{Ba2016LayerN}。图\ref{fig:12-14} 中的红色方框展示了Transformer中残差和层标准化的位置。层标准化的计算如下：
\begin{eqnarray} \begin{eqnarray}
\textrm{LN}(\mathbi{x}) &=& g \cdot \frac{\mathbi{x}- \mu} {\sigma} + b \textrm{LN}(\mathbi{x}) &=& g \cdot \frac{\mathbi{x}- \mu} {\sigma} + b
\label{eq:12-13} \label{eq:12-13}
...@@ -457,7 +457,7 @@ ...@@ -457,7 +457,7 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval Transformer使用了全连接网络。全连接网络的作用主要体现在将经过注意力操作之后的表示映射到新的空间中，新的空间会有利于接下来的非线性变换等操作。实验证明，去掉全连接网络会对模型的性能造成很大影响。Transformer的全连接前馈神经网络包含两次线性变换和一次非线性变换（ReLU激活函数:ReLU$(\mathbi{x})=\textrm{max}⁡(0,\mathbi{x})$），每层的前馈神经网络参数不共享，具体计算如公式\eqref{eq:12-14}： \parinterval Transformer使用了全连接网络。全连接网络的作用主要体现在将经过注意力操作之后的表示映射到新的空间中，新的空间会有利于接下来的非线性变换等操作。实验证明，去掉全连接网络会对模型的性能造成很大影响。Transformer的全连接前馈神经网络包含两次线性变换和一次非线性变换（ReLU激活函数:ReLU$(\mathbi{x})=\textrm{max}⁡(0,\mathbi{x})$），每层的前馈神经网络参数不共享，具体计算如下：
\begin{eqnarray} \begin{eqnarray}
\textrm{FFN}(\mathbi{x}) &=& \textrm{max} (0,\mathbi{x}\mathbi{W}_1 + \mathbi{b}_1)\mathbi{W}_2 + \mathbi{b}_2 \textrm{FFN}(\mathbi{x}) &=& \textrm{max} (0,\mathbi{x}\mathbi{W}_1 + \mathbi{b}_1)\mathbi{W}_2 + \mathbi{b}_2
\label{eq:12-14} \label{eq:12-14}
...@@ -487,7 +487,7 @@ ...@@ -487,7 +487,7 @@
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item Transformer使用Adam优化器优化参数，并设置$\beta_1=0.9$，$\beta_2=0.98$，$\epsilon=10^{-9}$。 \item Transformer使用Adam优化器优化参数，并设置$\beta_1=0.9$，$\beta_2=0.98$，$\epsilon=10^{-9}$。
\item Transformer在学习率中同样应用了学习率{\small\bfnew{预热}}\index{预热}（Warmup）\index{Warmup}策略，其计算如公式\eqref{eq:12-15}所示： \item Transformer在学习率中同样应用了学习率{\small\bfnew{预热}}\index{预热}（Warmup）\index{Warmup}策略，其计算如下：
\begin{eqnarray} \begin{eqnarray}
lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \textrm{step} \cdot \textrm{warmup\_steps}^{-1.5}) lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \textrm{step} \cdot \textrm{warmup\_steps}^{-1.5})
\label{eq:12-15} \label{eq:12-15}
...@@ -589,7 +589,8 @@ Transformer Deep（48层） & 30.2 & 43.1 & 194$\times 10^ ...@@ -589,7 +589,8 @@ Transformer Deep（48层） & 30.2 & 43.1 & 194$\times 10^
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 近两年，有研究已经发现注意力机制可以捕捉一些语言现象\upcite{DBLP:journals/corr/abs-1905-09418}，比如，在Transformer 的多头注意力中，不同头往往会捕捉到不同的信息，比如，有些头对低频词更加敏感，有些头更适合词意消歧，甚至有些头可以捕捉句法信息。此外，由于注意力机制增加了模型的复杂性，而且随着网络层数的增多，神经机器翻译中也存在大量的冗余，因此研发轻量的注意力模型也是具有实践意义的方向\upcite{Xiao2019SharingAW,DBLP:journals/corr/abs-1805-00631,Lin2020WeightDT,DBLP:conf/iclr/WuLLLH20,Kitaev2020ReformerTE,DBLP:journals/corr/abs-2005-00743,dai-etal-2019-transformer,DBLP:journals/corr/abs-2004-05150,DBLP:conf/iclr/RaePJHL20}。 \item 近两年，有研究已经发现注意力机制可以捕捉一些语言现象\upcite{DBLP:journals/corr/abs-1905-09418}，比如，在Transformer 的多头注意力机制中，不同头往往会捕捉到不同的信息，比如，有些头对低频词更加敏感，有些头更适合词意消歧，甚至有些头可以捕捉句法信息。此外，由于注意力机制增加了模型的复杂性，而且随着网络层数的增多，神经机器翻译中也存在大量的冗余，因此研发轻量的注意力模型也是具有实践意义的方向\upcite{Xiao2019SharingAW,DBLP:journals/corr/abs-1805-00631,Lin2020WeightDT,DBLP:conf/iclr/WuLLLH20,Kitaev2020ReformerTE}。
\vspace{0.5em} \vspace{0.5em}
\item 神经机器翻译依赖成本较高的GPU设备，因此对模型的裁剪和加速也是很多系统研发人员所感兴趣的方向。比如，从工程上，可以考虑减少运算强度，比如使用低精度浮点数\upcite{Ott2018ScalingNM} 或者整数\upcite{DBLP:journals/corr/abs-1906-00532,Lin2020TowardsF8}进行计算，或者引入缓存机制来加速模型的推断\upcite{Vaswani2018Tensor2TensorFN}；也可以通过对模型参数矩阵的剪枝来减小整个模型的体积\upcite{DBLP:journals/corr/SeeLM16}；另一种方法是知识蒸馏\upcite{Hinton2015Distilling,kim-rush-2016-sequence}。 利用大模型训练小模型，这样往往可以得到比单独训练小模型更好的效果\upcite{DBLP:journals/corr/ChenLCL17}。 \item 神经机器翻译依赖成本较高的GPU设备，因此对模型的裁剪和加速也是很多系统研发人员所感兴趣的方向。比如，从工程上，可以考虑减少运算强度，比如使用低精度浮点数\upcite{Ott2018ScalingNM} 或者整数\upcite{DBLP:journals/corr/abs-1906-00532,Lin2020TowardsF8}进行计算，或者引入缓存机制来加速模型的推断\upcite{Vaswani2018Tensor2TensorFN}；也可以通过对模型参数矩阵的剪枝来减小整个模型的体积\upcite{DBLP:journals/corr/SeeLM16}；另一种方法是知识蒸馏\upcite{Hinton2015Distilling,kim-rush-2016-sequence}。 利用大模型训练小模型，这样往往可以得到比单独训练小模型更好的效果\upcite{DBLP:journals/corr/ChenLCL17}。
\vspace{0.5em} \vspace{0.5em}
......
Chapter13/Figures/figure-bpe.tex
...@@ -2,11 +2,11 @@ ...@@ -2,11 +2,11 @@
\tikzstyle{node} =[font=\scriptsize] \tikzstyle{node} =[font=\scriptsize]
\tikzstyle{sentence} =[font=\scriptsize,fill=blue!5!white] \tikzstyle{sentence} =[font=\scriptsize,fill=blue!5!white]
\node[sentence] (node1) at (0,0) {[`low', `lower', `newest', `widest']}; \node[sentence] (node1) at (0,0) {['low', 'lower', 'newest', 'widest']};
\node[sentence,anchor = north] (node2) at ([yshift = -1em]node1.south) {[`l o w $<$e$>$':5, `l o w e r $<$e$>$':2, `n e w e s t $<$e$>$':6, `w i d e s t $<$e$>$':3]}; \node[sentence,anchor = north] (node2) at ([yshift = -1em]node1.south) {['l o w $<$e$>$':5, 'l o w e r $<$e$>$':2, 'n e w e s t $<$e$>$':6, 'w i d e s t $<$e$>$':3]};
\node[sentence,anchor = north] (node3) at ([yshift = -1.5em]node2.south) {[`l o w $<$e$>$':5, `l o w e r $<$e$>$':2, `n e w {\red es} t $<$e$>$':6, `w i d {\red es} t $<$e$>$':3]}; \node[sentence,anchor = north] (node3) at ([yshift = -1.5em]node2.south) {['l o w $<$e$>$':5, 'l o w e r $<$e$>$':2, 'n e w {\red es} t $<$e$>$':6, 'w i d {\red es} t $<$e$>$':3]};
\node[sentence,anchor = north] (node4) at ([yshift = -1em]node3.south) {[`l o w $<$e$>$':5, `l o w e r $<$e$>$':2, `n e w {\red est} $<$e$>$':6, `w i d {\red est} $<$e$>$':3]}; \node[sentence,anchor = north] (node4) at ([yshift = -1em]node3.south) {['l o w $<$e$>$':5, 'l o w e r $<$e$>$':2, 'n e w {\red est} $<$e$>$':6, 'w i d {\red est} $<$e$>$':3]};
\node[sentence,anchor = north] (node5) at ([yshift = -1em]node4.south) {[`l o w $<$e$>$':5, `l o w e r $<$e$>$':2, `n e w {\red est$<$e$>$}':6, `w i d {\red est$<$e$>$}':3]}; \node[sentence,anchor = north] (node5) at ([yshift = -1em]node4.south) {['l o w $<$e$>$':5, 'l o w e r $<$e$>$':2, 'n e w {\red est$<$e$>$}':6, 'w i d {\red est$<$e$>$}':3]};
\node[sentence,anchor = north] (node6) at ([yshift = -1em]node5.south) {$\cdots$}; \node[sentence,anchor = north] (node6) at ([yshift = -1em]node5.south) {$\cdots$};
\node[node,anchor = north] (node7) at ([yshift = -1.6em]node6.south) {直到达到预设的子词词表大小或下一个最高频的字节对出现频率为1。}; \node[node,anchor = north] (node7) at ([yshift = -1.6em]node6.south) {直到达到预设的子词词表大小或下一个最高频的字节对出现频率为1。};
......
Chapter13/Figures/figure-computation-of-dropout.tex
...@@ -14,7 +14,7 @@ ...@@ -14,7 +14,7 @@
\node [neuronnode] (neuron_z) at (1.2 * \nodespace,-1.5 * \neuronsep) {\scriptsize{$z_{i}^{l+1}$}}; \node [neuronnode] (neuron_z) at (1.2 * \nodespace,-1.5 * \neuronsep) {\scriptsize{$z_{i}^{l+1}$}};
\node [neuronnode] (neuron_y') at (2.4 * \nodespace,-1.5 * \neuronsep) {\scriptsize{$x_{i}^{l+1}$}}; \node [neuronnode] (neuron_y') at (2.4 * \nodespace,-1.5 * \neuronsep) {\scriptsize{$x_{i}^{l+1}$}};
\node [anchor=north,ublue] (standard) at ([yshift=-4em]neuron_z.south) {\scriptsize{standard}}; \node [anchor=north,ublue] (standard) at ([yshift=-4em]neuron_z.south) {\scriptsize{标准网络}};
\node [ublue] (standard) at ([xshift=-1em]neuron_z.west) {\scriptsize{$\mathbf{w}_{i}^{l}$}}; \node [ublue] (standard) at ([xshift=-1em]neuron_z.west) {\scriptsize{$\mathbf{w}_{i}^{l}$}};
\node [ublue] (standard) at ([xshift=0.6em,yshift=0.3em]neuron_z.east) {\scriptsize{$f$}}; \node [ublue] (standard) at ([xshift=0.6em,yshift=0.3em]neuron_z.east) {\scriptsize{$f$}};
...@@ -40,7 +40,7 @@ ...@@ -40,7 +40,7 @@
\node [neuronnode] (drop_neuron_r2) at (4.4*\nodespace,-1.5*\neuronsep) {\scriptsize{$r_{2}^{l}$}}; \node [neuronnode] (drop_neuron_r2) at (4.4*\nodespace,-1.5*\neuronsep) {\scriptsize{$r_{2}^{l}$}};
\node [neuronnode] (drop_neuron_r1) at (4.4*\nodespace,-2.5*\neuronsep) {\scriptsize{$r_{1}^{l}$}}; \node [neuronnode] (drop_neuron_r1) at (4.4*\nodespace,-2.5*\neuronsep) {\scriptsize{$r_{1}^{l}$}};
\node [anchor=north,ublue] (standard) at ([yshift=-4em]drop_neuron_z.south) {\scriptsize{dropout}}; \node [anchor=north,ublue] (standard) at ([xshift=2em,yshift=-4em]drop_neuron_z.south) {\scriptsize{应用Dropout后的网络}};
\node [ublue] (standard) at ([xshift=-1em]drop_neuron_z.west) {\scriptsize{$\mathbf{w}_{i}^{l}$}}; \node [ublue] (standard) at ([xshift=-1em]drop_neuron_z.west) {\scriptsize{$\mathbf{w}_{i}^{l}$}};
\node [ublue] (standard) at ([xshift=0.6em,yshift=0.3em]drop_neuron_z.east) {\scriptsize{$f$}}; \node [ublue] (standard) at ([xshift=0.6em,yshift=0.3em]drop_neuron_z.east) {\scriptsize{$f$}};
%structure %structure
...@@ -59,10 +59,10 @@ ...@@ -59,10 +59,10 @@
\draw [-,line width=0.3mm] (drop_neuron_r1.south) -- ([yshift=-1em]drop_neuron_r1.south); \draw [-,line width=0.3mm] (drop_neuron_r1.south) -- ([yshift=-1em]drop_neuron_r1.south);
%equ %equ
\node [anchor=west,inner sep = 2pt] (line1) at (9*\nodespace,0) {未应用dropout：}; \node [anchor=west,inner sep = 2pt] (line1) at (9*\nodespace,0) {未应用Dropout：};
\node [anchor=north west,inner sep = 2pt] (line2) at (line1.south west) {$z_{i}^{l+1}=\mathbf{w}_{i}^{l} \mathbf{x}+b_{i}^{l}$}; \node [anchor=north west,inner sep = 2pt] (line2) at (line1.south west) {$z_{i}^{l+1}=\mathbf{w}_{i}^{l} \mathbf{x}+b_{i}^{l}$};
\node [anchor=north west,inner sep = 2pt] (line3) at (line2.south west) {$x_{i}^{l+1}=f\left(x_{i}^{l}\right)$}; \node [anchor=north west,inner sep = 2pt] (line3) at (line2.south west) {$x_{i}^{l+1}=f\left(x_{i}^{l}\right)$};
\node [anchor=north west,inner sep = 2pt] (line4) at (line3.south west) {应用dropout：}; \node [anchor=north west,inner sep = 2pt] (line4) at (line3.south west) {应用Dropout：};
\node [anchor=north west,inner sep = 2pt] (line5) at (line4.south west) {$r_{j}^{l} \sim$ Bernoulli $(1-p)$}; \node [anchor=north west,inner sep = 2pt] (line5) at (line4.south west) {$r_{j}^{l} \sim$ Bernoulli $(1-p)$};
\node [anchor=north west,inner sep = 2pt] (line6) at (line5.south west) {$\tilde{\mathbf{x}}=\mathbf{r} * \mathbf{x}$}; \node [anchor=north west,inner sep = 2pt] (line6) at (line5.south west) {$\tilde{\mathbf{x}}=\mathbf{r} * \mathbf{x}$};
\node [anchor=north west,inner sep = 2pt] (line7) at (line6.south west) {$z_{i}^{l+1}=\mathbf{w}_{i}^{l} \widetilde{\mathbf{x}}+b_{i}^{l}$}; \node [anchor=north west,inner sep = 2pt] (line7) at (line6.south west) {$z_{i}^{l+1}=\mathbf{w}_{i}^{l} \widetilde{\mathbf{x}}+b_{i}^{l}$};
......
Chapter13/Figures/figure-ensemble-knowledge-distillation.tex
...@@ -6,7 +6,7 @@ ...@@ -6,7 +6,7 @@
\setlength{\YShift}{0.8\base} \setlength{\YShift}{0.8\base}
\setlength{\XShift}{0.8\base} \setlength{\XShift}{0.8\base}
\tikzstyle{modelnode} = [rectangle,draw,rounded corners=2pt,inner sep=0pt,minimum height=4.2em,minimum width=2em,font=\small,anchor=north] \tikzstyle{modelnode} = [rectangle,draw,rounded corners=2pt,inner sep=0pt,minimum height=4.5em,minimum width=2em,font=\small,anchor=north]
\coordinate (stu01) at (0,0); \coordinate (stu01) at (0,0);
\coordinate (stu02) at ([xshift=3em]stu01); \coordinate (stu02) at ([xshift=3em]stu01);
...@@ -20,27 +20,27 @@ ...@@ -20,27 +20,27 @@
\foreach \curr / \prev in {1/0,2/1,3/2} \foreach \curr / \prev in {1/0,2/1,3/2}
{ {
% models % models
\node[modelnode,fill=yellow!20] (stu\curr1) at ([yshift=-2em]stu\prev1.south) {\rotatebox{90}{Student $1$}}; \node[modelnode,fill=yellow!20] (stu\curr1) at ([yshift=-2em]stu\prev1.south) {\rotatebox{90}{学生模型 $1$}};
\node[modelnode,fill=yellow!20] (stu\curr2) at ([yshift=-2em]stu\prev2.south) {\rotatebox{90}{Student $2$}}; \node[modelnode,fill=yellow!20] (stu\curr2) at ([yshift=-2em]stu\prev2.south) {\rotatebox{90}{学生模型 $2$}};
\node[modelnode,fill=yellow!20] (stu\curr3) at ([yshift=-2em]stu\prev3.south) {\rotatebox{90}{Student $3$}}; \node[modelnode,fill=yellow!20] (stu\curr3) at ([yshift=-2em]stu\prev3.south) {\rotatebox{90}{学生模型 $3$}};
\node[modelnode,fill=yellow!20] (stu\curr4) at ([yshift=-2em]stu\prev4.south) {\rotatebox{90}{Student $4$}}; \node[modelnode,fill=yellow!20] (stu\curr4) at ([yshift=-2em]stu\prev4.south) {\rotatebox{90}{学生模型 $4$}};
\node[modelnode,fill=yellow!20] (stu\curr5) at ([yshift=-2em]stu\prev5.south) {\rotatebox{90}{Student $5$}}; \node[modelnode,fill=yellow!20] (stu\curr5) at ([yshift=-2em]stu\prev5.south) {\rotatebox{90}{学生模型 $5$}};
\node[modelnode] (tea\curr1) at ([yshift=-2em]tea\prev1.south) {\rotatebox{90}{\color{red!60} Teacher $1$}}; \node[modelnode] (tea\curr1) at ([yshift=-2em]tea\prev1.south) {\rotatebox{90}{\color{red!60} 教师模型 $1$}};
\node[modelnode] (tea\curr2) at ([yshift=-2em]tea\prev2.south) {\rotatebox{90}{\color{blue!60} Teacher $2$}}; \node[modelnode] (tea\curr2) at ([yshift=-2em]tea\prev2.south) {\rotatebox{90}{\color{blue!60} 教师模型 $2$}};
% ensemble labels % 集成 labels
\draw[-latex'] ([xshift=2pt]stu\curr5.east) to node [auto] {\small Ensemble} ([xshift=-2pt]tea\curr1.west); \draw[-latex'] ([xshift=2pt]stu\curr5.east) to node [auto] {\small 集成} ([xshift=-2pt]tea\curr1.west);
} }
% iteration labels % iteration labels
\node[font=\small,anchor=east,purple!80] (iterate1) at ([xshift=-1em]stu21.west) {\rotatebox{90}{Iteration $1$}}; \node[font=\small,anchor=east,purple!80] (iterate1) at ([xshift=-1em]stu21.west) {\rotatebox{90}{轮数 $1$}};
\node[font=\small,anchor=east,purple!80] (iterate2) at ([xshift=-1em]stu31.west) {\rotatebox{90}{Iteration $2$}}; \node[font=\small,anchor=east,purple!80] (iterate2) at ([xshift=-1em]stu31.west) {\rotatebox{90}{轮数 $2$}};
% distillation labels % distillation labels
\node[font=\small,anchor=south west] (distill1) at ([yshift=0.2em]iterate1.north west) {Distillation}; \node[font=\small,anchor=south west] (distill1) at ([yshift=0.8em]iterate1.north west) {知识蒸馏};
\node[font=\small,anchor=south west] (distill2) at ([yshift=0.2em]iterate2.north west) {Distillation}; \node[font=\small,anchor=south west] (distill2) at ([yshift=0.8em]iterate2.north west) {知识蒸馏};
% student groups % 学生模型 groups
\begin{pgfonlayer}{background} \begin{pgfonlayer}{background}
\node[rectangle,draw,very thick,red!60,densely dotted,inner sep=2pt,rounded corners=2pt,fill=red!20] [fit = (stu21) (stu22) (stu23) ] (group21) {}; \node[rectangle,draw,very thick,red!60,densely dotted,inner sep=2pt,rounded corners=2pt,fill=red!20] [fit = (stu21) (stu22) (stu23) ] (group21) {};
\node[rectangle,draw,very thick,blue!60,densely dotted,inner sep=2pt,rounded corners=2pt,fill=blue!20] [fit = (stu24) (stu25) ] (group22) {}; \node[rectangle,draw,very thick,blue!60,densely dotted,inner sep=2pt,rounded corners=2pt,fill=blue!20] [fit = (stu24) (stu25) ] (group22) {};
......
Chapter13/Figures/figure-label-smoothing.tex
\begin{tikzpicture} \begin{tikzpicture}
\node[font=\scriptsize] (model) at (0,0) {Model Output:}; \node[font=\scriptsize,align=left] (model) at (0,0) {模型输出:\\（未使用\\标签平滑）};
\node[anchor=north west,font=\scriptsize] (label_smooth) at ([yshift=-1.8em]model.south west) {Label Smoothing:}; \node[anchor=north west,font=\scriptsize,align=left] (label_smooth) at ([yshift=-0.3em]model.south west) {模型输出:\\（使用标\\签平滑）};
\node[anchor=south west,font=\scriptsize] (one-hot) at ([yshift=2em]model.north west) {One-hot:}; \node[anchor=south west,font=\scriptsize] (one-hot) at ([yshift=1em]model.north west) {One-hot分布:};
%model out %model out
\node [anchor=west,minimum width=1.2em,minimum height=0.2em,fill=ublue!80,inner sep=0pt] (model_label1) at ([xshift=1.5em,yshift=-0.5em]model.east) {}; \node [anchor=west,minimum width=1.2em,minimum height=0.2em,fill=ublue!80,inner sep=0pt] (model_label1) at ([xshift=1.5em,yshift=-0.8em]model.east) {};
\node [anchor=south,font=\scriptsize] (model_w1) at (model_label1.north) {$p_{1}$}; \node [anchor=south,font=\scriptsize] (model_w1) at (model_label1.north) {$p_{1}$};
\node [anchor=south west,minimum width=1.2em,minimum height=0.1em,fill=ublue!80,inner sep=0pt] (model_label2) at (model_label1.south east) {}; \node [anchor=south west,minimum width=1.2em,minimum height=0.1em,fill=ublue!80,inner sep=0pt] (model_label2) at (model_label1.south east) {};
\node [anchor=south,font=\scriptsize] (model_w2) at (model_label2.north) {$p_{2}$}; \node [anchor=south,font=\scriptsize] (model_w2) at (model_label2.north) {$p_{2}$};
...@@ -21,7 +21,7 @@ ...@@ -21,7 +21,7 @@
\node [anchor=south west,minimum width=1.2em,minimum height=0.2em,fill=ublue!80,inner sep=0pt] (model_label7) at (model_label6.south east) {}; \node [anchor=south west,minimum width=1.2em,minimum height=0.2em,fill=ublue!80,inner sep=0pt] (model_label7) at (model_label6.south east) {};
\node [anchor=south,font=\scriptsize] (model_w8) at (model_label7.north) {$p_{7}$}; \node [anchor=south,font=\scriptsize] (model_w8) at (model_label7.north) {$p_{7}$};
%no label smooth %no label smooth
\node [anchor=west,minimum width=1.2em,minimum height=0.05em,fill=orange!50,inner sep=0pt,font=\tiny] (one_hot_label1) at ([xshift=1.5em,yshift=3em]model.east) {}; \node [anchor=west,minimum width=1.2em,minimum height=0.05em,fill=orange!50,inner sep=0pt,font=\tiny] (one_hot_label1) at ([xshift=1.5em,yshift=2.5em]model.east) {};
\node [anchor=south,font=\scriptsize] (one_hot_w1) at (one_hot_label1.north) {$0$}; \node [anchor=south,font=\scriptsize] (one_hot_w1) at (one_hot_label1.north) {$0$};
\node [anchor=south west,minimum width=1.2em,minimum height=0.05em,fill=orange!50,inner sep=0pt,font=\tiny] (one_hot_label2) at (one_hot_label1.south east) {}; \node [anchor=south west,minimum width=1.2em,minimum height=0.05em,fill=orange!50,inner sep=0pt,font=\tiny] (one_hot_label2) at (one_hot_label1.south east) {};
\node [anchor=south,font=\scriptsize] (one_hot_w2) at (one_hot_label2.north) {$0$}; \node [anchor=south,font=\scriptsize] (one_hot_w2) at (one_hot_label2.north) {$0$};
...@@ -38,7 +38,7 @@ ...@@ -38,7 +38,7 @@
\node [anchor=south,font=\scriptsize] (one_hot_w7) at (one_hot_label7.north) {$0$}; \node [anchor=south,font=\scriptsize] (one_hot_w7) at (one_hot_label7.north) {$0$};
%label smoothing %label smoothing
\node [anchor=west,minimum width=1.2em,minimum height=0.2em,fill=red!50,inner sep=0pt] (label1) at ([xshift=1.5em,yshift=-3.2em]model.east) {}; \node [anchor=west,minimum width=1.2em,minimum height=0.2em,fill=red!50,inner sep=0pt] (label1) at ([xshift=1.5em,yshift=-4.4em]model.east) {};
\node [anchor=south,font=\scriptsize] (w1) at (label1.north) {$0.1$}; \node [anchor=south,font=\scriptsize] (w1) at (label1.north) {$0.1$};
\node [anchor=south west,minimum width=1.2em,minimum height=0.2em,fill=red!50,inner sep=0pt] (label2) at (label1.south east) {}; \node [anchor=south west,minimum width=1.2em,minimum height=0.2em,fill=red!50,inner sep=0pt] (label2) at (label1.south east) {};
\node [anchor=south,font=\scriptsize] (w2) at (label2.north) {$0.1$}; \node [anchor=south,font=\scriptsize] (w2) at (label2.north) {$0.1$};
...@@ -55,18 +55,18 @@ ...@@ -55,18 +55,18 @@
\node [anchor=south,font=\scriptsize] (w8) at (label7.north) {$0.1$}; \node [anchor=south,font=\scriptsize] (w8) at (label7.north) {$0.1$};
\node[font=\scriptsize] (line1) at ([xshift=9em,yshift=-1.5em]model_label7.east) {$loss =-0.3 \log p_{3}-\sum_{i=1}^{7} 0.1 \log p_{i}$}; \node[font=\scriptsize] (line1) at ([xshift=9em,yshift=-1.5em]model_label7.east) {$Loss =-0.3 \log p_{3}-\sum_{i=1}^{7} 0.1 \log p_{i}$};
\node[font=\scriptsize] (line2) at ([xshift=5.9em,yshift=3.5em]model_label7.east) {$loss =-\log p_{3}$}; \node[font=\scriptsize] (line2) at ([xshift=5.9em,yshift=3em]model_label7.east) {$Loss =-\log p_{3}$};
\begin{pgfonlayer}{background} \begin{pgfonlayer}{background}
\node [rectangle,inner sep=0.1em,rounded corners=1pt,very thick,dotted,draw=red] [fit = (one_hot_label1) (one_hot_w3) (one_hot_label7) (model_label1) (model_label7)] (box1) {}; \node [rectangle,inner sep=0.5em,rounded corners=1pt,very thick,dotted,draw=red] [fit =(model_w3) (model_label1) (model_label7)] (box1) {};
\node [rectangle,inner sep=0.2em,rounded corners=1pt,fill=purple!10,drop shadow,draw=purple] [fit = (line2)] (box3) {}; \node [rectangle,inner sep=0.2em,rounded corners=1pt,fill=purple!10,drop shadow,draw=purple] [fit = (line2)] (box3) {};
\draw [->,dotted,very thick,red] ([yshift=-1em]box1.east) .. controls +(east:1) and +(west:1) .. (box3.west); \draw [->,dotted,very thick,red] ([yshift=-0.5em]box1.east) .. controls +(east:1) and +(west:1) .. (box3.west);
\node [rectangle,inner sep=0.1em,rounded corners=1pt,very thick,dotted,draw=ugreen] [fit = (label1) (label7) (model_label1) (model_label7) (model_w3)] (box2) {}; \node [rectangle,inner sep=0.5em,rounded corners=1pt,very thick,dotted,draw=ugreen] [fit =(w3) (label1) (label7) ] (box2) {};
\node [rectangle,inner sep=0.2em,rounded corners=1pt,fill=green!10,drop shadow,draw=ugreen] [fit = (line1)] (box4) {}; \node [rectangle,inner sep=0.2em,rounded corners=1pt,fill=green!10,drop shadow,draw=ugreen] [fit = (line1)] (box4) {};
\draw [->,dotted,very thick,ugreen] ([yshift=1em]box2.east) .. controls +(east:1) and +(west:1) .. (box4.west); \draw [->,dotted,very thick,ugreen] ([yshift=-0.5em]box2.east) .. controls +(east:1) and +(west:1) .. (box4.west);
\end{pgfonlayer} \end{pgfonlayer}
......
Chapter13/chapter13.tex
...@@ -126,7 +126,7 @@ ...@@ -126,7 +126,7 @@
\vspace{0.5em} \vspace{0.5em}
\item 对每个句子进行分词； \item 对每个句子进行分词；
\vspace{0.5em} \vspace{0.5em}
\item 将分词后的每个单词进行进一步切分，划分为字符序列。同时，在每个单词结尾添加结束符<e>用于标记单词的边界。之后，统计该单词在数据中出现的次数。例如单词low在数据中出现了5次，可以将其记为`l o w <e>:'5（{\color{red} 什么时候用单引号，什么时候用双引号}）。 \item 将分词后的每个单词进行进一步切分，划分为字符序列。同时，在每个单词结尾添加结束符<e>用于标记单词的边界。之后，统计该单词在数据中出现的次数。例如单词low在数据中出现了5次，可以将其记为‘l o w <e>’:5（{\color{red}再调一下}）。
\vspace{0.5em} \vspace{0.5em}
\item 对得到的字符集合进行统计，统计每个单词中2-gram符号出现的频次 \footnote{发生合并前，一个字符便是一个符号}。之后，选择最高频的2-gram符号，将其合并为新的符号，即新的子词。例如“A”和“B”连续出现的频次最高，则以“AB”替换所有单词内连续出现的“A”和“B”并将其加入子词词表。这样，“AB”会被作为一个整体，在之后的过程中可以与其他符号进一步合并。需要注意的是，替换和合并不会跨越单词的边界，即只对单个单词进行替换和合并。 \item 对得到的字符集合进行统计，统计每个单词中2-gram符号出现的频次 \footnote{发生合并前，一个字符便是一个符号}。之后，选择最高频的2-gram符号，将其合并为新的符号，即新的子词。例如“A”和“B”连续出现的频次最高，则以“AB”替换所有单词内连续出现的“A”和“B”并将其加入子词词表。这样，“AB”会被作为一个整体，在之后的过程中可以与其他符号进一步合并。需要注意的是，替换和合并不会跨越单词的边界，即只对单个单词进行替换和合并。
\vspace{0.5em} \vspace{0.5em}
...@@ -176,7 +176,7 @@ ...@@ -176,7 +176,7 @@
\vspace{0.5em} \vspace{0.5em}
\item 子词规范化方法\upcite{DBLP:conf/acl/Kudo18}。其思想是在训练过程中扰乱确定的子词边界，根据1-gram Language Model{\red （ULM）}采样出多种子词切分候选。通过最大化整个句子的概率为目标构建词表。在实现上，与上述基于Word Piece的方法略有不同，这里不做详细介绍。 \item 子词规范化方法\upcite{DBLP:conf/acl/Kudo18}。其思想是在训练过程中扰乱确定的子词边界，根据1-gram Language Model{\red （ULM）}采样出多种子词切分候选。通过最大化整个句子的概率为目标构建词表。在实现上，与上述基于Word Piece的方法略有不同，这里不做详细介绍。
\vspace{0.5em} \vspace{0.5em}
\item BPE-Dropout\upcite{provilkov2020bpe}。在训练时，通过在合并过程中按照一定概率$p${\red（这个p能不能改成P）}{\color{blue} 改成P是不是和概率函数的符号就混淆了？}（介于0与1之间）随机丢弃一些可行的合并操作，从而产生不同的子词切分结果，进而增强模型健壮性。而在推断阶段，将$p$设置为0，等同于标准的BPE。总的来说，上述方法相当于在子词的粒度上对输入的序列进行扰动，进而达到增加训练健壮性的目的。 \item BPE-Dropout\upcite{provilkov2020bpe}。在训练时，通过在合并过程中按照一定概率$p$（介于0与1之间）随机丢弃一些可行的合并操作，从而产生不同的子词切分结果，进而增强模型健壮性。而在推断阶段，将$p$设置为0，等同于标准的BPE。总的来说，上述方法相当于在子词的粒度上对输入的序列进行扰动，进而达到增加训练健壮性的目的。
\vspace{0.5em} \vspace{0.5em}
\item DPE\upcite{he2020dynamic}。引入了混合字符-子词的切分方式，将句子的子词分割方式看作一种隐含变量，该结构能够利用动态规划精确地将潜在的子字片段边缘化（{\color{red} 啥叫边缘化？？？}）。解码端的输入是基于字符表示的目标语序列，推断时将每个时间步的输出映射到预先设定好的子词词表之上，得到当前最可能得子词结果。若当前子词长度为$m$，则接下来的$m$个时间步的输入为该子词，并在$m$个时间步后得到下一个切分的子词。 \item DPE\upcite{he2020dynamic}。引入了混合字符-子词的切分方式，将句子的子词分割方式看作一种隐含变量，该结构能够利用动态规划精确地将潜在的子字片段边缘化（{\color{red} 啥叫边缘化？？？}）。解码端的输入是基于字符表示的目标语序列，推断时将每个时间步的输出映射到预先设定好的子词词表之上，得到当前最可能得子词结果。若当前子词长度为$m$，则接下来的$m$个时间步的输入为该子词，并在$m$个时间步后得到下一个切分的子词。
\vspace{0.5em} \vspace{0.5em}
...@@ -199,7 +199,7 @@ y &=& f(x) ...@@ -199,7 +199,7 @@ y &=& f(x)
\parinterval 理想的情况下，我们希望反问题的解是{\small\bfnew{适定的}}\index{适定的}（Well-posed）\index{Well-posed}。所谓适定解，需要满足三个条件：解是存在的、解是唯一的、解是稳定的（即$y$微小的变化会导致$x$微小的变化，也被称作解连续）。所有不存在唯一稳定解的问题都被称作{\small\bfnew{不适定问题}}\index{不适定问题}（Ill-posed Problem）\index{Ill-posed Problem}。对于机器学习问题，解的存在性比较容易理解。解的唯一性大多由问题决定。比如，如果把描述问题的函数$f(\cdot)$看作一个$n\times n$矩阵$\mathbf{A}$，$x$和$y$都看作是$n$维向量。那么$x$不唯一的原因在于$\mathbf{A}$不满秩（非奇异矩阵）。不过，存在性和唯一性并不会对机器学习方法造成太大困扰，因为在实践中往往会找到近似的解。 \parinterval 理想的情况下，我们希望反问题的解是{\small\bfnew{适定的}}\index{适定的}（Well-posed）\index{Well-posed}。所谓适定解，需要满足三个条件：解是存在的、解是唯一的、解是稳定的（即$y$微小的变化会导致$x$微小的变化，也被称作解连续）。所有不存在唯一稳定解的问题都被称作{\small\bfnew{不适定问题}}\index{不适定问题}（Ill-posed Problem）\index{Ill-posed Problem}。对于机器学习问题，解的存在性比较容易理解。解的唯一性大多由问题决定。比如，如果把描述问题的函数$f(\cdot)$看作一个$n\times n$矩阵$\mathbf{A}$，$x$和$y$都看作是$n$维向量。那么$x$不唯一的原因在于$\mathbf{A}$不满秩（非奇异矩阵）。不过，存在性和唯一性并不会对机器学习方法造成太大困扰，因为在实践中往往会找到近似的解。
\parinterval 但是，解的稳定性却给神经机器翻译带来了很大的挑战。因为神经机器翻译模型非常复杂，里面存在大量的矩阵乘法和非线性变化。这导致$f(\cdot)$往往是不稳定的，也就是说，神经机器翻译中输出$y$ 的微小变化会导致输入$x$的巨大变化。比如，在系统研发中经常会发现，即使训练样本发生很小的变化，模型训练得到的参数都会有非常明显的区别。不仅如此，神经机器翻译模型参数解的稳定性还存在两方面问题： \parinterval 但是，解的稳定性却给神经机器翻译带来了很大的挑战。因为神经机器翻译模型非常复杂，里面存在大量的矩阵乘法和非线性变换。这导致$f(\cdot)$往往是不稳定的，也就是说，神经机器翻译中输出$y$的微小变化会导致输入$x$的巨大变化。比如，在系统研发中经常会发现，即使训练样本发生很小的变化，模型训练得到的参数都会有非常明显的区别。不仅如此，在神经机器翻译模型中，参数的解的稳定性还存在两方面问题：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
...@@ -209,7 +209,7 @@ y &=& f(x) ...@@ -209,7 +209,7 @@ y &=& f(x)
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 以上问题体现出来的现象就是过拟合。因为训练数据有限同时存在噪声，因此模型参数会过分拟合噪声数据。而且，这样的模型参数又与真实（理想）的模型参数相差很远。正则化正是针对这个问题。有时候，正则化也被称作{\small\bfnew{降噪}}\index{降噪}（Denoising）\index{Denoising}，虽然它的出发点并不只是去除噪声的影响。图\ref{fig:13-11}对比了不同函数对二维空间中一些数据点的拟合情况。在过拟合现象中，函数可以完美的拟合所有的数据点，即使有些数据点是噪声。 \parinterval 以上问题体现出来的现象就是过拟合。因为训练数据有限且存在噪声，因此模型参数会过分拟合噪声数据。而且，这样的模型参数又与真实（理想）的模型参数相差很远。正则化正是针对这个问题。有时候，正则化也被称作{\small\bfnew{降噪}}\index{降噪}（Denoising）\index{Denoising}，虽然它的出发点并不只是去除噪声的影响。图\ref{fig:13-11}对比了不同函数对二维空间中一些数据点的拟合情况。在过拟合现象中，函数可以完美的拟合所有的数据点，即使有些数据点是噪声。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -250,9 +250,9 @@ R(\mathbf{w}) & = & (\big| |\mathbf{w}| {\big|}_2)^2 \\ ...@@ -250,9 +250,9 @@ R(\mathbf{w}) & = & (\big| |\mathbf{w}| {\big|}_2)^2 \\
\label{eq:13-4} \label{eq:13-4}
\end{eqnarray} \end{eqnarray}
\parinterval 从几何的角度看，L1和L2正则项都是有物理意义的。二者都可以被看作是空间上的一个区域，比如，在二维平面上，L1范数表示一个以0点为中心的矩形，L2范数表示一个以0点为中心的圆。因此，优化问题可以被看作是在两个区域（$L(\mathbf{w})$和$R(\mathbf{w})$）叠加在一起所形成的区域上进行优化。由于L1和L2正则项都是在0点（坐标原点）附近形成的区域，因此优化的过程可以确保参数不会偏离0点太多。也就是说，L1和L2正则项引入了一个先验：模型的解不应该离0点太远。而L1和L2正则项实际上是在度量这个距离。 \parinterval 从几何的角度看，L1和L2正则项都是有物理意义的。二者都可以被看作是空间上的一个区域，比如，在二维平面上，L1范数表示一个以0点为中心的矩形，L2范数表示一个以0点为中心的圆。此时，$L(\mathbf{w})$和$R(\mathbf{w})$叠加在一起构成了一个新的区域，优化问题可以被看作是在这个新的区域上进行优化。由于L1和L2正则项都是在0点（坐标原点）附近形成的区域，因此优化的过程可以确保参数不会偏离0点太多。也就是说，L1和L2正则项引入了一个先验：模型的解不应该离0点太远。而L1和L2正则项实际上是在度量这个距离。
\parinterval 那为什么要用L1和L2正则项惩罚离0点远的解呢？这还要从模型复杂度谈起。实际上，对于神经机器翻译这样的模型来说，模型的容量是足够的。所谓容量可以被简单的理解为独立参数的个数 \footnote{简单理解，模型的容量是指神经网络的参数量，即神经元之间连接权重的个数。另一种定义是把容量看作神经网络所能表示的假设空间大小\upcite{DBLP:journals/nature/LeCunBH15}，也就是神经网络能表示的不同函数所构成的空间。}。也就是说，理论上存在一种模型可以完美的描述问题。但是，从目标函数拟合的角度来看，如果一个模型可以拟合很复杂的目标函数，那模型所表示的函数形态也会很复杂。这往往体现在模型中参数的值“偏大”。比如，用一个多项式函数拟合一些空间中的点，如果希望拟合得很好，各个项的系数往往是非零的。而且为了对每个点进行拟合，通常需要多项式中的某些项具有较大的系数，以获得函数在局部有较大的斜率。显然，这样的模型是很复杂的。而模型的复杂度可以用函数中的参数（比如多项式中各项的系数）的“值”进行度量，体现出来就是模型参数的范数。 \parinterval 那为什么要用L1和L2正则项惩罚离0点远的解呢？这还要从模型复杂度谈起。实际上，对于神经机器翻译这样的模型来说，模型的容量是足够的。所谓容量可以被简单的理解为独立参数的个数 \footnote{简单理解，模型的容量是指神经网络的参数量，即神经元之间连接权重的个数。另一种定义是把容量看作神经网络所能表示的假设空间大小\upcite{DBLP:journals/nature/LeCunBH15}，也就是神经网络能表示的不同函数所构成的空间。}。也就是说，理论上存在一种模型可以完美的描述问题。但是，从目标函数拟合的角度来看，如果一个模型可以拟合很复杂的目标函数，那模型所表示的函数形态也会很复杂。这往往体现在模型中参数的值“偏大”。比如，用一个多项式函数拟合一些空间中的点，如果希望拟合得很好，各个项的系数往往是非零的。而且为了对每个点进行拟合，通常需要多项式中的某些项具有较大的系数，以期望函数在局部有较大的斜率。显然，这样的模型是很复杂的。模型的复杂度可以用函数中的参数（比如多项式中各项的系数）的“值”进行度量，这也体现在模型参数的范数上。
\parinterval 因此，L1和L2正则项的目的是防止模型为了匹配少数（噪声）样本而导致模型的参数过大。反过来说，L1和L2正则项会鼓励那些参数值在0点附近的情况。从实践的角度看，这种方法可以很好的对统计模型的训练进行校正，得到泛化能力更强的模型。 \parinterval 因此，L1和L2正则项的目的是防止模型为了匹配少数（噪声）样本而导致模型的参数过大。反过来说，L1和L2正则项会鼓励那些参数值在0点附近的情况。从实践的角度看，这种方法可以很好的对统计模型的训练进行校正，得到泛化能力更强的模型。
...@@ -262,15 +262,15 @@ R(\mathbf{w}) & = & (\big| |\mathbf{w}| {\big|}_2)^2 \\ ...@@ -262,15 +262,15 @@ R(\mathbf{w}) & = & (\big| |\mathbf{w}| {\big|}_2)^2 \\
\subsection{标签平滑} \subsection{标签平滑}
\parinterval 神经机器翻译在每个目标语位置$j$会输出一个分布$y_j$，这个分布描述了每个目标语言单词出现的可能性。在训练时，每个目标语言位置上的答案是一个单词，也就对应了One-hot分布$\tilde{y}_j$，它仅仅在正确答案那一维为1，其它维均为0。模型训练可以被看作是一个调整模型参数让$y_j$逼近$\tilde{y}_j$的过程。但是，$\tilde{y}_j$的每一个维度是一个非0即1的目标，这样也就无法考虑类别之间的相关性。具体来说，除非模型在答案那一维输出1，否则都会得到惩罚。即使模型把一部分概率分配给与答案相近的单词（比如同义词），这个相近的单词仍被视为完全错误的预测。 \parinterval 神经机器翻译在每个目标语位置$j$会输出一个分布$\mathbf{y}_j$，这个分布描述了每个目标语言单词出现的可能性。在训练时，每个目标语言位置上的答案是一个单词，也就对应了One-hot分布$\tilde{\mathbf{y}}_j$，它仅仅在正确答案那一维为1，其它维均为0。模型训练可以被看作是一个调整模型参数让$\mathbf{y}_j$逼近$\tilde{\mathbf{y}}_j$的过程。但是，$\tilde{\mathbf{y}}_j$的每一个维度是一个非0即1的目标，这样也就无法考虑类别之间的相关性。具体来说，除非模型在答案那一维输出1，否则都会得到惩罚。即使模型把一部分概率分配给与答案相近的单词（比如同义词），这个相近的单词仍被视为完全错误的预测。
\parinterval {\small\bfnew{标签平滑}}\index{标签平滑}（Label Smoothing）\index{Label Smoothing}的思想很简单\upcite{Szegedy_2016_CVPR}：答案所对应的单词不应该“独享”所有的概率，其它单词应该有机会作为答案。这个观点与第二章中语言模型的平滑非常类似。在复杂模型的参数估计中，往往需要给未见或者低频事件分配一些概率，以保证模型具有更好的泛化能力。具体实现时，标签平滑使用了一个额外的分布$q$，它是在词汇表$V$ 上的一个均匀分布，即$q(k)=\frac{1}{|V|}$，其中$q(k)$表示分布的第$k$维。然后，答案分布被重新定义为$\tilde{y}_j$和$q$的线性插值： \parinterval {\small\bfnew{标签平滑}}\index{标签平滑}（Label Smoothing）\index{Label Smoothing}的思想很简单\upcite{Szegedy_2016_CVPR}：答案所对应的单词不应该“独享”所有的概率，其它单词应该有机会作为答案。这个观点与{\chaptertwo}中语言模型的平滑非常类似。在复杂模型的参数估计中，往往需要给未见或者低频事件分配一些概率，以保证模型具有更好的泛化能力。具体实现时，标签平滑使用了一个额外的分布$\mathbf{q}$，它是在词汇表$V$ 上的一个均匀分布，即$\mathbf{q}(k)=\frac{1}{|V|}$，其中$\mathbf{q}(k)$表示分布的第$k$维。然后，答案分布被重新定义为$\tilde{\mathbf{y}}_j$和$\mathbf{q}$的线性插值：
\begin{eqnarray} \begin{eqnarray}
y_{j}^{ls} &=& (1-\alpha) \cdot \tilde{y}_j + \alpha \cdot q \mathbf{y}_{j}^{ls} &=& (1-\alpha) \cdot \tilde{\mathbf{y}}_j + \alpha \cdot \mathbf{q}
\label{eq:13-5} \label{eq:13-5}
\end{eqnarray} \end{eqnarray}
\noindent 这里，$\alpha$表示一个系数，用于控制分布$q$的重要性。$y_{j}^{ls}$会被作为最终的答案分布用于模型的训练。 \noindent 这里，$\alpha$表示一个系数，用于控制分布$\mathbf{q}$的重要性。$\mathbf{y}_{j}^{ls}$会被作为最终的答案分布用于模型的训练。
\parinterval 标签平滑实际上定义了一种“软”标签，使得所有标签都可以分到一些概率。一方面可以缓解数据中噪声的影响，另一方面目标分布会更合理（显然，真实的分布不应该是One-hot分布）。图\ref{fig:13-12}展示了标签平滑前后的损失函数计算结果的对比。 \parinterval 标签平滑实际上定义了一种“软”标签，使得所有标签都可以分到一些概率。一方面可以缓解数据中噪声的影响，另一方面目标分布会更合理（显然，真实的分布不应该是One-hot分布）。图\ref{fig:13-12}展示了标签平滑前后的损失函数计算结果的对比。
...@@ -283,7 +283,7 @@ y_{j}^{ls} &=& (1-\alpha) \cdot \tilde{y}_j + \alpha \cdot q ...@@ -283,7 +283,7 @@ y_{j}^{ls} &=& (1-\alpha) \cdot \tilde{y}_j + \alpha \cdot q
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 标签平滑也可以被看作是对损失函数的一种调整，并引入了额外的先验知识（即与$q$相关的部分）。只不过这种先验知识并不是通过线性插值的方式与原始损失函数进行融合（公式\ref{eq:13-2}）。 \parinterval 标签平滑也可以被看作是对损失函数的一种调整，并引入了额外的先验知识（即与$\mathbf{q}$相关的部分）。只不过这种先验知识并不是通过线性插值的方式与原始损失函数进行融合（公式\ref{eq:13-2}）。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
...@@ -291,7 +291,7 @@ y_{j}^{ls} &=& (1-\alpha) \cdot \tilde{y}_j + \alpha \cdot q ...@@ -291,7 +291,7 @@ y_{j}^{ls} &=& (1-\alpha) \cdot \tilde{y}_j + \alpha \cdot q
\subsection{Dropout} \subsection{Dropout}
\parinterval 神经机器翻译模型是一种典型的多层神经网络模型。每一层都包含若干神经元，负责接收前一层所有神经元的输出，并进行诸如乘法、加法等变换，并有选择的使用非线性的激活函数，最终得到当前层每个神经元的输出。从模型最终预测的角度看，每个神经元都在参与最终的预测。理想的情况下，我们希望每个神经元都能相互独立的做出“贡献”。这样的模型会更加健壮，因为即使一部分神经元不能正常工作，其它神经元仍然可以独立做出合理的预测。但是，随着每一层神经元数量的增加以及网络结构的复杂化，神经元之间会出现{\small\bfnew{相互适应}}\index{相互适应}（Co-Adaptation）\index{Co-Adaptation}的现象。所谓相互适应是指，一个神经元对输出的贡献与同一层其它神经元的行为是相关的，也就是说这个神经元已经适应到它周围的“环境”中。 \parinterval 神经机器翻译模型是一种典型的多层神经网络模型。每一层都包含若干神经元，负责接收前一层所有神经元的输出，之后进行诸如乘法、加法等变换操作，并有选择地使用非线性的激活函数，最终得到当前层每个神经元的输出。从模型最终预测的角度看，每个神经元都在参与最终的预测。理想的情况下，我们希望每个神经元都能相互独立的做出“贡献”。这样的模型会更加健壮，因为即使一部分神经元不能正常工作，其它神经元仍然可以独立做出合理的预测。但是，随着每一层神经元数量的增加以及网络结构的复杂化，神经元之间会出现{\small\bfnew{相互适应}}\index{相互适应}（Co-Adaptation）\index{Co-Adaptation}的现象。所谓相互适应是指，一个神经元对输出的贡献与同一层其它神经元的行为是相关的，也就是说这个神经元已经适应到它周围的“环境”中。
\parinterval 相互适应的好处在于神经网络可以处理更加复杂的问题，因为联合使用两个神经元要比单独使用每个神经元的表示能力强。这也类似于传统机器学习任务中往往会设计一些高阶特征，比如自然语言序列标注中对2-gram和3-gram的使用。不过另一方面，相互适应会导致模型变得更加“脆弱”。因为相互适应的神经元可以更好的描述训练数据中的现象，但是在测试数据上，由于很多现象是未见的，细微的扰动会导致神经元无法适应。具体体现出来就是过拟合问题。 \parinterval 相互适应的好处在于神经网络可以处理更加复杂的问题，因为联合使用两个神经元要比单独使用每个神经元的表示能力强。这也类似于传统机器学习任务中往往会设计一些高阶特征，比如自然语言序列标注中对2-gram和3-gram的使用。不过另一方面，相互适应会导致模型变得更加“脆弱”。因为相互适应的神经元可以更好的描述训练数据中的现象，但是在测试数据上，由于很多现象是未见的，细微的扰动会导致神经元无法适应。具体体现出来就是过拟合问题。
...@@ -306,7 +306,7 @@ y_{j}^{ls} &=& (1-\alpha) \cdot \tilde{y}_j + \alpha \cdot q ...@@ -306,7 +306,7 @@ y_{j}^{ls} &=& (1-\alpha) \cdot \tilde{y}_j + \alpha \cdot q
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 具体实现时，可以设置一个参数$p\in (0,1)$。在每次参数更新所使用的前向和反向计算中，每个神经元都以概率$p$停止工作。相当于每层神经网络会有以$p$为比例的神经元被“屏蔽”掉。每一次参数更新中会随机屏蔽不同的神经元。图\ref{fig:13-14}给出了Dropout方法和传统方法计算方式的对比。 \parinterval 具体实现时，可以设置一个参数$p \in (0,1)$。在每次参数更新所使用的前向和反向计算中，每个神经元都以概率$p$停止工作。相当于每层神经网络会有以$p$为比例的神经元被“屏蔽”掉。每一次参数更新中会随机屏蔽不同的神经元，图\ref{fig:13-14}给出了Dropout方法和传统方法计算方式的对比。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -330,7 +330,7 @@ y_{j}^{ls} &=& (1-\alpha) \cdot \tilde{y}_j + \alpha \cdot q ...@@ -330,7 +330,7 @@ y_{j}^{ls} &=& (1-\alpha) \cdot \tilde{y}_j + \alpha \cdot q
\sectionnewpage \sectionnewpage
\section{对抗样本训练} \section{对抗样本训练}
\parinterval 同其它基于神经网络的方法一样，提高{\small\bfnew{健壮性}}\index{健壮性}（Robustness）\index{Robustness}也是神经机器翻译研发中需要关注的。比如，大容量模型可以很好的拟合训练数据，但是当测试样本与训练样本差异较大时，会导致很糟糕的翻译结果\upcite{JMLR:v15:srivastava14a,DBLP:conf/amta/MullerRS20}。另一方面，实践中也发现，有些情况下即使输入中有微小的扰动，神经网络模型的输出也会产生巨大变化。或者说，神经网络模型在输入样本上容易受到{\small\bfnew{攻击}}\index{攻击}（Attack）\index{Attack}\upcite{DBLP:conf/sp/Carlini017,DBLP:conf/cvpr/Moosavi-Dezfooli16,DBLP:conf/acl/ChengJM19}。图\ref{fig:13-19}展示了一个神经机器翻译系统的翻译结果，可以看到，把输入句子中的单词“他”换成“她”会得到完全不同的译文。这时神经机器翻译系统就存在健壮性问题。 \parinterval 同其它基于神经网络的方法一样，提高{\small\bfnew{健壮性}}\index{健壮性}（Robustness）\index{Robustness}也是神经机器翻译研发中需要关注的。比如，大容量模型可以很好的拟合训练数据，但是当测试样本与训练样本差异较大时，会导致很糟糕的翻译结果\upcite{JMLR:v15:srivastava14a,DBLP:conf/amta/MullerRS20}。另一方面，实践中也发现，有些情况下即使输入中有微小的扰动，神经网络模型的输出也会产生巨大变化。或者说，神经网络模型在输入样本上容易受到{\small\bfnew{攻击}}\index{攻击}（Attack）\index{Attack}\upcite{DBLP:conf/sp/Carlini017,DBLP:conf/cvpr/Moosavi-Dezfooli16,DBLP:conf/acl/ChengJM19}。图\ref{fig:13-19}展示了一个神经机器翻译系统的翻译结果，可以看到，把输入句子中的单词“他”换成“她”会得到完全不同的译文。这时神经机器翻译系统就存在健壮性问题。a
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -438,11 +438,33 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\ ...@@ -438,11 +438,33 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\sectionnewpage \sectionnewpage
\section{高级模型训练技术} \section{高级模型训练技术}
\parinterval 在神经机器翻译中，经常会使用极大似然估计对模型进行训练。尽管这种方法取得了巨大的成功，但是极大似然估计并不是一种完美的目标函数，它也面临着许多问题。比如，由于极大似然估计并不是用来评价翻译系统性能的指标，这使得即使在极大似然估计中获得了更低的损失，但是在实际的性能评价指标上却不一定会产生更好的结果。针对极大似然估计的问题，研究人员提出了许多不同方法。下面章节我们首先会对极大似然估计的问题进行论述，然后介绍解决对应问题的多种方法。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\subsection{极大似然估计的问题} \subsection{极大似然估计的问题}\label{subsec-15.3.1}
\parinterval 近几十年来，极大似然估计已成为机器翻译训练中使用最广泛的目标函数。但是，用极大似然估计进行训练存在曝光偏置问题和训练解码评价指标不一致问题，这可能导致在解码阶段模型性能下降：
\begin{itemize}
\vspace{0.5em}
\item 曝光偏置问题：{\red 在训练过程中，模型使用真实数据进行训练，因此模型在预测一个句子中的下一个单词时，解码器端的输入服从于真实数据的分布（改的对不对）}。但是在解码过程中，模型则会根据先前的预测结果来生成下一个词，此时模型输入所服从的分布在训练和解码中不一致，如图\ref{fig:13-21}所示。由于在训练过程中暴露于真实数据，模型可能会偏向于仅在具有真实数据的情况下才能表现良好，这就是曝光偏置问题\upcite{Bengio2015ScheduledSF,Ranzato2016SequenceLT}。{\red（转录时，w改为y，并在图中补充：$y_1,y_2,y_3,…, y_V$表示词表里的V个词）}
\vspace{0.5em}
%----------------------------------------------
\begin{figure}[htp]
\centering
\includegraphics[scale=1]{./Chapter13/Figures/figure-exposure-bias.png}
\caption{曝光偏置问题}
\label{fig:13-21}
\end{figure}
%----------------------------------------------
\item 训练解码评价指标不一致问题：{\red 在训练过程中，使用极大似然估计最大化训练集数据的概率（感觉说的有点奇怪）}，而在解码的时候，通常使用如BLEU等外部评价指标来评价模型的性能。理想的情况下，模型应该直接最大化模型性能评价指标而不是{\red 概率（什么概率）}，但是因为这些指标通常不可导，这使得我们无法直接利用反向传播来优化神经网络，因此在训练时我们只能使用概率作为实际评价指标的替代，这样就会导致训练解码评价指标不一致问题。在机器翻译任务中，这个问题的一个后果就是，更低的困惑度不一定能提高BLEU。
\vspace{0.5em}
\end{itemize}
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
...@@ -450,12 +472,194 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\ ...@@ -450,12 +472,194 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\subsection{非teacher-forcing方法} \subsection{非teacher-forcing方法}
\parinterval 所谓teacher-forcing，即要求模型生成的翻译和{\small\bfnew{标准答案}}\index{标准答案}（Ground Truth）\index{Ground Truth}完全对应。teacher-forcing是一种网络训练方法，对开发机器翻译、文本摘要和图像字幕的深度学习语言模型以及许多其他应用程序至关重要。使用这种方法，模型在训练时每次不是使用上一个时刻的输出作为下一个时刻的输入，而是使用训练数据中的标准答案作为下一个时刻的输入。尽管这一方法可以强制约束模型的翻译结果，加快收敛。但是这也会导致在训练阶段和解码{\red（推断？）}阶段中，模型的输入所服从的分布不一致，也就是曝光偏置问题。为了解决以上问题，研究人员提出非teacher-forcing方法，其中主要包括调度采样和生成对抗网络。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{1. 调度采样}
\parinterval 对于曝光偏置问题，一般可以使用束搜索等启发式搜索方法来进行缓解。但是即使使用束搜索，最终得到的有效序列数量仍然很小，仍然无法解决训练和解码不一致问题。
\parinterval 对于一个目标序列$\seq{y}=\{\mathbi{y}_1,\mathbi{y}_2,\ldots,\mathbi{y}_n\}$，在预测第$t$个单词$\mathbi{y}_t$时，训练过程与解码过程之间的主要区别在于：训练过程中使用真实的先前单词$\mathbi{y}_{t-1}$，而解码过程使用的是来自模型本身的估计$\hat{\mathbi{y}}_{t-1}$。此时可以采取一种调度采样机制，在训练期间随机决定使用$\mathbi{y}_{t-1}$还是$\hat{\mathbi{y}}_{t-1}$。假设训练时使用的是基于小批量{\red （批次？）}的随机梯度下降方法，对于每个预测训练算法的第$i$个小批量的$\mathbi{y}_t \in \textrm{Y}${\red (Y格式对不对，Y没解释)}，随机以概率$\epsilon_i$使用先前真实答案或以概率${(1-\epsilon_i)}^2$使用来自模型本身的估计。该模型的估计可以根据由$\funp{P}(\mathbi{y}_{t-1}|\mathbi{h}_{t-1})$建模的概率分布对单词进行采样来获得，也可以作为$\arg\max_s \funp{P}(\mathbi{y}_{t-1} = s|\mathbi{h}_{t-1})$，此过程如图\ref{fig:13-22}所示。{\red（上句难理解，s没解释，s是向量？）}
%----------------------------------------------
\begin{figure}[htp]
\centering
\includegraphics[scale=1]{./Chapter13/Figures/figure-of-scheduling-sampling-method.png}
\caption{“调度采样”方法的示意图}
\label{fig:13-22}
\end{figure}
%----------------------------------------------
\parinterval 当$\epsilon_i=1$时，模型的训练与以前完全相同，而当$\epsilon_i=0$时，{\red 模型的训练与解码时使用的设置相同（改的对吗）}。在这里使用到了一种{\small\bfnew{课程学习}}\index{课程学习}(curriculum learning)\index{curriculum learning}策略，该策略认为应从一种学习策略过渡到另一种学习策略：{\red 在训练开始时，由于模型训练不足，因此从模型中会采样产生随机单词，这可能会导致收敛速度非常慢，因此，经常选择真正的先前单词$yt−1$通常会有所帮助；另一方面，在训练结束时，$\epsilon_i$应该更倾向于使用来自模型本身的估计$\hat{\mathbi{y}}_{t-1}$，因为这与真实的推理情况相对应。（看不懂）}
\parinterval 在使用调度策略时，需要调整关于$i$的函数来降低$\epsilon_i$，与梯度下降方法中降低学习率的方式相似，调度策略可以采取如下几种方式{\red （调度策略、i、epslon什么关系？）}：
{\red （下面最后一句重复，而且没明白想表达什么）}
\begin{itemize}
\vspace{0.5em}
\item 线性衰减：$\epsilon_i = \max⁡(\epsilon,k-ci)${\red （ci中i是什么意思，c不是个常数？）}，其中$0 \leqslant \epsilon < 1$，是要提供给模型的最小数值，而k和c提供衰减的偏移量和斜率，取决于预期的收敛速度。
\vspace{0.5em}
\item 指数衰减：$\epsilon_i = k^i$，其中$k$是一个常数，一般为$k < 1$，取决于预期的收敛速度。
\vspace{0.5em}
\item 反向sigmoid 衰减：$ϵ_i=k/(k+exp⁡(i/k))$，其中$k≥1$，取决于预期的收敛速度。
\vspace{0.5em}
\end{itemize}
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{2. 生成对抗网络}
\parinterval {\red（前面讲了一点GAN）}与人工翻译相比，{\red 极大似然估计的优化目标是假设能够最大化标准答案的可能性（这种描述有点绕）}，但由于曝光偏置问题会导致训练和解码的不一致，因此这个{\red 假设}不一定成立。而{\small\bfnew{生成对抗网络}}\index{生成对抗网络}（Generative Adversarial Networks\index{Generative Adversarial Networks}，GAN）的优化目标{\red 不是最大化标准答案的可能性，而是最大化标准答案和模型预测结果的相似性，因此可以解决曝光偏置问题。}
\parinterval 生成对抗网络采用了对抗的训练架构并将其命名为{\small\bfnew{对抗神经机器翻译}}\index{对抗神经机器翻译}（Adversarial-NMT）\index{Adversarial-NMT}，其总体框架如图\ref{fig:13-23}所示，{\red 其中“Ref”是“Reference”的缩写，表示标准答案，而“ Hyp”是“Hypothesis”的缩写，表示模型翻译句子结果（准备直接吧图中英文改为中文）}。所有黄色部分表示神经机器翻译模型G{\red （看下15章的模型）}，该模型将源语言句子$\seq{x}$映射为目标语言句子。红色部分是对抗网络D，该网络预测目标语言句子是否是源语言句子$\seq{x}$的真实翻译。G和D相互对抗，同时生成{\red 采样翻译}$\seq{y}'$来训练D，以及生成奖励信号来通过策略梯度训练G。
%----------------------------------------------
\begin{figure}[htp]
\centering
\includegraphics[scale=1]{./Chapter13/Figures/figure-framework-of-Adversarial-Neural-machine-translation.png}
\caption{对抗神经机器翻译框架图}
\label{fig:13-23}
\end{figure}
%----------------------------------------------
\parinterval 对于用于训练的双语句对$(\seq{x}=\{\mathbi{x}_1,\mathbi{x}_2,\ldots,\mathbi{x}_m\},\seq{y}=\{\mathbi{y}_1,\mathbi{y}_2,\ldots,\mathbi{y}_n\})$，其中$\mathbi{x}_i$是源句子中的第$i$个单词，$\mathbi{y}_j$是目标句子中的第$j$个单词。令$\seq{y}'$表示神经机器翻译系统对源语言句子$\mathbi{x}$的解码结果。实际上，对抗神经机器翻译的训练目标就是强制$\seq{y}'$与$\seq{y}$相似。在理想情况下，$\seq{y}'$与人类的翻译结果$\seq{y}$非常相似，以至于人类也无法分辨$\seq{y}'$是由机器还是人类产生的。为了实现这一目标，需要引入一个额外的对抗网络\upcite{DBLP:conf/nips/GoodfellowPMXWOCB14}。该对抗网络的目标是将人类翻译与机器翻译区分开来，神经机器翻译模型G试图产生类似于人类翻译的目标句子，以欺骗对抗网络。
\parinterval 在对抗神经机器翻译中，原始的神经机器翻译模型为生成网络，其训练由一个对抗网络协助。对抗网络的目的是将神经机器翻译模型生成的翻译结果与人的翻译结果区分开，而生成网络的目标是产生高质量的翻译，以欺骗对抗网络。生成网络和对抗网络作为对手，由策略梯度方法来共同训练。{\red 为了使得生成网络和对抗网络能够提高彼此性能，可以通过学习人为产生的正例和从神经机器翻译取得的负例来提高对手的辨别力，通过将对手的输出作为反馈来提高神经机器翻译模型欺骗对手的能力。通过这种方式，神经机器翻译的结果可以尽可能接近真实答案。（句子太长）}
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\subsection{增强学习方法} \subsection{增强学习方法}
\parinterval 增强学习方法可以同时解决\ref{subsec-15.3.1}提到的曝光偏置问题和训练解码评价指标不一致问题，本节中涉及到的方法主要包括基于策略的增强学习方法和基于演员-评论家的增强学习方法。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{1. 基于策略的增强学习方法}
\parinterval 与传统的极大似然估计不同，{\small\bfnew{最小风险训练}}\index{最小风险训练}（Minimum Risk Training\index{Minimum Risk Training}，MRT）方法引入了评价指标作为损失函数，{\red 目标是将训练数据在测试数据上的预期损失降至最低}\upcite{DBLP:conf/acl/ShenCHHWSL16}。
\parinterval MRT的训练目标是最小化训练数据上的风险，风险定义为相对于后验分布的预期损失，其计算方式如公式\eqref{eq:13-13}所示：
\begin{eqnarray}
\hat{\theta}_{\textrm{MRT}} & = & \arg\max_{\theta}\{\funp{R}(\theta)\} \\
\funp{R}(\theta) & = & \sum_{i=1}^n \mathbb{E}_{\mathbi{y}_i|\mathbi{x}_i;\theta}[\vartriangle(\mathbi{y}_i,\widetilde{\mathbi{y}})] \nonumber \\
& = & \sum_{i=1}^n \sum_{\mathbi{y}_i \in \chi(\mathbi{x}_i)}\funp{P}(\mathbi{y}_i|\mathbi{x}_i;\theta)\vartriangle(\mathbi{y}_i,\widetilde{\mathbi{y}})
\label{eq:13-13}
\end{eqnarray}
\noindent 此处，$\{\mathbi{x}_i,\widetilde{\mathbi{y}}\}$是训练数据中第$i$个句子对，$\mathbi{y}_i$是模型预测输出，$\chi(\mathbi{x}_i)$是对$\mathbi{x}_i$的所有候选翻译的集合，损失函数$\vartriangle(\mathbi{y}_i,\widetilde{\mathbi{y}})$用来衡量模型预测$\mathbi{y}_i$与标准答案$\widetilde{\mathbi{y}}$间的差异，损失函数可以是负平滑句子级别的评估指标，例如BLEU\upcite{DBLP:conf/acl/PapineniRWZ02}，NIST\upcite{doddington2002automatic}，TER\upcite{snover2006study}或METEOR\upcite{lavie2009meteor}。在MRT中，对模型参数$\theta_i$的偏导数公式\eqref{eq:13-14}所示，由于无需对$\vartriangle(\mathbi{y}_i,\widetilde{\mathbi{y}})$进行微分，因此MRT允许任意不可微的损失函数。
\begin{eqnarray}
\frac{\partial \funp{R}(\theta)}{\partial \theta_k} & = & \sum_{i=1}^n \mathbb{E}_{\mathbi{y}_i|\mathbi{x}_i;\theta}[\vartriangle(\mathbi{y}_i,\widetilde{\mathbi{y}}) \times \sum_j^m\frac{\partial \funp{P}(\widetilde{\mathbi{y}}^j|\mathbi{x}_i,\widetilde{\mathbi{y}}^{<m};\theta)/\partial \theta_k}{\funp{P}(\widetilde{\mathbi{y}}^j|\mathbi{x}_i,\widetilde{\mathbi{y}}^{<m};\theta)}]
\label{eq:13-14}
\end{eqnarray}
\noindent 其中，$\widetilde{\mathbi{y}}^j$表示第i个句子的预测的第$j$个词，$\theta_k$表示第$k$个模型的参数
\parinterval 相比于最大似然估计，最小风险训练有着以下优点：
\begin{itemize}
\vspace{0.5em}
\item MRT通过使用模型自身产生的数据进行训练，从而解决了曝光偏置问题。
\vspace{0.5em}
\item MRT通过直接优化BLEU等解码中实际使用的评价指标，从而解决了训练解码评价指标不一致问题。
\vspace{0.5em}
\item 由于MRT方法中只涉及到模型输出而不涉及具体的模型结构，因此其对体系结构是透明的，可以应用于任意的端到端NMT模型。
\vspace{0.5em}
\end{itemize}
\parinterval MRT显著改善了机器翻译任务的性能\upcite{bahdanau2014neural}，且已广泛用于常规SMT\upcite{koehn2003statistical,smith2006minimum,he2012maximum}和基于深度学习的MT\upcite{DBLP:conf/acl/GaoHYD14}。
\parinterval {\red 图X}是最小风险训练计算的一个示例，$\mathbi{x}_i$是观测到的源语句子，$\widetilde{\mathbi{y}}_i$是对应的标准答案，$\mathbi{y}_1$，$\mathbi{y}_2$和$\mathbi{y}_3$是模型的预测结果。损失函数$\vartriangle(\mathbi{y}_i,\widetilde{\mathbi{y}})$用来衡量模型预测结果和标准答案间的差异，MRT的目标是找到一个分布（最右一列）来最小化期望的损失函数。假设$\chi(\mathbi{x}_i)$是包含$\mathbi{y}_1$，$\mathbi{y}_2$和$\mathbi{y}_3$三个候选的一个集合，整个搜索空间只有这三个候选。
\parinterval 表\ref{fig:13-24}的右半边展示了优化过程中的四个模型，顺序为从差到好。根据和标准答案$\widetilde{\mathbi{y}}_i$计算出的损失函数，从上到下的三个模型预测输出我们用$\mathbi{y}_1$，$\mathbi{y}_2$和$\mathbi{y}_3$表示（$\mathbi{y}_1$：“今天 天气 很 好”，$\mathbi{y}_2$：“今天 天气 不错”，$\mathbi{y}_3$：“今天 天 很 晴朗”），显然$\mathbi{y}_1$是最好的候选，$\mathbi{y}_3$是次优的候选，$\mathbi{y}_2$是最差的候选，$\mathbi{y}_1>\mathbi{y}_3>\mathbi{y}_2$。第一列的模型以和标准答案相反的顺序排序所有候选结果，$\mathbi{y}_2>\mathbi{y}_3>\mathbi{y}_1$，因此他得到了最高的风险分数-0.50，第二列的模型相对于第一列的模型得到了一个更好的分数-0.61，第三列得到的分数最高，为-0.71。通过将概率质量集中在$\mathbi{y}_1$上，可以进一步降低风险。通过最大程度地减少训练数据的风险分数，我们期望获得一个与标准答案非常相关的模型。
%----------------------------------------------
\begin{figure}[htp]
\centering
\includegraphics[scale=1]{./Chapter13/Figures/figure-minimum-risk-training-calculation-process.png}
\caption{最小风险训练计算过程}
\label{fig:13-24}
\end{figure}
%----------------------------------------------
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{2. 基于演员-评论家的增强学习方法}
\parinterval 对于基于策略的增强学习方法来说，它的目标是寻找一个策略$\funp{p}(\textrm{a}|\hat{\mathbi{y}}_{1 \ldots t},\mathbi{x})$，使得该策略选择的行动a未来可以获得的奖励期望{\red （后面期望下标中的a是不是加多了？另外原始word里面大小y混用，没有解释小y是什么。另外感觉这个公式太复杂了，没有解释的很清楚，要是解释不清楚的话建议删掉）}$\funp{Q}(\textrm{a};\hat{\mathbi{y}}_{1 \ldots t},\widetilde{\mathbi{y}}) = \mathbb{E}_{\hat{\mathbi{y}}_{1 \ldots T} \sim \funp{p}(\textrm{a}|\hat{\mathbi{y}}_{1 \ldots t} \textrm{a},\mathbi{x})}[\funp{r}_t(\textrm{a};\hat{\mathbi{y}}_{1 \ldots t-1},\widetilde{\mathbi{y}}) + \sum_{i=t+1}^T\funp{r}_i(\hat{\mathbi{y}}_i;\hat{\mathbi{y}}_{1 \ldots i-1}\textrm{a}\hat{\mathbi{y}}_{t+1 \ldots i},\widetilde{\mathbi{y}})]$（也被称为动作价值函数）最大化，其中$\funp{r}_t(\textrm{a};\hat{\mathbi{y}}_{1 \ldots t-1},\widetilde{\mathbi{y}})$是$t$时刻做出行动a获得的奖励，$\mathbi{x}$是源语句子，$\widetilde{\mathbi{y}}$是正确答案，$\hat{\mathbi{y}}_{1 \ldots t}$是策略$\funp{p}$产生的译文的前$t$个词。其{\red （在一个源语句子X上的）}目标函数可以表示为公式\eqref{eq:13-15}：{\red （下面A没解释）}
\begin{eqnarray}
\max_{\funp{p}}\mathbb{E}_{\hat{\mathbi{y}} \sim \funp{p}(\hat{\mathbi{y}} | \mathbi{x})}\sum_{t=1}^T\sum_{\textrm{a} \in \textrm{A}}\funp{p}(\textrm{a}|\hat{\mathbi{y}}_{1 \ldots t},\mathbi{x})\funp{Q}(\textrm{a};\hat{\mathbi{y}}_{1 \ldots t},\widetilde{\mathbi{y}})
\label{eq:13-15}
\end{eqnarray}
\parinterval {\red （这段上面不好理解，这段开始是ok的）}计算动作价值函数$\funp{Q}$需要{\red 迭代}$t$时刻以后所有可能句子，而可能的句子数目是随着其长度指数级增长，因此我们只能估计$\funp{Q}$。基于策略的增强学习方法，如最小风险训练（风险$\vartriangle=-\funp{Q}$）等都使用了采样的方法来估计$\funp{Q}$。尽管采样估计的结果是$\funp{Q}$的无偏估计，但是它的缺点在于估计的方差比较大。而$\funp{Q}$直接关系到梯度更新的大小，不稳定的数值会导致网络更新不稳定，难以优化。
\parinterval 为了避免采样的开销和随机性带来的不稳定，基于演员-评论家的增强学习方法\upcite{DBLP:conf/iclr/BahdanauBXGLPCB17}引入一个可学习的函数$\hat{\funp{Q}}$，通过函数$\hat{\funp{Q}}$来逼近动作价值函数$\funp{Q}$。但是由于$\hat{\funp{Q}}$是人工设计的一个函数，该函数有着自身的偏置，因此$\hat{\funp{Q}}$不是$\funp{Q}$的一个无偏估计，所以使用$\hat{\funp{Q}}$来指导$\funp{p}$的优化无法到达理论上的最优解。尽管如此，得益于神经网络强大的拟合能力，基于演员-评论家的增强学习方法仍更具优势。
\parinterval 对于基于演员-评论家的增强学习方法，演员就是策略$\funp{p}$，而评论家就是动作价值函数$\funp{Q}$的估计$\hat{\funp{Q}}$。对于演员，它的目标函数如下：
\begin{eqnarray}
\max_{\funp{p}}\mathbb{E}_{\hat{\mathbi{y}} \sim \funp{p}(\hat{\mathbi{y}} | \mathbi{x})}\sum_{t=1}^T\sum_{\textrm{a} \in \textrm{A}}\funp{p}(\textrm{a}|\hat{\mathbi{y}}_{1 \ldots t},\mathbi{x})\hat{\funp{Q}}(\textrm{a};\hat{\mathbi{y}}_{1 \ldots t},\widetilde{\mathbi{y}})
\label{eq:13-16}
\end{eqnarray}
\parinterval 与公式\eqref{eq:13-15}相比可以发现，基于演员-评论家的增强学习方法与基于策略的增强学习方法类似，公式\eqref{eq:13-16}对动作价值函数$\funp{Q}$的估计从采样换成了$\hat{\funp{Q}}$。{\red 对于目标函数里的期望，我们通常使用采样来进行逼近。借助与最小风险训练类似的方法，我们可以计算对$\funp{p}$的梯度来进行优化。（感觉这段讲不讲都行，没有帮助理解上面公式）}
\parinterval 而对于评论家，它的优化目标则不是那么显而易见。尽管根据定义我们可以通过采样来估计$\funp{Q}$，然后使用该估计作为目标让$\hat{\funp{Q}}$进行拟合，但是这样会导致非常高的（采样）代价，同时可以想象，既然有了一个无偏估计，为什么还要用有偏估计$\hat{\funp{Q}}$呢？
\parinterval 回顾动作价值函数的定义，我们对它做适当的展开，可以得到如下等式：
\begin{eqnarray}
\funp{Q}(\hat{\mathbi{y}};\hat{\mathbi{y}}_{1 \ldots t-1},\mathbi{y}) & = & \funp{r}_t(\hat{\mathbi{y}}_t;\hat{\mathbi{y}}_{1 \ldots t-1},\mathbi{y}) + \sum_{\textrm{a} \in \textrm{A}}\funp{p}(\textrm{a}|\hat{\mathbi{y}}_{1 \ldots t},\mathbi{x})\funp{Q}(\textrm{a};\hat{\mathbi{y}}_{1 \ldots t},\widetilde{\mathbi{y}})
\label{eq:13-17}
\end{eqnarray}
\parinterval 这个等式也被称为贝尔曼方程\upcite{sutton2018reinforcement}。这个等式告诉我们$t-1$时刻的动作价值函数$\funp{Q}(\hat{\mathbi{y}};\hat{\mathbi{y}}_{1 \ldots t-1},\mathbi{y})$跟下一时刻$t$的动作价值函数$\funp{Q}(\textrm{a};\hat{\mathbi{y}}_{1 \ldots t},\widetilde{\mathbi{y}})$之间的关系。因此我们可以很自然的使用等式右部作为等式左部$\funp{Q}(\hat{\mathbi{y}};\hat{\mathbi{y}}_{1 \ldots t-1},\mathbi{y})$的目标。而由于动作价值函数的输出是数值，通常会选用均方误差来计算目标函数值。
\parinterval t时刻动作价值函数的目标如下：{\red （下面开始用q？）}
\begin{eqnarray}
\funp{q}_t & = & \funp{r}_t(\hat{\mathbi{y}}_t;\hat{\mathbi{y}}_{1 \ldots t-1},\mathbi{y}) + \sum_{\textrm{a} \in \textrm{A}}\funp{p}(\textrm{a}|\hat{\mathbi{y}}_{1 \ldots t},\mathbi{x})\hat{\funp{Q}}(\textrm{a};\hat{\mathbi{y}}_{1 \ldots t},\widetilde{\mathbi{y}})
\label{eq:13-18}
\end{eqnarray}
\parinterval 而评论家对应的目标函数则如下：
\begin{eqnarray}
\min_{\hat{\funp{Q}}}\sum_{t=1}^T{(\hat{\funp{Q}}(\hat{\mathbi{y}};\hat{\mathbi{y}}_{1 \ldots t-1},\mathbi{y}) - \funp{q}_t)}^2
\label{eq:13-19}
\end{eqnarray}
\parinterval 最后，通过同时优化演员和评论家直到收敛，获得的演员也就是策略$\funp{p}$就是我们期望的翻译模型。图\ref{fig:13-25}展示了演员和评论家的关系。
%----------------------------------------------
\begin{figure}[htp]
\centering
\includegraphics[scale=0.4]{./Chapter13/Figures/figure-reinforcement-learning-method-based-on-actor-critic.png}
\caption{基于演员-评论家的增强学习方法}
\label{fig:13-25}
\end{figure}
%----------------------------------------------
\parinterval 实际使用基于演员-评论家的增强学习方法还有许多细节，包括但不限于以下技巧：
\begin{itemize}
\vspace{0.5em}
\item 多目标学习：演员的优化通常会引入额外的{\red MLE（好像之前没解释？）}目标函数，同时会使用MLE进行预训练。这样会简化训练，因为随机初始化的演员性能很差，很难获得有效的奖励。同时MLE作为一个额外的正则项也防止模型跑偏，加速收敛。
\vspace{0.5em}
\item 目标网络：评论家的优化目标是由自身输出所构造。当模型更新比较快的时候模型的输出变化也会很快，导致构造的优化目标不稳定，影响模型收敛。一个解决方案是在一定更新次数内固定构造优化目标使用的模型，然后再使用比较新的模型来构造后续一定更新次数内的优化目标，如此往复\upcite{DBLP:journals/nature/SilverHMGSDSAPL16}。
\vspace{0.5em}
\item 方差惩罚：在机器翻译里面使用增强学习方法一个问题就是动作空间，也就是词表非常大。因为模型只根据被采样到的结果来进行更新，很多动作很难得到更新，因此对不同动作的动作价值函数估计值会有很大差异。通常我们会引入一个正则项$C_t = \sum_{\textrm{a} \in \textrm{A}}{(\hat{\funp{Q}}(\textrm{a};\hat{\mathbi{y}}_{1 \ldots t},\widetilde{\mathbi{y}}) - \frac{1}{|\textrm{A}|} \sum_{\textrm{b} \in \textrm{A}}\hat{\funp{Q}}(\textrm{b};\hat{\mathbi{y}}_{1 \ldots t},\widetilde{\mathbi{y}}))}^2$来约束不同动作的动作函数估计值，使其不会偏离他们的均值太远\upcite{DBLP:conf/icml/ZarembaMJF16}。
\vspace{0.5em}
\item 函数塑形：在机器翻译里面使用增强学习方法另一个问题就是奖励的稀疏性。评价指标如BLEU等只能对完整的句子进行打分，这意味着奖励只有在句子结尾有值，而在句子中间只能为0。这种情况意味着模型在生成句子的过程中没有任何信号来指导它的行为，从而大大增加了学习难度。常见的解决方案是进行函数塑形，使得奖励在生成句子的过程中变得稠密，同时也不会改变模型的最优解\upcite{DBLP:conf/icml/NgHR99}。
\vspace{0.5em}
\end{itemize}
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
...@@ -499,7 +703,7 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\ ...@@ -499,7 +703,7 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\subsection{知识蒸馏的基本方法} \subsection{知识蒸馏的基本方法}
\parinterval 知识蒸馏的基本思路是让学生模型所表示的函数尽可能去拟合教师模型所表示的函数\upcite{Hinton2015Distilling}，通常有两种实现方式\upcite{DBLP:conf/emnlp/KimR16}： \parinterval 知识蒸馏的基本思路是让学生模型所表示的函数尽可能去拟合教师模型所表示的函数\upcite{Hinton2015Distilling}，通常有两种实现方式\upcite{kim-rush-2016-sequence}：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
...@@ -539,7 +743,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -539,7 +743,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\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可能会生成非常尖锐的分布。这时需要考虑对分布进行平滑，提高模型的泛化能力\footnote[16]{比如，可以在Softmax函数中加入一个参数$\alpha$，如$\textrm{Softmax}(s_i)=\frac{\exp(s_i/\alpha)}{\sum_j \exp(s_i/\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{DBLP:journals/corr/abs-1909-10351}。 \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}。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
...@@ -587,7 +791,9 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -587,7 +791,9 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\subsection{数据选择} \subsection{数据选择}
\parinterval 模型学习的过程本质上就是在学习训练数据的分布，以期望模型学到的分布和真实数据的分布越接近越好。然而训练数据是从真实世界中采样得来的，这导致了训练数据无法完整地描述客观世界的真实规律。这种分布的不匹配有许多不同的表现形式，比如类别不平衡、领域差异、存在标签噪声等，这导致模型在实践中表现不佳。类别不平衡在分类任务中更为常见，可以通过重采样、代价敏感等手段来解决，数据选择则是缓解后两个问题的一种有效手段，它的学习策略是不让模型学所有的样本，而是静态或动态的选择有价值的样本来让模型学习，此外，在一些稀缺资源场景下还会面临标注数据稀少的情况，此时可以利用主动学习选择那些最有价值的样本让人工进行标注，从而降低成本。 \parinterval 模型学习的过程本质上就是在学习训练数据的分布，以期望模型学到的分布和真实数据的分布越接近越好。然而训练数据是从真实世界中采样得来的，这导致了训练数据无法完整地描述客观世界的真实规律。这种分布的不匹配有许多不同的表现形式，比如类别不平衡、领域差异、存在标签噪声等，这导致模型在实践中表现不佳。
\parinterval 类别不平衡在分类任务中更为常见，可以通过重采样、代价敏感等手段来解决，数据选择则是缓解后两个问题的一种有效手段，它的学习策略是不让模型学所有的样本，而是静态或动态的选择有价值的样本来让模型学习，此外，在一些稀缺资源场景下还会面临标注数据稀少的情况，此时可以利用主动学习选择那些最有价值的样本让人工进行标注，从而降低成本。
\parinterval 在这里，定义价值本质上是在定义一个评价函数，这是数据选择的核心问题，价值在不同任务背景下有不同的含义，这与任务的特性和它的基本假设有关。比如，在领域相关数据选择中，价值表示样本与领域的相关性；在数据降噪中，价值表示样本的可信度；在主动学习中，价值表示样本的困难程度。下面对它们进行介绍。 \parinterval 在这里，定义价值本质上是在定义一个评价函数，这是数据选择的核心问题，价值在不同任务背景下有不同的含义，这与任务的特性和它的基本假设有关。比如，在领域相关数据选择中，价值表示样本与领域的相关性；在数据降噪中，价值表示样本的可信度；在主动学习中，价值表示样本的困难程度。下面对它们进行介绍。
...@@ -597,7 +803,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -597,7 +803,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\subsubsection{1. 领域相关的数据选择} \subsubsection{1. 领域相关的数据选择}
\parinterval 机器翻译模型是基于平行语料训练出来的，语料的质量、数量对翻译效果都有很大的影响。特别是，当机器翻译系统应用于不同领域的文本时，训练语料与所应用领域的相关性就非常重要（Survey of data-selection methods in statistical machine translation；Effective Domain Mixing for Neural Machine Translation）。不同领域往往具有自己独特的属性，比如语言风格、句子结构、专业术语等，例如，“bank”这个英语单词，在金融领域通常被翻译为“银行”，而在计算机领域，一般被解释为“库”、“存储体”等。这也会导致，使用通用领域数据训练出来的模型在特定领域上的翻译效果往往不理想，这本质上是训练数据和测试数据的领域属性不匹配造成的。 \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}）从源领域训练数据中选择与目标领域更加相关的样本进行模型训练。这样做的一个好处是，源领域中混有大量与目标领域不相关的样本，数据选择可以有效的降低这部分数据的比例，这样可以更加突出与领域相关的样本的作用。
...@@ -605,25 +811,25 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -605,25 +811,25 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 基于交叉熵差（cross-entropy difference，CED）的方法(Domain Adaptation Via Pseudo In-Domain Data Selection；Data Selection With Fewer Words；Instance Weighting for Neural Machine Translation Domain Adaptation；Combining translation and language model scoring for domain-specific data filtering)。该方法做法是在目标领域数据和通用数据上分别训练语言模型，然后用语言模型来给句子打分并做差，分数越低说明句子与目标领域越相关。 \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} \vspace{0.5em}
\item 基于文本分类的方法（Semi-supervised Convolutional Networks for Translation Adaptation with Tiny Amount of In-domain Data；Bilingual Methods for Adaptive Training Data Selection for Machine Translation；Cost Weighting for Neural Machine Translation Domain Adaptation；Automatic Threshold Detection for Data Selection in Machine Translation）。将该问题转化为文本分类问题，先构造一个领域分类器，之后利用该分类器对给定的句子进行领域分类，最后用输出的概率来打分，选择目标领域预测得分高的样本。 \item 基于文本分类的方法\upcite{DBLP:conf/conll/ChenH16,chen2016bilingual,DBLP:conf/aclnmt/ChenCFL17,DBLP:conf/wmt/DumaM17}。将该问题转化为文本分类问题，先构造一个领域分类器，之后利用该分类器对给定的句子进行领域分类，最后用输出的概率来打分，选择目标领域预测得分高的样本。
\vspace{0.5em} \vspace{0.5em}
\item 基于特征衰减算法的方法（Feature Decay Algorithms，FDA)（Instance selection for machine translation using feature decay algorithms；Feature decay algorithms for neural machine translation；Selecting Backtranslated Data from Multiple Sources for Improved Neural Machine Translation；Data Selection with Feature Decay Algorithms Using an Approximated Target Side）。该算法基于特征匹配，试图从源领域中提取出一个句子集合，这些句子能够使目标领域语言特征的覆盖范围最大化。 \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}。该算法基于特征匹配，试图从源领域中提取出一个句子集合，这些句子能够使目标领域语言特征的覆盖范围最大化。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 尽管这些方法有所不同，但是它们的目的都是为了衡量样本和领域的相关性，这些评价指标最终服务于训练过程中的样本学习策略。样本学习策略主要分为静态和动态两种，早期的研究工作都是关注于设计评分函数，在学习策略上普遍采用静态方法，即首先利用评分函数对源领域的数据进行打分排序，然后选取一定数量的数据合并到目标领域数据集中共同训练模型（Domain Adaptation Via Pseudo In-Domain Data Selection；Data Selection With Fewer Words；Bilingual Methods for Adaptive Training Data Selection for Machine Translation；Instance selection for machine translation using feature decay algorithms；Semi-supervised Convolutional Networks for Translation Adaptation with Tiny Amount of In-domain Data），这个过程其实是扩大了目标领域的数据规模，模型的收益主要来自于数据的增加。但是研究人员也发现静态方法会存在两方面的缺陷： \parinterval 尽管这些方法有所不同，但是它们的目的都是为了衡量样本和领域的相关性，这些评价指标最终服务于训练过程中的样本学习策略。样本学习策略主要分为静态和动态两种，早期的研究工作都是关注于设计评分函数，在学习策略上普遍采用静态方法，即首先利用评分函数对源领域的数据进行打分排序，然后选取一定数量的数据合并到目标领域数据集中共同训练模型\upcite{DBLP:conf/emnlp/AxelrodHG11,DBLP:conf/wmt/AxelrodRHO15,chen2016bilingual,DBLP:conf/wmt/BiciciY11,DBLP:conf/conll/ChenH16}，这个过程其实是扩大了目标领域的数据规模，模型的收益主要来自于数据的增加。但是研究人员也发现静态方法会存在两方面的缺陷：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 在选定的子集上进行训练会导致词表覆盖率的降低和加剧单词长尾分布问题。（Data Selection With Fewer Words；Dynamic Data Selection for Neural Machine Translation） \item 在选定的子集上进行训练会导致词表覆盖率的降低和加剧单词长尾分布问题\upcite{DBLP:conf/wmt/AxelrodRHO15,DBLP:conf/emnlp/WeesBM17}。
\vspace{0.5em} \vspace{0.5em}
\item 静态方法可以看作一种数据过滤技术，它对数据的判定方式是“非黑即白”的，即接收或拒绝，这种方式一方面会受到评分函数的影响，一方面被拒绝的数据可能对于训练模型仍然有用，而且样本的价值可能会随着训练过程的推进而改变。（Denoising Neural Machine Translation Training with Trusted Data and Online Data Selection） \item 静态方法可以看作一种数据过滤技术，它对数据的判定方式是“非黑即白”的，即接收或拒绝，这种方式一方面会受到评分函数的影响，一方面被拒绝的数据可能对于训练模型仍然有用，而且样本的价值可能会随着训练过程的推进而改变\upcite{DBLP:conf/wmt/WangWHNC18}。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 使用动态学习策略可以有效地缓解上述这些问题。这里的动态主要体现在模型训练过程中，训练数据是以某种策略进行动态的组织。它的基本想法是：不完全抛弃领域相关性低的样本，而只是使模型给予相关性高的样本更高的关注度，使得它更容易参与到训练过程中。具体在实现上，主要有两种方法，一种是将句子的领域相似性表达成概率分布，然后在训练过程中根据该分布对数据进行动态采样（Dynamic Data Selection for Neural Machine Translation；Dynamic Sentence Sampling for Efficient Training of Neural Machine Translation）， 一种是在计算损失函数时根据句子的领域相似性以加权的方式进行训练（Instance Weighting for Neural Machine Translation Domain Adaptation；Cost Weighting for Neural Machine Translation Domain Adaptation）。相比于基于静态的二元选择，基于动态的方法是一种“软”选择方式，这使得模型有机会使用到其它数据，提高了训练数据的多样性，因此性能也更稳定。 \parinterval 使用动态学习策略可以有效地缓解上述这些问题。这里的动态主要体现在模型训练过程中，训练数据是以某种策略进行动态的组织。它的基本想法是：不完全抛弃领域相关性低的样本，而只是使模型给予相关性高的样本更高的关注度，使得它更容易参与到训练过程中。具体在实现上，主要有两种方法，一种是将句子的领域相似性表达成概率分布，然后在训练过程中根据该分布对数据进行动态采样\upcite{DBLP:conf/emnlp/WeesBM17,DBLP:conf/acl/WangUS18}， 一种是在计算损失函数时根据句子的领域相似性以加权的方式进行训练\upcite{DBLP:conf/emnlp/WangULCS17,DBLP:conf/aclnmt/ChenCFL17}。相比于基于静态的二元选择，基于动态的方法是一种“软”选择方式，这使得模型有机会使用到其它数据，提高了训练数据的多样性，因此性能也更稳定。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION % NEW SUBSUB-SECTION
...@@ -631,11 +837,11 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -631,11 +837,11 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\subsubsection{2. 数据降噪} \subsubsection{2. 数据降噪}
\parinterval 除了领域差异，训练数据中也存在噪声，比如，机器翻译所使用的数据中经常出现句子未对齐、多种语言单词混合、单词丢失等问题。相关研究表明神经机器翻译对于噪声数据很敏感，当噪声过多时就会带来模型性能的显著下降（On the impact of various types of noise on neural machine translation），因此无论是从模型健壮性还是训练效率出发，数据降噪都是很有意义的。事实上，数据降噪从统计机器翻译时代就已经开展了许多工作（Dealing with Input Noise in Statistical Machine Translation；Bilingual Data Cleaning for SMT using Graph-based Random Walk；Learning from Noisy Data in Statistical Machine Translation），因此很多方法也可以应用到神经机器翻译中来。 \parinterval 除了领域差异，训练数据中也存在噪声，比如，机器翻译所使用的数据中经常出现句子未对齐、多种语言单词混合、单词丢失等问题。相关研究表明神经机器翻译对于噪声数据很敏感，当噪声过多时就会带来模型性能的显著下降\upcite{DBLP:conf/aclnmt/KhayrallahK18}，因此无论是从模型健壮性还是训练效率出发，数据降噪都是很有意义的。事实上，数据降噪从统计机器翻译时代就已经开展了许多工作\upcite{DBLP:conf/coling/FormigaF12,DBLP:conf/acl/CuiZLLZ13,DBLP:phd/dnb/Mediani17}，因此很多方法也可以应用到神经机器翻译中来。
\parinterval 含有噪声的数据通常都具有较为明显的特征，因此可以用诸如句子长度比、词对齐率、最长连续未对齐序列长度等一些特征来对句子进行综合评分（MT Detection in Web-Scraped Parallel Corpora；Parallel Corpus Refinement as an Outlier Detection Algorithm；Zipporah: a Fast and Scalable Data Cleaning System for NoisyWeb-Crawled Parallel Corpora）；也可以将该问题转化为分类任务来对句子进行筛选（Detecting Cross-Lingual Semantic Divergence for Neural Machine Translation；Identifying Semantic Divergences in Parallel Text without Annotations）；此外，从某种意义上来说，数据降噪其实也可以算是一种领域数据选择，因为它的目标是选择可信度高的样本，因此也可以人工构建一个可信度高的小数据集，然后利用该数据集和通用数据集之间的差异性进行选择（Denoising Neural Machine Translation Training with Trusted Data and Online Data Selection）。 \parinterval 含有噪声的数据通常都具有较为明显的特征，因此可以用诸如句子长度比、词对齐率、最长连续未对齐序列长度等一些特征来对句子进行综合评分\upcite{rarrick2011mt,taghipour2011parallel,Xu2017ZipporahAF}；也可以将该问题转化为分类任务来对句子进行筛选\upcite{DBLP:conf/aclnmt/CarpuatVN17,DBLP:conf/naacl/VyasNC18}；此外，从某种意义上来说，数据降噪其实也可以算是一种领域数据选择，因为它的目标是选择可信度高的样本，因此也可以人工构建一个可信度高的小数据集，然后利用该数据集和通用数据集之间的差异性进行选择\upcite{DBLP:conf/wmt/WangWHNC18}。
\parinterval 早期的工作大多在关注过滤噪声数据的方法，对于噪声数据中模型的健壮性训练和噪声样本的利用探讨较少。事实上，噪声是有强度的，有些噪声数据对于模型可能是有价值的，而且它们的价值可能会随着模型的状态而改变（Denoising Neural Machine Translation Training with Trusted Data and Online Data Selection）。一个例子如图\ref{fig:13-51}所示（画图的时候zh-gloss那行不要了，zh翻译为汉语{\color{red} 例子是别人的，还是自己造的？}）。图中的汉语句子中缺少了一部分翻译，但这两个句子都很流畅，简单的基于长度或双语词典的方法可以很容易地对其进行过滤（{\color{red} 过滤啥？}）。但是，这个训练样本对于训练机器翻译模型仍然有用，特别是在数据稀缺的情况下，因为汉语句子和英语句子的前半部分仍然是正确的互译结果。这表明了噪声数据的微妙之处，它不是一个简单的二元分类问题：一些训练样本可能部分有用，而它们的有用性也可能随着训练的进展而改变。因此简单的过滤并不一种很好的办法，一种合理的学习策略应该是既可以合理的利用这些数据，又不让其对模型产生负面影响。直觉上，这是一个动态的过程，当模型能力较弱时（比如在训练初期），这些数据就能对模型起到正面作用，反之亦然。受课程学习、微调等方法的启发，研究人员也提出了类似的学习策略，它的主要思想是：在训练过程中对批量数据的噪声水平进退火（Anneal），使得模型在越来越干净的数据上进行训练（Denoising Neural Machine Translation Training with Trusted Data and Online Data Selection；Dynamically Composing Domain-Data Selection with Clean-Data Selection by “Co-Curricular Learning” for Neural Machine Translation）。从宏观上看，整个训练过程其实是一个持续微调的过程，这和微调的思想基本一致。这种学习策略一方面充分利用了训练数据，一方面又避免了噪声数据对模型的负面影响，因此取得了不错的效果。 \parinterval 早期的工作大多在关注过滤噪声数据的方法，对于噪声数据中模型的健壮性训练和噪声样本的利用探讨较少。事实上，噪声是有强度的，有些噪声数据对于模型可能是有价值的，而且它们的价值可能会随着模型的状态而改变\upcite{DBLP:conf/wmt/WangWHNC18}。一个例子如图\ref{fig:13-51}所示（画图的时候zh-gloss那行不要了，zh翻译为汉语{\color{red} 例子是别人的，还是自己造的？}）。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -646,17 +852,19 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -646,17 +852,19 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 图中的汉语句子中缺少了一部分翻译，但这两个句子都很流畅，简单的基于长度或双语词典的方法可以很容易地对其进行过滤（{\color{red} 过滤啥？}）。但是，这个训练样本对于训练机器翻译模型仍然有用，特别是在数据稀缺的情况下，因为汉语句子和英语句子的前半部分仍然是正确的互译结果。这表明了噪声数据的微妙之处，它不是一个简单的二元分类问题：一些训练样本可能部分有用，而它们的有用性也可能随着训练的进展而改变。因此简单的过滤并不一种很好的办法，一种合理的学习策略应该是既可以合理的利用这些数据，又不让其对模型产生负面影响。直觉上，这是一个动态的过程，当模型能力较弱时（比如在训练初期），这些数据就能对模型起到正面作用，反之亦然。受课程学习、微调等方法的启发，研究人员也提出了类似的学习策略，它的主要思想是：在训练过程中对批量数据的噪声水平进{\small\bfnew{退火}}\index{退火}（Anneal）\index{Anneal}，使得模型在越来越干净的数据上进行训练\upcite{DBLP:conf/wmt/WangWHNC18,DBLP:conf/acl/WangCC19}。从宏观上看，整个训练过程其实是一个持续微调的过程，这和微调的思想基本一致。这种学习策略一方面充分利用了训练数据，一方面又避免了噪声数据对模型的负面影响，因此取得了不错的效果。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION % NEW SUBSUB-SECTION
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\subsubsection{3. 主动学习} \subsubsection{3. 主动学习}
\parinterval {\small\bfnew{主动学习}}\index{主动学习}（Active Learning\index{Active Learning}）也是一种数据选择策略。它最初的应用场景式是：标注大量的数据成本过高，因此希望优先标注对模型最有价值的数据，这样可以最大化模型学习的效率，同时整体降低标注的代价。主动学习主要由五个部分组成（{\color{red} 引用朱老师主动学习的论文}），包括：未标注样本池、筛选策略、标注者、标注样本集、目标模型。在主动学习过程中，会根据当前的模型状态找到未标注样本池中最优价值的样本，之后送给标注者。标注结束后，会把标注的样本加入到标注样本集中，之后用这些标注的样本更新模型。之后，重复这个过程，直到到达某种收敛状态。 \parinterval {\small\bfnew{主动学习}}\index{主动学习}（Active Learning\index{Active Learning}）也是一种数据选择策略。它最初的应用场景式是：标注大量的数据成本过高，因此希望优先标注对模型最有价值的数据，这样可以最大化模型学习的效率，同时整体降低标注的代价。主动学习主要由五个部分组成（{\color{red} 再确定一下Active learning with sampling by uncertainty and density for word sense disambiguation and text classification还是Active learning with sampling by uncertainty and density for data annotations还是Active learning for word sense disambiguation with methods for addressing the class imbalance problem等等}），包括：未标注样本池、筛选策略、标注者、标注样本集、目标模型。在主动学习过程中，会根据当前的模型状态找到未标注样本池中最优价值的样本，之后送给标注者。标注结束后，会把标注的样本加入到标注样本集中，之后用这些标注的样本更新模型。之后，重复这个过程，直到到达某种收敛状态。
\parinterval 主动学习的一个核心问题是：如何选择出那些最有价值的未标注样本？通常会假设模型认为最“难”的样本是最有价值的。具体实现有很多思路，例如，基于置信度的方法、基于分类错误的方法等等（Uncertainty-based Active Learning with Instability Estimation for Text Classification；Active Learning with Sampling by Uncertainty and Density for Word Sense Disambiguation and Text Classification）。 \parinterval 主动学习的一个核心问题是：如何选择出那些最有价值的未标注样本？通常会假设模型认为最“难”的样本是最有价值的。具体实现有很多思路，例如，基于置信度的方法、基于分类错误的方法等等\upcite{DBLP:journals/tslp/ZhuM12,DBLP:conf/coling/ZhuWYT08}。
\parinterval 在机器翻译中，主动学习可以被用于低资源翻译，以减少人工标注的成本（Learning to Actively Learn Neural Machine Translation；Active Learning Approaches to Enhancing Neural Machine Translation）。也可以被用于交互式翻译，让模型持续从外界反馈中受益（Active Learning for Interactive Neural Machine Translation of Data Streams；Continuous learning from human post-edits for neural machine translation；Online learning for effort reduction in interactive neural machine translation）。不过，总的来说，主动学习在机器翻译中应用不算广泛。这是由于，机器翻译任务较为复杂，设计样本价值的评价函数较为困难。而且，在很多场景中，并不是要简单的选择样本，而是希望训练装置能够考虑样本的价值，以充分发挥所有数据的优势。这也正是即将介绍的课程学习等方法要解决的问题。 \parinterval 在机器翻译中，主动学习可以被用于低资源翻译，以减少人工标注的成本\upcite{DBLP:conf/conll/LiuBH18,DBLP:conf/emnlp/ZhaoZZZ20}。也可以被用于交互式翻译，让模型持续从外界反馈中受益\upcite{Peris2018ActiveLF,DBLP:journals/pbml/TurchiNFF17,DBLP:journals/csl/PerisC19}。不过，总的来说，主动学习在机器翻译中应用不算广泛。这是由于，机器翻译任务较为复杂，设计样本价值的评价函数较为困难。而且，在很多场景中，并不是要简单的选择样本，而是希望训练装置能够考虑样本的价值，以充分发挥所有数据的优势。这也正是即将介绍的课程学习等方法要解决的问题。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
...@@ -664,7 +872,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -664,7 +872,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\subsection{课程学习} \subsection{课程学习}
\parinterval {\small\bfnew{课程学习}}\index{课程学习}（Curriculum Learning\index{Curriculum Learning}）的基本思想是：先学习简单的、普适性的知识，然后逐渐增加难度，学习更复杂、更专业化的知识。在统计模型训练中，这体现在让模型按照由“易”到”难“ 的顺序对样本进行学习（论文 Curriculum learning），这本质上是一种样本使用策略。以神经机器翻译翻译使用的随机梯度下降为例，在传统的方法中，所有训练样本都是随机呈现给模型的，换句话说，就是让模型来平等地对待所有的训练样本，这忽略了数据样本的各种复杂性和当前模型的学习状态。所以模拟人类由易到难的学习过程就是一种很自然的想法，这样做的好处在于： \parinterval {\small\bfnew{课程学习}}\index{课程学习}（Curriculum Learning\index{Curriculum Learning}）的基本思想是：先学习简单的、普适性的知识，然后逐渐增加难度，学习更复杂、更专业化的知识。在统计模型训练中，这体现在让模型按照由“易”到”难“ 的顺序对样本进行学习\upcite{DBLP:conf/icml/BengioLCW09}，这本质上是一种样本使用策略。以神经机器翻译翻译使用的随机梯度下降为例，在传统的方法中，所有训练样本都是随机呈现给模型的，换句话说，就是让模型来平等地对待所有的训练样本，这忽略了数据样本的各种复杂性和当前模型的学习状态。所以模拟人类由易到难的学习过程就是一种很自然的想法，这样做的好处在于：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
...@@ -688,10 +896,6 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -688,10 +896,6 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\parinterval 这里，把这两个问题抽象成两个模块：难度评估器和训练调度器，那么课程学习的一个大致的流程如图\ref{fig:13-53}所示。首先，难度评估器对训练样本按照由易到难的顺序进行排序，最开始调度器从相对容易的数据块中采样训练样本，发送给模型进行训练，随着训练时间的推移，训练调度器将逐渐从更加困难的数据块中进行采样（至于何时，以及何种采样方式则取决于设定的策略），持续这个过程，直到从整个训练集进行均匀采样。 \parinterval 这里，把这两个问题抽象成两个模块：难度评估器和训练调度器，那么课程学习的一个大致的流程如图\ref{fig:13-53}所示。首先，难度评估器对训练样本按照由易到难的顺序进行排序，最开始调度器从相对容易的数据块中采样训练样本，发送给模型进行训练，随着训练时间的推移，训练调度器将逐渐从更加困难的数据块中进行采样（至于何时，以及何种采样方式则取决于设定的策略），持续这个过程，直到从整个训练集进行均匀采样。
\parinterval 评估样本的难度和具体的任务相关，在神经机器翻译中，有很多种评估方法，可以利用语言学上的困难准则，比如句子长度、句子平均词频、句法树深度等（Competence-based curriculum learning for neural machine translation；Curriculum Learning and Minibatch Bucketing in Neural Machine Translation）。这些准则本质上属于人类的先验知识，符合人类的直觉，但不一定和模型相匹配，对人类来说简单的句子对模型来说并不总是容易的，所以研究学者们也提出了基于模型的方法，比如：语言模型（Dynamically Composing Domain-Data Selection with Clean-Data Selection by “Co-Curricular Learning” for Neural Machine Translation；Curriculum Learning for Domain Adaptation in Neural Machine Translation），或者神经机器翻译模型（An empirical exploration of curriculum learning for neural machine translation；Dynamic Curriculum Learning for Low-Resource Neural Machine Translation）都可以用于评价样本的难度。值得注意的是，利用神经机器翻译来打分的方法分为静态和动态两种，静态的方法是利用在小数据集上训练的、更小的翻译模型模型来打分（An empirical exploration of curriculum learning for neural machine translation），动态的方法则是利用当前模型的状态来打分，这在广义上也叫作{\small\bfnew{自步学习}}\index{自步学习}（Self-Paced Learning\index{Self-Paced Learning}），通常可以利用模型的训练误差或变化率等指标进行样本难度的估计（Dynamic Curriculum Learning for Low-Resource Neural Machine Translation）。
\parinterval 虽然样本难度的度量在不同的数据类型和任务中有所不同，但课程规划通常与数据和任务无关。在各种场景中，大多数课程学习都利用了类似的调度策略。具体而言，调度策略可以分为预定义的和自动的两种。预定义的调度策略通常是将按照难易程度排序好的样本划分为块，每个块中包含一定数量的难度相似的样本。然后按照“先易后难”的原则人工定义一个调度策略，比如，一种较为流行的方法是：在训练早期，模型只在简单块中进行采样，随着训练过程的进行，比如在固定数量的训练轮次之后，将下一个块的样本合并到当前训练子集中，继续训练，直到合并了整个数据块，即整个训练集可见为止，之后再继续进行几个额外轮次的训练直到收敛。这个过程如图\ref{fig:13-55}所示。类似的还有一些其他变体，比如，训练到模型可见整个数据集之后，将最难的样本块复制并添加到训练集中，或者是将最容易的数据块逐渐删除，然后再添加回来等，这些方法的基本想法都是想让模型在具备一定的能力之后更多关注于困难样本。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
...@@ -701,6 +905,10 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -701,6 +905,10 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\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}所示。类似的还有一些其他变体，比如，训练到模型可见整个数据集之后，将最难的样本块复制并添加到训练集中，或者是将最容易的数据块逐渐删除，然后再添加回来等，这些方法的基本想法都是想让模型在具备一定的能力之后更多关注于困难样本。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
...@@ -710,7 +918,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -710,7 +918,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 尽管预定义的调度策略简单有效，但也会面临着方法不够灵活、数据块划分不合理等问题，而且这种策略在一定程度上也忽略了当前模型的反馈。因此另一种方法是自动的方法，根据模型的反馈来动态调整样本的难度或调度策略，模型的反馈可以是模型的不确定性（Uncertainty-Aware Curriculum Learning for Neural Machine Translation）、模型的能力（Competence-based Curriculum Learning for Neural Machine Translation；Dynamic Curriculum Learning for Low-Resource Neural Machine Translation）等。这些方法在一定程度上使得整个训练过程和模型的状态相匹配，使得样本的选择过渡得更加平滑，因此在实践中取得了不错的效果。 \parinterval 尽管预定义的调度策略简单有效，但也会面临着方法不够灵活、数据块划分不合理等问题，而且这种策略在一定程度上也忽略了当前模型的反馈。因此另一种方法是自动的方法，根据模型的反馈来动态调整样本的难度或调度策略，模型的反馈可以是模型的不确定性\upcite{DBLP:conf/acl/ZhouYWWC20}、模型的能力\upcite{DBLP:conf/naacl/PlataniosSNPM19,DBLP:conf/coling/XuHJFWHJXZ20}等。这些方法在一定程度上使得整个训练过程和模型的状态相匹配，使得样本的选择过渡得更加平滑，因此在实践中取得了不错的效果。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
...@@ -724,15 +932,15 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -724,15 +932,15 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 基于正则化的方法。通过对神经权重的更新施加约束来减轻灾难性的遗忘，通常是在损失函数中引入了一个额外的正则化项，使得模型在学习新数据时巩固先前的知识。（Learning without Forgetting ；Elastic Weight Consolidation ） \item 基于正则化的方法。通过对神经权重的更新施加约束来减轻灾难性的遗忘，通常是在损失函数中引入了一个额外的正则化项，使得模型在学习新数据时巩固先前的知识\upcite{DBLP:journals/pami/LiH18a}。{\red Elastic Weight Consolidation}
\vspace{0.5em} \vspace{0.5em}
\item 基于实例的方法。以原始格式存储样本，或使用生成模型生成伪样本，在学习新任务的同时重放先前的任务样本以减轻遗忘。（iCaRL: Incremental Classifier and Representation Learning；End-to-End Incremental Learning ） \item 基于实例的方法。以原始格式存储样本，或使用生成模型生成伪样本，在学习新任务的同时重放先前的任务样本以减轻遗忘\upcite{DBLP:conf/cvpr/RebuffiKSL17,DBLP:conf/eccv/CastroMGSA18}。
\vspace{0.5em} \vspace{0.5em}
\item 基于动态模型架构的方法。例如，增加神经元或网络层进行重新训练，或者是在新任务训练时只更新部分参数。（Progressive Neural Networks；PathNet: Evolution Channels Gradient Descent in Super Neural Networks） \item 基于动态模型架构的方法。例如，增加神经元或网络层进行重新训练，或者是在新任务训练时只更新部分参数\upcite{rusu2016progressive,DBLP:journals/corr/FernandoBBZHRPW17}。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 从某种程度上看，机器翻译中的多领域、多语言等都属于持续学习的场景。在多领域神经机器翻译中，我们期望模型既有通用领域的性能，并且在特定领域也表现良好，然而事实上，适应特定领域往往是以牺牲通用领域的性能为代价的（Overcoming Catastrophic Forgetting During Domain Adaptation of Neural Machine Translation；Investigating Catastrophic Forgetting During Continual Training for Neural Machine Translation）。在多语言神经翻译中，最理想的情况是一个模型就能够实现在多个语言之间的映射，然而由于数据分布的极大不同，实际情况往往是：多语言模型能够提高低资源语言对互译的性能，但同时也会降低高资源语言对的性能。因此如何让模型从多语言训练数据中持续受益就是一个关键的问题。以上这些问题在{\chaptersixteen}和{\chaptereighteen}中还会有详细讨论。 \parinterval 从某种程度上看，机器翻译中的多领域、多语言等都属于持续学习的场景。在多领域神经机器翻译中，我们期望模型既有通用领域的性能，并且在特定领域也表现良好，然而事实上，适应特定领域往往是以牺牲通用领域的性能为代价的\upcite{DBLP:conf/naacl/ThompsonGKDK19,DBLP:conf/coling/GuF20}。在多语言神经翻译中，最理想的情况是一个模型就能够实现在多个语言之间的映射，然而由于数据分布的极大不同，实际情况往往是：多语言模型能够提高低资源语言对互译的性能，但同时也会降低高资源语言对的性能。因此如何让模型从多语言训练数据中持续受益就是一个关键的问题。以上这些问题在{\chaptersixteen}和{\chaptereighteen}中还会有详细讨论。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
...@@ -745,13 +953,13 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x}) ...@@ -745,13 +953,13 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\mathbf{y}} | \mathbf{x})
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 对抗样本除了用于提高模型的健壮性之外，还有很多其他的应用场景。其中最主要的便是用于评估模型。通过构建由对抗样本构造的数据集，可以验证模型对于不同类型噪声健壮性\upcite{DBLP:conf/emnlp/MichelN18}。正是由于对抗样本在检测和提高模型健壮性具有明显的效果，因此很多的研究人员在针对不同的任务提出了很多有效的方法。但是在生成对抗样本时常常要注意或考虑很多问题，比如扰动是否足够细微，在人类难以察觉的同时做到欺骗模型的目的，对抗样本在不同的模型结构或数据集上是否具有足够的泛化能力。生成的方法是否足够高效等等。（{\color{red}} 参考文献是不是有些少？加个2-3篇？） \item 对抗样本除了用于提高模型的健壮性之外，还有很多其他的应用场景。其中最主要的便是用于评估模型。通过构建由对抗样本构造的数据集，可以验证模型对于不同类型噪声健壮性\upcite{DBLP:conf/emnlp/MichelN18}。正是由于对抗样本在检测和提高模型健壮性具有明显的效果，因此很多的研究人员在针对不同的任务提出了很多有效的方法。但是在生成对抗样本时常常要注意或考虑很多问题，比如扰动是否足够细微，在人类难以察觉的同时做到欺骗模型的目的，对抗样本在不同的模型结构或数据集上是否具有足够的泛化能力。生成的方法是否足够高效等等。（{\color{red}参考文献是不是有些少？加个2-3篇？} ）
\vspace{0.5em} \vspace{0.5em}
\item 强化学习在MT的应用？ \item 强化学习在MT的应用？
\vspace{0.5em} \vspace{0.5em}
\item 从广义上说，大多数课程学习方法都是遵循由易到难的原则，然而在实践过程中人们逐渐赋予了课程学习更多的内涵，课程学习的含义早已超越了最原始的定义。一方面，课程学习可以与许多任务相结合，此时，评估准则并不一定总是样本的困难度，这取决于具体的任务，比如在多任务学习中（multi-task learning）（Curriculum learning of multiple tasks；Curriculum learning for multi-task classification of visual attributes），指的任务的难易程度或相关性；在领域适应任务中（Curriculum Learning for Domain Adaptation in Neural Machine Translation），指的是数据与领域的相似性；在噪声数据场景中，指的是样本的可信度（Dynamically Composing Domain-Data Selection with Clean-Data Selection by “Co-Curricular Learning” for Neural Machine Translation）。另一方面，在一些任务或数据中，由易到难并不总是有效，有时困难优先反而会取得更好的效果（Curriculum learning with deep convolutional neural networks；An empirical exploration of curriculum learning for neural machine translation），实际上这和我们的直觉不太符合，一种合理的解释是课程学习更适合标签噪声、离群值较多或者是目标任务困难的场景，能提高模型的健壮性和收敛速度，而困难优先则更适合数据集干净的场景，能使随机梯度下降更快更稳定（Active bias: Training more accurate neural networks by emphasizing high variance samples）。（{\color{red} 这段写得不错！}） \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}。（{\color{red} 这段写得不错！}）
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
Chapter14/chapter14.tex
...@@ -219,7 +219,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -219,7 +219,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\begin{example} \begin{example}
源语言句子：我们期待安理会尽早就此作出决定。 源语言句子：我们期待安理会尽早就此作出决定。
\qquad\ 机器译文\ \,1\ ：We look forward to the Security Council making a decision on this \qquad\ 机器译文\ \,1\ ：We look forward to the Security Council making a decision on this
\hspace{8.3em}as soon as possible. \hspace{8.3em}as soon as possible.
...@@ -405,7 +405,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -405,7 +405,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\section{非自回归翻译} \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 % NEW SUBSUB-SECTION
...@@ -429,7 +429,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -429,7 +429,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\label{eq:14-9} \label{eq:14-9}
\end{eqnarray} \end{eqnarray}
\noindent 其中，位置$j$上的输出$y_j$只依赖于输入句子$\seq{x}$，与其它位置上的输出无关。于是，所有位置上${y_j}$都可以并行生成，大大提高了GPU 等并行运算设备的利用率。这种方式一般可以带来几倍甚至十几倍的速度提升。 \noindent 其中，位置$j$上的输出$y_j$只依赖于输入句子$\seq{x}$，与其它位置上的输出无关。于是，所有位置上${y_j}$都可以并行生成，大大提高了GPU 等并行运算设备的利用率。理想情况下，这种方式一般可以带来几倍甚至十几倍的速度提升。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
...@@ -437,7 +437,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -437,7 +437,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{非自回归翻译模型的结构} \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值。这是因为每个位置词的分布$\funp{P}(y_j)$只依赖于源语言句子$\seq{x}$，使得$\funp{P}(y_j)$的预测不准确。
...@@ -450,7 +450,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -450,7 +450,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\end{figure} \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] \begin{figure}[htp]
...@@ -469,7 +469,10 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -469,7 +469,10 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsubsection{1. 基于繁衍率的非自回归模型} \subsubsection{1. 基于繁衍率的非自回归模型}
\parinterval 图\ref{fig:14-14}给出了基于繁衍率的Transformer非自回归模型的结构\upcite{Gu2017NonAutoregressiveNM}，由以下四个模块组成:编码器，解码器，繁衍率预测器和解码端的位置注意力模块。 \parinterval 图\ref{fig:14-14}给出了基于繁衍率的Transformer非自回归模型的结构\upcite{Gu2017NonAutoregressiveNM}，由以下四个模块组成:编码器，解码器，繁衍率预测器和解码端的位置注意力模块。与自回归翻译模型类似，Transformer模型的编码器和解码器都完全由前馈神经网络和多头注意力模块组成。在解码开始之前，非自回归模型需要知道译文的长度，以便并行生成所有单词。更重要的是，非自回归模型需要一次性生成出所有的译文单词，因此不能像自回归模型那样用已生成的词作为第一个解码器层的输入。
\parinterval 那么非自回归模型解码器的输入是什么呢？如果完全省略第一个解码器层的输入，或者仅使用位置嵌入，将会导致性能非常差。这里使用繁衍率来解决这个问题，繁衍率指的是对于每个源语言单词预测所对应的目标语言单词的个数（见{\chaptersix}）。这样，最终译文长度则由所有源语言单词对应的繁衍率之和决定（图\ref{fig:14-14}中的数字1\ 1\ 2\ 0\ 1表示繁衍率序列）。这个繁衍率序列可以通过外部词对齐工具得到，从而来训练这个繁衍率预测器。但由于外部词对齐系统会出现错误，因此在模型收敛之后，需要在繁衍率预测器上加一个强化学习的损失来进行微调。
%---------------------------------------------------------------------- %----------------------------------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -480,16 +483,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -480,16 +483,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\end{figure} \end{figure}
%---------------------------------------------------------------------- %----------------------------------------------------------------------
\parinterval 与自回归翻译模型类似，Transformer模型的编码器和解码器都完全由前馈神经网络和多头注意力模块组成。在解码开始之前，非自回归模型需要知道译文的长度，以便并行生成所有单词。更重要的是，非自回归模型需要一次性生成出所有的译文单词，因此不能像自回归模型那样用已生成的词作为第一个解码器层的输入。那么非自回归模型解码器的输入是什么呢？如果完全省略第一个解码器层的输入，或者仅使用位置嵌入，将会导致性能非常差。这里使用繁衍率来解决这个问题，繁衍率指的是对于每个源语言单词预测所对应的目标语言单词的个数（见\chaptersix）。翻译过程取决于繁衍率序列（图\ref{fig:14-14}中的数字1\ 1\ 2\ 0\ 1），最终译文长度则由所有源语言单词对应的繁衍率之和决定。这个繁衍率序列可以通过外部词对齐工具得到，从而来训练这个繁衍率预测器。但由于外部词对齐系统会出现错误，因此在模型收敛之后，需要在繁衍率预测器上加一个强化学习的损失来进行微调。 \parinterval 另外，在每个解码器层中还包括额外的位置注意力模块，该模块与Transformer模型的其它部分中使用的多头注意力机制相同。其仍然基于$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$之间的计算（见{\chaptertwelve}），只是把位置编码作为$\mathbi{Q}$ 和$\mathbi{K}$, 解码端上一层的输出作为$\mathbi{V}$。这种方法提供了更强的位置信息。
\parinterval 另外，在每个解码器层中还包括额外的位置注意力模块，该模块与Transformer模型的其它部分中使用的多头注意力机制相同，如公式\eqref{eq:14-10}：
\begin{eqnarray}
\textrm{Attention}(\mathbi{Q},\mathbi{K},\mathbi{V}) &=& \textrm{Softmax}(\frac{\mathbi{Q}{\mathbi{K}}^{T}}{\sqrt{d_k}})\cdot \mathbi{V}
\label{eq:14-10}
\end{eqnarray}
\noindent 其中，$d_k$表示模型的隐层大小，其中位置编码作为$\mathbi{Q}$和$\mathbi{K}$,解码端上一层的输出作为$\mathbi{V}$。将位置信息直接结合到注意力过程中，比单独的位置嵌入提供了更强的位置信息，同时该附加信息可能还会提高解码器执行局部重排序的能力。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION % NEW SUBSUB-SECTION
...@@ -499,7 +493,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -499,7 +493,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\parinterval 知识蒸馏的基本思路是让学生模型所表示的函数尽可能去拟合教师模型所表示的函数（见\chapterthirteen）。如果想要训练一个小模型，同时希望它的性能与大模型一样好，这时可以把大模型看作传授知识的“教师”，把小模型看作接受知识的“学生”。在训练时，先将输入送给教师模型，让它预测出概率分布，作为小模型的监督信息来计算损失函数，进而完成小模型的训练。 \parinterval 知识蒸馏的基本思路是让学生模型所表示的函数尽可能去拟合教师模型所表示的函数（见\chapterthirteen）。如果想要训练一个小模型，同时希望它的性能与大模型一样好，这时可以把大模型看作传授知识的“教师”，把小模型看作接受知识的“学生”。在训练时，先将输入送给教师模型，让它预测出概率分布，作为小模型的监督信息来计算损失函数，进而完成小模型的训练。
\parinterval 类似的，可以让自回归模型作为“教师”，非自回归模型作为“学生”。把自回归神经机器翻译生成的句子作为新的训练样本，送给非自回归机器翻译进行学习\upcite{Gu2017NonAutoregressiveNM,Lee2018DeterministicNN,Zhou2020UnderstandingKD,Guo2020FineTuningBC}。这种方式能够一定程度上解决多峰问题。因为，经过训练的自回归模型会始终将相同的源语言句子翻译成相同的译文。这样的操作得到的数据集噪声更少，能够降低非自回归模型学习的难度。 \parinterval 类似的，可以让自回归模型作为“教师”，非自回归模型作为“学生”。把自回归神经机器翻译模型生成的句子作为新的训练样本，送给非自回归机器翻译模型进行学习\upcite{Gu2017NonAutoregressiveNM,Lee2018DeterministicNN,Zhou2020UnderstandingKD,Guo2020FineTuningBC}。这种方式能够一定程度上解决多峰问题。因为，经过训练的自回归模型会始终将相同的源语言句子翻译成相同的译文。这样的操作得到的数据集噪声更少，能够降低非自回归模型学习的难度。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION % NEW SUBSUB-SECTION
...@@ -515,11 +509,11 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -515,11 +509,11 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{更好的训练目标} \subsection{更好的训练目标}
\parinterval 虽然非自回归翻译可以显著提升翻译速度，但是很多情况下其翻译质量还是低于传统的自回归翻译\upcite{Gu2017NonAutoregressiveNM,Kaiser2018FastDI,Guo2020FineTuningBC}。因此，很多工作致力于缩小自回归模型和非自回归模型的性能差距\upcite{Ran2020LearningTR,Tu2020ENGINEEI,Shu2020LatentVariableNN}。一些方法通常通过修改训练目标来达到提升非自回归翻译品质的目的，例如： \parinterval 虽然非自回归翻译可以显著提升翻译速度，但是很多情况下其翻译质量还是低于传统的自回归翻译\upcite{Gu2017NonAutoregressiveNM,Kaiser2018FastDI,Guo2020FineTuningBC}。因此，很多工作致力于缩小自回归模型和非自回归模型的性能差距\upcite{Ran2020LearningTR,Tu2020ENGINEEI,Shu2020LatentVariableNN}。一些通常通过修改训练目标来达到提升非自回归翻译品质的目的，例如：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 基于层级知识蒸馏的方法\upcite{Li2019HintBasedTF}。由于自回归模型和非自回归模型的结构相差不大，因此可以将翻译质量更高的自回归模型作为“教师”，通过给非自回归模型提供监督信号，使其逐块地学习前者的分布。研究人员发现了两点非常有意思的现象：1）非自回归模型输出的重复单词的位置的隐藏状态非常相似。2）非自回归模型的注意力分布比自回归模型的分布更加分散。这两点发现启发了研究人员使用自回归模型中的隐层状态来指导非自回归模型学习。通过计算两个模型隐层状态的距离以及注意力矩阵的KL散度\footnote{KL散度即相对熵}作为额外的损失来帮助非自回归模型的训练过程。 \item 基于层级知识蒸馏的方法\upcite{Li2019HintBasedTF}。由于自回归模型和非自回归模型的结构相差不大，因此可以将翻译质量更高的自回归模型作为“教师”，通过给非自回归模型提供监督信号，使其逐块地学习前者的分布。研究人员发现了两点非常有意思的现象：1）非自回归模型输出的重复单词的位置的隐藏状态非常相似。2）非自回归模型的注意力分布比自回归模型的分布更加分散。这两点发现启发了研究人员使用自回归模型中的隐层状态来指导非自回归模型学习。通过计算两个模型隐层状态的距离以及注意力矩阵的KL散度\footnote{KL散度即相对熵。}作为额外的损失来帮助非自回归模型的训练过程。
\vspace{0.5em} \vspace{0.5em}
\item 基于模仿学习的方法\upcite{Wei2019ImitationLF}。这种观点认为非自回归模型可以从性能优越的自回归模型中学得知识。{\small\bfnew{模仿学习}}\index{模仿学习}（Imitation Learning\index{Imitation Learning}）是强化学习中的一个概念，即从专家那里学习正确的行为，与监督学习很相似\upcite{Ho2016ModelFreeIL,Ho2016GenerativeAI,Duan2017OneShotIL}。与其不同的是，模仿学习不是照搬专家的行为，而是学习专家为什么要那样做。换句话说，学习的不是专家的镜像，而是一个专家的行为分布。这里，可以将自回归模型作为专家，非自回归模型学习不同时间步和不同层的解码状态，最后将模仿学习的损失与交叉熵损失加权求和后作为最终的优化目标。 \item 基于模仿学习的方法\upcite{Wei2019ImitationLF}。这种观点认为非自回归模型可以从性能优越的自回归模型中学得知识。{\small\bfnew{模仿学习}}\index{模仿学习}（Imitation Learning\index{Imitation Learning}）是强化学习中的一个概念，即从专家那里学习正确的行为，与监督学习很相似\upcite{Ho2016ModelFreeIL,Ho2016GenerativeAI,Duan2017OneShotIL}。与其不同的是，模仿学习不是照搬专家的行为，而是学习专家为什么要那样做。换句话说，学习的不是专家的镜像，而是一个专家的行为分布。这里，可以将自回归模型作为专家，非自回归模型学习不同时间步和不同层的解码状态，最后将模仿学习的损失与交叉熵损失加权求和后作为最终的优化目标。
\vspace{0.5em} \vspace{0.5em}
...@@ -533,9 +527,9 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -533,9 +527,9 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{引入自回归模块} \subsection{引入自回归模块}
\parinterval 非自回归翻译消除了序列生成中不同位置间的依赖，在每个位置都进行独立的预测，但这反过来会导致翻译质量显着下降，因为缺乏不同单词间依赖关系的建模。因此，也有研究聚焦于在非自回归模型中添加一些自回归组件来提升网络结构的表达能力。 \parinterval 非自回归翻译消除了序列生成中不同位置间的依赖，在每个位置都进行独立的预测，但这反过来会导致翻译质量显着下降，因为缺乏对不同单词间依赖关系的建模。因此，可以考虑在非自回归模型中添加一些自回归组件来提升网络结构的表达能力。
\parinterval 一种做法是将语法作为目标语言句子的框架\upcite{Akoury2019SyntacticallyST}。具体来说，先自回归地预测出一个目标语言的句法块序列，将句法树作为序列信息的抽象，然后根据句法块序列非自回归地生成所有目标语言单词。如图\ref{fig:14-21}所示,该模型由一个编码器和两个解码器组成。其中编码器和第一个解码器与标准的Transformer模型相同，用来自回归地预测句法树信息；第二个解码器将第一个解码器的句法信息作为输入，之后再非自回归地生成整个译文。在训练过程中，通过使用外部句法分析器获得对句法预测任务的监督信号。虽然可以简单地让模型预测整个句法树，但是这种方法会显著增加自回归步骤的数量，从而增大时间开销。因此，为了维持句法信息与解码时间的平衡，这里预测一些由句法类型和子树大小组成的块标识符（如VP3）而不是整个句法树。 \parinterval 一种做法是将句法信息作为目标语言句子的框架\upcite{Akoury2019SyntacticallyST}。具体来说，先自回归地预测出一个目标语言的句法块序列，将句法树作为序列信息的抽象，然后根据句法块序列非自回归地生成所有目标语言单词。如图\ref{fig:14-21}所示,该模型由一个编码器和两个解码器组成。其中编码器和第一个解码器与标准的Transformer模型相同，用来自回归地预测句法树信息；第二个解码器将第一个解码器的句法信息作为输入，之后再非自回归地生成整个译文。在训练过程中，通过使用外部句法分析器获得对句法预测任务的监督信号。虽然可以简单地让模型预测整个句法树，但是这种方法会显著增加自回归步骤的数量，从而增大时间开销。因此，为了维持句法信息与解码时间的平衡，这里预测一些由句法标记和子树大小组成的块标识符（如VP3）而不是整个句法树。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -546,7 +540,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -546,7 +540,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 另一种做法是半自回归地生成译文\upcite{Wang2018SemiAutoregressiveNM}。如图\ref{fig:14-20}所示，自回归模型从左到右依次生成译文，具有“最强”的自回归性；而非自回归模型完全独立的生成每个译文单词，具有“最弱”的自回归性；半自回归模型则是将整个译文分成$k$个块，在组内执行非自回归解码，在组间则执行自回归的解码，能够在每个时间步并行产生多个连续的单词。通过调整块的大小，半自回归模型可以灵活的调整到自回归模型（当$k$等于1）和非自回归模型（当$k$大于最大的译文长度）上来。 \parinterval 另一种做法是半自回归地生成译文\upcite{Wang2018SemiAutoregressiveNM}。如图\ref{fig:14-20}所示，自回归模型从左到右依次生成译文，具有“最强”的自回归性；而非自回归模型完全独立的生成每个译文单词，具有“最弱”的自回归性；半自回归模型则是将整个译文分成$k$个块，在组内执行非自回归解码，在组间则执行自回归的解码，能够在每个时间步并行产生多个连续的单词。通过调整块的大小，半自回归模型可以灵活的调整到自回归模型（当$k$等于1）和非自回归模型（当$k$大于等于最大的译文长度）上来。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -574,7 +568,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -574,7 +568,7 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{基于迭代精化的非自回归翻译模型} \subsection{基于迭代精化的非自回归翻译模型}
\parinterval 如果一次并行生成整个序列，往往会导致单词之间的关系很难捕捉，因此也限制了这类方法的能力。即使生成了错误的译文单词，这类方法也无法修改。针对这些问题，也可以使用迭代式的生成方式\upcite{Lee2018DeterministicNN,Ghazvininejad2019MaskPredictPD,Kasai2020NonAutoregressiveMT}。这种方法放弃了一次生成最终的译文句子，而是将解码出的文本再重新送给解码器，在每次迭代中来改进之前生成的译文单词，可以理解为句子级的自回归模型。这样做的好处在于，每次迭代的过程中可以利用已经生成的部分翻译结果，来指导其它部分的生成。 \parinterval 如果一次并行生成整个序列，往往会导致单词之间的关系很难捕捉，即使生成了错误的译文单词，这类方法也无法修改。针对这些问题，也可以使用迭代式的生成方式\upcite{Lee2018DeterministicNN,Ghazvininejad2019MaskPredictPD,Kasai2020NonAutoregressiveMT}。这种方法放弃了一次生成最终的译文句子，而是将解码出的译文再重新送给解码器，在每次迭代中来改进之前生成的译文单词，可以理解为句子级的自回归模型。这样做的好处在于，每次迭代的过程中可以利用已经生成的部分翻译结果，来指导其它部分的生成。
\parinterval 图\ref{fig:14-18}展示了这种方法的简单示例。它拥有一个编码器和$N$个解码器。编码器首先预测出译文的长度，然后将输入$\seq{x}$按照长度复制出$\seq{x'}$作为第一个解码器的输入，之后生成$\seq{y'}$作为第一轮迭代的输出。接下来再把$\seq{y'}$输入给第二个解码器输出$\seq{y''}$，以此类推。那么迭代到什么时候结束呢？一种简单的做法是提前制定好迭代次数，这种方法能够自主地对生成句子的质量和效率进行平衡。另一种称之为“自适应”的方法，具体是通过计算当前生成的句子上一次生成的变化量来自动停止，例如，使用杰卡德相似系数作为变化量函数\footnote{杰卡德相似系数是衡量有限样本集之间的相似性与差异性的一种指标，杰卡德相似系数值越大，样本相似度越高。}。另外，需要说明的是，图\ref{fig:14-18}中是使用多个解码器的一种逻辑示意。真实的系统仅需要一个解码器，并运行多次，就达到了迭代精化的目的。 \parinterval 图\ref{fig:14-18}展示了这种方法的简单示例。它拥有一个编码器和$N$个解码器。编码器首先预测出译文的长度，然后将输入$\seq{x}$按照长度复制出$\seq{x'}$作为第一个解码器的输入，之后生成$\seq{y'}$作为第一轮迭代的输出。接下来再把$\seq{y'}$输入给第二个解码器输出$\seq{y''}$，以此类推。那么迭代到什么时候结束呢？一种简单的做法是提前制定好迭代次数，这种方法能够自主地对生成句子的质量和效率进行平衡。另一种称之为“自适应”的方法，具体是通过计算当前生成的句子上一次生成的变化量来自动停止，例如，使用杰卡德相似系数作为变化量函数\footnote{杰卡德相似系数是衡量有限样本集之间的相似性与差异性的一种指标，杰卡德相似系数值越大，样本相似度越高。}。另外，需要说明的是，图\ref{fig:14-18}中是使用多个解码器的一种逻辑示意。真实的系统仅需要一个解码器，并运行多次，就达到了迭代精化的目的。
...@@ -582,20 +576,20 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -582,20 +576,20 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\input{./Chapter14/Figures/figure-iteration} \input{./Chapter14/Figures/figure-iteration}
\caption{基于迭代精化的非自回归翻译模型} \caption{基于迭代精化的非自回归翻译模型运行示例}
\label{fig:14-18} \label{fig:14-18}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 除了使用上一个步骤的输出，当前解码器的输入还使用了添加噪声的正确目标语言句子，两种使用情况之间使用一个超参数控制\upcite{Lee2018DeterministicNN}。另外，对于译文长度的预测，本章使用编码端的输出单独训练了一个独立的长度预测模块，这种方法也推广到了目前大多数模型上。 \parinterval 除了使用上一个步骤的输出，当前解码器的输入还使用了添加噪声的正确目标语言句子，两种使用情况之间使用一个超参数控制\upcite{Lee2018DeterministicNN}。另外，对于译文长度的预测，本章使用编码端的输出单独训练了一个独立的长度预测模块，这种方法也推广到了目前大多数模型上。
\parinterval 另一种方法借鉴了BERT的思想\upcite{devlin2019bert}，提出了一种新的解码方法：Mask-Predict\upcite{Ghazvininejad2019MaskPredictPD}。类似于BERT中的[CLS]，该方法在源语言句子的最前面加上了一个特殊符号[LEN]作为输入，用来预测目标句的长度$n$。之后，将特殊符[Mask]（与BERT中的[Mask]有相似的含义）复制$n$次作为解码器的输入，然后用非自回归的方式生成目标端所有的词。这样生成的翻译可能是比较差的，因此可以将第一次生成的这些词中不确定（即生成概率比较低）的一些词再“擦”掉，依据目标端剩余的单词以及源语言句子重新进行预测，不断迭代，直到满足停止条件为止。图\ref{fig:14-19}给出了一个示例。 \parinterval 另一种方法借鉴了BERT的思想\upcite{devlin2019bert}，称为Mask-Predict\upcite{Ghazvininejad2019MaskPredictPD}。类似于BERT中的[CLS]，该方法在源语言句子的最前面加上了一个特殊符号[LEN]作为输入，用来预测目标句的长度$n$。之后，将特殊符[Mask]（与BERT中的[Mask]有相似的含义）复制$n$次作为解码器的输入，然后用非自回归的方式生成目标端所有的词。这样生成的翻译可能是比较差的，因此可以将第一次生成的这些词中不确定（即生成概率比较低）的一些词再“擦”掉，依据目标端剩余的单词以及源语言句子重新进行预测，不断迭代，直到满足停止条件为止。图\ref{fig:14-19}给出了一个示例。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\input{./Chapter14/Figures/figure-mask-predict} \input{./Chapter14/Figures/figure-mask-predict}
\caption{Mask-Predict的模型结构} \caption{Mask-Predict方法的运行示例}
\label{fig:14-19} \label{fig:14-19}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
...@@ -717,21 +711,19 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4} ...@@ -717,21 +711,19 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\section{小结与扩展阅读} \section{小结与扩展阅读}
\parinterval 推断系统（或解码系统）是神经机器翻译的重要组成。在神经机器翻译研究中，单独就推断问题进行的讨论并不多见。更多的工作是将其与实践结合，常见于开源系统、评测比赛中。但是，从应用的角度看，研发高效的推断系统是机器翻译能够被大规模使用的前提。本章也从神经机器翻译推断的基本问题出发，重点探讨了推断系统的效率、非自回归翻译、多模型集成等问题。但是，由于推断问题涉及的问题十分广泛，因此本章也无法对其进行全面覆盖。有若干研究方向值得关注： \parinterval 推断系统（或解码系统）是神经机器翻译的重要组成部分。在神经机器翻译研究中，单独就推断问题开展的讨论并不多见。更多的工作是将其与实践结合，常见于开源系统、评测比赛中。但是，从应用的角度看，研发高效的推断系统是机器翻译能够被大规模使用的前提。本章也从神经机器翻译推断的基本问题出发，重点探讨了推断系统的效率、非自回归翻译、多模型集成等问题。但是，由于推断问题涉及的问题十分广泛，因此本章也无法对其进行全面覆盖。有若干研究方向值得关注：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 机器翻译系统中的推断也借用了{\small\sffamily\bfseries{统计推断}}\index{统计推断}（Statistical Inference）\index{Statistical Inference}的概念。传统意义上讲，这类方法都是在利用样本数据去推测总体的趋势和特征。因此，从统计学的角度也有很多不同的思路。例如，贝叶斯学习等方法就在自然语言处理中得到广泛应用\upcite{Held2013AppliedSI,Silvey2018StatisticalI}。其中比较有代表性的是{\small\sffamily\bfseries{变分方法}}\index{变分方法}（Variational Methods）\index{Variational Methods}。这类方法通过引入新的隐含变量来对样本的分布进行建模，从某种意义上说它是在描述“分布的分布”，因此这种方法对事物的统计规律描述得更加细致\upcite{Beal2003VariationalAF}。这类方法也被成功地用于统计机器翻译\upcite{Li2009VariationalDF,xiao2011language,}和神经机器翻译\upcite{Bastings2019ModelingLS,Shah2018GenerativeNM,Su2018VariationalRN,Zhang2016VariationalNM}。 \item 机器翻译系统中的推断也借用了{\small\sffamily\bfseries{统计推断}}\index{统计推断}（Statistical Inference）\index{Statistical Inference}的概念。传统意义上讲，这类方法都是在利用样本数据去推测总体的趋势和特征。因此，从统计学的角度也有很多不同的思路。例如，贝叶斯学习等方法就在自然语言处理中得到广泛应用\upcite{Held2013AppliedSI,Silvey2018StatisticalI}。其中比较有代表性的是{\small\sffamily\bfseries{变分方法}}\index{变分方法}（Variational Methods）\index{Variational Methods}。这类方法通过引入新的隐含变量来对样本的分布进行建模，从某种意义上说它是在描述“分布的分布”，因此这种方法对事物的统计规律描述得更加细致\upcite{Beal2003VariationalAF}。这类方法也被成功地用于统计机器翻译\upcite{Li2009VariationalDF,xiao2011language,}和神经机器翻译\upcite{Bastings2019ModelingLS,Shah2018GenerativeNM,Su2018VariationalRN,Zhang2016VariationalNM}。
\vspace{0.5em} \vspace{0.5em}
\item 推断系统也可以受益于更加高效的网络结构。这方面工作集中在结构化剪枝、减少模型的冗余计算、低秩分解等方向。结构化剪枝中的代表性工作是LayerDrop\upcite{DBLP:conf/iclr/FanGJ20,DBLP:conf/emnlp/WangXZ20,DBLP:journals/corr/abs-2002-02925}，这类方法在训练时随机选择部分子结构，在推断时根据输入来选择模型中的部分层进行计算，而跳过其余层，达到加速和减少参数量的目的。有关减少冗余计算的研究主要集中在改进注意力机制上，本章正文中已经有所介绍。低秩分解则针对词向量或者注意力的映射矩阵进行改进，例如词频自适应表示\upcite{DBLP:conf/iclr/BaevskiA19}，词频越高则对应的向量维度越大，反之则越小，或者层数越高注意力映射矩阵维度越小\upcite{DBLP:journals/corr/abs-2006-04768,DBLP:journals/corr/abs-1911-12385,DBLP:journals/corr/abs-1906-09777,DBLP:conf/nips/YangLSL19}。在实践中比较有效的是较深的编码器与较浅的解码器结合的方式，极端情况下解码器仅使用1层神经网络即可取得与多层神经网络相媲美的翻译精度，而极大地提升翻译效率\upcite{DBLP:journals/corr/abs-2006-10369,DBLP:conf/aclnmt/HuLLLLWXZ20,DBLP:journals/corr/abs-2010-02416}。在{\chapterfifteen}还会进一步对高效神经机器翻译的模型结构进行讨论。 \item 推断系统也可以受益于更加高效的网络结构。这方面工作集中在结构化剪枝、减少模型的冗余计算、低秩分解等方向。结构化剪枝中的代表性工作是LayerDrop\upcite{DBLP:conf/iclr/FanGJ20,DBLP:conf/emnlp/WangXZ20,DBLP:journals/corr/abs-2002-02925}，这类方法在训练时随机选择部分子结构，在推断时根据输入来选择模型中的部分层进行计算，而跳过其余层，达到加速和减少参数量的目的。有关减少冗余计算的研究主要集中在改进注意力机制上，本章中已经有所介绍。低秩分解则针对词向量或者注意力的映射矩阵进行改进，例如词频自适应表示\upcite{DBLP:conf/iclr/BaevskiA19}，词频越高则对应的向量维度越大，反之则越小，或者层数越高注意力映射矩阵维度越小\upcite{DBLP:journals/corr/abs-2006-04768,DBLP:journals/corr/abs-1911-12385,DBLP:journals/corr/abs-1906-09777,DBLP:conf/nips/YangLSL19}。在实践中比较有效的是较深的编码器与较浅的解码器结合的方式，极端情况下解码器仅使用1层神经网络即可取得与多层神经网络相媲美的翻译精度，而极大地提升翻译效率\upcite{DBLP:journals/corr/abs-2006-10369,DBLP:conf/aclnmt/HuLLLLWXZ20,DBLP:journals/corr/abs-2010-02416}。在{\chapterfifteen}还会进一步对高效神经机器翻译的模型结构进行讨论。
\vspace{0.5em} \vspace{0.5em}
\item 在对机器翻译推断系统进行实际部署时，对存储的消耗也是需要考虑的因素。因此如何让模型变得更小也是研发人员所关注的方向。当前的模型压缩方法主要可以分为几类：剪枝、量化、知识蒸馏和轻量方法，其中轻量方法主要是更轻量模型结构的设计，这类方法已经在上文进行了介绍。剪枝主要包括权重大小剪枝\upcite{Han2015LearningBW,Lee2019SNIPSN,Frankle2019TheLT,Brix2020SuccessfullyAT}、面向多头注意力的剪枝\upcite{Michel2019AreSH,DBLP:journals/corr/abs-1905-09418}、网络层以及其他部分的剪枝等\upcite{Liu2017LearningEC,Liu2019RethinkingTV}，还有一些方法也通过在训练期间采用正则化的方式来提升剪枝能力\upcite{DBLP:conf/iclr/FanGJ20}。量化方法主要通过截断浮点数来减少模型的存储大小，使其仅使用几个比特位的数字表示方法便能存储整个模型，虽然会导致舍入误差，但压缩效果显著\upcite{DBLP:journals/corr/abs-1906-00532,Cheong2019transformersZ,Banner2018ScalableMF,Hubara2017QuantizedNN}。一些方法利用知识蒸馏手段还将Transformer模型蒸馏成如LSTMs 等其他各种推断速度更快的架构\upcite{DBLP:journals/corr/HintonVD15,Munim2019SequencelevelKD,Tang2019DistillingTK}。另外还有一些其他方法不仅在输出上，还在权重矩阵和隐藏的激活层上对“教师模型”知识进行更深入的挖掘\upcite{Jiao2020TinyBERTDB}。 \item 在对机器翻译推断系统进行实际部署时，对存储的消耗也是需要考虑的因素。因此如何让模型变得更小也是研发人员所关注的方向。当前的模型压缩方法主要可以分为几类：剪枝、量化、知识蒸馏和轻量方法，其中轻量方法主要是基于更轻量模型结构的设计，这类方法已经在上文进行了介绍。剪枝主要包括权重大小剪枝\upcite{Han2015LearningBW,Lee2019SNIPSN,Frankle2019TheLT,Brix2020SuccessfullyAT}、 面向多头注意力的剪枝\upcite{Michel2019AreSH,DBLP:journals/corr/abs-1905-09418}、网络层以及其他部分的剪枝等\upcite{Liu2017LearningEC,Liu2019RethinkingTV}，还有一些方法也通过在训练期间采用正则化的方式来提升剪枝能力\upcite{DBLP:conf/iclr/FanGJ20}。量化方法主要通过截断浮点数来减少模型的存储大小，使其仅使用几个比特位的数字表示方法便能存储整个模型，虽然会导致舍入误差，但压缩效果显著\upcite{DBLP:journals/corr/abs-1906-00532,Cheong2019transformersZ,Banner2018ScalableMF,Hubara2017QuantizedNN}。一些方法利用知识蒸馏手段还将Transformer模型蒸馏成如LSTMs 等其他各种推断速度更快的架构\upcite{DBLP:journals/corr/HintonVD15,Munim2019SequencelevelKD,Tang2019DistillingTK}。另外还有一些其他方法不仅在输出上，还在权重矩阵和隐藏的激活层上对“教师模型”知识进行更深入的挖掘\upcite{Jiao2020TinyBERTDB}。
\vspace{0.5em} \vspace{0.5em}
\item 目前的翻译模型使用交叉熵损失作为优化函数，这在自回归模型上取得了非常优秀的性能。交叉熵是一个严格的损失函数，预测时位置错误的单词都会受到惩罚，即使是编辑距离很小的输出序列。回归模型会避免这种惩罚，因为单词是根据句子前一个词来生成的，而非自回归模型无法获知这个信息。为此，一些研究工作通过改进损失函数来提高非自回归模型的性能。一种做法使用对齐交叉熵函数\upcite{Ghazvininejad2020AlignedCE}，其基于标签序列和译文单词分布预测序列之间的对齐来计算交叉熵损失，采用动态规划的方法寻找单调对齐使交叉熵损失最小化。也可以使用基于$n$-gram的训练目标\upcite{Shao2020MinimizingTB}，希望能最小化模型与参考译文间$n$-gram的差异。该训练目标在$n$-gram的层面上评估预测结果，因此能够建模序列依赖关系。 \item 目前的翻译模型使用交叉熵损失作为优化函数，这在自回归模型上取得了非常优秀的性能。交叉熵是一个严格的损失函数，预测时位置错误的单词都会受到惩罚，即使是编辑距离很小的输出序列。回归模型会避免这种惩罚，因为单词是根据句子前一个词来生成的，而非自回归模型无法获知这个信息。为此，一些研究工作通过改进损失函数来提高非自回归模型的性能。一种做法使用对齐交叉熵函数\upcite{Ghazvininejad2020AlignedCE}，其基于标签序列和译文单词分布预测序列之间的对齐来计算交叉熵损失，采用动态规划的方法寻找单调对齐使交叉熵损失最小化。也可以使用基于$n$-gram的训练目标\upcite{Shao2020MinimizingTB}，希望能最小化模型与参考译文间$n$-gram的差异。该训练目标在$n$-gram的层面上评估预测结果，因此能够建模序列依赖关系。
\vspace{0.5em} \vspace{0.5em}
\item 自回归模型预测目标句时，当前词的生成是以之前已生成的词作为条件的，已生成词提供了较强的目标端上下文信息。然而，非自回归模型并行地生成所有词，因此不存在这样的信息。与自回归模型相比，非自回归模型的解码器需要在信息更少的情况下执行翻译任务。因此很多做法通过给非自回归模型的解码器端引入更多的信息，来降低模型的搜索空间。一些研究工作通过将条件随机场引入非自回归模型中来对结构依赖进行建模\upcite{Ma2019FlowSeqNC}。也有工作引入了一个词嵌入转换矩阵来将源端的词嵌入转换为目标端的词嵌入来增强解码端的输入\upcite{Guo2019NonAutoregressiveNM}。此外，研究人员也提出了轻量级的重排序模块来显式地 \item 自回归模型预测目标句时，当前词的生成是以之前已生成的词作为条件的，已生成词提供了较强的目标端上下文信息。然而，非自回归模型并行地生成所有词，因此不存在这样的信息。与自回归模型相比，非自回归模型的解码器需要在信息更少的情况下执行翻译任务。因此很多做法通过给非自回归模型的解码器端引入更多的信息，来降低模型的搜索空间。一些研究工作通过将条件随机场引入非自回归模型中来对结构依赖进行建模\upcite{Ma2019FlowSeqNC}。也有工作引入了一个词嵌入转换矩阵来将源端的词嵌入转换为目标端的词嵌入，进而强化解码端输入的表示结果\upcite{Guo2019NonAutoregressiveNM}。此外，研究人员也提出了轻量级的重排序模块，以提升非自回归模型的解码效果\upcite{Ran2019GuidingNN}。
建模重排序信息，以指导非自回归模型的解码\upcite{Ran2019GuidingNN}。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
......
Chapter15/Figures/figure-activation-function-swish-structure-diagram.tex deleted 100644 → 0
%%% outline
%-------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{opt}=[draw,minimum height=2em,minimum width=4em,rounded corners=2pt,thick]
\node[circle,minimum size=2em,draw,fill=red!20] (x1) at (0,0) {\small\bfnew{X}};
\node[circle,minimum size=2em,draw,fill=red!20] (x2) at (0,4em) {\small\bfnew{X}};
\node[circle,minimum size=2em,draw,fill=red!20] (x3) at (0,-5em) {\small\bfnew{X}};
\node[anchor=west,opt,fill=yellow!20] (unary1) at ([xshift=3em]x1.east){\small\bfnew{Unary}};
\node[anchor=west,opt,fill=yellow!20] (unary2) at ([xshift=3em]x2.east){\small\bfnew{Unary}};
\node[opt,fill=blue!20] (binary1) at (12em,2em){\small\bfnew{Binary}};
\node[opt,fill=blue!20] (binary2) at (25em,-1.5em){\small\bfnew{Binary}};
\node[anchor=west,opt,fill=yellow!20] (unary3) at ([xshift=3em]binary1.east){\small\bfnew{Unary}};
\node[anchor=west,opt,fill=yellow!20] (unary4) at ([xshift=16em]x3.east){\small\bfnew{Unary}};
\draw[-latex,very thick] (x1.0) -- (unary1.180);
\draw[-latex,very thick] (x2.0) -- (unary2.180);
\draw[-latex,very thick] (x3.0) -- (unary4.180);
\draw[-latex,very thick] (unary1.0) -- ([yshift=-0.2em]binary1.180);
\draw[-latex,very thick] (unary2.0) -- ([yshift=0.2em]binary1.180);
\draw[-latex,very thick] (binary1.0) -- (unary3.180);
\draw[-latex,very thick] (unary3.0) -- ([yshift=0.2em]binary2.180);
\draw[-latex,very thick] (unary4.0) -- ([yshift=-0.2em]binary2.180);
\begin{pgfonlayer}{background}
\node[draw=lightgray,fill=lightgray!50,rounded corners=2pt,inner sep=8pt][fit=(x2)(x1)(binary1)]{};
\end{pgfonlayer}
\node[anchor=south] at ([yshift=1em]binary1.north){\small\bfnew{Core Unit}};
\end{tikzpicture}
Chapter15/Figures/figure-encoder-structure-of-transformer-model-optimized-by-nas.tex
...@@ -3,22 +3,22 @@ ...@@ -3,22 +3,22 @@
%left %left
\begin{scope} \begin{scope}
\foreach \x/\d in {1/2em, 2/8em, 3/18em, 4/24em} \foreach \x/\d in {1/2em, 2/8em}
\node[unit,fill=yellow!20] at (0,\d) (ln_\x) {层正则}; \node[unit,fill=yellow!20] at (0,\d) (ln_\x) {层正则化};
\foreach \x/\d in {1/4em, 2/20em} \foreach \x/\d in {1/4em}
\node[unit,fill=green!20] at (0,\d) (sa_\x) {8头自注意力：512}; \node[unit,fill=green!20] at (0,\d) (sa_\x) {8头自注意力：512};
\foreach \x/\d in {1/6em, 2/16em, 3/22em, 4/32em} \foreach \x/\d in {1/6em, 2/16em}
\node[draw,circle,minimum size=1em,inner sep=1pt] at (0,\d) (add_\x) {\scriptsize\bfnew{+}}; \node[draw,circle,minimum size=1em,inner sep=1pt] at (0,\d) (add_\x) {\scriptsize\bfnew{+}};
\foreach \x/\d in {2/14em, 4/30em} \foreach \x/\d in {2/14em}
\node[unit,fill=red!20] at (0,\d) (conv_\x) {卷积$1 \times 1$：512}; \node[unit,fill=red!20] at (0,\d) (conv_\x) {卷积$1 \times 1$：512};
\foreach \x/\d in {1/10em,3/26em} \foreach \x/\d in {1/10em}
\node[unit,fill=red!20] at (0,\d) (conv_\x) {卷积$1 \times 1$：2048}; \node[unit,fill=red!20] at (0,\d) (conv_\x) {卷积$1 \times 1$：2048};
\foreach \x/\d in {1/12em, 2/28em} \foreach \x/\d in {1/12em}
\node[unit,fill=blue!20] at (0,\d) (relu_\x) {RELU}; \node[unit,fill=blue!20] at (0,\d) (relu_\x) {RELU};
\draw[->,thick] ([yshift=-1.4em]ln_1.-90) -- ([yshift=-0.1em]ln_1.-90); \draw[->,thick] ([yshift=-1.4em]ln_1.-90) -- ([yshift=-0.1em]ln_1.-90);
...@@ -29,80 +29,55 @@ ...@@ -29,80 +29,55 @@
\draw[->,thick] ([yshift=0.1em]conv_1.90) -- ([yshift=-0.1em]relu_1.-90); \draw[->,thick] ([yshift=0.1em]conv_1.90) -- ([yshift=-0.1em]relu_1.-90);
\draw[->,thick] ([yshift=0.1em]relu_1.90) -- ([yshift=-0.1em]conv_2.-90); \draw[->,thick] ([yshift=0.1em]relu_1.90) -- ([yshift=-0.1em]conv_2.-90);
\draw[->,thick] ([yshift=0.1em]conv_2.90) -- ([yshift=-0.1em]add_2.-90); \draw[->,thick] ([yshift=0.1em]conv_2.90) -- ([yshift=-0.1em]add_2.-90);
\draw[->,thick] ([yshift=0.1em]add_2.90) -- ([yshift=-0.1em]ln_3.-90); \draw[->,thick] ([yshift=0.1em]add_2.90) -- ([yshift=1em]add_2.90);
\draw[->,thick] ([yshift=0.1em]ln_3.90) -- ([yshift=-0.1em]sa_2.-90);
\draw[->,thick] ([yshift=0.1em]sa_2.90) -- ([yshift=-0.1em]add_3.-90);
\draw[->,thick] ([yshift=0.1em]add_3.90) -- ([yshift=-0.1em]ln_4.-90);
\draw[->,thick] ([yshift=0.1em]ln_4.90) -- ([yshift=-0.1em]conv_3.-90);
\draw[->,thick] ([yshift=0.1em]conv_3.90) -- ([yshift=-0.1em]relu_2.-90);
\draw[->,thick] ([yshift=0.1em]relu_2.90) -- ([yshift=-0.1em]conv_4.-90);
\draw[->,thick] ([yshift=0.1em]conv_4.90) -- ([yshift=-0.1em]add_4.-90);
\draw[->,thick] ([yshift=0.1em]add_4.90) -- ([yshift=1em]add_4.90);
\draw[->,thick] ([yshift=-0.8em]ln_1.-90) .. controls ([xshift=5em,yshift=-0.8em]ln_1.-90) and ([xshift=5em]add_1.0) .. (add_1.0); \draw[->,thick] ([yshift=-0.8em]ln_1.-90) .. controls ([xshift=5em,yshift=-0.8em]ln_1.-90) and ([xshift=5em]add_1.0) .. (add_1.0);
\draw[->,thick] (add_1.0) .. controls ([xshift=5em]add_1.0) and ([xshift=5em]add_2.0) .. (add_2.0); \draw[->,thick] (add_1.0) .. controls ([xshift=5em]add_1.0) and ([xshift=5em]add_2.0) .. (add_2.0);
\draw[->,thick] (add_2.0) .. controls ([xshift=5em]add_2.0) and ([xshift=5em]add_3.0) .. (add_3.0);
\draw[->,thick] (add_3.0) .. controls ([xshift=5em]add_3.0) and ([xshift=5em]add_4.0) .. (add_4.0);
\node[font=\scriptsize] at (0em, -1em){(a) Transformer编码器中若干块的结构}; \node[font=\scriptsize] at (0em, -1em){(a) Transformer编码器中若干块的结构};
\end{scope} \end{scope}
%right %right
\begin{scope}[xshift=14em] \begin{scope}[xshift=14em]
\foreach \x/\d in {1/2em, 2/8em, 3/16em, 4/22em, 5/28em} \foreach \x/\d in {1/2em, 2/8em, 3/14em}
\node[unit,fill=yellow!20] at (0,\d) (ln_\x) {层正则}; \node[unit,fill=yellow!20] at (0,\d) (ln_\x) {层正则化};
\node[unit,fill=green!20] at (0,24em) (sa_1) {8头自注意力：512};
\foreach \x/\d in {1/6em, 2/14em, 3/20em, 4/26em, 5/36em} \foreach \x/\d in {1/6em, 2/12em, 3/22em}
\node[draw,circle,minimum size=1em,inner sep=1pt] at (0,\d) (add_\x) {\scriptsize\bfnew{+}}; \node[draw,circle,minimum size=1em,inner sep=1pt] at (0,\d) (add_\x) {\scriptsize\bfnew{+}};
\node[unit,fill=red!20] at (0,30em) (conv_4) {卷积$1 \times 1$：2048}; \node[unit,fill=red!20] at (0,16em) (conv_4) {卷积$1 \times 1$：2048};
\node[unit,fill=red!20] at (0,34em) (conv_5) {卷积$1 \times 1$：512}; \node[unit,fill=red!20] at (0,20em) (conv_5) {卷积$1 \times 1$：512};
\node[unit,fill=blue!20] at (0,18em) (relu_3) {RELU};
\node[unit,fill=cyan!20] at (0,4em) (conv_3) {Sep卷积$9 \times 1$：256};
\node[unit,fill=green!20] at (0,10em) (sa_1) {8头自注意力：512};
\node[unit,fill=blue!20] at (0,32em) (relu_3) {RELU};
\node[unit,fill=red!20] at (0,4em) (glu_1) {门控线性单元：512};
\node[unit,fill=red!20] at (-3em,10em) (conv_1) {卷积$1 \times 1$：2048};
\node[unit,fill=cyan!20] at (3em,10em) (conv_2) {卷积$3 \times 1$：256};
\node[unit,fill=blue!20] at (-3em,12em) (relu_1) {RELU};
\node[unit,fill=blue!20] at (3em,12em) (relu_2) {RELU};
\node[unit,fill=cyan!20] at (0em,18em) (conv_3) {Sep卷积$9 \times 1$：256};
\draw[->,thick] ([yshift=-1.4em]ln_1.-90) -- ([yshift=-0.1em]ln_1.-90); \draw[->,thick] ([yshift=-1.4em]ln_1.-90) -- ([yshift=-0.1em]ln_1.-90);
\draw[->,thick] ([yshift=0.1em]ln_1.90) -- ([yshift=-0.1em]glu_1.-90); \draw[->,thick] ([yshift=0.1em]ln_1.90) -- ([yshift=-0.1em]conv_3.-90);
\draw[->,thick] ([yshift=0.1em]glu_1.90) -- ([yshift=-0.1em]add_1.-90); \draw[->,thick] ([yshift=0.1em]conv_3.90) -- ([yshift=-0.1em]add_1.-90);
\draw[->,thick] ([yshift=0.1em]add_1.90) -- ([yshift=-0.1em]ln_2.-90); \draw[->,thick] ([yshift=0.1em]add_1.90) -- ([yshift=-0.1em]ln_2.-90);
\draw[->,thick] ([,yshift=0.1em]ln_2.135) -- ([yshift=-0.1em]conv_1.-90); \draw[->,thick] ([,yshift=0.1em]ln_2.90) -- ([yshift=-0.1em]sa_1.-90);
\draw[->,thick] ([yshift=0.1em]ln_2.45) -- ([yshift=-0.1em]conv_2.-90); \draw[->,thick] ([yshift=0.1em]sa_1.90) -- ([yshift=-0.1em]add_2.-90);
\draw[->,thick] ([yshift=0.1em]conv_1.90) -- ([yshift=-0.1em]relu_1.-90);
\draw[->,thick] ([yshift=0.1em]conv_2.90) -- ([yshift=-0.1em]relu_2.-90);
\draw[->,thick] ([yshift=0.1em]relu_1.90) -- ([yshift=-0.1em]add_2.-135);
\draw[->,thick] ([yshift=0.1em]relu_2.90) -- ([yshift=-0.1em]add_2.-45);
\draw[->,thick] ([yshift=0.1em]add_2.90) -- ([yshift=-0.1em]ln_3.-90); \draw[->,thick] ([yshift=0.1em]add_2.90) -- ([yshift=-0.1em]ln_3.-90);
\draw[->,thick] ([yshift=0.1em]ln_3.90) -- ([yshift=-0.1em]conv_3.-90); \draw[->,thick] ([yshift=0.1em]ln_3.90) -- ([yshift=-0.1em]conv_4.-90);
\draw[->,thick] ([yshift=0.1em]conv_3.90) -- ([yshift=-0.1em]add_3.-90);
\draw[->,thick] ([yshift=0.1em]add_3.90) -- ([yshift=-0.1em]ln_4.-90);
\draw[->,thick] ([yshift=0.1em]ln_4.90) -- ([yshift=-0.1em]sa_1.-90);
\draw[->,thick] ([yshift=0.1em]sa_1.90) -- ([yshift=-0.1em]add_4.-90);
\draw[->,thick] ([yshift=0.1em]add_4.90) -- ([yshift=-0.1em]ln_5.-90);
\draw[->,thick] ([yshift=0.1em]ln_5.90) -- ([yshift=-0.1em]conv_4.-90);
\draw[->,thick] ([yshift=0.1em]conv_4.90) -- ([yshift=-0.1em]relu_3.-90); \draw[->,thick] ([yshift=0.1em]conv_4.90) -- ([yshift=-0.1em]relu_3.-90);
\draw[->,thick] ([yshift=0.1em]relu_3.90) -- ([yshift=-0.1em]conv_5.-90); \draw[->,thick] ([yshift=0.1em]relu_3.90) -- ([yshift=-0.1em]conv_5.-90);
\draw[->,thick] ([yshift=0.1em]conv_5.90) -- ([yshift=-0.1em]add_5.-90); \draw[->,thick] ([yshift=0.1em]conv_5.90) -- ([yshift=-0.1em]add_3.-90);
\draw[->,thick] ([yshift=0.1em]add_5.90) -- ([yshift=1em]add_5.90); \draw[->,thick] ([yshift=0.1em]add_3.90) -- ([yshift=1em]add_3.90);
\draw[->,thick] ([yshift=-0.8em]ln_1.-90) .. controls ([xshift=5em,yshift=-0.8em]ln_1.-90) and ([xshift=5em]add_1.0) .. (add_1.0); \draw[->,thick] ([yshift=-0.8em]ln_1.-90) .. controls ([xshift=5em,yshift=-0.8em]ln_1.-90) and ([xshift=5em]add_1.0) .. (add_1.0);
\draw[->,thick] (add_1.0) .. controls ([xshift=8em]add_1.0) and ([xshift=8em]add_3.0) .. (add_3.0); \draw[->,thick] (add_1.0) .. controls ([xshift=5em]add_1.0) and ([xshift=5em]add_2.0) .. (add_2.0);
\draw[->,thick] (add_3.0) .. controls ([xshift=5em]add_3.0) and ([xshift=5em]add_4.0) .. (add_4.0); \draw[->,thick] (add_2.0) .. controls ([xshift=5em]add_2.0) and ([xshift=5em]add_3.0) .. (add_3.0);
\draw[->,thick] (add_4.0) .. controls ([xshift=5em]add_4.0) and ([xshift=5em]add_5.0) .. (add_5.0);
\node[font=\scriptsize,align=center] at (0em, -1.5em){(b) 使用结构搜索方法优化后的 \\ Transformer编码器中若干块的结构}; \node[font=\scriptsize,align=center] at (0em, -1.5em){(b) 使用结构搜索方法优化后的 \\ Transformer编码器中若干块的结构};
\node[minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=blue!20] (act) at (5.5em, 38em){}; \node[minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=blue!20] (act) at (5.5em, 20em){};
\node[anchor=west,font=\footnotesize] at ([xshift=0.1em]act.east){激活函数}; \node[anchor=west,font=\footnotesize] at ([xshift=0.1em]act.east){激活函数};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=yellow!20] (nor) at ([yshift=-0.6em]act.south){}; \node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=yellow!20] (nor) at ([yshift=-0.6em]act.south){};
\node[anchor=west,font=\footnotesize] at ([xshift=0.1em]nor.east){正则化}; \node[anchor=west,font=\footnotesize] at ([xshift=0.1em]nor.east){层正则化};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=cyan!20] (wc) at ([yshift=-0.6em]nor.south){}; \node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=cyan!20] (wc) at ([yshift=-0.6em]nor.south){};
\node[anchor=west,font=\footnotesize] at ([xshift=0.1em]wc.east){宽卷积}; \node[anchor=west,font=\footnotesize] at ([xshift=0.1em]wc.east){宽卷积};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=green!20] (at) at ([yshift=-0.6em]wc.south){}; \node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=green!20] (at) at ([yshift=-0.6em]wc.south){};
......
Chapter15/Figures/figure-layer-fusion-method.tex
...@@ -17,7 +17,7 @@ ...@@ -17,7 +17,7 @@
\node [anchor=west,rectangle,minimum height=1.5em,minimum width=2.5em,rounded corners=5pt] (n6) at ([xshift=1em,yshift=0em]n5.east) {$\ldots$}; \node [anchor=west,rectangle,minimum height=1.5em,minimum width=2.5em,rounded corners=5pt] (n6) at ([xshift=1em,yshift=0em]n5.east) {$\ldots$};
\node [anchor=west,encnode,draw=red!60!black!80,fill=red!20] (n7) at ([xshift=1em,yshift=0em]n6.east) {$\mathbi{h}_{N-1}$}; \node [anchor=west,encnode,draw=red!60!black!80,fill=red!20] (n7) at ([xshift=1em,yshift=0em]n6.east) {$\mathbi{h}_{L-1}$};
\node [anchor=north,rectangle,draw=teal!80, inner sep=0mm,minimum height=2em,minimum width=8em,fill=teal!17,rounded corners=5pt,thick] (n8) at ([xshift=3em,yshift=-1.2em]n4.south) {权重聚合$\mathbi{g}$}; \node [anchor=north,rectangle,draw=teal!80, inner sep=0mm,minimum height=2em,minimum width=8em,fill=teal!17,rounded corners=5pt,thick] (n8) at ([xshift=3em,yshift=-1.2em]n4.south) {权重聚合$\mathbi{g}$};
......
Chapter15/Figures/figure-learning-of-local-structure-combination.tex deleted 100644 → 0
%%% outline
%-------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{opt}=[minimum height=1em,minimum width=5em,rounded corners=2pt,thick]
\node[opt] (opt1_0) at (0,0) {固定操作};
\node[draw,anchor=south,opt,fill=green!20] (opt1_1) at ([yshift=0.8em]opt1_0.north) {操作3};
\node[draw,anchor=south,opt,fill=cyan!20] (opt1_2) at ([yshift=0.8em]opt1_1.north) {操作2};
\node[anchor=south,opt] (opt1_3) at ([yshift=0.8em]opt1_2.north) {固定操作};
\node[draw,anchor=south,opt,fill=yellow!20] (opt1_4) at ([yshift=0.8em]opt1_3.north) {操作4};
\node[anchor=south,opt] (opt1_5) at ([yshift=0.8em]opt1_4.north) {$\cdots$};
\node[draw,anchor=south,opt,fill=blue!10] (opt1_6) at ([yshift=0.8em]opt1_5.north) {操作1};
\node[anchor=south,opt] (opt1_7) at ([yshift=0.8em]opt1_6.north) {};
\node[opt] (opt2_0) at (3,0) {固定操作};
\node[draw,anchor=south,opt,fill=blue!10] (opt2_1) at ([yshift=0.8em]opt2_0.north) {操作1};
\node[draw,anchor=south,opt,fill=green!20] (opt2_2) at ([yshift=0.8em]opt2_1.north) {操作3};
\node[anchor=south,opt] (opt2_3) at ([yshift=0.8em]opt2_2.north) {固定操作};
\node[draw,anchor=south,opt,fill=red!20] (opt2_4) at ([yshift=0.8em]opt2_3.north) {操作5};
\node[anchor=south,opt] (opt2_5) at ([yshift=0.8em]opt2_4.north) {$\cdots$};
\node[draw,anchor=south,opt,fill=cyan!20] (opt2_6) at ([yshift=0.8em]opt2_5.north) {操作2};
\node[anchor=south,opt] (opt2_7) at ([yshift=0.8em]opt2_6.north) {};
\node[opt] (opt3_0) at (6,0) {固定操作};
\node[draw,anchor=south,opt,fill=yellow!20] (opt3_1) at ([yshift=0.8em]opt3_0.north) {操作4};
\node[draw,anchor=south,opt,fill=cyan!20] (opt3_2) at ([yshift=0.8em]opt3_1.north) {操作2};
\node[anchor=south,opt] (opt3_3) at ([yshift=0.8em]opt3_2.north) {固定操作};
\node[draw,anchor=south,opt,fill=yellow!20] (opt3_4) at ([yshift=0.8em]opt3_3.north) {操作4};
\node[anchor=south,opt] (opt3_5) at ([yshift=0.8em]opt3_4.north) {$\cdots$};
\node[draw,anchor=south,opt,fill=red!20] (opt3_6) at ([yshift=0.8em]opt3_5.north) {操作5};
\node[anchor=south,opt] (opt3_7) at ([yshift=0.8em]opt3_6.north) {};
\begin{pgfonlayer}{background}
\node[draw,fill=yellow!20,rounded corners=6pt,inner ysep=2.6em,inner xsep=2.6em] [fit=(opt1_0) (opt3_7)](box4){};
\node[draw,fill=gray!10,rounded corners=2pt,inner sep=8pt] [fit=(opt1_0) (opt1_7)](box1){};
\node[draw,fill=gray!10,rounded corners=2pt,inner sep=8pt] [fit=(opt2_0) (opt2_7)](box2){};
\node[draw,fill=gray!10,rounded corners=2pt,inner sep=8pt] [fit=(opt3_0) (opt3_7)](box3){};
\end{pgfonlayer}
\draw[->,thick] (opt1_0) -- (opt1_1);
\draw[->,thick] (opt1_1) -- (opt1_2);
\draw[->,thick] (opt1_2) -- (opt1_3);
\draw[->,thick] (opt1_3) -- (opt1_4);
\draw[->,thick] (opt1_4) -- (opt1_5);
\draw[->,thick] (opt1_5) -- (opt1_6);
\draw[->,thick] (opt2_0) -- (opt2_1);
\draw[->,thick] (opt2_1) -- (opt2_2);
\draw[->,thick] (opt2_2) -- (opt2_3);
\draw[->,thick] (opt2_3) -- (opt2_4);
\draw[->,thick] (opt2_4) -- (opt2_5);
\draw[->,thick] (opt2_5) -- (opt2_6);
\draw[->,thick] (opt3_0) -- (opt3_1);
\draw[->,thick] (opt3_1) -- (opt3_2);
\draw[->,thick] (opt3_2) -- (opt3_3);
\draw[->,thick] (opt3_3) -- (opt3_4);
\draw[->,thick] (opt3_4) -- (opt3_5);
\draw[->,thick] (opt3_5) -- (opt3_6);
\node[] at ([xshift=-1.2em,yshift=0.2em]opt1_7){\small\bfnew{分支1}};
\node[] at ([xshift=-1.2em,yshift=0.2em]opt2_7){\small\bfnew{分支2}};
\node[] at ([xshift=-1.2em,yshift=0.2em]opt3_7){\small\bfnew{分支3}};
\node[] (input) at ([yshift=-5em]opt2_0){\small\bfnew{输入}};
\node[] (output) at ([yshift=5em]opt2_7){\small\bfnew{输出}};
\draw[->,thick,out=140,in=-30] (box4.-90) to (box1.-90);
\draw[->,thick,out=40,in=-150] (box4.-90) to (box3.-90);
\draw[->,thick] (box4.-90) -- (box2.-90);
\draw[->,thick,out=50,in=-130] (box1.90) to (box4.90);
\draw[->,thick,out=130,in=-50] (box3.90) to (box4.90);
\draw[->,thick] (box2.90) -- (box4.90);
\draw[->,thick] (input.90) -- (box4.-90);
\draw[->,thick] (box4.90) -- (output.-90);
\node[] at ([xshift=-2.8em,yshift=1.1em]box1.90){\small\bfnew{模型结构}};
\node[] at ([xshift=-0.8em]box4.0){$\cdots$};
\end{tikzpicture}
Chapter15/Figures/figure-whole-structure-and-internal-structure-in-rnn.tex → Chapter15/Figures/figure-main-flow-of-neural-network-structure-search.tex
%%% outline \begin{tikzpicture}
%------------------------------------------------------------------------- \tikzstyle{node}=[draw,minimum height=1.4em,minimum width=2em,rounded corners=1pt,thick]
\begin{tikzpicture}[scale=0.8]
\tikzstyle{every node}=[scale=0.8]
\tikzstyle{node}=[draw,minimum height=1.4em,minimum width=2em,rounded corners=3pt,thick]
\begin{scope}[scale=0.36]
\tikzstyle{every node}=[scale=0.36]
\node[draw=ublue,very thick,drop shadow,fill=white,minimum width=40em,minimum height=25em] (rec3) at (2.25,0){};
\node[draw=ublue,very thick,drop shadow,fill=white,minimum width=22em,minimum height=25em] (rec2) at (-12.4,0){};
\node[draw=ublue,very thick,drop shadow,fill=white,minimum width=24em,minimum height=25em] (rec1) at (-24,0){};
%left
\node[text=ublue] (label1) at (-26.4,4){\Huge\bfnew{结构空间}};
\node[align=left] at (-24,-0.5){\Huge\bfnew{1.前馈神经网络} \\ [4ex] \Huge\bfnew{2.卷积神经网络} \\ [4ex] \Huge\bfnew{3.循环神经网络} \\ [4ex] \Huge\bfnew{4. Transformer网络} \\ [4ex] \Huge\bfnew{...}};
\draw[ublue,very thick,-latex] (rec1.0) -- node[align=center,above,text=violet]{\huge{设计} \\ \huge{搜索} \\ \huge{空间}}(rec2.180);
%mid
\node[text=ublue] (label2) at (-14.4,4){\Huge\bfnew{搜索空间}};
\node[align=left] at (-12.4,-0.5){\Huge\bfnew{循环神经网络} \\ [4ex] \Huge\bfnew{1.普通RNN网络} \\ [4ex] \Huge\bfnew{2. LSTM网络} \\ [4ex] \Huge\bfnew{3. GRU网络} \\ [4ex] \Huge\bfnew{...}};
\draw[ublue,very thick,-latex] (rec2.0) -- node[align=center,above,text=violet]{\huge{选择} \\ \huge{搜索} \\ \huge{策略}}(rec3.180);
\draw[ublue,very thick,-latex,out=-150,in=-30] (rec3.-90) to node[above,text=violet,yshift=1em]{\huge{迭代结构搜索的过程}}(rec2.-90);
\draw[ublue,very thick,-latex,out=60,in=130] ([xshift=-8em]rec3.90) to node[above,text=violet]{\huge{性能评估}}([xshift=8em]rec3.90);
%right
\node[node] (n1) at (0,0){}; \node[node] (n1) at (0,0){};
\node[node] (n2) at (1.5,0){}; \node[node] (n2) at (1.5,0){};
\node[node] (n3) at (3,0){}; \node[node] (n3) at (3,0){};
...@@ -32,16 +52,9 @@ ...@@ -32,16 +52,9 @@
\node[font=\Huge] at (9,0){$\cdots$}; \node[font=\Huge] at (9,0){$\cdots$};
\node[font=\Huge] at (-4.5,0){$\cdots$}; \node[font=\Huge] at (-4.5,0){$\cdots$};
\node[minimum width=3em,minimum height=2em,fill=red!20,rounded corners=6pt] (b1) at (6,-3.8){}; \node[text=ublue] (label3) at (-2,4){\Huge\bfnew{找到的模型结构}};
\node[] (w1) at (7.8,-3.8){\Large 整体框架};
\node[minimum width=3em,minimum height=2em,fill=yellow!30,rounded corners=6pt] (b2) at (6,-4.8){};
\node[] (w2) at (7.8,-4.8){\Large 内部结构};
\begin{pgfonlayer}{background} \node[draw,rounded corners=6pt,very thick,minimum width=16em,minimum height=15em] (box1) at (2.25,0){};
\node[draw,rounded corners=6pt,very thick,fill=yellow!30,minimum width=16em,minimum height=15em] (box1) at (2.25,0){};
\node[draw=ublue,very thick,drop shadow,inner sep=1.2em,fill=white,xshift=-0.1em] [fit=(b1)(w2)]{};
\draw[fill=red!20,red!20,rounded corners=6pt] ([yshift=2.4em,xshift=1em]ht-1.east) -- ([yshift=2.4em,xshift=-0.1em]box1.west) -- ([xshift=-8em,xshift=-0.1em]box1.south) -- ([xshift=2em]box1.south) -- ([xshift=2em,yshift=-5em]box1.south) -- ([xshift=0em,yshift=-5em]box1.south) .. controls ([xshift=-12em,yshift=-5em]box1.south) and ([yshift=-2em]ht-1.east) ..([yshift=2.4em]ht-1.east) -- ([yshift=2.4em,xshift=1em]ht-1.east) ;
\end{pgfonlayer}
\draw[->,very thick] (ht-1.0) -- (box1.180); \draw[->,very thick] (ht-1.0) -- (box1.180);
\draw[->,very thick] (box1.0) -- (ht+1.180); \draw[->,very thick] (box1.0) -- (ht+1.180);
...@@ -51,10 +64,5 @@ ...@@ -51,10 +64,5 @@
\draw[->,very thick] ([yshift=-2em]ht-1.-90) -- (ht-1.-90); \draw[->,very thick] ([yshift=-2em]ht-1.-90) -- (ht-1.-90);
\draw[->,very thick] ([yshift=-2em]ht+1.-90) -- (ht+1.-90); \draw[->,very thick] ([yshift=-2em]ht+1.-90) -- (ht+1.-90);
\draw[->,very thick] ([yshift=-2em]box1.-90) -- (box1.-90); \draw[->,very thick] ([yshift=-2em]box1.-90) -- (box1.-90);
\end{scope}
\end{tikzpicture}
\end{tikzpicture} \ No newline at end of file
Chapter15/Figures/figure-post-norm-vs-pre-norm.tex
...@@ -39,8 +39,8 @@ ...@@ -39,8 +39,8 @@
\node [rectangle,inner sep=0.3em,fill=blue!10] [fit = (x3) (F2) (n2) (ln2) (x4) (k2)] (box1) {}; \node [rectangle,inner sep=0.3em,fill=blue!10] [fit = (x3) (F2) (n2) (ln2) (x4) (k2)] (box1) {};
\end{pgfonlayer} \end{pgfonlayer}
\node [anchor=north] (c1) at (box0.south){\footnotesize {(a)后作方式的残差连接}}; \node [anchor=north] (c1) at (box0.south){\footnotesize {(a)Post-Norm方式的残差连接}};
\node [anchor=north] (c2) at (box1.south){\footnotesize {(b)前作方式的残差连接}}; \node [anchor=north] (c2) at (box1.south){\footnotesize {(b)Pre-Norm方式的残差连接}};
\end{scope} \end{scope}
\end{tikzpicture} \end{tikzpicture}
\end{center} \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-multi-language-single-model-system-diagram.tex
...@@ -31,8 +31,8 @@ ...@@ -31,8 +31,8 @@
\node[anchor=north,lan,minimum width=9.8em] (box7) at ([yshift=-4em]train3.south) {}; \node[anchor=north,lan,minimum width=9.8em] (box7) at ([yshift=-4em]train3.south) {};
\begin{pgfonlayer}{background} \begin{pgfonlayer}{background}
\node[fill=red!20,draw=black,rounded corners=2pt,inner ysep=6pt,line width=1pt][fit=(train)(train4)(train1)(train2)(train3)]{}; \node[draw=ugreen,rounded corners=2pt,inner ysep=6pt,line width=1pt][fit=(train)(train4)(train1)(train2)(train3)]{};
\node[fill=blue!20,,draw=black,rounded corners=2pt,inner ysep=6pt,line width=1pt][fit=(decode)(output)(decode2)(decode3)(box7)]{}; \node[draw=purple,rounded corners=2pt,inner ysep=6pt,line width=1pt][fit=(decode)(output)(decode2)(decode3)(box7)]{};
\end{pgfonlayer} \end{pgfonlayer}
\end{tikzpicture} \end{tikzpicture}
......
Chapter16/Figures/figure-the-iterative-process-of-bidirectional-training.tex
...@@ -9,7 +9,7 @@ ...@@ -9,7 +9,7 @@
\node(bilingual_D_shadow)[data_shadow, right of = monolingual_X_shadow, xshift=5cm]{}; \node(bilingual_D_shadow)[data_shadow, right of = monolingual_X_shadow, xshift=5cm]{};
\node(monolingual_Y_shadow)[data_shadow, right of = bilingual_D_shadow, xshift=5cm]{}; \node(monolingual_Y_shadow)[data_shadow, right of = bilingual_D_shadow, xshift=5cm]{};
\node(monolingual_X)[data,right of = monolingual_X_shadow,xshift=-0.08cm,yshift=0.08cm]{单语语料X}; \node(monolingual_X)[data,right of = monolingual_X_shadow,xshift=-0.08cm,yshift=0.08cm]{单语语料X};
\node(bilingual_D)[data, right of = monolingual_X, xshift=5cm, fill=green!30]{双语语料D}; \node(bilingual_D)[data, right of = monolingual_X, xshift=5cm, fill=ugreen!30]{双语语料D};
\node(monolingual_Y)[data, right of = bilingual_D, xshift=5cm, fill=blue!25]{单语语料Y}; \node(monolingual_Y)[data, right of = bilingual_D, xshift=5cm, fill=blue!25]{单语语料Y};
\node(process_1_1)[process, right of = monolingual_X, xshift=2.5cm, yshift=-1.5cm]{\textbf{$M^0_{x\to y}$}}; \node(process_1_1)[process, right of = monolingual_X, xshift=2.5cm, yshift=-1.5cm]{\textbf{$M^0_{x\to y}$}};
...@@ -35,7 +35,7 @@ ...@@ -35,7 +35,7 @@
\node(text_2)[left of = process_5_1, xshift=-4cm,scale=0.8]{第1轮迭代}; \node(text_2)[left of = process_5_1, xshift=-4cm,scale=0.8]{第1轮迭代};
\node(text_3)[left of = ellipsis_2, xshift=-4cm, scale=0.8]{第2轮迭代}; \node(text_3)[left of = ellipsis_2, xshift=-4cm, scale=0.8]{第2轮迭代};
\draw[->, very thick, color=color1!40](monolingual_X.south)--(ellipsis_1.north); \draw[->, very thick, color=color1!40](monolingual_X.south)--(ellipsis_1.north);
\draw[->, very thick, color=green!30](bilingual_D.south)--(ellipsis_3.north); \draw[->, very thick, color=ugreen!30](bilingual_D.south)--(ellipsis_3.north);
\draw[->, very thick, color=blue!55](monolingual_Y.south)--(ellipsis_5.north); \draw[->, very thick, color=blue!55](monolingual_Y.south)--(ellipsis_5.north);
\draw[->, very thick, color=color1!40]([xshift=-1.5cm]process_2_1.west)--(process_2_1.west); \draw[->, very thick, color=color1!40]([xshift=-1.5cm]process_2_1.west)--(process_2_1.west);
\draw[->, very thick, color=color1!40]([xshift=-1.5cm]process_5_1.west)--(process_5_1.west); \draw[->, very thick, color=color1!40]([xshift=-1.5cm]process_5_1.west)--(process_5_1.west);
...@@ -55,13 +55,13 @@ ...@@ -55,13 +55,13 @@
\draw[->, very thick, color=color1!40](process_3_2.west)--([yshift=0.35cm]process_4_1.east); \draw[->, very thick, color=color1!40](process_3_2.west)--([yshift=0.35cm]process_4_1.east);
\draw[->, very thick, color=color1!40](process_6_1.east)--([yshift=0.35cm]process_7_2.west); \draw[->, very thick, color=color1!40](process_6_1.east)--([yshift=0.35cm]process_7_2.west);
\draw[->, very thick, color=color1!40](process_6_2.west)--([yshift=0.35cm]process_7_1.east); \draw[->, very thick, color=color1!40](process_6_2.west)--([yshift=0.35cm]process_7_1.east);
\draw[->, very thick, color=green!30,in=0,out=270]([xshift=-0.3cm]bilingual_D.south)to(process_1_1.east); \draw[->, very thick, color=ugreen!30,in=0,out=270]([xshift=-0.3cm]bilingual_D.south)to(process_1_1.east);
\draw[->, very thick, color=green!30,in=180,out=270]([xshift=0.3cm]bilingual_D.south)to(process_1_2.west); \draw[->, very thick, color=ugreen!30,in=180,out=270]([xshift=0.3cm]bilingual_D.south)to(process_1_2.west);
\draw[->, very thick, color=green!30,in=0,out=270]([yshift=-3.7cm]bilingual_D.south)to(process_4_1.east); \draw[->, very thick, color=ugreen!30,in=0,out=270]([yshift=-3.7cm]bilingual_D.south)to(process_4_1.east);
\draw[->, very thick, color=green!30,in=180,out=270]([yshift=-3.7cm]bilingual_D.south)to(process_4_2.west); \draw[->, very thick, color=ugreen!30,in=180,out=270]([yshift=-3.7cm]bilingual_D.south)to(process_4_2.west);
\draw[->, very thick, color=green!30,in=0,out=270]([yshift=-7.3cm]bilingual_D.south)to(process_7_1.east); \draw[->, very thick, color=ugreen!30,in=0,out=270]([yshift=-7.3cm]bilingual_D.south)to(process_7_1.east);
\draw[->, very thick, color=green!30,in=180,out=270]([yshift=-7.3cm]bilingual_D.south)to(process_7_2.west); \draw[->, very thick, color=ugreen!30,in=180,out=270]([yshift=-7.3cm]bilingual_D.south)to(process_7_2.west);
\draw[->, very thick, color=green!30,in=180,out=270]([yshift=-7.3cm]bilingual_D.south)to(process_7_2.west); \draw[->, very thick, color=ugreen!30,in=180,out=270]([yshift=-7.3cm]bilingual_D.south)to(process_7_2.west);
\draw[-, very thick, dashed, color=blue!55]([xshift=-1cm,yshift=-0.35cm]text_1.south)--([xshift=12.7cm,yshift=-0.35cm]text_1.south); \draw[-, very thick, dashed, color=blue!55]([xshift=-1cm,yshift=-0.35cm]text_1.south)--([xshift=12.7cm,yshift=-0.35cm]text_1.south);
\draw[-, very thick, dashed, color=blue!55]([xshift=-1cm,yshift=-0.35cm]text_2.south)--([xshift=12.7cm,yshift=-0.35cm]text_2.south); \draw[-, very thick, dashed, color=blue!55]([xshift=-1cm,yshift=-0.35cm]text_2.south)--([xshift=12.7cm,yshift=-0.35cm]text_2.south);
......
Chapter16/chapter16.tex
This source diff could not be displayed because it is too large. You can view the blob instead.
Chapter17/Figures/figure-an-end-to-end-voice-translation-model-based-on-transformer.tex
...@@ -17,11 +17,11 @@ ...@@ -17,11 +17,11 @@
\node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.4em]de_sa.north){Multi-Head \\ Attention}; \node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.4em]de_sa.north){Multi-Head \\ Attention};
\node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.4em]de_ca.north){Feed Forward \\ Network}; \node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.4em]de_ca.north){Feed Forward \\ Network};
\node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=2em]de_ffn.north){Softmax}; \node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=1.6em]de_ffn.north){Softmax};
\node[layer,anchor=south,fill=orange!20] (output) at ([yshift=1.4em]sf.north){STLoss}; %\node[layer,anchor=south,fill=orange!20] (output) at ([yshift=1.4em]sf.north){STLoss};
\node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){语音特征\\(FilterBank/MFCC)}; \node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){Speech Feature\\(FBank/MFCC)};
\node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1em]de_add.south){目标文本\\(Embedding)}; \node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1.1em]de_add.south){Target Text\\(Embedding)};
\node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){Position\\(Embedding)}; \node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){Position\\(Embedding)};
\node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){Position\\(Embedding)}; \node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){Position\\(Embedding)};
...@@ -35,13 +35,13 @@ ...@@ -35,13 +35,13 @@
\draw[->] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_ca.-90); \draw[->] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_ca.-90);
\draw[->] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_ffn.-90); \draw[->] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_ffn.-90);
\draw[->] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]sf.-90); \draw[->] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]sf.-90);
\draw[->] ([yshift=0.1em]sf.90) -- ([yshift=-0.1em]output.-90); \draw[->] ([yshift=0.1em]sf.90) -- ([yshift=1.5em]sf.90);
\draw[->] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180); \draw[->] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180);
\draw[->] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0); \draw[->] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0);
\draw[->,rounded corners=2pt] ([yshift=0.1em]en_ffn.90) -- ([yshift=2em]en_ffn.90) -- ([xshift=4em,yshift=2em]en_ffn.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west); \draw[->,rounded corners=2pt] ([yshift=0.1em]en_ffn.90) -- ([yshift=2em]en_ffn.90) -- ([xshift=4em,yshift=2em]en_ffn.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west);
\begin{pgfonlayer}{background} \begin{pgfonlayer}{background}
\node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt][fit=(en_sa)(en_ffn)]{}; \node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(en_sa)(en_ffn)]{};
\node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt][fit=(de_sa)(de_ca)(de_ffn)]{}; \node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(de_sa)(de_ca)(de_ffn)]{};
\end{pgfonlayer} \end{pgfonlayer}
\node[anchor=east,font=\scriptsize,text=ugreen] at ([xshift=-0.1em]box1.west){$N \times$}; \node[anchor=east,font=\scriptsize,text=ugreen] at ([xshift=-0.1em]box1.west){$N \times$};
......
Chapter17/Figures/figure-application-of-multimodal-machine-translation-to-multitask-learning.tex
\tikzstyle{coder} = [rectangle,thick,rounded corners,minimum width=2.3cm,minimum height=1cm,text centered,draw=black,fill=red!25] \tikzstyle{coder} = [rectangle,rounded corners,minimum height=2.2em,minimum width=4.3em,text centered,draw=black,fill=red!25]
\begin{tikzpicture}[node distance = 0,scale = 1] \begin{tikzpicture}[node distance = 0,scale = 1]
\tikzstyle{every node}=[scale=1] \tikzstyle{every node}=[scale=1]
\node(x)[]{x}; \node(x)[]{x};
\node(encoder)[coder, above of = x,yshift=4em]{{编码器}}; \node(encoder)[coder, above of = x,yshift=4em]{{编码器}};
\node(decoder_left)[coder, above of = encoder, yshift=6em,fill=blue!25]{{解码器}}; \node(decoder_left)[coder, above of = encoder, yshift=6em,fill=ugreen!25]{{解码器}};
\node(y_hat)[above of = decoder_left, yshift=4em]{{$\rm y'$}}; \node(y_hat)[above of = decoder_left, yshift=4em]{{$\rm y'$}};
\node(y)[above of = decoder_left, xshift=-6em]{{$\rm y$}}; \node(y)[above of = decoder_left, xshift=-6em]{{$\rm y$}};
\node(decoder_right)[coder, above of = encoder, xshift=12em,fill=yellow!25]{{解码器}}; \node(decoder_right)[coder, above of = encoder, xshift=11em,fill=yellow!25]{{解码器}};
\node(figure)[draw=white,above of = decoder_right,yshift=6.5em,scale=0.25] {\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-bank-without-attention.png}}; \node(figure)[draw=white,above of = decoder_right,yshift=6.5em,scale=0.25] {\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-bank-without-attention.png}};
...@@ -14,6 +14,6 @@ ...@@ -14,6 +14,6 @@
\draw[->,thick](encoder)to(decoder_left)node[right,xshift=-0.1cm,yshift=-1.25cm,scale=1.0]{翻译}; \draw[->,thick](encoder)to(decoder_left)node[right,xshift=-0.1cm,yshift=-1.25cm,scale=1.0]{翻译};
\draw[->,thick](decoder_left)to(y_hat); \draw[->,thick](decoder_left)to(y_hat);
\draw[->,thick](y)to(decoder_left); \draw[->,thick](y)to(decoder_left);
\draw[->,thick](encoder)to(decoder_right)node[left,xshift=-3.8em,yshift=0.25cm,scale=1.0]{生成图片}; \draw[->,thick](encoder)to(decoder_right)node[left,xshift=-3.1em,yshift=0.25cm,scale=1.0]{生成图片};
\draw[->,thick](decoder_right)to(figure); \draw[->,thick](decoder_right)to(figure);
\end{tikzpicture} \end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-audio-processing.tex
...@@ -21,7 +21,7 @@ ...@@ -21,7 +21,7 @@
\draw [very thick,rounded corners=10pt]([xshift=-2.2cm,yshift=-1cm]process_1.center)--([xshift=-1.8cm,yshift=1cm]process_1.center)--([xshift=-1.4cm,yshift=0cm]process_1.center)--([xshift=-1.1cm,yshift=0.8cm]process_1.center)--([xshift=-0.8cm,yshift=-0.4cm]process_1.center)--([xshift=-0.5cm,yshift=0.4cm]process_1.center); \draw [very thick,rounded corners=10pt]([xshift=-2.2cm,yshift=-1cm]process_1.center)--([xshift=-1.8cm,yshift=1cm]process_1.center)--([xshift=-1.4cm,yshift=0cm]process_1.center)--([xshift=-1.1cm,yshift=0.8cm]process_1.center)--([xshift=-0.8cm,yshift=-0.4cm]process_1.center)--([xshift=-0.5cm,yshift=0.4cm]process_1.center);
\draw [->,very thick]([xshift=-0.3cm]process_1.center)to([xshift=0.3cm]process_1.center); \draw [->,very thick]([xshift=-0.3cm]process_1.center)to([xshift=0.3cm]process_1.center);
\draw [very thick,rounded corners=10pt,densely dotted]([xshift=0.5cm,yshift=-1cm]process_1.center)--([xshift=0.9cm,yshift=1cm]process_1.center)--([xshift=1.3cm,yshift=0cm]process_1.center)--([xshift=1.6cm,yshift=0.8cm]process_1.center)--([xshift=1.9cm,yshift=-0.4cm]process_1.center)--([xshift=2.2cm,yshift=0.4cm]process_1.center); \draw [very thick,rounded corners=10pt,densely dotted]([xshift=0.5cm,yshift=-1cm]process_1.center)--([xshift=0.9cm,yshift=1cm]process_1.center)--([xshift=1.3cm,yshift=0cm]process_1.center)--([xshift=1.6cm,yshift=0.8cm]process_1.center)--([xshift=1.9cm,yshift=-0.4cm]process_1.center)--([xshift=2.2cm,yshift=0.4cm]process_1.center);
\node(process_2)[process,right of = process_1,xshift=6.6cm]{}; \node(process_2)[process,fill=ugreen!20,right of = process_1,xshift=6.6cm]{};
\node(text_2)[below of = process_2,yshift=-2cm,scale=1.3]{量化}; \node(text_2)[below of = process_2,yshift=-2cm,scale=1.3]{量化};
\draw [very thick,rounded corners=10pt,densely dotted]([xshift=-2.2cm,yshift=-1cm]process_2.center)--([xshift=-1.8cm,yshift=1cm]process_2.center)--([xshift=-1.4cm,yshift=0cm]process_2.center)--([xshift=-1.1cm,yshift=0.8cm]process_2.center)--([xshift=-0.8cm,yshift=-0.4cm]process_2.center)--([xshift=-0.5cm,yshift=0.4cm]process_2.center); \draw [very thick,rounded corners=10pt,densely dotted]([xshift=-2.2cm,yshift=-1cm]process_2.center)--([xshift=-1.8cm,yshift=1cm]process_2.center)--([xshift=-1.4cm,yshift=0cm]process_2.center)--([xshift=-1.1cm,yshift=0.8cm]process_2.center)--([xshift=-0.8cm,yshift=-0.4cm]process_2.center)--([xshift=-0.5cm,yshift=0.4cm]process_2.center);
\draw [->,very thick]([xshift=-0.3cm]process_2.center)to([xshift=0.3cm]process_2.center); \draw [->,very thick]([xshift=-0.3cm]process_2.center)to([xshift=0.3cm]process_2.center);
......
Chapter17/Figures/figure-cascading-speech-translation.tex
...@@ -7,9 +7,9 @@ ...@@ -7,9 +7,9 @@
\draw[-,thick]([xshift=-1.2cm]process_1.center)--([xshift=1.2cm]process_1.center); \draw[-,thick]([xshift=-1.2cm]process_1.center)--([xshift=1.2cm]process_1.center);
\draw[-,thick]([xshift=-1cm,yshift=-0.8cm]process_1.center)--([xshift=-0.9cm,yshift=0.4cm]process_1.center)--([xshift=-0.8cm,yshift=-0.3cm]process_1.center)--([xshift=-0.7cm,yshift=0.7cm]process_1.center)--([xshift=-0.6cm,yshift=-0.1cm]process_1.center)--([xshift=-0.5cm,yshift=0.3cm]process_1.center)--([xshift=-0.4cm,yshift=-0.5cm]process_1.center)--([xshift=-0.3cm,yshift=0.7cm]process_1.center)--([xshift=-0.2cm,yshift=-0.2cm]process_1.center)--([xshift=-0.1cm,yshift=0.4cm]process_1.center)--([xshift=0cm,yshift=-0.9cm]process_1.center)--([xshift=0.1cm,yshift=0.5cm]process_1.center)--([xshift=0.2cm,yshift=-0.4cm]process_1.center)--([xshift=0.3cm,yshift=0.3cm]process_1.center)--([xshift=0.4cm,yshift=-0.2cm]process_1.center)--([xshift=0.5cm,yshift=0.1cm]process_1.center)--([xshift=0.6cm,yshift=-0.8cm]process_1.center)--([xshift=0.7cm,yshift=0.4cm]process_1.center)--([xshift=0.8cm,yshift=-0.6cm]process_1.center)--([xshift=0.9cm,yshift=0.7cm]process_1.center)--([xshift=1cm,yshift=-0.2cm]process_1.center); \draw[-,thick]([xshift=-1cm,yshift=-0.8cm]process_1.center)--([xshift=-0.9cm,yshift=0.4cm]process_1.center)--([xshift=-0.8cm,yshift=-0.3cm]process_1.center)--([xshift=-0.7cm,yshift=0.7cm]process_1.center)--([xshift=-0.6cm,yshift=-0.1cm]process_1.center)--([xshift=-0.5cm,yshift=0.3cm]process_1.center)--([xshift=-0.4cm,yshift=-0.5cm]process_1.center)--([xshift=-0.3cm,yshift=0.7cm]process_1.center)--([xshift=-0.2cm,yshift=-0.2cm]process_1.center)--([xshift=-0.1cm,yshift=0.4cm]process_1.center)--([xshift=0cm,yshift=-0.9cm]process_1.center)--([xshift=0.1cm,yshift=0.5cm]process_1.center)--([xshift=0.2cm,yshift=-0.4cm]process_1.center)--([xshift=0.3cm,yshift=0.3cm]process_1.center)--([xshift=0.4cm,yshift=-0.2cm]process_1.center)--([xshift=0.5cm,yshift=0.1cm]process_1.center)--([xshift=0.6cm,yshift=-0.8cm]process_1.center)--([xshift=0.7cm,yshift=0.4cm]process_1.center)--([xshift=0.8cm,yshift=-0.6cm]process_1.center)--([xshift=0.9cm,yshift=0.7cm]process_1.center)--([xshift=1cm,yshift=-0.2cm]process_1.center);
\node(text_1)[below of = process_1,yshift=-2cm,scale=1.5]{语音信号}; \node(text_1)[below of = process_1,yshift=-2cm,scale=1.5]{语音信号};
\node(process_2)[process,right of = process_1,xshift=7.0cm,text width=4cm,align=center]{\baselineskip=4pt\LARGE{[[0.2,...,0.3], \qquad ..., \qquad 0.3,...,0.5]]}\par}; \node(process_2)[process,fill=blue!20,right of = process_1,xshift=7.0cm,text width=4cm,align=center]{\baselineskip=4pt\LARGE{[[0.2,...,0.3], \qquad ..., \qquad 0.3,...,0.5]]}\par};
\node(text_2)[below of = process_2,yshift=-2cm,scale=1.5]{语音特征}; \node(text_2)[below of = process_2,yshift=-2cm,scale=1.5]{语音特征};
\node(process_3)[process,,minimum width=6cm,minimum height=5cm,right of = process_2,xshift=8.2cm,text width=4cm,align=center]{}; \node(process_3)[process,fill=orange!20,minimum width=6cm,minimum height=5cm,right of = process_2,xshift=8.2cm,text width=4cm,align=center]{};
\node(text_3)[below of = process_3,yshift=-3cm,scale=1.5]{源语文本及其词格}; \node(text_3)[below of = process_3,yshift=-3cm,scale=1.5]{源语文本及其词格};
\node(cir_s)[cir,very thick, below of = process_3,xshift=-2.2cm,yshift=1.1cm]{\LARGE S}; \node(cir_s)[cir,very thick, below of = process_3,xshift=-2.2cm,yshift=1.1cm]{\LARGE S};
\node(cir_a)[cir,right of = cir_s,xshift=1cm,yshift=0.8cm]{\LARGE a}; \node(cir_a)[cir,right of = cir_s,xshift=1cm,yshift=0.8cm]{\LARGE a};
...@@ -33,7 +33,7 @@ ...@@ -33,7 +33,7 @@
\node(text)[below of = process_3,yshift=-1.8cm,scale=1.8]{你是谁}; \node(text)[below of = process_3,yshift=-1.8cm,scale=1.8]{你是谁};
\node(process_4)[process,right of = process_3,xshift=8.2cm,text width=4cm,align=center]{\Large\textbf{Who are you?}}; \node(process_4)[process,fill=ugreen!20,right of = process_3,xshift=8.2cm,text width=4cm,align=center]{\Large\textbf{Who are you?}};
\node(text_4)[below of = process_4,yshift=-2cm,scale=1.5]{翻译译文}; \node(text_4)[below of = process_4,yshift=-2cm,scale=1.5]{翻译译文};
\draw[->,very thick](process_1.east)to(process_2.west); \draw[->,very thick](process_1.east)to(process_2.west);
......
Chapter17/Figures/figure-examples-of-CTC-predictive-word-sequences.tex
...@@ -14,7 +14,7 @@ ...@@ -14,7 +14,7 @@
\node[anchor=west,minimum width=1.2em,minimum height=2.2em] (w8) at ([xshift=0.2em]w7.east){{l}}; \node[anchor=west,minimum width=1.2em,minimum height=2.2em] (w8) at ([xshift=0.2em]w7.east){{l}};
\node[anchor=west,minimum width=1.2em,minimum height=2.2em] (w9) at ([xshift=0.2em]w8.east){{o}}; \node[anchor=west,minimum width=1.2em,minimum height=2.2em] (w9) at ([xshift=0.2em]w8.east){{o}};
\node[anchor=west,minimum width=1.2em,minimum height=2.2em] (w10) at ([xshift=0.2em]w9.east){{o}}; \node[anchor=west,minimum width=1.2em,minimum height=2.2em] (w10) at ([xshift=0.2em]w9.east){{o}};
\node[anchor=west,minimum width=1.2em,minimum height=2.2em] (w11) at ([xshift=0.2em]w10.east){{!}}; \node[anchor=west,minimum width=1.2em,minimum height=2.2em] (w11) at ([xshift=0.2em]w10.east){{}};
\draw[very thick] (w1.south west) -- (w1.south east); \draw[very thick] (w1.south west) -- (w1.south east);
\draw[very thick] (w2.south west) -- (w2.south east); \draw[very thick] (w2.south west) -- (w2.south east);
...@@ -24,7 +24,7 @@ ...@@ -24,7 +24,7 @@
\draw[very thick] (w8.south west) -- (w8.south east); \draw[very thick] (w8.south west) -- (w8.south east);
\draw[very thick] (w9.south west) -- (w9.south east); \draw[very thick] (w9.south west) -- (w9.south east);
\draw[very thick] (w10.south west) -- (w10.south east); \draw[very thick] (w10.south west) -- (w10.south east);
\draw[very thick] (w11.south west) -- (w11.south east); %\draw[very thick] (w11.south west) -- (w11.south east);
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (m1) at ([yshift=-1em]w1.south){{h}}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (m1) at ([yshift=-1em]w1.south){{h}};
\node[anchor=north,minimum width=2.64em,minimum height=1.4em,fill=gray!30] (m2) at ([yshift=-1em,xshift=0.72em]w2.south){{e}}; \node[anchor=north,minimum width=2.64em,minimum height=1.4em,fill=gray!30] (m2) at ([yshift=-1em,xshift=0.72em]w2.south){{e}};
...@@ -33,14 +33,14 @@ ...@@ -33,14 +33,14 @@
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (m5) at ([yshift=-1em]w6.south){}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (m5) at ([yshift=-1em]w6.south){};
\node[anchor=north,minimum width=2.64em,minimum height=1.4em,fill=gray!30] (m6) at ([yshift=-1em,xshift=0.72em]w7.south){{l}}; \node[anchor=north,minimum width=2.64em,minimum height=1.4em,fill=gray!30] (m6) at ([yshift=-1em,xshift=0.72em]w7.south){{l}};
\node[anchor=north,minimum width=2.64em,minimum height=1.4em,fill=gray!30] (m7) at ([yshift=-1em,xshift=0.72em]w9.south){{o}}; \node[anchor=north,minimum width=2.64em,minimum height=1.4em,fill=gray!30] (m7) at ([yshift=-1em,xshift=0.72em]w9.south){{o}};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (m8) at ([yshift=-1em]w11.south){{!}}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (m8) at ([yshift=-1em]w11.south){};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o1) at ([yshift=-3.8em]w1.south){{h}}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o1) at ([yshift=-3.8em]w1.south){{h}};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o2) at ([yshift=-3.8em]w2.south){{e}}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o2) at ([yshift=-3.8em]w2.south){{e}};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o3) at ([yshift=-3.8em]w3.south){{l}}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o3) at ([yshift=-3.8em]w3.south){{l}};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o4) at ([yshift=-3.8em]w4.south){{l}}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o4) at ([yshift=-3.8em]w4.south){{l}};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o5) at ([yshift=-3.8em]w5.south){{o}}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o5) at ([yshift=-3.8em]w5.south){{o}};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o6) at ([yshift=-3.8em]w6.south){{!}}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] (o6) at ([yshift=-3.8em]w6.south){};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] at ([yshift=-3.8em]w7.south){}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] at ([yshift=-3.8em]w7.south){};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] at ([yshift=-3.8em]w8.south){}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] at ([yshift=-3.8em]w8.south){};
\node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] at ([yshift=-3.8em]w9.south){}; \node[anchor=north,minimum width=1.2em,minimum height=1.4em,fill=gray!30] at ([yshift=-3.8em]w9.south){};
...@@ -52,7 +52,7 @@ ...@@ -52,7 +52,7 @@
\draw[blue!40,fill=blue!30,opacity=0.7] (w5.south west) -- (w5.south east) -- (m4.south east) .. controls ([yshift=-0.3em]m4.south east) and ([yshift=0.3em]o3.north east) .. (o3.north east) -- (o3.south east) -- (o3.south west) -- (o3.north west) .. controls ([yshift=0.3em]o3.north west) and ([yshift=-0.3em]m4.south west) .. (m4.south west) -- (w5.south west); \draw[blue!40,fill=blue!30,opacity=0.7] (w5.south west) -- (w5.south east) -- (m4.south east) .. controls ([yshift=-0.3em]m4.south east) and ([yshift=0.3em]o3.north east) .. (o3.north east) -- (o3.south east) -- (o3.south west) -- (o3.north west) .. controls ([yshift=0.3em]o3.north west) and ([yshift=-0.3em]m4.south west) .. (m4.south west) -- (w5.south west);
\draw[blue!40,fill=blue!30,opacity=0.7] (w7.south west) -- (w8.south east) -- (m6.south east) .. controls ([yshift=-0.3em]m6.south east) and ([yshift=0.3em]o4.north east) .. (o4.north east) -- (o4.south east) -- (o4.south west) -- (o4.north west) .. controls ([yshift=0.3em]o4.north west) and ([yshift=-0.3em]m6.south west) .. (m6.south west) -- (w7.south west); \draw[blue!40,fill=blue!30,opacity=0.7] (w7.south west) -- (w8.south east) -- (m6.south east) .. controls ([yshift=-0.3em]m6.south east) and ([yshift=0.3em]o4.north east) .. (o4.north east) -- (o4.south east) -- (o4.south west) -- (o4.north west) .. controls ([yshift=0.3em]o4.north west) and ([yshift=-0.3em]m6.south west) .. (m6.south west) -- (w7.south west);
\draw[blue!40,fill=blue!30,opacity=0.7] (w9.south west) -- (w10.south east) -- (m7.south east) .. controls ([yshift=-0.1em]m7.south east) and ([yshift=0.2em]o5.north east) .. (o5.north east) -- (o5.south east) -- (o5.south west) -- (o5.north west) .. controls ([yshift=0.1em]o5.north west) and ([yshift=-0.5em]m7.south west) .. (m7.south west) -- (w9.south west); \draw[blue!40,fill=blue!30,opacity=0.7] (w9.south west) -- (w10.south east) -- (m7.south east) .. controls ([yshift=-0.1em]m7.south east) and ([yshift=0.2em]o5.north east) .. (o5.north east) -- (o5.south east) -- (o5.south west) -- (o5.north west) .. controls ([yshift=0.1em]o5.north west) and ([yshift=-0.5em]m7.south west) .. (m7.south west) -- (w9.south west);
\draw[blue!40,fill=blue!30,opacity=0.7] (w11.south west) -- (w11.south east) -- (m8.south east) .. controls ([yshift=-0.4em]m8.south east) and ([yshift=0.1em]o6.north east) .. (o6.north east) -- (o6.south east) -- (o6.south west) -- (o6.north west) .. controls ([yshift=0.1em]o6.north west) and ([yshift=-0.5em]m8.south west) .. (m8.south west) -- (w11.south west); %\draw[blue!40,fill=blue!30,opacity=0.7] (w11.south west) -- (w11.south east) -- (m8.south east) .. controls ([yshift=-0.4em]m8.south east) and ([yshift=0.1em]o6.north east) .. (o6.north east) -- (o6.south east) -- (o6.south west) -- (o6.north west) .. controls ([yshift=0.1em]o6.north west) and ([yshift=-0.5em]m8.south west) .. (m8.south west) -- (w11.south west);
\node[anchor=north,font=\scriptsize,align=center] (a2) at ([yshift=-1.4em]a1.south) {预测字母序列}; \node[anchor=north,font=\scriptsize,align=center] (a2) at ([yshift=-1.4em]a1.south) {预测字母序列};
\node[anchor=north,font=\scriptsize,align=center] (a3) at ([yshift=-1.8em]a2.south) {合并重复字母 \\ 并丢弃$\epsilon$}; \node[anchor=north,font=\scriptsize,align=center] (a3) at ([yshift=-1.8em]a2.south) {合并重复字母 \\ 并丢弃$\epsilon$};
......
Chapter17/Figures/figure-framing-schematic.tex
...@@ -4,7 +4,7 @@ ...@@ -4,7 +4,7 @@
\begin{tikzpicture}[node distance = 0,scale = 1] \begin{tikzpicture}[node distance = 0,scale = 1]
\tikzstyle{every node}=[scale=1] \tikzstyle{every node}=[scale=1]
\node [anchor=center](ori) at (-0.2,-0.2) {$O$}; \node [anchor=center](ori) at (-0.2,-0.2) {$O$};
\draw[->,thick](-0.5,0)--(5,0)node[below]{$t$}; \draw[->,thick](-0.5,0)--(5,0)node[below,scale=0.8]{时间};
\draw[->,thick](0,-2)--(0,2)node[left,scale=0.8]{量化值}; \draw[->,thick](0,-2)--(0,2)node[left,scale=0.8]{量化值};
\draw[-,thick](0,0)sin(0.7,1.5)cos(1.4,0)sin(2.1,-1.5)cos(2.8,0)sin(3.5,1.5)cos(4.2,0); \draw[-,thick](0,0)sin(0.7,1.5)cos(1.4,0)sin(2.1,-1.5)cos(2.8,0)sin(3.5,1.5)cos(4.2,0);
\draw[-,thick,dashed](0.5,-1.8)--(0.5,1.8); \draw[-,thick,dashed](0.5,-1.8)--(0.5,1.8);
...@@ -12,5 +12,5 @@ ...@@ -12,5 +12,5 @@
\draw[-,thick,dashed](1.9,-1.8)--(1.9,1.8); \draw[-,thick,dashed](1.9,-1.8)--(1.9,1.8);
\draw[<->,thick](0,-1.1)--(1.2,-1.1)node[left,xshift=-0.05cm,yshift=0.15cm,scale=0.6]{帧长}; \draw[<->,thick](0,-1.1)--(1.2,-1.1)node[left,xshift=-0.05cm,yshift=0.15cm,scale=0.6]{帧长};
\draw[<->,thick](0,-1.4)--(0.5,-1.4)node[left,xshift=0.05cm,yshift=-0.25cm,scale=0.6]{帧移}; \draw[<->,thick](0,-1.4)--(0.5,-1.4)node[left,xshift=0.05cm,yshift=-0.25cm,scale=0.6]{帧移};
\draw[<->,thick](0.5,-1.4)--(1.9,-1.4); %\draw[<->,thick](0.5,-1.4)--(1.9,-1.4);
\end{tikzpicture} \end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-image-description-of-encoder-decoder-framework.tex
...@@ -20,11 +20,11 @@ ...@@ -20,11 +20,11 @@
\foreach \x in {1,2}{ \foreach \x in {1,2}{
\draw[-,line width=2pt] (A\x) -- ([xshift=3.6em]A\x) -- ([xshift=3.6em,yshift=-3em]A\x) -- ([yshift=-3em]A\x) -- (A\x) -- ([xshift=1em]A\x); \draw[-,line width=2pt] (A\x) -- ([xshift=3.6em]A\x) -- ([xshift=3.6em,yshift=-3em]A\x) -- ([yshift=-3em]A\x) -- (A\x) -- ([xshift=1em]A\x);
\draw[-, very thick] (B\x) -- (C\x) -- (D\x) -- (B\x); \draw[-, thick] (B\x) -- (C\x) -- (D\x) -- (B\x);
\draw[-, very thick,fill=black] ([xshift=-0.6em,yshift=-1.2em]B\x) -- ([xshift=-0.3em,yshift=-1em]B\x) -- ([yshift=-1.2em]B\x) --([xshift=0.3em,yshift=-1em]B\x) -- ([xshift=0.6em,yshift=-1.2em]B\x) -- (D\x) -- (C\x) -- ([xshift=-0.6em,yshift=-1.2em]B\x); \draw[-, thick,fill=black] ([xshift=-0.6em,yshift=-1.2em]B\x) -- ([xshift=-0.3em,yshift=-1em]B\x) -- ([yshift=-1.2em]B\x) --([xshift=0.3em,yshift=-1em]B\x) -- ([xshift=0.6em,yshift=-1.2em]B\x) -- (D\x) -- (C\x) -- ([xshift=-0.6em,yshift=-1.2em]B\x);
\draw[-, very thick,fill=black] (E\x) -- ([xshift=0.2em,yshift=0.3em]E\x) -- ([xshift=0.33em]F\x) -- (F\x) -- (E\x); \draw[-, thick,fill=black] (E\x) -- ([xshift=0.2em,yshift=0.3em]E\x) -- ([xshift=0.33em]F\x) -- (F\x) -- (E\x);
\node[circle,inner sep=0pt,minimum size=0.4em,fill=black] at ([xshift=-0.7em,yshift=-0.2em]B\x){}; \node[circle,inner sep=0pt,minimum size=0.4em,fill=black] at ([xshift=-0.7em,yshift=-0.2em]B\x){};
\node[draw,rounded corners=2pt,fill=yellow!20,minimum width=2.3cm,minimum height=1cm](cnn\x) at ([xshift=9.5em,yshift=-1.5em]A\x){CNN}; \node[draw,rounded corners=2pt,fill=yellow!20,minimum height=2.2em,minimum width=4.3em](cnn\x) at ([xshift=9.5em,yshift=-1.5em]A\x){CNN};
\node[draw,circle,fill=green!20,font=\footnotesize,anchor=west,inner sep=3pt] (h\x_2) at ([xshift=3em,yshift=0.66em]cnn\x.east){$h_2$}; \node[draw,circle,fill=green!20,font=\footnotesize,anchor=west,inner sep=3pt] (h\x_2) at ([xshift=3em,yshift=0.66em]cnn\x.east){$h_2$};
\node[draw,circle,fill=green!20,font=\footnotesize,anchor=south,inner sep=3pt] (h\x_1) at ([yshift=1em]h\x_2.north){$h_1$}; \node[draw,circle,fill=green!20,font=\footnotesize,anchor=south,inner sep=3pt] (h\x_1) at ([yshift=1em]h\x_2.north){$h_1$};
\node[font=\footnotesize,anchor=north] (h\x_c) at ([yshift=-0.6em]h\x_2.south){$\cdots$}; \node[font=\footnotesize,anchor=north] (h\x_c) at ([yshift=-0.6em]h\x_2.south){$\cdots$};
...@@ -36,11 +36,11 @@ ...@@ -36,11 +36,11 @@
\node[draw,thick,rounded corners=2pt,densely dashed,inner ysep=1.2em,inner xsep=0.4em,label={above:图像特征向量}][fit=(h2_1)(h2_2)(h2_n)](box2){}; \node[draw,thick,rounded corners=2pt,densely dashed,inner ysep=1.2em,inner xsep=0.4em,label={above:图像特征向量}][fit=(h2_1)(h2_2)(h2_n)](box2){};
\end{pgfonlayer} \end{pgfonlayer}
\node[anchor=west,draw,rounded corners=2pt,fill=blue!20,minimum width=2.3cm,minimum height=1cm] (decoder1)at ([xshift=3em]box1.east){解码器}; \node[anchor=west,draw,rounded corners=2pt,fill=red!20,minimum height=2.2em,minimum width=4.3em] (decoder1)at ([xshift=3em]box1.east){解码器};
\node[anchor=west,draw,circle,inner sep=0pt,minimum size=1.4em] (add)at ([xshift=2em,yshift=1.6em]box2.east){}; \node[anchor=west,draw,circle,inner sep=0pt,minimum size=1.4em] (add)at ([xshift=2em,yshift=1.6em]box2.east){};
\draw[] (add.0) -- (add.180); \draw[] (add.0) -- (add.180);
\draw[] (add.90) -- (add.-90); \draw[] (add.90) -- (add.-90);
\node[anchor=west,draw,rounded corners=2pt,fill=blue!20,minimum width=2.3cm,minimum height=1cm] (decoder2)at ([xshift=6em]box2.east){解码器}; \node[anchor=west,draw,rounded corners=2pt,fill=red!20,minimum height=2.2em,minimum width=4.3em] (decoder2)at ([xshift=6em]box2.east){解码器};
\draw[->,thick] ([xshift=-2.7em]cnn1.180) -- ([xshift=-0.1em]cnn1.180); \draw[->,thick] ([xshift=-2.7em]cnn1.180) -- ([xshift=-0.1em]cnn1.180);
......
Chapter17/Figures/figure-image-translation-task.tex
...@@ -94,10 +94,10 @@ ...@@ -94,10 +94,10 @@
\node [draw,single arrow,minimum height=2.4em,single arrow head extend=0.4em] (arrow3) at ([xshift=-2.4em,yshift=-1.5em]A4) {}; \node [draw,single arrow,minimum height=2.4em,single arrow head extend=0.4em] (arrow3) at ([xshift=-2.4em,yshift=-1.5em]A4) {};
\node [draw,single arrow,minimum height=2.4em,single arrow head extend=0.4em] (arrow4) at ([xshift=-2.5em,yshift=-1.5em]A5) {}; \node [draw,single arrow,minimum height=2.4em,single arrow head extend=0.4em] (arrow4) at ([xshift=-2.5em,yshift=-1.5em]A5) {};
\node[anchor=north,font=\small,scale=1.5] at ([yshift=-6em]arrow1.south){（a）多模态机器翻译}; \node[anchor=north,font=\small,scale=1.5] at ([yshift=-6em]arrow1.south){(a) 多模态机器翻译};
\node[anchor=north,font=\small,scale=1.5] at ([yshift=-6em]arrow2.south){（b）图像到文本翻译}; \node[anchor=north,font=\small,scale=1.5] at ([yshift=-6em]arrow2.south){(b) 图像到文本翻译};
\node[anchor=north,font=\small,scale=1.5] at ([yshift=-6em]arrow3.south){（c）图像到图像翻译}; \node[anchor=north,font=\small,scale=1.5] at ([yshift=-6em]arrow3.south){(c) 图像到图像翻译};
\node[anchor=north,font=\small,scale=1.5] at ([yshift=-6em]arrow4.south){（d）文本到图像翻译}; \node[anchor=north,font=\small,scale=1.5] at ([yshift=-6em]arrow4.south){(d) 文本到图像翻译};
\end{tikzpicture} \end{tikzpicture}
%------------------------------------------------------------------------------------------------------------ %------------------------------------------------------------------------------------------------------------
Chapter17/Figures/figure-modeling-a-global-approach-to-visual-characteristics.tex
...@@ -24,13 +24,12 @@ ...@@ -24,13 +24,12 @@
\draw[-, very thick,fill=black] ([xshift=-0.6em,yshift=-1.2em]B\x) -- ([xshift=-0.3em,yshift=-1em]B\x) -- ([yshift=-1.2em]B\x) --([xshift=0.3em,yshift=-1em]B\x) -- ([xshift=0.6em,yshift=-1.2em]B\x) -- (D\x) -- (C\x) -- ([xshift=-0.6em,yshift=-1.2em]B\x); \draw[-, very thick,fill=black] ([xshift=-0.6em,yshift=-1.2em]B\x) -- ([xshift=-0.3em,yshift=-1em]B\x) -- ([yshift=-1.2em]B\x) --([xshift=0.3em,yshift=-1em]B\x) -- ([xshift=0.6em,yshift=-1.2em]B\x) -- (D\x) -- (C\x) -- ([xshift=-0.6em,yshift=-1.2em]B\x);
\draw[-, very thick,fill=black] (E\x) -- ([xshift=0.2em,yshift=0.3em]E\x) -- ([xshift=0.33em]F\x) -- (F\x) -- (E\x); \draw[-, very thick,fill=black] (E\x) -- ([xshift=0.2em,yshift=0.3em]E\x) -- ([xshift=0.33em]F\x) -- (F\x) -- (E\x);
\node[circle,inner sep=0pt,minimum size=0.4em,fill=black] at ([xshift=-0.7em,yshift=-0.2em]B\x){}; \node[circle,inner sep=0pt,minimum size=0.4em,fill=black] at ([xshift=-0.7em,yshift=-0.2em]B\x){};
\node[draw,rounded corners=2pt,fill=yellow!20,minimum width=2.3cm,minimum height=1cm](cnn\x) at ([xshift=1.8em,yshift=3.6em]A\x){CNN}; \node[draw,rounded corners=2pt,fill=yellow!20,minimum width=2.3cm,minimum height=2.2em](cnn\x) at ([xshift=1.8em,yshift=3.6em]A\x){CNN};
} }
\node[draw,anchor=south,rounded corners=2pt,minimum width=4.0cm,minimum height=2.2em,fill=red!20](encoder) at ([yshift=2.6em,xshift=2.2em]cnn1.north){编码器};
\node[draw,anchor=south,rounded corners=2pt,minimum width=4.0cm,minimum height=1cm,fill=red!20](encoder) at ([yshift=2.6em,xshift=2.2em]cnn1.north){编码器};
\node[anchor=north,font=\Large](x) at ([xshift=2.5em,yshift=-3.4em]encoder.south){$\seq{x}$}; \node[anchor=north,font=\Large](x) at ([xshift=2.5em,yshift=-3.4em]encoder.south){$\seq{x}$};
\node[draw,anchor=south,rounded corners=2pt,minimum width=4.0cm,minimum height=1cm,fill=blue!20](decoder) at ([yshift=2.6em,xshift=2.2em]cnn2.north){解码器}; \node[draw,anchor=south,rounded corners=2pt,minimum width=4.0cm,minimum height=2.2em,fill=ugreen!20](decoder) at ([yshift=2.6em,xshift=2.2em]cnn2.north){解码器};
\node[anchor=north,font=\Large](y) at ([xshift=2.5em,yshift=-3.4em]decoder.south){$\seq{y}$}; \node[anchor=north,font=\Large](y) at ([xshift=2.5em,yshift=-3.4em]decoder.south){$\seq{y}$};
\node[anchor=south,font=\Large](y_1) at ([yshift=3em]decoder.north){$\seq{y}'$}; \node[anchor=south,font=\Large](y_1) at ([yshift=3em]decoder.north){$\seq{y}'$};
......
Chapter17/Figures/figure-speech-recognition-model-based-on-transformer.tex
...@@ -17,11 +17,11 @@ ...@@ -17,11 +17,11 @@
\node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.4em]de_sa.north){Multi-Head \\ Attention}; \node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.4em]de_sa.north){Multi-Head \\ Attention};
\node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.4em]de_ca.north){Feed Forward \\ Network}; \node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.4em]de_ca.north){Feed Forward \\ Network};
\node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=2em]de_ffn.north){Softmax}; \node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=1.6em]de_ffn.north){Softmax};
\node[layer,anchor=south,fill=orange!20] (output) at ([yshift=1.4em]sf.north){Output Probabilities}; %\node[layer,anchor=south,fill=orange!20] (output) at ([yshift=1.4em]sf.north){Output Probabilities};
\node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){Speech Feature\\(FilterBank/MFCC)}; \node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){Speech Feature\\(FBank/MFCC)};
\node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1em]de_add.south){Transcription\\(Embedding)}; \node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1.1em]de_add.south){Transcription\\(Embedding)};
\node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){Position\\(Embedding)}; \node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){Position\\(Embedding)};
\node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){Position\\(Embedding)}; \node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){Position\\(Embedding)};
...@@ -35,13 +35,13 @@ ...@@ -35,13 +35,13 @@
\draw[->] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_ca.-90); \draw[->] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_ca.-90);
\draw[->] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_ffn.-90); \draw[->] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_ffn.-90);
\draw[->] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]sf.-90); \draw[->] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]sf.-90);
\draw[->] ([yshift=0.1em]sf.90) -- ([yshift=-0.1em]output.-90); \draw[->] ([yshift=0.1em]sf.90) -- ([yshift=1.5em]sf.90);
\draw[->] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180); \draw[->] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180);
\draw[->] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0); \draw[->] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0);
\draw[->,rounded corners=2pt] ([yshift=0.1em]en_ffn.90) -- ([yshift=2em]en_ffn.90) -- ([xshift=4em,yshift=2em]en_ffn.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west); \draw[->,rounded corners=2pt] ([yshift=0.1em]en_ffn.90) -- ([yshift=2em]en_ffn.90) -- ([xshift=4em,yshift=2em]en_ffn.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west);
\begin{pgfonlayer}{background} \begin{pgfonlayer}{background}
\node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt][fit=(en_sa)(en_ffn)](box1){}; \node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(en_sa)(en_ffn)](box1){};
\node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt][fit=(de_sa)(de_ca)(de_ffn)](box2){}; \node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(de_sa)(de_ca)(de_ffn)](box2){};
\end{pgfonlayer} \end{pgfonlayer}
\node[anchor=east,font=\scriptsize,text=ugreen] at ([xshift=-0.1em]box1.west){$N \times$}; \node[anchor=east,font=\scriptsize,text=ugreen] at ([xshift=-0.1em]box1.west){$N \times$};
......
Chapter17/Figures/figure-speech-translation-model-based-on-CTC.tex
...@@ -19,11 +19,11 @@ ...@@ -19,11 +19,11 @@
\node[layer,anchor=south,fill=blue!20] (en_sf) at ([yshift=3em]en_ffn.north){Softmax}; \node[layer,anchor=south,fill=blue!20] (en_sf) at ([yshift=3em]en_ffn.north){Softmax};
\node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=2em]de_ffn.north){Softmax}; \node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=2em]de_ffn.north){Softmax};
\node[layer,anchor=south,fill=orange!20] (en_output) at ([yshift=1.4em]en_sf.north){CTC输出}; \node[layer,anchor=south,fill=orange!20] (en_output) at ([yshift=1.4em]en_sf.north){CTC Output};
\node[layer,anchor=south,fill=orange!20] (output) at ([yshift=1.4em]sf.north){语音翻译输出}; %\node[layer,anchor=south,fill=orange!20] (output) at ([yshift=1.4em]sf.north){ST Output};
\node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){语音特征\\(FilterBank/MFCC)}; \node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){Speech Feature\\(FBank/MFCC)};
\node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1em]de_add.south){目标文本\\(Embedding)}; \node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1em]de_add.south){Target Text\\(Embedding)};
\node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){Position\\(Embedding)}; \node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){Position\\(Embedding)};
\node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){Position\\(Embedding)}; \node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){Position\\(Embedding)};
...@@ -39,18 +39,18 @@ ...@@ -39,18 +39,18 @@
\draw[->] ([yshift=0.1em]en_ffn.90) -- ([yshift=-0.1em]en_sf.-90); \draw[->] ([yshift=0.1em]en_ffn.90) -- ([yshift=-0.1em]en_sf.-90);
\draw[->] ([yshift=0.1em]en_sf.90) -- ([yshift=-0.1em]en_output.-90); \draw[->] ([yshift=0.1em]en_sf.90) -- ([yshift=-0.1em]en_output.-90);
\draw[->] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]sf.-90); \draw[->] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]sf.-90);
\draw[->] ([yshift=0.1em]sf.90) -- ([yshift=-0.1em]output.-90); \draw[->] ([yshift=0.1em]sf.90) -- ([yshift=1.5em]sf.90);
\draw[->] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180); \draw[->] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180);
\draw[->] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0); \draw[->] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0);
\draw[->,rounded corners=2pt] ([yshift=2em]en_ffn.90) -- ([xshift=4em,yshift=2em]en_ffn.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west); \draw[->,rounded corners=2pt] ([yshift=2em]en_ffn.90) -- ([xshift=4em,yshift=2em]en_ffn.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west);
\begin{pgfonlayer}{background} \begin{pgfonlayer}{background}
\node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt][fit=(en_sa)(en_ffn)]{}; \node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(en_sa)(en_ffn)]{};
\node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt][fit=(de_sa)(de_ca)(de_ffn)]{}; \node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(de_sa)(de_ca)(de_ffn)]{};
\end{pgfonlayer} \end{pgfonlayer}
\node[anchor=east,font=\scriptsize,text=ugreen] at ([xshift=-0.1em]box1.west){$N \times$}; \node[anchor=east,font=\scriptsize,text=ugreen] at ([xshift=-0.1em]box1.west){$N \times$};
\node[anchor=west,font=\scriptsize,text=red] at ([xshift=0.1em]box2.east){$\times N$}; \node[anchor=west,font=\scriptsize,text=red] at ([xshift=0.1em]box2.east){$\times N$};
\node[anchor=east,font=\scriptsize] at ([xshift=-0.1em]en_cnn.west){$2 \times$}; \node[anchor=east,font=\scriptsize] at ([xshift=-0.1em]en_cnn.west){$2 \times$};
\node[anchor=east,font=\scriptsize,align=center,text=ugreen] at ([xshift=-0.1em,yshift=3em]box1.west){语音翻译\\编码器}; \node[anchor=east,font=\scriptsize,align=center,text=ugreen] at ([xshift=-0.1em,yshift=3em]box1.west){ST\\Encoder};
\node[anchor=west,font=\scriptsize,align=center,text=red] at ([xshift=0.1em,yshift=5em]box2.east){语音翻译\\解码器}; \node[anchor=west,font=\scriptsize,align=center,text=red] at ([xshift=0.1em,yshift=5em]box2.east){ST\\Decoder};
\end{tikzpicture} \end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-the-encoder-explicitly-incorporates-semantic-information.tex
...@@ -2,32 +2,32 @@ ...@@ -2,32 +2,32 @@
\begin{tikzpicture}[node distance = 0,scale = 0.9] \begin{tikzpicture}[node distance = 0,scale = 0.9]
\tikzstyle{every node}=[scale=0.9] \tikzstyle{every node}=[scale=0.9]
\node(figure)[draw=white,scale=0.4] {\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-bank-without-attention.png}}; \node(figure)[draw=white,scale=0.4] {\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-bank-without-attention.png}};
\node(river)[word, right of = figure, xshift=5cm, yshift=0.35cm, fill=blue!45]{river}; \node(river)[word, right of = figure, xshift=5cm, yshift=0.35cm, fill=ugreen!45]{river};
\node(mountain)[word, above of = river, yshift=0.75cm, fill=blue!45]{mountain}; \node(mountain)[word, above of = river, yshift=0.75cm, fill=ugreen!45]{mountain};
\node(child)[word, above of = mountain, yshift=0.75cm, fill=blue!15]{child}; \node(child)[word, above of = mountain, yshift=0.75cm, fill=ugreen!15]{child};
\node(man)[word, above of = child, yshift=0.75cm, fill=blue!25]{man}; \node(man)[word, above of = child, yshift=0.75cm, fill=ugreen!25]{man};
\node(jump)[word, below of = river, yshift=-0.75cm, fill=blue!30]{jump}; \node(jump)[word, below of = river, yshift=-0.75cm, fill=ugreen!30]{jump};
\node(bank)[word, below of = jump, yshift=-0.75cm, fill=blue!65]{bank}; \node(bank)[word, below of = jump, yshift=-0.75cm, fill=ugreen!65]{bank};
\node(sky)[word, below of = bank, yshift=-0.75cm, fill=blue!30]{sky}; \node(sky)[word, below of = bank, yshift=-0.75cm, fill=ugreen!30]{sky};
\node(tree)[word, below of = sky, yshift=-0.75cm, fill=blue!15]{tree}; \node(tree)[word, below of = sky, yshift=-0.75cm, fill=ugreen!15]{tree};
\node(cir)[circle,very thick, minimum width=0.6cm, xshift=8cm, draw=black]{}; \node(cir)[circle,thick, minimum width=0.6cm, xshift=8cm, draw=black]{};
\node(decoder)[rectangle, rounded corners, minimum width=2.5cm, minimum height=1.2cm, right of = cir,xshift=3cm, draw=black, fill=blue!25]{\large{解码器}}; \node(decoder)[rectangle, rounded corners, minimum height=2.2em,minimum width=4.3em, right of = cir,xshift=3cm, draw=black, fill=ugreen!25]{\large{解码器}};
\node(yn_1)[below of = decoder,yshift=-2cm,scale=1.2]{$\rm y_{n-1}$}; \node(yn_1)[below of = decoder,yshift=-2cm,scale=1.2]{$\rm y_{n-1}$};
\node(yn_2)[above of = decoder,yshift=2cm,scale=1.2]{$\rm y'_{n-1}$(bank)}; \node(yn_2)[above of = decoder,yshift=2cm,scale=1.2]{$\rm y'_{n-1}$(bank)};
\draw[->, very thick]([xshift=0.1cm]figure.east)to([xshift=2cm]figure.east); \draw[->, thick]([xshift=0.1cm]figure.east)to([xshift=2cm]figure.east);
\draw[-,very thick]([xshift=-0.03cm]cir.east)to([xshift=0.03cm]cir.west); \draw[-,thick]([xshift=-0.03cm]cir.east)to([xshift=0.03cm]cir.west);
\draw[-,very thick]([yshift=0.03cm]cir.south)to([yshift=-0.03cm]cir.north); \draw[-,thick]([yshift=0.03cm]cir.south)to([yshift=-0.03cm]cir.north);
\draw[->, very thick]([xshift=0.1cm]cir.east)to([xshift=-0.1cm]decoder.west); \draw[->, thick]([xshift=0.1cm]cir.east)to([xshift=-0.1cm]decoder.west);
\draw[->, very thick](yn_1)to([yshift=-0.1cm]decoder.south); \draw[->, thick](yn_1)to([yshift=-0.1cm]decoder.south);
\draw[->, very thick]([yshift=0.1cm]decoder.north)to(yn_2); \draw[->, thick]([yshift=0.1cm]decoder.north)to(yn_2);
\draw[->, thick, color=blue!45]([xshift=0.05cm]river.east)to([xshift=-0.05cm]cir.west); \draw[->, thick, color=ugreen!45]([xshift=0.05cm]river.east)to([xshift=-0.05cm]cir.west);
\draw[->, thick, color=blue!45]([xshift=0.05cm]mountain.east)to([xshift=-0.05cm]cir.west); \draw[->, thick, color=ugreen!45]([xshift=0.05cm]mountain.east)to([xshift=-0.05cm]cir.west);
\draw[->, thick, color=blue!15]([xshift=0.05cm]child.east)to([xshift=-0.05cm]cir.west); \draw[->, thick, color=ugreen!15]([xshift=0.05cm]child.east)to([xshift=-0.05cm]cir.west);
\draw[->, thick, color=blue!25]([xshift=0.05cm]man.east)to([xshift=-0.05cm]cir.west); \draw[->, thick, color=ugreen!25]([xshift=0.05cm]man.east)to([xshift=-0.05cm]cir.west);
\draw[->, thick, color=blue!30]([xshift=0.05cm]jump.east)to([xshift=-0.05cm]cir.west); \draw[->, thick, color=ugreen!30]([xshift=0.05cm]jump.east)to([xshift=-0.05cm]cir.west);
\draw[->, thick, color=blue!65]([xshift=0.05cm]bank.east)to([xshift=-0.05cm]cir.west); \draw[->, very thick, color=ugreen!65]([xshift=0.05cm]bank.east)to([xshift=-0.05cm]cir.west);
\draw[->, thick, color=blue!30]([xshift=0.05cm]sky.east)to([xshift=-0.05cm]cir.west); \draw[->, thick, color=ugreen!30]([xshift=0.05cm]sky.east)to([xshift=-0.05cm]cir.west);
\draw[->, thick, color=blue!15]([xshift=0.05cm]tree.east)to([xshift=-0.05cm]cir.west); \draw[->, thick, color=ugreen!15]([xshift=0.05cm]tree.east)to([xshift=-0.05cm]cir.west);
\end{tikzpicture} \end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-three-ways-of-dual-decoder-speech-translation.tex
\tikzstyle{coder} = [rectangle,thick,rounded corners,minimum width=2.3cm,minimum height=1cm,text centered,draw=black!70,fill=red!20] \tikzstyle{coder} = [rectangle,thick,rounded corners,minimum height=2.2em,minimum width=4.3em,text centered,draw=black!70,fill=red!20]
\begin{tikzpicture}[node distance = 0,scale = 0.75] \begin{tikzpicture}[node distance = 0,scale = 0.75]
\tikzstyle{every node}=[scale=0.75] \tikzstyle{every node}=[scale=0.75]
\node(encoder)[coder]at (0,0){\large{编码器}}; \node(encoder)[coder]at (0,0){\large{编码器}};
\node(decoder_1)[coder,above of =encoder,xshift=-1.6cm,yshift=2.8cm,fill=blue!20]{\large{解码器}}; \node(decoder_1)[coder,above of =encoder,xshift=-1.6cm,yshift=2.8cm,fill=ugreen!20]{\large{解码器}};
\node(decoder_2)[coder,above of =encoder, xshift=1.6cm,yshift=2.8cm,fill=yellow!20]{\large{解码器}}; \node(decoder_2)[coder,above of =encoder, xshift=1.6cm,yshift=2.8cm,fill=yellow!20]{\large{解码器}};
\node(s)[below of = encoder,yshift=-1.8cm,scale=1.6]{$s$}; \node(s)[below of = encoder,yshift=-1.8cm,scale=1.2]{$s$};
\node(x)[above of = decoder_1,yshift=1.8cm,scale=1.6]{$x$}; \node(x)[above of = decoder_1,yshift=1.8cm,scale=1.2]{$x$};
\node(y)[above of = decoder_2,yshift=1.8cm,scale=1.6]{$y$}; \node(y)[above of = decoder_2,yshift=1.8cm,scale=1.2]{$y$};
\draw[->,thick](s.north)to(encoder.south); \draw[->,thick](s.north)to(encoder.south);
\draw[->,thick](decoder_1.north)to(x.south); \draw[->,thick](decoder_1.north)to(x.south);
\draw[->,thick](decoder_2.north)to(y.south); \draw[->,thick](decoder_2.north)to(y.south);
\draw[->,thick](encoder.north)--([yshift=0.7cm]encoder.north)--([xshift=-4.16em,yshift=0.7cm]encoder.north)--(decoder_1.south); \draw[->,thick](encoder.north)--([yshift=0.7cm]encoder.north)--([xshift=-4.16em,yshift=0.7cm]encoder.north)--(decoder_1.south);
\draw[->,thick](encoder.north)--([yshift=0.7cm]encoder.north)--([xshift=4.16em,yshift=0.7cm]encoder.north)--(decoder_2.south); \draw[->,thick](encoder.north)--([yshift=0.7cm]encoder.north)--([xshift=4.16em,yshift=0.7cm]encoder.north)--(decoder_2.south);
\node [anchor=north,scale = 1.2](pos1) at (s.south) {(a) 单编码器-双解码器方式}; \node [anchor=north,scale = 1.2](pos1) at (s.south) {(a) 单编码器-双解码器};
\node [anchor=south,scale=1.2] (node1) at ([xshift=-2.0em,yshift=6em]decoder_1.north) {{$x,y$：语言数据}}; \node [anchor=south,scale=1.2] (node1) at ([xshift=-2.0em,yshift=6em]decoder_1.north) {{$x,y$：语言数据}};
\node [anchor=north,scale=1.2] (node2) at ([xshift=0.6em]node1.south){{$s$：语音数据}}; \node [anchor=north,scale=1.2] (node2) at ([xshift=0.6em]node1.south){{$s$：语音数据}};
%%%%%%%%%%%%%%%%%%%%%%%%级联 %%%%%%%%%%%%%%%%%%%%%%%%级联
\node(encoder-2)[coder]at ([xshift=10.0em]encoder.east){\large{编码器}}; \node(encoder-2)[coder]at ([xshift=12.0em]encoder.east){\large{编码器}};
\node(decoder_1-2)[coder,above of =encoder-2,yshift=1.4cm,fill=blue!20]{\large{解码器}}; \node(decoder_1-2)[coder,above of =encoder-2,yshift=1.4cm,fill=ugreen!20]{\large{解码器}};
\node(decoder_2-2)[coder,above of =decoder_1-2, yshift=1.4cm,fill=yellow!20]{\large{解码器}}; \node(decoder_2-2)[coder,above of =decoder_1-2, yshift=1.4cm,fill=yellow!20]{\large{解码器}};
\node(s-2)[below of = encoder-2,yshift=-1.8cm,scale=1.6]{$s$}; \node(s-2)[below of = encoder-2,yshift=-1.8cm,scale=1.2]{$s$};
\node(y-2)[above of = decoder_2-2,yshift=1.8cm,scale=1.6]{$y$}; \node(y-2)[above of = decoder_2-2,yshift=1.8cm,scale=1.2]{$y$};
\draw[->,thick](s-2.north)to(encoder-2.south); \draw[->,thick](s-2.north)to(encoder-2.south);
\draw[->,thick](encoder-2.north)to(decoder_1-2.south); \draw[->,thick](encoder-2.north)to(decoder_1-2.south);
\draw[->,thick](decoder_1-2.north)to(decoder_2-2.south); \draw[->,thick](decoder_1-2.north)to(decoder_2-2.south);
\draw[->,thick](decoder_2-2.north)to(y-2.south); \draw[->,thick](decoder_2-2.north)to(y-2.south);
\node [anchor=north,scale = 1.2](pos2) at (s-2.south) {(b) 级联编码器方式}; \node [anchor=north,scale = 1.2](pos2) at (s-2.south) {(b) 级联编码器};
%%%%%%%%%%%%%%%%%%%%%%%%联合 %%%%%%%%%%%%%%%%%%%%%%%%联合
\node(encoder-3)[coder]at([xshift=10.0em]encoder-2.east){\large{编码器}}; \node(encoder-3)[coder]at([xshift=10.0em]encoder-2.east){\large{编码器}};
\node(decoder_1-3)[coder,above of =encoder-3,xshift=-1.6cm,yshift=2.8cm,fill=blue!20]{\large{解码器}}; \node(decoder_1-3)[coder,above of =encoder-3,xshift=-1.6cm,yshift=2.8cm,fill=ugreen!20]{\large{解码器}};
\node(decoder_2-3)[coder,above of =encoder-3, xshift=1.6cm,yshift=2.8cm,fill=yellow!20]{\large{解码器}}; \node(decoder_2-3)[coder,above of =encoder-3, xshift=1.6cm,yshift=2.8cm,fill=yellow!20]{\large{解码器}};
\node(s-3)[below of = encoder-3,yshift=-1.8cm,scale=1.6]{$s$}; \node(s-3)[below of = encoder-3,yshift=-1.8cm,scale=1.2]{$s$};
\node(y-3)[above of = decoder_2-3,yshift=1.8cm,scale=1.6]{$y$}; \node(y-3)[above of = decoder_2-3,yshift=1.8cm,scale=1.2]{$y$};
\draw[->,thick](s-3.north)to(encoder-3.south); \draw[->,thick](s-3.north)to(encoder-3.south);
\draw[->,thick](decoder_1-3.east)to(decoder_2-3.west); \draw[->,thick](decoder_1-3.east)to(decoder_2-3.west);
\draw[->,thick](decoder_2-3.north)to(y-3.south); \draw[->,thick](decoder_2-3.north)to(y-3.south);
\draw[->,thick](encoder-3.north)--([yshift=0.7cm]encoder-3.north)--([xshift=-4.16em,yshift=0.7cm]encoder-3.north)--(decoder_1-3.south); \draw[->,thick](encoder-3.north)--([yshift=0.7cm]encoder-3.north)--([xshift=-4.16em,yshift=0.7cm]encoder-3.north)--(decoder_1-3.south);
\draw[->,thick](encoder-3.north)--([yshift=0.7cm]encoder-3.north)--([xshift=4.16em,yshift=0.7cm]encoder-3.north)--(decoder_2-3.south); \draw[->,thick](encoder-3.north)--([yshift=0.7cm]encoder-3.north)--([xshift=4.16em,yshift=0.7cm]encoder-3.north)--(decoder_2-3.south);
\node [anchor=north,scale = 1.2](pos3) at (s-3.south) {(c) 联合编码器方式}; \node [anchor=north,scale = 1.2](pos3) at (s-3.south) {(c) 联合编码器};
\end{tikzpicture} \end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-traditional-methods-of-image-description.tex
...@@ -17,16 +17,16 @@ ...@@ -17,16 +17,16 @@
\node(surd-1)[right of = text_3-1, xshift=2cm,scale=1.5]{\textcolor{red}{$\surd$}}; \node(surd-1)[right of = text_3-1, xshift=2cm,scale=1.5]{\textcolor{red}{$\surd$}};
\node(text_4-1)[description, right of = figure-1, xshift=5.2cm,yshift=-0.9cm,fill=color_blue]{\textcolor{white}{男人戴着眼镜。}}; \node(text_4-1)[description, right of = figure-1, xshift=5.2cm,yshift=-0.9cm,fill=color_blue]{\textcolor{white}{男人戴着眼镜。}};
\node(point-1)[right of = figure-1, xshift=5cm,yshift=-1.4cm,scale=1.5]{...}; \node(point-1)[right of = figure-1, xshift=5cm,yshift=-1.4cm,scale=1.5]{...};
\draw[->,very thick](figure-1)to([xshift=-0.1cm]ground-1.west); \draw[->,thick](figure-1)to([xshift=-0.1cm]ground-1.west);
\node(figure)[draw=white,scale=0.25]at ([xshift=20.0em]figure-1.east){\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-dog-with-hat.png}}; \node(figure)[draw=white,scale=0.25]at ([xshift=20.0em]figure-1.east){\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-dog-with-hat.png}};
\node(ground)[rectangle,rounded corners, minimum width=5cm, minimum height=1.5cm,right of = figure, xshift=5cm,yshift=-2.6em,fill=blue!20]{\large{图片中有\underline{\textcolor{red}{狗}}，\underline{\textcolor{red}{帽子}}，\underline{\quad\ }。}}; \node(ground)[rectangle,rounded corners, minimum width=5cm, minimum height=1.5cm,right of = figure, xshift=5cm,yshift=-2.6em,fill=blue!20]{\large{图片中有\underline{\textcolor{red}{狗}}，\underline{\textcolor{red}{帽子}}，\underline{\quad\ }。}};
\node(dog)[rectangle,rounded corners, minimum width=1cm, minimum height=0.7cm,right of = figure, xshift=3cm,yshift=1.5cm,thick, draw=color_orange,fill=color_orange!50]{狗}; \node(dog)[rectangle,rounded corners, minimum width=1cm, minimum height=0.7cm,right of = figure, xshift=3cm,yshift=1.5cm,thick, draw=color_orange,fill=color_orange!50]{狗};
\node(hat)[rectangle,rounded corners, minimum width=1.5cm, minimum height=0.7cm,right of = figure, xshift=4.5cm,yshift=1.5cm,thick, draw=color_green,fill=color_green!50]{帽子}; \node(hat)[rectangle,rounded corners, minimum width=1.5cm, minimum height=0.7cm,right of = figure, xshift=4.5cm,yshift=1.5cm,thick, draw=color_green,fill=color_green!50]{帽子};
\draw[->, very thick,color=black!60](figure.east)to([xshift=-0.1cm]dog.west)node[left,xshift=-0.2cm,yshift=-0.1cm,color=black]{图片检测}; \draw[->, thick,color=black!60](figure.east)to([xshift=-0.1cm]dog.west)node[left,xshift=-0.2cm,yshift=-0.1cm,color=black]{图片检测};
\draw[->, very thick,color=black!60]([yshift=-0.1cm]hat.south)to([yshift=0.1cm]ground.north)node[right,xshift=-0.2cm,yshift=0.5cm,color=black]{模板填充}; \draw[->, thick,color=black!60]([yshift=-0.1cm]hat.south)to([yshift=0.1cm]ground.north)node[right,xshift=-0.2cm,yshift=0.5cm,color=black]{模板填充};
\node [anchor=north](pos1)at ([xshift=-3.8em,yshift=-0.5em]ground-1.south){（a）基于检索的图像描述生成范式}; \node [anchor=north](pos1)at ([xshift=-3.8em,yshift=-0.5em]ground-1.south){(a) 基于检索的图像描述生成范式};
\node [anchor=north](pos2)at ([xshift=-3.8em,yshift=-0.5em]ground.south){（b）基于模板的图像描述生成范式}; \node [anchor=north](pos2)at ([xshift=-3.8em,yshift=-0.5em]ground.south){(b) 基于模板的图像描述生成范式};
\end{tikzpicture} \end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-word-lattice.tex
...@@ -16,25 +16,25 @@ ...@@ -16,25 +16,25 @@
\node[anchor=north,node] (n4) at ([xshift=6em,yshift=-1.6em]n3.south){4}; \node[anchor=north,node] (n4) at ([xshift=6em,yshift=-1.6em]n3.south){4};
\draw[->] (n0.0) -- node[word,above]{of /0.343}(n2.180); \draw[->] (n0.0) -- node[word,above]{for /0.227}(n2.180);
\draw[->] (n0.60) -- node[word,above,rotate=40]{a /0.499}(n1.-150); \draw[->] (n0.60) -- node[word,above,rotate=40]{a /0.628}(n1.-150);
\draw[->] (n0.-50) -- node[word,above,rotate=-20]{our /0.116}(n3.150); \draw[->] (n0.-50) -- node[word,above,rotate=-20]{our /0.103}(n3.150);
\draw[->] (n0.-70) .. controls ([xshift=-8em]n4.180) and ([xshift=-8em]n4.180) .. node[above,word,xshift=3em,yshift=-0.6em]{that /0.039} (n4.180); \draw[->] (n0.-70) .. controls ([xshift=-8em]n4.180) and ([xshift=-8em]n4.180) .. node[above,word,xshift=3em,yshift=-0.6em]{this /0.042} (n4.180);
\draw[->] (n4.0) .. node[word,above,xshift=-2em,yshift=-0.4em]{hostage /1} controls ([xshift=5em]n4.0) and ([yshift=-6em]n6.-90) .. (n6.-90); \draw[->] (n4.0) .. node[word,above,xshift=-2em,yshift=-0.4em]{video /1} controls ([xshift=5em]n4.0) and ([yshift=-6em]n6.-90) .. (n6.-90);
\draw[->] (n2.-90) -- node[word,above,rotate=-18,pos=0.55]{house /0.125}(n7.180); \draw[->] (n2.-90) -- node[word,above,rotate=-18,pos=0.55]{movie /0.127}(n7.180);
\draw[->] (n3.-10) node[word,above,xshift=3.6em,yshift=-0.8em]{conference /1} .. controls ([xshift=4.6em,yshift=-1.8em]n3.-10) and ([yshift=-1.6em,xshift=-3em]n10.-135) .. (n10.-135); \draw[->] (n3.-10) node[word,above,xshift=3.6em,yshift=-0.8em]{book /1} .. controls ([xshift=4.6em,yshift=-1.8em]n3.-10) and ([yshift=-1.6em,xshift=-3em]n10.-135) .. (n10.-135);
\draw[->] (n7.0) -- node[word,above]{which /1}(n10.180); \draw[->] (n7.0) -- node[word,above]{which /1}(n10.180);
\draw[->] (n2.0) -- node[word,above,pos=0.5]{hostages /0.300}(n6.180); \draw[->] (n2.0) -- node[word,above,pos=0.5]{video /0.300}(n6.180);
\draw[->] (n2.45) -- node[word,above,rotate=18,pos=0.3]{a /0.573}(n11.-135); \draw[->] (n2.45) -- node[word,above,rotate=18,pos=0.3]{a /0.573}(n11.-135);
\draw[->,rounded corners=1em] (n1.-45) node[word,above,xshift=1.4em,yshift=-1.3em,rotate=-43]{house /0.078} -- ([yshift=-0.4em,xshift=-1em]n11.-90) -- (n7.100); \draw[->,rounded corners=1em] (n1.-45) node[word,above,xshift=1.4em,yshift=-1.3em,rotate=-43]{movie /0.187} -- ([yshift=-0.4em,xshift=-1em]n11.-90) -- (n7.100);
\draw[->] (n1.20) node[word,above,xshift=4em]{conference /0.734} .. controls ([xshift=8em]n1.20) and ([xshift=-0.6em,yshift=2.2em]n5.110) .. (n5.110); \draw[->] (n1.20) node[word,above,xshift=4em]{book /0.520} .. controls ([xshift=8em]n1.20) and ([xshift=-0.6em,yshift=2.2em]n5.110) .. (n5.110);
\draw[->] (n11.0) -- node[word,above]{conference /1}(n5.180); \draw[->] (n11.0) -- node[word,above]{book /1}(n5.180);
\draw[->] (n5.-90) ..node[word,above,xshift=1.4em]{is /0.773} controls ([yshift=-1.6em]n5.-90) and ([xshift=-3em]n6.150]) .. (n6.150); \draw[->] (n5.-90) ..node[word,above,xshift=1.4em]{is /0.822} controls ([yshift=-1.6em]n5.-90) and ([xshift=-3em]n6.150]) .. (n6.150);
\draw[->] (n5.0) node[word, above,xshift=1.4em]{as /0.226}.. controls ([xshift=2.6em]n5.0) and ([xshift=-0.6em,yshift=2em]n6.120) .. (n6.120); \draw[->] (n5.0) node[word, above,xshift=1.4em]{as /0.178}.. controls ([xshift=2.6em]n5.0) and ([xshift=-0.6em,yshift=2em]n6.120) .. (n6.120);
\coordinate (a) at ([xshift=6em,yshift=3em]n1); \coordinate (a) at ([xshift=6em,yshift=3em]n1);
\draw[->] (n1.60) .. controls ([xshift=3em,yshift=2em]n1.60) and ([xshift=-2em]a) .. (a) node[word,above,xshift=1em]{hostage /0.187}.. controls ([xshift=8em]a) and ([xshift=-0.6em,yshift=6em]n6.90) .. (n6.90); \draw[->] (n1.60) .. controls ([xshift=3em,yshift=2em]n1.60) and ([xshift=-2em]a) .. (a) node[word,above,xshift=1em]{video /0.293}.. controls ([xshift=8em]a) and ([xshift=-0.6em,yshift=6em]n6.90) .. (n6.90);
\draw[->] (n10.0) -- node[above,word,pos=0.4,rotate=30]{is /1}(n6.-135); \draw[->] (n10.0) -- node[above,word,pos=0.4,rotate=30]{is /1}(n6.-135);
\draw[->] (n6.0) -- node[above,word,yshift=0.2em]{being /1}(n8.180); \draw[->] (n6.0) -- node[above,word,yshift=0.2em]{being /1}(n8.180);
\draw[->] (n8.0) -- node[above,word,yshift=0.3em]{recorded /1}(n9.180); \draw[->] (n8.0) -- node[above,word,yshift=0.3em]{written /1}(n9.180);
\end{tikzpicture} \end{tikzpicture}
\ No newline at end of file
Chapter17/chapter17.tex
This source diff could not be displayed because it is too large. You can view the blob instead.
Chapter18/chapter18.tex
...@@ -23,9 +23,9 @@ ...@@ -23,9 +23,9 @@
\chapter{机器翻译应用技术} \chapter{机器翻译应用技术}
\parinterval 近几年，随着翻译品质的不断提升，越来越多的机器翻译需求被挖掘出来。但是，仅凭一个翻译引擎无法满足如此多样的需求。应用机器翻译技术时，需要“额外”考虑很多因素，例如，数据加工方式、交互方式、应用的领域等，甚至机器翻译模型也要经过改造才能适应到不同的场景中。 \parinterval 随着机器翻译品质的不断提升，越来越多的应用需求被挖掘出来。但是，一个优秀的机器翻译引擎并不意味着机器翻译可以被成功应用。机器翻译技术落地需要“额外”考虑很多因素，例如，数据加工方式、交互方式、应用的领域等，甚至机器翻译模型也要经过改造才能适应到不同的场景中。
\parinterval 本章将重点介绍机器翻译应用中所面临的问题，以及解决这些问题可以采用的策略。本章所涉及的内容较为广泛，一方面会大量使用本书前十七章的模型和方法，另一方面也会介绍新的技术手段。最终，本章会结合机器翻译的特点展示机器翻译可能的应用场景，并进行一些对机器翻译未来的思考。 \parinterval 本章将重点介绍机器翻译应用中所面临的问题，以及解决这些问题可以采用的策略。本章所涉及的内容较为广泛，一方面会大量使用本书前十七章的模型和方法，另一方面也会介绍新的技术手段。最终，本章会结合机器翻译的特点展示一些机器翻译可能的应用场景。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
...@@ -37,7 +37,7 @@ ...@@ -37,7 +37,7 @@
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item {\small\bfnew{机器翻译模型很脆弱}}。实验环境下，给定翻译任务，甚至给定训练和测试数据，机器翻译模型可以表现的很好。但是，应用场景是不断变化的。经常会出现训练数据缺乏、应用领域与训练数据不匹配、用户的测试方法与开发者不同等等一系列问题。特别是，对于不同的任务，神经机器翻译模型需要进行非常细致的调整，理想中“一套包打天下”的模型和设置是不存在的。这些都导致一个结果：直接使用既有机器翻译模型很难满足不断变化的应用场景。 \item {\small\bfnew{机器翻译模型很脆弱}}。实验环境下，给定翻译任务，甚至给定训练和测试数据，机器翻译模型可以表现得很好。但是，应用场景是不断变化的。经常会出现训练数据缺乏、应用领域与训练数据不匹配、用户的测试方法与开发者不同等等一系列问题。特别是，对于不同的任务，神经机器翻译模型需要进行非常细致的调整，理想中“一套包打天下”的模型和设置是不存在的。这些都导致一个结果：直接使用既有机器翻译模型很难满足不断变化的应用需求。
\vspace{0.5em} \vspace{0.5em}
\item {\small\bfnew{机器翻译缺少针对场景的应用技术}}。目前为止，机器翻译的研究进展已经为我们提供很好的机器翻译基础模型。但是，用户并不是简单的与这些模型“打交道”，他们更加关注如何解决自身的业务需求，例如，机器翻译应用的交互方式、系统是否可以自己预估翻译可信度等等。甚至，在某些场景中，用户对翻译模型的体积和速度都有非常严格的要求。 \item {\small\bfnew{机器翻译缺少针对场景的应用技术}}。目前为止，机器翻译的研究进展已经为我们提供很好的机器翻译基础模型。但是，用户并不是简单的与这些模型“打交道”，他们更加关注如何解决自身的业务需求，例如，机器翻译应用的交互方式、系统是否可以自己预估翻译可信度等等。甚至，在某些场景中，用户对翻译模型的体积和速度都有非常严格的要求。
...@@ -47,7 +47,7 @@ ...@@ -47,7 +47,7 @@
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 下面本章将重点对机器翻译应用中的若干技术问题展开讨论，旨在给机器翻译应用提供一些可落地的思路。之后，本章也会结合笔者的经验，对机器翻译的发展方向展开一些讨论。 \parinterval 下面本章将重点对机器翻译应用中的若干技术问题展开讨论，旨在给机器翻译应用提供一些可落地的思路。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
...@@ -67,9 +67,9 @@ ...@@ -67,9 +67,9 @@
\parinterval 这时就产生一个问题，能否使用新的数据让系统变得更好？简单直接的方式是，将新的数据和原始数据混合重新训练系统，但是使用全量数据训练模型的周期很长，这种方法的成本很高。而且，新的数据可能是不断产生的，甚至是流式的。这时就需要一种快速、低成本的方式对模型进行更新。 \parinterval 这时就产生一个问题，能否使用新的数据让系统变得更好？简单直接的方式是，将新的数据和原始数据混合重新训练系统，但是使用全量数据训练模型的周期很长，这种方法的成本很高。而且，新的数据可能是不断产生的，甚至是流式的。这时就需要一种快速、低成本的方式对模型进行更新。
\parinterval 增量训练就是满足上述需求的一种方法。本质上来说，神经机器翻译中使用的随机梯度下降方法就是典型的增量训练方法，其基本思想是：每次选择一个样本对模型进行更新，这个过程反复不断执行，每次模型更新都是一次增量训练。当多个样本构成了一个新数据集时，可以把这些新样本作为训练数据，把当前的模型作为初始模型，之后正常执行机器翻译的训练过程即可。如果新增加的数据量不大（比如，几万句对），训练的代价非常低。 \parinterval 增量训练就是满足上述需求的一种方法。{\chapterthirteen}已经就增量训练这个概念展开了一些讨论，这里重点介绍一些具体的实践手段。本质上，神经机器翻译中使用的随机梯度下降方法就是典型的增量训练方法，其基本思想是：每次选择一个样本对模型进行更新，这个过程反复不断执行，每次模型更新都是一次增量训练。当多个样本构成了一个新数据集时，可以把这些新样本作为训练数据，把当前的模型作为初始模型，之后正常执行机器翻译的训练过程即可。如果新增加的数据量不大（比如，几万句对），训练的代价非常低。
\parinterval 这里面的一个问题是，新的数据虽然能代表一部分的翻译现象，但是如果仅仅依赖新数据进行更新，会使模型对新数据过分拟合，进而造成无法很好地处理新数据之外的样本。这也可以被看做是一种灾难性遗忘的问题\upcite{DBLP:conf/coling/GuF20}，即：模型过分注重对新样本的拟合，丧失了旧模型的一部分能力。解决这个问题，有几种思路： \parinterval 这里面的一个问题是，新的数据虽然能代表一部分的翻译现象，但是如果仅仅依赖新数据进行更新，会使模型对新数据过分拟合，进而造成无法很好地处理新数据之外的样本。这也可以被看做是一种灾难性遗忘的问题\upcite{DBLP:conf/coling/GuF20}，即：模型过分注重对新样本的拟合，丧失了旧模型的一部分能力。在应用系统开发中，有几种常用的增量训练方法：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
...@@ -79,7 +79,7 @@ ...@@ -79,7 +79,7 @@
\item 模型插值\upcite{DBLP:conf/emnlp/WangULCS17}。在增量训练之后，将新模型与旧模型进行插值。 \item 模型插值\upcite{DBLP:conf/emnlp/WangULCS17}。在增量训练之后，将新模型与旧模型进行插值。
\vspace{0.5em} \vspace{0.5em}
\item 多目标训练\upcite{barone2017regularization,DBLP:conf/aclnmt/KhayrallahTDK18,DBLP:conf/naacl/ThompsonGKDK19}。在增量训练时，除了在新数据上定义损失函数之外，可以再定义一个在旧数据上的损失函数，这样确保模型可以在两个数据上都有较好的表现。另一种方案是引入正则化项，使新模型的参数不会偏离旧模型的参数太远。 \item 多目标训练\upcite{barone2017regularization,DBLP:conf/aclnmt/KhayrallahTDK18,DBLP:conf/naacl/ThompsonGKDK19}。在增量训练时，除了在新数据上定义损失函数之外，可以再定义一个在旧数据上的损失函数，这样确保模型可以在两个数据上都有较好的表现。也可以引入正则化项，使新模型的参数不会偏离旧模型的参数太远。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
...@@ -106,11 +106,11 @@ ...@@ -106,11 +106,11 @@
\section{交互式机器翻译} \section{交互式机器翻译}
\parinterval 机器翻译的结果会存在错误，因此很多时候需要人工的修改才能被使用。例如，在{\small\bfnew 译后编辑}\index{译后编辑}（Post-editing）\index{Post-editing}中，译员对机器翻译的译文进行修改，最终使译文达到要求。但是，译后编辑的成本仍然很高，因为它需要译员阅读机器翻译的结果，同时做出修改的动作。有时候，由于译文修改的内容较为复杂，译后编辑的时间甚至比人工直接翻译源语言句子的时间都长。因此在机器翻译应用中，需要更高效的方式调整机器翻译的结果，使其达到可用。比如，可以使用质量评估方法（{\chapterfour}），选择模型置信度较高的译文进行译后编辑，对置信度低的译文直接进行人工翻译。而另一种思路是，让人的行为直接影响机器翻译生成译文的过程，让人和机器翻译系统进行交互，在不断的修正中生成更好的译文。这个过程也被称作{\small\bfnew 交互式机器翻译}\index{交互式机器翻译}（Interactive Machine Translation,，IMT）\index{Interactive Machine Translation,，IMT}。 \parinterval 机器翻译的结果会存在错误，因此很多时候需要人工的修改才能被使用。例如，在{\small\bfnew 译后编辑}\index{译后编辑}（Post-editing）\index{Post-editing}中，译员对机器翻译的译文进行修改，最终使译文达到要求。但是，译后编辑的成本仍然很高，因为它需要译员阅读机器翻译的结果，同时做出修改的动作。有时候，由于译文修改的内容较为复杂，译后编辑的时间甚至比人工直接翻译源语言句子的时间都长。因此在机器翻译应用中，需要更高效的方式调整机器翻译的结果，使其达到可用。比如，可以使用质量评估方法（见{\chapterfour}），选择模型置信度较高的译文进行译后编辑，对置信度低的译文直接进行人工翻译。而另一种思路是，让人的行为直接影响机器翻译生成译文的过程，让人和机器翻译系统进行交互，在不断的修正中生成更好的译文。这种方法也被称作{\small\bfnew 交互式机器翻译}\index{交互式机器翻译}（Interactive Machine Translation,，IMT）\index{Interactive Machine Translation,，IMT}。
\parinterval 交互式机器翻译的大致流程如下：机器翻译系统根据用户输入的源语言句子预测出可能的译文交给用户，然后用户在现有翻译的基础上进行接受、修改或者删除等操作，然后翻译系统根据用户的反馈信息再次生成比前一次更好的翻译并提交给用户。以此循环，直到得到最终的译文。 \parinterval 交互式机器翻译的大致流程如下：机器翻译系统根据用户输入的源语言句子预测出可能的译文交给用户，然后用户在现有翻译的基础上进行接受、修改或者删除等操作，然后翻译系统根据用户的反馈信息再次生成比前一次更好的翻译并提交给用户。以此循环，直到得到最终的译文。
\parinterval 图\ref{fig:18-2}给出了一个使用TranSmart系统\footnote{TranSmart：\url{https://transmart.qq.com/index}}进行交互式机器翻译的例子，在这里我们要将一个汉语句子“疼痛/也/可能/会在/夜间/使/你/醒来。”翻译成英语“The pain may also wake you up during the night .”。在开始交互之前，系统首先推荐一个可能的译文“The pain may also wake you up at night .”。在第一次交互中，用户将单词at替换成during，然后系统根据用户修改后的译文立即给出新的译文候选，提供给用户选择。循环往复，直到用户接受了系统当前推荐的译文。 \parinterval 图\ref{fig:18-2}给出了一个使用TranSmart系统进行交互式机器翻译的例子，在这里我们要将一个汉语句子“疼痛/也/可能/会在/夜间/使/你/醒来。”翻译成英语“The pain may also wake you up during the night .”。在开始交互之前，系统首先推荐一个可能的译文“The pain may also wake you up at night .”。在第一次交互中，用户将单词at替换成during，然后系统根据用户修改后的译文立即给出新的译文候选，提供给用户选择。循环往复，直到用户接受了系统当前推荐的译文。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -124,14 +124,19 @@ ...@@ -124,14 +124,19 @@
\parinterval 交互式机器翻译系统主要通过用户的反馈来提升译文的质量，不同类型的反馈信息则影响着系统最终的性能。根据反馈形式的不同，可以将交互式机器翻译分为以下几种： \parinterval 交互式机器翻译系统主要通过用户的反馈来提升译文的质量，不同类型的反馈信息则影响着系统最终的性能。根据反馈形式的不同，可以将交互式机器翻译分为以下几种：
\begin{itemize} \begin{itemize}
\vspace{0.5em}
\item {\small\bfnew 基于前缀的交互式机器翻译}。早期的交互式机器翻译系统都是采用基于前缀的方式。基于翻译系统生成的初始译文，翻译人员从左到右检查翻译的正确性，并在第一个错误的位置进行更正。这为系统提供了一种双重信号：表明该位置上单词必须是译员修改过后的单词，并且该位置之前的单词都是正确的。之后系统根据已经检查过的前缀再生成后面的译文\upcite{DBLP:conf/acl/WuebkerGDHL16,Zens2003EfficientSF,DBLP:journals/coling/BarrachinaBCCCKLNTVV09,DBLP:journals/csl/PerisC19}。 \item {\small\bfnew 基于前缀的交互式机器翻译}。早期的交互式机器翻译系统都是采用基于前缀的方式。基于翻译系统生成的初始译文，翻译人员从左到右检查翻译的正确性，并在第一个错误的位置进行更正。这为系统提供了一种双重信号：表明该位置上单词必须是译员修改过后的单词，并且该位置之前的单词都是正确的。之后系统根据已经检查过的前缀再生成后面的译文\upcite{DBLP:conf/acl/WuebkerGDHL16,Zens2003EfficientSF,DBLP:journals/coling/BarrachinaBCCCKLNTVV09,DBLP:journals/csl/PerisC19}。
\vspace{0.5em}
\item {\small\bfnew 基于片段的交互式机器翻译}。根据用户提供的反馈来生成更好的翻译结果是交互式翻译系统的关键。而基于前缀的系统则存在一个严重的缺陷，当翻译系统获得确定的翻译前缀之后，再重新生成译文时会将原本正确的翻译后缀遗漏了，因此会引入新的错误。在基于片段的交互式机器翻译系统中，翻译人员除了纠正第一个错误的单词，还可以指定在未来迭代中保留的单词序列。之后系统根据这些反馈信号再生成新的译文\upcite{Peris2017InteractiveNM,DBLP:journals/mt/DomingoPC17}。 \item {\small\bfnew 基于片段的交互式机器翻译}。根据用户提供的反馈来生成更好的翻译结果是交互式翻译系统的关键。而基于前缀的系统则存在一个严重的缺陷，当翻译系统获得确定的翻译前缀之后，再重新生成译文时会将原本正确的翻译后缀遗漏了，因此会引入新的错误。在基于片段的交互式机器翻译系统中，翻译人员除了纠正第一个错误的单词，还可以指定在未来迭代中保留的单词序列。之后系统根据这些反馈信号再生成新的译文\upcite{Peris2017InteractiveNM,DBLP:journals/mt/DomingoPC17}。
\vspace{0.5em}
\item {\small\bfnew 基于评分的交互式机器翻译}。随着计算机算力的提升，有时会出现“机器等人”的现象，因此需要提升人参与交互的效率也是需要考虑的。与之前的系统不同，基于评分的交互式机器翻译系统不需要译员选择、纠正或删除某个片段，而是使用译员对译文的评分来强化机器翻译的学习\upcite{DBLP:journals/corr/abs-1805-01553,DBLP:conf/emnlp/NguyenDB17}。 \item {\small\bfnew 基于评分的交互式机器翻译}。随着计算机算力的提升，有时会出现“机器等人”的现象，因此需要提升人参与交互的效率也是需要考虑的。与之前的系统不同，基于评分的交互式机器翻译系统不需要译员选择、纠正或删除某个片段，而是使用译员对译文的评分来强化机器翻译的学习\upcite{DBLP:journals/corr/abs-1805-01553,DBLP:conf/emnlp/NguyenDB17}。
\vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 除此之外，基于在线学习的框架越来越引发人们的关注。在学习过程中，用户希望翻译系统能从反馈中自动纠正以前的错误。当用户最终确认一个修改过后的译文后，翻译系统将源语与该修正后的译文作为训练语料继续训练\upcite{DBLP:conf/acl/DomingoGEBHPCH19}。实际上，交互式机器翻译是机器翻译大规模应用的重要路径之一，它为打通译员和机器翻译系统之间的障碍提供了手段。不过，交互式机器翻译也有许多挑战等待解决。一个是如何设计交互方式？理想的交互方式应该式更加贴近译员输入文字的习惯，比如，利用输入法完成交互；另一个是如何把交互式翻译嵌入到翻译的生产流程里？这本身不完全是一个技术问题，可能需要更多的产品手段来求解。 \parinterval 除此之外，基于在线学习的方法也受到了关注，这类方法也可以被看作是交互式翻译与增量训练的一种结合。用户总是希望翻译系统能从反馈中自动纠正以前的错误。当用户最终确认一个修改过后的译文后，翻译系统将源语与该修正后的译文作为训练语料继续训练\upcite{DBLP:conf/acl/DomingoGEBHPCH19}。实际上，交互式机器翻译是机器翻译大规模应用的重要路径之一，它为打通译员和机器翻译系统之间的障碍提供了手段。不过，交互式机器翻译也有许多挑战等待解决。一个是如何设计交互方式？理想的交互方式应该式更加贴近译员输入文字的习惯，比如，利用输入法完成交互；另一个是如何把交互式翻译嵌入到翻译的生产流程里？这本身不完全是一个技术问题，可能需要更多的产品手段来求解。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
...@@ -140,12 +145,12 @@ ...@@ -140,12 +145,12 @@
\section{翻译结果可干预性} \section{翻译结果可干预性}
\parinterval 交互式机器翻译体现了一种用户的行为“干预”机器翻译结果的思想。实际上，在机器翻译出现错误时，人们总是希望用一种直接有效的方式“改变”译文，到达改善翻译质量的目的。比如，如果机器翻译系统可以输出多个候选译文，用户可以在其中挑选最好的译文进行输出。也就是，人干预了译文候选的排序过程。另一个例子是使用{\small\bfnew{翻译记忆}}\index{翻译记忆}（Translation Memory\index{Translation Memory}）改善机器翻译系统的性能。翻译记忆记录了高质量的源语言-目标语言句对，有时也可以被看作是一种先验知识或“记忆”。因此，当进行机器翻译（包括统计机器翻译和神经机器翻译）时，使用翻译记忆指导翻译过程也可以被看作是一种干预手段\upcite{DBLP:conf/acl/WangZS13,DBLP:conf/aaai/XiaHLS19}。 \parinterval 交互式机器翻译体现了一种用户的行为“干预”机器翻译结果的思想。实际上，在机器翻译出现错误时，人们总是希望用一种直接有效的方式“改变”译文，最短时间内达到改善翻译质量的目的。比如，如果机器翻译系统可以输出多个候选译文，用户可以在其中挑选最好的译文进行输出。也就是，人干预了译文候选的排序过程。另一个例子是使用{\small\bfnew{翻译记忆}}\index{翻译记忆}（Translation Memory\index{Translation Memory}）改善机器翻译系统的性能。翻译记忆记录了高质量的源语言-目标语言句对，有时也可以被看作是一种先验知识或“记忆”。因此，当进行机器翻译时，使用翻译记忆指导翻译过程也可以被看作是一种干预手段\upcite{DBLP:conf/acl/WangZS13,DBLP:conf/aaai/XiaHLS19}。
\parinterval 虽然干预机器翻译系统的方式很多，最常用的还是对源语言特定片段翻译的干预，以期望最终句子的译文中满足某些对片段翻译的约束。这个问题也被称作{\small\bfnew{基于约束的翻译}}\index{基于约束的翻译} （Constraint-based Translation\index{Constraint-based Translation}）。比如，在翻译网页时，需要保持译文中的网页标签与源文一致。另一个典型例子是术语翻译。在实际应用中，经常会遇到公司名称、品牌名称、产品名称等专有名词和行业术语，以及不同含义的缩写，比如，对于“小牛翻译”这个专有术语，不同的机器翻译系统给出的结果不一样:“Maverick translation”、“Calf translation”、“The mavericks translation”…… 而它正确的翻译应该为“NiuTrans”。 对于这些类似的特殊词汇，大多数机器翻译引擎很难翻译得准确。一方面，因为模型大多是在通用数据集上训练出来的，并不能保证数据集能涵盖所有的语言现象。另一方面，即使是这些术语在训练数据中出现，它们通常也是低频的，模型比较难学到。为了保证翻译的准确性，对术语翻译进行干预是十分有必要的，这对领域适应等问题的求解也是非常有意义的。 \parinterval 虽然干预机器翻译系统的方式很多，最常用的还是对源语言特定片段翻译的干预，以期望最终句子的译文满足某些约束。这个问题也被称作{\small\bfnew{基于约束的翻译}}\index{基于约束的翻译} （Constraint-based Translation\index{Constraint-based Translation}）。比如，在翻译网页时，需要保持译文中的网页标签与源文一致。另一个典型例子是术语翻译。在实际应用中，经常会遇到公司名称、品牌名称、产品名称等专有名词和行业术语，以及不同含义的缩写，比如，对于“小牛翻译”这个专有名词，不同的机器翻译系统给出的结果不一样:“Maverick translation”、“Calf translation”、“The mavericks translation”…… 而它正确的翻译应该为“NiuTrans”。 对于这些类似的特殊词汇，大多数机器翻译引擎很难翻译得准确。一方面，因为模型大多是在通用数据集上训练出来的，并不能保证数据集能涵盖所有的语言现象。另一方面，即使是这些术语在训练数据中出现，它们通常也是低频的，模型不容易捕捉它们的规律。为了保证翻译的准确性，对术语翻译进行干预是十分有必要的，这对领域适应等问题的求解也是非常有意义的。
\parinterval 就{\small\bfnew 术语翻译}\index{术语翻译}（Lexically Constrained Translation）\index{Lexically Constrained Translation}而言，在不干预的情况下让模型直接翻译出正确术语是很难的，因为目标术语翻译词很可能是未登录词，因此必须人为提供额外的术语词典，那么我们的目标就是让模型的翻译输出遵守用户提供的术语约束。这个过程如图\ref{fig:18-3}所示。 \parinterval 就{\small\bfnew 词汇约束翻译}\index{词汇约束翻译}（Lexically Constrained Translation）\index{Lexically Constrained Translation}而言，在不干预的情况下让模型直接翻译出正确术语是很难的，因为目标术语翻译词很可能是未登录词，因此必须人为提供额外的术语词典，那么我们的目标就是让模型的翻译输出遵守用户提供的术语约束。这个过程如图\ref{fig:18-3}所示。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
...@@ -156,11 +161,11 @@ ...@@ -156,11 +161,11 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 在统计机器翻译中，翻译本质上是由短语和规则构成的推导，因此修改译文比较容易，比如，可以在一个源语言片段所对应的翻译候选集中添加希望得到的译文即可。而神经机器翻译是一个端到端模型，内部基于连续空间的实数向量表示，翻译过程本质上是连续空间中元素的一系列映射、组合和代数运算，因此无法像修改符号系统那样直接修改模型并加入离散化的约束来影响译文生成。目前主要有两种解决思路： \parinterval 在统计机器翻译中，翻译本质上是由短语和规则构成的推导，因此修改译文比较容易，比如，可以在一个源语言片段所对应的翻译候选集中添加希望得到的译文即可。而神经机器翻译是一个端到端模型，翻译过程本质上是连续空间中元素的一系列映射、组合和代数运算，因此无法像修改符号系统那样直接修改模型并加入离散化的约束来影响译文生成。目前主要有两种解决思路：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 强制生成。这种方法并不改变模型，而是在解码过程中按照一定的策略来实施约束，一般是修改束搜索算法以确保输出必须包含指定的词或者短语\upcite{DBLP:conf/acl/HokampL17,DBLP:conf/naacl/PostV18,DBLP:conf/wmt/ChatterjeeNTFSB17,DBLP:conf/naacl/HaslerGIB18}，例如，在获得译文输出后，利用注意力机制获取词对齐，之后通过词对齐对指定部分译文进行强制替换。或者，对包含正确术语翻译的翻译候选进行额外的加分，以确保解码时这样的翻译候选的排名足够靠前。 \item 强制生成。这种方法并不改变模型，而是在解码过程中按照一定的策略来实施约束，一般是修改束搜索算法以确保输出必须包含指定的词或者短语\upcite{DBLP:conf/acl/HokampL17,DBLP:conf/naacl/PostV18,DBLP:conf/wmt/ChatterjeeNTFSB17,DBLP:conf/naacl/HaslerGIB18}，例如，在获得译文输出后，利用注意力机制获取词对齐，之后通过词对齐得到源语言和目标语言片段的对应关系，最后对指定译文片段进行强制替换。或者，对包含正确术语翻译的翻译候选进行额外的加分，以确保解码时这样的翻译候选的排名足够靠前。
\vspace{0.5em} \vspace{0.5em}
\item 数据增强。这类方法通过修改机器翻译模型的数据和训练过程来实现约束。通常是根据术语词典对源语言句子进行一定的修改，例如，将术语的译文编辑到源语言句子中，之后将原始语料库和合成语料库进行混合训练，期望模型能够自动利用术语信息来指导解码，或者是利用占位符来替换源语中的术语，待翻译完成后再进行还原\upcite{DBLP:conf/naacl/SongZYLWZ19,DBLP:conf/acl/DinuMFA19,DBLP:journals/corr/abs-1912-00567,DBLP:conf/ijcai/ChenCWL20}。 \item 数据增强。这类方法通过修改机器翻译模型的数据和训练过程来实现约束。通常是根据术语词典对源语言句子进行一定的修改，例如，将术语的译文编辑到源语言句子中，之后将原始语料库和合成语料库进行混合训练，期望模型能够自动利用术语信息来指导解码，或者是利用占位符来替换源语中的术语，待翻译完成后再进行还原\upcite{DBLP:conf/naacl/SongZYLWZ19,DBLP:conf/acl/DinuMFA19,DBLP:journals/corr/abs-1912-00567,DBLP:conf/ijcai/ChenCWL20}。
...@@ -168,7 +173,7 @@ ...@@ -168,7 +173,7 @@
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 强制生成的方法是在搜索策略上进行限制，与模型无关，这类方法能保证输出满足约束，但是会影响翻译速度。数据增强的方法是通过构造特定格式的数据让模型训练，从而让模型具有一定的泛化能力，这类方法需要进行译前译后编辑，通常不会影响翻译速度，但并不能保证输出能满足约束。 \parinterval 强制生成的方法是在搜索策略上进行限制，与模型无关，这类方法能保证输出满足约束，但是会影响翻译速度。数据增强的方法是通过构造特定格式的数据让模型训练，从而让模型具有一定的泛化能力，通常不会影响翻译速度，但并不能保证输出能满足约束。
\parinterval 此外，机器翻译在应用时通常还需要进行译前译后的处理，译前处理指的是在翻译前对源语言句子进行修改和规范，从而能生成比较顺畅的译文，提高译文的可读性和准确率。在实际应用时，由于用户输入的形式多样，可能会包含比如术语、缩写、数学公式等，有些甚至可能还包含网页标签，因此对源文进行预处理是很有必要的。常见的处理工作包括格式转换、标点符号检査、术语编辑、标签识别等，待翻译完成后，则需要对机器译文进行进一步的编辑和修正，从而使其符合使用规范，比如进行标点、格式检查，术语、标签还原等，这些过程通常都是按照设定的处理策略自动完成的。另外,译文长度的控制、译文多样性的控制等也可以丰富机器翻译系统干预的手段（见{\chapterfourteen}）。 \parinterval 此外，机器翻译在应用时通常还需要进行译前译后的处理，译前处理指的是在翻译前对源语言句子进行修改和规范，从而能生成比较顺畅的译文，提高译文的可读性和准确率。在实际应用时，由于用户输入的形式多样，可能会包含比如术语、缩写、数学公式等，有些甚至可能还包含网页标签，因此对源文进行预处理是很有必要的。常见的处理工作包括格式转换、标点符号检査、术语编辑、标签识别等，待翻译完成后，则需要对机器译文进行进一步的编辑和修正，从而使其符合使用规范，比如进行标点、格式检查，术语、标签还原等，这些过程通常都是按照设定的处理策略自动完成的。另外,译文长度的控制、译文多样性的控制等也可以丰富机器翻译系统干预的手段（见{\chapterfourteen}）。
...@@ -178,13 +183,13 @@ ...@@ -178,13 +183,13 @@
\section{小设备机器翻译} \section{小设备机器翻译}
\parinterval 在机器翻译研究中，一般会假设计算资源是充足的。但是，在很多应用场景中，机器翻译使用的计算资源非常有限，比如，一些离线设备上没有GPU处理器，而且CPU的处理能力也很弱，甚至内存也非常有限。这时，让模型变得更小、系统变得更快就成为了一个重要的需求。 \parinterval 在机器翻译研究中，一般会假设计算资源是充足的。但是，在很多应用场景中，机器翻译使用的计算资源非常有限，比如，一些离线设备上没有GPU处理器，而且CPU的处理能力也很弱，甚至内存也非常有限。这时，让模型变得更小、系统变得更快就成为了重要的需求。
\parinterval 本书中已经讨论了大量的可用于小设备上的机器翻译技术方法，例如： \parinterval 本书中已经讨论了大量的可用于小设备上的机器翻译技术方法，例如：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 知识蒸馏（{\chapterthirteen}）。这种方法可以有效地把翻译能力从大模型迁移到小模型。 \item 知识蒸馏（{\chapterthirteen}）。这种方法可以有效地将翻译能力从大模型迁移到小模型。
\vspace{0.5em} \vspace{0.5em}
\item 低精度存储及计算（{\chapterfourteen}）。可以使用量化的方式将模型压缩，同时整数型计算也非常适合在CPU等设备上执行。 \item 低精度存储及计算（{\chapterfourteen}）。可以使用量化的方式将模型压缩，同时整数型计算也非常适合在CPU等设备上执行。
...@@ -243,14 +248,15 @@ ...@@ -243,14 +248,15 @@
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 除了上述问题，如何对多设备环境下进行负载均衡、容灾处理等都是大规模机器翻译系统部署中需要考虑的。有时候，甚至统计机器翻译系统也可以与神经机器翻译系统混合使用。由于统计机器翻译系统对GPU设备的要求较低，纯CPU部署的方案也相对成熟。因此，可以作为GPU机器翻译服务的灾备。此外，在有些任务，特别是低资源翻译任务上，统计机器翻译仍然具有优势。 \parinterval 除了上述问题，如何对多设备环境下进行负载均衡、容灾处理等都是大规模机器翻译系统部署中需要考虑的。有时候，甚至统计机器翻译系统也可以与神经机器翻译系统混合使用。由于统计机器翻译系统对GPU资源的要求较低，纯CPU部署的方案也相对成熟。因此，可以作为GPU机器翻译服务的灾备。此外，在有些任务，特别是某些低资源翻译任务上，统计机器翻译仍然具有优势。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\section{机器翻译的应用场景} \section{机器翻译的应用场景}
\parinterval 机器翻译有着十分广泛的应用，下面看一下机器翻译在生活中的具体应用形式：
\parinterval 机器翻译有着十分广泛的应用，这里列举了一些常见的应用场景：
\parinterval （一）网页翻译 \parinterval （一）网页翻译
...@@ -272,23 +278,19 @@ ...@@ -272,23 +278,19 @@
\parinterval 在一些国际会议中，与会者来自许多不同的国家，为了保证会议的流畅，通常需要专业译员进行同声传译。同声传译需要在不打断演讲的同时，不间断地将讲话内容进行口译，对翻译人员的素质要求极高，成本高昂。现在，一些会议开始采用语音识别来将语音转换成文本，同时使用机器翻译技术进行翻译的方式，达到同步翻译的目的。这项技术已经得到了多个企业的关注，并在很多重要会议上进行尝试，取得了很好的反响。不过同声传译达到真正的使用还需一定时间的打磨，特别是会议场景下，准确进行语音识别和翻译仍然具有挑战性。 \parinterval 在一些国际会议中，与会者来自许多不同的国家，为了保证会议的流畅，通常需要专业译员进行同声传译。同声传译需要在不打断演讲的同时，不间断地将讲话内容进行口译，对翻译人员的素质要求极高，成本高昂。现在，一些会议开始采用语音识别来将语音转换成文本，同时使用机器翻译技术进行翻译的方式，达到同步翻译的目的。这项技术已经得到了多个企业的关注，并在很多重要会议上进行尝试，取得了很好的反响。不过同声传译达到真正的使用还需一定时间的打磨，特别是会议场景下，准确进行语音识别和翻译仍然具有挑战性。
\parinterval （六）医药领域翻译 \parinterval （六）中国传统语言文化的翻译
\parinterval 在医药领域中，从药品研发、临床试验到药品注册，都有着大量的翻译需求。比如，在新药注册阶段，限定申报时间的同时，更是对翻译质量有着极高的要求。由于医药领域专业词汇量庞大、单词冗长复杂、术语准确且文体专业性强，翻译难度明显高于其他领域，人工翻译的方式代价大且很难满足效率的要求。为此，机器翻译近几年在医药领域取得广泛应用。在针对医药领域进行优化后，机器翻译质量可以很好地满足翻译的要求。
\parinterval （七）中国传统语言文化的翻译
\parinterval 中国几千年的历史留下了极为宝贵的文化遗产，而其中，文言文作为古代书面语，具有言文分离、行文简练的特点，易于流传。言文分离的特点使得文言文和现在的标准汉语具有一定的区别。为了更好发扬中国传统文化，我们需要对文言文进行翻译。而文言文古奥难懂，人们需要具备一定的文言文知识背景才能准确翻译。机器翻译技术也可以帮助人们快速完成文言文的翻译。除此之外，机器翻译技术同样可以用于古诗生成和对联生成等任务。 \parinterval 中国几千年的历史留下了极为宝贵的文化遗产，而其中，文言文作为古代书面语，具有言文分离、行文简练的特点，易于流传。言文分离的特点使得文言文和现在的标准汉语具有一定的区别。为了更好发扬中国传统文化，我们需要对文言文进行翻译。而文言文古奥难懂，人们需要具备一定的文言文知识背景才能准确翻译。机器翻译技术也可以帮助人们快速完成文言文的翻译。除此之外，机器翻译技术同样可以用于古诗生成和对联生成等任务。
\parinterval （八）全球化 \parinterval （七）全球化
\parinterval 在经济全球化的今天，很多企业都有国际化的需求，企业员工或多或少地会遇到一些跨语言阅读和交流的情况，比如阅读进口产品的说明书，跨国公司之间的邮件、说明文件等等。相比于成本较高的人工翻译，机器翻译往往是一种很好的选择。在一些质量要求不高的翻译场景中，机器翻译可以得到应用。 \parinterval 在经济全球化的今天，很多企业都有国际化的需求，企业员工或多或少地会遇到一些跨语言阅读和交流的情况，比如阅读进口产品的说明书，跨国公司之间的邮件、说明文件等等。相比于成本较高的人工翻译，机器翻译往往是一种很好的选择。在一些质量要求不高的翻译场景中，机器翻译可以得到应用。
\parinterval （九）翻译机 \parinterval （八）翻译机/翻译笔
\parinterval 出于商务、学术交流或者旅游的目的，人们在出国时会面临着跨语言交流的问题。近几年，随着出境人数的增加，不少企业推出了翻译机产品。通过结合机器翻译、语音识别和图像识别技术，翻译机实现了图像翻译和语音翻译的功能。用户可以很便捷地获取一些外语图像文字和语音信息，同时可以通过翻译机进行对话，降低跨语言交流门槛。 \parinterval 出于商务、学术交流或者旅游的目的，人们在出国时会面临着跨语言交流的问题。近几年，随着出境人数的增加，不少企业推出了翻译机产品。通过结合机器翻译、语音识别和图像识别技术，翻译机实现了图像翻译和语音翻译的功能。用户可以很便捷地获取一些外语图像文字和语音信息，同时可以通过翻译机进行对话，降低跨语言交流门槛。类似的，翻译笔等应用产品可以通过划词翻译的方式，对打印材料中的外语文字进行翻译。
\parinterval （十）翻译结果后编辑 \parinterval （九）翻译结果后编辑
\parinterval 翻译结果后编辑是指在机器翻译的结果之上，通过少量的人工编辑来进一步完善机器译文。在传统的人工翻译过程中，翻译人员完全依靠人工的方式进行翻译，这虽然保证了翻译质量，但是时间成本高。相对应的，机器翻译具有速度快和成本低的优势。在一些领域，目前的机器翻译质量已经可以很大程度上减小翻译人员的工作量，翻译人员可以在机器翻译的辅助下，花费相对较小的代价来完成翻译。 \parinterval 翻译结果后编辑是指在机器翻译的结果之上，通过少量的人工编辑来进一步完善机器译文。在传统的人工翻译过程中，翻译人员完全依靠人工的方式进行翻译，这虽然保证了翻译质量，但是时间成本高。相对应的，机器翻译具有速度快和成本低的优势。在一些领域，目前的机器翻译质量已经可以很大程度上减小翻译人员的工作量，翻译人员可以在机器翻译的辅助下，花费相对较小的代价来完成翻译。
......
Chapter7/Figures/figure-basic-process-of-translation.tex
...@@ -11,7 +11,7 @@ ...@@ -11,7 +11,7 @@
\node[anchor=east] (t0) at (-0.5em, -1.5) {$\seq{t}$：}; \node[anchor=east] (t0) at (-0.5em, -1.5) {$\seq{t}$：};
\node[anchor=north] (l) at ([xshift=7em,yshift=-0.5em]t0.south) {\small{(a)\ }}; \node[anchor=north] (l) at ([xshift=7em,yshift=-0.5em]t0.south) {\small{(a)\ 初始化状态}};
\end{scope} \end{scope}
...@@ -29,7 +29,7 @@ ...@@ -29,7 +29,7 @@
\path[<->, thick] (s2.south) edge (t1.north); \path[<->, thick] (s2.south) edge (t1.north);
} }
\node[anchor=north] (l) at ([xshift=7em,yshift=-0.5em]t0.south) {\small{(b)\ }}; \node[anchor=north] (l) at ([xshift=7em,yshift=-0.5em]t0.south) {\small{(b)\ 找到译文第一个词 }};
\end{scope} \end{scope}
...@@ -50,7 +50,7 @@ ...@@ -50,7 +50,7 @@
\node[anchor=west,fill=red!20] (t2) at ([xshift=1em]t1.east) {\footnotesize{an apple}}; \node[anchor=west,fill=red!20] (t2) at ([xshift=1em]t1.east) {\footnotesize{an apple}};
\path[<->, thick] (s3.south) edge (t2.north); \path[<->, thick] (s3.south) edge (t2.north);
} }
\node[anchor=north] (l) at ([xshift=7em,yshift=-0.5em]t0.south) {\small{(c)\ }}; \node[anchor=north] (l) at ([xshift=7em,yshift=-0.5em]t0.south) {\small{(c)\ 找到译文第二个词}};
\end{scope} \end{scope}
...@@ -76,6 +76,6 @@ ...@@ -76,6 +76,6 @@
\node[anchor=west,fill=red!20] (t3) at ([xshift=1em]t2.east) {\footnotesize{on the table}}; \node[anchor=west,fill=red!20] (t3) at ([xshift=1em]t2.east) {\footnotesize{on the table}};
\path[<->, thick] (s1.south) edge (t3.north); \path[<->, thick] (s1.south) edge (t3.north);
} }
\node[anchor=north] (l) at ([xshift=7em,yshift=-0.5em]t0.south) {\small{(d)\ }}; \node[anchor=north] (l) at ([xshift=7em,yshift=-0.5em]t0.south) {\small{(d)\ 找到译文第三个词}};
\end{scope} \end{scope}
\end{tikzpicture} \end{tikzpicture}
\ No newline at end of file
Chapter7/Figures/figure-word-and-phrase-translation-regard-as-path.tex
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
\node [anchor=west] (s1) at (0,0) {\textbf{我}}; \node [anchor=west] (s1) at (0,0) {\textbf{我}};
\node [anchor=west] (s2) at ([xshift=2em]s1.east) {\textbf{对}}; \node [anchor=west] (s2) at ([xshift=2em]s1.east) {\textbf{对}};
\node [anchor=west] (s3) at ([xshift=2em]s2.east) {\textbf{你}}; \node [anchor=west] (s3) at ([xshift=2em]s2.east) {\textbf{你}};
\node [anchor=west] (s4) at ([xshift=2em]s3.east) {\textbf{表示}}; \node [anchor=west] (s4) at ([xshift=2em]s3.east) {\textbf{感到}};
\node [anchor=west] (s5) at ([xshift=2em]s4.east) {\textbf{满意}}; \node [anchor=west] (s5) at ([xshift=2em]s4.east) {\textbf{满意}};
\node [anchor=south west] (sentlabel) at ([yshift=-0.5em]s1.north west) {\scriptsize{\textbf{待翻译句子（已经分词）：}}}; \node [anchor=south west] (sentlabel) at ([yshift=-0.5em]s1.north west) {\scriptsize{\textbf{待翻译句子（已经分词）：}}};
......
Chapter7/Figures/figure-word-translation-regard-as-path.tex
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
\node [anchor=west] (s1) at (0,0) {\textbf{我}}; \node [anchor=west] (s1) at (0,0) {\textbf{我}};
\node [anchor=west] (s2) at ([xshift=2em]s1.east) {\textbf{对}}; \node [anchor=west] (s2) at ([xshift=2em]s1.east) {\textbf{对}};
\node [anchor=west] (s3) at ([xshift=2em]s2.east) {\textbf{你}}; \node [anchor=west] (s3) at ([xshift=2em]s2.east) {\textbf{你}};
\node [anchor=west] (s4) at ([xshift=2em]s3.east) {\textbf{表示}}; \node [anchor=west] (s4) at ([xshift=2em]s3.east) {\textbf{感到}};
\node [anchor=west] (s5) at ([xshift=2em]s4.east) {\textbf{满意}}; \node [anchor=west] (s5) at ([xshift=2em]s4.east) {\textbf{满意}};
\node [anchor=south west] (sentlabel) at ([yshift=-0.5em]s1.north west) {\scriptsize{\textbf{待翻译句子（已经分词）：}}}; \node [anchor=south west] (sentlabel) at ([yshift=-0.5em]s1.north west) {\scriptsize{\textbf{待翻译句子（已经分词）：}}};
......
Chapter7/chapter7.tex
...@@ -23,7 +23,7 @@ ...@@ -23,7 +23,7 @@
\chapter{基于短语的模型} \chapter{基于短语的模型}
\parinterval 机器翻译的一个基本问题是要定义翻译的基本单元是什么。比如，可以像{\chapterfive}介绍的那样，以单词为单位进行翻译，即把句子的翻译看作是单词之间对应关系的一种组合。基于单词的模型是符合人类对翻译问题的认知的，因为单词本身就是人类加工语言的一种基本单元。另一方面，在进行翻译时也可以使用一些更“复杂”的知识。比如，很多词语间的搭配需要根据语境的变化进行调整，而且对于句子结构的翻译往往需要更上层的知识，如句法知识。因此，在对单词翻译进行建模的基础上，需要探索其他类型的翻译知识，使得搭配和结构翻译等问题可以更好地被建模。 \parinterval 机器翻译的一个基本问题是要定义翻译的基本单元是什么。比如，可以像{\chapterfive}介绍的那样，以单词为单位进行翻译，即把句子的翻译看作是单词之间对应关系的一种组合。基于单词的模型是符合人类对翻译问题的认知的，因为单词本身就是人类加工语言的一种基本单元。然而，在进行翻译时也可以使用一些更“复杂”的知识。比如，很多词语间的搭配需要根据语境的变化进行调整，而且对于句子结构的翻译往往需要更上层的知识，如句法知识。因此，在对单词翻译进行建模的基础上，需要探索其他类型的翻译知识，使得搭配和结构翻译等问题可以更好地被建模。
\parinterval 本章会介绍基于短语的机器翻译模型。在过去二十年中，它一直是机器翻译的主流方法。相比于基于单词的模型，基于短语的模型可以更好地对单词之间搭配和小范围依赖关系进行描述。这种方法也在相当长的一段时期内占据着机器翻译的统治地位。即使近些年神经机器翻译逐渐崛起，基于短语的模型仍然是机器翻译的主要框架之一，其中的思想和很多技术手段对今天的机器翻译研究仍然有很好的借鉴意义。 \parinterval 本章会介绍基于短语的机器翻译模型。在过去二十年中，它一直是机器翻译的主流方法。相比于基于单词的模型，基于短语的模型可以更好地对单词之间搭配和小范围依赖关系进行描述。这种方法也在相当长的一段时期内占据着机器翻译的统治地位。即使近些年神经机器翻译逐渐崛起，基于短语的模型仍然是机器翻译的主要框架之一，其中的思想和很多技术手段对今天的机器翻译研究仍然有很好的借鉴意义。
...@@ -159,12 +159,12 @@ ...@@ -159,12 +159,12 @@
\end{definition} \end{definition}
%------------------------------------------- %-------------------------------------------
\parinterval 比如，对于一个句子，“机器/翻译/是/一/项/很有/挑战/的/问题”，一种可能的短语切分为： \parinterval 比如，对于一个句子，“机器/翻译/是/一/项/很有/挑战/的/任务”，一种可能的短语切分为：
\begin{eqnarray} \begin{eqnarray}
p_1 &=& \text{机器}/\text{翻译} \nonumber \\ p_1 &=& \text{机器}/\text{翻译} \nonumber \\
p_2 &=& \text{是}/\text{一}/\text{项} \nonumber \\ p_2 &=& \text{是}/\text{一}/\text{项} \nonumber \\
p_3 &=& \text{很有}/\text{挑战}/\text{的} \nonumber \\ p_3 &=& \text{很有}/\text{挑战}/\text{的} \nonumber \\
p_4 &=& \text{问题}\nonumber p_4 &=& \text{任务}\nonumber
\end{eqnarray} \end{eqnarray}
\parinterval 进一步，把单语短语的概念推广到双语的情况： \parinterval 进一步，把单语短语的概念推广到双语的情况：
...@@ -174,16 +174,17 @@ p_4 &=& \text{问题}\nonumber ...@@ -174,16 +174,17 @@ p_4 &=& \text{问题}\nonumber
\begin{definition} 双语短语（或短语对） \begin{definition} 双语短语（或短语对）
{\small {\small
对于源语言和目标语言句对$(\seq{s},\seq{t})$，$\seq{s}$中的一个短语$\bar{s}_i$和$\seq{t}$中的一个短语$\bar{t}_j$可以构成一个双语短语对$(\bar{s}_i,\bar{t}_j)$，简称{\small\bfnew{短语对}}\index{短语对}$(\bar{s}_i,\bar{t}_j)$。 对于源语言和目标语言句对$(\seq{s},\seq{t})$，$\seq{s}$中的一个短语$\bar{s}_i$和$\seq{t}$中的一个短语$\bar{t}_j$可以构成一个双语短语对$(\bar{s}_i,\bar{t}_j)$，简称{\small\bfnew{短语对}}（Phrase Pairs）\index{短语对}\index{Phrase Pairs}$(\bar{s}_i,\bar{t}_j)$。
} }
\end{definition} \end{definition}
%------------------------------------------- %-------------------------------------------
\parinterval 也就是说，源语言句子中任意的短语和目标语言句子中任意的短语都构成一个双语短语。这里用$\leftrightarrow$表示互译关系。对于一个双语句对“进口/大幅度/下降/了 $\leftrightarrow$ the imports have drastically fallen”，可以得到很多双语短语，比如： \parinterval 也就是说，源语言句子中任意的短语和目标语言句子中任意的短语都构成一个双语短语。这里用$\leftrightarrow$表示互译关系。对于一个双语句对“牛肉的/进口/大幅度/下降/了 $\leftrightarrow$ the import of beef has drastically fallen”，可以得到很多双语短语，比如：
\begin{eqnarray} \begin{eqnarray}
&&\text{大幅度}\ \leftrightarrow\ \textrm{drastically} \nonumber \\ &&\text{大幅度}\ \leftrightarrow\ \textrm{drastically} \nonumber \\
&&\text{大幅度}/\text{下降}\ \leftrightarrow\ \textrm{have}\ \textrm{drastically}\ \textrm{fallen} \nonumber \\ &&\text{大幅度}/\text{下降}\ \leftrightarrow\ \textrm{has}\ \textrm{drastically}\ \textrm{fallen} \nonumber \\
&&\text{进口}/\text{大幅度}\ \leftrightarrow\ \textrm{imports}\ \textrm{have}\ \textrm{drastically} \nonumber \\ &&\text{牛肉的}/\text{进口}\ \leftrightarrow\ \textrm{import}\ \textrm{of}\ \textrm{beef} \nonumber \\
&&\text{进口}/\text{大幅度}\ \leftrightarrow\ \textrm{import}\ \textrm{has}\ \textrm{drastically} \nonumber \\
&&\text{大幅度}/\text{下降}/\text{了}\ \leftrightarrow\ \textrm{drastically}\ \textrm{fallen} \nonumber \\ &&\text{大幅度}/\text{下降}/\text{了}\ \leftrightarrow\ \textrm{drastically}\ \textrm{fallen} \nonumber \\
&&\text{了}\ \leftrightarrow\ \textrm{have}\ \textrm{drastically} \nonumber \\ &&\text{了}\ \leftrightarrow\ \textrm{have}\ \textrm{drastically} \nonumber \\
&&... \nonumber &&... \nonumber
...@@ -221,7 +222,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2) ...@@ -221,7 +222,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 到此为止，就得到了一个基于短语的翻译模型。对于每个双语句对$(\seq{s}, \seq{t})$，每个翻译推导$d$都对应了一个基于短语的翻译过程。而基于短语的机器翻译的目标就是对$d$进行描述。有四个基本问题： \parinterval 到此为止，就得到了一个基于短语的翻译模型。对于每个双语句对$(\seq{s}, \seq{t})$，每个翻译推导$d$都对应了一个基于短语的翻译过程。而基于短语的机器翻译的目标就是对$d$进行描述。为了实现基于短语的翻译模型，有四个基本问题需要解决：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
...@@ -268,7 +269,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2) ...@@ -268,7 +269,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\parinterval 公式\eqref{eq:7-3}中，$\funp{P}(d,\seq{t}|\seq{s})$表示翻译推导的概率。公式\eqref{eq:7-3}把翻译问题转化为翻译推导的生成问题。但是，由于翻译推导的数量十分巨大\footnote[3]{如果把推导看作是一种树结构，推导的数量与词串的长度成指数关系。}，公式\eqref{eq:7-3}的右端需要对所有可能的推导进行枚举并求和，这几乎是无法计算的。 \parinterval 公式\eqref{eq:7-3}中，$\funp{P}(d,\seq{t}|\seq{s})$表示翻译推导的概率。公式\eqref{eq:7-3}把翻译问题转化为翻译推导的生成问题。但是，由于翻译推导的数量十分巨大\footnote[3]{如果把推导看作是一种树结构，推导的数量与词串的长度成指数关系。}，公式\eqref{eq:7-3}的右端需要对所有可能的推导进行枚举并求和，这几乎是无法计算的。
\parinterval 对于这个问题，常用的解决办法是利用一个化简的模型来近似完整的模型。如果把翻译推导的全体看作一个空间$D$，可以从$D$中选取一部分样本参与计算，而不是对整个$D$进行计算。比如，可以用最好的$n$个翻译推导来代表整个空间$D$。令$D_{n\textrm{-best}}$表示最好的$n$个翻译推导所构成的空间，于是可以定义： \parinterval 对于这个问题，常用的一种解决办法是利用一个化简的模型来近似完整的模型。如果把翻译推导的全体看作一个空间$D$，可以从$D$中选取一部分样本参与计算，而不是对整个$D$进行计算。比如，可以用最好的$n$个翻译推导来代表整个空间$D$。令$D_{n\textrm{-best}}$表示最好的$n$个翻译推导所构成的空间，于是可以定义：
\begin{eqnarray} \begin{eqnarray}
\funp{P}(\seq{t}|\seq{s}) \approx \sum_{d \in D_{n\textrm{-best}}} \funp{P}(d,\seq{t}|\seq{s}) \funp{P}(\seq{t}|\seq{s}) \approx \sum_{d \in D_{n\textrm{-best}}} \funp{P}(d,\seq{t}|\seq{s})
\label{eq:7-4} \label{eq:7-4}
...@@ -341,7 +342,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2) ...@@ -341,7 +342,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\subsection{判别式模型中的特征} \subsection{判别式模型中的特征}
\parinterval 判别式模型最大的好处在于它可以更灵活地引入特征。某种意义上，每个特征都是在描述翻译的某方面属性。在各种统计分类模型中，也大量使用了“特征”这个概念（见{\chapterthree}）。比如，要判别一篇新闻是体育方面的还是文化方面的，可以设计一个分类器，用词作为特征。这个分类器就会根据有能力区分“体育”和“文化”两个类别的特征，最终决定这篇文章属于哪个类别。统计机器翻译也在做类似的事情。系统研发者可以通过设计翻译相关的特征，来区分不同翻译结果的好坏。翻译模型会综合这些特征对所有可能的译文进行打分和排序，并选择得分最高的译文输出。 \parinterval 判别式模型最大的好处在于它可以更灵活地引入特征。某种意义上，每个特征都是在描述翻译的某方面属性。在各种统计分类模型中，也大量使用了“特征”这个概念（见{\chapterthree}）。比如，要判别一篇新闻是体育方面的还是文化方面的，可以设计一个分类器，用词作为特征。这个分类器就会有能力区分“体育”和“文化”两个类别的特征，最终决定这篇文章属于哪个类别。统计机器翻译也在做类似的事情。系统研发者可以通过设计翻译相关的特征，来区分不同翻译结果的好坏。翻译模型会综合这些特征对所有可能的译文进行打分和排序，并选择得分最高的译文输出。
\parinterval 在判别式模型中，系统开发者可以设计任意的特征来描述翻译，特征的设计甚至都不需要统计上的解释，包括0-1特征、计数特征等。比如，可以设计特征来回答“you这个单词是否出现在译文中？”。如果答案为真，这个特征的值为1，否则为0。再比如，可以设计特征来回答“译文里有多少个单词？”。这个特征相当于一个统计目标语单词数的函数，它的值即为译文的长度。此外，还可以设计更加复杂的实数特征，甚至具有概率意义的特征。在随后的内容中还将看到，翻译的调序、译文流畅度等都会被建模为特征，而机器翻译系统会融合这些特征，综合得到最优的输出译文。 \parinterval 在判别式模型中，系统开发者可以设计任意的特征来描述翻译，特征的设计甚至都不需要统计上的解释，包括0-1特征、计数特征等。比如，可以设计特征来回答“you这个单词是否出现在译文中？”。如果答案为真，这个特征的值为1，否则为0。再比如，可以设计特征来回答“译文里有多少个单词？”。这个特征相当于一个统计目标语单词数的函数，它的值即为译文的长度。此外，还可以设计更加复杂的实数特征，甚至具有概率意义的特征。在随后的内容中还将看到，翻译的调序、译文流畅度等都会被建模为特征，而机器翻译系统会融合这些特征，综合得到最优的输出译文。
...@@ -365,7 +366,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2) ...@@ -365,7 +366,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
在基于短语的翻译模型中，通常包含三类特征：短语翻译特征、调序特征、语言模型相关的特征。这些特征都需要从训练数据中学习。 在基于短语的翻译模型中，通常包含三类特征：短语翻译特征、调序特征、语言模型相关的特征。这些特征都需要从训练数据中学习。
\parinterval 图\ref{fig:7-11}展示了一个基于短语的机器翻译模型的搭建流程。其中的训练数据包括双语平行语料和目标语言单语语料。首先，需要从双语平行数据中学习短语的翻译，并形成一个短语翻译表；然后，再从双语平行数据中学习调序模型；最后，从目标语单语数据中学习语言模型。短语翻译表、调序模型、语言模型都会作为特征被送入判别式模型，由解码器完成对新句子的翻译。而这些特征的权重可以在额外的开发集上进行调优。关于短语翻译、调序模型和特征权重的学习，会在本章的\ref{section-7.3}-\ref{section-7.6}节进行介绍。 \parinterval 图\ref{fig:7-11}展示了一个基于短语的机器翻译模型的搭建流程。其中的训练数据包括双语平行语料和目标语言单语语料。首先，需要从双语平行数据中学习短语的翻译，并形成一个短语翻译表；然后，再从双语平行数据中学习调序模型；最后，从目标语单语数据中学习语言模型。短语翻译表、调序模型、语言模型都会作为特征被送入判别式模型，由解码器完成对新句子的翻译。而这些特征的权重可以在额外的开发集上进行调优。关于短语抽取、调序模型和翻译特征的学习，会在本章的\ref{section-7.3}-\ref{section-7.6}节进行介绍。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -423,7 +424,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2) ...@@ -423,7 +424,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 如图\ref{fig:7-14}所示，左边的例子中的$t_1$和$t_2$严格地对应到$s_1$、$s_2$、$s_3$，所以短语是与词对齐相一致的；中间的例子中的$t_2$对应到短语$s_1$和$s_2$的外面，所以短语是与词对齐不一致的；类似的，右边的例子也是与词对齐相一致的短语。 \parinterval 如图\ref{fig:7-14}所示，左边的例子中的$t_1$和$t_2$严格地对应到$s_1$、$s_2$、$s_3$，所以短语是与词对齐相一致的；中间例子中的$t_2$对应到短语$s_1$和$s_2$的外面，所以短语是与词对齐不一致的；类似的，右边的例子中短语与词对齐也是相一致的。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -488,7 +489,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2) ...@@ -488,7 +489,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\parinterval 它表达的意思是短语$\bar{s}$和$\bar{t}$存在词汇级的对应关系，其中$a(j,i)=1$表示双语句对$(\seq{s},\seq{t})$中单词$s_j$和单词$t_i$对齐，$\sigma $表示词汇翻译概率用来度量两个单词之间翻译的可能性大小（见{\chapterfive}），作为两个词之间对应的强度。 \parinterval 它表达的意思是短语$\bar{s}$和$\bar{t}$存在词汇级的对应关系，其中$a(j,i)=1$表示双语句对$(\seq{s},\seq{t})$中单词$s_j$和单词$t_i$对齐，$\sigma $表示词汇翻译概率用来度量两个单词之间翻译的可能性大小（见{\chapterfive}），作为两个词之间对应的强度。
\parinterval 下面来看一个具体的例子，如图\ref{fig:7-17}所示。对于一个双语短语，将它们的词对齐关系代入到上面的公式就会得到短语的词汇翻译概率。对于词汇翻译概率，可以使用IBM 模型中的单词翻译表，也可以通过统计获得\upcite{koehn2002learning}。如果一个单词的词对齐为空，则用$N$表示它翻译为空的概率。和短语翻译概率一样，可以使用双向的词汇化翻译概率来评价双语短语的好坏。 \parinterval 下面来看一个具体的例子，如图\ref{fig:7-17}所示。对于一个双语短语，将它们的词对齐关系代入到公式\eqref{eq:7-14}就会得到短语的词汇翻译概率。对于词汇翻译概率，可以使用IBM 模型中的单词翻译表，也可以通过统计获得\upcite{koehn2002learning}。如果一个单词的词对齐为空，则用$N$表示它翻译为空的概率。和短语翻译概率一样，可以使用双向的词汇化翻译概率来评价双语短语的好坏。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -704,7 +705,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1 ...@@ -704,7 +705,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\parinterval 格搜索的问题在于，每个特征都要访问$V$个点，且不说$V$个点无法对连续的特征权重进行表示，里面也会存在大量的无用访问。也就是说，这$V$个点中绝大多数点根本“不可能”成为最优的权重。可以把这样的点称为无效取值点。 \parinterval 格搜索的问题在于，每个特征都要访问$V$个点，且不说$V$个点无法对连续的特征权重进行表示，里面也会存在大量的无用访问。也就是说，这$V$个点中绝大多数点根本“不可能”成为最优的权重。可以把这样的点称为无效取值点。
\parinterval 能否避开这些无效的权重取值点呢？再重新看一下优化的目标BLEU。实际上，当一个特征权重发生变化时，BLEU的变化只会出现在系统1-best译文发生变化的时候。那么，可以只关注使1-best译文发生变化的取值点，而其他的取值点都不会使优化的目标函数产生变化。这也就构成了线搜索的思想。 \parinterval 能否避开这些无效的权重取值点呢？再重新看一下优化的目标BLEU。实际上，当一个特征权重发生变化时，BLEU的变化只会出现在系统1-best译文发生变化的时候。那么，可以只关注使1-best译文发生变化的取值点，因为其他的取值点都不会使优化的目标函数产生变化。这也就构成了线搜索的思想。
\parinterval 假设对于每个输入的句子，翻译模型生成了两个推导$\seq{d} = \{d_1,d_2\}$，每个推导$d$的得分score($d$)可以表示成关于第$i$个特征的权重$\lambda_i$的线性函数： \parinterval 假设对于每个输入的句子，翻译模型生成了两个推导$\seq{d} = \{d_1,d_2\}$，每个推导$d$的得分score($d$)可以表示成关于第$i$个特征的权重$\lambda_i$的线性函数：
\begin{eqnarray} \begin{eqnarray}
...@@ -743,7 +744,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1 ...@@ -743,7 +744,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 最小错误率训练最大的优点在于可以用于目标函数不可微、甚至不连续的情况。对于优化线性模型， 最小错误率训练是一种很好的选择。但是，也有研究发现，简单使用最小错误率训练无法处理特征数量过多的情况。比如，用最小错误率训练优化10000个稀疏特征的权重时，优化效果可能会不理想，而且收敛速度慢。这时也可以考虑使用在线学习等技术对大量特征的权重进行调优，比较有代表性的方法包括MIRA\upcite{DBLP:conf/emnlp/ChiangMR08}和PRO\upcite{Hopkins2011Tuning}。由于篇幅所限，这里不对这些方法做深入讨论，感兴趣的读者可以参考\ref{section-7.8}节的内容，对相关文献进行查阅。 \parinterval 最小错误率训练最大的优点在于可以用于目标函数不可微、甚至不连续的情况。对于优化线性模型， 最小错误率训练是一种很好的选择。但是，也有研究发现，直接使用最小错误率训练无法处理特征数量过多的情况。比如，用最小错误率训练优化10000个稀疏特征的权重时，优化效果可能会不理想，而且收敛速度慢。这时也可以考虑使用在线学习等技术对大量特征的权重进行调优，比较有代表性的方法包括MIRA\upcite{DBLP:conf/emnlp/ChiangMR08}和PRO\upcite{Hopkins2011Tuning}。由于篇幅所限，这里不对这些方法做深入讨论，感兴趣的读者可以参考\ref{section-7.8}节的内容，对相关文献进行查阅。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
...@@ -779,7 +780,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1 ...@@ -779,7 +780,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 前者对应了一种{\small\bfnew{覆盖度模型}}\index{覆盖度模型}（Coverage Model）\index{Coverage Model}；后者定义了解码的方向，这样可以确保$n$-gram语言模型的计算是准确的。这样，就得到了一个简单的基于短语的机器翻译解码框架。每次从源语言句子中找到一个短语，作为译文最右侧的部分，重复执行直到整个译文被生成出来。 \parinterval 第一点对应了一种{\small\bfnew{覆盖度模型}}\index{覆盖度模型}（Coverage Model）\index{Coverage Model}；第二点定义了解码的方向，这样可以确保$n$-gram语言模型的计算是准确的。这样，就得到了一个简单的基于短语的机器翻译解码框架。每次从源语言句子中找到一个短语，作为译文最右侧的部分，重复执行直到整个译文被生成出来。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
...@@ -804,7 +805,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1 ...@@ -804,7 +805,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\subsection{翻译假设扩展} \subsection{翻译假设扩展}
\parinterval 下一步，需要使用这些翻译候选生成完整的译文。在机器翻译中，一个很重要的概念是{\small\bfnew{翻译假设}}\index{翻译假设}（Translation Hypothesis）\index{Translation Hypothesis}。 它可以被当作是一个局部译文所对应的短语翻译推导。在解码开始时，只有一个空假设，也就是任何译文单词都没有被生成出来。接着，可以挑选翻译选项来扩展当前的翻译假设。 \parinterval 接下来，需要使用这些翻译候选生成完整的译文。在机器翻译中，一个很重要的概念是{\small\bfnew{翻译假设}}\index{翻译假设}（Translation Hypothesis）\index{Translation Hypothesis}。 它可以被当作是一个局部译文所对应的短语翻译推导。在解码开始时，只有一个空假设，也就是任何译文单词都没有被生成出来。接着，可以挑选翻译选项来扩展当前的翻译假设。
\parinterval 图\ref{fig:7-28}展示了翻译假设扩展的过程。在翻译假设扩展时，需要保证新加入的翻译候选放置在旧翻译假设译文的右侧，也就是要确保翻译自左向右的连续性。而且，同一个翻译假设可以使用不同的翻译候选进行扩展。例如，扩展第一个翻译假设时，可以选择“桌子”的翻译候选“table”；也可以选择“有”的翻译候选“There is”。扩展完之后需要记录输入句子中已翻译的短语，同时计算当前所有翻译假设的模型得分。这个过程相当于生成了一个图的结构，每个节点代表了一个翻译假设。当翻译假设覆盖了输入句子所有的短语，不能被继续扩展时，就生成了一个完整的翻译假设（译文）。最后需要找到得分最高的完整翻译假设，它对应了搜索图中的最优路径。 \parinterval 图\ref{fig:7-28}展示了翻译假设扩展的过程。在翻译假设扩展时，需要保证新加入的翻译候选放置在旧翻译假设译文的右侧，也就是要确保翻译自左向右的连续性。而且，同一个翻译假设可以使用不同的翻译候选进行扩展。例如，扩展第一个翻译假设时，可以选择“桌子”的翻译候选“table”；也可以选择“有”的翻译候选“There is”。扩展完之后需要记录输入句子中已翻译的短语，同时计算当前所有翻译假设的模型得分。这个过程相当于生成了一个图的结构，每个节点代表了一个翻译假设。当翻译假设覆盖了输入句子所有的短语，不能被继续扩展时，就生成了一个完整的翻译假设（译文）。最后需要找到得分最高的完整翻译假设，它对应了搜索图中的最优路径。
...@@ -876,7 +877,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1 ...@@ -876,7 +877,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
所以最好的情况是尽早删除质量差的翻译假设，同时又不会对整个搜索结果产生过大影响。但是这个“质量”从哪个方面来衡量，也是一个需要思考的问题。理想的情况就是从早期的翻译假设中，挑选一些可比的翻译假设进行筛选。 所以最好的情况是尽早删除质量差的翻译假设，这样就不会对整个搜索结果产生过大影响。但是这个“质量”从哪个方面来衡量，也是一个需要思考的问题。理想的情况就是从早期的翻译假设中，挑选一些可比的翻译假设进行筛选。
\parinterval 目前比较通用的做法是将翻译假设进行整理，放进一种栈结构中。这里所说的“栈”是为了描述方便的一种说法。它实际上就是保存多个翻译假设的一种数据结构\footnote[4]{虽然被称作栈，实际上使用一个堆进行实现。这样可以根据模型得分对翻译假设进行排序。}。当放入栈的翻译假设超过一定阈值时（比如200），可以删除掉模型得分低的翻译假设。一般，会使用多个栈来保存翻译假设，每个栈代表覆盖源语言单词数量相同的翻译假设。 \parinterval 目前比较通用的做法是将翻译假设进行整理，放进一种栈结构中。这里所说的“栈”是为了描述方便的一种说法。它实际上就是保存多个翻译假设的一种数据结构\footnote[4]{虽然被称作栈，实际上使用一个堆进行实现。这样可以根据模型得分对翻译假设进行排序。}。当放入栈的翻译假设超过一定阈值时（比如200），可以删除掉模型得分低的翻译假设。一般，会使用多个栈来保存翻译假设，每个栈代表覆盖源语言单词数量相同的翻译假设。
...@@ -912,7 +913,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1 ...@@ -912,7 +913,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\vspace{0.5em} \vspace{0.5em}
\item 统计机器翻译中使用的栈解码方法源自Tillmann等人的工作\upcite{tillmann1997a}。这种方法在Pharaoh\upcite{DBLP:conf/amta/Koehn04}、Moses\upcite{Koehn2007Moses}等开源系统中被成功的应用，在机器翻译领域产生了很大的影响力。特别是，这种解码方法效率很高，因此在许多工业系统里也大量使用。对于栈解码也有很多改进工作，比如，早期的工作考虑剪枝或者限制调序范围以加快解码速度\upcite{DBLP:conf/acl/WangW97,DBLP:conf/coling/TillmannN00,DBLP:conf/iwslt/ShenDA06a,robert2007faster}。随后，也有研究工作从解码算法和语言模型集成方式的角度对这类方法进行改进\upcite{DBLP:conf/acl/HeafieldKM14,DBLP:conf/acl/WuebkerNZ12,DBLP:conf/iwslt/ZensN08}。 \item 统计机器翻译中使用的栈解码方法源自Tillmann等人的工作\upcite{tillmann1997a}。这种方法在Pharaoh\upcite{DBLP:conf/amta/Koehn04}、Moses\upcite{Koehn2007Moses}等开源系统中被成功的应用，在机器翻译领域产生了很大的影响力。特别是，这种解码方法效率很高，因此在许多工业系统里也大量使用。对于栈解码也有很多改进工作，比如，早期的工作考虑剪枝或者限制调序范围以加快解码速度\upcite{DBLP:conf/acl/WangW97,DBLP:conf/coling/TillmannN00,DBLP:conf/iwslt/ShenDA06a,robert2007faster}。随后，也有研究工作从解码算法和语言模型集成方式的角度对这类方法进行改进\upcite{DBLP:conf/acl/HeafieldKM14,DBLP:conf/acl/WuebkerNZ12,DBLP:conf/iwslt/ZensN08}。
\vspace{0.5em} \vspace{0.5em}
\item 统计机器翻译的成功很大程度上来自判别式模型引入任意特征的能力。因此，在统计机器翻译时代，很多工作都集中在新特征的设计上。比如，可以基于不同的统计特征和先验知识设计翻译特征\upcite{och2004smorgasbord,Chiang200911,gildea2003loosely}，也可以模仿分类任务设计大规模的稀疏特征\upcite{DBLP:conf/emnlp/ChiangMR08}。另一方面，模型训练和特征权重调优也是统计机器翻译中的重要问题，除了最小错误率训练，还有很多方法，比如，最大似然估计\upcite{koehn2003statistical,DBLP:journals/coling/BrownPPM94}、判别式方法\upcite{Blunsom2008A}、贝叶斯方法\upcite{Blunsom2009A,Cohn2009A}、最小风险训练\upcite{smith2006minimum,li2009first}、基于Margin的方法\upcite{watanabe2007online,Chiang200911}以及基于排序模型的方法（PRO）\upcite{Hopkins2011Tuning,dreyer2015apro}。实际上，统计机器翻译的训练和解码也存在不一致的问题，比如，特征值由双语数据上的极大似然估计得到（没有剪枝），而解码时却使用束剪枝，而且模型的目标是最大化机器翻译评价指标。对于这个问题也可以通过调整训练的目标函数进行缓解\upcite{XiaoA,marcu2006practical}。 \item 统计机器翻译的成功很大程度上来自判别式模型引入任意特征的能力。因此，在统计机器翻译时代，很多工作都集中在新特征的设计上。比如，可以基于不同的统计特征和先验知识设计翻译特征\upcite{och2004smorgasbord,Chiang200911,gildea2003loosely}，也可以模仿分类任务设计大规模的稀疏特征\upcite{DBLP:conf/emnlp/ChiangMR08}。模型训练和特征权重调优也是统计机器翻译中的重要问题，除了最小错误率训练，还有很多方法，比如，最大似然估计\upcite{koehn2003statistical,DBLP:journals/coling/BrownPPM94}、判别式方法\upcite{Blunsom2008A}、贝叶斯方法\upcite{Blunsom2009A,Cohn2009A}、最小风险训练\upcite{smith2006minimum,li2009first}、基于Margin的方法\upcite{watanabe2007online,Chiang200911}以及基于排序模型的方法（PRO）\upcite{Hopkins2011Tuning,dreyer2015apro}。实际上，统计机器翻译的训练和解码也存在不一致的问题，比如，特征值由双语数据上的极大似然估计得到（没有剪枝），而解码时却使用束剪枝，而且模型的目标是最大化机器翻译评价指标。对于这个问题也可以通过调整训练的目标函数进行缓解\upcite{XiaoA,marcu2006practical}。
\vspace{0.5em} \vspace{0.5em}
\item 短语表是基于短语的系统中的重要模块。但是，简单地利用基于频次的方法估计得到的翻译概率无法很好地处理低频短语。这时就需要对短语表进行平滑\upcite{DBLP:conf/iwslt/ZensN08,DBLP:conf/emnlp/SchwenkCF07,boxing2011unpacking,DBLP:conf/coling/DuanSZ10}。另一方面，随着数据量的增长和抽取短语长度的增大，短语表的体积会急剧膨胀，这也大大增加了系统的存储消耗，同时过大的短语表也会带来短语查询效率的下降。针对这个问题，很多工作尝试对短语表进行压缩。一种思路是限制短语的长度\upcite{DBLP:conf/naacl/QuirkM06,DBLP:journals/coling/MarinoBCGLFC06}；另一种广泛使用的思路是使用一些指标或者分类器来对短语进行剪枝，其核心思想是判断每个短语的质量\upcite{DBLP:conf/emnlp/ZensSX12}，并过滤掉低质量的短语。代表性的方法有：基于假设检验的剪枝\upcite{DBLP:conf/emnlp/JohnsonMFK07}、基于熵的剪枝\upcite{DBLP:conf/emnlp/LingGTB12}、两阶段短语抽取方法\upcite{DBLP:conf/naacl/ZettlemoyerM07}、基于解码中短语使用频率的方法\upcite{DBLP:conf/naacl/EckVW07}等。此外，短语表的存储方式也是在实际使用中需要考虑的问题。因此，也有研究者尝试使用更加紧凑、高效的结构保存短语表。其中最具代表性的结构是后缀数组（Suffix Arrays），这种结构可以充分利用短语之间有重叠的性质，减少了重复存储\upcite{DBLP:conf/acl/Callison-BurchBS05,DBLP:conf/acl/Callison-BurchBS05,DBLP:conf/naacl/ZensN07,2014Dynamic}。 \item 短语表是基于短语的系统中的重要模块。但是，简单地利用基于频次的方法估计得到的翻译概率无法很好地处理低频短语。这时就需要对短语表进行平滑\upcite{DBLP:conf/iwslt/ZensN08,DBLP:conf/emnlp/SchwenkCF07,boxing2011unpacking,DBLP:conf/coling/DuanSZ10}。另一方面，随着数据量的增长和抽取短语长度的增大，短语表的体积会急剧膨胀，这也大大增加了系统的存储消耗，同时过大的短语表也会带来短语查询效率的下降。针对这个问题，很多工作尝试对短语表进行压缩。一种思路是限制短语的长度\upcite{DBLP:conf/naacl/QuirkM06,DBLP:journals/coling/MarinoBCGLFC06}；另一种广泛使用的思路是使用一些指标或者分类器来对短语进行剪枝，其核心思想是判断每个短语的质量\upcite{DBLP:conf/emnlp/ZensSX12}，并过滤掉低质量的短语。代表性的方法有：基于假设检验的剪枝\upcite{DBLP:conf/emnlp/JohnsonMFK07}、基于熵的剪枝\upcite{DBLP:conf/emnlp/LingGTB12}、两阶段短语抽取方法\upcite{DBLP:conf/naacl/ZettlemoyerM07}、基于解码中短语使用频率的方法\upcite{DBLP:conf/naacl/EckVW07}等。此外，短语表的存储方式也是在实际使用中需要考虑的问题。因此，也有研究者尝试使用更加紧凑、高效的结构保存短语表。其中最具代表性的结构是后缀数组（Suffix Arrays），这种结构可以充分利用短语之间有重叠的性质，减少了重复存储\upcite{DBLP:conf/acl/Callison-BurchBS05,DBLP:conf/acl/Callison-BurchBS05,DBLP:conf/naacl/ZensN07,2014Dynamic}。
\vspace{0.5em} \vspace{0.5em}
......
Chapter8/Figures/figure-cky-algorithm.tex
...@@ -22,7 +22,7 @@ ...@@ -22,7 +22,7 @@
\node[srcnode,anchor=north west] (c8) at ([xshift=-4.5em,yshift=0.4em]c7.south west) {\normalsize{\textbf{return} $span[0, J]$}}; \node[srcnode,anchor=north west] (c8) at ([xshift=-4.5em,yshift=0.4em]c7.south west) {\normalsize{\textbf{return} $span[0, J]$}};
\node[anchor=west] (c9) at ([xshift=-3.2em,yshift=1.7em]c1.west) {\small{\textrm{参数：}\seq{s}为输入字符串。$G$为输入CFG。$J$为待分析字符串长度。}}; \node[anchor=west] (c9) at ([xshift=-3.2em,yshift=1.7em]c1.west) {\small{\textrm{参数：}\seq{s}为输入字符串。$G$为输入CFG。$J$为待分析字符串长度。}};
\node[anchor=west] (c10) at ([xshift=0em,yshift=1.3em]c9.west) {\small{\textrm{输出：字符串全部可能的语法分析结果}}}; \node[anchor=west] (c10) at ([xshift=0em,yshift=1.3em]c9.west) {\small{\textrm{输出：全部可能的字符串语法分析结果}}};
\node[anchor=west] (c11) at ([xshift=0em,yshift=1.3em]c10.west) {\small{\textrm{输入：符合乔姆斯基范式的待分析字符串和一个上下文无关文法（CFG）}}}; \node[anchor=west] (c11) at ([xshift=0em,yshift=1.3em]c10.west) {\small{\textrm{输入：符合乔姆斯基范式的待分析字符串和一个上下文无关文法（CFG）}}};
......
Chapter8/Figures/figure-execution-of-cube-pruning.tex
...@@ -40,7 +40,7 @@ ...@@ -40,7 +40,7 @@
\draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=-1.0em,yshift=-0.7em]alig4.south west); \draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=-1.0em,yshift=-0.7em]alig4.south west);
\draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=0.8em,yshift=1.0em]alig13.north east); \draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=0.8em,yshift=1.0em]alig13.north east);
\node[anchor=north] (l) at ([xshift=0em,yshift=-1.5em]alig4.south) {\small{(a)}}; \node[anchor=north] (l) at ([xshift=-2em,yshift=-1.5em]alig4.south) {\small{(a) \ 当前最好结果为2.1}};
\end{scope} \end{scope}
%图2 %图2
...@@ -87,7 +87,7 @@ ...@@ -87,7 +87,7 @@
\draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=-1.0em,yshift=-0.7em]alig4.south west); \draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=-1.0em,yshift=-0.7em]alig4.south west);
\draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=0.8em,yshift=1.0em]alig13.north east); \draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=0.8em,yshift=1.0em]alig13.north east);
\node[anchor=north] (l) at ([xshift=0em,yshift=-1.5em]alig4.south) {\small{(b)}}; \node[anchor=north] (l) at ([xshift=-2em,yshift=-1.5em]alig4.south) {\small{(b)\ 当前最好结果为5.5}};
\end{scope} \end{scope}
%图3 %图3
...@@ -137,7 +137,7 @@ ...@@ -137,7 +137,7 @@
\draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=-1.0em,yshift=-0.7em]alig4.south west); \draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=-1.0em,yshift=-0.7em]alig4.south west);
\draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=0.8em,yshift=1.0em]alig13.north east); \draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=0.8em,yshift=1.0em]alig13.north east);
\node[anchor=north] (l) at ([xshift=0em,yshift=-1.5em]alig4.south) {\small{(c)}}; \node[anchor=north] (l) at ([xshift=-2em,yshift=-1.5em]alig4.south) {\small{(c)\ 当前最好结果为8.5}};
\end{scope} \end{scope}
...@@ -194,7 +194,7 @@ ...@@ -194,7 +194,7 @@
\draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=-1.0em,yshift=-0.7em]alig4.south west); \draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=-1.0em,yshift=-0.7em]alig4.south west);
\draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=0.8em,yshift=1.0em]alig13.north east); \draw [->,thick] ([xshift=-1.0em,yshift=1.0em]alig1.north west)--([xshift=0.8em,yshift=1.0em]alig13.north east);
\node[anchor=north] (l) at ([xshift=0em,yshift=-1.5em]alig4.south) {\small{(d)}}; \node[anchor=north] (l) at ([xshift=-2em,yshift=-1.5em]alig4.south) {\small{(d)\ 当前最好结果为8.2}};
\end{scope} \end{scope}
......
Chapter8/Figures/figure-one-best-node-alignment-and-alignment-matrix.tex
...@@ -78,19 +78,19 @@ ...@@ -78,19 +78,19 @@
} }
} }
\node[fill=blue!40, scale=1.1, inner sep=1pt, minimum size=12pt] at (1,-1) {{\color{white} \small{.9}}}; \node[fill=blue!40, scale=1.1, inner sep=1pt, minimum size=12pt] at (1,-1) {{\color{white} \footnotesize{0.9}}};
\node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (1,-3) {{\color{white} \small{.1}}}; \node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (1,-3) {{\color{white} \footnotesize{0.1}}};
\node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (2,-2) {{\color{white} \small{.1}}}; \node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (2,-2) {{\color{white} \footnotesize{0.1}}};
\node[fill=blue!40, scale=0.8, inner sep=1pt, minimum size=12pt] at (2,-3) {{\color{white} \small{.6}}}; \node[fill=blue!40, scale=0.8, inner sep=1pt, minimum size=12pt] at (2,-3) {{\color{white} \footnotesize{0.6}}};
\node[fill=blue!40, scale=0.8, inner sep=1pt, minimum size=12pt] at (2,-5) {{\color{white} \small{.6}}}; \node[fill=blue!40, scale=0.8, inner sep=1pt, minimum size=12pt] at (2,-5) {{\color{white} \footnotesize{0.6}}};
\node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (3,-1) {{\color{white} \small{.1}}}; \node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (3,-1) {{\color{white} \footnotesize{0.1}}};
\node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (3,-2) {{\color{white} \small{.1}}}; \node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (3,-2) {{\color{white} \footnotesize{0.1}}};
\node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (3,-3) {{\color{white} \small{.1}}}; \node[fill=blue!40, scale=0.5, inner sep=1pt, minimum size=12pt] at (3,-3) {{\color{white} \footnotesize{0.1}}};
\node[fill=blue!40, scale=1.0, inner sep=1pt, minimum size=12pt] at (4,-2) {{\color{white} \small{.8}}}; \node[fill=blue!40, scale=1.0, inner sep=1pt, minimum size=12pt] at (4,-2) {{\color{white} \footnotesize{0.8}}};
\node[fill=blue!40, scale=0.6, inner sep=1pt, minimum size=12pt] at (5,-3) {{\color{white} \small{.2}}}; \node[fill=blue!40, scale=0.6, inner sep=1pt, minimum size=12pt] at (5,-3) {{\color{white} \footnotesize{0.2}}};
\node[fill=blue!40, scale=0.7, inner sep=1pt, minimum size=12pt] at (5,-5) {{\color{white} \small{.4}}}; \node[fill=blue!40, scale=0.7, inner sep=1pt, minimum size=12pt] at (5,-5) {{\color{white} \footnotesize{0.4}}};
\node[fill=blue!40, scale=0.65, inner sep=1pt, minimum size=12pt] at (3,-4) {{\color{white} \small{.3}}}; \node[fill=blue!40, scale=0.65, inner sep=1pt, minimum size=12pt] at (3,-4) {{\color{white} \footnotesize{0.3}}};
\node[fill=blue!40, scale=0.9, inner sep=1pt, minimum size=12pt] at (5,-4) {{\color{white} \small{.7}}}; \node[fill=blue!40, scale=0.9, inner sep=1pt, minimum size=12pt] at (5,-4) {{\color{white} \footnotesize{0.7}}};
\node[] at (4,-6.3) {{\color{blue!40} $\blacksquare$} = 概率化对齐}; \node[] at (4,-6.3) {{\color{blue!40} $\blacksquare$} = 概率化对齐};
\node[] at (4,-7.2) {Matrix 2: 对齐概率}; \node[] at (4,-7.2) {Matrix 2: 对齐概率};
......
Chapter8/Figures/figure-tree-cutting-defined-by-edge-nodes.tex
...@@ -27,21 +27,21 @@ ...@@ -27,21 +27,21 @@
\begin{pgfonlayer}{background} \begin{pgfonlayer}{background}
{ {
\node [rectangle,fill=blue!20,inner sep=0] [fit = (n11)] (n11box) {}; \node [rectangle,fill=red!20,inner sep=0] [fit = (n11)] (n11box) {};
\node [rectangle,fill=red!20,inner sep=0] [fit = (n4)] (n4box) {}; \node [rectangle,fill=blue!20,inner sep=0] [fit = (n4)] (n4box) {};
\node [rectangle,fill=red!20,inner sep=0] [fit = (n1)] (n1box) {}; \node [rectangle,fill=blue!20,inner sep=0] [fit = (n1)] (n1box) {};
\node [rectangle,fill=red!20,inner sep=0] [fit = (n2)] (n2box) {}; \node [rectangle,fill=blue!20,inner sep=0] [fit = (n2)] (n2box) {};
\node [rectangle,fill=red!20,inner sep=0] [fit = (n3)] (n3box) {}; \node [rectangle,fill=blue!20,inner sep=0] [fit = (n3)] (n3box) {};
\node [rectangle,fill=red!20,inner sep=0] [fit = (n5)] (n5box) {}; \node [rectangle,fill=blue!20,inner sep=0] [fit = (n5)] (n5box) {};
\node [rectangle,fill=red!20,inner sep=0] [fit = (n6)] (n6box) {}; \node [rectangle,fill=blue!20,inner sep=0] [fit = (n6)] (n6box) {};
\node [rectangle,fill=red!20,inner sep=0] [fit = (n7)] (n7box) {}; \node [rectangle,fill=blue!20,inner sep=0] [fit = (n7)] (n7box) {};
\node [rectangle,fill=red!20,inner sep=0] [fit = (n8)] (n8box) {}; \node [rectangle,fill=blue!20,inner sep=0] [fit = (n8)] (n8box) {};
\node [rectangle,fill=red!20,inner sep=0] [fit = (n9)] (n9box) {}; \node [rectangle,fill=blue!20,inner sep=0] [fit = (n9)] (n9box) {};
\node [rectangle,fill=blue!20,inner sep=0] [fit = (n10)] (n10box) {}; \node [rectangle,fill=red!20,inner sep=0] [fit = (n10)] (n10box) {};
\node [anchor=north west, minimum size=1.2em, fill=red!20] (land1) at ([xshift=7.0em,yshift=0em]n1.north east) {}; \node [anchor=north west, minimum size=1.2em, fill=blue!20] (land1) at ([xshift=7.0em,yshift=0em]n1.north east) {};
\node [anchor=west] (land1label) at (land1.east) {\scriptsize{可信}}; \node [anchor=west] (land1label) at (land1.east) {\scriptsize{可信}};
\node [anchor=north west, minimum size=1.2em, fill=blue!20] (land2) at ([yshift=-0.3em]land1.south west) {}; \node [anchor=north west, minimum size=1.2em, fill=red!20] (land2) at ([yshift=-0.3em]land1.south west) {};
\node [anchor=west] (land2label) at (land2.east) {\scriptsize{不可信}}; \node [anchor=west] (land2label) at (land2.east) {\scriptsize{不可信}};
} }
...@@ -54,6 +54,8 @@ ...@@ -54,6 +54,8 @@
\node[anchor=west,minimum size=18pt] (tw5) at ([xshift=0.3em]tw4.east){the}; \node[anchor=west,minimum size=18pt] (tw5) at ([xshift=0.3em]tw4.east){the};
\node[anchor=west,minimum size=18pt] (tw6) at ([yshift=-0.1em,xshift=0.3em]tw5.east){answer}; \node[anchor=west,minimum size=18pt] (tw6) at ([yshift=-0.1em,xshift=0.3em]tw5.east){answer};
\node[anchor=north](pos1) at ([xshift=-1.0em,yshift=-1.0em]tw4.south){\small{（a）标有可信节点信息的句法树}};
\draw[dashed] (cw1.south) -- ([yshift=-0.4em]tw1.north); \draw[dashed] (cw1.south) -- ([yshift=-0.4em]tw1.north);
\draw[dashed] (cw2.south) .. controls +(south:2.0) and +(north:0.6) .. ([yshift=-0.4em]tw4.north); \draw[dashed] (cw2.south) .. controls +(south:2.0) and +(north:0.6) .. ([yshift=-0.4em]tw4.north);
\draw[dashed] (cw3.south) -- ([yshift=-0.4em]tw5.north); \draw[dashed] (cw3.south) -- ([yshift=-0.4em]tw5.north);
...@@ -107,6 +109,8 @@ ...@@ -107,6 +109,8 @@
\node[scale=0.9,anchor=west,minimum size=18pt] (tw15) at ([xshift=0.5em]tw14.east){the}; \node[scale=0.9,anchor=west,minimum size=18pt] (tw15) at ([xshift=0.5em]tw14.east){the};
\node[scale=0.9,anchor=west,minimum size=18pt] (tw16) at ([yshift=-0.1em,xshift=0.5em]tw15.east){answer}; \node[scale=0.9,anchor=west,minimum size=18pt] (tw16) at ([yshift=-0.1em,xshift=0.5em]tw15.east){answer};
\node[anchor=north](pos1) at ([xshift=-1.0em,yshift=-0.6em]tw14.south){\small{（b）通过边缘集合定义切割得到的句法树}};
\draw[dashed] ([xshift=-0.3em]cfrag1.south) -- ([yshift=-0.3em]tw11.north); \draw[dashed] ([xshift=-0.3em]cfrag1.south) -- ([yshift=-0.3em]tw11.north);
\draw[dashed] (cfrag2.south) -- ([yshift=-0.4em]tw14.north); \draw[dashed] (cfrag2.south) -- ([yshift=-0.4em]tw14.north);
\draw[dashed] (cfrag3.south) -- ([yshift=-0.4em]tw15.north); \draw[dashed] (cfrag3.south) -- ([yshift=-0.4em]tw15.north);
......
Chapter8/chapter8.tex
...@@ -25,7 +25,7 @@ ...@@ -25,7 +25,7 @@
人类的语言是具有结构的，这种结构往往体现在句子的句法信息上。比如，人们进行翻译时会将待翻译句子的主干确定下来，之后得到译文的主干，最后形成完整的译文。一个人学习外语时，也会先学习外语句子的基本构成，比如，主语、谓语等，之后用这种句子结构知识生成外语句子。 人类的语言是具有结构的，这种结构往往体现在句子的句法信息上。比如，人们进行翻译时会将待翻译句子的主干确定下来，之后得到译文的主干，最后形成完整的译文。一个人学习外语时，也会先学习外语句子的基本构成，比如，主语、谓语等，之后用这种句子结构知识生成外语句子。
使用句法分析可以很好地处理翻译中的结构调序、远距离依赖等问题。因此，基于句法的机器翻译模型长期受到研究者关注。比如，早期基于规则的方法里就大量使用了句法信息来定义翻译规则。进入统计机器翻译时代，句法信息的使用同样是领域主要研究方向之一。这也产生了很多基于句法的机器翻译模型及方法，而且在很多任务上取得非常出色的结果。本章将对这些模型和方法进行介绍，内容涉及机器翻译中句法信息的表示、基于句法的翻译建模、句法翻译规则的学习等。 使用句法分析可以很好地处理翻译中的结构调序、远距离依赖等问题。因此，基于句法的机器翻译模型长期受到研究者关注。比如，早期基于规则的方法里就大量使用了句法信息来定义翻译规则。进入统计机器翻译时代，句法信息的使用同样是主要研究方向之一。这也产生了很多基于句法的机器翻译模型及方法，而且在很多任务上取得非常出色的结果。本章将对这些模型和方法进行介绍，内容涉及机器翻译中句法信息的表示、基于句法的翻译建模、句法翻译规则的学习等。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
...@@ -361,7 +361,7 @@ y&=&\beta_0 y_{\pi_1} \beta_1 y_{\pi_2} ... \beta_{m-1} y_{\pi_m} \beta_m ...@@ -361,7 +361,7 @@ y&=&\beta_0 y_{\pi_1} \beta_1 y_{\pi_2} ... \beta_{m-1} y_{\pi_m} \beta_m
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 图\ref{fig:8-7}展示了一个层次短语抽取的示意图。可以看到，在获取一个“ 大”短语的基础上（红色），直接在其内部挖掉另一个“小”短语（绿色），这样就生成了一个层次短语规则。 \parinterval 图\ref{fig:8-7}展示了一个通过双语短语抽取层次短语的示意图。可以看到，在获取一个“ 大”短语的基础上（红色），直接在其内部抽取得到另一个“小”短语（绿色），这样就生成了一个层次短语规则。
\parinterval 这种方式可以抽取出大量的层次短语规则。但是，不加限制的抽取会带来规则集合的过度膨胀，对解码系统造成很大负担。比如，如果考虑任意长度的短语会使得层次短语规则过大，一方面这些规则很难在测试数据上被匹配，另一方面抽取这样的“长”规则会使得抽取算法变慢，而且规则数量猛增之后难以存储。还有，如果一个层次短语规则中含有过多的变量，也会导致解码算法变得更加复杂，不利于系统实现和调试。针对这些问题，在标准的层次短语系统中会考虑一些限制\upcite{chiang2007hierarchical}，包括： \parinterval 这种方式可以抽取出大量的层次短语规则。但是，不加限制的抽取会带来规则集合的过度膨胀，对解码系统造成很大负担。比如，如果考虑任意长度的短语会使得层次短语规则过大，一方面这些规则很难在测试数据上被匹配，另一方面抽取这样的“长”规则会使得抽取算法变慢，而且规则数量猛增之后难以存储。还有，如果一个层次短语规则中含有过多的变量，也会导致解码算法变得更加复杂，不利于系统实现和调试。针对这些问题，在标准的层次短语系统中会考虑一些限制\upcite{chiang2007hierarchical}，包括：
...@@ -504,7 +504,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q ...@@ -504,7 +504,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
\parinterval 图\ref{fig:8-10}展示了CKY方法的一个运行实例（输入词串是aabbc）。算法在处理完最后一个跨度后会得到覆盖整个词串的分析结果，即句法树的根结点S。 \parinterval 图\ref{fig:8-10}展示了CKY方法的一个运行实例（输入词串是aabbc）。算法在处理完最后一个跨度后会得到覆盖整个词串的分析结果，即句法树的根结点S。
\parinterval 不过，CKY方法并不能直接用于层次短语模型。有两个问题： \parinterval 不过，CKY方法并不能直接用于层次短语模型，主要有两个问题：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
...@@ -571,7 +571,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q ...@@ -571,7 +571,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 假设有$n$个规则源语言端相同，规则中每个变量可以被替换为$m$个结果，对于只含有一个变量的规则，一共有$nm$种不同的组合。如果规则含有两个变量，这种组合的数量是$n{m}^2$。由于翻译中会进行大量的规则匹配，如果每个匹配的源语言端都考虑所有$n{m}^2$种译文的组合，解码速度会很慢。 \parinterval 假设有$n$个规则的源语言端相同，规则中每个变量可以被替换为$m$个结果，对于只含有一个变量的规则，一共有$nm$种不同的组合。如果规则含有两个变量，这种组合的数量是$n{m}^2$。由于翻译中会进行大量的规则匹配，如果每个匹配的源语言端都考虑所有$n{m}^2$种译文的组合，解码速度会很慢。
\parinterval 在层次短语系统中，会进一步对搜索空间剪枝。简言之，此时并不需要对所有$n{m}^2$种组合进行遍历，而是只考虑其中的一部分组合。这种方法也被称作{\small\bfnew{立方剪枝}}\index{立方剪枝}（Cube Pruning）\index{Cube Pruning}。所谓“ 立方”是指组合译文时的三个维度：规则的目标语端、第一个变量所对应的翻译候选、第二个变量所对应的翻译候选。立方剪枝假设所有的译文候选都经过排序，比如，按照短语翻译概率排序。这样，每个译文都对应一个坐标，比如，$(i,j,k)$就表示第$i$个规则目标语端、第一个变量的第$j$个翻译候选、第二个变量的第$k$个翻译候选的组合。于是，可以把每种组合看作是一个三维空间中的一个点。在立方剪枝中，开始的时候会看到$(0,0,0)$这个翻译假设，并把这个翻译假设放入一个优先队列中。之后每次从这个优先队里中弹出最好的结果，之后沿着三个维度分别将坐标加1，比如，如果优先队列弹出$(i,j,k)$，则会生成$(i+1,j,k)$、$(i,j+1,k)$和$(i,j,k+1)$这三个新的翻译假设。之后，计算出它们的模型得分，并压入优先队列。这个过程不断被执行，直到达到终止条件，比如，扩展次数达到一个上限。 \parinterval 在层次短语系统中，会进一步对搜索空间剪枝。简言之，此时并不需要对所有$n{m}^2$种组合进行遍历，而是只考虑其中的一部分组合。这种方法也被称作{\small\bfnew{立方剪枝}}\index{立方剪枝}（Cube Pruning）\index{Cube Pruning}。所谓“ 立方”是指组合译文时的三个维度：规则的目标语端、第一个变量所对应的翻译候选、第二个变量所对应的翻译候选。立方剪枝假设所有的译文候选都经过排序，比如，按照短语翻译概率排序。这样，每个译文都对应一个坐标，比如，$(i,j,k)$就表示第$i$个规则目标语端、第一个变量的第$j$个翻译候选、第二个变量的第$k$个翻译候选的组合。于是，可以把每种组合看作是一个三维空间中的一个点。在立方剪枝中，开始的时候会看到$(0,0,0)$这个翻译假设，并把这个翻译假设放入一个优先队列中。之后每次从这个优先队里中弹出最好的结果，之后沿着三个维度分别将坐标加1，比如，如果优先队列弹出$(i,j,k)$，则会生成$(i+1,j,k)$、$(i,j+1,k)$和$(i,j,k+1)$这三个新的翻译假设。之后，计算出它们的模型得分，并压入优先队列。这个过程不断被执行，直到达到终止条件，比如，扩展次数达到一个上限。
...@@ -595,7 +595,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q ...@@ -595,7 +595,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
\sectionnewpage \sectionnewpage
\section{基于语言学句法的模型}\label{section-8.3} \section{基于语言学句法的模型}\label{section-8.3}
\parinterval 层次短语模型是一种典型的基于翻译文法的模型。它把翻译问题转化为语言分析问题。在翻译一个句子的时候，模型会生成一个树形结构，这样也就得到了句子结构的层次化表示。图\ref{fig:8-14}展示了一个使用层次短语系统进行翻译时所生成的翻译推导$d$，以及这个推导所对应的树形结构（源语言）。这棵树体现了机器翻译的视角下的句子结构，尽管这个结构并不是人类语言学中的句法树。 \parinterval 层次短语模型是一种典型的基于翻译文法的模型。它把翻译问题转化为语言分析问题。在翻译一个句子的时候，模型会生成一个树形结构，这样也就得到了句子结构的层次化表示。图\ref{fig:8-14}展示了一个使用层次短语模型进行翻译时所生成的翻译推导$d$，以及这个推导所对应的树形结构（源语言）。这棵树体现了机器翻译的视角下的句子结构，尽管这个结构并不是人类语言学中的句法树。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -617,7 +617,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q ...@@ -617,7 +617,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 实际上，基于层次短语的方法可以被看作是介于基于短语的方法和基于语言学句法的方法之间的一种折中。它的优点在于，短语模型简单且灵活，同时，由于同步翻译文法可以对句子的层次结构进行表示，因此也能够处理一些较长距离的调序问题。但是，另一方面，层次短语模型并不是一种“精细”的句法模型，当翻译需要复杂的结构信息时，这种模型可能会无能为力。 \parinterval 实际上，基于层次短语的方法可以被看作是介于基于短语的方法和基于语言学句法的方法之间的一种折中。它的优点在于，短语模型简单且灵活，同时，由于同步翻译文法可以对句子的层次结构进行表示，因此也能够处理一些较长距离的调序问题。但是，层次短语模型并不是一种“精细”的句法模型，当翻译需要复杂的结构信息时，这种模型可能会无能为力。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -1174,7 +1174,7 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex ...@@ -1174,7 +1174,7 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex
\parinterval 然后，从这个短语出发向上搜索，找到覆盖这个短语的最小树片段，之后生成规则即可。在这个例子中可以得到SPMT规则： \parinterval 然后，从这个短语出发向上搜索，找到覆盖这个短语的最小树片段，之后生成规则即可。在这个例子中可以得到SPMT规则：
\begin{eqnarray} \begin{eqnarray}
\textrm{VP(P(对)}\ \ \textrm{NP(NN(局势))}\ \ \textrm{VP}_1) \rightarrow \textrm{VP}_1\ \ \textrm{about}\ \ \textrm{the}\ \ \textrm{situation} \nonumber \textrm{VP(P(对)}\ \ \textrm{NP(NN(形式))}\ \ \textrm{VP}_1) \rightarrow \textrm{VP}_1\ \ \textrm{about}\ \ \textrm{the}\ \ \textrm{situation} \nonumber
\end{eqnarray} \end{eqnarray}
\parinterval 而这条规则需要组合三条最小规则才能得到，但是在SPMT中可以直接得到。相比规则组合的方法，SPMT方法可以更有效地抽取包含短语的规则。 \parinterval 而这条规则需要组合三条最小规则才能得到，但是在SPMT中可以直接得到。相比规则组合的方法，SPMT方法可以更有效地抽取包含短语的规则。
...@@ -1279,7 +1279,7 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex ...@@ -1279,7 +1279,7 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 可以看到，节点对齐可以避免词对齐错误造成的影响。不过，节点对齐需要开发额外的工具。有很多方法可以参考，比如可以基于启发性规则\upcite{DBLP:conf/coling/GrovesHW04}、基于分类模型\upcite{DBLP:conf/coling/SunZT10}、基于无指导的方法\upcite{xiao2013unsupervised}等。 \parinterval 可以看到，节点对齐可以避免词对齐错误造成的影响。不过，节点对齐需要开发额外的工具，有很多方法可以参考，比如可以基于启发性规则\upcite{DBLP:conf/coling/GrovesHW04}、基于分类模型\upcite{DBLP:conf/coling/SunZT10}、基于无指导的方法\upcite{xiao2013unsupervised}等。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION % NEW SUBSUB-SECTION
......
ChapterAcknowledgement/acknowledgement.tex 0 → 100644
% !Mode:: "TeX:UTF-8"
% !TEX encoding = UTF-8 Unicode
%----------------------------------------------------------------------------------------
% 机器翻译：统计建模与深度学习方法
% Machine Translation: Statistical Modeling and Deep Learning Methods
%
% Copyright 2020
% 肖桐(xiaotong@mail.neu.edu.cn) 朱靖波 (zhujingbo@mail.neu.edu.cn)
%----------------------------------------------------------------------------------------
%----------------------------------------------------------------------------------------
% CONFIGURATIONS
%----------------------------------------------------------------------------------------
\renewcommand\figurename{图}%将figure改为图
%----------------------------------------------------------------------------------------
% postscript
%----------------------------------------------------------------------------------------
\fancyhead[LO]{\sffamily\normalsize\bfseries{后记 \ \quad 肖桐\ 朱靖波}} % Print the nearest section name on the left side of odd pages
\fancyhead[RE]{\sffamily\normalsize\bfseries{后记 \ \quad 肖桐\ 朱靖波}} % Print the current chapter name on the right side of even pages
%\chapter*{后记}
\addcontentsline{toc}{chapter}{后记}
{\color{white} 空}
\vspace{1em}
\begin{center}
{\Huge \bfnew{后记}}
\end{center}
\vspace{2em}
\begin{spacing}{1.18}
\parinterval 写点儿什么 。。。
\hfill 肖桐
\hfill 2020.12.27
\end{spacing}
\ No newline at end of file
ChapterAppend/chapterappend.tex
...@@ -22,6 +22,8 @@ ...@@ -22,6 +22,8 @@
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% CHAPTER APPENDIX A % CHAPTER APPENDIX A
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\fancyhead[LO]{\rightmark} % Print the nearest section name on the left side of odd pages
\fancyhead[RE]{\leftmark} % Print the current chapter name on the right side of even pages
\begin{appendices} \begin{appendices}
\chapter{附录A} \chapter{附录A}
......
Chapter19/chapter19.tex → Chapterpostscript/postscript.tex
...@@ -14,16 +14,25 @@ ...@@ -14,16 +14,25 @@
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\renewcommand\figurename{图}%将figure改为图 \renewcommand\figurename{图}%将figure改为图
\renewcommand\tablename{表}%将figure改为图
\chapterimage{fig-NEU-8.jpg} % Chapter heading image
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% CHAPTER 19 % postscript
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\fancyhead[LO]{\sffamily\normalsize\bfseries{随笔 \ \quad 肖桐\ 朱靖波}} % Print the nearest section name on the left side of odd pages
\fancyhead[RE]{\sffamily\normalsize\bfseries{随笔 \ \quad 肖桐\ 朱靖波}} % Print the current chapter name on the right side of even pages
%\chapter*{后记}
\addcontentsline{toc}{chapter}{随笔}
\chapter{机器翻译杂谈} {\color{white} 空}
\vspace{1em}
\begin{center}
{\Huge \bfnew{随笔}}
\end{center}
\vspace{2em}
\parinterval 朱靖波 2020.12.10-16随笔\\ \begin{spacing}{1.18}
%\section{随笔}
\parinterval 自从计算机诞生开始，机器翻译即利用计算机软件技术实现不同语言自动翻译，就是人们首先想到的计算机主要应用之一。很多人说现在处于人工智能时代，是得语言者的天下，因此机器翻译也是认知智能的终极梦想之一，本节将分享我们对机器翻译技术和应用的一些思考，有些想法不一定正确，也许需要十年之后才能验证。 \parinterval 自从计算机诞生开始，机器翻译即利用计算机软件技术实现不同语言自动翻译，就是人们首先想到的计算机主要应用之一。很多人说现在处于人工智能时代，是得语言者的天下，因此机器翻译也是认知智能的终极梦想之一，本节将分享我们对机器翻译技术和应用的一些思考，有些想法不一定正确，也许需要十年之后才能验证。
...@@ -88,13 +97,11 @@ ...@@ -88,13 +97,11 @@
%\parinterval 通常用于构建机器翻译系统的神经网络结构是人为事先确定的，包括预定义层数（深度）和每层宽度等，其实人为事先给定的网络结构对于当前任务来说是否最佳，这个问题没有结论，学术界目前也无法很好回答这个问题。但根据我们的常识性知识可以得知，过于依赖专家经验来设计网络结构肯定不是最佳方案，后来学术界就产生了网络结构搜索研究工作，即如何根据训练数据本身来自动优化模型深层网络结构，争取达到最佳的训练学习效果，是一个非常有趣的研究方向。目前神经机器翻译技术主要依赖于编码器-解码器两层技术框架，把编码和解码阶段分开，类似于将传统的分析和生成阶段分开，但两者又相互依赖，这样做的好处是技术架构简单，不过可能存在表示学习不够充分和错误蔓延等问题的可能性。为了解决这个问题，我们团队做了一个有趣尝试，提出一个新的神经机器翻译技术框架\ \dash \ 基于联合分布的注意力模型Reformer，不依赖于传统编码器-解码器技术框架，而是直接采用一个统一技术框架完成翻译过程，这项工作目前还比较初级，有待于进一步深入研究。 %\parinterval 通常用于构建机器翻译系统的神经网络结构是人为事先确定的，包括预定义层数（深度）和每层宽度等，其实人为事先给定的网络结构对于当前任务来说是否最佳，这个问题没有结论，学术界目前也无法很好回答这个问题。但根据我们的常识性知识可以得知，过于依赖专家经验来设计网络结构肯定不是最佳方案，后来学术界就产生了网络结构搜索研究工作，即如何根据训练数据本身来自动优化模型深层网络结构，争取达到最佳的训练学习效果，是一个非常有趣的研究方向。目前神经机器翻译技术主要依赖于编码器-解码器两层技术框架，把编码和解码阶段分开，类似于将传统的分析和生成阶段分开，但两者又相互依赖，这样做的好处是技术架构简单，不过可能存在表示学习不够充分和错误蔓延等问题的可能性。为了解决这个问题，我们团队做了一个有趣尝试，提出一个新的神经机器翻译技术框架\ \dash \ 基于联合分布的注意力模型Reformer，不依赖于传统编码器-解码器技术框架，而是直接采用一个统一技术框架完成翻译过程，这项工作目前还比较初级，有待于进一步深入研究。
%\vspace{0.5em} %\vspace{0.5em}
\parinterval 最后简单评价一下机器翻译市场发展的趋势。机器翻译本身是个强刚需，用于解决全球用户多语言交流障碍问题。机器翻译产业真正热起来，应该归功于神经机器翻译技术应用，之前基于规则的方法和统计机器翻译技术虽然也在工业界得到了应用，但由于翻译品质没有达到用户预期，用户付费欲望比较差，没有良好的商业变现能力，导致机器翻译产业在2017年以前类似于“鸡肋”产业。严格上来说，2016年下半年开始，神经机器翻译技术工业界应用快速激活了用户需求，用户对机器翻译的认可度急剧上升，越来越丰富的应用模式和需求被挖掘出来，除了传统计算机辅助翻译CAT以外，语音和OCR与机器翻译技术结合，使得大家比较熟悉的语音翻译APP、翻译机、翻译笔、会议AI同传和垂直行业（专利、医药、旅游等）等的机器翻译解决方案也逐渐得到了广泛应用。总体来说，机器翻译产学研正处于快速上升期，每年市场规模达到至少100\%以上增长，随着多模态机器翻译和大数据翻译技术应用，应用场景会越来越丰富，随着5G甚至6G技术发展，视频翻译和电话通讯翻译等应用会进一步爆发。另外，随着人工智能芯片领域的发展，很自然地机器翻译芯片也会逐渐得到应用，比如嵌入到手机、打印机、复印机、传真机和电视机等智能终端设备，实现所有内容皆可翻译，任何场景皆可运行的目标，机器翻译服务将进入人们的日常生活中，无所不在，让生活更加美好！ \parinterval 最后简单评价一下机器翻译市场发展的趋势。机器翻译本身是个强刚需，用于解决全球用户多语言交流障碍问题。机器翻译产业真正热起来，应该归功于神经机器翻译技术应用，之前基于规则的方法和统计机器翻译技术虽然也在工业界得到了应用，但由于翻译品质没有达到用户预期，用户付费欲望比较差，没有良好的商业变现能力，导致机器翻译产业在2017年以前类似于“鸡肋”产业。严格上来说，2016年下半年开始，神经机器翻译技术工业界应用快速激活了用户需求，用户对机器翻译的认可度急剧上升，越来越丰富的应用模式和需求被挖掘出来，除了传统计算机辅助翻译CAT以外，语音和OCR与机器翻译技术结合，使得大家比较熟悉的语音翻译APP、翻译机、翻译笔、会议AI同传和垂直行业（专利、医药、旅游等）等的机器翻译解决方案也逐渐得到了广泛应用。总体来说，机器翻译产学研正处于快速上升期，每年市场规模达到至少100\%以上增长，随着多模态机器翻译和大数据翻译技术应用，应用场景会越来越丰富，随着5G甚至6G技术发展，视频翻译和电话通讯翻译等应用会进一步爆发。另外，随着人工智能芯片领域的发展，很自然地机器翻译芯片也会逐渐得到应用，比如嵌入到手机、打印机、复印机、传真机和电视机等智能终端设备，实现所有内容皆可翻译，任何场景皆可运行的目标，机器翻译服务将进入人们的日常生活中，无所不在，让生活更加美好！\\
%----------------------------------------------
\begin{figure}[htp] \hfill 朱靖波
\centering
\includegraphics[scale=0.4]{./Chapter19/Figures/figure-niutrans.jpg} \hfill 2020.12.10-16 随笔
%\setlength{\abovecaptionskip}{-0.2cm}
%\caption{使用TranSmart系统进行交互式翻译的实例}
\label{fig:19-1} \end{spacing}
\end{figure} \ No newline at end of file
%----------------------------------------------
bibliography.bib
This source diff could not be displayed because it is too large. You can view the blob instead.
mt-book-xelatex.tex
...@@ -149,8 +149,9 @@ ...@@ -149,8 +149,9 @@
%\include{Chapter15/chapter15} %\include{Chapter15/chapter15}
%\include{Chapter16/chapter16} %\include{Chapter16/chapter16}
%\include{Chapter17/chapter17} %\include{Chapter17/chapter17}
\include{Chapter18/chapter18} %\include{Chapter18/chapter18}
\include{Chapter19/chapter19} \include{ChapterPostscript/postscript}
\include{ChapterAcknowledgement/acknowledgement}
%\include{ChapterAppend/chapterappend} %\include{ChapterAppend/chapterappend}
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论