合并分支 'caorunzhe' 到 'master'

Caorunzhe 查看合并请求 !714

合并分支 'caorunzhe' 到 'master'
Caorunzhe 查看合并请求 !714
064f3a56 · 曹润柘 · 6f8da096 · dbf04713 · 064f3a56 · 064f3a56
Commit 064f3a56 authored Dec 27, 2020 by 曹润柘
--- a/Chapter10/Figures/figure-calculation-process-of-context-vector-c.tex
+++ b/Chapter10/Figures/figure-calculation-process-of-context-vector-c.tex
@@ -36,7 +36,7 @@
 \node [anchor=north] (enc2) at (h2.south) {\scriptsize{编码器输出}};
 \node [anchor=north] (enc22) at ([yshift=0.5em]enc2.south) {\scriptsize{(位置$2$)}};
 \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 $ \ \ \ \ };

--- a/Chapter10/Figures/figure-example-of-context-vector-calculation-process.tex
+++ b/Chapter10/Figures/figure-example-of-context-vector-calculation-process.tex
@@ -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) {};

 %attention score labels
-\node[align=center] (l17) at (a17) {\scriptsize{{\color{white} .4}}};
-\node[align=center] (l26) at (a06) {\scriptsize{{\color{white} .3}}};
-\node[align=center] (l26) at (a16) {\scriptsize{{\color{white} .4}}};
-\node[align=center] (l17) at (a35) {\scriptsize{{\color{white} .3}}};
-\node[align=center] (l17) at (a34) {\tiny{{\color{white} .3}}};
-\node[align=center] (l17) at (a23) {\small{{\color{white} .8}}};
-\node[align=center] (l17) at (a41) {\small{{\color{white} .8}}};
-\node[align=center] (l17) at (a50) {\small{{\color{white} .7}}};
+\node[align=center,scale=0.8] (l17) at (a17) {\scriptsize{{\color{white} 0.4}}};
+\node[align=center,scale=0.7] (l26) at (a06) {\tiny{{\color{white} 0.3}}};
+\node[align=center,scale=0.8] (l26) at (a16) {\scriptsize{{\color{white} 0.4}}};
+\node[align=center,scale=0.7] (l17) at (a35) {\tiny{{\color{white} 0.3}}};
+\node[align=center,scale=0.7] (l17) at (a34) {\tiny{{\color{white} 0.3}}};
+\node[align=center] (l17) at (a23) {\small{{\color{white} 0.8}}};
+\node[align=center] (l17) at (a41) {\small{{\color{white} 0.8}}};
+\node[align=center,scale=0.9] (l17) at (a50) {\small{{\color{white} 0.7}}};

 % source
 \node[srcnode] (src1) at (-5.4*0.5*\hnode,-1.05*\hnode+7.5*0.5*\hnode) {\scriptsize{Have}};

--- a/Chapter10/Figures/figure-matrix-representation-of-attention-weights-between-chinese-english-sentence-pairs.tex
+++ b/Chapter10/Figures/figure-matrix-representation-of-attention-weights-between-chinese-english-sentence-pairs.tex
@@ -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) {};

 %attention score labels
-\node[align=center] (l17) at (a17) {\scriptsize{{\color{white} .4}}};
-\node[align=center] (l26) at (a06) {\scriptsize{{\color{white} .3}}};
-\node[align=center] (l26) at (a16) {\scriptsize{{\color{white} .4}}};
-\node[align=center] (l17) at (a35) {\scriptsize{{\color{white} .3}}};
-\node[align=center] (l17) at (a34) {\tiny{{\color{white} .3}}};
-\node[align=center] (l17) at (a23) {\small{{\color{white} .8}}};
-\node[align=center] (l17) at (a41) {\small{{\color{white} .8}}};
-\node[align=center] (l17) at (a50) {\small{{\color{white} .7}}};
+\node[align=center,scale=0.8] (l17) at (a17) {\scriptsize{{\color{white} 0.4}}};
+\node[align=center,scale=0.8] (l26) at (a06) {\scriptsize{{\color{white} 0.3}}};
+\node[align=center,scale=0.8] (l26) at (a16) {\scriptsize{{\color{white} 0.4}}};
+\node[align=center,scale=0.8] (l17) at (a35) {\scriptsize{{\color{white} 0.3}}};
+\node[align=center,scale=0.8] (l17) at (a34) {\scriptsize{{\color{white} 0.3}}};
+\node[align=center] (l17) at (a23) {\small{{\color{white} 0.8}}};
+\node[align=center] (l17) at (a41) {\small{{\color{white} 0.8}}};
+\node[align=center] (l17) at (a50) {\small{{\color{white} 0.7}}};

 % source
 \node[srcnode] (src1) at (-5.4*0.5*1.2cm,-1.05*1.2cm+7.5*0.5*1.2cm) {\scriptsize{Have}};

--- a/Chapter10/chapter10.tex
+++ b/Chapter10/chapter10.tex
@@ -191,7 +191,7 @@ NMT                     & 21.7          & 18.7           & -13.7      \\
 \end{table}
 %----------------------------------------------

-\parinterval  在最近两年，神经机器翻译的发展更加迅速，新的模型及方法层出不穷。表\ref{tab:10-3}给出了到2020年为止一些主流的神经机器翻译模型的对比。可以看到，相比2017年，2018-2020年中机器翻译仍然有明显的进步。
+\parinterval  在最近两年，神经机器翻译的发展更加迅速，新的模型及方法层出不穷。表\ref{tab:10-3}给出了到2020年为止，一些主流的神经机器翻译模型在WMT14英德数据集上的表现。可以看到，相比2017年，2018-2020年中机器翻译仍然有明显的进步。

 \vspace{0.5em}%全局布局使用
 %----------------------------------------------
@@ -439,13 +439,13 @@ NMT                     & 21.7          & 18.7           & -13.7      \\
 \end{figure}
 %----------------------------------------------

-\parinterval 从数学模型上看，神经机器翻译模型与统计机器翻译的目标是一样的：在给定源语言句子$\seq{x}$的情况下，找出翻译概率最大的目标语言译文$\hat{\seq{y}}$，其计算如公式\eqref{eq:10-1}所示:
+\parinterval 从数学模型上看，神经机器翻译模型与统计机器翻译的目标是一样的：在给定源语言句子$\seq{x}$的情况下，找出翻译概率最大的目标语言译文$\hat{\seq{y}}$，其计算如下式:
 \begin{eqnarray}
 \hat{\seq{{y}}} &=& \argmax_{\seq{{y}}} \funp{P} (\seq{{y}} | \seq{{x}})
 \label{eq:10-1}
 \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}
 \funp{P} (\seq{{y}} | \seq{{x}}) &=& \prod_{j=1}^{n} \funp{P} ( y_j | \seq{{y}}_{<j }, \seq{{x}}  )
 \label{eq:10-2}
@@ -463,12 +463,12 @@ NMT                     & 21.7          & 18.7           & -13.7      \\
 \vspace{0.5em}
 \item	如何在词嵌入的基础上获取整个序列的表示，即句子的表示学习。可以把词嵌入的序列作为循环神经网络的输入，循环神经网络最后一个时刻的输出向量便是整个句子的表示结果。如图\ref{fig:10-10}中，编码器最后一个循环单元的输出$\mathbi{h}_m$被看作是一种包含了源语言句子信息的表示结果，记为$\mathbi{C}$。
 \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}
 \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}
 \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}
 \funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}}) &=&
 \left \{ \begin{array}{ll}
@@ -490,7 +490,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
 %----------------------------------------------

 \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}
 \mathbi{h}_t &=& f(\mathbi{x}_t \mathbi{U}+\mathbi{h}_{t-1} \mathbi{W}+\mathbi{b})
 \label{eq:10-5}
@@ -527,7 +527,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm

 \begin{itemize}
 \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}
 \mathbi{f}_t &=& \sigma(\mathbi{W}_f [\mathbi{h}_{t-1},\mathbi{x}_{t}] + \mathbi{b}_f )
 \label{eq:10-6}
@@ -556,7 +556,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
 \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]
@@ -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}
 \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}
 \hat{\mathbi{h}}_t &=& \textrm{Tanh} (\mathbi{W}_h [\mathbi{r}_t \cdot \mathbi{h}_{t-1},\mathbi{x}_{t}])
 \label{eq:10-14}
 \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}
 \mathbi{h}_t &=& (1-\mathbi{u}_t) \cdot \mathbi{h}_{t-1} +\mathbi{u}_t \cdot \hat{\mathbi{h}}_t
 \label{eq:10-15}
@@ -614,7 +614,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm

 \subsection{双向模型}

-\parinterval 前面提到的循环神经网络都是自左向右运行的，也就是说在处理一个单词的时候只能访问它前面的序列信息。但是，只根据句子的前文来生成一个序列的表示是不全面的，因为从最后一个词来看，第一个词的信息可能已经很微弱了。为了同时考虑前文和后文的信息，一种解决办法是使用双向循环网络，其结构如图\ref{fig:10-14}所示。这里，编码器可以看作有两个循环神经网络，第一个网络，即红色虚线框里的网络，从句子的右边进行处理，第二个网络从句子左边开始处理，最终将正向和反向得到的结果都融合后传递给解码器。
+\parinterval 前面提到的循环神经网络都是自左向右运行的，也就是说在处理一个单词的时候只能访问它前面的序列信息。但是，只根据句子的前文来生成一个序列的表示是不全面的，因为从最后一个词来看，第一个词的信息可能已经很微弱了。为了同时考虑前文和后文的信息，一种解决办法是使用双向循环网络，其结构如图\ref{fig:10-14}所示。这里，编码器可以看作由两个循环神经网络构成，第一个网络，即红色虚线框里的网络，从句子的右边进行处理，第二个网络从句子左边开始处理，最终将正向和反向得到的结果都融合后传递给解码器。

 %----------------------------------------------
 \begin{figure}[htp]
@@ -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$被定义为对不同时间步编码器输出的状态序列$\{ \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}
 \mathbi{C}_j&=&\sum_{i} \alpha_{i,j} \mathbi{h}_i
 \label{eq:10-16}
@@ -740,7 +740,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm

 \begin{itemize}
 \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}
 \beta_{i,j} &=& a(\mathbi{s}_{j-1},\mathbi{h}_i)
 \label{eq:10-17}
@@ -760,7 +760,7 @@ a (\mathbi{s},\mathbi{h}) &=&  \left\{ \begin{array}{ll}

 其中$\mathbi{W}$和$\mathbi{v}$是可学习的参数。
 \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}
 \begin{eqnarray}
 \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}
 \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}
 \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}
@@ -837,7 +837,7 @@ a (\mathbi{s},\mathbi{h}) &=&  \left\{ \begin{array}{ll}
 \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}
 \overline{\mathrm{value}} &=& \sum_i \alpha_i \cdot {\mathrm{value}}_i
 \label{eq:10-21}
@@ -856,13 +856,13 @@ a (\mathbi{s},\mathbi{h}) &=&  \left\{ \begin{array}{ll}
 \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}
 \overline{\mathrm{value}} &=& \sum_i \funp{P} ( {\mathrm{value}}_i) \cdot {\mathrm{value}}_i
 \label{eq:10-22}
 \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}
 \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}
@@ -898,7 +898,7 @@ a (\mathbi{s},\mathbi{h}) &=&  \left\{ \begin{array}{ll}
 \caption{GNMT与其他翻译模型对比\upcite{Wu2016GooglesNM}}
 \label{tab:10-8}
 \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|}{}                    & EN-DE  & EN-FR                                               \\ \hline
 \multicolumn{1}{l|}{PBMT}                & 20.7            & 37.0            \\
@@ -923,7 +923,7 @@ a (\mathbi{s},\mathbi{h}) &=&  \left\{ \begin{array}{ll}
 %----------------------------------------------------------------------------------------
 \subsection{训练}

-\parinterval 在基于梯度的方法中，模型参数可以通过损失函数$L$对参数的梯度进行不断更新。对于第$\textrm{step}$步参数更新，首先进行神经网络的前向计算，之后进行反向计算，并得到所有参数的梯度信息，再使用公式\eqref{eq:10-24}的规则进行参数更新：
+\parinterval 在基于梯度的方法中，模型参数可以通过损失函数$L$对参数的梯度进行不断更新。对于第$\textrm{step}$步参数更新，首先进行神经网络的前向计算，之后进行反向计算，并得到所有参数的梯度信息，再使用下面的规则进行参数更新：
 \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}} }
 \label{eq:10-24}
@@ -939,13 +939,13 @@ a (\mathbi{s},\mathbi{h}) &=&  \left\{ \begin{array}{ll}

 \subsubsection{1. 损失函数}

-\parinterval 神经机器翻译在目标端的每个位置都会输出一个概率分布，表示这个位置上不同单词出现的可能性。设计损失函数时，需要知道当前位置输出的分布相比于标准答案的“差异”。对于这个问题，常用的是交叉熵损失函数。令$\mathbi{y}$表示机器翻译模型输出的分布，$\hat{\mathbi{y}}$ 表示标准答案，则交叉熵损失可以被定义为公式\eqref{eq:10-25}：
+\parinterval 神经机器翻译在目标端的每个位置都会输出一个概率分布，表示这个位置上不同单词出现的可能性。设计损失函数时，需要知道当前位置输出的分布相比于标准答案的“差异”。对于这个问题，常用的是交叉熵损失函数。令$\mathbi{y}$表示机器翻译模型输出的分布，$\hat{\mathbi{y}}$ 表示标准答案，则交叉熵损失可以被定义为：
 \begin{eqnarray}
 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}
 \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}
 L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j,\hat{\mathbi{y}}_j)
 \label{eq:10-26}
@@ -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 除了交叉熵，很多系统也使用了面向评价的损失函数，比如，直接利用评价指标BLEU定义损失函数\upcite{DBLP:conf/acl/ShenCHHWSL16}。不过这类损失函数往往不可微分，因此无法直接获取梯度。这时可以引入强化学习技术，通过策略梯度等方法进行优化。不过这类方法需要采样等手段，这里不做重点讨论，相关内容会在后面技术部分进行介绍。
+\parinterval 除了交叉熵，很多系统也使用了面向评价的损失函数，比如，直接利用评价指标BLEU定义损失函数\upcite{DBLP:conf/acl/ShenCHHWSL16}。不过这类损失函数往往不可微分，因此无法直接获取梯度。这时可以引入强化学习技术，通过策略梯度等方法进行优化。不过这类方法需要采样等手段，这里不做重点讨论，相关内容会在{\chapterthirteen}进行介绍。

 %----------------------------------------------------------------------------------------
 %    NEW SUBSUB-SECTION
@@ -971,7 +971,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
 \vspace{0.5em}
 \item 网络中的其他偏置一般都初始化为0，可以有效防止加入过大或过小的偏置后使得激活函数的输出跑到“饱和区”，也就是梯度接近0的区域，防止训练一开始就无法跳出局部极小的区域。
 \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}
 \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}
@@ -988,9 +988,9 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
 \subsubsection{3. 优化策略}

 %\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
@@ -999,7 +999,7 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
 \subsubsection{4. 梯度裁剪}
 %\vspace{0.5em}

-\parinterval 需要注意的是，训练循环神经网络时，反向传播使得网络层之间的梯度相乘。在网络层数过深时，如果连乘因子小于1可能造成梯度指数级的减少，甚至趋近于0，导致网络无法优化，也就是梯度消失问题。当连乘因子大于1时，可能会导致梯度的乘积变得异常大，造成梯度爆炸的问题。在这种情况下需要使用“梯度裁剪”来防止梯度超过阈值。梯度裁剪在{\chapternine}已经介绍过，这里简单回顾一下。梯度裁剪的具体公式如公式\eqref{eq:10-28}所示：
+\parinterval 需要注意的是，训练循环神经网络时，反向传播使得网络层之间的梯度相乘。在网络层数过深时，如果连乘因子小于1可能造成梯度指数级的减少，甚至趋近于0，导致网络无法优化，也就是梯度消失问题。当连乘因子大于1时，可能会导致梯度的乘积变得异常大，造成梯度爆炸的问题。在这种情况下需要使用“梯度裁剪”来防止梯度超过阈值。梯度裁剪在{\chapternine}已经介绍过，这里简单回顾一下。梯度裁剪的具体公式如下：
 \vspace{-0.5em}
 \begin{eqnarray}
 \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
 \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}
 \begin{eqnarray}
 \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
 \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]
@@ -1110,9 +1110,9 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
 \begin{figure}[htp]
 \centering
 \begin{tabular}{l l}
-\subfigure[{\small }]{\input{./Chapter10/Figures/figure-process01}} &\subfigure[{\small }]{\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-process05}}  &\subfigure[{\small }]{\input{./Chapter10/Figures/figure-process06}}
+\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 第五步\qquad }]{\input{./Chapter10/Figures/figure-process05}}  &\subfigure[{\small 第六步\qquad }]{\input{./Chapter10/Figures/figure-process06}}
 \end{tabular}
 \caption{一个三层循环神经网络的模型并行过程}
 \label{fig:10-28}
@@ -1124,20 +1124,20 @@ L(\mathbi{Y},\widehat{\mathbi{Y}}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\mathbi{y}_j
 %----------------------------------------------------------------------------------------
 \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}
 \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}})
 \label{eq:10-30}
 \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}
 \hat{y}_j &=& \argmax_{y_j} \funp{P}(y_j | \hat{\seq{{y}}}_{<j} , \seq{{x}})
 \label{eq:10-31}
 \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}
 \{ \hat{y}_{j1},...,\hat{y}_{jk} \} &=& \argmax_{ \{ \hat{y}_{j1},...,\hat{y}_{jk} \} }
 \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
 \vspace{0.5em}
 \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}
 \textrm{lp}(\seq{{y}}) &=& \frac {(5+ |\seq{{y}}|)^{\alpha}} {(5+1)^{\alpha}}
 \label{eq:10-33}
 \end{eqnarray}

-\noindent 其中，$|\seq{{y}}|$代表已经得到的译文长度，$\alpha$是一个固定的常数，用于控制惩罚的强度。同时在计算句子得分时，额外引入表示覆盖度的因子，如公式\eqref{eq:10-34}所示：
+\noindent 其中，$|\seq{{y}}|$代表已经得到的译文长度，$\alpha$是一个固定的常数，用于控制惩罚的强度。同时在计算句子得分时，额外引入表示覆盖度的因子，如下：
 \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)
 \label{eq:10-34}
@@ -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$也是需要经验性设置的超参数，用于对覆盖度惩罚的强度进行控制。

-\parinterval 最终，模型得分定义如公式\eqref{eq:10-35}所示：
+\parinterval 最终，模型得分定义如下：
 \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}})
 \label{eq:10-35}

--- a/Chapter11/chapter11.tex
+++ b/Chapter11/chapter11.tex
@@ -85,13 +85,13 @@
 \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}
 \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}
 \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}
 \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 \\
@@ -201,9 +201,9 @@
 \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.
@@ -244,9 +244,9 @@

 \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}

 %----------------------------------------------
@@ -311,7 +311,7 @@
 \mathbi{B} & = & \mathbi{x} * \mathbi{V} + \mathbi{b}_\mathbi{V} \label{eq:11-4}
 \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}
 \mathbi{y} & = & \mathbi{A} \otimes \sigma ( \mathbi{B} )
 \label{eq:11-5}
@@ -338,7 +338,7 @@
 \subsection{残差网络}
 \label{sec:11.2.3}

-\parinterval 残差连接是一种训练深层网络的技术，其内容在{\chapternine}已经进行了介绍，即在多层神经网络之间通过增加直接连接的方式，从而将底层信息直接传递给上层。通过增加这样的直接连接，可以让不同层之间的信息传递更加高效，有利于深层神经网络的训练，其计算如公式\eqref{eq:11-6}所示：
+\parinterval 残差连接是一种训练深层网络的技术，其内容在{\chapternine}已经进行了介绍，即在多层神经网络之间通过增加直接连接的方式，从而将底层信息直接传递给上层。通过增加这样的直接连接，可以让不同层之间的信息传递更加高效，有利于深层神经网络的训练，其计算公式为：
 \begin{eqnarray}
 \mathbi{h}^{l+1} &=& F (\mathbi{h}^l) + \mathbi{h}^l
 \label{eq:11-6}
@@ -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$。

-\parinterval 在ConvS2S中残差连接主要应用于门控卷积神经网络和多跳自注意力机制中，比如在编码器的多层门控卷积神经网络中，在每一层的输入和输出之间增加残差连接，具体的数学描述如公式\eqref{eq:11-7}所示：
+\parinterval 在ConvS2S中残差连接主要应用于门控卷积神经网络和多跳自注意力机制中，比如在编码器的多层门控卷积神经网络中，在每一层的输入和输出之间增加残差连接，具体的数学描述如下：
 \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}^{l+1} &=& \mathbi{A}^{l} \otimes \sigma ( \mathbi{B}^{l} ) + \mathbi{h}^{l}
@@ -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}已经详细讨论。

-\parinterval 在ConvS2S模型中，解码器同样采用堆叠的多层门控卷积网络来对目标语言进行序列建模。区别于编码器，解码器在每一层卷积网络之后引入了注意力机制，用来参考源语言信息。ConvS2S选用了点乘注意力，并且通过类似残差连接的方式将注意力操作的输入与输出同时作用于下一层计算，称为多跳注意力。其具体计算方式如公式\eqref{eq:11-10}所示：
+\parinterval 在ConvS2S模型中，解码器同样采用堆叠的多层门控卷积网络来对目标语言进行序列建模。区别于编码器，解码器在每一层卷积网络之后引入了注意力机制，用来参考源语言信息。ConvS2S选用了点乘注意力，并且通过类似残差连接的方式将注意力操作的输入与输出同时作用于下一层计算，称为多跳注意力。其具体计算方式如下：
 \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^{'}})}
 \label{eq:11-10}
@@ -393,13 +393,13 @@
 \mathbi{z}_j^l &=& \textrm{Conv}(\mathbi{s}_j^l) \label{eq:11-12}
 \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}
 \mathbi{C}_j^l &=& \sum_i \alpha_{ij}^l (\mathbi{h}_i + \mathbi{e}_i)
 \label{eq:11-13}
 \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}
 \mathbi{s}_j^{l+1} &=& \mathbi{C}_j^l + \mathbi{z}_j^l
 \label{eq:11-14}
@@ -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$控制累积的范围。

-\parinterval 而在Nesterov加速梯度下降法中，使用的梯度不是来自于当前参数位置，而是按照之前梯度方向更新一小步的位置，以便于更好地“预测未来”，提前调整更新速率，因此，其动量的更新方式如公式\eqref{eq:11-17}：
+\parinterval 而在Nesterov加速梯度下降法中，使用的梯度不是来自于当前参数位置，而是按照之前梯度方向更新一小步的位置，以便于更好地“预测未来”，提前调整更新速率，因此，其动量的更新方式如下：
 \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} )}
 \label{eq:11-17}
 \end{eqnarray}

-\parinterval Nesterov加速梯度下降法其实是利用了二阶导数的信息，因此可以做到“向前看”，加速收敛过程\upcite{Bengio2013AdvancesIO}。为了模型的稳定训练。ConvS2S模型也采用了一些网络正则化和参数初始化的策略，使得模型在前向计算和反向计算过程中方差尽可能保持一致。
+\parinterval Nesterov加速梯度下降法利用了二阶导数的信息，可以做到“向前看”，加速收敛过程\upcite{Bengio2013AdvancesIO}。为了模型的稳定训练。ConvS2S模型也采用了一些网络正则化和参数初始化的策略，使得模型在前向计算和反向计算过程中方差尽可能保持一致。

 \parinterval 此外，ConvS2S模型为了进一步提升训练效率及性能，还使用了小批量训练，即每次从样本中选择出一小部分数据进行训练。同时，ConvS2S模型中也使用了Dropout方法\upcite{JMLR:v15:srivastava14a}。除了在词嵌入层和解码器输出层应用Dropout外，ConvS2S模型还对卷积块的输入层应用了Dropout。

@@ -476,7 +476,7 @@
 \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 \}$。
-在标准卷积中，若使用N表示卷积核的个数，也就是标准卷积输出序列的通道数，那么对于第$i$个位置的第$n$个通道$ \mathbi{z}_{i,n}^\textrm{\,std}$，其标准卷积具体计算如公式\eqref{eq:11-18}所示：
+在标准卷积中，若使用N表示卷积核的个数，也就是标准卷积输出序列的通道数，那么对于第$i$个位置的第$n$个通道$ \mathbi{z}_{i,n}^\textrm{\,std}$，其标准卷积具体计算如下：
 \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}
 \label{eq:11-18}
@@ -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}中的连接数也最多。

-\parinterval 相应的，深度卷积只考虑不同词之间的依赖性，而不考虑不同通道之间的关系，相当于使用$O$个卷积核逐个通道对不同的词进行卷积操作。因此深度卷积不改变输出的表示维度，输出序列表示的通道数与输入序列一致，其计算如公式\eqref{eq:11-19}所示：
+\parinterval 相应的，深度卷积只考虑不同词之间的依赖性，而不考虑不同通道之间的关系，相当于使用$O$个卷积核逐个通道对不同的词进行卷积操作。因此深度卷积不改变输出的表示维度，输出序列表示的通道数与输入序列一致，其计算如下：
 \begin{eqnarray}
 \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}
@@ -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}$为深度卷积的参数，参数量只涉及卷积核大小及输入表示维度。

-\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}
 \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}
@@ -547,7 +547,7 @@
 \end{figure}
 %----------------------------------------------

-\parinterval 此外，和标准卷积不同的是，轻量卷积之前需要先对卷积参数进行归一化，具体计算过程如公式\eqref{eq:11-21}所示：
+\parinterval 此外，和标准卷积不同的是，轻量卷积之前需要先对卷积参数进行归一化，具体计算过程为：
 \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}
 \label{eq:11-21}
@@ -562,7 +562,7 @@

 \parinterval 轻量卷积和动态卷积的概念最早都是在图像领域被提出，大大减少了卷积神经网络模型中的参数和计算量\upcite{726791,Taigman2014DeepFaceCT,Chen2015LocallyconnectedAC}。虽然轻量卷积在存储和速度上具有优势，但其参数量的减少也导致了表示能力的下降，损失了一部分模型性能。为此，研究人员提出了动态卷积，旨在不增加网络深度和宽度的情况下来增强模型的表示能力，其思想就是根据输入来动态地生成卷积参数\upcite{Wu2019PayLA,Chen2020DynamicCA}。

-\parinterval 在轻量卷积中，模型使用的卷积参数是静态的，与序列位置无关， 维度大小为$K\times a$；而在动态卷积中，为了增强模型的表示能力，卷积参数来自于当前位置输入的变换，具体如公式\eqref{eq:11-22}：
+\parinterval 在轻量卷积中，模型使用的卷积参数是静态的，与序列位置无关， 维度大小为$K\times a$；而在动态卷积中，为了增强模型的表示能力，卷积参数来自于当前位置输入的变换，具体计算为：
 \begin{eqnarray}
 \funp{f} (\mathbi{x}_{i}) &=& \sum_{c=1}^d \mathbi{W}_{:,:,c} \odot \mathbi{x}_{i,c}
 \label{eq:11-22}

--- a/Chapter12/chapter12.tex
+++ b/Chapter12/chapter12.tex
@@ -56,7 +56,7 @@
 \end{figure}
 %----------------------------------------------

-\parinterval 自注意力机制也可以被看作是一个序列表示模型。比如，对于每个目标位置$j$，都生成一个与之对应的源语言句子表示，它的形式如公式\eqref{eq:12-1}所示：
+\parinterval 自注意力机制也可以被看作是一个序列表示模型。比如，对于每个目标位置$j$，都生成一个与之对应的源语言句子表示，它的形式如下：
 \begin{eqnarray}
 \mathbi{C}_j & = & \sum_i \alpha_{i,j}\mathbi{h}_i
 \label{eq:12-1}
@@ -73,7 +73,7 @@
 \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}
 \tilde{h} (\textrm{他} ) & = & \alpha_1 {h} (\textrm{他} ) + \alpha_2 {h} (\textrm{什么}) + \alpha_3 {h} (\textrm{也} ) + \nonumber \\
@@ -102,7 +102,7 @@

 \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]
@@ -271,7 +271,7 @@
 %    NEW SUB-SECTION
 %----------------------------------------------------------------------------------------

-\subsection{点乘注意力}
+\subsection{点乘注意力机制}

 \parinterval 在\ref{sec:12.1}节中已经介绍，自注意力机制中至关重要的是获取相关性系数，也就是在融合不同位置的表示向量时各位置的权重。Transformer模型采用了一种基于点乘的方法来计算相关性系数。这种方法也称为{\small\bfnew{缩放的点乘注意力}}\index{缩放的点乘注意力}（Scaled Dot-product Attention）\index{Scaled Dot-product Attention}机制。它的运算并行度高，同时并不消耗太多的存储空间。

@@ -279,7 +279,7 @@

 \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}
 \textrm{Attention}(\mathbi{Q},\mathbi{K},\mathbi{V}) &=& \textrm{Softmax}
 ( \frac{\mathbi{Q}\mathbi{K}^{\textrm{T}}} {\sqrt{d_k}} + \mathbi{Mask} ) \mathbi{V}
@@ -302,7 +302,7 @@
 \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]
@@ -317,9 +317,9 @@
 %    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}详细介绍多头注意力的计算过程：

@@ -342,14 +342,14 @@
 \end{figure}
 %----------------------------------------------

-\parinterval 多头机制可以被形式化描述为公式\eqref{eq:12-10}和\eqref{eq:12-11}：
+\parinterval 多头注意力机制可以被形式化描述为公式\eqref{eq:12-10}和\eqref{eq:12-11}：
 \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} \\
 \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}
 \end{eqnarray}

-\parinterval 多头机制的好处是允许模型在不同的表示子空间里学习。在很多实验中发现，不同表示空间的头捕获的信息是不同的，比如，在使用Transformer处理自然语言时，有的头可以捕捉句法信息，有的头可以捕捉词法信息。
+\parinterval 多头注意力机制的好处是允许模型在不同的表示子空间里学习。在很多实验中发现，不同表示空间的头捕获的信息是不同的，比如，在使用Transformer处理自然语言时，有的头可以捕捉句法信息，有的头可以捕捉词法信息。

 %----------------------------------------------------------------------------------------
 %    NEW SUB-SECTION
@@ -414,14 +414,14 @@
 \end{figure}
 %----------------------------------------------

-\parinterval 在Transformer的训练过程中，由于引入了残差操作，将前面所有层的输出加到一起，如公式\eqref{eq:12-12}所示：
+\parinterval 在Transformer的训练过程中，由于引入了残差操作，将前面所有层的输出加到一起，如下：
 \begin{eqnarray}
 %x_{l+1} = x_l + F (x_l)
 \mathbi{x}^{l+1} &=& F (\mathbi{x}^l) + \mathbi{x}^l
 \label{eq:12-12}
 \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}
 \textrm{LN}(\mathbi{x}) &=& g \cdot \frac{\mathbi{x}- \mu} {\sigma} + b
 \label{eq:12-13}
@@ -457,7 +457,7 @@
 \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}
 \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}
@@ -487,7 +487,7 @@
 \begin{itemize}
 \vspace{0.5em}
 \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}
 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}
@@ -589,7 +589,8 @@ Transformer Deep（48层） & 30.2            & 43.1            & 194$\times 10^

 \begin{itemize}
 \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}
 \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}

--- a/Chapter13/Figures/figure-exposure-bias.png
+++ b/Chapter13/Figures/figure-exposure-bias.png
--- a/Chapter13/Figures/figure-framework-of-Adversarial-Neural-machine-translation.png
+++ b/Chapter13/Figures/figure-framework-of-Adversarial-Neural-machine-translation.png
--- a/Chapter13/Figures/figure-minimum-risk-training-calculation-process.png
+++ b/Chapter13/Figures/figure-minimum-risk-training-calculation-process.png
--- a/Chapter13/Figures/figure-of-scheduling-sampling-method.png
+++ b/Chapter13/Figures/figure-of-scheduling-sampling-method.png
--- a/Chapter13/Figures/figure-reinforcement-learning-method-based-on-actor-critic.png
+++ b/Chapter13/Figures/figure-reinforcement-learning-method-based-on-actor-critic.png
--- a/Chapter15/Figures/figure-activation-function-swish-structure-diagram.tex
+++ b/Chapter15/Figures/figure-activation-function-swish-structure-diagram.tex
-
-%%% 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}
-
-
-
-
--- a/Chapter15/Figures/figure-learning-of-local-structure-combination.png
+++ b/Chapter15/Figures/figure-learning-of-local-structure-combination.png
--- a/Chapter15/Figures/figure-learning-of-local-structure-combination.tex
+++ b/Chapter15/Figures/figure-learning-of-local-structure-combination.tex
-
-%%% 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}
-
-
-
-
--- a/Chapter15/Figures/figure-whole-structure-and-internal-structure-in-rnn.tex
+++ b/Chapter15/Figures/figure-whole-structure-and-internal-structure-in-rnn.tex
-
-%%% outline
-%-------------------------------------------------------------------------
-\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]
-
-\node[node] (n1) at (0,0){};
-\node[node] (n2) at (1.5,0){};
-\node[node] (n3) at (3,0){};
-\node[node] (n4) at (4.5,0){};
-\node[node] (n5) at (1.5,-1.3){};
-\node[node] (n6) at (3,-1.3){};
-\node[node] (n7) at (2.25,-2.4){};
-\node[node] (n8) at (3,1.3){};
-
-\draw[->,thick] (n1.0) -- (n2.180);
-\draw[->,thick] (n2.0) -- (n3.180);
-\draw[->,thick] (n3.0) -- (n4.180);
-\draw[->,thick,out=60,in=180] (n1.90) to (n8.180);
-\draw[->,thick,out=-10,in=90] (n8.0) to (n4.90);
-\draw[->,thick,out=90,in=-90] (n5.90) to (n3.-90);
-\draw[->,thick,out=90,in=-90] (n6.90) to (n4.-90);
-\draw[->,thick,out=90,in=-90] (n7.90) to (n5.-90);
-\draw[->,thick,out=90,in=-90] (n7.90) to (n6.-90);
-\node[font=\huge] (ht) at (-0.2,2.2){$\mathbi h_t$};
-
-\node[draw,font=\huge,inner sep=0pt,minimum width=4em,minimum height=4em,very thick,rounded corners=2pt] (ht-1) at (-3,0) {$\mathbi h_{t-1}$};
-\node[draw,font=\huge,inner sep=0pt,minimum width=4em,minimum height=4em,very thick,rounded corners=2pt] (ht+1) at (7.5,0) {$\mathbi h_{t+1}$};
-
-\node[font=\huge] (xt) at (2.25,-4.2){$x_t$};
-\node[font=\Huge]  at (9,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[]  (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,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] (box1.0) -- (ht+1.180);
-\draw[->,very thick] (ht-1.90) -- ([yshift=2em]ht-1.90);
-\draw[->,very thick] (ht+1.90) -- ([yshift=2em]ht+1.90);
-\draw[->,very thick] (box1.90) -- ([yshift=2em]box1.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);
-
-
-\end{tikzpicture}
-
-
-
-
--- a/Chapter15/chapter15.tex
+++ b/Chapter15/chapter15.tex
@@ -1037,7 +1037,7 @@ lr &=& d_{model}^{-0.5}\cdot step\_num^{-0.5}

 \parinterval 针对上述方法，也有以下问题：紧密的融合词串和句法结构的方法是否优于多任务学习的方法？以及，目标语言句法信息的引入是否真的帮助到了机器翻译？\upcite{DBLP:conf/wmt/NadejdeRSDJKB17}。 为了回答这些问题，研究人员尝试利用{\small\bfnew{CCG}}\index{CCG}（Combinatory Categorial Grammar）\index{Combinatory Categorial Grammar}中的supertags 作为句法信息，并发现CCG标签与句子进行融合更加有效。

-\parinterval 虽然，融合树结构和目标语言词串的方法有其优越性，但是这种方法会导致目标语言端的序列过长，导致模型难以训练。为了缓解这个问题，可以使用两个模型（如循环神经网络），一个生成句子，另一个生成树结构\upcite{DBLP:conf/acl/WuZYLZ17,DBLP:journals/corr/abs-1808-09374}。以生成目标语言依存树为例，生成依存树的模型仍然是一个移进-规约序列的生成模型，称为动作模型。另一个模型负责预测目标语言词序列，成为词预测模型。它只有在第一个模型进行进操作的时候才会预测一下词，同时会将当前词的状态作为信息送入到第一个模型中。整个过程如图\ref{fig:15-26}所示，这里使用循环神经网络构建了动作模型和词预测模型。$\mathbi{h}_i^\textrm{action}$ 表示动作模型的隐藏层状态，$\mathbi{h}_i^\textrm{word}$表示词预测模型的隐藏层状态。动作模型会结合词预测模型的状态预测出“移位”，“左规约”，“右规约”三种动作，只有当动作模型预测出“移位”操作时，词预测模型才会预测下一时刻的词语；而动作模型预测“左规约”和“右规约相当于完成了依存关系的预测（依存树见图\ref{fig:15-26}右侧）。最后词预测模型预测出结束符号<eos> 时，整个过程结束。
+\parinterval 虽然，融合树结构和目标语言词串的方法有其优越性，但是这种方法会导致目标语言端的序列过长，导致模型难以训练。为了缓解这个问题，可以使用两个模型（如循环神经网络），一个生成句子，另一个生成树结构\upcite{DBLP:conf/acl/WuZYLZ17,DBLP:journals/corr/abs-1808-09374}。以生成目标语言依存树为例，生成依存树的模型仍然是一个移进-规约序列的生成模型，称为动作模型。另一个模型负责预测目标语言词序列，成为词预测模型。它只有在第一个模型进行进操作的时候才会预测一下词，同时会将当前词的状态作为信息送入到第一个模型中。整个过程如图\ref{fig:15-26}所示，这里使用循环神经网络构建了动作模型和词预测模型。$\mathbi{h}_i^\textrm{action}$ 表示动作模型的隐藏层状态，$\mathbi{h}_i^\textrm{word}$表示词预测模型的隐藏层状态。动作模型会结合词预测模型的状态预测出“移位”，“左规约”，“右规约”三种动作，只有当动作模型预测出“移位”操作时，词预测模型才会预测下一时刻的词语；而动作模型预测“左规约”和“右规约”相当于完成了依存关系的预测（依存树见图\ref{fig:15-26}右侧）。最后词预测模型预测出结束符号<eos> 时，整个过程结束。

 %----------------------------------------------
 \begin{figure}[htp]
@@ -1087,9 +1087,9 @@ lr &=& d_{model}^{-0.5}\cdot step\_num^{-0.5}
 \end{figure}
 %-------------------------------------------

-\parinterval 于是，就诞生了网络结构搜索这个研究方向。早在上世纪八十年代，研究人员就开始使用进化算法对神经网络结构进行设计\upcite{DBLP:conf/icga/MillerTH89}，之后也有很多研究人员对基于进化算法的结构搜索进行了探索\upcite{mandischer1993representation,koza1991genetic,DBLP:conf/ijcnn/Dodd90,DBLP:conf/nips/HarpSG89,DBLP:journals/compsys/Kitano90,DBLP:conf/icec/SantosD94}（{\color{red} 这个地方可以少放几个参考文献}）。近些年，随着深度学习技术的发展，神经网络结构搜索这个方向也重新走进更多人的视线中，受到了来自计算机视觉、自然语言处理多个领域的关注与应用。
+\parinterval 于是，就诞生了网络结构搜索这个研究方向。早在上世纪八十年代，研究人员就开始使用进化算法对神经网络结构进行设计\upcite{DBLP:conf/icga/MillerTH89}，之后也有很多研究人员对基于进化算法的结构搜索进行了探索\upcite{koza1991genetic,DBLP:conf/nips/HarpSG89,DBLP:journals/compsys/Kitano90}。近些年，随着深度学习技术的发展，神经网络结构搜索这个方向也重新走进更多人的视线中，受到了来自计算机视觉、自然语言处理多个领域的关注与应用。

-\parinterval 目前网络结构搜索技术在很多任务中受到关注。例如，在WMT19国际机器翻译比赛中，有参赛单位使用了基于梯度的结构搜索方法改进翻译模型\upcite{DBLP:conf/nips/LuoTQCL18}。此外，在语言建模等任务中也大量应用了结构搜索技术，并取得了很好的结果\upcite{DBLP:conf/icml/PhamGZLD18,DBLP:conf/iclr/LiuSY19,DBLP:conf/acl/LiHZXJXZLL20,DBLP:conf/emnlp/JiangHXZZ19}。下面将对结构搜索的基本方法和其在机器翻译中的应用进行介绍。
+\parinterval 目前网络结构搜索技术在很多任务中受到关注。例如，在WMT19国际机器翻译比赛中，有参赛单位使用了基于梯度的结构搜索方法改进翻译模型\upcite{DBLP:conf/nips/LuoTQCL18}。此外，在语言建模等任务中也大量应用了结构搜索技术，并取得了很好的结果\upcite{DBLP:conf/iclr/LiuSY19,DBLP:conf/acl/LiHZXJXZLL20,DBLP:conf/emnlp/JiangHXZZ19}。下面将对结构搜索的基本方法和其在机器翻译中的应用进行介绍。

 %----------------------------------------------------------------------------------------
 %    NEW SUB-SECTION
@@ -1104,24 +1104,7 @@ lr &=& d_{model}^{-0.5}\cdot step\_num^{-0.5}
 \label{eq:15-54}
 \end{eqnarray}

-\noindent 其中，$\funp{P}(\mathbi{y}_{i}|\mathbi{x}_{i};a)$为模型$a$观察到数据$\mathbi{x}_{i}$后预测$\mathbi{y}_{i}$的概率，而模型结构$a$本身可以看作是输入$\mathbi{x}$到输出$\mathbi{y}$ 的映射函数。因此可以简单第把模型$a$看作根据$\mathbi{x}$预测$\mathbi{y}$的一个函数，记为：
-
-\begin{eqnarray}
-a(\mathbi{x}) &=& \funp{P}(\cdot|\mathbi{x})
-\label{eq:15-55}
-\end{eqnarray}
-
-\noindent 其中，$\funp{P}(\cdot|\mathbi{x})$表示在所有译文句子上的一个分布。图\ref{fig:15-29}展示了神经网络结构搜索方法的主要流程，主要包括三个部分：
-
-\begin{itemize}
-\vspace{0.5em}
-\item 设计搜索空间：理论上,网络结构搜索的搜索空间应由所有的潜在模型结构构成（图\ref{fig:15-29}）。在这种情况下，如果不对候选模型结构进行限制的话，搜索空间会十分庞大。因此，在实际的结构搜索过程中，往往会针对特定任务设计一个搜索空间，这个搜索空间是全体结构空间的一个子集，之后的搜索过程将在这个子空间中进行。如图\ref{fig:15-29}中的搜索空间所示，该空间由循环神经网络构成，其中候选的模型包括人工设计的LSTM、GRU等模型结构，也包括其他潜在的循环神经网络结构。
-\vspace{0.5em}
-\item 选择搜索策略：在设计好搜索空间之后，结构搜索的过程将选择一种合适的策略，对搜索空间进行探索。不同于模型参数的学习，模型结构本身不存在直接可计算的关联，所以很难通过传统的最优化算法对其进行学习。因此，搜索策略往往选择采用遗传算法或强化学习等方法，这些方法间接地对模型结构进行设计或优化\upcite{DBLP:conf/icml/SoLL19,DBLP:conf/aaai/RealAHL19,DBLP:conf/icml/RealMSSSTLK17,DBLP:conf/iclr/ElskenMH19,DBLP:conf/iclr/ZophL17,DBLP:conf/cvpr/ZophVSL18,DBLP:conf/icml/PhamGZLD18,DBLP:conf/iclr/BakerGNR17,DBLP:conf/cvpr/TanCPVSHL19,DBLP:conf/iclr/LiuSVFK18} （{\color{red} 参考文献太多了！}）。 不过近些年来也有研究人员开始尝试将模型结构建模为超网络中的参数，这样即可使用基于梯度的方式直接对最优结构进行搜索\upcite{DBLP:conf/nips/LuoTQCL18,DBLP:conf/iclr/LiuSY19,DBLP:conf/iclr/CaiZH19,DBLP:conf/cvpr/LiuCSAHY019,DBLP:conf/cvpr/WuDZWSWTVJK19,DBLP:conf/iclr/XieZLL19,DBLP:conf/uai/LiT19,DBLP:conf/cvpr/DongY19,DBLP:conf/iclr/XuX0CQ0X20,DBLP:conf/iclr/ZelaESMBH20,DBLP:conf/iclr/MeiLLJYYY20} （{\color{red} 参考文献太多了！}）。
-\vspace{0.5em}
-\item 进行性能评估：在搜索到模型结构之后需要对其性能进行验证，确定当前时刻模型结构的性能优劣。但是对于结构搜索任务来说，由于搜索过程中会产生大量的中间模型结构，如果直接对所有可能的结构进行评价，其时间代价是难以接受的。因此在结构搜索任务中也有很多研究人员尝试如何快速获取模型性能（绝对性能或相对性能）\upcite{DBLP:conf/nips/LuoTQCL18,DBLP:journals/jmlr/LiJDRT17,DBLP:conf/eccv/LiuZNSHLFYHM18}。
-\vspace{0.5em}
-\end{itemize}
+\noindent 其中，$\funp{P}(\mathbi{y}_{i}|\mathbi{x}_{i};a)$为模型$a$观察到数据$\mathbi{x}_{i}$后预测$\mathbi{y}_{i}$的概率，而模型结构$a$本身可以看作是输入$\mathbi{x}$到输出$\mathbi{y}$ 的映射函数。图\ref{fig:15-29}展示了神经网络结构搜索方法的主要流程，主要包括三个部分：设计搜索空间、选择搜索策略以及进行性能评估，下面将对上述各个部分进行介绍。

 %----------------------------------------------
 \begin{figure}[htp]
@@ -1132,79 +1115,47 @@ a(\mathbi{x}) &=& \funp{P}(\cdot|\mathbi{x})
 \end{figure}
 %-------------------------------------------

-\parinterval 下面将对网络结构搜索任务中搜索空间、搜索策略以及性能评估几个方向进行简单介绍。
-
 %----------------------------------------------------------------------------------------
 %    NEW SUBSUB-SECTION
 %----------------------------------------------------------------------------------------

 \subsubsection{1. 搜索空间}

-\parinterval 对搜索空间建模是结构搜索任务中的基础部分。如图\ref{fig:15-30}所示，结构空间中包含着所有潜在的模型结构，虽然可以假设这些模型结构都是等概率出现的，不过面对同一个任务时，这些模型就有了不同的性能表现。例如，卷积神经网络非常适合处理图像数据，而类似Transformer这类的模型结构在自然语言处理领域中更具优势。此外，由于不同网络结构之间往往存在局部结构的复用，因此在结构空间中不同结构的距离也不一致。
-
-\parinterval 如图\ref{fig:15-30}所示，基于自注意力机制的模型结构往往聚在一起，而基于循环神经网络和基于卷积神经网络的各类模型之间的距离也相对较近。因此，在研究人员设计搜索空间的时候，为了增加找到最优结构的可能性，往往会根据经验或者实验来确定当前任务下易产出高性能模型结构的区域，并将这个区域作为结构搜索任务中的搜索空间。以自然语言处理任务为例，最初的网络结构搜索工作主要对基于循环神经网络构成的搜索空间进行探索\upcite{DBLP:conf/iclr/ZophL17,DBLP:conf/icml/PhamGZLD18,DBLP:conf/iclr/LiuSY19}，而近些年，针对Transformer模型结构的研究工作也引起了研究人员的广泛关注\upcite{DBLP:conf/icml/SoLL19,DBLP:journals/taslp/FanTXQLL20,DBLP:conf/ijcai/ChenLQWLDDHLZ20,DBLP:conf/acl/WangWLCZGH20}。
+\parinterval 对搜索空间建模是结构搜索任务中的基础部分。如图\ref{fig:15-30}所示，结构空间中包含着所有潜在的模型结构，虽然可以假设这些模型结构都是等概率出现的，不过面对同一个任务时，这些模型就有了不同的性能表现。图\ref{fig:15-30}以结构之间的相似性为衡量指标对模型结构在搜索空间中的相对位置进行了刻画，同时颜色的深浅表示了该结构在指定任务下的性能情况。可以看到对于特定任务来说，性能较好的模型结构往往会聚集在一起。因此，在研究人员设计搜索空间的时候，为了增加找到最优结构的可能性，往往会根据经验或者实验将易产出高性能模型结构的区域设定为搜索空间。以自然语言处理任务为例，最初的网络结构搜索工作主要对基于循环神经网络构成的搜索空间进行探索\upcite{DBLP:conf/iclr/ZophL17,DBLP:conf/icml/PhamGZLD18,DBLP:conf/iclr/LiuSY19}，而近些年，针对Transformer模型结构的研究工作也引起了研究人员的广泛关注\upcite{DBLP:conf/icml/SoLL19,DBLP:conf/ijcai/ChenLQWLDDHLZ20,DBLP:conf/acl/WangWLCZGH20}。

 %----------------------------------------------
 \begin{figure}[htp]
 \centering
-\includegraphics[scale=0.6]{./Chapter15/Figures/figure-relationship-between-structures-in-structural-space.jpg}
+\includegraphics[scale=0.5]{./Chapter15/Figures/figure-relationship-between-structures-in-structural-space.jpg}
 \caption{结构空间内结构之间的关系}
 \label{fig:15-30}
 \end{figure}
 %-------------------------------------------

-\parinterval 设计搜索空间时另一个很重要的问题是如何表示一个网络结构。在目前的结构搜索方法中，通常将模型结构分为整体框架和内部结构（元结构）两部分。整体框架将若干内部结构的输出按照特定的方式组织起来，最终得到模型输出。如图\ref{fig:15-31}中循环神经网络模型结构，黄色部分即为内部结构，红色部分为整体框架。
-
-%----------------------------------------------
-\begin{figure}[htp]
-\centering
-\input{./Chapter15/Figures/figure-whole-structure-and-internal-structure-in-rnn}
-\caption{循环神经网络模型中的整体结构和内部结构}
-\label{fig:15-31}
-\end{figure}
-%-------------------------------------------
-
-\parinterval 具体来说，内部结构负责的是计算出$t$时刻的循环单元输出$\mathbi{h}_t$，如下所示：
-\begin{eqnarray}
-\mathbi{h}_t &=& \pi(\hat{\mathbi{h}}_{t-1},\hat{\mathbi{x}_t})
-\label{eq:15-56}
-\end{eqnarray}
-
-\noindent 其中，函数$\pi(\cdot)$表达的是结构表示中的内部结构。而循环单元之间的组织方式（即整体框架）决定了循环单元的输入信息，也就是上式中的循环单元表示$\hat{\mathbi{h}}_{t-1}$和输入表示$\hat{\mathbi{x}}_{t}$。理论上二者均能获得对应时刻之前所有的表示信息，因此可表示为：
-\begin{eqnarray}
-\hat{\mathbi{h}}_{t-1} &=& f(\mathbi{h}_{[0,t-1]};\mathbi{x}_{[1,t-1]}) \\
-\hat{\mathbi{x}_t} &=& g(\mathbi{x}_{[1,t]};\mathbi{h}_{[0,t-1]})
-\label{eq:15-58}
-\end{eqnarray}
-
-\noindent 其中$\mathbi{h}_{[0,t-1]} = \{\mathbi{h}_0,\ldots,\mathbi{h}_{t-1}\}$，$\mathbi{x}_{[1,t-1]} = \{\mathbi{x}_1,\ldots,\mathbi{x}_{t-1}\}$，函数$f(\cdot)$和$g(\cdot)$即为循环神经网络模型中的整体框架。
-
-\parinterval 可以看到，整体框架和内部结构共同组成了神经网络的模型结构。因此,在搜索过程中,确定了整体框架以及内部结构也就确定了搜索空间。
+\parinterval 设计搜索空间时另一个很重要的问题是如何表示一个网络结构。在目前的结构搜索方法中，通常将模型结构分为整体框架和内部结构（元结构）两部分。整体框架将若干内部结构的输出按照特定的方式组织起来，最终得到模型输出。

 \begin{itemize}
 \vspace{0.5em}
-\item 整体框架：如图\ref{fig:15-30}所示，在不同任务下，不同结构往往会有不同的建模能力，类似的结构在结构空间中相对集中。因此在搜索空间的设计中，根据不同的任务特点，整体框架会选择在该任务上已经得到验证的经验性结构，这能够更快速地定位到更有潜力的搜索空间。比如，对于图像任务来说，一般会将卷积神经网络设计为候选搜索空间\upcite{DBLP:conf/iclr/ElskenMH19,DBLP:conf/icml/PhamGZLD18,DBLP:conf/iclr/LiuSY19,DBLP:conf/eccv/LiuZNSHLFYHM18,DBLP:conf/icml/CaiYZHY18}，而对于包括机器翻译在内的自然语言处理任务而言，则会更倾向于使用循环神经网络或基于自注意力机制的Transformer模型附近的结构空间作为搜索空间\upcite{DBLP:conf/icml/SoLL19,DBLP:conf/iclr/ZophL17,DBLP:conf/icml/PhamGZLD18,DBLP:conf/iclr/LiuSY19,DBLP:journals/taslp/FanTXQLL20,DBLP:conf/ijcai/ChenLQWLDDHLZ20,DBLP:conf/acl/WangWLCZGH20}。 此外，也可以拓展搜索空间以覆盖更多结构\upcite{DBLP:conf/acl/LiHZXJXZLL20}。
+\item 整体框架：如图\ref{fig:15-30}所示，在不同任务下，不同结构往往会有不同的建模能力，类似的结构在结构空间中相对集中。因此在搜索空间的设计中，根据不同的任务特点，整体框架会选择在该任务上已经得到验证的经验性结构以更快速地定位到更有潜力的搜索空间。对于包括机器翻译在内的自然语言处理任务而言，一般会更倾向于使用循环神经网络或基于自注意力机制的Transformer模型附近的结构空间作为搜索空间\upcite{DBLP:conf/icml/SoLL19,DBLP:conf/iclr/ZophL17,DBLP:conf/iclr/LiuSY19}。 
 \vspace{0.5em}
-\item 	内部结构：由于算力限制，网络结构搜索任务通常使用经验性的架构作为模型的整体框架，之后对内部结构堆叠进而得到完整的模型结构。对于内部结构的设计需要考虑到搜索过程中的最小搜索单元，以及搜索单元之间的连接方式。最小搜索单元指的是在结构搜索过程中可被选择的最小独立计算单元（或被称为搜索算子），在不同搜索空间的设计中，最小搜索单元的颗粒度各有不同，较小的搜索粒度主要包括如矩阵乘法、张量缩放等基本数学运算\upcite{DBLP:journals/corr/abs-2003-03384}，更大粒度的搜索单元包括常见的激活函数，如ReLU、Tanh等\upcite{DBLP:conf/iclr/LiuSY19,DBLP:conf/acl/LiHZXJXZLL20,Chollet2017XceptionDL}，甚至搜索单元可以是一些模型的局部结构，如注意力模型、层标准化模型等\upcite{DBLP:conf/icml/SoLL19,DBLP:conf/nips/LuoTQCL18,DBLP:journals/taslp/FanTXQLL20}。不过，对于搜索颗粒度的问题，目前还缺乏有效的方法针对不同任务进行自动优化。
+\item 	内部结构：对于内部结构的设计需要考虑到搜索过程中的最小搜索单元，以及搜索单元之间的连接方式。最小搜索单元指的是在结构搜索过程中可被选择的最小独立计算单元，在不同搜索空间的设计中，最小搜索单元的颗粒度各有不同，较小的搜索粒度主要包括如矩阵乘法、张量缩放等基本数学运算\upcite{DBLP:journals/corr/abs-2003-03384}，更大粒度的搜索单元包括常见的激活函数以及一些局部结构，如ReLU、注意力机制等\upcite{DBLP:conf/acl/LiHZXJXZLL20,Chollet2017XceptionDL,DBLP:journals/taslp/FanTXQLL20}。不过，对于搜索颗粒度的问题，目前还缺乏有效的方法针对不同任务进行自动优化。
 \vspace{0.5em}
 \end{itemize}

-\parinterval 实际上，使用“整体+局部”的两层搜索空间表示模型的原因在于：结构搜索任务过于复杂，无法有效的遍历原始的搜索空间。如果存在足够高效的搜索策略，搜索空间的表示也可能会发生变化，比如，对任意的网络结构使用统一的表示方式。理论上讲，这样的搜索空间可以涵盖更多的潜在模型结构。
-
 %----------------------------------------------------------------------------------------
 %    NEW SUBSUB-SECTION
 %----------------------------------------------------------------------------------------

 \subsubsection{2. 搜索策略}

-\parinterval 在定义好搜索空间之后，如何进行网络结构的搜索也同样重要。该过程被称为搜索策略的设计，其主要目的是根据已找到的模型结构计算出下一个最有潜力的模型结构，为保证模型有效性，在一些方法中也会引入外部知识（如经验性的模型结构或张量运算规则）对搜索过程进行剪枝。目前常见的搜索策略一般包括基于进化算法、强化学习、贝叶斯优化、梯度的方法等方式，不同的搜索策略一般也和搜索空间中的结构建模方式相关。
+\parinterval 在定义好搜索空间之后，如何进行网络结构的搜索也同样重要。该过程被称为搜索策略的设计，其主要目的是根据已找到的模型结构计算出下一个最有潜力的模型结构，为保证模型有效性，在一些方法中也会引入外部知识（如经验性的模型结构或张量运算规则）对搜索过程进行剪枝。目前常见的搜索策略一般包括基于进化算法、强化学习、梯度的方法等方式。

 \begin{itemize}
 \vspace{0.5em}
-\item 进化算法：进化算法最初被用来对神经网络模型结构以及权重参数进行优化\upcite{DBLP:conf/icga/MillerTH89,DBLP:journals/tnn/AngelineSP94,stanley2002evolving,DBLP:journals/alife/StanleyDG09}。虽然随着最优化算法的发展，近年来，对于网络参数的学习更多地采用梯度下降法的方式，但是进化算法仍被用于对模型结构进行优化\upcite{DBLP:conf/aaai/RealAHL19,DBLP:conf/icml/RealMSSSTLK17,DBLP:conf/iclr/ElskenMH19,DBLP:conf/ijcai/SuganumaSN18,Real2019AgingEF,DBLP:conf/iclr/LiuSVFK18,DBLP:conf/iccv/XieY17}。 从结构优化的角度来说，一般是将模型结构看做遗传算法中种群的个体，使用轮盘赌或锦标赛等抽取方式，对种群中的结构进行取样作为亲本，之后通过亲本模型的突变产生新的模型结构，最终对这些新的模型结构进行适应度评估。根据模型结构在校验集上的性能确定是否将其加入种群。
+\item 进化算法：进化算法最初被用来对神经网络模型结构以及权重参数进行优化\upcite{DBLP:conf/icga/MillerTH89,DBLP:journals/tnn/AngelineSP94,stanley2002evolving}。虽然随着最优化算法的发展，近年来，对于网络参数的学习更多地采用梯度下降法的方式，但是进化算法仍被用于对模型结构进行优化\upcite{DBLP:conf/icml/RealMSSSTLK17,DBLP:conf/iclr/ElskenMH19,DBLP:conf/iclr/LiuSVFK18}。 从结构优化的角度来说，一般是将模型结构看做遗传算法中种群的个体，使用轮盘赌或锦标赛等抽取方式，对种群中的结构进行取样作为亲本，之后通过亲本模型的突变产生新的模型结构，最终对这些新的模型结构进行适应度评估。根据模型结构在校验集上的性能确定是否将其加入种群。

 \vspace{0.5em}
-\item 	强化学习：例如，将网络结构的设计看做是一种序列生成任务，使用字符序列对网络结构进行表述，通过使用强化学习训练的循环神经网络对该序列（目标任务网络结构）进行预测，从而为目标任务生成高效的网络结构\upcite{DBLP:conf/iclr/ZophL17}。基于强化学习的结构搜索方法过程如图\ref{fig:15-33}所示，其中智能体可以看做是一个用于生成模型结构的生成模型，该模型将产生智能体认为的最适用于当前任务的模型结构，强化学习中的动作在这里指的是由智能体产生一个模型结构，而环境对应着当前任务。当环境获得模型结构后，环境将输出当前任务下该模型的输出以及对输出结果的评价，二者分别对应强化学习中的状态和奖励，接下来这两个信息将反馈给智能体，让结构生成器更好地了解该状态下生成的模型结果，进而对结构生成的模式进行调整，然后生成更优的模型结构。对于基于强化学习的结构搜索策略来说，不同研究工作的差异主要集中在如何表示生成网络这个过程，以及如何对结构生成器进行优化\upcite{DBLP:conf/iclr/ZophL17,DBLP:conf/cvpr/ZophVSL18,DBLP:conf/iclr/BakerGNR17,DBLP:conf/cvpr/ZhongYWSL18}。{\red{（下图转录时，主体改成智能体）}}
+\item 	强化学习：例如，将网络结构的设计看做是一种序列生成任务，使用字符序列对网络结构进行表述，通过使用强化学习训练的循环神经网络对该序列（目标任务网络结构）进行预测，从而为目标任务生成高效的网络结构\upcite{DBLP:conf/iclr/ZophL17}。基于强化学习的结构搜索方法过程如图\ref{fig:15-33}所示。对于基于强化学习的结构搜索策略来说，不同研究工作的差异主要集中在如何表示生成网络这个过程，以及如何对结构生成器进行优化\upcite{DBLP:conf/iclr/ZophL17,DBLP:conf/cvpr/ZophVSL18,DBLP:conf/iclr/BakerGNR17}。

 %----------------------------------------------
 \begin{figure}[htp]
@@ -1216,7 +1167,7 @@ a(\mathbi{x}) &=& \funp{P}(\cdot|\mathbi{x})
 %-------------------------------------------

 \vspace{0.5em}
-\item 	梯度方法：在基于进化算法和强化学习的结构搜索策略中，往往将模型结构看作是离散空间中的若干点，搜索策略通过诸如“进化”或“激励”等方式促进种群或者结构生成器产生更好的模型结构。相对而言，这种方式并未直接对模型结构进行优化。不同于这些方法，有研究人员尝试在连续空间中对模型结构进行表示\upcite{DBLP:conf/iclr/LiuSY19}，这种方式将模型结构建模为超网络中的权重，使用基于梯度的最优化方法对权重进行优化，最终达到搜索结构的目的，如图\ref{fig:15-34}所示。相对进化算法以及强化学习方法而言，这种方式更加直接，在搜索过程中的算力消耗以及时间消耗上也更少，因此也吸引了很多研究人员对梯度方法进行不断探索\upcite{DBLP:conf/cvpr/WuDZWSWTVJK19,DBLP:conf/iclr/XuX0CQ0X20,DBLP:conf/acl/LiHZXJXZLL20,DBLP:conf/emnlp/JiangHXZZ19}。
+\item 	梯度方法：不同于强化学习以及进化算法的方法，有研究人员尝试在连续空间中对模型结构进行表示\upcite{DBLP:conf/iclr/LiuSY19}，这种方式将模型结构建模为超网络中的权重，使用基于梯度的最优化方法对权重进行优化，最终达到搜索结构的目的，如图\ref{fig:15-34}所示。基于梯度的方式在搜索过程中更加直接，在搜索过程中的算力消耗以及时间消耗上也更少，因此也吸引了很多研究人员对梯度方法进行不断探索\upcite{DBLP:conf/cvpr/WuDZWSWTVJK19,DBLP:conf/iclr/XuX0CQ0X20,DBLP:conf/acl/LiHZXJXZLL20}。
 \vspace{0.5em}

 %----------------------------------------------
@@ -1230,8 +1181,6 @@ a(\mathbi{x}) &=& \funp{P}(\cdot|\mathbi{x})

 \end{itemize}

-\parinterval 除了上述提到的基于进化算法、强化学习以及梯度的方法之外，还有很多其他的结构搜索策略，例如，基于贝叶斯优化的方法、基于随机搜索的方法。贝叶斯优化的方法在搜索结构超参数中表现优异，能够在给定模型结构的基础上找到最适用于当前任务的超参数\upcite{DBLP:conf/icml/BergstraYC13,DBLP:conf/ijcai/DomhanSH15,DBLP:conf/icml/MendozaKFSH16,DBLP:journals/corr/abs-1807-06906}，同时基于随机搜索的方法也在一些结构搜索任务中引起研究人员的注意\upcite{DBLP:conf/uai/LiT19,li2020automated,DBLP:conf/cvpr/BenderLCCCKL20}。
-
 %----------------------------------------------------------------------------------------
 %    NEW SUBSUB-SECTION
 %----------------------------------------------------------------------------------------
@@ -1242,11 +1191,11 @@ a(\mathbi{x}) &=& \funp{P}(\cdot|\mathbi{x})

 \begin{itemize}
 \vspace{0.5em}
-\item 数据以及超参数的调整：一种常见的方法是从数据和超参数的角度简化模型训练难度。具体来说，可采取的策略包括使用更少量、更容易建模的数据作为训练集合\upcite{DBLP:conf/aistats/KleinFBHH17,DBLP:journals/corr/ChrabaszczLH17}。比如，图像任务中，使用低分辨率数据对模型进行训练及评估。在自然语言处理任务中，可以选择更容易建模的口语领域数据进行实验。在超参数的调整方面，也可以通过减少模型训练轮数、减少模型的层数、减少每层中神经元数量等方式来简化模型参数，达到加速训练、评估的目的\upcite{DBLP:conf/cvpr/ZophVSL18,Real2019AgingEF,DBLP:journals/corr/abs-1807-06906}。上述两种方法虽然不能准确地评价模型的绝对性能，但是其结果已经能够对搜索起到一定指示作用，并帮助结构搜索策略对结构生成的过程进行调优。
+\item 数据以及超参数的调整：一种常见的方法是从数据和超参数的角度简化模型训练难度。具体来说，可采取的策略包括使用更少量、更容易建模的数据作为训练集合\upcite{DBLP:conf/aistats/KleinFBHH17,DBLP:journals/corr/ChrabaszczLH17}。比如，在自然语言处理任务中，可以选择更容易建模的口语领域数据进行实验。在超参数的调整方面，也可以通过减少模型训练轮数、减少模型的层数等方式来简化模型参数，达到加速训练、评估的目的\upcite{DBLP:conf/cvpr/ZophVSL18,Real2019AgingEF,DBLP:journals/corr/abs-1807-06906}。
 \vspace{0.5em}
-\item 现有参数的继承及复用：另一类方法希望从训练过程的角度出发，在现有的模型参数基础上，继续优化中间过程产生的模型结构，快速达到收敛状态后进行性能评估\upcite{DBLP:conf/icml/RealMSSSTLK17,DBLP:conf/iclr/ElskenMH19,DBLP:conf/icml/CaiYZHY18,DBLP:conf/aaai/CaiCZYW18,DBLP:conf/iclr/ElskenMH18}。这种方式无需从头训练中间结构，通过“热启动”的方式对模型参数进行优化，大幅减少性能评估过程的时间消耗。此外对于前文提到的基于梯度的结构搜索方法，由于将众多候选模型结构建模在同一个超网络中，因此在完成超网络的参数优化时，其子模型的模型参数也得到了优化，通过这种共享参数的方式也能够快速对网络结构的性能进行评估\upcite{DBLP:conf/icml/PhamGZLD18,DBLP:conf/iclr/XieZLL19,DBLP:conf/iclr/LiuSY19,DBLP:conf/iclr/CaiZH19,DBLP:conf/nips/SaxenaV16,DBLP:conf/icml/BenderKZVL18}。
+\item 现有参数的继承及复用：另一类方法希望从训练过程的角度出发，在现有的模型参数基础上，继续优化中间过程产生的模型结构，快速达到收敛状态后进行性能评估\upcite{DBLP:conf/icml/RealMSSSTLK17,DBLP:conf/iclr/ElskenMH19,DBLP:conf/aaai/CaiCZYW18}。这种方式无需从头训练中间结构，通过“热启动”的方式对模型参数进行优化，大幅减少性能评估过程的时间消耗。此外对于前文提到的基于梯度的结构搜索方法，其将搜索空间中的模型结构建模在同一个超网络中，其候选模型之间的参数相互共享，因此该方法也能够快速对网络结构的性能进行评估\upcite{DBLP:conf/icml/PhamGZLD18,DBLP:conf/iclr/LiuSY19,DBLP:conf/iclr/CaiZH19}。
 \vspace{0.5em}
-\item 模型性能的预测：从加速性能评估过程的角度来看，模型性能预测也是一个具有潜力的方法。这种方式使用训练过程中的性能变化曲线来预估模型是否具有潜力，从而快速终止低性能模型的训练过程，节约更多训练时间\upcite{DBLP:conf/ijcai/DomhanSH15,DBLP:conf/iclr/KleinFSH17,DBLP:conf/iclr/BakerGRN18}。除了根据性能变化曲线预测模型性能之外，也有研究人员根据局部结构的性能预测整体结构性能，这种方式也能更快速地了解结构搜索过程中中间结构的表示能力\upcite{DBLP:conf/eccv/LiuZNSHLFYHM18}。
+\item 模型性能的预测：从加速性能评估过程的角度来看，模型性能预测也是一个具有潜力的方法。这种方式使用训练过程中的性能变化曲线来预估模型是否具有潜力，从而快速终止低性能模型的训练过程，节约更多训练时间\upcite{DBLP:conf/ijcai/DomhanSH15,DBLP:conf/iclr/KleinFSH17,DBLP:conf/iclr/BakerGRN18}。
 \vspace{0.5em}
 \end{itemize}

@@ -1268,18 +1217,7 @@ a(\mathbi{x}) &=& \funp{P}(\cdot|\mathbi{x})

 \begin{itemize}
 \vspace{0.5em}
-\item 搜索模型中的局部结构：在机器翻译任务中，一种典型的局部模型结构搜索方法是面向激活函数的搜索\upcite{DBLP:conf/iclr/RamachandranZL18}。该方法将激活函数看作是简单函数的若干次复合使用，图\ref{fig:15-35}是激活函数结构的一个示例，其中核心单元由两个输入、两个一元函数（如绝对值、幂方运算等）和一个二元函数（如乘法、取最大值运算等）组成。
-
-%----------------------------------------------
-\begin{figure}[htp]
-\centering
-\input{./Chapter15/Figures/figure-activation-function-swish-structure-diagram}
-\caption{激活函数结构图}
-\label{fig:15-35}
-\end{figure}
-%-------------------------------------------
-
-\noindent 此外，还有方法将为深层神经网络找到更合适的激活函数作为搜索的目标\upcite{DBLP:conf/iclr/RamachandranZL18}，通过基于强化学习的搜索策略对激活函数空间进行探索，找到了若干新的激活函数，之后通过对这些激活函数在包括图像分类、机器翻译等任务上进行实验。例如，Swish激活函数就是一种被找到的新的激活函数，如下：
+\item 搜索模型中的局部结构：在机器翻译任务中，一种典型的局部模型结构搜索方法是面向激活函数的搜索\upcite{DBLP:conf/iclr/RamachandranZL18}，该方法将激活函数看作是简单一元、二元函数的若干次复合使用，在这种结构表示方式下，基于强化学习的搜索策略能够为深层神经网络设计出更适合的激活函数，之后通过对这些激活函数在对应任务上的实验来确定所搜索到的激活函数的有效性。例如，Swish激活函数就是一种被找到的新的激活函数，如下：
 \begin{eqnarray}
 f(x) &=& x \cdot \delta(\beta x) \\
 \delta(z) &=& {(1 + \exp{(-z)})}^{-1}
@@ -1290,16 +1228,7 @@ f(x) &=& x \cdot \delta(\beta x) \\
 \noindent 相比传统人工设计的激活函数ReLU而言，Swish函数在多个机器翻译的测试集上具有更优的性能表现，同时使用该函数不要求对原本的模型结构进行更多修改，非常容易实现。

 \vspace{0.5em}
-\item 搜索模型中局部结构的组合：在基于Transformer模型的网络结构搜索任务中，对于局部结构的组合方式的学习也受到了很多关注，其中包括基于进化算法的方法和基于梯度对现有Transformer模型结构进行改良的方法\upcite{DBLP:conf/icml/SoLL19,DBLP:journals/taslp/FanTXQLL20}。与前文所述的对局部结构的改良不同，此处更多地是对现有经验性的局部结构进行组合，找到最佳的整体结构。在模型结构的表示方法上，这些方法会根据先验知识为搜索单元设定一个部分框架，如每当信息传递过来之后先进行层标准化，之后再对候选位置上的操作使用对应的搜索策略进行搜索。另外这类方法也会在Transformer结构中引入多分支结构，一个搜索单元的输出可以被多个后续单元所使用，这种方式有效扩大了结构搜索过程中的搜索空间，能够在现有Transformer结构的基础上找到更优的模型结构。对模型中结构组合方式的学习如图\ref{fig:15-37}所示。
-
-%----------------------------------------------
-\begin{figure}[htp]
-\centering
-\input{./Chapter15/Figures/figure-learning-of-local-structure-combination}
-\caption{局部结构组合方式的学习}
-\label{fig:15-37}
-\end{figure}
-%-------------------------------------------
+\item 搜索模型中局部结构的组合：在基于Transformer模型的网络结构搜索任务中，对于局部结构的组合方式的学习也受到了很多关注，其中包括基于进化算法的方法和基于梯度对现有Transformer模型结构进行改良的方法\upcite{DBLP:conf/icml/SoLL19,DBLP:journals/taslp/FanTXQLL20}。与前文所述的对局部结构的改良不同，此处更多地是对现有经验性的局部结构进行组合，找到最佳的整体结构。在模型结构的表示方法上，这些方法会根据先验知识为搜索单元设定一个部分框架，如每当信息传递过来之后先进行层标准化，之后再对候选位置上的操作使用对应的搜索策略进行搜索。另外这类方法也会在Transformer结构中引入多分支结构，一个搜索单元的输出可以被多个后续单元所使用，这种方式有效扩大了结构搜索过程中的搜索空间，能够在现有Transformer结构的基础上找到更优的模型结构。

 \vspace{0.5em}
 \end{itemize}
@@ -1332,12 +1261,10 @@ f(x) &=& x \cdot \delta(\beta x) \\
 \sectionnewpage
 \section{小结及深入阅读}

-\parinterval 神经网络结构的设计一直是研究热点。本章节介绍了基于Transformer模型的结构优化工作，其中涉及了基于注意力机制的改进，网络连接优化，基于树结构的模型，以及神经网络结构的自动搜索。依靠自注意力机制的高并行化的计算特性，以及其全局建模能力，Transformer模型在各项自然语言处理任务中取得了优异的成绩。因此，该模型常被用来当作各项任务的基线模型。Transformer模型能够取得如此傲人的成绩，一定程度上受益于多头自注意力机制。多头机制可以让模型从更多维度的空间中提取相应的特征，与多分支思想有异曲同工之妙。研究人员针对编码端的多头进行分析，发现部分头在神经网络的学习过程中扮演至关重要的角色，并且蕴含语言学解释\upcite{DBLP:journals/corr/abs-1905-09418}。而另一部分头本身则不具备实质性的解释，可以通过剪枝的方式去除神经网络的冗余。然而在Transformer模型中，并不是头数越多，模型的性能就越强。{\red 一个有趣的发现是，在训练过程中利用多头，在推断过程中可以去除大部分头，性能没有明显变化，但却能够提高在CPU等串行计算单元的计算效率}\upcite{Michel2019AreSH}。
-
-\parinterval 为了进一步提高Transformer的性能，可以利用正则化训练手段,在训练过程中增大不同头之间的差异\upcite{DBLP:conf/emnlp/LiTYLZ18}。也可以通过多尺度的思想,对输入的特征进行分级表示，并引入短语的信息\upcite{DBLP:conf/emnlp/HaoWSZT19}。此外，在对自注意力网络中的注意力权重分布进行修改时，同样可以根据不同的缩放比例对序列中的实词与虚词进行区分\upcite{DBLP:conf/emnlp/Lin0RLS18}。除了上述基于编码端-解码端的建模范式，还可以定义隐变量模型来捕获句子中潜在的语义信息\upcite{Su2018VariationalRN,DBLP:conf/acl/SetiawanSNP20},或直接对源语言和目标语言进行联合的抽象表示\upcite{Li2020NeuralMT}。
+\parinterval 除了上述介绍的多分支网络，还可以通过多尺度的思想来对输入的特征表示进行分级表示，引入短语的信息\upcite{DBLP:conf/emnlp/HaoWSZT19}。此外，在对自注意力网络中的注意力权重分布进行修改时，同样可以根据不同的缩放比例对序列中的实词与虚词进行区分\upcite{DBLP:conf/emnlp/Lin0RLS18}。

-\parinterval Transformer的优越性能得益于自注意力机制与前馈神经网络的子层设计，同时残差连接{\red (引用)}与层正则化{\red (引用)}的引入让网络的训练变得更加稳定。此外，Transformer在训练过程中使用多种dropout来缓解过拟合问题\upcite{JMLR:v15:srivastava14a}，同时在计算交叉熵损失时，也可以使用标签平滑(Label Smoothing)来提高模型的泛化能力\upcite{Szegedy_2016_CVPR}。有研究人员综合了上述的技术并提出了RNMT模型\upcite{Chen2018TheBO}，即利用循环神经网络作为编码器和解码器，搭配上残差连接、层正则化、多头自注意力以及标签平滑等机制，构建了一个新模型。该模型能够取得与Transformer相媲美的性能，这也侧面反映了Transformer模型恰似一件艺术品，各个组件共同作用，缺一不可。
+\parinterval 高效地Transformer：针对处理长文本数据时面临庞大的时间复杂度问题，除了上述章节介绍的方法，研究人员通过简化网络的结构来构建更高效地Transformer结构\upcite{DBLP:journals/corr/abs-2004-05150,DBLP:journals/corr/abs-2006-04768,DBLP:journals/corr/abs-2009-14794}。

-\parinterval 针对处理长文本数据时面临的复杂度较高的问题，一种比较直接的方式是优化自注意力机制，将复杂度减少到O(N)，其中N代表输入序列的长度。例如采用基于滑动窗口的局部注意力的Longformer模型\upcite{DBLP:journals/corr/abs-2004-05150}，基于正向的正价随机特征的Performer\upcite{DBLP:journals/corr/abs-2006-04768},应用低秩分解重新设计注意力计算的Linformer\upcite{DBLP:journals/corr/abs-2009-14794}，应用星型拓扑排序的Star-Transformer模型(Star-Transformer)。
+\parinterval  ODE工作（图像）

-\parinterval 结构搜索技术是模型结构优化的一种方法，在近些年得到了愈加广泛的关注。其中搜索策略是衔接搜索空间和评价方法的关键步骤，在整个结构搜索方法中扮演着非常重要的角色，不同类型的搜索策略也决定了搜索过程能够在怎样的搜索空间中进行，以及性能评估如何帮助完成搜索等。除前文详细介绍的基于进化算法、强化学习以及基于梯度的方法外，基于贝叶斯优化以及随机搜索的方式同样能够有效地对搜索空间进行探索。贝叶斯优化的方式已经在超参数优化领域中取得一定成绩，而对于结构搜索任务来说，也有相关研究人员尝试使用基于树的模型来对模型结构以及超参数进行协同优化\upcite{DBLP:conf/nips/BergstraBBK11,DBLP:conf/lion/HutterHL11,DBLP:conf/icml/BergstraYC13,DBLP:conf/ijcai/DomhanSH15,DBLP:conf/icml/MendozaKFSH16,DBLP:journals/corr/abs-1807-06906}。随机搜索的方法在很多工作中被作为基线，这种方式在搜索空间中随机对搜索单元进行选择及操作，最终通过组合或进化等方式找到适用于当前任务的模型结构\upcite{li2020automated,DBLP:conf/cvpr/BenderLCCCKL20,DBLP:conf/uai/LiT19}。对于结构搜索任务来说如何提升目前搜索策略的稳定性\upcite{DBLP:conf/iccv/ChenXW019,DBLP:conf/icml/ChenH20,DBLP:conf/iclr/XuX0CQ0X20}，如何在更大的搜索空间\upcite{DBLP:conf/iclr/XieZLL19,DBLP:conf/acl/LiHZXJXZLL20,DBLP:conf/iclr/CaiZH19}、如何在更多的任务中进行搜索\upcite{DBLP:conf/emnlp/JiangHXZZ19,DBLP:conf/icml/SoLL19}等等，已经成为结构搜索方法中亟待解决的重要问题。
+\parinterval 结构搜索技术是模型结构优化的一种方法，在近些年愈加得到广泛的关注。其中搜索策略作为衔接搜索空间和评价方法的关键步骤，在整个结构搜索方法中扮演着非常重要的角色，不同类型的搜索策略也决定了搜索过程能够在怎样的搜索空间中进行、性能评估如何帮助完成搜索等。除前文详细介绍的基于进化算法、强化学习以及梯度的方法外，基于贝叶斯优化以及随机搜索的方式同样能够有效对搜索空间进行探索。贝叶斯优化的方式已经在超参数优化领域中取得一定成绩，而对于结构搜索任务来说，也有相关研究人员尝试使用基于树的模型来对模型结构以及超参数进行协同优化\upcite{DBLP:conf/nips/BergstraBBK11,DBLP:conf/icml/MendozaKFSH16,DBLP:journals/corr/abs-1807-06906}。随机搜索的方法在很多工作中被作为基线，这种方式在搜索空间中随机对搜索单元进行选择及操作，最终通过组合或进化等方式找到适用于于当前任务的模型结构\upcite{li2020automated,DBLP:conf/cvpr/BenderLCCCKL20,DBLP:conf/uai/LiT19}。对于结构搜索任务来说如何提升目前搜索策略的稳定性\upcite{DBLP:conf/iccv/ChenXW019,DBLP:conf/icml/ChenH20,DBLP:conf/iclr/XuX0CQ0X20}，如何在更大的搜索空间\upcite{DBLP:conf/iclr/XieZLL19,DBLP:conf/acl/LiHZXJXZLL20,DBLP:conf/iclr/CaiZH19}、更多的任务中进行搜索\upcite{DBLP:conf/emnlp/JiangHXZZ19,DBLP:conf/icml/SoLL19}等问题成为结构搜索方法中亟待解决的重要问题。
--- a/Chapter17/Figures/figure-an-end-to-end-voice-translation-model-based-on-transformer.tex
+++ b/Chapter17/Figures/figure-an-end-to-end-voice-translation-model-based-on-transformer.tex
@@ -18,9 +18,9 @@
 \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=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){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=-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)};
@@ -35,7 +35,7 @@
 \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_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]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);

--- a/Chapter17/Figures/figure-examples-of-CTC-predictive-word-sequences.tex
+++ b/Chapter17/Figures/figure-examples-of-CTC-predictive-word-sequences.tex
@@ -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] (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] (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] (w2.south west) -- (w2.south east);
@@ -24,7 +24,7 @@
 \draw[very thick] (w8.south west) -- (w8.south east);
 \draw[very thick] (w9.south west) -- (w9.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=2.64em,minimum height=1.4em,fill=gray!30] (m2) at ([yshift=-1em,xshift=0.72em]w2.south){{e}};
@@ -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=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=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] (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] (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] (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]w8.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 @@
 \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] (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] (a3) at  ([yshift=-1.8em]a2.south) {合并重复字母 \\ 并丢弃$\epsilon$};

--- a/Chapter17/Figures/figure-framing-schematic.tex
+++ b/Chapter17/Figures/figure-framing-schematic.tex
@@ -12,5 +12,5 @@
 \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.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}
\ No newline at end of file
--- a/Chapter17/Figures/figure-speech-recognition-model-based-on-transformer.tex
+++ b/Chapter17/Figures/figure-speech-recognition-model-based-on-transformer.tex
@@ -18,9 +18,9 @@
 \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=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=-1.1em]de_add.south){Transcription\\(Embedding)};

 \node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){Position\\(Embedding)};
@@ -35,7 +35,7 @@
 \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_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]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);

--- a/Chapter17/Figures/figure-speech-translation-model-based-on-CTC.tex
+++ b/Chapter17/Figures/figure-speech-translation-model-based-on-CTC.tex
@@ -20,9 +20,9 @@
 \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=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){ST Output};
+%\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){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){Target Text\\(Embedding)};

 \node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){Position\\(Embedding)};
@@ -39,7 +39,7 @@
 \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]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]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);

--- a/Chapter17/Figures/figure-three-ways-of-dual-decoder-speech-translation.tex
+++ b/Chapter17/Figures/figure-three-ways-of-dual-decoder-speech-translation.tex
@@ -6,9 +6,9 @@
 \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_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(x)[above of = decoder_1,yshift=1.8cm,scale=1.6]{$x$};
-\node(y)[above of = decoder_2,yshift=1.8cm,scale=1.6]{$y$};
+\node(s)[below of = encoder,yshift=-1.8cm,scale=1.2]{$s$};
+\node(x)[above of = decoder_1,yshift=1.8cm,scale=1.2]{$x$};
+\node(y)[above of = decoder_2,yshift=1.8cm,scale=1.2]{$y$};

 \draw[->,thick](s.north)to(encoder.south);
 \draw[->,thick](decoder_1.north)to(x.south);
@@ -22,8 +22,8 @@
 \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_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(y-2)[above of = decoder_2-2,yshift=1.8cm,scale=1.6]{$y$};
+\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.2]{$y$};

 \draw[->,thick](s-2.north)to(encoder-2.south);
 \draw[->,thick](encoder-2.north)to(decoder_1-2.south);
@@ -34,8 +34,8 @@
 \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_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(y-3)[above of = decoder_2-3,yshift=1.8cm,scale=1.6]{$y$};
+\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.2]{$y$};

 \draw[->,thick](s-3.north)to(encoder-3.south);
 \draw[->,thick](decoder_1-3.east)to(decoder_2-3.west);

--- a/Chapter17/Figures/figure-word-lattice.tex
+++ b/Chapter17/Figures/figure-word-lattice.tex
@@ -16,25 +16,25 @@
 \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.60) -- node[word,above,rotate=40]{a /0.499}(n1.-150);
-\draw[->] (n0.-50) -- node[word,above,rotate=-20]{their /0.116}(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.042} (n4.180);
-\draw[->] (n4.0) .. node[word,above,xshift=-2em,yshift=-0.4em]{hospital /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.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[->] (n0.0) -- node[word,above]{for /0.227}(n2.180);
+\draw[->] (n0.60) -- node[word,above,rotate=40]{a /0.628}(n1.-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]{this /0.042} (n4.180);
+\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]{movie /0.127}(n7.180);
+\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[->] (n2.0) -- node[word,above,pos=0.5]{hospital /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[->,rounded corners=1em] (n1.-45) node[word,above,xshift=1.4em,yshift=-1.3em,rotate=-43]{house /0.079} -- ([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[->] (n11.0) -- node[word,above]{conference /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.0) node[word, above,xshift=1.4em]{as /0.227}.. controls ([xshift=2.6em]n5.0) and ([xshift=-0.6em,yshift=2em]n6.120) .. (n6.120);
+\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]{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]{book /1}(n5.180);
+\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.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);
-\draw[->] (n1.60) .. controls ([xshift=3em,yshift=2em]n1.60) and ([xshift=-2em]a) .. (a) node[word,above,xshift=1em]{hospital /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[->] (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}
\ No newline at end of file
--- a/Chapter17/chapter17.tex
+++ b/Chapter17/chapter17.tex
@@ -54,7 +54,7 @@
 %----------------------------------------------------------------------------------------
 \section{语音翻译}

-\parinterval 语音，是人类日常生活与交流中最常用的一种信息载体。从日常聊天、国际旅游，到国际会议、跨国合作，对于语言进行翻译的需求不断增加。甚至在有些场景下，用语音进行交互要比用文本进行交互频繁的多。因此，{\small\bfnew{语音翻译}}\index{语音翻译}（Speech Translation）\index{Speech Translation}也成为了语音处理和机器翻译相结合的重要产物。根据目标语言的载体类型，可以将语音翻译分为{\small\bfnew{语音到文本翻译}}\index{语音到文本翻译}（Speech-to-Text Translation）\index{Speech-to-Text Translation}和{\small\bfnew{语音到语音翻译}}（Speech-to-Speech Translation）\index{Speech-to-Speech Translation}；基于翻译的实时性，还可以分为{\small\bfnew{实时语音翻译}}\index{实时语音翻译}（即同声传译，Simultaneous Translation）\index{Simultaneous Translation}和{\small\bfnew{离线语音翻译}}（Offline speech translation）\index{Offline speech translation}。本节主要关注离线语音到文本翻译方法（简称为语音翻译），分别从音频处理、级联语音翻译和端到端语音翻译进行介绍。
+\parinterval 语音，是人类日常生活与交流中最常用的一种信息载体。从日常聊天、国际旅游，到国际会议、跨国合作，对于语言进行翻译的需求不断增加。甚至在有些场景下，用语音进行交互要比用文本进行交互频繁的多。因此，{\small\bfnew{语音翻译}}\index{语音翻译}（Speech Translation）\index{Speech Translation}也成为了语音处理和机器翻译相结合的重要产物。根据目标语言的载体类型，可以将语音翻译分为{\small\bfnew{语音到文本翻译}}\index{语音到文本翻译}（Speech-to-Text Translation）\index{Speech-to-Text Translation}和{\small\bfnew{语音到语音翻译}}\index{语音到语音翻译}（Speech-to-Speech Translation）\index{Speech-to-Speech Translation}；基于翻译的实时性，还可以分为{\small\bfnew{实时语音翻译}}\index{实时语音翻译}（即同声传译，Simultaneous Translation）\index{Simultaneous Translation}和{\small\bfnew{离线语音翻译}}（Offline Speech Translation）\index{离线语音翻译}\index{Offline Speech Translation}。本节主要关注离线语音到文本翻译方法（简称为语音翻译），分别从音频处理、级联语音翻译和端到端语音翻译进行介绍。

 %----------------------------------------------------------------------------------------
 %    NEW SUB-SECTION
@@ -62,7 +62,7 @@

 \subsection{音频处理}

-\parinterval 不同于文本，音频本质上是经过若干信号处理之后的{\small\bfnew{波形}}（Waveform）\index{Waveform}。具体来说，声音是一种空气的震动，因此可以被转换为模拟信号。模拟信号是一段连续的信号，经过采样变为离散数字信号。采样是每隔固定的时间记录一下声音的振幅，采样率表示每秒的采样点数，单位是赫兹（Hz）。采样率越高，结果的损失则越小。通常来说，采样的标准是能够通过离散化的数字信号重现原始语音。我们日常生活中使用的手机和电脑设备的采样率一般为16kHz，表示每秒16000个采样点；而音频CD的采样率可以达到44.1kHz。经过进一步的量化，将采样点的值转换为整型数值保存，从而减少占用的存储空间，通常采用的是16位量化。将采样率和量化位数相乘，就可以得到{\small\bfnew{比特率}}\index{比特率}（Bits Per Second，BPS）\index{Bits Per Second}，表示音频每秒占用的位数。16kHz采样率和16位量化的音频，比特率为256kb/s。整体流程如图\ref{fig:17-2}所示\upcite{洪青阳2020语音识别原理与应用,陈果果2020语音识别实战}。
+\parinterval 不同于文本，音频本质上是经过若干信号处理之后的{\small\bfnew{波形}}（Waveform）\index{Waveform}。具体来说，声音是一种空气的震动，因此可以被转换为模拟信号。模拟信号是一段连续的信号，经过采样变为离散数字信号。采样是每隔固定的时间记录一下声音的振幅，采样率表示每秒的采样点数，单位是赫兹（Hz）。采样率越高，结果的损失则越小。通常来说，采样的标准是能够通过离散化的数字信号重现原始语音。我们日常生活中使用的手机和电脑设备的采样率一般为16kHz，表示每秒16000个采样点；而音频CD的采样率可以达到44.1kHz。经过进一步的量化，将采样点的值转换为整型数值保存，从而减少占用的存储空间，通常采用的是16位量化。将采样率和量化位数相乘，就可以得到{\small\bfnew{比特率}}\index{比特率}（Bits Per Second，BPS）\index{Bits Per Second}，表示音频每秒占用的位数。例如，16kHz采样率和16位量化的音频，比特率为256kb/s。整体流程如图\ref{fig:17-2}所示\upcite{洪青阳2020语音识别原理与应用,陈果果2020语音识别实战}。

 %----------------------------------------------------------------------------------------------------
 \begin{figure}[htp]
@@ -73,9 +73,9 @@
 \end{figure}
 %----------------------------------------------------------------------------------------------------

-\parinterval 经过上面的描述，音频的表示实际上是一个非常长的采样点序列，这导致了直接使用现有的深度学习技术处理音频序列较为困难。并且，原始的音频信号中可能包含着较多的噪声、环境声或冗余信息也会对模型产生干扰。因此，一般会对音频序列进行处理来提取声学特征，具体为将长序列的采样点序列转换为短序列的特征向量序列，再用于下游系统模块。虽然已有一些工作不依赖特征提取，直接在原始的采样点序列上进行声学建模和模型训练\upcite{DBLP:conf/interspeech/SainathWSWV15}，但目前的主流方法仍然是基于声学特征进行建模\upcite{DBLP:conf/icassp/MohamedHP12}。
+\parinterval 经过上面的描述可以看出，音频的表示实际上是一个非常长的采样点序列，这导致了直接使用现有的深度学习技术处理音频序列较为困难。并且，原始的音频信号中可能包含着较多的噪声、环境声或冗余信息，也会对模型产生干扰。因此，一般会对音频序列进行处理来提取声学特征，具体为将长序列的采样点序列转换为短序列的特征向量序列，再用于下游系统模块。虽然已有一些工作不依赖特征提取，直接在原始的采样点序列上进行声学建模和模型训练\upcite{DBLP:conf/interspeech/SainathWSWV15}，但目前的主流方法仍然是基于声学特征进行建模\upcite{DBLP:conf/icassp/MohamedHP12}。

-\parinterval 声学特征提取的第一步是预处理。其流程主要是对音频进行预加重、分帧和加窗。预加重用来提升音频信号中的高频部分，目的是使频谱更加平滑。分帧（原理如图\ref{fig:17-3}）是基于短时平稳假设，即根据生物学特征，语音信号是一个缓慢变化的过程，10ms~30ms的信号片段是相对平稳的。基于这个假设，一般将每25ms作为一帧来提取特征，这个时间称为{\small\bfnew{帧长}}\index{帧长}（Frame Length）\index{Frame Length}。同时，为了保证不同帧之间的信号平滑性，使每两个相邻帧之间存在一定的重合部分。一般每隔10ms取一帧，这个时长称为{\small\bfnew{帧移}}\index{帧移}（Frame Shift）\index{Frame Shift}。为了缓解分帧带来的频谱泄漏，对每帧的信号进行加窗处理使其幅度在两段渐变到0，一般采用的是{\small\bfnew{汉明窗}}\index{汉明窗}（Hamming）\index{Hamming}。
+\parinterval 声学特征提取的第一步是预处理。其流程主要是对音频进行预加重、分帧和加窗。预加重用来提升音频信号中的高频部分，目的是使频谱更加平滑。分帧（原理如图\ref{fig:17-3}）是基于短时平稳假设，即根据生物学特征，语音信号是一个缓慢变化的过程，10ms$\thicksim$30ms的信号片段是相对平稳的。基于这个假设，一般将每25ms作为一帧来提取特征，这个时间称为{\small\bfnew{帧长}}\index{帧长}（Frame Length）\index{Frame Length}。同时，为了保证不同帧之间的信号平滑性，使每两个相邻帧之间存在一定的重合部分。一般每隔10ms取一帧，这个时长称为{\small\bfnew{帧移}}\index{帧移}（Frame Shift）\index{Frame Shift}。为了缓解分帧带来的频谱泄漏，对每帧的信号进行加窗处理使其幅度在两段渐变到0，一般采用的是{\small\bfnew{汉明窗}}\index{汉明窗}（Hamming）\index{Hamming}。
 %----------------------------------------------------------------------------------------------------
 \begin{figure}[htp]
 \centering
@@ -110,7 +110,7 @@

 \parinterval 传统的语音识别模型和统计机器翻译相似，需要利用声学模型、语言模型和发音词典联合进行识别，系统较为复杂\upcite{DBLP:journals/ftsig/GalesY07,DBLP:journals/taslp/MohamedDH12,DBLP:journals/spm/X12a}。而近些年来，随着神经网络的发展，基于神经网络的端到端语音识别模型逐渐成为主流，大大简化了训练流程\upcite{DBLP:conf/nips/ChorowskiBSCB15,DBLP:conf/icassp/ChanJLV16}。目前的端到端语音识别模型主要基于序列到序列结构，编码器根据输入的声学特征进一步提取高级特征，解码器根据编码器提取的特征识别对应的文本。在后文中即将介绍的端到端语音翻译模型也是使用十分相似的结构。因此，从某种意义上说，语音识别和翻译的端到端方法与神经机器翻译是一致的。

-\parinterval 语音识别目前广泛使用基于Transformer的模型结构（见{\chaptertwelve}），如图\ref{fig:17-5}所示。可以看出，相比文本翻译，模型结构上唯一的区别在于编码器的输入为声学特征，以及编码器底层会使用额外的卷积层来减小输入序列的长度，从而降低长序列带来的显存占用以及建模困难。通过大量的语音-标注平行数据对模型进行训练，可以得到高质量的语音识别模型。
+\parinterval 语音识别目前广泛使用基于Transformer的模型结构（见{\chaptertwelve}），如图\ref{fig:17-5}所示。可以看出，相比文本翻译，模型结构上唯一的区别在于编码器的输入为声学特征，以及编码器底层会使用额外的卷积层来减小输入序列的长度，从而降低长序列带来的显存占用以及建模困难。由于语音对应的特征序列过长，在计算Attention的时候，会占用大量的内存/显存，从而降低计算效率，过长的序列也会增加模型训练的难度。因此，通常会先对语音特征做一个下采样，缩小语音的序列长度。目前一个常用的做法，是在输入的语音特征上进行两层步长为2的卷积操作，从而将输入序列的长度缩小为之前的1/4。通过大量的语音-标注平行数据对模型进行训练，可以得到高质量的语音识别模型。

 %----------------------------------------------------------------------------------------------------
 \begin{figure}[htp]
@@ -151,7 +151,7 @@
    \vspace{0.5em}
    \item 翻译效率问题。由于需要语音识别模型和文本标注模型只能串行地计算，翻译效率相对较低，而实际很多场景中都需要达到低延时的翻译。
    \vspace{0.5em}
-    \item 语音中的副语言信息丢失。将语音识别为文本的过程中，语音中包含的语气、情感、音调等信息会丢失，而同一句话在不同的语气中表达的意思很可能是不同的，导致翻译出现偏差。
+    \item 语音中的副语言信息丢失。将语音识别为文本的过程中，语音中包含的语气、情感、音调等信息会丢失，而同一句话在不同的语气中表达的意思很可能是不同的，导致翻译出现偏差。尤其是在实际使用时，由于ASR的识别结果通常并不包含标点，还需要额外的后处理模型将标点还原，也会带来额外的计算代价。
    \vspace{0.5em}
 \end{itemize}
 %----------------------------------------------------------------------------------------------------
@@ -170,7 +170,7 @@
 \end{itemize}
 %----------------------------------------------------------------------------------------------------

-\parinterval 因此，端到端模型收到了研究人员的关注。目前比较火热的，基于Transformer的语音翻译模型架构如图\ref{fig:17-7}所示（下文中语音翻译模型均指端到端的模型）。该模型采用的也是序列到序列架构，编码器的输入是从语音中提取的特征（比如FBank特征）。由于语音对应的特征序列过长，在计算Attention的时候，会占用大量的内存/显存，从而降低计算效率，过长的序列也会增加模型训练的难度。因此，通常会先对语音特征做一个下采样，缩小语音的序列长度。目前一个常用的做法，是在输入的语音特征上进行两层步长为2的卷积操作，从而将输入序列的长度缩小为之前的1/4。之后的流程和标准的机器翻译是完全一致的，编码器对语音特征进行编码，解码器根据编码表示生成目标语言的翻译结果。
+\parinterval 因此，端到端模型收到了研究人员的关注。目前比较火热的，基于Transformer的语音翻译模型架构如图\ref{fig:17-7}所示（下文中语音翻译模型均指端到端的模型）。该模型采用的也是序列到序列架构，编码器的输入是从语音中提取的特征（比如FBank特征）。编码器底层采用和ASR模型相同的卷积结构来降低序列的长度。之后的流程和标准的机器翻译是完全一致的，编码器对语音特征进行编码，解码器根据编码表示生成目标语言的翻译结果。

 %----------------------------------------------------------------------------------------------------
 \begin{figure}[htp]
@@ -214,7 +214,7 @@
 %----------------------------------------------------------------------------------------------------
 \begin{itemize}
    \vspace{0.5em}
-    \item 输入输出之间的对齐是单调的。也就是后面的输入只会预测与前面的序列相同或后面的输出内容。比如对于上面的例子，如果输入的位置t已经预测了字符r，那么t之后的位置不会再预测前面的字符w和o。
+    \item 输入输出之间的对齐是单调的。也就是后面的输入只会预测与前面的序列相同或后面的输出内容。比如对于上面的例子，如果输入的位置t已经预测了字符l，那么t之后的位置不会再预测前面的字符h和e。
    \vspace{0.5em}
    \item 输入和输出之间是多对一的关系。也就是多个输入会对应到同一个输出上。这对于语音序列来说是非常自然的一件事情，由于输入的每个位置只包含非常短的语音特征，因此多个输入才可以对应到一个输出字符。
    \vspace{0.5em}
@@ -677,6 +677,8 @@ D_i&\subseteq&\{X_{-i},Y_{-i}\} \label{eq:17-3-2}

 \parinterval 本章仅对音频处理和语音识别进行了简单的介绍，具体内容可以参考一些经典书籍，比如关于信号处理的基础知识\upcite{Oppenheim2001DiscretetimeSP,Quatieri2001DiscreteTimeSS}，以及语音识别的传统方法\upcite{DBLP:books/daglib/0071550,Huang2001SpokenLP}和基于深度学习的最新方法\upcite{benesty2008automatic}。此外，语音翻译的一个重要应用是机器同声传译。

+\parinterval 同声传译是指在说话人陈述过程中，实时输出语音对应的文本翻译结果。在演讲、会议、聊天等场景，同声传译可以极大地提高交流效率。同声传译主要的难点在于不同语言的句法顺序不同。比如，“普京７月在赫尔辛基与特朗普会晤”这句话对应的翻译结果为“Putin meets Trump in Helsinki in July”，只有当最后一个词“会晤”说出来时，翻译结果中的第二个词“meets”才能够被正确翻译。这个问题导致了同声传译模型需要在翻译性能和实时性之间进行取舍。目前，同声传译的一种思路是基于目前已经说出的语音进行翻译\upcite{DBLP:conf/acl/MaHXZLZZHLLWW19}，一种方式是设定固定等待源语K个词语，然后再进行翻译，同时改进束搜索方式来预测未来的词序列，从而提升准确度\upcite{DBLP:conf/emnlp/ZhengMZH19}。另一种方式是对当前语音进行翻译，但需要判断翻译的词是否能够作为最终结果。如果是则不需要重新解码，可以将确定的词作为之后解码端的输入，否则将会根据之后的语音重新进行解码\upcite{DBLP:conf/naacl/DalviDSV18,DBLP:journals/corr/ChoE16}。第二种思路是动态预测当前时刻是应该继续等待还是开始翻译，这种方式更符合人类进行同传的思路。但是这种策略的难点在于标注每一时刻的决策状态十分耗时且标准难以统一，目前主流的方式是利用强化学习方法\upcite{DBLP:conf/eacl/NeubigCGL17,DBLP:conf/emnlp/GrissomHBMD14}，对句子进行不同决策方案采样，最终学到最优的决策方案。此外，还有一些工作设计不同的学习策略\upcite{DBLP:conf/acl/ZhengLZMLH20,DBLP:conf/emnlp/ZhengZMH19,DBLP:conf/acl/ZhengZMH19}或改进注意力机制\upcite{DBLP:conf/acl/ArivazhaganCMCY19}以提升同声传译的性能。
+
 \parinterval 在篇章级翻译方面，一些研究工作对这类模型的上下文建模能力进行了探索\upcite{DBLP:conf/discomt/KimTN19,DBLP:conf/acl/LiLWJXZLL20}，发现模型性能在小数据集上的BLEU提升并不完全来自于上下文信息的利用。同时，受限于数据规模，篇章级翻译模型相对难以训练。一些研究人员通过调整训练策略来帮助模型更容易捕获上下文信息\upcite{DBLP:journals/corr/abs-1903-04715,DBLP:conf/acl/SaundersSB20,DBLP:conf/mtsummit/StojanovskiF19}。除了训练策略的调整，也可以使用数据增强\upcite{DBLP:conf/discomt/SugiyamaY19}和预训练\upcite{DBLP:journals/corr/abs-1911-03110,DBLP:journals/tacl/LiuGGLEGLZ20}的手段来缓解数据稀缺的问题。此外，区别于传统的篇章级翻译，一些对话翻译也需要使用长距离上下文信息\upcite{DBLP:conf/wmt/MarufMH18}。

 \parinterval 最近，多模态机器翻译、图像描述、视觉问答\upcite{DBLP:conf/iccv/AntolALMBZP15}（Visual Question Answering）等多模态任务受到人工智能领域的广泛关注。如何将多个模态的信息充分融合，是研究多模态任务的重要问题。在自然语言处理领域transformer\upcite{vaswani2017attention}框架的提出后，被应用到计算机视觉\upcite{DBLP:conf/eccv/CarionMSUKZ20}、多模态任务\upcite{DBLP:conf/acl/YaoW20,DBLP:journals/tcsv/YuLYH20,Huasong2020SelfAdaptiveNM}效果也有显著的提升。另外，数据稀缺是多模态任务受限之处，可以采取数据增强\upcite{DBLP:conf/emnlp/GokhaleBBY20,DBLP:conf/eccv/Tang0ZWY20}的方式缓解。但是，这时仍需要回答在：模型没有充分训练时，图像等模态信息究竟在翻译里发挥了多少作用？类似的问题在篇章级机器翻译中也存在，上下文模型在训练数据量很小的时候对翻译的作用十分微弱（引用李北ACL）。因此，也有必要探究究竟图像等上下文信息如何可以更有效地发挥作用。此外，受到预训练模型的启发，在多模态领域，图像和文本联合预训练\upcite{DBLP:conf/eccv/Li0LZHZWH0WCG20,DBLP:conf/aaai/ZhouPZHCG20,DBLP:conf/iclr/SuZCLLWD20}的工作也相继开展，利用transformer框架，通过自注意力机制捕捉图像和文本的隐藏对齐，提升模型性能，同时缓解数据稀缺问题。

--- a/Chapter7/Figures/figure-basic-process-of-translation.tex
+++ b/Chapter7/Figures/figure-basic-process-of-translation.tex
@@ -11,7 +11,7 @@

 \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}


@@ -29,7 +29,7 @@
 \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}


@@ -50,7 +50,7 @@
 \node[anchor=west,fill=red!20] (t2) at ([xshift=1em]t1.east) {\footnotesize{an apple}};
 \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}


@@ -76,6 +76,6 @@
 \node[anchor=west,fill=red!20] (t3) at ([xshift=1em]t2.east) {\footnotesize{on the table}};
 \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{tikzpicture}
\ No newline at end of file
--- a/Chapter7/Figures/figure-word-and-phrase-translation-regard-as-path.tex
+++ b/Chapter7/Figures/figure-word-and-phrase-translation-regard-as-path.tex
@@ -7,7 +7,7 @@
 \node [anchor=west] (s1) at (0,0) {\textbf{我}};
 \node [anchor=west] (s2) at ([xshift=2em]s1.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=south west] (sentlabel) at ([yshift=-0.5em]s1.north west) {\scriptsize{\textbf{待翻译句子（已经分词）：}}};

--- a/Chapter7/Figures/figure-word-translation-regard-as-path.tex
+++ b/Chapter7/Figures/figure-word-translation-regard-as-path.tex
@@ -7,7 +7,7 @@
 \node [anchor=west] (s1) at (0,0) {\textbf{我}};
 \node [anchor=west] (s2) at ([xshift=2em]s1.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=south west] (sentlabel) at ([yshift=-0.5em]s1.north west) {\scriptsize{\textbf{待翻译句子（已经分词）：}}};

--- a/Chapter7/chapter7.tex
+++ b/Chapter7/chapter7.tex
@@ -23,7 +23,7 @@

 \chapter{基于短语的模型}

-\parinterval 机器翻译的一个基本问题是要定义翻译的基本单元是什么。比如，可以像{\chapterfive}介绍的那样，以单词为单位进行翻译，即把句子的翻译看作是单词之间对应关系的一种组合。基于单词的模型是符合人类对翻译问题的认知的，因为单词本身就是人类加工语言的一种基本单元。另一方面，在进行翻译时也可以使用一些更“复杂”的知识。比如，很多词语间的搭配需要根据语境的变化进行调整，而且对于句子结构的翻译往往需要更上层的知识，如句法知识。因此，在对单词翻译进行建模的基础上，需要探索其他类型的翻译知识，使得搭配和结构翻译等问题可以更好地被建模。
+\parinterval 机器翻译的一个基本问题是要定义翻译的基本单元是什么。比如，可以像{\chapterfive}介绍的那样，以单词为单位进行翻译，即把句子的翻译看作是单词之间对应关系的一种组合。基于单词的模型是符合人类对翻译问题的认知的，因为单词本身就是人类加工语言的一种基本单元。然而，在进行翻译时也可以使用一些更“复杂”的知识。比如，很多词语间的搭配需要根据语境的变化进行调整，而且对于句子结构的翻译往往需要更上层的知识，如句法知识。因此，在对单词翻译进行建模的基础上，需要探索其他类型的翻译知识，使得搭配和结构翻译等问题可以更好地被建模。

 \parinterval 本章会介绍基于短语的机器翻译模型。在过去二十年中，它一直是机器翻译的主流方法。相比于基于单词的模型，基于短语的模型可以更好地对单词之间搭配和小范围依赖关系进行描述。这种方法也在相当长的一段时期内占据着机器翻译的统治地位。即使近些年神经机器翻译逐渐崛起，基于短语的模型仍然是机器翻译的主要框架之一，其中的思想和很多技术手段对今天的机器翻译研究仍然有很好的借鉴意义。

@@ -159,12 +159,12 @@
 \end{definition}
 %-------------------------------------------

-\parinterval 比如，对于一个句子，“机器/翻译/是/一/项/很有/挑战/的/问题”，一种可能的短语切分为：
+\parinterval 比如，对于一个句子，“机器/翻译/是/一/项/很有/挑战/的/任务”，一种可能的短语切分为：
 \begin{eqnarray}
 p_1 &=& \text{机器}/\text{翻译} \nonumber \\
 p_2 &=& \text{是}/\text{一}/\text{项} \nonumber \\
 p_3 &=& \text{很有}/\text{挑战}/\text{的} \nonumber \\
-p_4 &=& \text{问题}\nonumber
+p_4 &=& \text{任务}\nonumber
 \end{eqnarray}

 \parinterval 进一步，把单语短语的概念推广到双语的情况：
@@ -174,16 +174,17 @@ p_4 &=& \text{问题}\nonumber
 \begin{definition} 双语短语（或短语对）

 {\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}
 %-------------------------------------------

-\parinterval 也就是说，源语言句子中任意的短语和目标语言句子中任意的短语都构成一个双语短语。这里用$\leftrightarrow$表示互译关系。对于一个双语句对“进口/大幅度/下降/了 $\leftrightarrow$ the imports have drastically fallen”，可以得到很多双语短语，比如：
+\parinterval 也就是说，源语言句子中任意的短语和目标语言句子中任意的短语都构成一个双语短语。这里用$\leftrightarrow$表示互译关系。对于一个双语句对“牛肉的/进口/大幅度/下降/了 $\leftrightarrow$ the import of beef has drastically fallen”，可以得到很多双语短语，比如：
 \begin{eqnarray}
 &&\text{大幅度}\ \leftrightarrow\ \textrm{drastically} \nonumber \\
-&&\text{大幅度}/\text{下降}\ \leftrightarrow\ \textrm{have}\ \textrm{drastically}\ \textrm{fallen} \nonumber \\
-&&\text{进口}/\text{大幅度}\ \leftrightarrow\ \textrm{imports}\ \textrm{have}\ \textrm{drastically} \nonumber \\
+&&\text{大幅度}/\text{下降}\ \leftrightarrow\ \textrm{has}\ \textrm{drastically}\ \textrm{fallen} \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{了}\ \leftrightarrow\ \textrm{have}\ \textrm{drastically} \nonumber \\
 &&... \nonumber
@@ -221,7 +222,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
 \end{figure}
 %-------------------------------------------

-\parinterval 到此为止，就得到了一个基于短语的翻译模型。对于每个双语句对$(\seq{s}, \seq{t})$，每个翻译推导$d$都对应了一个基于短语的翻译过程。而基于短语的机器翻译的目标就是对$d$进行描述。有四个基本问题：
+\parinterval 到此为止，就得到了一个基于短语的翻译模型。对于每个双语句对$(\seq{s}, \seq{t})$，每个翻译推导$d$都对应了一个基于短语的翻译过程。而基于短语的机器翻译的目标就是对$d$进行描述。为了实现基于短语的翻译模型，有四个基本问题需要解决：

 \begin{itemize}
 \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)

 \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}
 \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}
@@ -341,7 +342,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
 \subsection{判别式模型中的特征}


-\parinterval 判别式模型最大的好处在于它可以更灵活地引入特征。某种意义上，每个特征都是在描述翻译的某方面属性。在各种统计分类模型中，也大量使用了“特征”这个概念（见{\chapterthree}）。比如，要判别一篇新闻是体育方面的还是文化方面的，可以设计一个分类器，用词作为特征。这个分类器就会根据有能力区分“体育”和“文化”两个类别的特征，最终决定这篇文章属于哪个类别。统计机器翻译也在做类似的事情。系统研发者可以通过设计翻译相关的特征，来区分不同翻译结果的好坏。翻译模型会综合这些特征对所有可能的译文进行打分和排序，并选择得分最高的译文输出。
+\parinterval 判别式模型最大的好处在于它可以更灵活地引入特征。某种意义上，每个特征都是在描述翻译的某方面属性。在各种统计分类模型中，也大量使用了“特征”这个概念（见{\chapterthree}）。比如，要判别一篇新闻是体育方面的还是文化方面的，可以设计一个分类器，用词作为特征。这个分类器就会有能力区分“体育”和“文化”两个类别的特征，最终决定这篇文章属于哪个类别。统计机器翻译也在做类似的事情。系统研发者可以通过设计翻译相关的特征，来区分不同翻译结果的好坏。翻译模型会综合这些特征对所有可能的译文进行打分和排序，并选择得分最高的译文输出。

 \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)

 在基于短语的翻译模型中，通常包含三类特征：短语翻译特征、调序特征、语言模型相关的特征。这些特征都需要从训练数据中学习。

-\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]
@@ -423,7 +424,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
 \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]
@@ -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 下面来看一个具体的例子，如图\ref{fig:7-17}所示。对于一个双语短语，将它们的词对齐关系代入到上面的公式就会得到短语的词汇翻译概率。对于词汇翻译概率，可以使用IBM 模型中的单词翻译表，也可以通过统计获得\upcite{koehn2002learning}。如果一个单词的词对齐为空，则用$N$表示它翻译为空的概率。和短语翻译概率一样，可以使用双向的词汇化翻译概率来评价双语短语的好坏。
+\parinterval 下面来看一个具体的例子，如图\ref{fig:7-17}所示。对于一个双语短语，将它们的词对齐关系代入到公式\eqref{eq:7-14}就会得到短语的词汇翻译概率。对于词汇翻译概率，可以使用IBM 模型中的单词翻译表，也可以通过统计获得\upcite{koehn2002learning}。如果一个单词的词对齐为空，则用$N$表示它翻译为空的概率。和短语翻译概率一样，可以使用双向的词汇化翻译概率来评价双语短语的好坏。

 %----------------------------------------------
 \begin{figure}[htp]
@@ -704,7 +705,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1

 \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$的线性函数：
 \begin{eqnarray}
@@ -743,7 +744,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
 \vspace{0.5em}
 \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
@@ -779,7 +780,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
 \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
@@ -804,7 +805,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1

 \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”。扩展完之后需要记录输入句子中已翻译的短语，同时计算当前所有翻译假设的模型得分。这个过程相当于生成了一个图的结构，每个节点代表了一个翻译假设。当翻译假设覆盖了输入句子所有的短语，不能被继续扩展时，就生成了一个完整的翻译假设（译文）。最后需要找到得分最高的完整翻译假设，它对应了搜索图中的最优路径。

@@ -876,7 +877,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
 \vspace{0.5em}
 \end{itemize}

-所以最好的情况是尽早删除质量差的翻译假设，同时又不会对整个搜索结果产生过大影响。但是这个“质量”从哪个方面来衡量，也是一个需要思考的问题。理想的情况就是从早期的翻译假设中，挑选一些可比的翻译假设进行筛选。
+所以最好的情况是尽早删除质量差的翻译假设，这样就不会对整个搜索结果产生过大影响。但是这个“质量”从哪个方面来衡量，也是一个需要思考的问题。理想的情况就是从早期的翻译假设中，挑选一些可比的翻译假设进行筛选。

 \parinterval 目前比较通用的做法是将翻译假设进行整理，放进一种栈结构中。这里所说的“栈”是为了描述方便的一种说法。它实际上就是保存多个翻译假设的一种数据结构\footnote[4]{虽然被称作栈，实际上使用一个堆进行实现。这样可以根据模型得分对翻译假设进行排序。}。当放入栈的翻译假设超过一定阈值时（比如200），可以删除掉模型得分低的翻译假设。一般，会使用多个栈来保存翻译假设，每个栈代表覆盖源语言单词数量相同的翻译假设。

@@ -912,7 +913,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
 \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}。
 \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}
 \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}

--- a/Chapter8/Figures/figure-cky-algorithm.tex
+++ b/Chapter8/Figures/figure-cky-algorithm.tex
@@ -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[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）}}};



--- a/Chapter8/Figures/figure-execution-of-cube-pruning.tex
+++ b/Chapter8/Figures/figure-execution-of-cube-pruning.tex
@@ -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=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}

 %图2
@@ -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=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}

 %图3
@@ -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=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}


@@ -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=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}



--- a/Chapter8/Figures/figure-one-best-node-alignment-and-alignment-matrix.tex
+++ b/Chapter8/Figures/figure-one-best-node-alignment-and-alignment-matrix.tex
@@ -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=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 (2,-2) {{\color{white} \small{.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,-5) {{\color{white} \small{.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,-2) {{\color{white} \small{.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=1.0, inner sep=1pt, minimum size=12pt] at (4,-2) {{\color{white} \small{.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.7, inner sep=1pt, minimum size=12pt] at (5,-5) {{\color{white} \small{.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.9, inner sep=1pt, minimum size=12pt] at (5,-4) {{\color{white} \small{.7}}};
+\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} \footnotesize{0.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} \footnotesize{0.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} \footnotesize{0.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} \footnotesize{0.1}}};
+\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} \footnotesize{0.2}}};
+\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} \footnotesize{0.3}}};
+\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,-7.2) {Matrix 2: 对齐概率};

--- a/Chapter8/Figures/figure-tree-cutting-defined-by-edge-nodes.tex
+++ b/Chapter8/Figures/figure-tree-cutting-defined-by-edge-nodes.tex
@@ -27,21 +27,21 @@
 \begin{pgfonlayer}{background}

 {
-\node [rectangle,fill=blue!20,inner sep=0] [fit = (n11)] (n11box) {};
-\node [rectangle,fill=red!20,inner sep=0] [fit = (n4)] (n4box) {};
-\node [rectangle,fill=red!20,inner sep=0] [fit = (n1)] (n1box) {};
-\node [rectangle,fill=red!20,inner sep=0] [fit = (n2)] (n2box) {};
-\node [rectangle,fill=red!20,inner sep=0] [fit = (n3)] (n3box) {};
-\node [rectangle,fill=red!20,inner sep=0] [fit = (n5)] (n5box) {};
-\node [rectangle,fill=red!20,inner sep=0] [fit = (n6)] (n6box) {};
-\node [rectangle,fill=red!20,inner sep=0] [fit = (n7)] (n7box) {};
-\node [rectangle,fill=red!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 = (n10)] (n10box) {};
-
-\node [anchor=north west, minimum size=1.2em, fill=red!20] (land1) at ([xshift=7.0em,yshift=0em]n1.north east) {};
+\node [rectangle,fill=red!20,inner sep=0] [fit = (n11)] (n11box) {};
+\node [rectangle,fill=blue!20,inner sep=0] [fit = (n4)] (n4box) {};
+\node [rectangle,fill=blue!20,inner sep=0] [fit = (n1)] (n1box) {};
+\node [rectangle,fill=blue!20,inner sep=0] [fit = (n2)] (n2box) {};
+\node [rectangle,fill=blue!20,inner sep=0] [fit = (n3)] (n3box) {};
+\node [rectangle,fill=blue!20,inner sep=0] [fit = (n5)] (n5box) {};
+\node [rectangle,fill=blue!20,inner sep=0] [fit = (n6)] (n6box) {};
+\node [rectangle,fill=blue!20,inner sep=0] [fit = (n7)] (n7box) {};
+\node [rectangle,fill=blue!20,inner sep=0] [fit = (n8)] (n8box) {};
+\node [rectangle,fill=blue!20,inner sep=0] [fit = (n9)] (n9box) {};
+\node [rectangle,fill=red!20,inner sep=0] [fit = (n10)] (n10box) {};
+
+\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=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{不可信}};
 }

@@ -54,6 +54,8 @@
 \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=north](pos1) at ([xshift=-1.0em,yshift=-1.0em]tw4.south){\small{（a）标有可信节点信息的句法树}};
+
 \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] (cw3.south) -- ([yshift=-0.4em]tw5.north);
@@ -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] (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] (cfrag2.south) -- ([yshift=-0.4em]tw14.north);
 \draw[dashed] (cfrag3.south) -- ([yshift=-0.4em]tw15.north);

--- a/Chapter8/chapter8.tex
+++ b/Chapter8/chapter8.tex
@@ -25,7 +25,7 @@

 人类的语言是具有结构的，这种结构往往体现在句子的句法信息上。比如，人们进行翻译时会将待翻译句子的主干确定下来，之后得到译文的主干，最后形成完整的译文。一个人学习外语时，也会先学习外语句子的基本构成，比如，主语、谓语等，之后用这种句子结构知识生成外语句子。

-使用句法分析可以很好地处理翻译中的结构调序、远距离依赖等问题。因此，基于句法的机器翻译模型长期受到研究者关注。比如，早期基于规则的方法里就大量使用了句法信息来定义翻译规则。进入统计机器翻译时代，句法信息的使用同样是领域主要研究方向之一。这也产生了很多基于句法的机器翻译模型及方法，而且在很多任务上取得非常出色的结果。本章将对这些模型和方法进行介绍，内容涉及机器翻译中句法信息的表示、基于句法的翻译建模、句法翻译规则的学习等。
+使用句法分析可以很好地处理翻译中的结构调序、远距离依赖等问题。因此，基于句法的机器翻译模型长期受到研究者关注。比如，早期基于规则的方法里就大量使用了句法信息来定义翻译规则。进入统计机器翻译时代，句法信息的使用同样是主要研究方向之一。这也产生了很多基于句法的机器翻译模型及方法，而且在很多任务上取得非常出色的结果。本章将对这些模型和方法进行介绍，内容涉及机器翻译中句法信息的表示、基于句法的翻译建模、句法翻译规则的学习等。

 %----------------------------------------------------------------------------------------
 %    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
 \end{figure}
 %-------------------------------------------

-\parinterval 图\ref{fig:8-7}展示了一个层次短语抽取的示意图。可以看到，在获取一个“ 大”短语的基础上（红色），直接在其内部挖掉另一个“小”短语（绿色），这样就生成了一个层次短语规则。
+\parinterval 图\ref{fig:8-7}展示了一个通过双语短语抽取层次短语的示意图。可以看到，在获取一个“ 大”短语的基础上（红色），直接在其内部抽取得到另一个“小”短语（绿色），这样就生成了一个层次短语规则。

 \parinterval 这种方式可以抽取出大量的层次短语规则。但是，不加限制的抽取会带来规则集合的过度膨胀，对解码系统造成很大负担。比如，如果考虑任意长度的短语会使得层次短语规则过大，一方面这些规则很难在测试数据上被匹配，另一方面抽取这样的“长”规则会使得抽取算法变慢，而且规则数量猛增之后难以存储。还有，如果一个层次短语规则中含有过多的变量，也会导致解码算法变得更加复杂，不利于系统实现和调试。针对这些问题，在标准的层次短语系统中会考虑一些限制\upcite{chiang2007hierarchical}，包括：

@@ -504,7 +504,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q

 \parinterval 图\ref{fig:8-10}展示了CKY方法的一个运行实例（输入词串是aabbc）。算法在处理完最后一个跨度后会得到覆盖整个词串的分析结果，即句法树的根结点S。

-\parinterval 不过，CKY方法并不能直接用于层次短语模型。有两个问题：
+\parinterval 不过，CKY方法并不能直接用于层次短语模型，主要有两个问题：

 \begin{itemize}
 \vspace{0.5em}
@@ -571,7 +571,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
 \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)$这三个新的翻译假设。之后，计算出它们的模型得分，并压入优先队列。这个过程不断被执行，直到达到终止条件，比如，扩展次数达到一个上限。

@@ -595,7 +595,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
 \sectionnewpage
 \section{基于语言学句法的模型}\label{section-8.3}

-\parinterval 层次短语模型是一种典型的基于翻译文法的模型。它把翻译问题转化为语言分析问题。在翻译一个句子的时候，模型会生成一个树形结构，这样也就得到了句子结构的层次化表示。图\ref{fig:8-14}展示了一个使用层次短语系统进行翻译时所生成的翻译推导$d$，以及这个推导所对应的树形结构（源语言）。这棵树体现了机器翻译的视角下的句子结构，尽管这个结构并不是人类语言学中的句法树。
+\parinterval 层次短语模型是一种典型的基于翻译文法的模型。它把翻译问题转化为语言分析问题。在翻译一个句子的时候，模型会生成一个树形结构，这样也就得到了句子结构的层次化表示。图\ref{fig:8-14}展示了一个使用层次短语模型进行翻译时所生成的翻译推导$d$，以及这个推导所对应的树形结构（源语言）。这棵树体现了机器翻译的视角下的句子结构，尽管这个结构并不是人类语言学中的句法树。

 %----------------------------------------------
 \begin{figure}[htp]
@@ -617,7 +617,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
 \vspace{0.5em}
 \end{itemize}

-\parinterval 实际上，基于层次短语的方法可以被看作是介于基于短语的方法和基于语言学句法的方法之间的一种折中。它的优点在于，短语模型简单且灵活，同时，由于同步翻译文法可以对句子的层次结构进行表示，因此也能够处理一些较长距离的调序问题。但是，另一方面，层次短语模型并不是一种“精细”的句法模型，当翻译需要复杂的结构信息时，这种模型可能会无能为力。
+\parinterval 实际上，基于层次短语的方法可以被看作是介于基于短语的方法和基于语言学句法的方法之间的一种折中。它的优点在于，短语模型简单且灵活，同时，由于同步翻译文法可以对句子的层次结构进行表示，因此也能够处理一些较长距离的调序问题。但是，层次短语模型并不是一种“精细”的句法模型，当翻译需要复杂的结构信息时，这种模型可能会无能为力。

 %----------------------------------------------
 \begin{figure}[htp]
@@ -1174,7 +1174,7 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex

 \parinterval 然后，从这个短语出发向上搜索，找到覆盖这个短语的最小树片段，之后生成规则即可。在这个例子中可以得到SPMT规则：
 \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}

 \parinterval 而这条规则需要组合三条最小规则才能得到，但是在SPMT中可以直接得到。相比规则组合的方法，SPMT方法可以更有效地抽取包含短语的规则。
@@ -1279,7 +1279,7 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex
 \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

--- a/bibliography.bib
+++ b/bibliography.bib