diff --git a/Book/Chapter4/Figures/based-on-tree-structure-generate-sentence-pairs.tex b/Book/Chapter4/Figures/based-on-tree-structure-generate-sentence-pairs.tex
index ed7be55..0c38032 100644
--- a/Book/Chapter4/Figures/based-on-tree-structure-generate-sentence-pairs.tex
+++ b/Book/Chapter4/Figures/based-on-tree-structure-generate-sentence-pairs.tex
@@ -137,7 +137,7 @@
 
 {
 % red rule 4
-\begin{scope}[red, scale=0.6, xshift=16em, yshift=-11em, level distance=20pt]
+\begin{scope}[scale=0.6, xshift=16em, yshift=-11em, level distance=20pt]
 
 \begin{scope}[anchor=north east, xshift=-6em] \Tree[.IP [.NN ] [.VP ]] \end{scope}
 \draw[->] (-1.7,0.1) -- (-0.9,0.1);
diff --git a/Book/Chapter4/Figures/combination-of-translation-with-different-rules.tex b/Book/Chapter4/Figures/combination-of-translation-with-different-rules.tex
index bdad85a..6d401ae 100644
--- a/Book/Chapter4/Figures/combination-of-translation-with-different-rules.tex
+++ b/Book/Chapter4/Figures/combination-of-translation-with-different-rules.tex
@@ -38,10 +38,10 @@
 }
 
 \node [rectangle,inner sep=0.1em,rounded corners=1pt,draw] [fit = (h1) (h5) (h6)] (gl1) {};
-\node [rectangle,inner sep=0.1em,rounded corners=1pt,draw] [fit = (h21) (h27)] (gl2) {};
+\node [rectangle,inner sep=0.1em,rounded corners=1pt,draw] [fit = (h21) (h25) (h27)] (gl2) {};
 
 \draw [->,ublue,thick] ([xshift=0.6em,yshift=0.2em]n4.south) .. controls +(south:2em) and +(east:0em) ..   ([xshift=-0em,yshift=2em]gl2.west);
-\draw [->,ublue,thick] ([xshift=0em,yshift=1em]gl1.east) .. controls +(south:3em) and +(east:0em) ..   ([xshift=-0em,yshift=1.6em]gl2.west);
+\draw [->,ublue,thick] ([xshift=0em,yshift=0em]gl1.east) .. controls +(north:2.2em) and +(east:0em) ..   ([xshift=-0em,yshift=2em]gl2.west);
 
 \end{scope}
 \end{tikzpicture}
diff --git a/Book/Chapter4/Figures/combine-minimum-rule-1.tex b/Book/Chapter4/Figures/combine-minimum-rule-1.tex
index 189305e..2ab053d 100644
--- a/Book/Chapter4/Figures/combine-minimum-rule-1.tex
+++ b/Book/Chapter4/Figures/combine-minimum-rule-1.tex
@@ -1,6 +1,6 @@
 %%%------------------------------------------------------------------------------------------------------------
 %%%  组合规则
-\begin{minipage}[b]{0.35\textwidth}
+\begin{minipage}[b]{0.38\textwidth}
 {\footnotesize
 \renewcommand*{\arraystretch}{1.3}
 \begin{tabular}{l l}
@@ -10,10 +10,10 @@
 {$r_7$} & {IP(NP$_1$ VP$_2$) $\to$ NP$_1$ VP$_2$} \\
 {\red{$r_{1,7}$}} & {IP(NP(PN(他)) VP$_1$) $\to$} \\
                           & {he VP$_1$}\\
-{\red{$r_{1,6}$}} & {IP(NP(PN(他)) VP(PP$_1$ VP$_2$))} \\
-{\red{\ $^{,7}$}}  & {$\to$ he VP$_2$ PP$_1$}\\
-{\red{$r_{1,5}$}} & {IP(NP(PN(他)) } \\
-{\red{\ $^{,6,7}$}}  & {VP(P$_1$ NP$_2$ VP$_3$))}\\
+{\red{$r_{1,6,7}$}} & {IP(NP(PN(他)) VP(PP$_1$ VP$_2$))} \\
+                           & {$\to$ he VP$_2$ PP$_1$}\\
+{\red{$r_{1,5,6,7}$}} & {IP(NP(PN(他)) } \\
+                           & {VP(P$_1$ NP$_2$ VP$_3$))}\\
                            & {$\to$ he VP$_3$ P$_1$ NP$_2$}\\
                            & \\
 \end{tabular}
diff --git a/Book/Chapter4/Figures/content-of-chart-in-tree-based-decoding.tex b/Book/Chapter4/Figures/content-of-chart-in-tree-based-decoding.tex
index 6d01781..d179a64 100644
--- a/Book/Chapter4/Figures/content-of-chart-in-tree-based-decoding.tex
+++ b/Book/Chapter4/Figures/content-of-chart-in-tree-based-decoding.tex
@@ -97,8 +97,8 @@
 }
 
 \draw[-] ([xshift=-0.3em,yshift=-0.3em]k1.north west) -- ([xshift=-0.3em,yshift=-10.7em]k1.south west);
-\draw[-] ([xshift=-0.3em,yshift=-0.3em]b1.north west) -- ([xshift=-0.3em,yshift=-10.7em]b1.south west);
-\draw[-] ([xshift=-0em,yshift=-0.3em]y1.north west) -- ([xshift=-0em,yshift=-10.7em]y1.south west);
+%\draw[-] ([xshift=-0.3em,yshift=-0.3em]b1.north west) -- ([xshift=-0.3em,yshift=-10.7em]b1.south west);
+%\draw[-] ([xshift=-0em,yshift=-0.3em]y1.north west) -- ([xshift=-0em,yshift=-10.7em]y1.south west);
 
 \end{tikzpicture}
 \end{center}
diff --git a/Book/Chapter4/Figures/cyk-algorithm.tex b/Book/Chapter4/Figures/cyk-algorithm.tex
index 0e9f71a..25c411a 100644
--- a/Book/Chapter4/Figures/cyk-algorithm.tex
+++ b/Book/Chapter4/Figures/cyk-algorithm.tex
@@ -8,22 +8,22 @@
 \tikzstyle{srcnode} = [anchor=south west]
 \begin{scope}[scale=0.85]
 
-\node[srcnode] (c1) at (0,0) {\small{\textbf{Function} CYK-Algorithm($\textbf{s},G$)}};
-\node[srcnode,anchor=north west] (c21) at ([xshift=1.5em,yshift=0.4em]c1.south west) {\small{\textbf{fore} $j=0$ to $ J - 1$}};
-\node[srcnode,anchor=north west] (c22) at ([xshift=1.5em,yshift=0.4em]c21.south west) {\small{$span[j,j+1 ]$.Add($A \to a \in G$)}};
-\node[srcnode,anchor=north west] (c3) at ([xshift=-1.5em,yshift=0.4em]c22.south west) {\small{\textbf{for} $l$ = 1 to $J$}};
-\node[srcnode,anchor=west] (c31) at ([xshift=6em]c3.east) {\small{// length of span}};
-\node[srcnode,anchor=north west] (c4) at ([xshift=1.5em,yshift=0.4em]c3.south west) {\small{\textbf{for} $j$ = 0 to $J-l$}};
-\node[srcnode,anchor=north west] (c41) at ([yshift=0.4em]c31.south west) {\small{// beginning of span}};
-\node[srcnode,anchor=north west] (c5) at ([xshift=1.5em,yshift=0.4em]c4.south west) {\small{\textbf{for} $k$ = $j$ to $j+l$}};
-\node[srcnode,anchor=north west] (c51) at ([yshift=0.4em]c41.south west) {\small{// partition of span}};
-\node[srcnode,anchor=north west] (c6) at ([xshift=1.5em,yshift=0.4em]c5.south west) {\small{$hypos$ = Compose($span[j, k], span[k, j+l]$)}};
-\node[srcnode,anchor=north west] (c7) at ([yshift=0.4em]c6.south west) {\small{$span[j, j+l]$.Update($hypos$)}};
-\node[srcnode,anchor=north west] (c8) at ([xshift=-4.5em,yshift=0.4em]c7.south west) {\small{\textbf{return} $span[0, J]$}};
-
-\node[anchor=west] (c9) at ([xshift=0em,yshift=1.7em]c1.west) {\scriptsize{\textrm{参数：}\textbf{s}为输入字符串。$G$为输入CFG。$J$为待分析字符串长度。}};
-\node[anchor=west] (c10) at ([xshift=0em,yshift=1.3em]c9.west) {\scriptsize{\textrm{输出：字符串全部可能的语法分析结果}}};
-\node[anchor=west] (c11) at ([xshift=0em,yshift=1.3em]c10.west) {\scriptsize{\textrm{输入：符合乔姆斯基范式的待分析字符串和一个上下文无关文法（CFG）}}};
+\node[srcnode] (c1) at (0,0) {\normalsize{\textbf{Function} CYK-Algorithm($\textbf{s},G$)}};
+\node[srcnode,anchor=north west] (c21) at ([xshift=1.5em,yshift=0.4em]c1.south west) {\normalsize{\textbf{fore} $j=0$ to $ J - 1$}};
+\node[srcnode,anchor=north west] (c22) at ([xshift=1.5em,yshift=0.4em]c21.south west) {\normalsize{$span[j,j+1 ]$.Add($A \to a \in G$)}};
+\node[srcnode,anchor=north west] (c3) at ([xshift=-1.5em,yshift=0.4em]c22.south west) {\normalsize{\textbf{for} $l$ = 1 to $J$}};
+\node[srcnode,anchor=west] (c31) at ([xshift=6em]c3.east) {\normalsize{// length of span}};
+\node[srcnode,anchor=north west] (c4) at ([xshift=1.5em,yshift=0.4em]c3.south west) {\normalsize{\textbf{for} $j$ = 0 to $J-l$}};
+\node[srcnode,anchor=north west] (c41) at ([yshift=0.4em]c31.south west) {\normalsize{// beginning of span}};
+\node[srcnode,anchor=north west] (c5) at ([xshift=1.5em,yshift=0.4em]c4.south west) {\normalsize{\textbf{for} $k$ = $j$ to $j+l$}};
+\node[srcnode,anchor=north west] (c51) at ([yshift=0.4em]c41.south west) {\normalsize{// partition of span}};
+\node[srcnode,anchor=north west] (c6) at ([xshift=1.5em,yshift=0.4em]c5.south west) {\normalsize{$hypos$ = Compose($span[j, k], span[k, j+l]$)}};
+\node[srcnode,anchor=north west] (c7) at ([yshift=0.4em]c6.south west) {\normalsize{$span[j, j+l]$.Update($hypos$)}};
+\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{参数：}\textbf{s}为输入字符串。$G$为输入CFG。$J$为待分析字符串长度。}};
+\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）}}};
 
 
 
diff --git a/Book/Chapter4/Figures/derivation-of-hierarchical-phrase-and-tree-structure-model.tex b/Book/Chapter4/Figures/derivation-of-hierarchical-phrase-and-tree-structure-model.tex
index baaaf79..30f64a4 100644
--- a/Book/Chapter4/Figures/derivation-of-hierarchical-phrase-and-tree-structure-model.tex
+++ b/Book/Chapter4/Figures/derivation-of-hierarchical-phrase-and-tree-structure-model.tex
@@ -69,9 +69,9 @@
 
 \node[anchor=north west] (r7) at ([yshift=-0.4em]r61.south west) {$r_7$};
 \node[anchor=west] (rc7) at ([xshift=0em]r7.east) {$\textrm{X} \; \to \; \langle\ \text{组织 的}, \; \; \text{of}\ \rangle$};
-
-
 \end{scope}
 
+\node[anchor=south] (l1) at ([xshift=-9em,yshift=1em]rules.north) {\normalsize{${d = r_3}{\circ r_1}{ \circ r_4}{ \circ r_2}{ \circ r_5}{ \circ r_2}{ \circ r_7}{ \circ r_6}{ \circ r_2}$}};
+
 }
 \end{tikzpicture}
diff --git a/Book/Chapter4/Figures/example-of-n-gram-1.tex b/Book/Chapter4/Figures/example-of-n-gram-1.tex
index 975cea7..f5c0e6f 100644
--- a/Book/Chapter4/Figures/example-of-n-gram-1.tex
+++ b/Book/Chapter4/Figures/example-of-n-gram-1.tex
@@ -1,6 +1,6 @@
 %%%------------------------------------------------------------------------------------------------------------
 %%% 引入短语翻译
-{\scriptsize
+{\small
 \begin{tabular}{l | l}
 {{\red{\sout{单词}}}词串翻译表} & P \\ \hline
 我 $\to$ I & 0.6 \\
diff --git a/Book/Chapter4/Figures/example-of-n-gram-2.tex b/Book/Chapter4/Figures/example-of-n-gram-2.tex
index 67a413a..46f2401 100644
--- a/Book/Chapter4/Figures/example-of-n-gram-2.tex
+++ b/Book/Chapter4/Figures/example-of-n-gram-2.tex
@@ -1,6 +1,6 @@
 %%%------------------------------------------------------------------------------------------------------------
 %%% 引入短语翻译
-\begin{minipage}[c]{0.55\linewidth}
+\begin{minipage}[c]{0.48\linewidth}
 \vspace{1em}
 \begin{center}
 \begin{tikzpicture}
diff --git a/Book/Chapter4/Figures/example-of-tree-structure-correspondence.tex b/Book/Chapter4/Figures/example-of-tree-structure-correspondence.tex
index a33db15..1b5d942 100644
--- a/Book/Chapter4/Figures/example-of-tree-structure-correspondence.tex
+++ b/Book/Chapter4/Figures/example-of-tree-structure-correspondence.tex
@@ -3,7 +3,7 @@
 \begin{center}
 \begin{tikzpicture}
 
-{\scriptsize
+{\small
 \begin{scope}[sibling distance=5pt, level distance = 22pt]
 \Tree[.\node(s1){VP}; [.\node(s2){PP}; ] [.\node(s3){VP}; [.\node(s4){VV}; \node[fill=white](w1){表示}; ] [.\node(s5){NN}; ] ] ]
 \end{scope}
diff --git a/Book/Chapter4/Figures/example-of-vocabulary-translation-probability.tex b/Book/Chapter4/Figures/example-of-vocabulary-translation-probability.tex
index 8deaf26..600372e 100644
--- a/Book/Chapter4/Figures/example-of-vocabulary-translation-probability.tex
+++ b/Book/Chapter4/Figures/example-of-vocabulary-translation-probability.tex
@@ -39,7 +39,7 @@
 \node[align=center,elementnode,minimum size=0.3cm,inner sep=0.1pt,fill=blue!50] (la4) at (a41) {};
 \node[align=center,elementnode,minimum size=0.3cm,inner sep=0.1pt,fill=blue!50] (la5) at (a30) {};
 
-\node[anchor=west] (f1) at ([xshift=3em,yshift=0.8em]a43.east) {\footnotesize{$\textrm{P}_{lex}(\bar{t}|\bar{s})=w(t_1|s_1)\times$}};
+\node[anchor=west] (f1) at ([xshift=3em,yshift=0.8em]a43.east) {\footnotesize{$\textrm{P}_{\textrm{lex}}(\bar{t}|\bar{s})=w(t_1|s_1)\times$}};
 \node[anchor=north] (f2) at ([xshift=5.2em]f1.south) {\footnotesize{$\frac{1}{2}(w(t_2|s_2)+w(t_4|s_2))\times$}};
 \node[anchor=north west] (f3) at (f2.south west) {\footnotesize{$w(N|s_3)\times$}};
 \node[anchor=north west] (f4) at (f3.south west) {\footnotesize{$w(t_4|s_4)\times$}};
diff --git a/Book/Chapter4/Figures/examples-of-translation-with-complex-ordering.tex b/Book/Chapter4/Figures/examples-of-translation-with-complex-ordering.tex
index 2f015f3..063ddb2 100644
--- a/Book/Chapter4/Figures/examples-of-translation-with-complex-ordering.tex
+++ b/Book/Chapter4/Figures/examples-of-translation-with-complex-ordering.tex
@@ -5,7 +5,7 @@
 
 \begin{scope}[yshift=-0in]
 
-{\tiny
+{\scriptsize
 
 \node[anchor=west] (ref) at (0,0) {{\sffamily\bfseries{参考答案:}} The Chinese star performance troupe presented a wonderful Peking opera as well as singing and dancing };
 
@@ -25,9 +25,9 @@
 
 \node[anchor=west] (synhifstpart6) at (synhifstpart5.east) {.};
 
-\node[anchor=north west] (input) at ([yshift=-10em]synhifst.south west) {\sffamily\bfseries{源语句法树:}};
+\node[anchor=north west] (input) at ([yshift=-6.5em]synhifst.south west) {\sffamily\bfseries{源语句法树:}};
 
-\begin{scope}[scale = 0.9, grow'=up, sibling distance=15pt, level distance=23pt, xshift=2.8in, yshift=-2.8in]
+\begin{scope}[scale = 0.9, grow'=up, sibling distance=5pt, level distance=23pt, xshift=3.49in, yshift=-2.8in]
 
 \Tree[.\node(tn1){IP};
         [.\node(tn2){NP}; \edge[roof]; \node[](seg1){中国$_1$ 明星$_2$ 艺术团$_3$}; ]
diff --git a/Book/Chapter4/Figures/hierarchical-phrase-rule-match-generate.tex b/Book/Chapter4/Figures/hierarchical-phrase-rule-match-generate.tex
index 14d8a42..2773cef 100644
--- a/Book/Chapter4/Figures/hierarchical-phrase-rule-match-generate.tex
+++ b/Book/Chapter4/Figures/hierarchical-phrase-rule-match-generate.tex
@@ -36,7 +36,7 @@
 \node [rectangle,inner sep=0.1em,rounded corners=1pt,draw] [fit = (h21) (h25)] (gl2) {};
 
 \draw [->,ublue,thick] ([xshift=0.6em,yshift=0.2em]n2.south) .. controls +(south:2em) and +(east:0em) ..   ([xshift=-0em,yshift=2em]gl2.west);
-\draw [->,ublue,thick] ([xshift=0em,yshift=2em]gl1.east) .. controls +(south:3em) and +(east:0em) ..   ([xshift=-0em,yshift=1.6em]gl2.west);
+\draw [->,ublue,thick] ([xshift=0em,yshift=1em]gl1.east) .. controls +(north:2.2em) and +(east:0em) ..   ([xshift=-0em,yshift=2em]gl2.west);
 
 \end{scope}
 \end{tikzpicture}
diff --git a/Book/Chapter4/Figures/operation-of-tree-replace.tex b/Book/Chapter4/Figures/operation-of-tree-replace.tex
index 2d55097..9e539ad 100644
--- a/Book/Chapter4/Figures/operation-of-tree-replace.tex
+++ b/Book/Chapter4/Figures/operation-of-tree-replace.tex
@@ -3,7 +3,7 @@
 \begin{center}
 \begin{tikzpicture}
 
-{\scriptsize
+{
 \begin{scope}[sibling distance=5pt, level distance = 22pt]
 \Tree[.\node(s1){VP}; [.\node(s2){PP}; ] [.\node(s3){VP}; [.\node(s4){VV}; \node[fill=white](w1){表示}; ] [.\node(s5){NN}; ] ] ]
 \end{scope}
diff --git a/Book/Chapter4/Figures/role-of-syntax-tree-in-different-decoding-methods.tex b/Book/Chapter4/Figures/role-of-syntax-tree-in-different-decoding-methods.tex
index 0e4d25e..7e4e1e5 100644
--- a/Book/Chapter4/Figures/role-of-syntax-tree-in-different-decoding-methods.tex
+++ b/Book/Chapter4/Figures/role-of-syntax-tree-in-different-decoding-methods.tex
@@ -3,7 +3,7 @@
 \begin{center}
 \begin{tikzpicture}
 
-\begin{scope}[scale=0.9,level distance=30pt,sibling distance=0pt]
+\begin{scope}[scale=0.9,level distance=30pt,sibling distance=7pt]
 
 {\scriptsize
 \Tree[.\node(bsn0){IP};
@@ -21,13 +21,13 @@
 \draw [->,thick] (bsw3.east) -- (target.west);
 \node [anchor=west] (sourcelabel) at ([xshift=4em,yshift=-1em]bsn0.east) {显式输入的结构};
 
-\node [anchor=west] (source2) at ([xshift=5em]target.east) {猫 喜欢 吃 鱼};
+\node [anchor=west] (source2) at ([xshift=3.3em]target.east) {猫$\ \ \;$喜欢$\ \;$吃\ 鱼};
 \node [anchor=west] (target2) at ([xshift=1em]source2.east) {Cats like eating fish};
-\node [anchor=north,inner sep=3pt] (cap2) at ([xshift=2em,yshift=-1em]target2.south west) {(b) 基于串的解码};
+\node [anchor=north,inner sep=3pt] (cap2) at ([xshift=1.1em,yshift=-1em]target2.south west) {(b) 基于串的解码};
 \draw [->,thick] (source2.east) -- (target2.west);
 
 
-\begin{scope}[xshift=2.55in,yshift=-1em,sibling distance=3pt]
+\begin{scope}[xshift=2.55in,yshift=-1em,sibling distance=7pt]
 \Tree[.\node(bsn0){IP};
           [.\node(bsn1){NP};
                [.\node(bsn2){NN}; ]
diff --git a/Book/Chapter4/Figures/three-types-of-reorder-method-in-msd.tex b/Book/Chapter4/Figures/three-types-of-reorder-method-in-msd.tex
index 97c9005..bee1062 100644
--- a/Book/Chapter4/Figures/three-types-of-reorder-method-in-msd.tex
+++ b/Book/Chapter4/Figures/three-types-of-reorder-method-in-msd.tex
@@ -55,7 +55,7 @@
 \node [anchor=west] (p1line1) at ([xshift=3.5em,yshift=0.5em]a75.east) {\footnotesize{M(monotone):单调调序}};
 \node [anchor=north west] (p1line2) at ([xshift=0,yshift=-1em]p1line1.south west) {\footnotesize{S(swap): 与前面一个短语}};
 \node [anchor=north west] (p1line3) at ([xshift=3.5em]p1line2.south west) {\footnotesize{位置进行交换}};
-\node [anchor=north west] (p1line4) at ([xshift=-3.8em,yshift=-1em]p1line3.south west) {\footnotesize{D(discontinuous):非连续调序}};
+\node [anchor=north west] (p1line4) at ([xshift=-3.5em,yshift=-1em]p1line3.south west) {\footnotesize{D(discontinuous):非连续调序}};
 
 \node [anchor=east] (p1line5) at ([xshift=0em,yshift=3em]p1line4.east) {};
 \node [anchor=east] (p1line6) at ([xshift=0em,yshift=7em]p1line4.east) {};
diff --git a/Book/Chapter4/Figures/tree-fragment-to-string-mapping.tex b/Book/Chapter4/Figures/tree-fragment-to-string-mapping.tex
index 82d6019..79cb0a5 100644
--- a/Book/Chapter4/Figures/tree-fragment-to-string-mapping.tex
+++ b/Book/Chapter4/Figures/tree-fragment-to-string-mapping.tex
@@ -3,7 +3,7 @@
 \begin{center}
 \begin{tikzpicture}
 
-\begin{scope}[scale=0.9]
+\begin{scope}[scale=1]
 \Tree[.\node(sn1){VP};
         [.\node(sn2){VV}; \node(scw1){提高}; ]
         [.\node(sn3){NN}; ]
diff --git a/Book/Chapter4/Figures/tree-to-tree-rule-extraction-base-node-alignment.tex b/Book/Chapter4/Figures/tree-to-tree-rule-extraction-base-node-alignment.tex
index dbb5db1..73fcce4 100644
--- a/Book/Chapter4/Figures/tree-to-tree-rule-extraction-base-node-alignment.tex
+++ b/Book/Chapter4/Figures/tree-to-tree-rule-extraction-base-node-alignment.tex
@@ -48,31 +48,31 @@
 \end{scope}
 
 
-\node[anchor=north](t1) at (4.7,0.3){{\scriptsize{抽取得到的规则(子树对齐)}}};
+\node[anchor=north](t1) at (4.7,0.3){{\footnotesize{抽取得到的规则(子树对齐)}}};
 \node[anchor=north](t2) at ([xshift=3.7em,yshift=0.5em]t1.south){\underline{\qquad \qquad \qquad \quad  \qquad \qquad \qquad \qquad \qquad}};
-\node[anchor=north](t3) at ([xshift=-7.7em,yshift=0.0em]t2.south){\color{gray!70}\scriptsize{$r_1$}};
-\node[anchor=west](t3-1) at ([xshift=0.0em,yshift=0.0em]t3.east){\color{gray!70}\scriptsize{AS(了) $\rightarrow$ DT(the)}};
-\node[anchor=north](t4) at ([xshift=0.0em,yshift=0.0em]t3.south){\color{gray!70}\scriptsize{$r_2$}};
-\node[anchor=west](t4-1) at ([xshift=0.0em,yshift=0.0em]t4.east){\color{gray!70}\scriptsize{NN(进口) $\rightarrow$ NNS(imports)}};
-\node[anchor=north](t5) at ([xshift=0.0em,yshift=0.0em]t4.south){\scriptsize{$r_3$}};
-\node[anchor=west](t5-1) at ([xshift=0.0em,yshift=0.0em]t5.east){\scriptsize{AD(大幅度) $\rightarrow$ RB(drastically)}};
-\node[anchor=north](t6) at ([xshift=0.0em,yshift=0.0em]t5.south){\scriptsize{$r_4$}};
-\node[anchor=west](t6-1) at ([xshift=0.0em,yshift=0.0em]t6.east){\scriptsize{VV(下降) $\rightarrow$ VBN(fallen)}};
-\node[anchor=north](t7) at ([xshift=0.0em,yshift=0.0em]t6.south){\color{gray!70}\scriptsize{$r_5$}};
-\node[anchor=west](t7-1) at ([xshift=0.0em,yshift=0.0em]t7.east){\color{gray!70}\scriptsize{IP(NN$_1$ VP(AD$_2$ VP(VV$_3$ AS$_4$)) $\rightarrow$}};
-\node[anchor=north](t8) at ([xshift=7.4em,yshift=0.0em]t7.south){\color{gray!70}\tiny{S(NP(DT$_4$ NNS$_1$) VP(VBZ(have) ADVP(RB$_2$ VBN$_3$))}};
+\node[anchor=north](t3) at ([xshift=-7.7em,yshift=0.0em]t2.south){\color{gray!70}\footnotesize{$r_1$}};
+\node[anchor=west](t3-1) at ([xshift=0.0em,yshift=0.0em]t3.east){\color{gray!70}\footnotesize{AS(了) $\rightarrow$ DT(the)}};
+\node[anchor=north](t4) at ([xshift=0.0em,yshift=0.0em]t3.south){\color{gray!70}\footnotesize{$r_2$}};
+\node[anchor=west](t4-1) at ([xshift=0.0em,yshift=0.0em]t4.east){\color{gray!70}\footnotesize{NN(进口) $\rightarrow$ NNS(imports)}};
+\node[anchor=north](t5) at ([xshift=0.0em,yshift=0.0em]t4.south){\footnotesize{$r_3$}};
+\node[anchor=west](t5-1) at ([xshift=0.0em,yshift=0.0em]t5.east){\footnotesize{AD(大幅度) $\rightarrow$ RB(drastically)}};
+\node[anchor=north](t6) at ([xshift=0.0em,yshift=0.0em]t5.south){\footnotesize{$r_4$}};
+\node[anchor=west](t6-1) at ([xshift=0.0em,yshift=0.0em]t6.east){\footnotesize{VV(下降) $\rightarrow$ VBN(fallen)}};
+\node[anchor=north](t7) at ([xshift=0.0em,yshift=0.0em]t6.south){\color{gray!70}\footnotesize{$r_5$}};
+\node[anchor=west](t7-1) at ([xshift=0.0em,yshift=0.0em]t7.east){\color{gray!70}\footnotesize{IP(NN$_1$ VP(AD$_2$ VP(VV$_3$ AS$_4$)) $\rightarrow$}};
+\node[anchor=north](t8) at ([xshift=9.4em,yshift=0.0em]t7.south){\color{gray!70}\scriptsize{S(NP(DT$_4$ NNS$_1$) VP(VBZ(have) ADVP(RB$_2$ VBN$_3$))}};
 
-\node[anchor=north](s3) at ([xshift=0.0em,yshift=-1.3em]t7.south){\red{\scriptsize{$r_{6}$}}};
-\node[anchor=west](s3-1) at ([xshift=0.0em,yshift=0.0em]s3.east){\red{\scriptsize{AS(了) $\rightarrow$ VBZ(have)}}};
-\node[anchor=north](s4) at ([xshift=0.0em,yshift=0.0em]s3.south){\red{\scriptsize{$r_{7}$}}};
-\node[anchor=west](s4-1) at ([xshift=0.0em,yshift=0.0em]s4.east){\red{\scriptsize{NN(进口) $\rightarrow$}}};
-\node[anchor=north](s5) at ([xshift=0.0em,yshift=0.0em]s4.south){\scriptsize{\color{white}{$r_{?}$}}};
-\node[anchor=west](s5-1) at ([xshift=0.0em,yshift=0.0em]s5.east){\red{\scriptsize{NP(DT(the) NNS(imports))}}};
-\node[anchor=north](s6) at ([xshift=0.0em,yshift=0.0em]s5.south){\red{\scriptsize{$r_{8}$}}};
-\node[anchor=west](s6-1) at ([xshift=0.0em,yshift=0.0em]s6.east){\red{\scriptsize{VP(AD$_1$ VP(VV$_2$ AS$_3$)) $\rightarrow$}}};
-\node[anchor=north](s7) at ([xshift=0.0em,yshift=0.0em]s6.south){\red{\scriptsize{\color{white}{$r_{?}$}}}};
-\node[anchor=west](s7-1) at ([xshift=0.0em,yshift=0.0em]s7.east){\red{\scriptsize{VP(VBZ$_3$ ADVP(RB$_1$ VBN$_2$)}}};
-\node[anchor=north](s8) at ([xshift=0.0em,yshift=0.0em]s7.south){\red{\scriptsize{$r_{9}$}}};
-\node[anchor=west](s8-1) at ([xshift=0.0em,yshift=0.0em]s8.east){\red{\scriptsize{IP(NN$_1$ VP$_2$) $\rightarrow$ S(NP$_1$ VP$_2$)}}};
+\node[anchor=north](s3) at ([xshift=0.0em,yshift=-1.3em]t7.south){\red{\footnotesize{$r_{6}$}}};
+\node[anchor=west](s3-1) at ([xshift=0.0em,yshift=0.0em]s3.east){\red{\footnotesize{AS(了) $\rightarrow$ VBZ(have)}}};
+\node[anchor=north](s4) at ([xshift=0.0em,yshift=0.0em]s3.south){\red{\footnotesize{$r_{7}$}}};
+\node[anchor=west](s4-1) at ([xshift=0.0em,yshift=0.0em]s4.east){\red{\footnotesize{NN(进口) $\rightarrow$}}};
+\node[anchor=north](s5) at ([xshift=0.0em,yshift=0.0em]s4.south){\footnotesize{\color{white}{$r_{?}$}}};
+\node[anchor=west](s5-1) at ([xshift=0.0em,yshift=0.0em]s5.east){\red{\footnotesize{NP(DT(the) NNS(imports))}}};
+\node[anchor=north](s6) at ([xshift=0.0em,yshift=0.0em]s5.south){\red{\footnotesize{$r_{8}$}}};
+\node[anchor=west](s6-1) at ([xshift=0.0em,yshift=0.0em]s6.east){\red{\footnotesize{VP(AD$_1$ VP(VV$_2$ AS$_3$)) $\rightarrow$}}};
+\node[anchor=north](s7) at ([xshift=0.0em,yshift=0.0em]s6.south){\red{\footnotesize{\color{white}{$r_{?}$}}}};
+\node[anchor=west](s7-1) at ([xshift=0.0em,yshift=0.0em]s7.east){\red{\footnotesize{VP(VBZ$_3$ ADVP(RB$_1$ VBN$_2$)}}};
+\node[anchor=north](s8) at ([xshift=0.0em,yshift=0.0em]s7.south){\red{\footnotesize{$r_{9}$}}};
+\node[anchor=west](s8-1) at ([xshift=0.0em,yshift=0.0em]s8.east){\red{\footnotesize{IP(NN$_1$ VP$_2$) $\rightarrow$ S(NP$_1$ VP$_2$)}}};
 
 \end{tikzpicture}
diff --git a/Book/Chapter4/Figures/tree-to-tree-rule-extraction-base-word-alignment.tex b/Book/Chapter4/Figures/tree-to-tree-rule-extraction-base-word-alignment.tex
index 81ca526..bc15124 100644
--- a/Book/Chapter4/Figures/tree-to-tree-rule-extraction-base-word-alignment.tex
+++ b/Book/Chapter4/Figures/tree-to-tree-rule-extraction-base-word-alignment.tex
@@ -44,30 +44,30 @@
 
 \end{scope}
 
-\node[anchor=north](t1) at (4.5,0.3){{\scriptsize{抽取得到的规则}}};
+\node[anchor=north](t1) at (4.5,0.3){{\footnotesize{抽取得到的规则}}};
 \node[anchor=north](t2) at ([xshift=5.5em,yshift=0.5em]t1.south){\underline{\qquad \qquad \qquad \quad  \qquad \qquad \qquad \qquad \qquad}};
-\node[anchor=north](t3) at ([xshift=-7.7em,yshift=0.0em]t2.south){\scriptsize{$r_1$}};
-\node[anchor=west](t3-1) at ([xshift=0.0em,yshift=0.0em]t3.east){\scriptsize{AS(了) $\rightarrow$ DT(the)}};
-\node[anchor=north](t4) at ([xshift=0.0em,yshift=0.0em]t3.south){\scriptsize{$r_2$}};
-\node[anchor=west](t4-1) at ([xshift=0.0em,yshift=0.0em]t4.east){\scriptsize{NN(进口) $\rightarrow$ NNS(imports)}};
-\node[anchor=north](t5) at ([xshift=0.0em,yshift=0.0em]t4.south){\scriptsize{$r_3$}};
-\node[anchor=west](t5-1) at ([xshift=0.0em,yshift=0.0em]t5.east){\scriptsize{AD(大幅度) $\rightarrow$ RB(drastically)}};
-\node[anchor=north](t6) at ([xshift=0.0em,yshift=0.0em]t5.south){\scriptsize{$r_4$}};
-\node[anchor=west](t6-1) at ([xshift=0.0em,yshift=0.0em]t6.east){\scriptsize{VV(下降) $\rightarrow$ VBN(fallen)}};
-\node[anchor=north](t7) at ([xshift=0.0em,yshift=0.0em]t6.south){\scriptsize{$r_6$}};
-\node[anchor=west](t7-1) at ([xshift=0.0em,yshift=0.0em]t7.east){\scriptsize{IP(NN$_1$ VP(AD$_2$ VP(VV$_3$ AS$_4$)) $\rightarrow$}};
-\node[anchor=north](t8) at ([xshift=7.4em,yshift=0.0em]t7.south){\tiny{S(NP(DT$_4$ NNS$_1$) VP(VBZ(have) ADVP(RB$_2$ VBN$_3$))}};
+\node[anchor=north](t3) at ([xshift=-7.7em,yshift=0.0em]t2.south){\footnotesize{$r_1$}};
+\node[anchor=west](t3-1) at ([xshift=0.0em,yshift=0.0em]t3.east){\footnotesize{AS(了) $\rightarrow$ DT(the)}};
+\node[anchor=north](t4) at ([xshift=0.0em,yshift=0.0em]t3.south){\footnotesize{$r_2$}};
+\node[anchor=west](t4-1) at ([xshift=0.0em,yshift=0.0em]t4.east){\footnotesize{NN(进口) $\rightarrow$ NNS(imports)}};
+\node[anchor=north](t5) at ([xshift=0.0em,yshift=0.0em]t4.south){\footnotesize{$r_3$}};
+\node[anchor=west](t5-1) at ([xshift=0.0em,yshift=0.0em]t5.east){\footnotesize{AD(大幅度) $\rightarrow$ RB(drastically)}};
+\node[anchor=north](t6) at ([xshift=0.0em,yshift=0.0em]t5.south){\footnotesize{$r_4$}};
+\node[anchor=west](t6-1) at ([xshift=0.0em,yshift=0.0em]t6.east){\footnotesize{VV(下降) $\rightarrow$ VBN(fallen)}};
+\node[anchor=north](t7) at ([xshift=0.0em,yshift=0.0em]t6.south){\footnotesize{$r_6$}};
+\node[anchor=west](t7-1) at ([xshift=0.0em,yshift=0.0em]t7.east){\footnotesize{IP(NN$_1$ VP(AD$_2$ VP(VV$_3$ AS$_4$)) $\rightarrow$}};
+\node[anchor=north](t8) at ([xshift=9.4em,yshift=0.0em]t7.south){\scriptsize{S(NP(DT$_4$ NNS$_1$) VP(VBZ(have) ADVP(RB$_2$ VBN$_3$))}};
 
-\node[anchor=north](s1) at ([yshift=-8.0em]t1.south){{\scriptsize{无法得到的规则}}};
+\node[anchor=north](s1) at ([yshift=-8.0em]t1.south){{\footnotesize{无法得到的规则}}};
 \node[anchor=north](s2) at ([xshift=5.5em,yshift=0.5em]s1.south){\underline{\qquad \qquad \qquad \quad  \qquad \qquad \qquad \qquad \qquad}};
-\node[anchor=north](s3) at ([xshift=-7.7em,yshift=0.0em]s2.south){\scriptsize{$r_{?}$}};
-\node[anchor=west](s3-1) at ([xshift=0.0em,yshift=0.0em]s3.east){\scriptsize{AS(了) $\rightarrow$ VBZ(have)}};
-\node[anchor=north](s4) at ([xshift=0.0em,yshift=0.0em]s3.south){\scriptsize{$r_{?}$}};
-\node[anchor=west](s4-1) at ([xshift=0.0em,yshift=0.0em]s4.east){\scriptsize{NN(进口) $\rightarrow$}};
-\node[anchor=north](s5) at ([xshift=0.0em,yshift=0.0em]s4.south){\scriptsize{\color{white}{$r_{?}$}}};
-\node[anchor=west](s5-1) at ([xshift=0.0em,yshift=0.0em]s5.east){\scriptsize{NP(DT(the) NNS(imports))}};
-\node[anchor=north](s6) at ([xshift=0.0em,yshift=0.0em]s5.south){\scriptsize{$r_{?}$}};
-\node[anchor=west](s6-1) at ([xshift=0.0em,yshift=0.0em]s6.east){\scriptsize{IP(NN$_1$ VP$_2$) $\rightarrow$ S(NP$_1$ VP$_2$)}};
+\node[anchor=north](s3) at ([xshift=-7.7em,yshift=0.0em]s2.south){\footnotesize{$r_{?}$}};
+\node[anchor=west](s3-1) at ([xshift=0.0em,yshift=0.0em]s3.east){\footnotesize{AS(了) $\rightarrow$ VBZ(have)}};
+\node[anchor=north](s4) at ([xshift=0.0em,yshift=0.0em]s3.south){\footnotesize{$r_{?}$}};
+\node[anchor=west](s4-1) at ([xshift=0.0em,yshift=0.0em]s4.east){\footnotesize{NN(进口) $\rightarrow$}};
+\node[anchor=north](s5) at ([xshift=0.0em,yshift=0.0em]s4.south){\footnotesize{\color{white}{$r_{?}$}}};
+\node[anchor=west](s5-1) at ([xshift=0.0em,yshift=0.0em]s5.east){\footnotesize{NP(DT(the) NNS(imports))}};
+\node[anchor=north](s6) at ([xshift=0.0em,yshift=0.0em]s5.south){\footnotesize{$r_{?}$}};
+\node[anchor=west](s6-1) at ([xshift=0.0em,yshift=0.0em]s6.east){\footnotesize{IP(NN$_1$ VP$_2$) $\rightarrow$ S(NP$_1$ VP$_2$)}};
 
 \end{tikzpicture}
 
diff --git a/Book/Chapter4/chapter4.tex b/Book/Chapter4/chapter4.tex
index 44a7187..03174ab 100644
--- a/Book/Chapter4/chapter4.tex
+++ b/Book/Chapter4/chapter4.tex
@@ -138,7 +138,7 @@
 %---------4.2基于短语的翻译模型
 \section{基于短语的翻译模型}\index{Chapter4.2}
 
-\parinterval 基于短语的翻译模型是统计机器翻译最具代表性的模型之一\cite{koehn2003statistical}\cite{chiang2007hierarchical}。这类模型易于实现，而且性能突出。统计机器翻译中很多经典的方法都出自基于短语的模型，比如：统计调序模型、最小错误率训练等等。下面就来了解一下基于短语的机器翻译是如何工作的。
+\parinterval 基于短语的翻译模型是统计机器翻译最具代表性的模型之一\cite{koehn2003statistical,chiang2007hierarchical}。这类模型易于实现，而且性能突出。统计机器翻译中很多经典的方法都出自基于短语的模型，比如：统计调序模型、最小错误率训练等等。下面就来了解一下基于短语的机器翻译是如何工作的。
 
 %--4.2.1 机器翻译中的短语---------------------
 \subsection{机器翻译中的短语}\index{Chapter4.2.1}
@@ -161,7 +161,7 @@
 \begin{definition} 短语
 
 {\small
-对于一个句子$\textbf{w} = w_1...w_n$，任意子串$w_i...w_j$($i\leq j,0\leq i,j\leq n$)都是句子\textbf{w}的一个{\red{短语}}。
+对于一个句子$\textbf{w} = w_1...w_n$，任意子串$w_i...w_j$($i\leq j,0\leq i,j\leq n$)都是句子\textbf{w}的一个{\small\sffamily\bfseries{短语}}。
 }
 \end{definition}
 %-------------------------------------------
@@ -172,20 +172,18 @@
 \begin{definition} 句子的短语切分
 
 {\small
-对于一个句子$\textbf{w} = w_1...w_n$，可以被切分为$m$个子串，则称\textbf{w}由$m$个短语组成，记为$\textbf{w} = p_1...p_m$，其中$p_i$是\textbf{w}的一个短语，$p_1...p_m$也被称作句子\textbf{w}的一个{\red{短语切分}}。
+对于一个句子$\textbf{w} = w_1...w_n$，可以被切分为$m$个子串，则称\textbf{w}由$m$个短语组成，记为$\textbf{w} = p_1...p_m$，其中$p_i$是\textbf{w}的一个短语，$p_1...p_m$也被称作句子\textbf{w}的一个{\small\sffamily\bfseries{短语切分}}。
 }
 \end{definition}
 %-------------------------------------------
 
 \parinterval 比如，对于一个句子，``$\text{机器}\ \text{翻译}\ \text{是}\ \text{一}\ \text{项}\ \text{很}\ \text{有}\ \text{挑战}\ \text{的}\ \text{问题}$''，一种可能的短语切分为：
-\begin{example}
 \begin{eqnarray}
 p_1 &=& \text{机器}\ \text{翻译} \nonumber \\ 
 p_2 &=& \text{是}\ \text{一}\ \text{项} \nonumber \\ 
 p_3 &=& \text{很有}\ \text{挑战}\ \text{的} \nonumber \\ 
 p_4 &=& \text{问题}\nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 进一步，把单语短语的概念推广到双语的情况：
 
@@ -193,13 +191,12 @@ p_4 &=& \text{问题}\nonumber
 \begin{definition} 双语短语（或短语对）
 
 {\small
-对于源语和目标语句对(\textbf{s},\textbf{t})，\textbf{s}中短语$\bar{s}_i$和\textbf{t}中的短语$\bar{t}_j$可以构成一个双语短语对($\bar{s}_i,\bar{t}_j$)，简称{\red{短语对}}($\bar{s}_i,\bar{t}_j$)。
+对于源语和目标语句对(\textbf{s},\textbf{t})，\textbf{s}中短语$\bar{s}_i$和\textbf{t}中的短语$\bar{t}_j$可以构成一个双语短语对($\bar{s}_i,\bar{t}_j$)，简称{\small\sffamily\bfseries{短语对}}($\bar{s}_i,\bar{t}_j$)。
 }
 \end{definition}
 %-------------------------------------------
 
 \parinterval 也就是说，源语言句子中任意的短语和目标语言句子中任意的短语都构成一个双语短语。这里用$\leftrightarrow$表示互译关系。对于一个双语句对``进口\ 大幅度\ 下降\ 了 $\leftrightarrow$ the imports have drastically fallen''，可以得到很多双语短语，比如：
-\begin{example}
 \begin{eqnarray}
 &&\text{大幅度}\ \leftrightarrow\ \textrm{drastically} \nonumber \\ 
 &&\text{大幅度}\ \ \text{下降}\ \leftrightarrow\ \textrm{have}\ \textrm{drastically}\ \textrm{fallen} \nonumber \\ 
@@ -208,7 +205,6 @@ p_4 &=& \text{问题}\nonumber
 &&\text{了}\ \leftrightarrow\ \textrm{have}\ \textrm{drastically} \nonumber \\ 
 &&... \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 接下来的问题是，如何使用双语短语描述双语句子的生成，即句子翻译的建模问题。在基于词的翻译模型里，我们可以用词对齐来描述双语句子的对应关系。类似的，我们也可以使用双语短语描述句子的翻译。这里，借用形式文法中{\small\sffamily\bfseries{推导}}（Derivation）的概念。把生成双语句对所使用的双语短语序列定义为一个基于短语的翻译推导：
 
@@ -216,7 +212,7 @@ p_4 &=& \text{问题}\nonumber
 \begin{definition} 基于短语的翻译推导
 
 {\small
-对于源语和目标语句对($\textbf{s}, \textbf{t}$)，分别有短语切分$\{\bar{s}_i\}$和$\{\bar{t}_j\}$，且$\{\bar{s}_i\}$和$\{\bar{t}_j\}$之间存在一一对应的关系。令$\{\bar{a}_j\}$表示$\{\bar{t}_j\}$ 中每个短语对应到源语言短语的编号，则称短语对$\{(\bar{s}_{\bar{a}_j},\bar{t}_j)\}$构成了$\textbf{s}$到$\textbf{t}$的{\red{基于短语的翻译推导}}(简称推导)，记为$d(\{(\bar{s}_{\bar{a}_j},\bar{t}_j)\},\textbf{s},\textbf{t})$(简记为$d(\{(\bar{s}_{\bar{a}_j},\bar{t}_j)\})$或$d$)。
+对于源语和目标语句对($\textbf{s}, \textbf{t}$)，分别有短语切分$\{\bar{s}_i\}$和$\{\bar{t}_j\}$，且$\{\bar{s}_i\}$和$\{\bar{t}_j\}$之间存在一一对应的关系。令$\{\bar{a}_j\}$表示$\{\bar{t}_j\}$ 中每个短语对应到源语言短语的编号，则称短语对$\{(\bar{s}_{\bar{a}_j},\bar{t}_j)\}$构成了$\textbf{s}$到$\textbf{t}$的{\small\sffamily\bfseries{基于短语的翻译推导}}(简称推导)，记为$d(\{(\bar{s}_{\bar{a}_j},\bar{t}_j)\},\textbf{s},\textbf{t})$(简记为$d(\{(\bar{s}_{\bar{a}_j},\bar{t}_j)\})$或$d$)。
 }
 \end{definition}
 %-------------------------------------------
@@ -233,10 +229,10 @@ p_4 &=& \text{问题}\nonumber
 \end{figure}
 %-------------------------------------------
 
-\parinterval 图\ref{fig:derivation-consist-of-bilingual-phrase}给出了一个由三个双语短语$\{(\bar{s}_{\bar{a}_1},\bar{t}_1),(\bar{s}_{\bar{a}_2},\bar{t}_2),(\bar{s}_{\bar{a}_3},\bar{t}_3)\}$构成的汉英互译句对，其中短语对齐信息为$\bar{a}_1 = 1$，$\bar{a}_2 = 2$，$\bar{a}_3 = 3$。这里，我们可以把这三个短语对的组合看作是翻译推导，形式化表示为如下公式。其中，${}^{\circ}$表示短语的组合\footnote[2]{短语的组合是指将两个短语a和b进行拼接，形成新的短语ab。在机器翻译中，可以把双语短语的组合看作是对目标语短语的组合。比如，对于两个双语短语$(\bar{s}_{\bar{a}_1},\bar{t}_1),(\bar{s}_{\bar{a}_2},\bar{t}_2)$，短语的组合表示将$\bar{t}_1$和$\bar{t}_2$进行组合，而源语言端作为输入已经给定，因此直接匹配源语言句子中相应的部分即可。根据两个短语在源语言中位置的不同，通常又分为顺序翻译、反序翻译、不连续翻译。关于这部分内容将会在后面调序模型的部分进行介绍。}。
+\parinterval 图\ref{fig:derivation-consist-of-bilingual-phrase}给出了一个由三个双语短语$\{(\bar{s}_{\bar{a}_1},\bar{t}_1),(\bar{s}_{\bar{a}_2},\bar{t}_2),(\bar{s}_{\bar{a}_3},\bar{t}_3)\}$构成的汉英互译句对，其中短语对齐信息为$\bar{a}_1 = 1$，$\bar{a}_2 = 2$，$\bar{a}_3 = 3$。这里，我们可以把这三个短语对的组合看作是翻译推导，形式化表示为如下公式。其中，${} \circ $表示短语的组合\footnote[2]{短语的组合是指将两个短语a和b进行拼接，形成新的短语ab。在机器翻译中，可以把双语短语的组合看作是对目标语短语的组合。比如，对于两个双语短语$(\bar{s}_{\bar{a}_1},\bar{t}_1),(\bar{s}_{\bar{a}_2},\bar{t}_2)$，短语的组合表示将$\bar{t}_1$和$\bar{t}_2$进行组合，而源语言端作为输入已经给定，因此直接匹配源语言句子中相应的部分即可。根据两个短语在源语言中位置的不同，通常又分为顺序翻译、反序翻译、不连续翻译。关于这部分内容将会在后面调序模型的部分进行介绍。}。
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-d = {(\bar{s}_{\bar{a}_1},\bar{t}_1)}^{\circ}{(\bar{s}_{\bar{a}_2},\bar{t}_2)}^{\circ}{(\bar{s}_{\bar{a}_3},\bar{t}_3)}
+d = {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)} \circ {(\bar{s}_{\bar{a}_3},\bar{t}_3)}
 \label{eqa4.1}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
@@ -280,10 +276,10 @@ d = {(\bar{s}_{\bar{a}_1},\bar{t}_1)}^{\circ}{(\bar{s}_{\bar{a}_2},\bar{t}_2)}^{
 
 \parinterval 公式\ref{eqa4.3}中，$\textrm{P}(d,\textbf{t}|\textbf{s})$表示翻译推导的概率。公式\ref{eqa4.3}把翻译问题转化为翻译推导的生成问题。但是，由于翻译推导的数量十分巨大\footnote[3]{如果把推导看作是一种树结构，推导的数量与词串的长度成指数关系。}，公式\ref{eqa4.3}的右端需要对所有可能的推导进行枚举并求和，这几乎是无法计算的。
 
-\parinterval 对于这个问题，常用的解决办法是利用一个化简的模型来近似完整的模型。如果把翻译推导的全体看作一个空间$D$，我们可以从$D$中选取一部分样本参与计算，而不是对整个$D$进行计算。比如，可以用最好的$n$个翻译推导来代表整个空间$D$。令$D_{n-best}$表示最好的$n$个翻译推导所构成的空间，于是可以定义：
+\parinterval 对于这个问题，常用的解决办法是利用一个化简的模型来近似完整的模型。如果把翻译推导的全体看作一个空间$D$，我们可以从$D$中选取一部分样本参与计算，而不是对整个$D$进行计算。比如，可以用最好的$n$个翻译推导来代表整个空间$D$。令$D_{n-\textrm{best}}$表示最好的$n$个翻译推导所构成的空间，于是可以定义：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-\textrm{P}(\textbf{t}|\textbf{s}) \approx \sum_{d \in D_{n-best}} \textrm{P}(d,\textbf{t}|\textbf{s})
+\textrm{P}(\textbf{t}|\textbf{s}) \approx \sum_{d \in D_{n-\textrm{best}}} \textrm{P}(d,\textbf{t}|\textbf{s})
 \label{eqa4.4}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
@@ -291,7 +287,7 @@ d = {(\bar{s}_{\bar{a}_1},\bar{t}_1)}^{\circ}{(\bar{s}_{\bar{a}_2},\bar{t}_2)}^{
 \parinterval 进一步，把公式\ref{eqa4.4}带入公式\ref{eqa4.2}，我们可以得到翻译的目标为：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-\hat{\textbf{t}} = \arg\max_{\textbf{t}} \sum_{d \in D_{n-best}} \textrm{P}(d,\textbf{t}|\textbf{s})
+\hat{\textbf{t}} = \arg\max_{\textbf{t}} \sum_{d \in D_{n-\textrm{best}}} \textrm{P}(d,\textbf{t}|\textbf{s})
 \label{eqa4.5}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
@@ -328,7 +324,7 @@ d = {(\bar{s}_{\bar{a}_1},\bar{t}_1)}^{\circ}{(\bar{s}_{\bar{a}_2},\bar{t}_2)}^{
 \end{eqnarray}
 %公式--------------------------------------------------------------------
 
-\parinterval 注意，公式\ref{eqa4.8}-\ref{eqa4.9}和公式\ref{eqa4.7}本质上是一样的。它们也构成了统计机器翻译中最常用的方法 - Viterbi方法。在后面机器翻译的解码中我们还会看到它们的应用。而公式\ref{eqa4.5}也被称作$n$-best方法，常常作为Viterbi方法的一种改进。
+\parinterval 注意，公式\ref{eqa4.8}-\ref{eqa4.9}和公式\ref{eqa4.7}本质上是一样的。它们也构成了统计机器翻译中最常用的方法 – Viterbi方法。在后面机器翻译的解码中我们还会看到它们的应用。而公式\ref{eqa4.5}也被称作$n$-best方法，常常作为Viterbi方法的一种改进。
 
 %%%%%%%%%%%%%%%%%%
 \subsubsection{对数线性模型}\index{Chapter4.2.2.2}
@@ -345,7 +341,7 @@ d = {(\bar{s}_{\bar{a}_1},\bar{t}_1)}^{\circ}{(\bar{s}_{\bar{a}_2},\bar{t}_2)}^{
 \parinterval 公式\ref{eqa4.11}是一种典型的{\small\sffamily\bfseries{对数线性模型}}（Log-linear Model）。所谓``对数线型''体现在对多个量求和后进行指数运算（$\textrm{exp}(\cdot)$），这相当于对多个因素进行乘法。公式\ref{eqa4.10}的右端是一种归一化操作。分子部分可以被看作是一种对翻译推导$d$的对数线型建模。具体来说，对于每个$d$，我们用$M$个特征对其进行描述，每个特征用函数$h_i (d,\textbf{t},\textbf{s})$表示。每个特征都对应一个权重$\lambda_i$，表示特征$i$的重要性。$\sum_{i=1}^{M} \lambda_i \cdot h_i (d,\textbf{t},\textbf{s})$表示了对这些特征的线型加权和，值越大表示模型得分越高，相应的$d$和\textbf{t}的质量越高。公式\ref{eqa4.10}的分母部分实际上不需要计算，因为其值与求解最佳推导的过程无关。把公式\ref{eqa4.10}带入公式\ref{eqa4.8}得到：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-\hat{d} &=& \arg\max_{d} \frac{\textrm{exp}(\textrm{score}(d,\textbf{t},\textbf{s}))}{\sum_{d',\textbf{t}'} \textrm{exp}(\textrm{score}(d',\textbf{t}',\textbf{s}))} \\ \nonumber
+\hat{d} &=& \arg\max_{d} \frac{\textrm{exp}(\textrm{score}(d,\textbf{t},\textbf{s}))}{\sum_{d',\textbf{t}'} \textrm{exp}(\textrm{score}(d',\textbf{t}',\textbf{s}))} \nonumber \\ 
 &=& \arg\max_{d}\ \textrm{exp}(\textrm{score}(d,\textbf{t},\textbf{s}))
 \label{eqa4.12}
 \end{eqnarray}
@@ -445,7 +441,7 @@ d = {(\bar{s}_{\bar{a}_1},\bar{t}_1)}^{\circ}{(\bar{s}_{\bar{a}_2},\bar{t}_2)}^{
 %%%%%%%%%%%%%%%%%%
 \subsubsection{获取词对齐}\index{Chapter4.2.3.2}
 
-\parinterval 词对齐如何获得呢？上一章介绍的IBM模型本身就是一个词对齐模型，因此一种常用的方法是直接使用IBM模型生成词对齐。IBM模型约定每个源语言单词必须对应、也只能对应到一个目标语单词。因此，IBM模型得到的词对齐结果是不对称的。正常情况下词对齐可以是一个源语言单词对应多个目标语言单词，或者多对一，甚至多对多的情况。为了获得对称的词对齐，一种简单的方法是，分别进行正向翻译和反向翻译的词对齐，然后利用启发性方法生成对称的词对齐，例如，双向词对齐取交集、并集等。如图\ref{fig:get-word-alignment}中，左边两个图就是正向和反向两种词对齐的结果。右边的图是融合双向词对齐的结果，取交集是蓝色的方框，取并集是红色的方框。当然，还可以设计更多的启发性规则生成词对齐\cite{koehn2000estimating}\cite{koehn2007factored}。
+\parinterval 词对齐如何获得呢？上一章介绍的IBM模型本身就是一个词对齐模型，因此一种常用的方法是直接使用IBM模型生成词对齐。IBM模型约定每个源语言单词必须对应、也只能对应到一个目标语单词。因此，IBM模型得到的词对齐结果是不对称的。正常情况下词对齐可以是一个源语言单词对应多个目标语言单词，或者多对一，甚至多对多的情况。为了获得对称的词对齐，一种简单的方法是，分别进行正向翻译和反向翻译的词对齐，然后利用启发性方法生成对称的词对齐，例如，双向词对齐取交集、并集等。如图\ref{fig:get-word-alignment}中，左边两个图就是正向和反向两种词对齐的结果。右边的图是融合双向词对齐的结果，取交集是蓝色的方框，取并集是红色的方框。当然，还可以设计更多的启发性规则生成词对齐\cite{koehn2000estimating,koehn2007factored}。
 
 %----------------------------------------------
 % 图4.16
@@ -475,7 +471,7 @@ d = {(\bar{s}_{\bar{a}_1},\bar{t}_1)}^{\circ}{(\bar{s}_{\bar{a}_2},\bar{t}_2)}^{
 \parinterval 当遇到低频短语时，短语翻译概率的估计可能会不准确。例如，短语$\bar{s}$和$\bar{t}$在语料中只出现了一次，且在一个句子中共现，那么$\bar{s}$到$\bar{t}$的翻译概率为$\textrm{P}(\bar{t}|\bar{s})=1$，这显然是不合理的，因为$\bar{s}$和$\bar{t}$的出现完全可能是偶然事件。既然直接度量双语短语的好坏会面临数据稀疏问题，一个自然的想法就是把短语拆解成单词，利用双语短语中单词翻译的好坏间接度量双语短语的好还。为了达到这个目的，可以使用{\small\sffamily\bfseries{词汇化翻译概率}}（Lexical Translation Probability）。前面我们借助词对齐信息完成了双语短语的抽取，因此，词对齐信息本身就包含了短语内部单词之间的对应关系。我们同样可以借助词对齐来计算词汇翻译概率，公式如下：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-\textrm{$\textrm{P}_{lex}$}(\bar{t}|\bar{s}) = \prod_{j=1}^{J} \frac{1}{|\{j|a(j,i) = 1\}|} \sum_{\forall(j,i):a(j,i) = 1} w(t_i|s_j)
+\textrm{$\textrm{P}_{\textrm{lex}}$}(\bar{t}|\bar{s}) = \prod_{j=1}^{J} \frac{1}{|\{j|a(j,i) = 1\}|} \sum_{\forall(j,i):a(j,i) = 1} w(t_i|s_j)
 \label{eqa4.14}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
@@ -524,7 +520,7 @@ d = {(\bar{s}_{\bar{a}_1},\bar{t}_1)}^{\circ}{(\bar{s}_{\bar{a}_2},\bar{t}_2)}^{
 
 \parinterval 基于距离的调序是最简单的一种调序模型。很多时候，语言的翻译基本上都是顺序的，也就是，译文单词出现的顺序和源语言单词的顺序基本上是一致的。反过来说，如果译文和源语言单词（或短语）的顺序差别很大，就认为出现了调序。
 
-\parinterval 基于距离的调序方法的核心思想就是度量当前翻译结果与顺序翻译之间的差距。对于译文中的第$i$个短语，令$start_i$表示它所对应的源语言短语中第一个词所在的位置，$end_i$是这个短语中最后一个词所在的位置。于是，这个短语（相对于前一个短语）的调序距离为：
+\parinterval 基于距离的调序方法的核心思想就是度量当前翻译结果与顺序翻译之间的差距。对于译文中的第$i$个短语，令$\textrm{start}_i$表示它所对应的源语言短语中第一个词所在的位置，$\textrm{end}_i$是这个短语中最后一个词所在的位置。于是，这个短语（相对于前一个短语）的调序距离为：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
 dr = \textrm{start}_i-\textrm{end}_{i-1}-1
@@ -544,12 +540,12 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \end{figure}
 %-------------------------------------------
 
-\parinterval 如果把调序距离作为特征，一般会使用指数函数$f(dr) = a^{|dr|}$作为特征函数（或者调序代价的函数），其中$a$是一个参数，控制调序距离对整个特征值的影响。调序距离$dr$的绝对值越大，调序代价越高。基于距离的调序模型比较适用于像法-英翻译这样的任务，因为两种语言的语序基本上是一致的。但是，对于汉-日翻译，由于句子结构存在很大差异（日语是谓词后置，而汉语中谓词放在宾语前），使用基于距离的调序会带来一些问题。因此，具体应用时应该根据语言之间的差异性有选择的使用该模型。
+\parinterval 如果把调序距离作为特征，一般会使用指数函数$f(dr) = a^{|dr|}$作为特征函数（或者调序代价的函数），其中$a$是一个参数，控制调序距离对整个特征值的影响。调序距离$dr$的绝对值越大，调序代价越高。基于距离的调序模型比较适用于像法–英翻译这样的任务，因为两种语言的语序基本上是一致的。但是，对于汉–日翻译，由于句子结构存在很大差异（日语是谓词后置，而汉语中谓词放在宾语前），使用基于距离的调序会带来一些问题。因此，具体应用时应该根据语言之间的差异性有选择的使用该模型。
 
 %%%%%%%%%%%%%%%%%%
 \subsubsection{基于方向的调序}\index{Chapter4.2.4.2}
 
-\parinterval 基于方向的调序模型是另一种常用的调序模型。该模型是一种典型的词汇化调序模型，因此调序的结果会根据不同短语有所不同。简单来说，在给定双语短语的情况下，该模型会判断它在目标语短端的调序情况，包含三种调序类型：顺序的单调翻译（M）、与前一个短语交换位置（S）、非连续翻译（D）。因此，这个模型也被称作MSD调序模型cite{Gros2008MSD}。图\ref{fig:three-types-of-reorder-method-in-msd}展示了这三种调序类型，当两个短语对在源语言和目标语言中都是按顺序排列时，它们就是单调的（如：从左边数前两个短语）；如果对应的短语顺序在目标语中是反过来的，属于交换调序（如：从左边数第三和第四个短语）；如果两个短语之间还有其它的短语，就是非连续翻译（如：从右边数的前两个短语）。
+\parinterval 基于方向的调序模型是另一种常用的调序模型。该模型是一种典型的词汇化调序模型，因此调序的结果会根据不同短语有所不同。简单来说，在给定双语短语的情况下，该模型会判断它在目标语短端的调序情况，包含三种调序类型：顺序的单调翻译（M）、与前一个短语交换位置（S）、非连续翻译（D）。因此，这个模型也被称作MSD调序模型\cite{Gros2008MSD}。图\ref{fig:three-types-of-reorder-method-in-msd}展示了这三种调序类型，当两个短语对在源语言和目标语言中都是按顺序排列时，它们就是单调的（如：从左边数前两个短语）；如果对应的短语顺序在目标语中是反过来的，属于交换调序（如：从左边数第三和第四个短语）；如果两个短语之间还有其它的短语，就是非连续翻译（如：从右边数的前两个短语）。
 
 %----------------------------------------------
 % 图4.21
@@ -601,13 +597,13 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \parinterval 基于短语的模型使用判别式模型对翻译推导进行建模，给定双语句对$(\textbf{s},\textbf{t})$，每个翻译推导$d$都有一个模型得分，由$M$个特征线性加权得到，记为$\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})$表示特征函数（简记为$h_i (d)$）。这些特征包含我们刚刚介绍过的短语翻译概率、调序模型得分等，除此之外，还包含语言模型等其它特征，它们共同组成了特征集合。这里列出了基于短语的模型中常用的特征：
 
 \begin{itemize}
-\item 短语翻译概率（取对数），包含正向翻译概率$\textrm{log}(\textrm{Pr}(\bar{t}|\bar{s}))$和反向翻译概率$\textrm{log}(\textrm{Pr}(\bar{s}|\bar{t}))$，它们是基于短语的模型中最主要的特征；
-\item 词汇化翻译概率（取对数），同样包含正向词汇化翻译概率$\textrm{log(Pr}_{lex}(\bar{t}|\bar{s}\textrm{))}$和反向词汇化翻译概率$\textrm{log(Pr}_{lex}(\bar{s}|\bar{t}\textrm{))}$，它们用来描述双语短语中单词之间对应的好坏；
+\item 短语翻译概率（取对数），包含正向翻译概率$\textrm{log}(\textrm{P}(\bar{t}|\bar{s}))$和反向翻译概率$\textrm{log}(\textrm{P}(\bar{s}|\bar{t}))$，它们是基于短语的模型中最主要的特征；
+\item 词汇化翻译概率（取对数），同样包含正向词汇化翻译概率$\textrm{log(P}_{\textrm{lex}}(\bar{t}|\bar{s}\textrm{))}$和反向词汇化翻译概率$\textrm{log(P}_{\textrm{lex}}(\bar{s}|\bar{t}\textrm{))}$，它们用来描述双语短语中单词之间对应的好坏；
 \item $n$-gram语言模型，用来度量译文的流畅程度，可以通过大规模目标端单语数据得到；
 \item 译文长度，避免模型倾向于短译文，同时让系统自动学习对译文长度的偏好；
 \item 翻译规则数量，为了避免模型仅使用少量特征构成翻译推导（规则数量少，短语翻译概率相乘的因子也会少，得分一般会大一些），同时让系统自动学习对规则数量的偏好；
 \item 被翻译为空的源语言单词数量。注意，空翻译规则有时也被称作evil feature，这类特征在一些数据上对BLEU有很好的提升作用，但会造成人工评价结果的下降，需要谨慎使用；
-\item 基于MSD的调序模型，包括与前一个短语的调序模型$f_{M-pre}(d)$、$f_{S-pre}(d)$、$f_{D-pre}(d)$和与后一个短语的调序模型$f_{M-fol}(d)$、$f_{S-fol}(d)$、$f_{D-fol}(d)$，共6个特征。
+\item 基于MSD的调序模型，包括与前一个短语的调序模型$f_{\textrm{M-pre}}(d)$、$f_{\textrm{S-pre}}(d)$、$f_{\textrm{D-pre}}(d)$和与后一个短语的调序模型$f_{\textrm{M-fol}}(d)$、$f_{\textrm{S-fol}}(d)$、$f_{\textrm{D-fol}}(d)$，共6个特征。
 \end{itemize}
 
 %--4.2.6 最小错误率训练---------------------
@@ -636,7 +632,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \parinterval 其中\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})$。则式191可改写为：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-\lambda^{\ast} &=& \arg\min_{\lambda} 1 - \textrm{BLEU}(\textbf{D}^{\ast},\textbf{R}) \\ \nonumber
+\lambda^{\ast} &=& \arg\min_{\lambda}\ 1 - \textrm{BLEU}(\textbf{D}^{\ast},\textbf{R})   \nonumber \\
 &=& \arg\max_{\lambda} \textrm{BLEU}(\textbf{D}^{\ast},\textbf{R})
 \label{eqa4.19}
 \end{eqnarray}
@@ -679,8 +675,8 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \parinterval 假设对于每个输入的句子，翻译模型生成了两个推导$\textbf{d} = \{d_1,d_2\}$，每个推导$d$的得分score($d$)可以表示成关于某个第$i$个特征的权重$\lambda_i$的线性函数：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-\textrm{score}(d) &=& \sum_{k=1}^{M} \lambda_k \cdot h_k (d) \\ \nonumber
-&=& h_i (d) \cdot \lambda_i + \sum_{k \neq i}^{M} \lambda_k \cdot h_k (d) \\ \nonumber
+\textrm{score}(d) &=& \sum_{k=1}^{M} \lambda_k \cdot h_k (d) \nonumber \\
+&=& h_i (d) \cdot \lambda_i + \sum_{k \neq i}^{M} \lambda_k \cdot h_k (d) \nonumber \\ 
 &=& a \cdot \lambda_i + b
 \label{eqa4.20}
 \end{eqnarray}
@@ -815,7 +811,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 
 \parinterval 当质量较差的翻译假设在扩展早期出现时，我们希望裁剪掉这些翻译假设，这样可以忽略所有从它扩展出来的翻译假设，进而有效地减小搜索空间。但是这样做也存在着一定的问题，首先，删除的翻译假设可能会在后续的扩展过程中被重新搜索出来。其次，过早的删除某些翻译假设可能会导致无法搜索到最优的翻译假设。我们既希望尽早删除质量差的翻译假设，同时也不希望它们对整个搜索结果产生过大影响。但是这个``质量''，从哪个方面来衡量，也是一个需要思考的问题。理想的情况就是从早期的翻译假设中，挑选一些可比的翻译假设进行筛选。
 
-\parinterval 目前比较通用的做就是将翻译假设进行整理，放进一种栈结构中。这里所说的`栈''是为了描述方便的一种说法。它实际上就是保存多个翻译假设的一种数据结构\footnote[4]{虽然被称作栈，实际上使用一个堆进行实现。这样可以根据模型得分对翻译假设进行排序。}。当放入栈的翻译假设超过一定阈值时（比如200），可以删除掉模型得分低的翻译假设。一般，会使用多个栈来保存翻译假设，每个栈代表覆盖源语言单词数量相同的翻译假设。比如，第一个堆栈包含了覆盖一个源语言单词的翻译假设，第二个堆栈包含了覆盖两个源语言单词的翻译假设，以此类推。利用覆盖源语言单词数进行栈的划分的原因在于：翻译相同数量的单词所对应的翻译假设一般是`可比的''，因此在同一个栈里对它们进行剪枝带来的风险较小。
+\parinterval 目前比较通用的做就是将翻译假设进行整理，放进一种栈结构中。这里所说的``栈''是为了描述方便的一种说法。它实际上就是保存多个翻译假设的一种数据结构\footnote[4]{虽然被称作栈，实际上使用一个堆进行实现。这样可以根据模型得分对翻译假设进行排序。}。当放入栈的翻译假设超过一定阈值时（比如200），可以删除掉模型得分低的翻译假设。一般，会使用多个栈来保存翻译假设，每个栈代表覆盖源语言单词数量相同的翻译假设。比如，第一个堆栈包含了覆盖一个源语言单词的翻译假设，第二个堆栈包含了覆盖两个源语言单词的翻译假设，以此类推。利用覆盖源语言单词数进行栈的划分的原因在于：翻译相同数量的单词所对应的翻译假设一般是``可比的''，因此在同一个栈里对它们进行剪枝带来的风险较小。
 
 \parinterval 在基于栈的解码中，每次都会从所有的栈中弹出一个翻译假设，并选择一个或者若干个翻译假设进行扩展，之后把新得到的翻译假设重新压入解码栈中。这个过程不断执行，并可以配合束剪枝、假设重组等技术。最后在覆盖所有源语言单词的栈中可以得到整个句子的译文。图\ref{fig:example-of-stack-decode}展示了一个简单的栈解码过程。第一个栈（0号栈）用来存放空翻译假设。之后我们通过假设扩展，不断将翻译假设填入对应的栈中。
 
@@ -833,14 +829,11 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \section{基于层次短语的模型}\index{Chapter4.3}
 
 \parinterval 在机器翻译中，如果翻译需要局部上下文的信息，把短语作为翻译单元是一种理想的方案。但是，单词之间的关系并不总是``局部''的，很多时候我们需要距离更远一些的搭配。比较典型的例子是含有从句的情况。比如：
+\begin{eqnarray}
+\qquad \textrm{{\small\sffamily\bfseries{我}}\ \ 在\ \ 今天\ \ 早上\ \ 没有\ \ 吃\ \ 早\ \ 饭\ \ 的\ \ 情况\ \ 下\ \ 还是\ \ 正常\ \ {\small\sffamily\bfseries{去}}\ \ {\small\sffamily\bfseries{上班}}\ \ 了。} \nonumber
+\end{eqnarray}
 
-\begin{example}
-\quad
-
-\quad {\small\sffamily\bfseries{我}}\ \ 在\ \ 今天\ \ 早上\ \ 没有\ \ 吃\ \ 早\ \ 饭\ \ 的\ \ 情况\ \ 下\ \ 还是\ \ 正常\ \ {\small\sffamily\bfseries{去}}\ \ {\small\sffamily\bfseries{上班}}\ \ 了 。
-\end{example}
-
-\noindent 这句话的主语``我''和谓语``去 上班''构成了主谓搭配，而二者之间的部分是状语。显然，用短语去捕捉这个搭配需要覆盖很长的词串，也就是整个``我 … 去 上班''的部分。如果把这样的短语考虑到建模中，会面临非常严重的数据稀疏问题，因为无法保证这么长的词串在训练数据中能够出现。实际上，随着短语长度变长，短语在数据中会变得越来越低频，相关的统计特征也会越来越不可靠。表\ref{tab:trainingdata-phrase-frequency}就展示了不同长度的短语在训练数据中出现的频次。可以看到，长度超过3的短语已经非常低频了，更长的短语甚至在训练数据中一次也没有出现过。
+\parinterval 这句话的主语``我''和谓语``去 上班''构成了主谓搭配，而二者之间的部分是状语。显然，用短语去捕捉这个搭配需要覆盖很长的词串，也就是整个``我 $...$ 去 上班''的部分。如果把这样的短语考虑到建模中，会面临非常严重的数据稀疏问题，因为无法保证这么长的词串在训练数据中能够出现。实际上，随着短语长度变长，短语在数据中会变得越来越低频，相关的统计特征也会越来越不可靠。表\ref{tab:trainingdata-phrase-frequency}就展示了不同长度的短语在训练数据中出现的频次。可以看到，长度超过3的短语已经非常低频了，更长的短语甚至在训练数据中一次也没有出现过。
 
 %----------------------------------------------
 % 表4.1
@@ -878,56 +871,42 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 %-------------------------------------------
 
 \parinterval 这个例子也在一定程度上说明了长距离的调序需要额外的机制才能得到更好的被处理。实际上，1和2之间的调序现象本身对应了一种结构，或者说模板。也就是汉语中的：
-\begin{example}
 \begin{eqnarray}
 \text{与}\ \ \text{[什么东西]}\ \ \text{有}\ \ \text{[什么事]} \quad \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 可以翻译成：
-\begin{example}
 \begin{eqnarray}
 \textrm{have}\ \ \text{[什么事]}\ \ \textrm{with}\ \ \text{[什么东西]} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 这里[什么东西]和[什么事]表示模板中的变量，可以被其它词序列替换。通常，可以把这个模板形式化描述为：
-\begin{example}
 \begin{eqnarray}
 \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{example}
 
 \parinterval 其中逗号分隔了源语言和目标语言部分，$\textrm{X}_1$和$\textrm{X}_2$表示模板中需要替换的内容，或者说变量。源语言中的变量和目标语言中的变量是一一对应的，比如，源语言中的$\textrm{X}_1$和目标语言中的$\textrm{X}_1$代表这两个变量可以``同时''被替换。假设给定短语对：
-\begin{example}
 \begin{eqnarray}
-&\langle \ \text{北韩},\quad \textrm{North Korea} \ \rangle \qquad\quad  \nonumber \\
-&\langle \ \text{邦交},\quad \textrm{diplomatic relations} \ \rangle \nonumber
+\langle \ \text{北韩},\quad \textrm{North Korea} \ \rangle \qquad\ \quad\quad\ \  \nonumber \\
+\langle \ \text{邦交},\quad \textrm{diplomatic relations} \ \rangle\quad\ \ \ \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 我们可以使用第一个短语替换模板中的变量$\textrm{X}_1$，得到：
-\begin{example}
 \begin{eqnarray}
 \langle \ \text{与}\ \text{[北韩]}\ \text{有}\ \textrm{X}_2,\quad \textrm{have}\ \textrm{X}_2\ \textrm{with}\ \textrm{[North Korea]} \ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 其中，$[\cdot]$表示被替换的部分。可以看到，在源语言和目标语言中，$\textrm{X}_1$被同时替换为相应的短语。进一步，我们可以用第二个短语替换$\textrm{X}_2$，得到：
-\begin{example}
 \begin{eqnarray}
-\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{example}
 
 \parinterval 至此，我们就得到了一个完整词串的译文。类似的，我们还可以写出其它的翻译模板，如下：
-\begin{example}
 \begin{eqnarray}
-&\langle \ \textrm{X}_1\ \text{是}\ \textrm{X}_2,\quad \textrm{X}_1\ \textrm{is}\ \textrm{X}_2 \ \rangle \qquad\quad\,  \nonumber \\
-&\langle \ \textrm{X}_1\ \text{之一},\quad \textrm{one}\ \textrm{of}\ \textrm{X}_1 \ \rangle \qquad\quad\; \nonumber \\
-&\langle \ \textrm{X}_1\ \text{的}\ \textrm{X}_2,\quad \textrm{X}_2\ \textrm{that}\ \textrm{have}\ \textrm{X}_1 \ \rangle \nonumber
+\langle \ \textrm{X}_1\ \text{是}\ \textrm{X}_2,\quad \textrm{X}_1\ \textrm{is}\ \textrm{X}_2 \ \rangle \qquad\qquad\ \nonumber \\
+\langle \ \textrm{X}_1\ \text{之一},\quad \textrm{one}\ \textrm{of}\ \textrm{X}_1 \ \rangle \qquad\qquad\ \nonumber \\
+\langle \ \textrm{X}_1\ \text{的}\ \textrm{X}_2,\quad \textrm{X}_2\ \textrm{that}\ \textrm{have}\ \textrm{X}_1\ \rangle\quad\ \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 使用上面这种变量替换的方式，就可以得到一个完整句子的翻译。这个过程如图\ref{fig:translation-rule-describe-two-sentence-generation}所示。其中，左右相连接的方框表示翻译模版的源语言和目标语言部分。可以看到，模版中两种语言中的变量会被同步替换，替换的内容可以是其它模版生成的结果。这也就对应了一种层次结构，或者说互译的句对可以被双语的层次结构同步生成出来。
 
@@ -946,7 +925,7 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 %--4.3.1 同步上下文无关文法---------------------
 \subsection{同步上下文无关文法}\index{Chapter4.3.1}
 
-\parinterval {\small\sffamily\bfseries{基于层次短语的模型}}（\textbf{Hierarchical Phrase-based Model}）是David Chiang于2015提出的统计机器翻译模型\cite{chiang2005a}\cite{chiang2007hierarchical}。这个模型可以很好的解决短语系统对翻译中长距离调序建模不足的问题。基于层次短语的系统也在多项机器翻译比赛中取得了很好的成绩。这项工作也获得了自然处理领域顶级会议ACL2015的最佳论文奖。
+\parinterval {\small\sffamily\bfseries{基于层次短语的模型}}（Hierarchical Phrase-based Model）是David Chiang于2015提出的统计机器翻译模型\cite{chiang2005a,chiang2007hierarchical}。这个模型可以很好的解决短语系统对翻译中长距离调序建模不足的问题。基于层次短语的系统也在多项机器翻译比赛中取得了很好的成绩。这项工作也获得了自然处理领域顶级会议ACL2015的最佳论文奖。
 
 \parinterval 层次短语模型的核心是把翻译问题归结为两种语言词串的同步生成问题。实际上，词串的生成问题是自然语言处理中的经典问题，早期的研究更多的是关注单语句子的生成，比如，如何使用句法树描述一个句子的生成过程。层次短语模型的创新之处是把传统单语词串的生成推广到双语词串的同步生成上。这使得机器翻译可以使用类似句法分析的方法进行求解。
 
@@ -977,50 +956,41 @@ dr = \textrm{start}_i-\textrm{end}_{i-1}-1
 \parinterval 根据这个定义，源语言和目标语言有不同的终结符集合（单词），但是它们会共享同一个非终结符集合（变量）。每个产生式包括源语言和目标语言两个部分，分别表示由规则左部生成的源语言和目标语言符号串。由于产生式会同时生成两种语言的符号串，因此这是一种``同步''生成，可以很好的描述翻译中两个词串的对应。
 
 \parinterval 下面是一个简单的SCFG实例：
-\begin{example}
 \begin{eqnarray}
 \textrm{S}\ &\to\ &\langle \ \textrm{NP}_1\ \text{希望}\ \textrm{VP}_2,\quad \textrm{NP}_1\ \textrm{wish}\ \textrm{to}\ \textrm{VP}_2\ \rangle \nonumber \\
 \textrm{VP}\ &\to\ &\langle \ \text{对}\ \textrm{NP}_1\ \text{感到}\ \textrm{VP}_2,\quad \textrm{be}\ \textrm{VP}_2\ \textrm{wish}\ \textrm{NP}_1\ \rangle \nonumber \\
 \textrm{NN}\ &\to\ &\langle \ \text{强大},\quad \textrm{strong}\ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 这里的S、NP、VP等符号可以被看作是具有句法功能的标记，因此这个文法和传统句法分析中的CFG很像，只是CFG是单语文法，而SCFG是双语同步文法。当然，复杂的句法功能标记并不是必须的。比如，我们也可以使用更简单的文法形式：
-\begin{example}
 \begin{eqnarray}
 \textrm{X}\ &\to\ &\langle \ \textrm{X}_1\ \text{希望}\ \textrm{X}_2,\quad \textrm{X}_1\ \textrm{wish}\ \textrm{to}\ \textrm{X}_2\ \rangle \nonumber \\
 \textrm{X}\ &\to\ &\langle \ \text{对}\ \textrm{X}_1\ \text{感到}\ \textrm{X}_2,\quad \textrm{be}\ \textrm{X}_2\ \textrm{wish}\ \textrm{X}_1\ \rangle \nonumber \\
 \textrm{X}\ &\to\ &\langle \ \text{强大},\quad \textrm{strong}\ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
-\parinterval 这个文法只有一种非终结符X，因此所有的变量都可以使用任意的产生式进行推导。这就给翻译提供了更大的自由度，也就是说，规则可以被任意使用，进行自由组合。这也符合基于短语的模型中对短语进行灵活拼接的思想。基于此，层次短语系统中也使用这种并不依赖语言学句法标记的文法。在本章的内容中，如果没有特殊说明，我们把这种没有语言学句法标记的文法称作{\small\sffamily\bfseries{基于层次短语的文法}}（\textbf{Hierarchical Phrase-based Grammar}），或简称层次短语文法。
+\parinterval 这个文法只有一种非终结符X，因此所有的变量都可以使用任意的产生式进行推导。这就给翻译提供了更大的自由度，也就是说，规则可以被任意使用，进行自由组合。这也符合基于短语的模型中对短语进行灵活拼接的思想。基于此，层次短语系统中也使用这种并不依赖语言学句法标记的文法。在本章的内容中，如果没有特殊说明，我们把这种没有语言学句法标记的文法称作{\small\sffamily\bfseries{基于层次短语的文法}}（Hierarchical Phrase-based Grammar），或简称层次短语文法。
 
 %%%%%%%%%%%%%%%%%%
 \subsubsection{推导}\index{Chapter4.3.1.2}
 
 \parinterval 下面是一个完整的层次短语文法：
-\begin{example}
 \begin{eqnarray}
 r_1:\quad \textrm{X}\ &\to\ &\langle \ \text{进口}\ \textrm{X}_1,\quad \textrm{The}\ \textrm{imports}\ \textrm{X}_1\ \rangle \nonumber \\
 r_2:\quad \textrm{X}\ &\to\ &\langle \ \textrm{X}_1\ \text{下降}\ \textrm{X}_2,\quad \textrm{X}_2\ \textrm{X}_1\ \textrm{fallen}\ \rangle \nonumber \\
 r_3:\quad \textrm{X}\ &\to\ &\langle \ \text{大幅度},\quad \textrm{drastically}\ \rangle \nonumber \\
 r_4:\quad \textrm{X}\ &\to\ &\langle \ \text{了},\quad \textrm{have}\ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 其中，规则$r_1$和$r_2$是含有变量的规则，这些变量可以被其它规则的右部替换；规则$r_2$是调序规则；规则$r_3$和$r_4$是纯词汇化规则，表示单词或者短语的翻译。
 
 \parinterval 对于一个双语句对：
-\begin{example}
 \begin{eqnarray}
 &\text{{\small\sffamily\bfseries{源语}}：}\ \ \ &\text{进口}\ \text{大幅度}\ \text{下降}\ \text{了} \nonumber \\
 &\text{{\small\sffamily\bfseries{目标语}}：}&\textrm{The}\ \textrm{imports}\ \textrm{have}\ \textrm{drastically}\ \textrm{fallen} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 我们可以进行如下的推导（假设起始符号是X）：
-\begin{example}
 \begin{eqnarray}
 & & \langle\ \textrm{X}_1, \textrm{X}_1\ \rangle \nonumber \\
 & \xrightarrow[]{r_1} & \langle\ {\red{\textrm{进口}\ \textrm{X}_2}},\ {\red{\textrm{The imports}\ \textrm{X}_2}}\ \rangle \nonumber \\
@@ -1030,12 +1000,11 @@ r_4:\quad \textrm{X}\ &\to\ &\langle \ \text{了},\quad \textrm{have}\ \rangle \
 & \xrightarrow[]{r_4} & \langle\ \textrm{进口}\ \textrm{大幅度}\ \textrm{下降}\ {\red{\textrm{了}}}, \nonumber \\
 & & \ \textrm{The imports}\ {\red{\textrm{have}}}\ \textrm{drastically}\ \textrm{fallen}\ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 其中，每使用一次规则就会同步替换源语言和目标语言符号串中的一个非终结符。通常，可以把上面这个过程称作翻译推导，记为：
 %公式--------------------------------------------------------------------
 \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}
 \label{eqa4.22}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
@@ -1046,22 +1015,18 @@ d = {r_1}^{\circ}{r_2}^{\circ}{r_3}^{\circ}{r_4}
 \subsubsection{胶水规则}\index{Chapter4.3.1.3}
 
 \parinterval 由于翻译现象非常复杂，在实际系统中往往需要把两个局部翻译线性拼接到一起。在层次短语模型中，这个问题通过引入胶水规则（Glue Rule）来处理，形式如下：
-\begin{example}
 \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{X}_1,\ \textrm{X}_1\ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 胶水规则引入了一个新的非终结符S，S只能和X进行顺序拼接，或者S由X生成。如果把S看作文法的起始符，使用胶水规则后，相当于对句子划分为若干个部分，每个部分都被归纳为X。之后，顺序的把这些X拼接到一起，得到最终的译文。比如，最极端的情况，整个句子会生成一个X，之后再归纳为S，这时并不需要进行胶水规则的顺序拼接；另一种极端的情况，每个单词都是独立的被翻译，被归纳为X，之后先把最左边的X归纳为S，再依次把剩下的X顺序拼到一起。这样的推导形式如下：
-\begin{example}
 \begin{eqnarray}
 \textrm{S} & \to & \langle\ \textrm{S}_1\ \textrm{X}_2,\ \textrm{S}_1\ \textrm{X}_2\ \rangle \nonumber \\
                 & \to & \langle\ \textrm{S}_3\ \textrm{X}_4\ \textrm{X}_2,\ \textrm{S}_3\ \textrm{X}_4\ \textrm{X}_2\ \rangle \nonumber \\
                 & \to & ... \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{example}
 
 \parinterval 实际上，胶水规则在很大程度上模拟了基于短语的系统中对字符串顺序翻译的操作。而且在实践中发现，这个步骤是十分必要的。特别是对汉-英翻译这样的任务，由于语言的结构基本上是顺序翻译的，因此引入顺序拼接的操作符合翻译的整体规律。同时，这种拼接给翻译增加了灵活性，系统会更加健壮。
 
@@ -1095,17 +1060,17 @@ d = {r_1}^{\circ}{r_2}^{\circ}{r_3}^{\circ}{r_4}
 对于句对(\textbf{s},\textbf{t})和它们之间的词对齐\textbf{a}，令$N$表示在句对(\textbf{s},\textbf{t})上与\textbf{a}相兼容的双语短语集合。则：
 \begin{enumerate}
 \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,$\ldots,m$)上面的一个排序$\sim = {\pi_1 , \ldots ,\pi_m}$，且：
+\item 	对于$(x,y)\in N$，存在$m$个双语短语$(x_i,y_j)\in N$，同时存在(1,$...$,$m$)上面的一个排序$\sim = {\pi_1 , ... ,\pi_m}$，且：
 \end{enumerate}
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-x&=&\alpha_0 x_1 \alpha_1 x_2 \ldots \alpha_{m-1} x_m \alpha_m \label{eqa4.23}\\
-y&=&\beta_0 y_{\pi_1} \beta_1 y_{\pi_2} \ldots \beta_{m-1} y_{\pi_m} \beta_m
+x&=&\alpha_0 x_1 \alpha_1 x_2 ... \alpha_{m-1} x_m \alpha_m \label{eqa4.23}\\
+y&=&\beta_0 y_{\pi_1} \beta_1 y_{\pi_2} ... \beta_{m-1} y_{\pi_m} \beta_m
 \label{eqa4.24}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
 
-其中，${\alpha_0, \ldots ,\alpha_m}$和${\beta_0, \ldots ,\beta_m}$表示源语言和目标语言的若干个词串（包含空串）。则$\textrm{X} \to \langle x,y,\sim \rangle$是与词对齐相兼容的层次短语规则。这条规则包含$m$个变量，变量的对齐信息是$\sim$。
+其中，${\alpha_0, ... ,\alpha_m}$和${\beta_0, ... ,\beta_m}$表示源语言和目标语言的若干个词串（包含空串）。则$\textrm{X} \to \langle x,y,\sim \rangle$是与词对齐相兼容的层次短语规则。这条规则包含$m$个变量，变量的对齐信息是$\sim$。
 }
 \end{definition}
 %-------------------------------------------
@@ -1140,7 +1105,7 @@ y&=&\beta_0 y_{\pi_1} \beta_1 y_{\pi_2} \ldots \beta_{m-1} y_{\pi_m} \beta_m
 
 \begin{itemize}
 \item 	(h1-2)短语翻译概率（取对数），即$\textrm{log}(\textrm{P}(\alpha \mid \beta))$和$\textrm{log}(\textrm{P}(\beta \mid \alpha))$，特征的计算与基于短语的模型完全一样；
-\item 	(h3-4)词汇化翻译概率（取对数），即$\textrm{log}(\textrm{P}_{lex}(\alpha \mid \beta))$和$\textrm{log}(\textrm{P}(\beta \mid \alpha))$，特征的计算与基于短语的模型完全一样；
+\item 	(h3-4)词汇化翻译概率（取对数），即$\textrm{log}(\textrm{P}_{\textrm{lex}}(\alpha \mid \beta))$和$\textrm{log}(\textrm{P}(\beta \mid \alpha))$，特征的计算与基于短语的模型完全一样；
 \item (h5)翻译规则数量，让模型自动学习对规则数量的偏好，同时避免使用过少规则造成分数偏高的现象；
 \item (h6)胶水规则数量，让模型自动学习使用胶水规则的偏好；
 \item (h7)短语规则数量，让模型自动学习使用纯短语规则的偏好。
@@ -1165,7 +1130,7 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \parinterval 最终，模型得分被定义为：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-\textrm{score}(d,\textbf{t},\textbf{s})=\textrm{rscore}(d,\textbf{t},\textbf{s})+ \lambda_8 \textrm{log}⁡(\textrm{P}_{lm}(\textrm{t}))+\lambda_9 \mid \textrm{t} \mid
+\textrm{score}(d,\textbf{t},\textbf{s})=\textrm{rscore}(d,\textbf{t},\textbf{s})+ \lambda_8 \textrm{log}⁡(\textrm{P}_{\textrm{lm}}(\textrm{t}))+\lambda_9 \mid \textrm{t} \mid
 \label{eqa4.27}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
@@ -1173,7 +1138,7 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \parinterval 其中：
 
 \begin{itemize}
-\item 	$\textrm{log}⁡(\textrm{P}_{lm}(\textrm{t}))$表示语言模型得分；
+\item 	$\textrm{log}⁡(\textrm{P}_{\textrm{lm}}(\textrm{t}))$表示语言模型得分；
 \item 	$\mid \textrm{t} \mid$表示译文的长度。
 \end{itemize}
 
@@ -1200,7 +1165,7 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 
 \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 CYK是形式语言中一种常用的句法分析方法\cite{cocke1969programming}\cite{younger1967recognition}\cite{kasami1966efficient}。它主要用于基于符合乔姆斯基范式的分析。由于乔姆斯基范式中每个规则最多包含两叉（或者说两个变量），因此CYK方法也可以被看作是基于二叉规则的一种分析方法。对于一个待分析的字符串，CYK方法从小的``范围''开始，不断扩大分析的``范围''，最终完成对整个字符串的分析。在CYK方法中，一个重要的概念是跨度（Span），所谓跨度表示了一个符号串的范围。这里可以把跨度简单的理解为从一个起始位置到一个结束位置中间的部分。比如，如图\ref{fig:word-and-index-of-pos}所示，每个单词左右都有一个数字来表示序号。我们可以用序号的范围来表示跨度，例如：
+\parinterval CYK是形式语言中一种常用的句法分析方法\cite{cocke1969programming,younger1967recognition,kasami1966efficient}。它主要用于基于符合乔姆斯基范式的分析。由于乔姆斯基范式中每个规则最多包含两叉（或者说两个变量），因此CYK方法也可以被看作是基于二叉规则的一种分析方法。对于一个待分析的字符串，CYK方法从小的``范围''开始，不断扩大分析的``范围''，最终完成对整个字符串的分析。在CYK方法中，一个重要的概念是跨度（Span），所谓跨度表示了一个符号串的范围。这里可以把跨度简单的理解为从一个起始位置到一个结束位置中间的部分。比如，如图\ref{fig:word-and-index-of-pos}所示，每个单词左右都有一个数字来表示序号。我们可以用序号的范围来表示跨度，例如：
 
 %----------------------------------------------
 % 图
@@ -1211,13 +1176,11 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \label{fig:word-and-index-of-pos}
 \end{figure}
 %-------------------------------------------
-\begin{example}
 \begin{eqnarray}
-\textrm{Span[0,1]}&=&\textrm{``范围''} \nonumber \\
+\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
 \end{eqnarray}
-\end{example}
 
 \parinterval CYK方法是按跨度由小到大的次序执行的，这也对应了一种自下而上的分析过程。对于每个跨度，检查：
 
@@ -1290,13 +1253,11 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 %-------------------------------------------
 
 \parinterval 真实的情况会更加复杂。对于一个规则的源语言端，可能会有多个不同的目标语言端与之对应。比如，如下的规则的源语言端完全相同，但是译文不同：
-\begin{example}
 \begin{eqnarray}
 \textrm{X} & \to & \langle\ \textrm{X}_1\ \text{大幅度}\ \text{下降}\ \text{了},\ \textrm{X}_1\ \textrm{have}\ \textrm{drastically}\ \textrm{fallen}\ \rangle \nonumber \\
 \textrm{X} & \to & \langle\ \textrm{X}_1\ \text{大幅度}\ \text{下降}\ \text{了},\ \textrm{X}_1\ \textrm{have}\ \textrm{fallen}\ \textrm{drastically}\ \rangle \nonumber \\
 \textrm{X} & \to & \langle\ \textrm{X}_1\ \text{大幅度}\ \text{下降}\ \text{了},\ \textrm{X}_1\ \textrm{has}\ \textrm{drastically}\ \textrm{fallen}\ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 这也就是说，当我们匹配规则的源语言部分``$\textrm{X}_1$ 大幅度 下降 了''会有三个译文可以选择。而变量$\textrm{X}_1$部分又有很多不同的局部翻译结果。不同的规则译文和不同的变量译文都可以组合出一个局部翻译结果。图\ref{fig:combination-of-translation-with-different-rules}展示了这种情况的实例。
 
@@ -1385,32 +1346,40 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \begin{center}
 \caption{基于句法的机器翻译中常用概念}
 \label{tab:common-concepts-in-syntax}
-{\footnotesize
+{
 \begin{tabular}{l | l}
 术语 & 说明 \\
 \hline
 \rule{0pt}{15pt}翻译规则 & 翻译的最小单元（或步骤） \\
-\rule{0pt}{15pt}推导 & 由一系列规则组成的分析或翻译过程，推导可以\\ & 被看作是规则的序列 \\
+\rule{0pt}{15pt}推导 & 由一系列规则组成的分析或翻译过程，推导可以被看作是规\\ 
+&则的序列 \\
 \rule{0pt}{15pt}规则表 & 翻译规则的存储表示形式，可以高效进行查询 \\
-\rule{0pt}{15pt}层次短语模型 & 基于同步上下文无关文法的翻译模型，非终结符\\ & 只有S和X两种，文法并不需要符合语言学\\ & 句法约束 \\
-\rule{0pt}{15pt}树到串模型 & 一类翻译模型，它使用源语语言学句法树，因此\\ & 翻译可以被看作是从一颗句法树到词串的转换 \\
-\rule{0pt}{15pt}串到树模型 & 一类翻译模型，它使用目标语语言学句法树，因\\ & 此翻译可以被看作是从词串到句法树的转换 \\
-\rule{0pt}{15pt}树到树模型 & 一类翻译模型，它同时使用源语和目标语语言学\\ & 句法树，因此翻译可以被看作从句法树到句法树\\ & 的转换 \\
+\rule{0pt}{15pt}层次短语模型 & 基于同步上下文无关文法的翻译模型，非终结符只有S和X\\ 
+&两种，文法并不需要符合语言学句法约束 \\
+\rule{0pt}{15pt}树到串模型 & 一类翻译模型，它使用源语语言学句法树，因此翻译可以被\\ 
+&看作是从一颗句法树到词串的转换 \\
+\rule{0pt}{15pt}串到树模型 & 一类翻译模型，它使用目标语语言学句法树，因此翻译可以\\ 
+&被看作是从词串到句法树的转换 \\
+\rule{0pt}{15pt}树到树模型 & 一类翻译模型，它同时使用源语和目标语语言学句法树，因\\ 
+&此翻译可以被看作从句法树到句法树的转换 \\
 \rule{0pt}{15pt}基于句法 & 使用语言学句法 \\
 \rule{0pt}{15pt}基于树 &（源语言）使用树结构（大多指句法树） \\
-\rule{0pt}{15pt}基于串 &（源语言）使用词串，比如串到树的翻译系统的解\\ & 码器一般都是基于串的解码方法 \\
-\rule{0pt}{15pt}基于森林 &（源语言）使用句法森林，这里森林只是对多个句\\ & 法树的一种压缩表示 \\
+\rule{0pt}{15pt}基于串 &（源语言）使用词串，比如串到树的翻译系统的解码器一般\\ 
+&都是基于串的解码方法 \\
+\rule{0pt}{15pt}基于森林 &（源语言）使用句法森林，这里森林只是对多个句法树的一\\ 
+&种压缩表示 \\
 \rule{0pt}{15pt}词汇化规则 & 含有终结符的规则 \\
 \rule{0pt}{15pt}非词汇规则 & 不含有终结符的规则 \\
-\rule{0pt}{15pt}句法软约束 & 不强制规则推导匹配语言学句法树，通常把句法\\ & 信息作为特征使用 \\
-\rule{0pt}{15pt}句法硬约束 & 强制推导必须符合语言学句法树，不符合的推导\\ & 会被过滤掉 \\
+\rule{0pt}{15pt}句法软约束 & 不强制规则推导匹配语言学句法树，通常把句法信息作为特\\ 
+&征使用 \\
+\rule{0pt}{15pt}句法硬约束 & 强制推导必须符合语言学句法树，不符合的推导会被过滤掉 \\
 \end{tabular}
 }
 \end{center}
 }\end{table}
 %-------------------------------------------
 
-\parinterval 基于句法的翻译模型可以被分为两类：基于形式化文法的模型和语言学上基于句法的模型（图\ref{fig:classification-of-models-based-on-syntax}）。基于形式化文法的模型的典型代表包括，吴德恺提出的基于反向转录文法的模型\cite{wu1997stochastic}和David Chiang提出的基于层次短语的模型\cite{chiang2007hierarchical}。而语言学上基于句法的模型包括，句法树到串的模型\cite{liu2006tree}\cite{huang2006statistical}、串到句法树的模型\cite{galley2006scalable}\cite{galley2004s}、句法树到句法树的模型\cite{eisner2003learning}\cite{zhang2008tree}\cite{liu2009improving}\cite{chiang2010learning}等。通常来说，基于形式化文法的模型并不需要句法分析技术的支持。这类模型只是把翻译过程描述为一系列形式化文法规则的组合过程。而语言学上基于句法的模型则需要源语言和（或者）目标语言句法分析的支持，以获取更丰富的语言学信息来提高模型的翻译能力。这也是本节所关注的重点。当然，所谓分类也没有唯一的标准，比如，还可以把句法模型分为基于软约束的模型和基于硬约束的模型，或者分为基于树的模型和基于串的模型。
+\parinterval 基于句法的翻译模型可以被分为两类：基于形式化文法的模型和语言学上基于句法的模型（图\ref{fig:classification-of-models-based-on-syntax}）。基于形式化文法的模型的典型代表包括，吴德恺提出的基于反向转录文法的模型\cite{wu1997stochastic}和David Chiang提出的基于层次短语的模型\cite{chiang2007hierarchical}。而语言学上基于句法的模型包括，句法树到串的模型\cite{liu2006tree,huang2006statistical}、串到句法树的模型\cite{galley2006scalable,galley2004s}、句法树到句法树的模型\cite{eisner2003learning,zhang2008tree,liu2009improving,chiang2010learning}等。通常来说，基于形式化文法的模型并不需要句法分析技术的支持。这类模型只是把翻译过程描述为一系列形式化文法规则的组合过程。而语言学上基于句法的模型则需要源语言和（或者）目标语言句法分析的支持，以获取更丰富的语言学信息来提高模型的翻译能力。这也是本节所关注的重点。当然，所谓分类也没有唯一的标准，比如，还可以把句法模型分为基于软约束的模型和基于硬约束的模型，或者分为基于树的模型和基于串的模型。
 
 %----------------------------------------------
 % 图
@@ -1430,7 +1399,7 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \begin{center}
 \caption{基于句法的机器翻译模型对比}
 \label{tab:comparison-of-models-based-on-syntax}
-{\footnotesize
+{
 \begin{tabular}{l | l | l | l | l}
  & 形式句法 & \multicolumn{3}{c}{语言学句法} \\
 \cline{3-5}
@@ -1494,7 +1463,7 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 \end{definition}
 %-------------------------------------------
 
-\parinterval 基于树结构的规则非常适于描述树结构到树结构的映射。比如，图\ref{fig:example-of-tree-structure-correspondence}是一个汉语句法树结构到一个英语句法树结构的对应。其中的树结构可以被看作是完整句法树上的一个片段，称为{\small\sffamily\bfseries{树片段}}（\textbf{Tree Fragment}）。树片段的叶子节点既可以是单词（终结符）也可以是非终结符。当叶子节点为非终结符时，表示这个非终结符会被进一步替换，因此它可以被看作是变量。而源语言树结构和目标语言树结构中的变量是一一对应的，对应关系用虚线表示。
+\parinterval 基于树结构的规则非常适于描述树结构到树结构的映射。比如，图\ref{fig:example-of-tree-structure-correspondence}是一个汉语句法树结构到一个英语句法树结构的对应。其中的树结构可以被看作是完整句法树上的一个片段，称为{\small\sffamily\bfseries{树片段}}（Tree Fragment）。树片段的叶子节点既可以是单词（终结符）也可以是非终结符。当叶子节点为非终结符时，表示这个非终结符会被进一步替换，因此它可以被看作是变量。而源语言树结构和目标语言树结构中的变量是一一对应的，对应关系用虚线表示。
 
 %----------------------------------------------
 % 图
@@ -1507,28 +1476,24 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 %-------------------------------------------
 
 \parinterval 这个双语映射关系可以被表示为一个基于树结构的文法规则，套用规则的定义$\langle\  \alpha_h, \beta_h\ \rangle \to \langle\ \alpha_r, \beta_r, \sim\ \rangle$形式，可以知道：
-\begin{example}
 \begin{eqnarray}
 \langle\ \alpha_h, \beta_h\ \rangle &=& \langle\ \textrm{VP}, \textrm{VP}\ \rangle \nonumber \\
 \alpha_r &=& \textrm{VP}(\textrm{PP:}x\ \textrm{VP(VV(表示)}\ \textrm{NN:}x)) \nonumber \\
 \beta_r &=& \textrm{VP}(\textrm{VBZ(was)}\ \textrm{VP(VBN:}x\ \textrm{PP:}x)) \nonumber \\
 \sim &=& \{1-2,2-1\} \nonumber
 \end{eqnarray}
-\end{example}
 
-\parinterval 这里，$\alpha_h$和$\beta_h$表示规则的左部，对应树片段的根节点；$\alpha_r$和$\beta_r$是两种语言的树结构（序列化表示），其中标记为x的非终结符是变量。$\sim = \{1-2,2-1\}$表示源语言的第一个变量对应目标语言的第二个变量，而源语言的第二个变量对应目标语言的第一个变量，这也反应出两种语言句法结构中的调序现象。有时候为了化简规则的形式，会把规则中变量的对应关系用下标进行表示。比如，上面的规则也可以被写为如下形式。
-\begin{example}
+\parinterval 这里，$\alpha_h$和$\beta_h$表示规则的左部，对应树片段的根节点；$\alpha_r$和$\beta_r$是两种语言的树结构（序列化表示），其中标记为$x$的非终结符是变量。$\sim = \{1-2,2-1\}$表示源语言的第一个变量对应目标语言的第二个变量，而源语言的第二个变量对应目标语言的第一个变量，这也反应出两种语言句法结构中的调序现象。有时候为了化简规则的形式，会把规则中变量的对应关系用下标进行表示。比如，上面的规则也可以被写为如下形式。
 \begin{eqnarray}
-\langle\ \textrm{VP}, \textrm{VP}\ \rangle\ \to\ \langle\ \textrm{PP}_{\red{1}} \ \textrm{VP(VV(表示)}\ \textrm{NN}_{\red{2}}))\ \textrm{VP}(\textrm{VBZ(was)}\ \textrm{VP(VBN}_{\red{2}} \ \textrm{PP}_{\red{1}})) \ \rangle \nonumber
+\langle\ \textrm{VP}, \textrm{VP}\ \rangle\ \to\ \langle\ \textrm{PP}_{1} \ \textrm{VP(VV(表示)}\ \textrm{NN}_{2}))\ \textrm{VP}(\textrm{VBZ(was)}\ \textrm{VP(VBN}_{2} \ \textrm{PP}_{1})) \ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 其中，两种语言中变量的对应关系为$\textrm{PP}_1 \leftrightarrow \textrm{PP}_1$，$\textrm{NN}_2 \leftrightarrow \textrm{VBN}_2$。
 
 %%%%%%%%%%%%%%%%%%
 \subsubsection{基于树结构的翻译推导}\index{Chapter4.4.2.2}
 
-\parinterval 规则中的变量预示着一种替换操作，即变量可以被其它树结构替换。实际上，上面的树到树规则就是一种{\small\sffamily\bfseries{同步树替换文法规则}}（\textbf{Synchronous Tree Substitution Grammar Rule}）。不论是源语言端还是目标语言端，都可以通过这种替换操作不断生成更大的树结构，也就是通过树片段的组合得到更大的树片段。图\ref{fig:operation-of-tree-replace}就展示了树替换操作的一个实例。
+\parinterval 规则中的变量预示着一种替换操作，即变量可以被其它树结构替换。实际上，上面的树到树规则就是一种{\small\sffamily\bfseries{同步树替换文法规则}}（Synchronous Tree Substitution Grammar Rule）。不论是源语言端还是目标语言端，都可以通过这种替换操作不断生成更大的树结构，也就是通过树片段的组合得到更大的树片段。图\ref{fig:operation-of-tree-replace}就展示了树替换操作的一个实例。
 
 %----------------------------------------------
 % 图
@@ -1553,22 +1518,21 @@ h_i (d,\textbf{t},\textbf{s})=\sum_{r \in d}h_i (r)
 %-------------------------------------------
 
 \parinterval 规则的推导对应了一种源语言和目标语言树结构的同步生成的过程。比如，使用下面的规则集：
-\begin{example}
+{
 \begin{eqnarray}
-r_3& \quad &\textrm{AD(大幅度)} \rightarrow \textrm{RB(drastically)} \nonumber \\
-r_4& \quad &\textrm{VV(减少)} \rightarrow \textrm{VBN(fallen)} \nonumber \\
-r_6& \quad &\textrm{AS(了)} \rightarrow \textrm{VBP(have)} \nonumber \\
-r_7& \quad &\textrm{NN(进口)} \rightarrow \textrm{NP(DT(the)}\ \textrm{NNS(imports)} \nonumber \\
-r_8& \quad &\textrm{VP(}\textrm{AD}_1\ \textrm{VP(} \textrm{VV}_2\ \textrm{AS}_3)) \rightarrow \textrm{VP(}\textrm{VBP}_3\ \textrm{ADVP(} \textrm{RB}_1\ \textrm{VBN}_2)) \nonumber \\
-r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\textrm{NP}_1\ \textrm{VP}_2) \nonumber
+r_3: \quad \textrm{AD(大幅度)} \rightarrow \textrm{RB(drastically)}\qquad\qquad\qquad\qquad\qquad\qquad\qquad\ \nonumber \\
+r_4: \quad \textrm{VV(减少)} \rightarrow \textrm{VBN(fallen)}\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\ \,\nonumber \\
+r_6: \quad \textrm{AS(了)} \rightarrow \textrm{VBP(have)}\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\, \nonumber \\
+r_7: \quad \textrm{NN(进口)} \rightarrow \textrm{NP(DT(the)}\ \textrm{NNS(imports)} \nonumber\ \qquad\qquad\qquad\qquad\qquad\ \,\\
+r_8: \quad \textrm{VP(}\textrm{AD}_1\ \textrm{VP(} \textrm{VV}_2\ \textrm{AS}_3)) \rightarrow \textrm{VP(}\textrm{VBP}_3\ \textrm{ADVP(} \textrm{RB}_1\ \textrm{VBN}_2))\ \nonumber \qquad\ \ \,\\
+r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\textrm{NP}_1\ \textrm{VP}_2) \qquad\qquad\qquad\qquad\qquad\qquad\qquad\nonumber\ \ \ \ \,
 \end{eqnarray}
-\end{example}
+}
 
 \parinterval 可以得到一个翻译推导：
-\begin{example}
 {\footnotesize
 \begin{eqnarray}
-& \langle\ \textrm{IP}^{[1]},\ \textrm{S}^{[1]}\ \rangle & \nonumber \\
+&& \langle\ \textrm{IP}^{[1]},\ \textrm{S}^{[1]}\ \rangle \nonumber \\
 & \xrightarrow[r_9]{\textrm{IP}^{[1]} \Leftrightarrow \textrm{S}^{[1]}} & \langle\ \textrm{IP(}\textrm{NN}^{[2]}\ \textrm{VP}^{[3]}),\ \textrm{S(}\textrm{NP}^{[2]}\ \textrm{VP}^{[3]})\ \rangle \nonumber \\
 & \xrightarrow[r_7]{\textrm{NN}^{[2]} \Leftrightarrow \textrm{NP}^{[2]}} & \langle\ \textrm{IP(NN(进口)}\ \textrm{VP}^{[3]}),\ \textrm{S(NP(DT(the) NNS(imports))}\ \textrm{VP}^{[3]})\ \rangle \nonumber \\
 & \xrightarrow[r_8]{\textrm{VP}^{[3]} \Leftrightarrow \textrm{VP}^{[3]}} & \langle\ \textrm{IP(NN(进口)}\ \textrm{VP(AD}^{[4]}\ \textrm{VP(VV}^{[5]}\ \textrm{AS}^{[6]}))), \nonumber \\
@@ -1583,7 +1547,6 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 &                 & \ \ \textrm{ADVP(RB(drastically)}\ \textrm{VBN(fallen)})))\ \rangle \hspace{15em} \nonumber
 \end{eqnarray}
 }
-\end{example}
 
 \parinterval 其中，箭头$\rightarrow$表示推导之意。显然，可以把翻译看作是基于树结构的推导过程（记为$d$）。因此，与层次短语模型一样，基于语言学句法的机器翻译也是要找到最佳的推导$\hat{d} = \arg\max\textrm{P}(d)$。
 
@@ -1603,7 +1566,6 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 %-------------------------------------------
 
 \parinterval 其中，源语言树片段中的叶子结点NN表示变量，它与右手端的变量NN对应。我们仍然可以使用基于树结构的规则对上面这个树到串的映射进行表示。参照规则形式$\langle\  \alpha_h, \beta_h\ \rangle \to \langle\ \alpha_r, \beta_r, \sim\ \rangle$，有：
-\begin{example}
 \begin{eqnarray}
 \alpha_h & = & \textrm{VP} \nonumber \\
 \beta_h & = & \textrm{VP}\ (=\alpha_h) \nonumber \\
@@ -1611,23 +1573,18 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 \beta_r & = & \textrm{VP(increases\ NN:}x) \nonumber \\
 \sim & = & \{1-1\} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 这里，源语言部分是一个树片段，因此$\alpha_h$和$\alpha_r$很容易确定。对于目标语部分，可以把这个符号串当作是一个单层的树片段，根结点直接共享源语言树片段的根结点，叶子结点就是符号串本身。这样，我们也可以得到$\beta_h$和$\beta_r$。从某种意义上说，树到串翻译仍然体现了一种双语的树结构，只是目标语部分不是语言学句法驱动的，而是一种借用了源语言句法标记所形成的层次结构。
 
 \parinterval 这里也可以把变量的对齐信息用下标表示，同时将左部两个相同的非终结符合并\footnote[8]{在树到串规则中，$\alpha_h$和$\beta_h$是一样的。}，于是规则可以被写作：
-\begin{example}
 \begin{eqnarray}
 \textrm{VP} \rightarrow \langle\ \textrm{VP(VV(提高)}\ \textrm{NN}_1),\ \textrm{increases}\ \textrm{NN}_1\ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 另外，在机器翻译领域，大家习惯把规则看作源语言结构（树/串）到目标语言（树/串）的一种映射，因此会常常把上面的规则记为：
-\begin{example}
 \begin{eqnarray}
 \textrm{VP(VV(提高)}\ \textrm{NN}_1) \rightarrow \textrm{increases}\ \textrm{NN}_1 \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 在后面的内容中，我们也会使用这种形式来表示基于句法的翻译规则。
 
@@ -1636,7 +1593,7 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 
 \parinterval 基于句法的机器翻译包括两个步骤：文法归纳和解码。其中，文法归纳是指从双语平行数据中自动学习翻译规则及规则所对应的特征；解码是指利用得到的文法对新的句子进行分析，并得到概率最高的翻译推导。
 
-\parinterval 这里，我们首先介绍树到串文法归纳的经典方法 —— GHKM方法\cite{galley2004s}\cite{galley2006scalable}。所谓GHKM是四位作者名字的首字母。GHKM方法的输入包括：
+\parinterval 这里，我们首先介绍树到串文法归纳的经典方法 —— GHKM方法\cite{galley2004s,galley2006scalable}。所谓GHKM是四位作者名字的首字母。GHKM方法的输入包括：
 
 \begin{itemize}
 \item 源语言句子及其句法树；
@@ -1650,18 +1607,14 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 \subsubsection{树的切割与最小规则}\index{Chapter4.4.3.1}
 
 \parinterval 获取树到串规则就是要找到在源语言树片段与目标语串的对应关系。一棵句法树会有很多个树片段，那么哪些树片段可以和目标语言词串产生对应关系呢？在GHKM方法中，源语言树片段和目标语言词串的对应是由词对齐决定的。GHKM假设：一个合法的树到串翻译规则，不应该违反词对齐。这个假设和双语短语抽取中的词对齐一致性约束是一样的。简单来说，两个互相对应的部分不应包含对齐到外部的词对齐连接。为了说明这个问题，来看一个例子。图\ref{fig:example-of-tree-to-string-rule-and-word-alignment}包含了一棵句法树、一个词串和它们之间的词对齐结果。图中包含如下规则：
-\begin{example}
 \begin{eqnarray}
 \textrm{PP(P(对)}\ \textrm{NP(NN(回答)))} \rightarrow \textrm{with}\ \textrm{the}\ \textrm{answer} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 该规则是一个条满足词对齐约束的规则（对应于图\ref{fig:example-of-tree-to-string-rule-and-word-alignment}中红色部分），因为不存在从规则的源语言或目标语言部分对齐到规则外部的情况。但是，如下的规则却是一条不合法的规则：
-\begin{example}
 \begin{eqnarray}
 \textrm{NN(满意)} \rightarrow \textrm{satisfied} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 这是因为，``satisfied''除了对齐到``满意''，还对齐到``表示''。也就是，这条规则会产生歧义，因为``satisfied''不应该只由``满意''生成。
 
@@ -1732,11 +1685,9 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 %-------------------------------------------
 
 \parinterval 图\ref{fig:translation-rule-based-on-admissible-node}是一个基于可信节点得到的树到串规则：
-\begin{example}
 \begin{eqnarray}
 \textrm{VP(PP(P(对)}\ \textrm{NP(NN(回答)))}\ \textrm{VP}_1) \rightarrow \textrm{VP}_1\ \textrm{with}\ \textrm{the}\ \textrm{answer} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 其中蓝色部分表示可以抽取到的规则，显然它的根节点和叶子非终结符节点都是可信节点。由于源语言树片段中包含一个变量（VP），因此需要对VP节点的Span所表示的目标语范围进行泛化（红色方框部分）。
 
@@ -1750,7 +1701,7 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 \end{figure}
 %-------------------------------------------
 
-\parinterval 至此，对于任何一个树片段我们都能够判断它是否合法。如果合法，就可以抽取相应的树到串规则。但是，枚举句子中的所有树片段并不是一个很高效的方法，因为对于任何一个节点，以它为根的树片段数量随着其深度和宽度的增加呈指数增长。在GHKM方法中，为了避免低效的枚举操作，可以使用另一种方法抽取规则。实际上，可信节点告诉了我们哪些地方可以作为规则的边界（合法树片段的根节点或者叶子节点），可以把所有的可信节点看作是一个{\small\sffamily\bfseries{边缘集合}}（\textbf{Frontier Set}）。所谓边缘集合就是定义了哪些地方可以被``切割''，通过这种切割可以得到一个个合法的树片段，这些树片段无法再被切割为更小的合法树片段。图\ref{fig:tree-cutting-defined-by-edge-nodes}给出了一个通过边缘集合定义的树切割。图右侧中的矩形框表示的是切割得到的树片段。
+\parinterval 至此，对于任何一个树片段我们都能够判断它是否合法。如果合法，就可以抽取相应的树到串规则。但是，枚举句子中的所有树片段并不是一个很高效的方法，因为对于任何一个节点，以它为根的树片段数量随着其深度和宽度的增加呈指数增长。在GHKM方法中，为了避免低效的枚举操作，可以使用另一种方法抽取规则。实际上，可信节点告诉了我们哪些地方可以作为规则的边界（合法树片段的根节点或者叶子节点），可以把所有的可信节点看作是一个{\small\sffamily\bfseries{边缘集合}}（Frontier Set）。所谓边缘集合就是定义了哪些地方可以被``切割''，通过这种切割可以得到一个个合法的树片段，这些树片段无法再被切割为更小的合法树片段。图\ref{fig:tree-cutting-defined-by-edge-nodes}给出了一个通过边缘集合定义的树切割。图右侧中的矩形框表示的是切割得到的树片段。
 
 %----------------------------------------------
 % 图
@@ -1784,20 +1735,16 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 \parinterval 空对齐是翻译中的常见现象。比如，一些虚词经常找不到在另一种语言中的对应，因此不会被翻译，这种情况也被称作空对齐。比如，在图\ref{fig:minimum-rule-from-tree-cutting}中目标语中的``was''就是一个空对齐单词。实际上，空对齐的使用可以大大增加翻译的灵活度。具体到树到串规则抽取任务，我们需要把空对齐考虑进来，这样能够覆盖更多的语言现象。
 
 \parinterval 处理空对齐单词的手段非常简单。我们只需要把空对齐单词附着在它周围的规则上即可。也就是，我们检查每条最小规则，如果空对齐单词能够作为规则的一部分进行扩展，就可以生成一条新的规则。图\ref{fig:tree-to-string-rule-empty-alignment}展示了前面例子中``was''被附着在周围的规则上的结果。其中，含有红色``was''的规则是通过附着空对齐单词得到的新规则。比如，对于规则：
-\begin{example}
 \begin{eqnarray}
 \textrm{NP(PN(他))} \rightarrow \textrm{he} \nonumber
 \end{eqnarray}
-\end{example}
 
-\noindent ``was''紧挨着这个规则目标端的单词``he''，因此可以把``was''包含在规则的目标端，形成新的规则：
-\begin{example}
+\parinterval ``was''紧挨着这个规则目标端的单词``he''，因此可以把``was''包含在规则的目标端，形成新的规则：
 \begin{eqnarray}
 \textrm{NP(PN(他))} \rightarrow \textrm{he}\ \textrm{was} \nonumber
 \end{eqnarray}
-\end{example}
 
-\noindent 通常，在规则抽取中考虑空对齐可以大大增加规则的覆盖度。
+\parinterval 通常，在规则抽取中考虑空对齐可以大大增加规则的覆盖度。
 
 %----------------------------------------------
 % 图
@@ -1838,18 +1785,14 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 \parinterval 组合规则固然有效，并不是所有组合规则都非常好用。比如，在机器翻译中已经发现，如果一个规则含有连续词串（短语），这种规则往往会比较可靠。但是由于句法树结构复杂，获取这样的规则可能会需要很多次规则的组合，规则抽取的效率很低。
 
 \parinterval 针对这个问题，一种解决办法是直接从词串出发进行规则抽取。这种方法被称为SPMT方法\cite{marcu2006spmt:}。它的思想是：对于任意一个与词对齐兼容的短语，可以找到包含它的``最小''翻译规则，即SPMT规则。如图\ref{fig:tree-segment-corresponding-to-phrase}所示，我们可以得到短语翻译：
-\begin{example}
 \begin{eqnarray}
 \textrm{对}\ \textrm{形式} \rightarrow \textrm{about}\ \textrm{the}\ \textrm{situation} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 然后，从这个短语出发向上搜索，找到覆盖这个短语的最小树片段，之后生成规则即可。在这个例子中可以使用SPMT规则：
-\begin{example}
 \begin{eqnarray}
 \textrm{VP(P(对)}\ \textrm{NP(NN(局势))}\ \textrm{VP}_1) \rightarrow \textrm{VP}_1\ \textrm{about}\ \textrm{the}\ \textrm{situation} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 而这条规则需要组合三条最小规则才能得到，但是在SPMT中可以直接得到。相比规则组合的方法，SPMT方法可以更有效的抽取包含短语的规则。
 
@@ -1879,11 +1822,9 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 %-------------------------------------------
 
 \parinterval 这种扁平的结构会给规则抽取带来麻烦。图\ref{fig:tree-binarization}给出了一个实例，其中的名词短语（NP），包含四个词，都在同一层树结构中。由于``唐纳德$\ $特朗普''并不是一个独立的句法结构，因此我们无法抽取类似于下面这样的规则：
-\begin{example}
 \begin{eqnarray}
 \textrm{NP(NN(唐纳德))}\ \textrm{NN(特朗普))} \rightarrow \textrm{Trump} \nonumber
 \end{eqnarray}
-\end{example}
 
 %----------------------------------------------
 % 图
@@ -1896,12 +1837,10 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 %-------------------------------------------
 
 \parinterval 对于这个问题，一种解决办法是把句法树变得更深，使局部的翻译片段更容易被抽取出来。常用的手段是树{\small\sffamily\bfseries{二叉化}}（Binarization）。比如，图\ref{fig:result-of-tree-binarization}就是一个树二叉化的实例。二叉化生成了一些新的节点（记为X-BAR），其中``唐纳德$\ $特朗普''被作为一个独立的结构体现出来。这样，就能够抽取到规则：
-\begin{example}
 \begin{eqnarray}
 && \textrm{NP-BAR(NN(唐纳德))}\ \textrm{NN(特朗普))} \rightarrow \textrm{Trump} \nonumber \\
 && \textrm{NP-BAR(}\textrm{NN}_1\ \textrm{NP-}\textrm{BAR}_2) \rightarrow \textrm{NN}_1\ \textrm{NP-}\textrm{BAR}_2 \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 由于树二叉化可以帮助规则抽取得到更细颗粒度的规则，提高规则抽取的召回率，因此成为了基于句法的机器翻译中的常用方法。二叉化方法也有很多不同的实现策略，比如：左二叉化、右二叉化、基于中心词的二叉化等\cite{Tong2009Better}。具体实现时可以根据实际情况进行选择。
 
@@ -1919,19 +1858,15 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 \subsection{树到树翻译规则抽取}\index{Chapter4.4.4}
 
 \parinterval 树到串/串到树模型只在一个语言端使用句法树，而树到树模型可以同时利用源语言和目标语言句法信息，因此可以更细致的刻画两种语言的结构对应关系，进而更好的完成句法结构的调序和生成。树到树翻译中，需要两端都有树结构的规则，比如：
-\begin{example}
 \begin{eqnarray}
 \langle\ \textrm{VP},\textrm{VP}\ \rangle \rightarrow \langle\ \textrm{VP(}\textrm{PP}_1\ \textrm{VP(VV(表示)}\ \textrm{NN}_2\textrm{))}, \nonumber \\
 \textrm{VP(VBZ(was)}\ \textrm{VP(}\textrm{VBN}_2\ \textrm{PP}_1\textrm{))}\ \rangle \nonumber
 \end{eqnarray}
-\end{example}
 
-\noindent 我们也可以把它写为如下形式：
-\begin{example}
+\parinterval 我们也可以把它写为如下形式：
 \begin{eqnarray}
 \textrm{VP(}\textrm{PP}_1\ \textrm{VP(VV(表示)}\ \textrm{NN}_2\textrm{))} \rightarrow \textrm{VP(VBZ(was)}\ \textrm{VP(}\textrm{VBN}_2\ \textrm{PP}_1\textrm{))} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 其中，规则的左部是源语言句法树结构，右部是目标语言句法树结构，变量的下标表示对应关系。为了获取这样的规则，我们需要进行树到树规则抽取。最直接的办法是把GHKM方法推广到树到树翻译的情况。比如，可以利用双语结构的约束和词对齐，定义树的切割点，之后找到两种语言树结构的映射关系\cite{Yang2009Improving}。
 
@@ -1962,14 +1897,14 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 \end{figure}
 %-------------------------------------------
 
-\parinterval 可以看到，节点对齐可以避免词对齐错误造成的影响。不过，节点对齐需要开发额外的工具。有很多方法可以参考，比如可以基于启发性规则、基于分类模型、基于无指导的方法等\cite{xiao2013unsupervised}\cite{tinsley2007robust}。
+\parinterval 可以看到，节点对齐可以避免词对齐错误造成的影响。不过，节点对齐需要开发额外的工具。有很多方法可以参考，比如可以基于启发性规则、基于分类模型、基于无指导的方法等\cite{xiao2013unsupervised,tinsley2007robust}。
 
 %%%%%%%%%%%%%%%%%%
 \subsubsection{基于对齐矩阵的规则抽取}\index{Chapter4.4.4.2}
 
 \parinterval 同词对齐一样，节点对齐也会存在错误，这样就不可以避免的造成规则抽取的错误。既然单一的对齐中含有错误，那能否让系统看到更多样的对齐结果，进而提高正确规则被抽取到的几率呢？答案是肯定的。实际上，在基于短语的模型中就有基于多个词对齐（如$n$-best词对齐）进行规则抽取的方法，这种方法可以在一定程度上提高短语的召回率。在树到树规则抽取中也同样适用，比如可以使用多个节点对齐结果进行规则抽取。但是，简单使用多个对齐结果会使系统运行代价线性增长，而且即使是$n$-best对齐，也无法保证涵盖到正确的对齐结果。对于这个问题，另一种思路是使用对齐矩阵进行规则的``软''抽取。
 
-\parinterval 所谓对齐矩阵，是描述两个句法树节点之间对应强度的数据结构。矩阵的每个单元中都是一个0到1之间的数字。规则抽取时，可以认为所有节点之间都存在对齐，这样可以抽取出很多$n$-best对齐中无法覆盖的规则。图\ref{fig:one-best-node-alignment-and-alignment-matrix}展示了一个用对齐矩阵的进行规则抽取的实例。其中矩阵1（Matrix 1）表示的标准的1-best节点对齐，矩阵2（Matrix 2）表示的是一种概率化的对齐矩阵。可以看到矩阵2可以帮助我们抽取到更多样的规则。另外，值得注意的是，基于对齐矩阵的方法也同样适用于短语和层次短语规则的抽取。关于对齐矩阵的生成可以参考相关论文的内容\cite{xiao2013unsupervised}\cite{liu2009weighted}\cite{sun2010exploring}\cite{sun2010discriminative}。
+\parinterval 所谓对齐矩阵，是描述两个句法树节点之间对应强度的数据结构。矩阵的每个单元中都是一个0到1之间的数字。规则抽取时，可以认为所有节点之间都存在对齐，这样可以抽取出很多$n$-best对齐中无法覆盖的规则。图\ref{fig:one-best-node-alignment-and-alignment-matrix}展示了一个用对齐矩阵的进行规则抽取的实例。其中矩阵1（Matrix 1）表示的标准的1-best节点对齐，矩阵2（Matrix 2）表示的是一种概率化的对齐矩阵。可以看到矩阵2可以帮助我们抽取到更多样的规则。另外，值得注意的是，基于对齐矩阵的方法也同样适用于短语和层次短语规则的抽取。关于对齐矩阵的生成可以参考相关论文的内容\cite{xiao2013unsupervised,liu2009weighted,sun2010exploring,sun2010discriminative}。
 
 %----------------------------------------------
 % 图
@@ -1990,12 +1925,9 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 
 \parinterval 这里，可以使用最小错误率训练对特征权重进行调优（4.2.6节）。而特征函数可参考如下定义：
 
-%-------------------------------------------
-\begin{definition} {\small\sffamily\bfseries{基于短语的特征}}（对应于每条规则$r : \langle\  \alpha_h, \beta_h\ \rangle \to \langle\ \alpha_r, \beta_r, \sim\ \rangle$ ）
+\parinterval {\small\sffamily\bfseries{基于短语的特征}}（对应于每条规则$r : \langle\  \alpha_h, \beta_h\ \rangle \to \langle\ \alpha_r, \beta_r, \sim\ \rangle$ ）
 
-{\small
 \begin{itemize}
-\item 
 \item (h1-2)短语翻译概率，即规则源语言和目标语言树结构的叶子节点序列的翻译概率。首先，令函数$\tau(\cdot)$返回一个树片段的叶子节点序列，比如对于规则：
 \begin{displaymath}
 \textrm{VP(}\textrm{PP}_1\ \textrm{VP(VV(表示)}\ \textrm{NN}_2\textrm{))} \rightarrow \textrm{VP(VBZ(was)}\ \textrm{VP(}\textrm{VBN}_2\ \textrm{PP}_1\textrm{))}
@@ -2007,43 +1939,28 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 \begin{displaymath}
 \tau( \beta_r ) = \textrm{was}\ \textrm{VBN}\ \textrm{PP}
 \end{displaymath}
-\noindent 于是，可以定义短语翻译概率为$\textrm{P(}\tau( \alpha_r )|\tau( \beta_r ))$和$\textrm{P(}\tau( \beta_r )|\tau( \alpha_r ))$。它们的计算方法与基于短语的系统是完全一样的\footnotemark[8]。 
-\item (h3-4) 词汇化翻译概率，即$\textrm{P}_{lex}(\tau( \alpha_r )|\tau( \beta_r ))$和$\textrm{P}_{lex}(\tau( \beta_r )|\tau( \alpha_r ))$。这两个特征的计算方法与基于短语的系统也是一样的。
+\noindent 于是，可以定义短语翻译概率为$\textrm{P(}\tau( \alpha_r )|\tau( \beta_r ))$和$\textrm{P(}\tau( \beta_r )|\tau( \alpha_r ))$。它们的计算方法与基于短语的系统是完全一样的\footnote[9]{对于树到串规则，$\tau( \beta_r )$就是规则目标语端的符号串。}。 
+\item (h3-4) 词汇化翻译概率，即$\textrm{P}_{\textrm{lex}}(\tau( \alpha_r )|\tau( \beta_r ))$和$\textrm{P}_{\textrm{lex}}(\tau( \beta_r )|\tau( \alpha_r ))$。这两个特征的计算方法与基于短语的系统也是一样的。
 \end{itemize}
-}
-\end{definition}
-%-------------------------------------------
-\footnotetext[9]{对于树到串规则，$\tau( \beta_r )$就是规则目标语端的符号串。}
-%-------------------------------------------
-\begin{definition} {\small\sffamily\bfseries{基于句法的特征}}（对应于每条规则$r : \langle\  \alpha_h, \beta_h\ \rangle \to \langle\ \alpha_r, \beta_r, \sim\ \rangle$ ）
 
-{\small
+\parinterval {\small\sffamily\bfseries{基于句法的特征}}（对应于每条规则$r : \langle\  \alpha_h, \beta_h\ \rangle \to \langle\ \alpha_r, \beta_r, \sim\ \rangle$ ）
+
 \begin{itemize}
-\item 
 \item (h5)基于根节点句法标签的规则生成概率，即$\textrm{P(}r|\textrm{root(}r\textrm{))}$。这里，$\textrm{root(}r)$是规则所对应的双语根节点$(\alpha_h,\beta_h)$；
 \item (h6)基于源语言端的规则生成概率，即$\textrm{P(}r|\alpha_r))$，给定源语言端生成整个规则的概率；
 \item (h7)基于目标语言端的规则生成概率，即$\textrm{P(}r|\beta_r))$，给定目标语言端生成整个规则的概率。
 \end{itemize}
-}
-\end{definition}
-%-------------------------------------------
 
-%-------------------------------------------
-\begin{definition} {\small\sffamily\bfseries{其它特征}}（对应于整个推导$d$）
+\parinterval {\small\sffamily\bfseries{其它特征}}（对应于整个推导$d$）
 
-{\small
 \begin{itemize}
-\item 
-\item (h8)语言模型，即$\textrm{P}_{lm}(\textbf{t})$，用于度量译文的流畅度；
+\item (h8)语言模型，即$\textrm{P}_{\textrm{lm}}(\textbf{t})$，用于度量译文的流畅度；
 \item (h9)译文长度，即$|\textbf{t}|$，用于避免模型过于倾向生成短译文（因为短译文语言模型分数高）；
 \item (h10)翻译规则数量，学习对使用规则数量的偏好。比如，如果这个特征的权重较高，则表明系统更喜欢使用数量多的规则；
 \item (h11)组合规则的数量，学习对组合规则的偏好；
 \item (h12)词汇化规则的数量，学习对含有终结符规则的偏好；
 \item (h13)低频规则的数量，学习对训练数据中出现频次低于3的规则的偏好。低频规则大多不可靠，设计这个特征的目的也是为了区分不同质量的规则。
 \end{itemize}
-}
-\end{definition}
-%-------------------------------------------
 
 %--4.4.5 基于超图的推导空间表示---------------------
 \subsection{基于超图的推导空间表示}\index{Chapter4.4.5}
@@ -2062,12 +1979,10 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 %-------------------------------------------
 
 \parinterval 与传统的有向图不同，超图中的每一个边（超边）的尾可以包含多个节点。也就是说，每个超边从若干个节点出发最后指向同一个节点。这种定义完美契合了CFG的要求。比如，如果把节点看作是一个推导所对应树结构的根节点（含有句法标记），那么每个超边就可以表示一条CFG规则。图\ref{fig:example-of-hyper-graph}就展示了一个简单的超图。其中每个节点都有一个句法标记，句法标记下面记录了这个节点的跨度。超边edge1和edge2分别对应了两条CFG规则：
-\begin{example}
 \begin{eqnarray}
 \textrm{VP} \rightarrow \textrm{VV}\ \textrm{NP} \nonumber \\
 \textrm{NP} \rightarrow \textrm{NN}\ \textrm{NP} \nonumber
 \end{eqnarray}
-\end{example}
 
 \parinterval 对于规则``$\textrm{VP} \rightarrow \textrm{VV}\ \textrm{NP}$''，超边的头指向VP，超边的尾表示规则右部的两个变量VV和NP。规则``$\textrm{NP} \rightarrow \textrm{NN}\ \textrm{NP}$''也可以进行类似的解释。
 
@@ -2081,22 +1996,22 @@ r_9& \quad &\textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\te
 \end{figure}
 %-------------------------------------------
 
-\parinterval 不难发现，超图提供了一种非常紧凑的数据结构来表示多个推导，因为不同推导之间可以共享节点。如果把图\ref{fig:example-of-hyper-graph}中的蓝色和红色部分看作是两个推导，那么它们就共享了同一个节点NN[1,2]。能够想象，简单枚举一个句子所有的推导几乎是不可能的，但是用超图的方式却可以很有效的对指数级数量的推导进行表示。另一方面，超图上的运算常常被看作是一种基于半环的代数系统，而且人们发现许多句法分析和机器翻译问题本质上都是{\small\sffamily\bfseries{半环分析}}（semi-ring parsing）。不过，由于篇幅有限，这里我们不会对半环等结构展开讨论。感兴趣的读者可以查阅相关文献\cite{goodman1999semiring}\cite{eisner2002parameter}。
+\parinterval 不难发现，超图提供了一种非常紧凑的数据结构来表示多个推导，因为不同推导之间可以共享节点。如果把图\ref{fig:example-of-hyper-graph}中的蓝色和红色部分看作是两个推导，那么它们就共享了同一个节点NN[1,2]。能够想象，简单枚举一个句子所有的推导几乎是不可能的，但是用超图的方式却可以很有效的对指数级数量的推导进行表示。另一方面，超图上的运算常常被看作是一种基于半环的代数系统，而且人们发现许多句法分析和机器翻译问题本质上都是{\small\sffamily\bfseries{半环分析}}（semi-ring parsing）。不过，由于篇幅有限，这里我们不会对半环等结构展开讨论。感兴趣的读者可以查阅相关文献\cite{goodman1999semiring,eisner2002parameter}。
 
 \parinterval 从句法分析的角度看，超图最大程度的复用了局部的分析结果，使得分析可以``结构化''。比如，有两个推导：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-d_1 = {r_1}^{\circ}{r_2}^{\circ}{r_3}^{\circ}{r_4} \label{eqa4.30}\\
-d_2 = {r_1}^{\circ}{r_2}^{\circ}{r_3}^{\circ}{r_5}
+d_1 = {r_1} \circ {r_2} \circ {r_3} \circ {r_4} \label{eqa4.30}\\
+d_2 = {r_1} \circ {r_2} \circ {r_3} \circ {r_5}
 \label{eqa4.31}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
 
-\noindent 其中，$r_1$-$r_5$分别表示不同的规则。${r_1}^{\circ}{r_2}^{\circ}{r_3}$是两个推导的公共部分。在超图表示中，${r_1}^{\circ}{r_2}^{\circ}{r_3}$可以对应一个子图，显然这个子图也是一个推导，记为${d'}= {r_1}^{\circ}{r_2}^{\circ}{r_3}$。这样，$d_1$和$d_2$不需要重复记录${r_1}^{\circ}{r_2}^{\circ}{r_3}$，重新写作：
+\noindent 其中，$r_1$-$r_5$分别表示不同的规则。${r_1} \circ {r_2} \circ {r_3}$是两个推导的公共部分。在超图表示中，${r_1} \circ {r_2} \circ {r_3}$可以对应一个子图，显然这个子图也是一个推导，记为${d'}= {r_1} \circ {r_2} \circ {r_3}$。这样，$d_1$和$d_2$不需要重复记录${r_1} \circ {r_2} \circ {r_3}$，重新写作：
 %公式--------------------------------------------------------------------
 \begin{eqnarray}
-d_1 = {d'}^{\circ}{r_4} \label{eqa4.32}\\
-d_1 = {d'}^{\circ}{r_5}
+d_1 = {d'} \circ {r_4} \label{eqa4.32}\\
+d_1 = {d'} \circ {r_5}
 \label{eqa4.33}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
@@ -2142,7 +2057,7 @@ d_1 = {d'}^{\circ}{r_5}
 \end{eqnarray}
 %公式--------------------------------------------------------------------
 
-\noindent 这也是一种标准的{\small\sffamily\bfseries{基于串的解码}}（string-based decoding），即通过句法模型对输入的源语言句子进行翻译，得到译文串。不过，搜索所有的推导会导致巨大的解码空间。对于树到串和树到树翻译来说来说，源语言句法树是可见的，因此可以使用另一种解码方法 $-$ {\small\sffamily\bfseries{基于树的解码}}（tree-based decoding），即把输出入的源语句法树翻译为目标语串。
+\noindent 这也是一种标准的{\small\sffamily\bfseries{基于串的解码}}（string-based decoding），即通过句法模型对输入的源语言句子进行翻译，得到译文串。不过，搜索所有的推导会导致巨大的解码空间。对于树到串和树到树翻译来说来说，源语言句法树是可见的，因此可以使用另一种解码方法–{\small\sffamily\bfseries{基于树的解码}}（tree-based decoding），即把输出入的源语句法树翻译为目标语串。
 
 \parinterval 表\ref{tab:decode-base-string-vs-base-tree}对比了基于串和基于树的解码方法。可以看到，基于树的解码只考虑了与源语言句法树兼容的推导，因此搜索空间更小，不过解码速度会更快。
 
@@ -2152,13 +2067,12 @@ d_1 = {d'}^{\circ}{r_5}
 \begin{center}
 \caption{基于串的解码 vs 基于树的解码}
 \label{tab:decode-base-string-vs-base-tree}
-{\scriptsize
-\begin{tabular}{l | l | l}
+{
+\begin{tabular}{l | l l}
 对比 & 基于树的解码 & 基于串的解码 \\
 \hline
-\rule{0pt}{15pt}解码方法 & $\hat{d} = \arg\max_{d \in D_tree} score (d)$ & $\hat{d} = \arg\max_{d \in D} score (d)$ \\
-\rule{0pt}{15pt}搜索空间 & 与输入的源语句法树兼容的 & 所有的推导$D$ \\
-& 推导$D_tree$ & \\
+\rule{0pt}{15pt}解码方法 & $\hat{d} = \arg\max_{d \in D_{\textrm{tree}}} \textrm{score} (d)$ & $\hat{d} = \arg\max_{d \in D} \textrm{score} (d)$ \\
+\rule{0pt}{15pt}搜索空间 & 与输入的源语句法树兼容的推导$D_{\textrm{tree}}$ & 所有的推导$D$ \\
 \rule{0pt}{15pt}适用模型 & 树到串、树到树 & 所有的句法模型 \\
 \rule{0pt}{15pt}解码算法 & chart解码 & CYK + 规则二叉化 \\
 \rule{0pt}{15pt}速度 & 快 & 一般较慢
@@ -2235,20 +2149,16 @@ d_1 = {d'}^{\circ}{r_5}
 \begin{itemize}
 \item 对文法进行限制。比如，可以限制规则中变量的数量。或者直接不允许连续的变量，这样的规则也被称作满足Lexicalized Norm Form (LNF)的规则。比如，层次短语规则就是LNF规则。由于LNF中单词（终结符）可以作为锚点，因此规则匹配时所有变量的匹配范围是固定的；
 \item 对规则进行二叉化，使用CYK方法进行分析。这个方法也是句法分析中常用的策略。所谓规则二叉化是把规则转化为最多只含两个变量或连续词串的规则（串到树规则）。比如，对于如下的规则：
-\begin{example}
 \begin{eqnarray}
 \textrm{喜欢}\ \textrm{VP}_1\ \textrm{NP}_2 \rightarrow \textrm{VP(VBZ(likes)}\ \textrm{VP}_1\ \textrm{NP}_2 ) \nonumber
 \end{eqnarray}
-\end{example}
 
 \noindent 二叉化的结果为：
-\begin{example}
 \begin{eqnarray}
 \textrm{喜欢}\ \textrm{V103} &\rightarrow& \textrm{VP}(\textrm{VBZ}(\textrm{likes})\ \textrm{V103} ) \nonumber \\
 \textrm{VP}_1\ \textrm{NP}_2 &\rightarrow& \textrm{V103(}\ \textrm{VP}_1\ \textrm{NP}_2 ) \nonumber
 \end{eqnarray}
-\end{example}
-\noindent 可以看到，这两条新的规则源语言端只有两个部分，代表两个分叉。V103是一个新的标签，它没有任何句法含义。不过，为了保证二叉化后规则目标语部分的连续性，需要考虑源语言和目标语二叉化的同步性\cite{zhang2006synchronous}\cite{Tong2009Better}。这样的规则与CYK方法一起使用完成解码，具体内容可以参考4.3.4节的内容。
+\noindent 可以看到，这两条新的规则源语言端只有两个部分，代表两个分叉。V103是一个新的标签，它没有任何句法含义。不过，为了保证二叉化后规则目标语部分的连续性，需要考虑源语言和目标语二叉化的同步性\cite{zhang2006synchronous,Tong2009Better}。这样的规则与CYK方法一起使用完成解码，具体内容可以参考4.3.4节的内容。
 \end{itemize}
 
 \parinterval 总的来说，基于句法的解码器较为复杂。无论是算法的设计还是工程技巧的运用，对开发者都有一定要求。因此开发优秀的基于句法的机器翻译系统也是一项有挑战的工作。
@@ -2261,8 +2171,8 @@ d_1 = {d'}^{\circ}{r_5}
 \parinterval 本章对统计机器翻译的经典模型进行了介绍。从早期的基于短语的模型，再到层次短语模型，以及更为复杂的基于语言学句法的模型，我们都尝试对不同的建模思想进行阐释。只是，统计机器翻译的内容非常丰富，很难通过几十页的文字进行面面俱到的介绍。还有很多方向值得读者进一步了解：
 
 \begin{itemize}
-\item 统计机器翻译的成功很大程度上来自判别式模型引入任意特征的能力。因此，在统计机器翻译时代，很多工作都集中在新特征的设计上。比如，可以基于不同的统计特征和先验知识设计翻译特征\cite{och2004smorgasbord}\cite{Chiang200911}\cite{gildea2003loosely}，也可以模仿很多分类任务设计大规模的稀疏特征\cite{chiang2008online}。另一方面，模型训练和特征权重调优也是统计机器翻译中的重要问题，除了最小错误率训练，还有很多方法，在过去十年，研究人员提出了许多有效的方法来学习现代SMT系统的特征值和权重。这些方法有最大似然训练\cite{koehn2003statistical}\cite{Peter1993The}，区分性训练\cite{Blunsom2008A}，贝叶斯训练\cite{Blunsom2009A}\cite{Cohn2009A}，最小错误率训练（MERT）\cite{och2003minimum}，最小风险训练\cite{smith2006minimum}\cite{li2009first-}，最大利益训练\cite{watanabe2007online}\cite{Chiang200911}以及两两排序优化（PRO）\cite{Hopkins2011Tuning}\cite{dreyer2015apro}。尽管这些方法被广泛使用，但是他们仍然没有解决训练与解码间不匹配的问题。大多数系统仍然采用相对频率估计加上MERT/PRO的模式。实际上，统计机器翻译的训练和解码本身也存在不一致的问题，比如，特征值由双语数据上的极大似然估计得到（没有剪枝），而解码时却使用束剪枝，而且目的是最大化机器翻译评价指标。对于这个问题也可以通过调整训练的目标函数进行缓解\cite{XiaoA}；
-\item 统计机器翻译的另一个基础问题是如何表示并获取翻译单元（如短语）。这个问题在本章介绍的三种模型中都有涉及。传统方法中，研究者大多使用词对齐或者句法树等结构化信息，通过启发性方法进行短语或者规则的获取。不过这类方法最大的问题是上游系统（比如，词对齐、句法分析等）的错误会产生蔓延。因此，很多研究者尝试使用更多样的对齐或者句法分析来指导翻译单元的获取。比如，可以绕过词对齐，直接进行短语对齐\cite{koehn2003statistical}；也可以使用多个句法树或者句法森林来覆盖更多的句法现象，进而增加规则抽取的召回率\cite{mi2008forest}\cite{xiao2010empirical}。另一个有趣的方向是用更紧凑的方式表示更多样的翻译假设，比如，直接将翻译结果用有限状态自动机进行表示，进行更大搜索空间上的解码\cite{de2010hierarchical}\cite{Casacuberta2004Machine}；
-\item 系统融合是具有统计机器翻译时代特色的研究方向。某种意义上说，系统融合的兴起源于本世纪初各种机器翻译比赛。因为当时提升翻译性能的主要方法之一就是将多个翻译引擎进行融合。系统融合的出发点是：多样的翻译候选有助于生成更好的译文。有很多思路，比较简单的方法是假设选择，即从多个翻译系统的输出中直接选择一个译文\cite{bangalore2001computing}\cite{rosti2007combining}\cite{xiao2013bagging}；另一种方法是用多个系统的输出构建解码格或者混淆网络，这样可以生成新的翻译结果\cite{Yang2009Lattice}\cite{He2008Indirect}\cite{Li2009Incremental}；此外，还可以在解码过程中动态融合不同模型\cite{Yang2009Joint}、co-decoding（Mu Li）\cite{Mu2009Collaborative}。另一方面，也有研究者探讨如何在一个翻译系统中让不同的模型进行互补，而不是简单的融合，比如，可以控制句法在机器翻译中使用的程度，让句法模型和层次短语模型处理各自擅长的问题\cite{Tong2016Syntactic}；
-\item 语言模型是统计机器翻译系统所使用的重要特征。但是，即使引入n-gram语言模型，机器翻译系统仍然会产生语法上不正确的译文，甚至会生成结构完全错误的译文。对于这个问题，研究者尝试使用基于句法的语言模型。早期的探索有Charniak等人\cite{charniak2001immediate}和Och等人\cite{och2004smorgasbord}的工作，不过当时的结果并没有显示出基于句法的语言模型可以显著提升机器翻译的品质。后来，BBN的研究团队提出了基于依存树的语言模型\cite{shen2008a}，这个模型可以显著提升层次短语模型的性能。正是凭借这这项技术，BBN的系统也在多个机器翻译评测比赛中名列前茅，引起了广泛关注。除此之外，也有研究工作探索基于树替换文法等结构的语言模型\cite{xiao2011language}。实际上，树到树、串到树模型也可以被看作是一种对目标语言句法合理性的度量，只不过目标语言的句法信息被隐含在翻译规则中。这时，可以在翻译规则上设计相应的特征，以达到引入目标语句法语言模型的目的。
+\item 统计机器翻译的成功很大程度上来自判别式模型引入任意特征的能力。因此，在统计机器翻译时代，很多工作都集中在新特征的设计上。比如，可以基于不同的统计特征和先验知识设计翻译特征\cite{och2004smorgasbord,Chiang200911,gildea2003loosely}，也可以模仿很多分类任务设计大规模的稀疏特征\cite{chiang2008online}。另一方面，模型训练和特征权重调优也是统计机器翻译中的重要问题，除了最小错误率训练，还有很多方法，在过去十年，研究人员提出了许多有效的方法来学习现代SMT系统的特征值和权重。这些方法有最大似然训练\cite{koehn2003statistical,Peter1993The}，区分性训练\cite{Blunsom2008A}，贝叶斯训练\cite{Blunsom2009A,Cohn2009A}，最小错误率训练（MERT）\cite{och2003minimum}，最小风险训练\cite{smith2006minimum,li2009first-}，最大利益训练\cite{watanabe2007online,Chiang200911}以及两两排序优化（PRO）\cite{Hopkins2011Tuning,dreyer2015apro}。尽管这些方法被广泛使用，但是他们仍然没有解决训练与解码间不匹配的问题。大多数系统仍然采用相对频率估计加上MERT/PRO的模式。实际上，统计机器翻译的训练和解码本身也存在不一致的问题，比如，特征值由双语数据上的极大似然估计得到（没有剪枝），而解码时却使用束剪枝，而且目的是最大化机器翻译评价指标。对于这个问题也可以通过调整训练的目标函数进行缓解\cite{XiaoA}；
+\item 统计机器翻译的另一个基础问题是如何表示并获取翻译单元（如短语）。这个问题在本章介绍的三种模型中都有涉及。传统方法中，研究者大多使用词对齐或者句法树等结构化信息，通过启发性方法进行短语或者规则的获取。不过这类方法最大的问题是上游系统（比如，词对齐、句法分析等）的错误会产生蔓延。因此，很多研究者尝试使用更多样的对齐或者句法分析来指导翻译单元的获取。比如，可以绕过词对齐，直接进行短语对齐\cite{koehn2003statistical}；也可以使用多个句法树或者句法森林来覆盖更多的句法现象，进而增加规则抽取的召回率\cite{mi2008forest,xiao2010empirical}。另一个有趣的方向是用更紧凑的方式表示更多样的翻译假设，比如，直接将翻译结果用有限状态自动机进行表示，进行更大搜索空间上的解码\cite{de2010hierarchical,Casacuberta2004Machine}；
+\item 系统融合是具有统计机器翻译时代特色的研究方向。某种意义上说，系统融合的兴起源于本世纪初各种机器翻译比赛。因为当时提升翻译性能的主要方法之一就是将多个翻译引擎进行融合。系统融合的出发点是：多样的翻译候选有助于生成更好的译文。有很多思路，比较简单的方法是假设选择，即从多个翻译系统的输出中直接选择一个译文\cite{bangalore2001computing,rosti2007combining,xiao2013bagging}；另一种方法是用多个系统的输出构建解码格或者混淆网络，这样可以生成新的翻译结果\cite{Yang2009Lattice,He2008Indirect,Li2009Incremental}；此外，还可以在解码过程中动态融合不同模型\cite{Yang2009Joint,Mu2009Collaborative}。另一方面，也有研究者探讨如何在一个翻译系统中让不同的模型进行互补，而不是简单的融合，比如，可以控制句法在机器翻译中使用的程度，让句法模型和层次短语模型处理各自擅长的问题\cite{Tong2016Syntactic}；
+\item 语言模型是统计机器翻译系统所使用的重要特征。但是，即使引入$n$-gram语言模型，机器翻译系统仍然会产生语法上不正确的译文，甚至会生成结构完全错误的译文。对于这个问题，研究者尝试使用基于句法的语言模型。早期的探索有Charniak等人\cite{charniak2001immediate}和Och等人\cite{och2004smorgasbord}的工作，不过当时的结果并没有显示出基于句法的语言模型可以显著提升机器翻译的品质。后来，BBN的研究团队提出了基于依存树的语言模型\cite{shen2008a}，这个模型可以显著提升层次短语模型的性能。正是凭借这这项技术，BBN的系统也在多个机器翻译评测比赛中名列前茅，引起了广泛关注。除此之外，也有研究工作探索基于树替换文法等结构的语言模型\cite{xiao2011language}。实际上，树到树、串到树模型也可以被看作是一种对目标语言句法合理性的度量，只不过目标语言的句法信息被隐含在翻译规则中。这时，可以在翻译规则上设计相应的特征，以达到引入目标语句法语言模型的目的。
 \end{itemize}
\ No newline at end of file
diff --git a/Book/structure.tex b/Book/structure.tex
index 1ff6b9c..36690fc 100644
--- a/Book/structure.tex
+++ b/Book/structure.tex
@@ -74,7 +74,7 @@
 %	BIBLIOGRAPHY AND INDEX
 %----------------------------------------------------------------------------------------
 
-\usepackage[style=numeric,citestyle=numeric,sorting=nyt,sortcites=true,autopunct=true,babel=hyphen,hyperref=true,abbreviate=false,backref=true,backend=biber]{biblatex}
+\usepackage[style=numeric,citestyle=numeric,sorting=nyt,sortcites=true,autopunct=true,babel=hyphen,hyperref=true,abbreviate=false,backref=true,backend=biber,maxcitenames=2,maxbibnames=9999]{biblatex}
 \addbibresource{bibliography.bib} % BibTeX bibliography file
 \defbibheading{bibempty}{}