updates of section 4

Book/Chapter4/Figures/combination-of-translation-with-different-rules.tex

@@ -7,7 +7,7 @@
 \node[anchor=north] (q1) at (0,0) {\scriptsize\sffamily\bfseries{输入字符串：}};
 \node[anchor=north] (q1) at (0,0) {\scriptsize\sffamily\bfseries{输入字符串：}};
 \node[anchor=west] (q2) at ([xshift=0em,yshift=-2em]q1.west) {\footnotesize{进口$\quad$和$\quad$出口$\quad$大幅度$\quad$下降$\quad$了}};
 \node[anchor=west] (q2) at ([xshift=0em,yshift=-2em]q1.west) {\footnotesize{进口$\quad$和$\quad$出口$\quad$大幅度$\quad$下降$\quad$了}};
 
 
-\node[anchor=north,fill=blue!20,minimum height=1em,minimum width=1em] (f1) at ([xshift=-4.1em,yshift=-0.8em]q2.south) {};
+%\node[anchor=north,fill=blue!20,minimum height=1em,minimum width=1em] (f1) at ([xshift=-4.1em,yshift=-0.8em]q2.south) {};
 
 
 \node[anchor=north,fill=blue!20,minimum height=4em,minimum width=1em] (f1) at ([xshift=2.2em,yshift=-0.7em]q2.south) {};
 \node[anchor=north,fill=blue!20,minimum height=4em,minimum width=1em] (f1) at ([xshift=2.2em,yshift=-0.7em]q2.south) {};
 
 

Book/Chapter4/Figures/extract-hierarchical-phrase-rules.tex

@@ -67,11 +67,11 @@
 \draw[-] (rules.south west)--([xshift=1.9in]rules.south west);
 \draw[-] (rules.south west)--([xshift=1.9in]rules.south west);
 
 
 {
 {
-\node[anchor=north west] (p1) at ([yshift=-0.3em]phrase.south west) {天气真好 -- The weather is very good};
+\node[anchor=north west] (p1) at ([yshift=-0.3em]phrase.south west) {天气\ \ 真好 -- The weather is very good};
 }
 }
 
 
 {
 {
-\node[anchor=north west] (r1) at ([yshift=-0.3em]rules.south west) {$\mathrm{X_1}$真好 -- $\mathrm{X_1}$ is very good};
+\node[anchor=north west] (r1) at ([yshift=-0.3em]rules.south west) {$\mathrm{X_1}$\ \ 真好 -- $\mathrm{X_1}$ is very good};
 
 
 \node[anchor=east] (r2) at ([yshift=-2.65cm]p1.east) {};
 \node[anchor=east] (r2) at ([yshift=-2.65cm]p1.east) {};
 }
 }

Book/Chapter4/chapter4.tex

@@ -636,7 +636,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \label{eqa4.18}
 \label{eqa4.18}
 \end{eqnarray}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
 %公式--------------------------------------------------------------------
- 
+
 \noindent 其中\textrm{Error}$(\cdot)$是错误率函数。\textrm{Error}$(\cdot)$的定义方式有很多，一般来说\textrm{Error}$(\cdot)$会与机器翻译的评价指标相关，例如，词错误率(WER)、位置错误率(PER)、BLEU 值、NIST值等都可以用于\textrm{Error}$(\cdot)$的定义。这里使用1-BLEU作为错误率函数，即$\textrm{Error}(\textbf{D}^{\ast},\textbf{R}) = 1 - \textrm{BLEU}(\textbf{D}^{\ast},\textbf{R})$。则公式\ref{eqa4.18}可改写为：
 \noindent 其中\textrm{Error}$(\cdot)$是错误率函数。\textrm{Error}$(\cdot)$的定义方式有很多，一般来说\textrm{Error}$(\cdot)$会与机器翻译的评价指标相关，例如，词错误率(WER)、位置错误率(PER)、BLEU 值、NIST值等都可以用于\textrm{Error}$(\cdot)$的定义。这里使用1-BLEU作为错误率函数，即$\textrm{Error}(\textbf{D}^{\ast},\textbf{R}) = 1 - \textrm{BLEU}(\textbf{D}^{\ast},\textbf{R})$。则公式\ref{eqa4.18}可改写为：
 %公式--------------------------------------------------------------------
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
 \begin{eqnarray}
@@ -844,7 +844,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \qquad \textrm{{\small\bfnew{我}}\ \ 在\ \ 今天\ \ 早上\ \ 没有\ \ 吃\ \ 早\ \ 饭\ \ 的\ \ 情况\ \ 下\ \ 还是\ \ 正常\ \ {\small\bfnew{去}}\ \ {\small\bfnew{上班}}\ \ 了。} \nonumber
 \qquad \textrm{{\small\bfnew{我}}\ \ 在\ \ 今天\ \ 早上\ \ 没有\ \ 吃\ \ 早\ \ 饭\ \ 的\ \ 情况\ \ 下\ \ 还是\ \ 正常\ \ {\small\bfnew{去}}\ \ {\small\bfnew{上班}}\ \ 了。} \nonumber
 \end{eqnarray}
 \end{eqnarray}
 
 
-\parinterval 这句话的主语``我''和谓语``去 上班''构成了主谓搭配，而二者之间的部分是状语。显然，用短语去捕捉这个搭配需要覆盖很长的词串，也就是整个``我 $...$ 去 上班''的部分。如果把这样的短语考虑到建模中，会面临非常严重的数据稀疏问题，因为无法保证这么长的词串在训练数据中能够出现。实际上，随着短语长度变长，短语在数据中会变得越来越低频，相关的统计特征也会越来越不可靠。表\ref{tab:trainingdata-phrase-frequency}就展示了不同长度的短语在训练数据中出现的频次。可以看到，长度超过3的短语已经非常低频了，更长的短语甚至在训练数据中一次也没有出现过。
+\parinterval 这句话的主语``我''和谓语``去\ 上班''构成了主谓搭配，而二者之间的部分是状语。显然，用短语去捕捉这个搭配需要覆盖很长的词串，也就是整个``我 $...$ 去 上班''的部分。如果把这样的短语考虑到建模中，会面临非常严重的数据稀疏问题，因为无法保证这么长的词串在训练数据中能够出现。实际上，随着短语长度变长，短语在数据中会变得越来越低频，相关的统计特征也会越来越不可靠。表\ref{tab:trainingdata-phrase-frequency}就展示了不同长度的短语在训练数据中出现的频次。可以看到，长度超过3的短语已经非常低频了，更长的短语甚至在训练数据中一次也没有出现过。
 
 
 %----------------------------------------------
 %----------------------------------------------
 % 表4.1
 % 表4.1
@@ -869,7 +869,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 
 
 \parinterval 显然，利用过长的短语来处理长距离的依赖并不是一种十分有效的方法。过于低频的长短语无法提供可靠的信息，而且使用长短语会导致模型体积急剧增加。
 \parinterval 显然，利用过长的短语来处理长距离的依赖并不是一种十分有效的方法。过于低频的长短语无法提供可靠的信息，而且使用长短语会导致模型体积急剧增加。
 
 
-\parinterval 再来看一个翻译实例\cite{Chiang2012Hope}。图\ref{fig:an-example-of-phrase-system}是一个基于短语的机器翻译系统的翻译结果。这个例子中的调序有一些复杂，比如，``少数 国家 之一''和``与 北韩 有 邦交''的英文翻译都需要进行调序，分别是``one of the few countries''和``have diplomatic relations with North Korea''。基于短语的系统可以很好的处理这些调序问题，因为它们仅仅使用了局部的信息。但是，系统却无法在这两个短语（1和2）之间进行正确的调序。
+\parinterval 再来看一个翻译实例\cite{Chiang2012Hope}。图\ref{fig:an-example-of-phrase-system}是一个基于短语的机器翻译系统的翻译结果。这个例子中的调序有一些复杂，比如，``少数\ 国家\ 之一''和``与\ 北韩\ 有\ 邦交''的英文翻译都需要进行调序，分别是``one of the few countries''和``have diplomatic relations with North Korea''。基于短语的系统可以很好的处理这些调序问题，因为它们仅仅使用了局部的信息。但是，系统却无法在这两个短语（1和2）之间进行正确的调序。
 
 
 %----------------------------------------------
 %----------------------------------------------
 % 图4.31
 % 图4.31
@@ -881,7 +881,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \end{figure}
 \end{figure}
 %-------------------------------------------
 %-------------------------------------------
 
 
-\parinterval 这个例子也在一定程度上说明了长距离的调序需要额外的机制才能得到更好的被处理。实际上，1和2之间的调序现象本身对应了一种结构，或者说模板。也就是汉语中的：
+\parinterval 这个例子也在一定程度上说明了长距离的调序需要额外的机制才能得到更好的被处理。实际上，两个短语（1和2）之间的调序现象本身对应了一种结构，或者说模板。也就是汉语中的：
 \begin{eqnarray}
 \begin{eqnarray}
 \text{与}\ \ \text{[什么东西]}\ \ \text{有}\ \ \text{[什么事]} \quad \nonumber
 \text{与}\ \ \text{[什么东西]}\ \ \text{有}\ \ \text{[什么事]} \quad \nonumber
 \end{eqnarray}
 \end{eqnarray}
@@ -896,7 +896,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \langle \ \text{与}\ \textrm{X}_1\ \text{有}\ \textrm{X}_2,\quad \textrm{have}\ \textrm{X}_2\ \textrm{with}\ \textrm{X}_1\ \rangle \nonumber
 \langle \ \text{与}\ \textrm{X}_1\ \text{有}\ \textrm{X}_2,\quad \textrm{have}\ \textrm{X}_2\ \textrm{with}\ \textrm{X}_1\ \rangle \nonumber
 \end{eqnarray}
 \end{eqnarray}
 
 
-\parinterval 其中逗号分隔了源语言和目标语言部分，$\textrm{X}_1$和$\textrm{X}_2$表示模板中需要替换的内容，或者说变量。源语言中的变量和目标语言中的变量是一一对应的，比如，源语言中的$\textrm{X}_1$和目标语言中的$\textrm{X}_1$代表这两个变量可以``同时''被替换。假设给定短语对：
+\noindent 其中，逗号分隔了源语言和目标语言部分，$\textrm{X}_1$和$\textrm{X}_2$表示模板中需要替换的内容，或者说变量。源语言中的变量和目标语言中的变量是一一对应的，比如，源语言中的$\textrm{X}_1$ 和目标语言中的$\textrm{X}_1$代表这两个变量可以``同时''被替换。假设给定短语对：
 \begin{eqnarray}
 \begin{eqnarray}
 \langle \ \text{北韩},\quad \textrm{North Korea} \ \rangle \qquad\ \quad\quad\ \  \nonumber \\
 \langle \ \text{北韩},\quad \textrm{North Korea} \ \rangle \qquad\ \quad\quad\ \  \nonumber \\
 \langle \ \text{邦交},\quad \textrm{diplomatic relations} \ \rangle\quad\ \ \ \nonumber
 \langle \ \text{邦交},\quad \textrm{diplomatic relations} \ \rangle\quad\ \ \ \nonumber
@@ -907,7 +907,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \langle \ \text{与}\ \text{[北韩]}\ \text{有}\ \textrm{X}_2,\quad \textrm{have}\ \textrm{X}_2\ \textrm{with}\ \textrm{[North Korea]} \ \rangle \nonumber
 \langle \ \text{与}\ \text{[北韩]}\ \text{有}\ \textrm{X}_2,\quad \textrm{have}\ \textrm{X}_2\ \textrm{with}\ \textrm{[North Korea]} \ \rangle \nonumber
 \end{eqnarray}
 \end{eqnarray}
 
 
-\parinterval 其中，$[\cdot]$表示被替换的部分。可以看到，在源语言和目标语言中，$\textrm{X}_1$被同时替换为相应的短语。进一步，可以用第二个短语替换$\textrm{X}_2$，得到：
+\noindent 其中，$[\cdot]$表示被替换的部分。可以看到，在源语言和目标语言中，$\textrm{X}_1$被同时替换为相应的短语。进一步，可以用第二个短语替换$\textrm{X}_2$，得到：
 \begin{eqnarray}
 \begin{eqnarray}
 \quad\langle \ \text{与}\ \text{北韩}\ \text{有}\ \text{[邦交]},\quad \textrm{have}\ \textrm{[diplomatic relations]}\ \textrm{with}\ \textrm{North Korea} \ \rangle \nonumber
 \quad\langle \ \text{与}\ \text{北韩}\ \text{有}\ \text{[邦交]},\quad \textrm{have}\ \textrm{[diplomatic relations]}\ \textrm{with}\ \textrm{North Korea} \ \rangle \nonumber
 \end{eqnarray}
 \end{eqnarray}
@@ -936,7 +936,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 %--4.3.1 同步上下文无关文法---------------------
 %--4.3.1 同步上下文无关文法---------------------
 \subsection{同步上下文无关文法}\index{Chapter4.3.1}
 \subsection{同步上下文无关文法}\index{Chapter4.3.1}
 
 
-\parinterval {\small\bfnew{基于层次短语的模型}}（Hierarchical Phrase-based Model）是David Chiang于2015提出的统计机器翻译模型\cite{chiang2005a,chiang2007hierarchical}。这个模型可以很好的解决短语系统对翻译中长距离调序建模不足的问题。基于层次短语的系统也在多项机器翻译比赛中取得了很好的成绩。这项工作也获得了自然处理领域顶级会议ACL2015的最佳论文奖。
+\parinterval {\small\bfnew{基于层次短语的模型}}（Hierarchical Phrase-based Model）是David Chiang于2005提出的统计机器翻译模型\cite{chiang2005a,chiang2007hierarchical}。这个模型可以很好的解决短语系统对翻译中长距离调序建模不足的问题。基于层次短语的系统也在多项机器翻译比赛中取得了很好的成绩。这项工作也获得了自然处理领域顶级会议ACL2015的最佳论文奖。
 
 
 \parinterval 层次短语模型的核心是把翻译问题归结为两种语言词串的同步生成问题。实际上，词串的生成问题是自然语言处理中的经典问题，早期的研究更多的是关注单语句子的生成，比如，如何使用句法树描述一个句子的生成过程。层次短语模型的创新之处是把传统单语词串的生成推广到双语词串的同步生成上。这使得机器翻译可以使用类似句法分析的方法进行求解。
 \parinterval 层次短语模型的核心是把翻译问题归结为两种语言词串的同步生成问题。实际上，词串的生成问题是自然语言处理中的经典问题，早期的研究更多的是关注单语句子的生成，比如，如何使用句法树描述一个句子的生成过程。层次短语模型的创新之处是把传统单语词串的生成推广到双语词串的同步生成上。这使得机器翻译可以使用类似句法分析的方法进行求解。
 
 
@@ -946,25 +946,26 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \parinterval 层次短语模型中一个重要的概念是{\small\bfnew{同步上下文无关文法}}（Synchronous Context-free Grammar，简称SCFG）。SCFG可以被看作是对源语言和目标语言上下文无关文法的融合，它要求源语言和目标语言的产生式及产生式中的变量具有对应关系。具体定义如下：
 \parinterval 层次短语模型中一个重要的概念是{\small\bfnew{同步上下文无关文法}}（Synchronous Context-free Grammar，简称SCFG）。SCFG可以被看作是对源语言和目标语言上下文无关文法的融合，它要求源语言和目标语言的产生式及产生式中的变量具有对应关系。具体定义如下：
 
 
 %-------------------------------------------
 %-------------------------------------------
+\vspace{0.5em}
 \begin{definition} 同步上下文无关文法
 \begin{definition} 同步上下文无关文法
 
 
 {\small
 {\small
 一个同步上下文无关文法由五部分构成$(N, T_s, T_t, I, R)$，其中：
 一个同步上下文无关文法由五部分构成$(N, T_s, T_t, I, R)$，其中：
 \begin{enumerate}
 \begin{enumerate}
 \item $N$是非终结符集合。
 \item $N$是非终结符集合。
-\item $T_s$和$T_t$分别是源语言和目标语终结符集合。
+\item $T_s$和$T_t$分别是源语言和目标语言的终结符集合。
 \item $I \subseteq N$起始非终结符集合。
 \item $I \subseteq N$起始非终结符集合。
 \item $R$是规则集合，每条规则$r \in R$有如下形式：
 \item $R$是规则集合，每条规则$r \in R$有如下形式：
 \end{enumerate}
 \end{enumerate}
 \begin{displaymath}
 \begin{displaymath}
 \textrm{LHS} \to <\alpha, \beta, \sim>
 \textrm{LHS} \to <\alpha, \beta, \sim>
 \end{displaymath}
 \end{displaymath}
-其中，$\textrm{LHS} \in N$表示规则的左部，它是一个非终结符；规则右部由三部分组成，$\alpha \in (N \bigcup T_s)^{*}$表示由源语言终结符和非终结符组成的串；$\beta \in (N \bigcup T_t)^{*}$ 表示由目标语言终结符和非终结符组成的串；$\sim$表示$\alpha$和$\beta$中终结符的1-1对应关系。
+其中，$\textrm{LHS} \in N$表示规则的左部，它是一个非终结符；规则的右部由三部分组成，$\alpha \in (N \bigcup T_s)^{*}$表示由源语言终结符和非终结符组成的串；$\beta \in (N \bigcup T_t)^{*}$ 表示由目标语言终结符和非终结符组成的串；$\sim$表示$\alpha$和$\beta$中非终结符的1-1对应关系。
 }
 }
 \end{definition}
 \end{definition}
 %-------------------------------------------
 %-------------------------------------------
 
 
-\parinterval 根据这个定义，源语言和目标语言有不同的终结符集合（单词），但是它们会共享同一个非终结符集合（变量）。每个产生式包括源语言和目标语言两个部分，分别表示由规则左部生成的源语言和目标语言符号串。由于产生式会同时生成两种语言的符号串，因此这是一种``同步''生成，可以很好的描述翻译中两个词串的对应。
+\parinterval 根据这个定义，源语言和目标语言有不同的终结符集合（单词），但是它们会共享同一个非终结符集合（变量）。每个产生式包括源语言和目标语言两个部分，分别表示由规则左部生成的源语言和目标语言符号串。由于产生式会同时生成两种语言的符号串，因此这是一种``同步''生成，可以很好的描述翻译中两个词串之间的对应。
 
 
 \parinterval 下面是一个简单的SCFG实例：
 \parinterval 下面是一个简单的SCFG实例：
 \begin{eqnarray}
 \begin{eqnarray}
@@ -993,7 +994,7 @@ r_3:\quad \textrm{X}\ &\to\ &\langle \ \text{大幅度},\quad \textrm{drasticall
 r_4:\quad \textrm{X}\ &\to\ &\langle \ \text{了},\quad \textrm{have}\ \rangle \nonumber
 r_4:\quad \textrm{X}\ &\to\ &\langle \ \text{了},\quad \textrm{have}\ \rangle \nonumber
 \end{eqnarray}
 \end{eqnarray}
 
 
-\parinterval 其中，规则$r_1$和$r_2$是含有变量的规则，这些变量可以被其他规则的右部替换；规则$r_2$是调序规则；规则$r_3$和$r_4$是纯词汇化规则，表示单词或者短语的翻译。
+\noindent 其中，规则$r_1$和$r_2$是含有变量的规则，这些变量可以被其他规则的右部替换；规则$r_2$是调序规则；规则$r_3$和$r_4$是纯词汇化规则，表示单词或者短语的翻译。
 
 
 \parinterval 对于一个双语句对：
 \parinterval 对于一个双语句对：
 \begin{eqnarray}
 \begin{eqnarray}
@@ -1012,7 +1013,7 @@ r_4:\quad \textrm{X}\ &\to\ &\langle \ \text{了},\quad \textrm{have}\ \rangle \
 & & \ \textrm{The imports}\ {\red{\textrm{have}}}\ \textrm{drastically}\ \textrm{fallen}\ \rangle \nonumber
 & & \ \textrm{The imports}\ {\red{\textrm{have}}}\ \textrm{drastically}\ \textrm{fallen}\ \rangle \nonumber
 \end{eqnarray}
 \end{eqnarray}
 
 
-\parinterval 其中，每使用一次规则就会同步替换源语言和目标语言符号串中的一个非终结符。通常，可以把上面这个过程称作翻译推导，记为：
+\noindent 其中，每使用一次规则就会同步替换源语言和目标语言符号串中的一个非终结符。通常，可以把上面这个过程称作翻译{\small\bfnew{推导}}（Derivation），记为：
 %公式--------------------------------------------------------------------
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
 \begin{eqnarray}
 d = {r_1} \circ {r_2} \circ {r_3} \circ {r_4}
 d = {r_1} \circ {r_2} \circ {r_3} \circ {r_4}
@@ -1020,12 +1021,12 @@ d = {r_1} \circ {r_2} \circ {r_3} \circ {r_4}
 \end{eqnarray}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
 %公式--------------------------------------------------------------------
 
 
-\parinterval 在层次短语模型中，每个翻译推导都唯一的对应一个目标语译文。因此，可以用推导的概率$\textrm{P}(d)$描述翻译的好坏。同基于短语的模型是一样的（第7.2.2节），层次短语翻译的目标是：求概率最高的翻译推导$\hat{d}=\arg\max\textrm{P}(d)$。值得注意的是，基于推导的方法在句法分析中也十分常用。层次短语翻译实质上也是通过生成翻译规则的推导来对问题的表示空间进行建模。在\ref{section-4.4}节还将看到，这种方法可以被扩展到语言学上基于句法的翻译模型中。而且这些模型都可以用一种被称作超图的结构来进行建模。从某种意义上讲，基于规则推导的方法将句法分析和机器翻译进行了形式上的统一。因此机器翻译也借用了很多句法分析的思想。
+\parinterval 在层次短语模型中，每个翻译推导都唯一的对应一个目标语译文。因此，可以用推导的概率$\textrm{P}(d)$描述翻译的好坏。同基于短语的模型是一样的（见\ref{subsection-4.2.2}节），层次短语翻译的目标是：求概率最高的翻译推导$\hat{d}=\arg\max\textrm{P}(d)$。值得注意的是，基于推导的方法在句法分析中也十分常用。层次短语翻译实质上也是通过生成翻译规则的推导来对问题的表示空间进行建模。在\ref{section-4.4} 节还将看到，这种方法可以被扩展到语言学上基于句法的翻译模型中。而且这些模型都可以用一种被称作超图的结构来进行建模。从某种意义上讲，基于规则推导的方法将句法分析和机器翻译进行了形式上的统一。因此机器翻译也借用了很多句法分析的思想。
 
 
 %%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%
 \subsubsection{胶水规则}\index{Chapter4.3.1.3}
 \subsubsection{胶水规则}\index{Chapter4.3.1.3}
 
 
-\parinterval 由于翻译现象非常复杂，在实际系统中往往需要把两个局部翻译线性拼接到一起。在层次短语模型中，这个问题通过引入胶水规则（Glue Rule）来处理，形式如下：
+\parinterval 由于翻译现象非常复杂，在实际系统中往往需要把两个局部翻译线性拼接到一起。在层次短语模型中，这个问题通过引入{\small\bfnew{胶水规则}}（Glue Rule）来处理，形式如下：
 \begin{eqnarray}
 \begin{eqnarray}
 \textrm{S} & \to & \langle\ \textrm{S}_1\ \textrm{X}_2,\ \textrm{S}_1\ \textrm{X}_2\ \rangle \nonumber \\
 \textrm{S} & \to & \langle\ \textrm{S}_1\ \textrm{X}_2,\ \textrm{S}_1\ \textrm{X}_2\ \rangle \nonumber \\
 \textrm{S} & \to & \langle\ \textrm{X}_1,\ \textrm{X}_1\ \rangle \nonumber
 \textrm{S} & \to & \langle\ \textrm{X}_1,\ \textrm{X}_1\ \rangle \nonumber
@@ -1039,9 +1040,9 @@ d = {r_1} \circ {r_2} \circ {r_3} \circ {r_4}
                 & \to & \langle\ \textrm{X}_n\ ...\ \textrm{X}_4\ \textrm{X}_2,\ \textrm{X}_n\ ...\ \textrm{X}_4\ \textrm{X}_2\ \rangle \nonumber
                 & \to & \langle\ \textrm{X}_n\ ...\ \textrm{X}_4\ \textrm{X}_2,\ \textrm{X}_n\ ...\ \textrm{X}_4\ \textrm{X}_2\ \rangle \nonumber
 \end{eqnarray}
 \end{eqnarray}
 
 
-\parinterval 实际上，胶水规则在很大程度上模拟了基于短语的系统中对字符串顺序翻译的操作。而且在实践中发现，这个步骤是十分必要的。特别是对汉-英翻译这样的任务，由于语言的结构基本上是顺序翻译的，因此引入顺序拼接的操作符合翻译的整体规律。同时，这种拼接给翻译增加了灵活性，系统会更加健壮。
+\parinterval 实际上，胶水规则在很大程度上模拟了基于短语的系统中对字符串顺序翻译的操作。而且在实践中发现，这个步骤是十分必要的。特别是对法-英翻译这样的任务，由于语言的结构基本上是顺序翻译的，因此引入顺序拼接的操作符合翻译的整体规律。同时，这种拼接给翻译增加了灵活性，系统会更加健壮。
 
 
-\parinterval 需要说明的是，使用同步文法进行翻译时由于单词之间顺序是内嵌在翻译规则内的，因此这种模型并不依赖额外的调序模型。一旦文法确定下来，系统就可以进行翻译。
+\parinterval 需要说明的是，使用同步文法进行翻译时由于单词的顺序是内嵌在翻译规则内的，因此这种模型并不依赖额外的调序模型。一旦文法确定下来，系统就可以进行翻译。
 
 
 %%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%
 \subsubsection{处理流程}\index{Chapter4.3.1.4}
 \subsubsection{处理流程}\index{Chapter4.3.1.4}
@@ -1065,12 +1066,13 @@ d = {r_1} \circ {r_2} \circ {r_3} \circ {r_4}
 \parinterval 在\ref{subsection-4.2.3}节已经介绍了短语与词对齐相兼容的概念。这里，所有层次短语规则也是与词对齐相兼容（一致）的。
 \parinterval 在\ref{subsection-4.2.3}节已经介绍了短语与词对齐相兼容的概念。这里，所有层次短语规则也是与词对齐相兼容（一致）的。
 
 
 %-------------------------------------------
 %-------------------------------------------
+\vspace{0.5em}
 \begin{definition} 与词对齐相兼容的层次短语规则
 \begin{definition} 与词对齐相兼容的层次短语规则
 
 
 {\small
 {\small
-对于句对(\textbf{s},\textbf{t})和它们之间的词对齐\textbf{a}，令$N$表示在句对(\textbf{s},\textbf{t})上与\textbf{a}相兼容的双语短语集合。则：
+对于句对$(\mathbf{s},\mathbf{t})$和它们之间的词对齐$\mathbf{a}$，令$N$表示在句对$(\mathbf{s},\mathbf{t})$上与$\mathbf{a}$相兼容的双语短语集合。则：
 \begin{enumerate}
 \begin{enumerate}
-\item 	如果$(x,y)\in N$，$\textrm{X} \to \langle x,y,\phi \rangle$是与词对齐相兼容的层次短语规则。
+\item 	如果$(x,y)\in N$，则$\textrm{X} \to \langle x,y,\phi \rangle$是与词对齐相兼容的层次短语规则。
 \item 	对于$(x,y)\in N$，存在$m$个双语短语$(x_i,y_j)\in N$，同时存在(1,$...$,$m$)上面的一个排序$\sim = {\pi_1 , ... ,\pi_m}$，且：
 \item 	对于$(x,y)\in N$，存在$m$个双语短语$(x_i,y_j)\in N$，同时存在(1,$...$,$m$)上面的一个排序$\sim = {\pi_1 , ... ,\pi_m}$，且：
 \end{enumerate}
 \end{enumerate}
 %公式--------------------------------------------------------------------
 %公式--------------------------------------------------------------------
@@ -1101,9 +1103,13 @@ y&=&\beta_0 y_{\pi_1} \beta_1 y_{\pi_2} ... \beta_{m-1} y_{\pi_m} \beta_m
 \parinterval 这种方式可以抽取出大量的层次短语规则。但是，不加限制的抽取，会带来规则集合的过度膨胀，对解码系统造成很大负担。比如，如果考虑任意长度的短语会使得层次短语规则过大，一方面这些规则很难在测试数据上被匹配，另一方面抽取这样的``长''规则会使得抽取算法变慢，而且规则数量猛增之后难以存储。还有，如果一个层次短语规则中含有过多的变量，也会导致解码算法变得更加复杂，不利于系统实现和调试。针对这些问题，在标准的层次短语系统中会考虑一些限制，包括：
 \parinterval 这种方式可以抽取出大量的层次短语规则。但是，不加限制的抽取，会带来规则集合的过度膨胀，对解码系统造成很大负担。比如，如果考虑任意长度的短语会使得层次短语规则过大，一方面这些规则很难在测试数据上被匹配，另一方面抽取这样的``长''规则会使得抽取算法变慢，而且规则数量猛增之后难以存储。还有，如果一个层次短语规则中含有过多的变量，也会导致解码算法变得更加复杂，不利于系统实现和调试。针对这些问题，在标准的层次短语系统中会考虑一些限制，包括：
 
 
 \begin{itemize}
 \begin{itemize}
+\vspace{0.3em}
 \item 抽取的规则最多可以跨越10个词；
 \item 抽取的规则最多可以跨越10个词；
+\vspace{0.3em}
 \item 规则的（源语言端）变量个数不能超过2；
 \item 规则的（源语言端）变量个数不能超过2；
+\vspace{0.3em}
 \item 规则的（源语言端）变量不能连续出现。
 \item 规则的（源语言端）变量不能连续出现。
+\vspace{0.3em}
 \end{itemize}
 \end{itemize}
 \parinterval 在具体实现时还会考虑其他的限制，比如，限定规则的源语言端终结符数量的上限等。
 \parinterval 在具体实现时还会考虑其他的限制，比如，限定规则的源语言端终结符数量的上限等。
 
 
@@ -1112,7 +1118,7 @@ y&=&\beta_0 y_{\pi_1} \beta_1 y_{\pi_2} ... \beta_{m-1} y_{\pi_m} \beta_m
 
 
 \parinterval 在层次短语模型中，每个翻译推导都有一个模型得分$\textrm{score}(d,\textbf{s},\textbf{t})$。$\textrm{score}(d,\textbf{s},\textbf{t})$是若干特征的线性加权之和：$\textrm{score}(d,\textbf{t},\textbf{s})=\sum_{i=1}^M\lambda_i\cdot h_i (d,\textbf{t},\textbf{s})$，其中$\lambda_i$是特征权重，$h_i (d,\textbf{t},\textbf{s})$是特征函数。层次短语模型的特征包括与规则相关的特征和语言模型特征，如下：
 \parinterval 在层次短语模型中，每个翻译推导都有一个模型得分$\textrm{score}(d,\textbf{s},\textbf{t})$。$\textrm{score}(d,\textbf{s},\textbf{t})$是若干特征的线性加权之和：$\textrm{score}(d,\textbf{t},\textbf{s})=\sum_{i=1}^M\lambda_i\cdot h_i (d,\textbf{t},\textbf{s})$，其中$\lambda_i$是特征权重，$h_i (d,\textbf{t},\textbf{s})$是特征函数。层次短语模型的特征包括与规则相关的特征和语言模型特征，如下：
 
 
-\parinterval 对于每一条翻译规则LHS$\to \langle \alpha, \beta ,\sim \rangle$
+\parinterval 对于每一条翻译规则LHS$\to \langle \alpha, \beta ,\sim \rangle$，有：
 
 
 \begin{itemize}
 \begin{itemize}
 \item 	(h1-2)短语翻译概率（取对数），即$\textrm{log}(\textrm{P}(\alpha \mid \beta))$和$\textrm{log}(\textrm{P}(\beta \mid \alpha))$，特征的计算与基于短语的模型完全一样；
 \item 	(h1-2)短语翻译概率（取对数），即$\textrm{log}(\textrm{P}(\alpha \mid \beta))$和$\textrm{log}(\textrm{P}(\beta \mid \alpha))$，特征的计算与基于短语的模型完全一样；
@@ -1149,8 +1155,11 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \parinterval 其中：
 \parinterval 其中：
 
 
 \begin{itemize}
 \begin{itemize}
-\item 	$\textrm{log}⁡(\textrm{P}_{\textrm{lm}}(\textrm{t}))$表示语言模型得分；
-\item 	$\mid \textrm{t} \mid$表示译文的长度。
+\vspace{0.3em}
+\item $\textrm{log}⁡(\textrm{P}_{\textrm{lm}}(\textrm{t}))$表示语言模型得分；
+\vspace{0.3em}
+\item $\mid \textrm{t} \mid$表示译文的长度。
+\vspace{0.3em}
 \end{itemize}
 \end{itemize}
 
 
 \parinterval 在定义特征函数之后，特征权重$\{ \lambda_i \}$可以通过最小错误率训练在开发集上进行调优。关于最小错误率训练可以参考\ref{subsection-4.2.6}节的内容。
 \parinterval 在定义特征函数之后，特征权重$\{ \lambda_i \}$可以通过最小错误率训练在开发集上进行调优。关于最小错误率训练可以参考\ref{subsection-4.2.6}节的内容。
@@ -1161,22 +1170,22 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \parinterval 层次短语模型解码的目标是找到模型得分最高的推导，即：
 \parinterval 层次短语模型解码的目标是找到模型得分最高的推导，即：
 %公式--------------------------------------------------------------------
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
 \begin{eqnarray}
-\hat{d} = \arg\max_{d} score(d,\textbf{s},\textbf{t})
+\hat{d} = \arg\max_{d} \textrm{score}(d,\textbf{s},\textbf{t})
 \label{eqa4.28}
 \label{eqa4.28}
 \end{eqnarray}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
 %公式--------------------------------------------------------------------
 
 
-\parinterval $\hat{d}$的目标语部分即最佳译文$\hat{\textbf{t}}$。令函数$e(\cdot)$返回翻译推导的目标语词串，于是有：
+\parinterval $\hat{d}$的目标语部分即最佳译文$\hat{\textbf{t}}$。令函数$t(\cdot)$返回翻译推导的目标语词串，于是有：
 %公式--------------------------------------------------------------------
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
 \begin{eqnarray}
-\hat{\textbf{t}}=e(\hat{d})
+\hat{\textbf{t}}=t(\hat{d})
 \label{eqa4.29}
 \label{eqa4.29}
 \end{eqnarray}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
 %公式--------------------------------------------------------------------
 
 
-\parinterval 由于层次短语规则本质上就是CFG规则，因此公式\ref{eqa4.6}代表了一个典型的句法分析过程。需要做的是，用模型源语言端的CFG对输入句子进行分析，同时用模型目标语言端的CFG生成译文。基于CFG的句法分析是自然语言处理中的经典问题。一种广泛使用的方法是：首先把CFG转化为$\varepsilon$-free的乔姆斯基范式（Chomsky Normal Form）\footnote[5]{能够证明任意的CFG都可以被转换为乔姆斯基范式，即文法只包含形如A$\to$BC或A$\to$a的规则。这里，假设文法中不包含空串产生式A$\to\varepsilon$，其中$\varepsilon$表示空字符串。}，之后采用CYK方法进行分析。
+\parinterval 由于层次短语规则本质上就是CFG规则，因此公式\ref{eqa4.28}代表了一个典型的句法分析过程。需要做的是，用模型源语言端的CFG对输入句子进行分析，同时用模型目标语言端的CFG生成译文。基于CFG的句法分析是自然语言处理中的经典问题。一种广泛使用的方法是：首先把CFG转化为$\varepsilon$-free的{\small\bfnew{乔姆斯基范式}}（Chomsky Normal Form）\footnote[5]{能够证明任意的CFG都可以被转换为乔姆斯基范式，即文法只包含形如A$\to$BC或A$\to$a的规则。这里，假设文法中不包含空串产生式A$\to\varepsilon$，其中$\varepsilon$表示空字符串。}，之后采用CYK方法进行分析。
 
 
-\parinterval CYK是形式语言中一种常用的句法分析方法\cite{cocke1969programming,younger1967recognition,kasami1966efficient}。它主要用于分析符合乔姆斯基范式的句子。由于乔姆斯基范式中每个规则最多包含两叉（或者说两个变量），因此CYK方法也可以被看作是基于二叉规则的一种分析方法。对于一个待分析的字符串，CYK方法从小的``范围''开始，不断扩大分析的``范围''，最终完成对整个字符串的分析。在CYK方法中，一个重要的概念是跨度（Span），所谓跨度表示了一个符号串的范围。这里可以把跨度简单的理解为从一个起始位置到一个结束位置中间的部分。比如，如图\ref{fig:word-and-index-of-pos}所示，每个单词左右都有一个数字来表示序号。可以用序号的范围来表示跨度，例如：
+\parinterval CYK是形式语言中一种常用的句法分析方法\cite{cocke1969programming,younger1967recognition,kasami1966efficient}。它主要用于分析符合乔姆斯基范式的句子。由于乔姆斯基范式中每个规则最多包含两叉（或者说两个变量），因此CYK方法也可以被看作是基于二叉规则的一种分析方法。对于一个待分析的字符串，CYK方法从小的``范围''开始，不断扩大分析的``范围''，最终完成对整个字符串的分析。在CYK方法中，一个重要的概念是{\small\bfnew{跨度}}（Span），所谓跨度表示了一个符号串的范围。这里可以把跨度简单的理解为从一个起始位置到一个结束位置中间的部分。
 
 
 %----------------------------------------------
 %----------------------------------------------
 % 图
 % 图
@@ -1187,20 +1196,26 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \label{fig:word-and-index-of-pos}
 \label{fig:word-and-index-of-pos}
 \end{figure}
 \end{figure}
 %-------------------------------------------
 %-------------------------------------------
+
+比如，如图\ref{fig:word-and-index-of-pos} 所示，每个单词左右都有一个数字来表示序号。可以用序号的范围来表示跨度，例如：
+
 \begin{eqnarray}
 \begin{eqnarray}
-\textrm{Span[0,1]}&=&\textrm{``猫''} \nonumber \\
-\textrm{Span[2,4]}&=&\textrm{``吃} \quad \textrm{鱼''} \nonumber \\
-\textrm{Span[0,4]}&=&\textrm{``猫} \quad \textrm{喜欢} \quad \textrm{吃} \quad \textrm{鱼''} \nonumber
+span\textrm{[0,1]}&=&\textrm{``猫''} \nonumber \\
+span\textrm{[2,4]}&=&\textrm{``吃} \quad \textrm{鱼''} \nonumber \\
+span\textrm{[0,4]}&=&\textrm{``猫} \quad \textrm{喜欢} \quad \textrm{吃} \quad \textrm{鱼''} \nonumber
 \end{eqnarray}
 \end{eqnarray}
 
 
-\parinterval CYK方法是按跨度由小到大的次序执行的，这也对应了一种自下而上的分析过程。对于每个跨度，检查：
+\parinterval CYK方法是按跨度由小到大的次序执行的，这也对应了一种{\small\bfnew{自下而上的分析}}（Top-down Parsing）过程。对于每个跨度，检查：
 
 
 \begin{itemize}
 \begin{itemize}
+\vspace{0.3em}
 \item 	是否有形如A$\to$a的规则可以匹配；
 \item 	是否有形如A$\to$a的规则可以匹配；
+\vspace{0.3em}
 \item 	是否有形如A$\to$BC的规则可以匹配。
 \item 	是否有形如A$\to$BC的规则可以匹配。
+\vspace{0.3em}
 \end{itemize}
 \end{itemize}
 
 
-\parinterval 对于第一种情况，简单匹配字符串即可；对于第二种情况，需要把当前的跨度进一步分割为两部分，并检查左半部分是否已经被归纳为B，右半部分是否已经被归纳为C。如果可以匹配，会在这个跨度上保存匹配结果。后面，可以访问这个结果（也就是A）来生成更大跨度上的分析结果。CYK算法的伪代码如图\ref{fig:CYK-algorithm}所示。整个算法的执行顺序是按跨度的长度（$l$）组织的。对于每个span[$j,j + l$]，会在位置$k$进行切割。之后，判断span[$j,k$]和span[$k,j +l$]是否可以形成一个规则的右部。也就是判断span[$j,k$]是否生成了B，同时判断span[$k,j + l$]是否生成了C，如果文法中有规则A$\to$BC，则把这个规则放入span[$j,j+l$]。这个过程由Compose函数完成。如果span[$j,j + l$]可以匹配多条规则，所有生成的推导都会被记录在span[$j,j + l$]所对应的一个列表里\footnote[6]{通常，这个列表会用优先队列实现。这样可以对推导按模型得分进行排序，方便后续的剪枝操作。}。
+\parinterval 对于第一种情况，简单匹配字符串即可；对于第二种情况，需要把当前的跨度进一步分割为两部分，并检查左半部分是否已经被归纳为B，右半部分是否已经被归纳为C。如果可以匹配，会在这个跨度上保存匹配结果。后面，可以访问这个结果（也就是A）来生成更大跨度上的分析结果。CYK算法的伪代码如图\ref{fig:CYK-algorithm}所示。整个算法的执行顺序是按跨度的长度（$l$）组织的。对于每个$span[j,j + l]$，会在位置$k$进行切割。之后，判断$span[j,k]$和$span[k,j +l]$是否可以形成一个规则的右部。也就是判断$span[j,k]$是否生成了B，同时判断$span[k,j + l]$是否生成了C，如果文法中有规则A$\to$BC，则把这个规则放入$span[j,j+l]$。这个过程由Compose函数完成。如果$span[j,j + l]$可以匹配多条规则，所有生成的推导都会被记录在$span[j,j + l]$所对应的一个列表里\footnote[6]{通常，这个列表会用优先队列实现。这样可以对推导按模型得分进行排序，方便后续的剪枝操作。}。
 
 
 %----------------------------------------------
 %----------------------------------------------
 % 图
 % 图
@@ -1220,7 +1235,7 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \centering
 \centering
 \input{./Chapter4/Figures/example-of-cyk-algorithm-execution-label}
 \input{./Chapter4/Figures/example-of-cyk-algorithm-execution-label}
 \input{./Chapter4/Figures/example-of-cyk-algorithm-execution}
 \input{./Chapter4/Figures/example-of-cyk-algorithm-execution}
-\caption{一个三层循环神经网络的模型并行过程}
+\caption{CYK算法执行实例}
 \label{fig:example-of-cyk-algorithm-execution}
 \label{fig:example-of-cyk-algorithm-execution}
 \end{figure}
 \end{figure}
 %----------------------------------------------
 %----------------------------------------------
@@ -1228,23 +1243,29 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \parinterval 不过，CYK方法并不能直接用于层次短语模型。有两个问题：
 \parinterval 不过，CYK方法并不能直接用于层次短语模型。有两个问题：
 
 
 \begin{itemize}
 \begin{itemize}
+\vspace{0.3em}
 \item 层次短语模型的文法不符合乔姆斯基范式；
 \item 层次短语模型的文法不符合乔姆斯基范式；
+\vspace{0.3em}
 \item 机器翻译中需要语言模型。由于当前词的语言模型得分需要前面的词做条件，因此机器翻译的解码过程并不是上下文无关的。
 \item 机器翻译中需要语言模型。由于当前词的语言模型得分需要前面的词做条件，因此机器翻译的解码过程并不是上下文无关的。
+\vspace{0.3em}
 \end{itemize}
 \end{itemize}
 
 
 \parinterval 解决第一个问题有两个思路：
 \parinterval 解决第一个问题有两个思路：
 
 
 \begin{itemize}
 \begin{itemize}
+\vspace{0.3em}
 \item 把层次短语文法转化为乔姆斯基范式，这样可以直接使用原始的CYK方法进行分析；
 \item 把层次短语文法转化为乔姆斯基范式，这样可以直接使用原始的CYK方法进行分析；
+\vspace{0.3em}
 \item 对CYK方法进行改造。解码的核心任务要知道每个跨度是否能匹配规则的源语言部分。实际上，层次短语模型的文法是一种特殊的文法。这种文法规则的源语言部分最多包含两个变量，而且变量不能连续。这样的规则会对应一种特定类型的模版，比如，对于包含两个变量的规则，它的源语言部分形如$\alpha_0 \textrm{X}_1 \alpha_1 \textrm{X}_2 \alpha_2$。其中，$\alpha_0$、$\alpha_1$和$\alpha_2$表示终结符串，$\textrm{X}_1$和$\textrm{X}_2$是变量。显然，如果$\alpha_0$、$\alpha_1$和$\alpha_2$确定下来那么$\textrm{X}_1$和$\textrm{X}_2$的位置也就确定了下来。因此，对于每一个词串，都可以很容易的生成这种模版，进而完成匹配。而$\textrm{X}_1$和$\textrm{X}_2$和原始CYK中匹配二叉规则本质上是一样的。由于这种方法并不需要对CYK方法进行过多的调整，因此层次短语系统中广泛使用这种改造的CYK方法进行解码。
 \item 对CYK方法进行改造。解码的核心任务要知道每个跨度是否能匹配规则的源语言部分。实际上，层次短语模型的文法是一种特殊的文法。这种文法规则的源语言部分最多包含两个变量，而且变量不能连续。这样的规则会对应一种特定类型的模版，比如，对于包含两个变量的规则，它的源语言部分形如$\alpha_0 \textrm{X}_1 \alpha_1 \textrm{X}_2 \alpha_2$。其中，$\alpha_0$、$\alpha_1$和$\alpha_2$表示终结符串，$\textrm{X}_1$和$\textrm{X}_2$是变量。显然，如果$\alpha_0$、$\alpha_1$和$\alpha_2$确定下来那么$\textrm{X}_1$和$\textrm{X}_2$的位置也就确定了下来。因此，对于每一个词串，都可以很容易的生成这种模版，进而完成匹配。而$\textrm{X}_1$和$\textrm{X}_2$和原始CYK中匹配二叉规则本质上是一样的。由于这种方法并不需要对CYK方法进行过多的调整，因此层次短语系统中广泛使用这种改造的CYK方法进行解码。
+\vspace{0.3em}
 \end{itemize}
 \end{itemize}
 
 
-\parinterval 对于语言模型在解码中的集成问题，一种简单的办法是：在CYK分析的过程中，用语言模型对每个局部的翻译结果进行评价，并计算局部翻译（推导）的模型得分。注意，局部的语言模型得分可能是不准确的，比如，局部翻译片段最左边单词的概率计算需要依赖前面的单词。但是由于每个跨度下生成的翻译是局部的，当前跨度下看不到前面的译文。这时会用1-gram语言模型的得分代替真实的高阶语言模型得分。等这个局部翻译片段和其他片段组合之后，可以知道前文的内容时，才会得出最终的语言模型得分。另一种解决问题的思路是，先不加入语言模型，这样可以直接使用CYK方法进行分析。在得到最终的结果后，对最好的多个推导用含有语言模型的完整模型进行打分，选出最终的最优推导。不过，在实践中发现，由于语言模型在机器翻译中起到至关重要的作用，因此对最终结果进行重排序会带来一定的性能损失。不过这种方法的优势在于速度快，而且容易实现。
+\parinterval 对于语言模型在解码中的集成问题，一种简单的办法是：在CYK分析的过程中，用语言模型对每个局部的翻译结果进行评价，并计算局部翻译（推导）的模型得分。注意，局部的语言模型得分可能是不准确的，比如，局部翻译片段最左边单词的概率计算需要依赖前面的单词。但是由于每个跨度下生成的翻译是局部的，当前跨度下看不到前面的译文。这时会用1-gram语言模型的得分代替真实的高阶语言模型得分。等这个局部翻译片段和其他片段组合之后，可以知道前文的内容，这时才会得出最终的语言模型得分。另一种解决问题的思路是，先不加入语言模型，这样可以直接使用CYK方法进行分析。在得到最终的结果后，对最好的多个推导用含有语言模型的完整模型进行打分，选出最终的最优推导。不过，在实践中发现，由于语言模型在机器翻译中起到至关重要的作用，因此对最终结果进行重排序会带来一定的性能损失。不过这种方法的优势在于速度快，而且容易实现。
 
 
 \parinterval 另外，在实践时，还需要考虑两方面问题：
 \parinterval 另外，在实践时，还需要考虑两方面问题：
 
 
 \begin{itemize}
 \begin{itemize}
-\item 剪枝：在CYK中，每个跨度都可以生成非常多的推导（局部翻译假设）。理论上，这些推导的数量会和跨度大小成指数关系。显然不可能保存如此大量的翻译推导。对于这个问题，常用的办法是只保留top-$k$个推导。也就是每个局部结果只保留最好的$k$个。这种方法也被称作束剪枝（Beam Pruning）。在极端情况下，当$k$=1时，这个方法就变成了贪婪的方法；
+\item 剪枝：在CYK中，每个跨度都可以生成非常多的推导（局部翻译假设）。理论上，这些推导的数量会和跨度大小成指数关系。显然不可能保存如此大量的翻译推导。对于这个问题，常用的办法是只保留top-$k$个推导。也就是每个局部结果只保留最好的$k$个。这种方法也被称作{\small\bfnew{束剪枝}}（Beam Pruning）。在极端情况下，当$k$=1时，这个方法就变成了贪婪的方法；
 \item $n$-best结果的生成：$n$-best推导（译文）的生成是统计机器翻译必要的功能。比如，最小错误率训练中就需要最好的$n$个结果用于特征权重调优。在基于CYK的方法中，整个句子的翻译结果会被保存在最大跨度所对应的结构中。因此一种简单的$n$-best生成方法是从这个结构中取出排名最靠前的$n$个结果。另外，也可以考虑自上而下遍历CYK生成的推导空间，得到更好的$n$-best结果\cite{huang2005better}。
 \item $n$-best结果的生成：$n$-best推导（译文）的生成是统计机器翻译必要的功能。比如，最小错误率训练中就需要最好的$n$个结果用于特征权重调优。在基于CYK的方法中，整个句子的翻译结果会被保存在最大跨度所对应的结构中。因此一种简单的$n$-best生成方法是从这个结构中取出排名最靠前的$n$个结果。另外，也可以考虑自上而下遍历CYK生成的推导空间，得到更好的$n$-best结果\cite{huang2005better}。
 \end{itemize}
 \end{itemize}
 
 
@@ -1282,9 +1303,9 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \end{figure}
 \end{figure}
 %-------------------------------------------
 %-------------------------------------------
 
 
-\parinterval 如果相同源语言端的规则有$n$个，规则中每个变量可以被替换为$m$个结果，对于只含有一个变量的规则，一共有$nm$种不同的组合。如果规则含有两个变量，组合的数量是$n{m}^2$。由于翻译中会进行大量的规则匹配，如果每个匹配的源语言端都考虑所有$n{m}^2$种译文的组合，解码速度会很慢。
+\parinterval 假设有$n$个规则源语言端相同，规则中每个变量可以被替换为$m$个结果，对于只含有一个变量的规则，一共有$nm$种不同的组合。如果规则含有两个变量，这种组合的数量是$n{m}^2$。由于翻译中会进行大量的规则匹配，如果每个匹配的源语言端都考虑所有$n{m}^2$种译文的组合，解码速度会很慢。
 
 
-\parinterval 在层次短语系统中，会进一步对搜索空间剪枝。简言之，此时并不需要对所有$n{m}^2$种组合进行遍历，而是只考虑其中的一部分组合。这种方法也被称作立方剪枝（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)$这三个新的翻译假设。之后，计算出它们的模型得分，并压入优先队列。这个过程不断被执行，直到达到终止条件，比如，扩展次数达到一个上限。图\ref{fig:execution-of-cube-pruning}展示了立方剪枝的过程（规则只含有一个变量的情况）。可以看到，每个步骤中，算法只会扩展当前最好结果周围的两个点（对应两个维度，横轴对应变量被替换的内容，纵轴对应规则的目标语端）。
+\parinterval 在层次短语系统中，会进一步对搜索空间剪枝。简言之，此时并不需要对所有$n{m}^2$种组合进行遍历，而是只考虑其中的一部分组合。这种方法也被称作{\small\bfnew{立方剪枝}}（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)$这三个新的翻译假设。之后，计算出它们的模型得分，并压入优先队列。这个过程不断被执行，直到达到终止条件，比如，扩展次数达到一个上限。图\ref{fig:execution-of-cube-pruning}展示了立方剪枝的过程（规则只含有一个变量的情况）。可以看到，每个步骤中，算法只会扩展当前最好结果周围的两个点（对应两个维度，横轴对应变量被替换的内容，纵轴对应规则的目标语端）。
 
 
 %----------------------------------------------
 %----------------------------------------------
 % 图
 % 图

Book/mt-book-xelatex.idx

@@ -21,35 +21,35 @@
 \indexentry{Chapter4.2.7.1|hyperpage}{30}
 \indexentry{Chapter4.2.7.1|hyperpage}{30}
 \indexentry{Chapter4.2.7.2|hyperpage}{30}
 \indexentry{Chapter4.2.7.2|hyperpage}{30}
 \indexentry{Chapter4.2.7.3|hyperpage}{31}
 \indexentry{Chapter4.2.7.3|hyperpage}{31}
-\indexentry{Chapter4.2.7.4|hyperpage}{33}
-\indexentry{Chapter4.3|hyperpage}{34}
+\indexentry{Chapter4.2.7.4|hyperpage}{32}
+\indexentry{Chapter4.3|hyperpage}{33}
 \indexentry{Chapter4.3.1|hyperpage}{36}
 \indexentry{Chapter4.3.1|hyperpage}{36}
-\indexentry{Chapter4.3.1.1|hyperpage}{37}
+\indexentry{Chapter4.3.1.1|hyperpage}{36}
 \indexentry{Chapter4.3.1.2|hyperpage}{38}
 \indexentry{Chapter4.3.1.2|hyperpage}{38}
 \indexentry{Chapter4.3.1.3|hyperpage}{39}
 \indexentry{Chapter4.3.1.3|hyperpage}{39}
-\indexentry{Chapter4.3.1.4|hyperpage}{40}
+\indexentry{Chapter4.3.1.4|hyperpage}{39}
 \indexentry{Chapter4.3.2|hyperpage}{40}
 \indexentry{Chapter4.3.2|hyperpage}{40}
 \indexentry{Chapter4.3.3|hyperpage}{41}
 \indexentry{Chapter4.3.3|hyperpage}{41}
 \indexentry{Chapter4.3.4|hyperpage}{42}
 \indexentry{Chapter4.3.4|hyperpage}{42}
 \indexentry{Chapter4.3.5|hyperpage}{46}
 \indexentry{Chapter4.3.5|hyperpage}{46}
 \indexentry{Chapter4.4|hyperpage}{49}
 \indexentry{Chapter4.4|hyperpage}{49}
-\indexentry{Chapter4.4.1|hyperpage}{51}
-\indexentry{Chapter4.4.2|hyperpage}{51}
-\indexentry{Chapter4.4.2.1|hyperpage}{53}
+\indexentry{Chapter4.4.1|hyperpage}{50}
+\indexentry{Chapter4.4.2|hyperpage}{53}
+\indexentry{Chapter4.4.2.1|hyperpage}{54}
 \indexentry{Chapter4.4.2.2|hyperpage}{55}
 \indexentry{Chapter4.4.2.2|hyperpage}{55}
 \indexentry{Chapter4.4.2.3|hyperpage}{57}
 \indexentry{Chapter4.4.2.3|hyperpage}{57}
 \indexentry{Chapter4.4.3|hyperpage}{58}
 \indexentry{Chapter4.4.3|hyperpage}{58}
-\indexentry{Chapter4.4.3.1|hyperpage}{58}
-\indexentry{Chapter4.4.3.2|hyperpage}{61}
-\indexentry{Chapter4.4.3.3|hyperpage}{62}
-\indexentry{Chapter4.4.3.4|hyperpage}{63}
-\indexentry{Chapter4.4.3.5|hyperpage}{64}
+\indexentry{Chapter4.4.3.1|hyperpage}{59}
+\indexentry{Chapter4.4.3.2|hyperpage}{62}
+\indexentry{Chapter4.4.3.3|hyperpage}{63}
+\indexentry{Chapter4.4.3.4|hyperpage}{64}
+\indexentry{Chapter4.4.3.5|hyperpage}{65}
 \indexentry{Chapter4.4.4|hyperpage}{66}
 \indexentry{Chapter4.4.4|hyperpage}{66}
-\indexentry{Chapter4.4.4.1|hyperpage}{66}
-\indexentry{Chapter4.4.4.2|hyperpage}{67}
-\indexentry{Chapter4.4.5|hyperpage}{68}
-\indexentry{Chapter4.4.5|hyperpage}{69}
+\indexentry{Chapter4.4.4.1|hyperpage}{67}
+\indexentry{Chapter4.4.4.2|hyperpage}{68}
+\indexentry{Chapter4.4.5|hyperpage}{70}
+\indexentry{Chapter4.4.5|hyperpage}{71}
 \indexentry{Chapter4.4.7|hyperpage}{73}
 \indexentry{Chapter4.4.7|hyperpage}{73}
-\indexentry{Chapter4.4.7.1|hyperpage}{73}
-\indexentry{Chapter4.4.7.2|hyperpage}{74}
-\indexentry{Chapter4.5|hyperpage}{76}
+\indexentry{Chapter4.4.7.1|hyperpage}{75}
+\indexentry{Chapter4.4.7.2|hyperpage}{76}
+\indexentry{Chapter4.5|hyperpage}{77}