Skip to content

M
mtbookv2
Commit 3b34f35c by zengxin
Options

合并分支 'caorunzhe' 到 'zengxin' 

Caorunzhe

查看合并请求 !971
parents db55bbab 30f143b7
正在显示 包含 1275 行增加 和 941 行删除
Chapter1/Figures/figure-example-smt.tex
......@@ -52,7 +52,7 @@
}
{
\begin{scope}[xshift=1.7in]
\begin{scope}[xshift=2in]
{\scriptsize
\node [anchor=north west] (phrase1) at (0,0) {$\textrm{Pr}(\textrm{我} \to \textrm{I}) = 0.7$};
\node [anchor=north west] (phrase2) at ([yshift=0.1em]phrase1.south west) {$\textrm{Pr}(\textrm{我} \to \textrm{me}) = 0.3$};
......@@ -76,7 +76,7 @@
}
{
\begin{scope}[xshift=1.7in,yshift=-1.55in]
\begin{scope}[xshift=2in,yshift=-1.55in]
{\scriptsize
\node [anchor=north west] (ngram1) at (0,0) {$\textrm{Pr}(\textrm{I}) = 0.0001$};
\node [anchor=north west] (ngram2) at ([yshift=0.0em]ngram1.south west) {$\textrm{Pr}(\textrm{I}\ \textrm{am}) = 0.623$};
......@@ -96,14 +96,14 @@
}
{
\draw[->,thick,ublue] (bidata.east)--([xshift=2.2em]bidata.east) node[pos=0.5,above] (simexample) {\color{red}{\scriptsize{\scriptsize{学习}}}};
\draw[->,thick,ublue] (bidata.east)--([xshift=4.2em]bidata.east) node[pos=0.5,above] (simexample) {\color{red}{\scriptsize{\scriptsize{学习}}}};
}
{
\draw[->,thick,ublue] (monodata.east)--([xshift=2.2em]monodata.east) node[pos=0.5,above] (simexample) {\color{red}{\scriptsize{\scriptsize{学习}}}};
\draw[->,thick,ublue] (monodata.east)--([xshift=4.2em]monodata.east) node[pos=0.5,above] (simexample) {\color{red}{\scriptsize{\scriptsize{学习}}}};
}
\begin{scope}[xshift=3.6in]
\begin{scope}[xshift=4in]
{\footnotesize
{
\node[anchor=center] (srcsentence) at (0,0) {我 对 你 感到 满意};
......
Chapter1/chapter1.tex
......@@ -54,14 +54,6 @@
\parinterval 从机器翻译系统的组成上来看，通常可以抽象为两个部分，如图\ref{fig:1-2}所示：
\begin{itemize}
\vspace{0.5em}
\item {\small\bfnew{资源}}：如果把机器翻译系统比作一辆汽车，资源就好比是可以使汽车运行的“汽油”，它包括很多内容，如翻译规则、双（单）语数据、知识库等翻译知识，且这些“知识”都是计算机可读的。值得一提的是,如果没有翻译资源的支持，任何机器翻译系统都无法运行起来。
\vspace{0.5em}
\item {\small\bfnew{系统}}：机器翻译算法的程序实现被称作系统，也就是机器翻译研究人员开发的软件。无论是翻译规则、翻译模板还是统计模型中的参数都需要通过机器翻译系统进行读取和使用。
\vspace{0.5em}
\end{itemize}
%----------------------------------------------
\begin{figure}[htp]
\centering
......@@ -71,6 +63,14 @@
\end{figure}
%-------------------------------------------
\begin{itemize}
\vspace{0.5em}
\item {\small\bfnew{资源}}：如果把机器翻译系统比作一辆汽车，资源就好比是可以使汽车运行的“汽油”，它包括很多内容，如翻译规则、双（单）语数据、知识库等翻译知识，且这些“知识”都是计算机可读的。值得一提的是,如果没有翻译资源的支持，任何机器翻译系统都无法运行起来。
\vspace{0.5em}
\item {\small\bfnew{系统}}：机器翻译算法的程序实现被称作系统，也就是机器翻译研究人员开发的软件。无论是翻译规则、翻译模板还是统计模型中的参数都需要通过机器翻译系统进行读取和使用。
\vspace{0.5em}
\end{itemize}
\parinterval 构建一个强大的机器翻译系统需要“资源”和“系统”两方面共同作用。在资源方面，随着语料库语言学的发展，已经有大量的高质量的双语和单语数据（称为语料）被整理并且被电子化存储，因此可以说具备了研发机器翻译系统所需要的语料基础。特别是像英语、汉语等世界主流语种，相关语料资源已经非常丰富，这也大大加速了相关研究的进展。当然，对于一些稀缺资源语种或者特殊的领域，语料库中的语料仍然匮乏，但是这些并不影响机器翻译领域整体的发展速度。因此在现有语料库的基础上，很多研究者把精力集中在“系统”研发上。
%----------------------------------------------------------------------------------------
......@@ -129,7 +129,7 @@
\parinterval 1957年，Noam Chomsky在\emph{Syntactic Structures}中描述了转换生成语法\upcite{chomsky1957syntactic}，并使用数学方法来研究自然语言，建立了包括上下文有关语法、上下文无关语法等4种类型的语法。这些工作最终为今天计算机中广泛使用的“形式语言”奠定了基础。而他的思想也深深地影响了同时期的语言学和自然语言处理领域的学者。特别的是，早期基于规则的机器翻译中也大量使用了这些思想。
\parinterval 虽然在这段时间，使用机器进行翻译的议题越加火热，但是事情并不总是一帆风顺，怀疑论者对机器翻译一直存有质疑，并很容易找出一些机器翻译无法解决的问题。自然地，人们也期望能够客观地评估一下机器翻译的可行性。当时美国基金资助组织委任自动语言处理咨询会承担了这项任务。经过近两年的调查与分析，该委员会于1966年11月公布了一个题为\emph{LANGUAGE AND MACHINES}的报告（图\ref{fig:1-5}），即ALPAC报告。该报告全面否定了机器翻译的可行性，为机器翻译的研究泼了一盆冷水。
\parinterval 虽然在这段时间，使用机器进行翻译的议题越加火热，但是事情并不总是一帆风顺，怀疑论者对机器翻译一直存有质疑，并很容易找出一些机器翻译无法解决的问题。自然地，人们也期望能够客观地评估一下机器翻译的可行性。当时美国基金资助组织委任自动语言处理咨询会承担了这项任务。经过近两年的调查与分析，该委员会于1966年11月公布了一个题为\emph{LANGUAGE AND MACHINES}的报告（图\ref{fig:1-4}），即ALPAC报告。该报告全面否定了机器翻译的可行性，为机器翻译的研究泼了一盆冷水。
%----------------------------------------------
\begin{figure}[htp]
......@@ -258,8 +258,6 @@
\parinterval 规则就像语言中的“If-then”语句，如果满足条件，则执行相应的语义动作。比如，可以将待翻译句子中的某个词，使用目标语言单词进行替换，但是这种替换并非随意的，而是在语言学知识的指导下进行的。
\parinterval 图\ref{fig:1-8}展示了一个使用转换法进行翻译的实例。这里，利用一个简单的汉译英规则库完成对句子“我对你感到满意”的翻译。当翻译“我”时，从规则库中找到规则1，该规则表示遇到单词“我”就翻译为“I”；类似地，也可以从规则库中找到规则4，该规则表示翻译调序，即将单词“you”放到“be satisfied with”后面。这种通过规则表示单词之间的对应关系也为统计机器翻译方法提供了思路。如统计机器翻译中，基于短语的翻译模型使用短语对对原文进行替换，详细描述可以参考{\chapterseven}。
%----------------------------------------------
\begin{figure}[htp]
\centering
......@@ -269,6 +267,8 @@
\end{figure}
%-------------------------------------------
\parinterval 图\ref{fig:1-8}展示了一个使用转换法进行翻译的实例。这里，利用一个简单的汉译英规则库完成对句子“我对你感到满意”的翻译。当翻译“我”时，从规则库中找到规则1，该规则表示遇到单词“我”就翻译为“I”；类似地，也可以从规则库中找到规则4，该规则表示翻译调序，即将单词“you”放到“be satisfied with”后面。这种通过规则表示单词之间的对应关系也为统计机器翻译方法提供了思路。如统计机器翻译中，基于短语的翻译模型使用短语对对原文进行替换，详细描述可以参考{\chapterseven}。
\parinterval 在上述例子中可以发现，规则不仅仅可以翻译句子之间单词的对应，如规则1，还可以表示句法甚至语法之间的对应，如规则6。因此基于规则的方法可以分成多个层次，如图\ref{fig:1-9}所示。图中不同的层次表示采用不同的知识来书写规则，进而完成机器翻译过程。对于翻译问题，可以构建不同层次的基于规则的机器翻译系统。这里包括四个层次，分别为：词汇转换、句法转换、语义转换和中间语言层。其中，上层可以继承下层的翻译知识，比如说句法转换层会利用词汇转换层知识。早期基于规则的方法属于词汇转换层。
%----------------------------------------------
......
Chapter13/Figures/figure-bpe.tex
......@@ -11,11 +11,11 @@
\node [anchor=west,tnode] (n3) at ([xshift=5em,yshift=0em]n2.east) {};
\node [anchor=north west,align=left,font=\footnotesize] (n31) at ([xshift=0.2em,yshift=-0.2em]n3.north west) {{\small 词表}\\low\\lower\\newest\\widest\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n32) at ([xshift=-0.2em,yshift=-0.2em]n3.north east) {{\small 频率}\\6\\2\\6\\3\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n32) at ([xshift=-0.2em,yshift=-0.2em]n3.north east) {{\small 频次}\\6\\2\\6\\3\\$\ldots$};
\node [anchor=west,tnode] (n4) at ([xshift=5em,yshift=0em]n3.east) {};
\node [anchor=north west,align=left,font=\footnotesize] (n41) at ([xshift=0.2em,yshift=-0.2em]n4.north west) {{\small 词表}\\l/o/w\\l/o/w/e/r\\n/e/w/e/s/t\\w/i/d/e/s/t\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n42) at ([xshift=-0.2em,yshift=-0.2em]n4.north east) {{\small 频率}\\6\\2\\6\\3\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n42) at ([xshift=-0.2em,yshift=-0.2em]n4.north east) {{\small 频次}\\6\\2\\6\\3\\$\ldots$};
\begin{pgfonlayer}{background}
......@@ -32,13 +32,13 @@
\node [anchor=north west,tnode] (n6) at ([xshift=0em,yshift=-0.5em]n5.south west) {};
\node [anchor=north west,align=left,font=\footnotesize] (n61) at ([xshift=0.2em,yshift=-0.2em]n6.north west) {{\small 词表}\\l/o/w\\l/o/w/e/r\\n/e/w/e/s/t\\w/i/d/e/s/t\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n62) at ([xshift=-0.2em,yshift=-0.2em]n6.north east) {{\small 频率}\\6\\2\\6\\3\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n62) at ([xshift=-0.2em,yshift=-0.2em]n6.north east) {{\small 频次}\\6\\2\\6\\3\\$\ldots$};
\draw [->,thick,ublue] ([xshift=-0em,yshift=-0em]n4.south) .. controls +(south:4em) and +(north:4em) .. ([xshift=1em,yshift=-0em]n6.north);
\node [anchor=west,pnode] (n7) at ([xshift=5em,yshift=0em]n6.east) {};
\node [anchor=north west,align=left,font=\footnotesize] (n71) at ([xshift=0.2em,yshift=-0.2em]n7.north west) {{\small 二元组}\\(e,s)\\(s,t)\\(l,o)\\(o,w)\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n72) at ([xshift=-0.2em,yshift=-0.2em]n7.north east) {{\small 频率}\\9\\9\\8\\8\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n72) at ([xshift=-0.2em,yshift=-0.2em]n7.north east) {{\small 频次}\\9\\9\\8\\8\\$\ldots$};
\node [anchor=west,mnode] (n8) at ([xshift=5em,yshift=0em]n7.east) {};
\node [anchor=north,align=center,font=\footnotesize] (n81) at ([xshift=0em,yshift=-0.2em]n8.north) {{\small 符号合并表}\\(e,s)};
......@@ -51,14 +51,14 @@
%第三排
\node [anchor=north,tnode] (n9) at ([xshift=0em,yshift=-2.5em]n6.south) {};
\node [anchor=north west,align=left,font=\footnotesize] (n91) at ([xshift=0.2em,yshift=-0.2em]n9.north west) {{\small 词表}\\l/o/w\\l/o/w/e/r\\n/e/w/{\red es}/t\\w/i/d/{\red es}/t\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n92) at ([xshift=-0.2em,yshift=-0.2em]n9.north east) {{\small 频率}\\6\\2\\6\\3\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n92) at ([xshift=-0.2em,yshift=-0.2em]n9.north east) {{\small 频次}\\6\\2\\6\\3\\$\ldots$};
\draw [->,thick,ublue] ([xshift=-0em,yshift=-0em]n8.south) .. controls +(south:3em) and +(north:3em) .. ([xshift=1em,yshift=-0em]n9.north);
\node [anchor=north west,ublue,font=\footnotesize,align=left] (l1) at ([xshift=1em,yshift=-0em]n7.south east) {在词表中\\[0.8ex]合并(e,s)};
\node [anchor=west,pnode] (n10) at ([xshift=5em,yshift=0em]n9.east) {};
\node [anchor=north west,align=left,font=\footnotesize] (n101) at ([xshift=0.2em,yshift=-0.2em]n10.north west) {{\small 二元组}\\(es,t)\\(l,o)\\(o,w)\\(n,e)\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n102) at ([xshift=-0.2em,yshift=-0.2em]n10.north east) {{\small 频率}\\9\\8\\8\\6\\$\ldots$};
\node [anchor=north east,align=center,font=\footnotesize] (n102) at ([xshift=-0.2em,yshift=-0.2em]n10.north east) {{\small 频次}\\9\\8\\8\\6\\$\ldots$};
\node [anchor=west,mnode] (n11) at ([xshift=5em,yshift=0em]n10.east) {};
\node [anchor=north,align=center,font=\footnotesize] (n111) at ([xshift=0em,yshift=-0.2em]n11.north) {{\small 符号合并表}\\(e,s)\\(es,t)};
......
Chapter13/Figures/figure-difference-between-word-level-and-sequence-level-in-knowledge-distillation.tex
......@@ -13,6 +13,7 @@
\coordinate (topright) at ([shift={(0.25cm,0.25cm)}]prob11.center);
\node [draw,fit=(prob11) (prob21) (prob31) (prob41) (prob51) (topright) (bottomleft)] (prob1) {};
\end{pgfonlayer}
% \node [anchor=center] (word11) at ([yshift=0.7cm]prob11.center) {I};
% Column 2
\node [prob,minimum size=0.1cm,anchor=center] (prob12) at ([xshift=1cm]prob11.center) {};
......@@ -25,18 +26,20 @@
\coordinate (topright) at ([shift={(0.25cm,0.25cm)}]prob12.center);
\node [draw,fit=(prob12) (prob22) (prob32) (prob42) (prob52) (topright) (bottomleft)] (prob2) {};
\end{pgfonlayer}
% \node [anchor=center] (word12) at ([yshift=0.68cm]prob12.center) {am};
% Column 3
\node [prob,minimum size=0.1cm,anchor=center] (prob13) at ([xshift=1cm]prob12.center) {};
\node [prob,minimum size=0.1cm,anchor=center] (prob23) at ([yshift=-0.5cm]prob13.center) {};
\node [prob,minimum size=0.1cm,anchor=center] (prob33) at ([yshift=-0.5cm]prob23.center) {};
\node [prob,minimum size=0.4cm,anchor=center] (prob43) at ([yshift=-0.5cm]prob33.center) {$.6$};
\node [prob,minimum size=0.1cm,anchor=center] (prob53) at ([yshift=-0.5cm]prob43.center) {};
\node [prob,minimum size=0.1cm,anchor=center] (prob43) at ([yshift=-0.5cm]prob33.center) {};
\node [prob,minimum size=0.4cm,anchor=center] (prob53) at ([yshift=-0.5cm]prob43.center) {$.6$};
\begin{pgfonlayer}{background}
\coordinate (bottomleft) at ([shift={(-0.25cm,-0.25cm)}]prob53.center);
\coordinate (topright) at ([shift={(0.25cm,0.25cm)}]prob13.center);
\node [draw,fit=(prob13) (prob23) (prob33) (prob43) (prob53) (topright) (bottomleft)] (prob3) {};
\end{pgfonlayer}
% \node [anchor=center] (word13) at ([yshift=0.7cm]prob13.center) {fine};
% Column 4
\node [prob,minimum size=0.5cm,anchor=center] (prob14) at ([xshift=1cm]prob13.center) {$.8$};
......@@ -49,9 +52,10 @@
\coordinate (topright) at ([shift={(0.25cm,0.25cm)}]prob14.center);
\node [draw,fit=(prob14) (prob24) (prob34) (prob44) (prob54) (topright) (bottomleft)] (prob4) {};
\end{pgfonlayer}
% \node [anchor=center] (word14) at ([yshift=0.68cm]prob14.center) {$\langle$eos$\rangle$};
% Label
\draw [decorate,decoration={brace}] ([yshift=0.1cm]prob1.north west) to node [midway,above,font=\small] {学习目标(Teacher输出)} ([yshift=0.1cm]prob4.north east);
\draw [decorate,decoration={brace}] ([xshift=0.1cm]prob4.north east) to node [midway,right,font=\small,align=center] {教师\\模型\\输出\\分布} ([xshift=0.1cm]prob4.south east);
% Vocab
\node [word,anchor=center] () at ([xshift=-0.9cm]prob11.center) {$\langle$eos$\rangle$};
......@@ -72,19 +76,20 @@
\draw [-latex,thick] (prob\i.south) to ([yshift=-0.5cm]prob\i.south);
% Input
\node [word,anchor=south] (input1) at ([yshift=-1.8cm]prob1.south) {$\langle$eos$\rangle$};
\node [word,anchor=south] (input1) at ([yshift=-1.87cm]prob1.south) {$\langle$eos$\rangle$};
\node [word,anchor=south] (input2) at ([yshift=-1.8cm]prob2.south) {I};
\node [word,anchor=south] (input3) at ([yshift=-1.8cm]prob3.south) {am};
\node [word,anchor=south] (input4) at ([yshift=-1.8cm]prob4.south) {fine};
\foreach \i in {1,2,...,4}
\foreach \i in {2,3,4}
\draw [-latex,thick] ([yshift=0.3cm]input\i.south) to ([yshift=0.8cm]input\i.south);
\draw [-latex,thick] ([yshift=0.36cm]input1.south) to ([yshift=0.86cm]input1.south);
\node [word,anchor=south] (ns) at ([xshift=-1cm]input1.south) {输入:};
\node [word,anchor=south] (ns) at ([xshift=-1.2cm]input1.south) {真实数据:};
\node [word,anchor=north] () at ([xshift=2.1cm,yshift=-0.5cm]ns.south) {(a)\ Word-level};
\end{scope}
\begin{scope}[xshift=2.5in]
\begin{scope}[xshift=2.7in]
% Column 1
\node [prob,minimum size=0.1cm] (prob11) at (0,0) {};
\node [prob,minimum size=0.5cm,anchor=center] (prob21) at ([yshift=-0.5cm]prob11.center) {$1.$};
......@@ -96,6 +101,7 @@
\coordinate (topright) at ([shift={(0.25cm,0.25cm)}]prob11.center);
\node [draw,fit=(prob11) (prob21) (prob31) (prob41) (prob51) (topright) (bottomleft)] (prob1) {};
\end{pgfonlayer}
\node [anchor=center] (word11) at ([yshift=0.7cm]prob11.center) {I};
% Column 2
\node [prob,minimum size=0.1cm,anchor=center] (prob12) at ([xshift=1cm]prob11.center) {};
......@@ -108,6 +114,7 @@
\coordinate (topright) at ([shift={(0.25cm,0.25cm)}]prob12.center);
\node [draw,fit=(prob12) (prob22) (prob32) (prob42) (prob52) (topright) (bottomleft)] (prob2) {};
\end{pgfonlayer}
\node [anchor=center] (word12) at ([yshift=0.68cm]prob12.center) {am};
% Column 3
\node [prob,minimum size=0.1cm,anchor=center] (prob13) at ([xshift=1cm]prob12.center) {};
......@@ -120,6 +127,7 @@
\coordinate (topright) at ([shift={(0.25cm,0.25cm)}]prob13.center);
\node [draw,fit=(prob13) (prob23) (prob33) (prob43) (prob53) (topright) (bottomleft)] (prob3) {};
\end{pgfonlayer}
\node [anchor=center] (word13) at ([yshift=0.68cm]prob13.center) {good};
% Column 4
\node [prob,minimum size=0.5cm,anchor=center] (prob14) at ([xshift=1cm]prob13.center) {$1.$};
......@@ -132,9 +140,10 @@
\coordinate (topright) at ([shift={(0.25cm,0.25cm)}]prob14.center);
\node [draw,fit=(prob14) (prob24) (prob34) (prob44) (prob54) (topright) (bottomleft)] (prob4) {};
\end{pgfonlayer}
\node [anchor=center] (word14) at ([yshift=0.68cm]prob14.center) {$\langle$eos$\rangle$};
% Label
\draw [decorate,decoration={brace}] ([yshift=0.1cm]prob1.north west) to node [midway,above,font=\small] {学习目标(Teacher输出)} ([yshift=0.1cm]prob4.north east);
\draw [decorate,decoration={brace}] ([xshift=0.1cm]prob4.north east) to node [midway,right,font=\small,align=center] {教师\\模型\\输出\\译文} ([xshift=0.1cm]prob4.south east);
% Vocab
\node [word,anchor=center] () at ([xshift=-0.9cm]prob11.center) {$\langle$eos$\rangle$};
......@@ -155,16 +164,17 @@
\draw [-latex,thick] (prob\i.south) to ([yshift=-0.5cm]prob\i.south);
% Input
\node [word,anchor=south] (input1) at ([yshift=-1.8cm]prob1.south) {$\langle$eos$\rangle$};
\node [word,anchor=south] (input1) at ([yshift=-1.85cm]prob1.south) {$\langle$eos$\rangle$};
\node [word,anchor=south] (input2) at ([yshift=-1.8cm]prob2.south) {I};
\node [word,anchor=south] (input3) at ([yshift=-1.8cm]prob3.south) {am};
\node [word,anchor=center] (input4) at ([xshift=1cm]input3.center) {good};
\foreach \i in {1,2,3}
\foreach \i in {2,3}
\draw [-latex,thick] ([yshift=0.3cm]input\i.south) to ([yshift=0.8cm]input\i.south);
\draw [-latex,thick] ([yshift=0.36cm]input4.south) to ([yshift=0.86cm]input4.south);
\draw [-latex,thick] ([yshift=0.36cm]input1.south) to ([yshift=0.86cm]input1.south);
\node [word,anchor=south] (ns) at ([xshift=-1cm]input1.south) {输入:};
\node [word,anchor=south] (ns) at ([xshift=-1.2cm]input1.south) {教师译文:};
\node [word,anchor=north] () at ([xshift=2.1cm,yshift=-0.5cm]ns.south) {(b)\ Sequence-level };
\end{scope}
\end{tikzpicture}
Chapter13/Figures/figure-unk-of-bpe.tex
......@@ -3,24 +3,28 @@
\node[rounded corners=3pt,minimum width=1.0em,minimum height=2.0em,font=\scriptsize,fill=red!10,drop shadow,thick](top) at (0,0) {
\begin{tabular}{lllllll}
\multicolumn{7}{c}{符号合并表} \\
(r,$<$e$>$), & (e,s), & (l,o), & (es,t), & (lo,w), & (est,$<$e$>$), & (e,r$<$e$>$),
(r,$<$e$>$), & (e,s), & (l,o), & (es,t), & (lo,w), & (est,$<$e$>$), & (e,r$<$e$>$)
\end{tabular}
};
\node[font=\footnotesize,anchor=north] (l1) at ([xshift=0em,yshift=-1em]top.south) {(a) 符号合并表};
\node[font=\scriptsize,anchor=west] (n1) at ([xshift=-6em,yshift=-6em]top.west) {l\ o\ w\ e\ r\ $<$e$>$};
\node[font=\scriptsize,anchor=west] (n1) at ([xshift=-4.5em,yshift=-6em]top.west) {l\ o\ w\ e\ r\ $<$e$>$};
\node[font=\scriptsize,anchor=west] (n2) at ([xshift=2.6em]n1.east) {l\ o\ w\ e\ {\red r$<$e$>$}};
\node[font=\scriptsize,anchor=west] (n3) at ([xshift=2.6em]n2.east) {{\red lo}\ w\ e\ r$<$e$>$};
\node[font=\scriptsize,anchor=west] (n4) at ([xshift=2.6em]n3.east) {{\red low}\ e\ r$<$e$>$};
\node[font=\scriptsize,anchor=west] (n5) at ([xshift=2.6em]n4.east) {low\ {\red er$<$e$>$}};
\node[font=\scriptsize,anchor=west] (t1) at ([yshift=-1.5em]n1.south west) {l\ o\ w\ e\ s\ t\ $<$e$>$};
\node[font=\scriptsize,anchor=west] (t1) at ([yshift=-2.5em]n1.south west) {l\ o\ w\ e\ s\ t\ $<$e$>$};
\node[font=\scriptsize,anchor=west] (t2) at ([xshift=0.8em]t1.east) {l\ o\ w\ {\red es}\ t\ $<$e$>$};
\node[font=\scriptsize,anchor=west] (t3) at ([xshift=0.8em]t2.east) {{\red lo}\ w\ es\ t\ $<$e$>$};
\node[font=\scriptsize,anchor=west] (t4) at ([xshift=0.8em]t3.east) {lo\ w\ {\red est}\ $<$e$>$};
\node[font=\scriptsize,anchor=west] (t5) at ([xshift=0.8em]t4.east) {{\red low}\ est\ $<$e$>$};
\node[font=\scriptsize,anchor=west] (t6) at ([xshift=0.8em]t5.east) {low\ {\red est$<$e$>$}};
\node[font=\footnotesize,anchor=north] (l2) at ([xshift=1.5em,yshift=-1em]t3.south) {(b) 合并样例};
\node[font=\scriptsize,anchor=north east] (s1) at ([yshift=0.1em]n1.north west) {样例1:};
\node[font=\scriptsize,anchor=north east] (s1) at ([yshift=0.1em]t1.north west) {样例2:};
\node[font=\footnotesize,anchor=north] (l2) at ([xshift=2em,yshift=-1em]t3.south) {(b) 合并样例};
\draw[->,thick](n1.east) -- (n2.west);
\draw[->,thick](n2.east) -- (n3.west);
......
Chapter13/chapter13.tex
......@@ -35,7 +35,7 @@
\vspace{0.5em}
\end{itemize}
\parinterval 本章将就这些问题展开讨论，内容会覆盖开放词表、正则化、对抗样本训练、最小风险训练、知识蒸馏等多个主题。需要注意的是，神经机器翻译模型训练涉及的内容十分广泛。很多情况下，模型训练问题会和建模问题强相关。因此，本章的内容主要集中在相对独立的模型训练问题上。在后续章节中，仍然会有模型训练方面的介绍，其主要针对机器翻译的特定主题，如极深神经网络训练、无指导训练等。
\parinterval 本章将就这些问题展开讨论，内容会覆盖开放词表、正则化、对抗样本训练、最小风险训练、知识蒸馏等多个主题。需要注意的是，神经机器翻译模型训练涉及的内容十分广泛。很多情况下，模型训练问题会和建模问题强相关。因此，本章的内容主要集中在相对独立的基础模型训练问题上。在后续章节中，仍然会有模型训练方面的介绍，其主要针对机器翻译的特定主题，如深层神经网络训练、无指导训练等。
%----------------------------------------------------------------------------------------
% NEW SECTION
......@@ -44,7 +44,7 @@
\sectionnewpage
\section{开放词表}
\parinterval 对于神经机器翻译而言，我们通常希望使用更大的词表完成模型训练。因为大词表可以覆盖更多的语言现象，使模型对不同的语言现象有更强的区分能力。但是，人类的语言表达方式是十分多样的，这也体现在单词的构成上，甚至我们都无法想象数据中存在的不同单词的数量。比如，在WMT、CCMT等评测数据上，英语词表大小都会在100万以上。当然，这里面也包括很多的数字和字母的混合，还有一些组合词。不过，如果不加限制，机器翻译所面对的词表将会很“大”。这也会导致模型参数量变大，模型训练变得极为困难。更严重的问题是，测试数据中的一些单词根本就没有在训练数据中出现过，这时会出现未登录词翻译问题（或OOV 问题），即系统无法对未见单词进行翻译。在神经机器翻译中，通常会考虑使用更小的翻译单元来缓解以上问题，因为小颗粒度的单元可以有效缓解数据稀疏问题。
\parinterval 对于神经机器翻译而言，研究人员通常希望使用更大的词表完成模型训练。因为大词表可以覆盖更多的语言现象，使模型对不同的语言现象有更强的区分能力。但是，人类的语言表达方式是十分多样的，这也体现在单词的构成上，甚至人们都无法想象数据中存在的不同单词的数量。比如，在WMT、CCMT等评测数据上，英语词表大小都会在100万以上。如果不加限制，机器翻译的词表将会很“大”。这也会导致模型参数量变大，模型训练变得极为困难。更严重的问题是，测试数据中的一些单词根本就没有在训练数据中出现过，这时会出现未登录词翻译问题（即OOV问题），即系统无法对未见单词进行翻译。在神经机器翻译中，通常会考虑使用更小的翻译单元来缓解数据稀疏问题。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -62,7 +62,7 @@
\vspace{0.5em}
\end{itemize}
\parinterval 理想情况下，机器翻译应该是一个{\small\bfnew{开放词表}}\index{开放词表}（Open Vocabulary）\index{Open Vocabulary}的翻译任务。也就是，无论测试数据中包含什么样的词，机器翻译系统都应该能够正常翻译。但是，现实的情况是即使不断扩充词表，也不可能覆盖所有可能的单词。这个问题在使用受限词表时会更加严重，因为低频词和未见过的词都会被看作未登录词。这时会将这些单词用<UNK>代替。通常，数据中<UNK>的数量会直接影响翻译性能，过多的<UNK>会造成欠翻译、结构混乱等问题。因此神经机器翻译需要额外的机制解决大词表和未登录词问题。
\parinterval 理想情况下，机器翻译应该是一个{\small\bfnew{开放词表}}\index{开放词表}（Open Vocabulary）\index{Open Vocabulary}的翻译任务。也就是，无论测试数据中包含什么样的词，机器翻译系统都应该能够正常翻译。但是，现实的情况是即使不断扩充词表，也不可能覆盖所有可能的单词。这个问题在使用受限词表时会更加严重，因为低频词和未见过的词都会被看作未登录词。这时会将这些单词用符号<UNK>代替。通常，数据中<UNK>的数量会直接影响翻译性能，过多的<UNK>会造成欠翻译、结构混乱等问题。因此神经机器翻译需要额外的机制解决大词表和未登录词问题。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -70,13 +70,13 @@
\subsection{子词}
\parinterval 一种解决开放词表翻译问题的方法是改造输出层结构\upcite{garcia-martinez2016factored,DBLP:conf/acl/JeanCMB15}，比如，替换原始的Softmax层，用更加高效的神经网络结构进行超大规模词表上的预测。不过，模型结构和训练方法的调整使得系统开发与调试的工作量增加，并且这类方法仍然无法解决未登录词问题，因此在实用系统中并不常用。
\parinterval 一种解决开放词表翻译问题的思路是改造输出层结构\upcite{garcia-martinez2016factored,DBLP:conf/acl/JeanCMB15}，比如，替换原始的Softmax层，用更加高效的神经网络结构进行超大规模词表上的预测。不过，模型结构和训练方法的调整使得系统开发与调试的工作量增加，并且这类方法仍然无法解决未登录词问题，因此在实用系统中并不常用。
\parinterval 另一种思路是不改变机器翻译系统，而是从数据处理的角度来缓解未登录词问题。既然使用单词会带来数据稀疏问题，那么自然会想到使用更小的单元。比如，把字符作为最小的翻译单元 \footnote{汉语里的字符可以被看作是汉字。} \ \dash \ 也就是基于字符的翻译模型\upcite{DBLP:journals/tacl/LeeCH17}。以英语为例，只需要构造一个包含26个英语字母、数字和一些特殊符号的字符表，便可以表示所有的单词。
\parinterval 另一种思路是不改变机器翻译系统，而是从数据处理的角度来缓解未登录词问题。既然使用单词会带来数据稀疏问题，那么自然会想到使用更小的单元，通过更小的单元的多种排列组合来表示更多的单词。比如，把字符作为最小的翻译单元 \footnote{汉语里的字符可以被看作是汉字。} \ \dash \ 也就是基于字符的翻译模型\upcite{DBLP:journals/tacl/LeeCH17}。以英语为例，只需要构造一个包含26个英语字母、数字和一些特殊符号的字符表，便可以表示所有的单词。
\parinterval 但是字符级翻译也面临着新的问题\ \dash\ 使用字符增加了系统捕捉不同语言单元之间搭配的难度。假设平均一个单词由5个字符组成，系统所处理的序列长度便增大5倍。这使得具有独立意义的不同语言单元需要跨越更远的距离才能产生联系。此外，基于字符的方法也破坏了单词中天然存在的构词规律，或者说破坏了单词内字符的局部依赖。比如，英语单词“telephone”中的“tele”和“phone”都是有具体意义的词缀，但是如果把它们打散为字符就失去了这些含义。
\parinterval 那么有没有一种方式能够兼顾基于单词和基于字符方法的优点呢？常用的手段包括两种，一种是采用字词融合的方式构建词表，将未知单词转换为字符的序列并通过特殊的标记将其与普通的单词区分开来\upcite{luong2016acl_hybrid}。而另一种方式是将单词切分为{\small\bfnew{子词}}\index{子词}（Sub-word）\index{Sub-word}，它是介于单词和字符中间的一种语言单元表示形式。比如，将英语单词“doing”切分为“do”+“ing”。对于形态学丰富的语言来说，子词体现了一种具有独立意义的构词基本单元。如图\ref{fig:13-2}，子词“do”和“new”在可以用于组成其他不同形态的单词。
\parinterval 那么有没有一种方式能够兼顾基于单词和基于字符方法的优点呢？常用的手段包括两种，一种是采用字词融合的方式构建词表，将未知单词转换为字符的序列并通过特殊的标记将其与普通的单词区分开来\upcite{luong2016acl_hybrid}。而另一种方式是将单词切分为{\small\bfnew{子词}}\index{子词}（Sub-word）\index{Sub-word}，它是介于单词和字符中间的一种语言单元表示形式。比如，将英语单词“doing”切分为“do”+“ing”。对于形态学丰富的语言来说，子词体现了一种具有独立意义的构词基本单元。如图\ref{fig:13-2}，子词“do”和“new”可以用于组成其他不同形态的单词。
%----------------------------------------------
\begin{figure}[htp]
......@@ -87,7 +87,7 @@
\end{figure}
%----------------------------------------------
\parinterval 在极端一些的情况下，子词仍然可以包含所有的字母和数字。这样，理论上，所有的单词都可以用子词进行组装。当然，理想的状况是：在子词词表不太大的前提下，使用尽可能少的子词单元拼装出每个单词。在神经机器翻译中，基于子词的切分是很常用的数据处理方法，称为子词切分。主要包括三个步骤：
\parinterval 在一些极端的情况下，子词仍然可以包含所有的字母和数字。这样，理论上，所有的单词都可以用子词进行组装。当然，理想的状况是：在子词词表不太大的前提下，使用尽可能少的子词单元拼装出每个单词。在神经机器翻译中，基于子词的切分是很常用的数据处理方法，称为子词切分。主要包括三个步骤：
\begin{itemize}
\vspace{0.5em}
......@@ -95,7 +95,7 @@
\vspace{0.5em}
\item 构建符号合并表；
\vspace{0.5em}
\item 通过合并表，按字符合并为子词。
\item 根据合并表，将字符合并为子词。
\vspace{0.5em}
\end{itemize}
......@@ -107,15 +107,15 @@
\subsection{双字节编码}
\parinterval 字节对编码或双字节编码（BPE）是一种常用的子词词表构建方法。BPE方法最早用于数据压缩，该方法将数据中常见的连续字符串替换为一个不存在的字符，之后通过构建一个替换关系的对应表，对压缩后的数据进行还原\upcite{Gage1994ANA}。机器翻译借用了这种思想，把子词切分看作是学习对自然语言句子进行压缩编码表示的问题\upcite{DBLP:conf/acl/SennrichHB16a}。其目的是，保证编码后的结果（即子词切分）占用的字节尽可能少。这样，子词单元会尽可能被不同单词复用，同时又不会因为使用过小的单元造成子词切分序列过长。
\parinterval 字节对编码或双字节编码（BPE）是一种常用的子词词表构建方法。BPE方法最早用于数据压缩，该方法将数据中常见的连续字符串替换为一个不存在的字符，之后通过构建一个替换关系的对应表，对压缩后的数据进行还原\upcite{Gage1994ANA}。机器翻译借用了这种思想，把子词切分看作是学习对自然语言句子进行压缩编码表示的问题\upcite{DBLP:conf/acl/SennrichHB16a}。其目的是，保证编码（即子词切分）后的结果占用的字节尽可能少。这样，子词单元会尽可能被不同单词复用，同时又不会因为使用过小的单元造成子词切分后的序列过长。
\parinterval 图\ref{fig:13-3}给出了BPE算法执行的实例。其中预先设定的合并表的大小为10。在得到了符号合并表后，便需要对用字符表示的单词进行合并，得到以子词形式表示的文本。首先，将单词切分为以字符表示的符号序列，并在尾部加上终结符（为了便于理解图\ref{fig:13-3}中没有包含终结符）。然后按照符号合并表的顺序依次遍历，如果存在相同的2-gram符号组合，则对其进行合并，直至遍历结束。图\ref{fig:13-4}给出了一个使用字符合并表对单词进行子词切分的实例。红色单元为每次合并后得到的新符号，直至无法合并，或遍历结束，得到最终的合并结果。其中每一个单元为一个子词。
\parinterval 使用BPE算法进行子词切分包含两个步骤。首先，通过统计的方法构造符号合并表，具体的方式为：先对分过词的文本进行统计，得到词表和词频，同时将词表中的单词分割为字符表示；其次统计词表中所有出现的二元组的频次，选择当前频次最高的二元组加入符号合并表，并将所有词表中出现的该二元组合并为一个单元；不断地重复上述过程，直到合并表的大小达到预先设定的大小，或者无法继续合并。图\ref{fig:13-4}给出了一个使用字符合并表对单词进行子词切分的实例。红色单元为每次合并后得到的新符号，直至无法合并，或遍历结束，得到最终的合并结果。其中每一个单元为一个子词。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter13/Figures/figure-bpe}
\caption{BPE 算法运行实例}
\caption{BPE算法中符号合并表的生成过程}
\label{fig:13-3}
\end{figure}
%----------------------------------------------
......@@ -129,11 +129,11 @@
\end{figure}
%----------------------------------------------
\parinterval 使用BPE方法后，翻译模型的输出也是子词序列，因此需要对最终得到的翻译结果进行子词还原，即将子词形式表达的单元重新组合为原本的单词。这一步操作也十分简单，只需要不断的将每个子词向后合并，直至遇到表示单词边界的结束符，便得到了一个完整的单词。
\parinterval 使用BPE方法后，翻译模型的输出也是子词序列，因此需要对最终得到的翻译结果进行子词还原，即将子词形式表达的单元重新组合为原本的单词。这一步操作也十分简单，只需要不断的将每个子词向后合并，直至遇到表示单词边界的终结符，便得到了一个完整的单词。
\parinterval 使用BPE方法的策略有很多。不仅可以单独对源语言和目标语言句子进行子词的切分，也可以联合两种语言，共同进行子词切分，被称作{\small\bfnew{双字节联合编码}}\index{双字节联合编码}（Joint-BPE\index{Joint-BPE}）\upcite{DBLP:conf/acl/SennrichHB16a}。 相比于单语BPE，Joint-BPE可以增加两种语言子词切分的一致性。对于相似语系中的语言，如英语和德语，常使用Joint-BPE 的方法联合构建词表。而对于汉语和英语这些差异比较大的语种，则需要独立的进行子词切分。
\parinterval 使用BPE方法的策略有很多。不仅可以单独对源语言和目标语言句子进行子词的切分，也可以联合两种语言，共同进行子词切分，被称作{\small\bfnew{双字节联合编码}}\index{双字节联合编码}（Joint-BPE\index{Joint-BPE}）\upcite{DBLP:conf/acl/SennrichHB16a}。 相比于单语BPE，Joint-BPE可以增加两种语言子词切分的一致性。对于相似语系中的语言，如英语和德语，常使用Joint-BPE 的方法联合构建词表。而对于汉语和英语这些差异比较大的语种，则需要独立地进行子词切分。
\parinterval BPE还有很多变种方法。比如，可以设计更合理的符号合并优先级。这种方法的出发点在于，在不考虑优先级的情况下，在对一个单词用同一个合并表切分子词时，可能存在多种结果。如hello，可以被切分为“hell”和“o”，也可以分割为“h” 和“ello”。 这种切分的多样性可以用来提高神经机器翻译系统的健壮性\upcite{DBLP:conf/acl/Kudo18}。此外，尽管BPE被命名为字节对编码，但是在实践中该方法一般处理的是Unicode编码，而不是字节。因此在预训练模型GPT2 中，也探索了字节级别的BPE，这种方法在机器翻译、自动问答等任务中取得了很好的效果\upcite{radford2019language}。
\parinterval BPE还有很多变种方法。比如，可以设计更合理的符号合并优先级。这种方法的出发点在于，在不考虑优先级的情况下，在对一个单词用同一个合并表切分子词时，可能存在多种结果。如hello，可以被切分为“hell”和“o”，也可以被切分为“h” 和“ello”。 这种切分方式的多样性可以用来提高神经机器翻译系统的健壮性\upcite{DBLP:conf/acl/Kudo18}。此外，尽管BPE也被命名为双字节编码，但是在实践中该方法一般处理的是Unicode编码，而不是字节。相应的，在预训练模型GPT2 中也探索了字节级别的BPE，这种方法在机器翻译、自动问答等任务中取得了很好的效果\upcite{radford2019language}。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -164,7 +164,7 @@
\sectionnewpage
\section{正则化}\label{subsection-13.2}
\parinterval 正则化是机器学习中的经典技术，通常用于缓解过拟合问题。正则化的概念源自线性代数和代数几何。在实践中，它更多的是指对{\small\bfnew{反问题}}\index{反问题}（The Inverse Problem）\index{Inverse Problem}的一种求解方式。假设输入$x$和输出$y$之间存在一种映射$f$
\parinterval 正则化是机器学习中的经典技术，通常用于缓解过拟合问题。正则化的概念源自线性代数和代数几何。在实践中，它更多的是指对{\small\bfnew{反问题}}\index{反问题}（The Inverse Problem）\index{Inverse Problem}的一种求解方式。假设输入$x$和输出$y$之间存在一种映射$f$：
\begin{eqnarray}
y &=& f(x)
\label{eq:13-1}
......@@ -172,9 +172,7 @@ y &=& f(x)
\noindent 反问题是指：当观测到$y$时，能否求出$x$。反问题对应了很多实际问题，比如，可以把$y$看作经过美化的图片，$x$看作原始的图片，反问题就对应了图片还原。机器翻译的训练也是一种反问题，因为可以把$y$看作是正确的译文，$x$看作是输入句子或者模型参数\footnote{在训练中，如果把源语言句子看作是不变的量，这时函数$f(\cdot)$的输入只有模型参数。}。
\parinterval 理想的情况下，我们希望反问题的解是{\small\bfnew{适定的}}\index{适定的}（Well-posed）\index{Well-posed}。所谓适定解，需要满足三个条件：解是存在的、解是唯一的、解是稳定的（即$y$微小的变化会导致$x$微小的变化，也被称作解连续）。所有不存在唯一稳定解的问题都被称作{\small\bfnew{不适定问题}}\index{不适定问题}（Ill-posed Problem）\index{Ill-posed Problem}。对于机器学习问题，解的存在性比较容易理解。解的唯一性大多由问题决定。比如，如果把描述问题的函数$f(\cdot)$看作一个$n\times n$矩阵$\mathbi{A}$，$x$和$y$都看作是$n$维向量。那么$x$不唯一的原因在于$\mathbi{A}$不满秩（非奇异矩阵）。不过，存在性和唯一性并不会对机器学习方法造成太大困扰，因为在实践中往往会找到近似的解。
\parinterval 但是，解的稳定性却给神经机器翻译带来了很大的挑战。因为神经机器翻译模型非常复杂，里面存在大量的矩阵乘法和非线性变换。这导致$f(\cdot)$往往是不稳定的，也就是说，神经机器翻译中输出$y$的微小变化会导致输入$x$的巨大变化。比如，在系统研发中经常会发现，即使训练样本发生很小的变化，模型训练得到的参数都会有非常明显的区别。不仅如此，在神经机器翻译模型中，稳定性训练还面临两方面问题：
\parinterval 理想的情况下，研究人员希望反问题的解是{\small\bfnew{适定的}}\index{适定的}（Well-posed）\index{Well-posed}。所谓适定解，需要满足三个条件：解是存在的、解是唯一的、解是稳定的（即$y$微小的变化会导致$x$微小的变化，也被称作解连续）。所有不存在唯一稳定解的问题都被称作{\small\bfnew{不适定问题}}\index{不适定问题}（Ill-posed Problem）\index{Ill-posed Problem}。对于机器学习问题，解的存在性比较容易理解。解的唯一性大多由问题决定。比如，如果把描述问题的函数$f(\cdot)$看作一个$n\times n$矩阵$\mathbi{A}$，$x$和$y$都看作是$n$维向量。那么$x$不唯一的原因在于$\mathbi{A}$不满秩（非奇异矩阵）。不过，存在性和唯一性并不会对机器学习方法造成太大困扰，因为在实践中往往会找到近似的解。但是，解的稳定性却给神经机器翻译带来了很大的挑战。因为神经机器翻译模型非常复杂，里面存在大量的矩阵乘法和非线性变换。这导致$f(\cdot)$往往是不稳定的，也就是说，神经机器翻译中输出$y$的微小变化会导致输入$x$的巨大变化。比如，在系统研发中经常会发现，即使训练样本发生很小的变化，模型训练得到的参数都会有非常明显的区别。不仅如此，在神经机器翻译模型中，稳定性训练还面临两方面问题：
\begin{itemize}
\vspace{0.5em}
......@@ -197,13 +195,13 @@ y &=& f(x)
\parinterval 正则化的一种实现是在训练目标中引入一个正则项。在神经机器翻译中，引入正则项的训练目标为：
\begin{eqnarray}
\widehat{\mathbi{w}} &=& \argmax_{\mathbi{w}}L(\mathbi{w}) + \lambda R(\mathbi{w})
\widehat{\mathbi{w}} &=& \argmin_{\mathbi{w}}Loss(\mathbi{w}) + \lambda R(\mathbi{w})
\label{eq:13-2}
\end{eqnarray}
\noindent 其中，$\mathbi{w}$是模型参数，$L(\mathbi{w})$是损失函数，$R(\mathbi{w})$是正则项，$\lambda$是正则项的系数，用于控制正则化对训练影响的程度。$R(\mathbi{w})$通常也可以被看作是一种先验，因为在数据不充分且存在噪声的情况下，可以根据一些先验知识让模型偏向正确的方向一些，而不是一味地根据受噪声影响的不准确的$L(\mathbi{w})$进行优化。相应的，引入正则化后的模型可以获得更好的{\small\bfnew{泛化}}\index{泛化}（Generalization）\index{Generalization}能力，即模型在新的未见数据上表现会更好。
\noindent 其中，$\mathbi{w}$是模型参数，$Loss(\mathbi{w})$是损失函数，$R(\mathbi{w})$是正则项，$\lambda$是正则项的系数，用于控制正则化对训练影响的程度。$R(\mathbi{w})$通常也可以被看作是一种先验，因为在数据不充分且存在噪声的情况下，可以根据一些先验知识让模型偏向正确的方向一些，而不是一味地根据受噪声影响的$Loss(\mathbi{w})$进行优化。相应的，引入正则化后的模型可以获得更好的{\small\bfnew{泛化}}\index{泛化}（Generalization）\index{Generalization}能力，即模型在新的未见数据上表现会更好。
\parinterval 实践中已经证明，正则化方法有助于使得像神经机器翻译模型这样复杂模型获得稳定的模型参数。甚至有些情况下，如果不引入正则化，训练得到的翻译模型根本无法使用。此外，正则化方法不仅可以用于提高模型的泛化能力，也可以作为干预模型学习的一种手段，比如，可以将一些先验知识作为正则项约束机器翻译模型的学习。类似的手段在本书后续的内容中也会得到使用。
\parinterval 实践中已经证明，正则化方法有助于使得像神经机器翻译模型这样复杂模型获得稳定的模型参数。甚至有些情况下，如果不引入正则化，训练得到的翻译模型根本无法使用。此外，正则化方法不仅可以用于提高模型的泛化能力，也可以作为干预模型学习的一种手段，比如，可以将一些先验知识作为正则项约束机器翻译模型的学习。类似的手段在本书后续的内容中也会被使用。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -211,7 +209,7 @@ y &=& f(x)
\subsection{L1/L2正则化}
\parinterval L1/L2正则化是常用的正则化方法，虽然这种方法并不仅针对机器翻译模型。L1/L2正则化分别对应正则项是L1和L2范数的情况。具体来说，L1正则化是指：
\parinterval L1/L2正则化是常用的正则化方法，虽然这种方法并不仅针对机器翻译模型。L1/L2正则化分别对应正则项是$l_1$和$l_2$范数的情况。具体来说，L1正则化是指：
\begin{eqnarray}
R(\mathbi{w}) & = & {\Vert{\mathbi{w}}\Vert}_1 \\
& = &\sum_{w_i}|w_i| \nonumber
......@@ -225,7 +223,7 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\label{eq:13-4}
\end{eqnarray}
\parinterval {\chapternine}已经介绍了L1和L2正则化方法，这里做一些展开。从几何的角度看，L1和L2正则项都是有物理意义的。二者都可以被看作是空间上的一个区域，比如，在二维平面上，L1范数表示一个以0点为中心的矩形，L2范数表示一个以0点为中心的圆。此时，$L(\mathbi{w})$和$R(\mathbi{w})$叠加在一起构成了一个新的区域，优化问题可以被看作是在这个新的区域上进行优化。由于L1和L2正则项都是在0点（坐标原点）附近形成的区域，因此优化的过程可以确保参数不会偏离0点太多。也就是说，L1和L2正则项引入了一个先验：模型的解不应该离0点太远。而L1和L2正则项实际上是在度量这个距离。
\parinterval {\chapternine}已经介绍了L1和L2正则化方法，这里做一些展开。从几何的角度看，L1和L2正则项都是有物理意义的。二者都可以被看作是空间上的一个区域，比如，在二维平面上，$l_1$范数表示一个以0点为中心的菱形，$l_2$范数表示一个以0点为中心的圆。此时，$L(\mathbi{w})$和$R(\mathbi{w})$叠加在一起构成了一个新的区域，优化问题可以被看作是在这个新的区域上进行优化。由于L1和L2正则项都是在0点（坐标原点）附近形成的区域，因此优化的过程可以确保参数不会偏离0点太多。也就是说，L1和L2正则项引入了一个先验：模型的解不应该离0点太远。而L1和L2正则项实际上是在度量这个距离。
\parinterval 那为什么要用L1和L2正则项惩罚离0点远的解呢？这还要从模型复杂度谈起。实际上，对于神经机器翻译这样的模型来说，模型的容量是足够的。所谓容量可以被简单的理解为独立参数的个数 \footnote{另一种定义是把容量看作神经网络所能表示的假设空间大小\upcite{DBLP:journals/nature/LeCunBH15}，也就是神经网络能表示的不同函数所构成的空间。}。也就是说，理论上存在一种模型可以完美的描述问题。但是，从目标函数拟合的角度来看，如果一个模型可以拟合很复杂的目标函数，那模型所表示的函数形态也会很复杂。这往往体现在模型中参数的值“偏大”。比如，用一个多项式函数拟合一些空间中的点，如果希望拟合得很好，各个项的系数往往是非零的。而且为了对每个点进行拟合，通常需要多项式中的某些项具有较大的系数，以期望函数在局部有较大的斜率。显然，这样的模型是很复杂的。模型的复杂度可以用函数中参数（比如多项式中各项的系数）的“值”进行度量，这也体现在模型参数的范数上。
......@@ -245,7 +243,7 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\label{eq:13-5}
\end{eqnarray}
\noindent 这里，$\alpha$表示一个系数，用于控制分布$\mathbi{q}$的重要性。
\noindent 这里，$\alpha$表示一个系数，用于控制分布$\mathbi{q}$的重要性，$\mathbi{y}_{j}^{ls}$表示使用标签平滑后的学习目标。
\parinterval 标签平滑实际上定义了一种“软”标签，使得所有标签都可以分到一些概率。一方面可以缓解数据中噪声的影响，另一方面目标分布会更合理（显然，真实的分布不应该是One-hot分布）。图\ref{fig:13-6}展示了标签平滑前后的损失函数计算结果的对比。
......@@ -266,7 +264,7 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\subsection{Dropout}
\parinterval 神经机器翻译模型是一种典型的多层神经网络模型。每一层都包含若干神经元，负责接收前一层所有神经元的输出，之后进行诸如乘法、加法等变换操作，并有选择地使用非线性的激活函数，最终得到当前层每个神经元的输出。从模型最终预测的角度看，每个神经元都在参与最终的预测。理想的情况下，我们希望每个神经元都能相互独立的做出“贡献”。这样的模型会更加健壮，因为即使一部分神经元不能正常工作，其它神经元仍然可以独立做出合理的预测。但是，随着每一层神经元数量的增加以及网络结构的复杂化，神经元之间会出现{\small\bfnew{相互适应}}\index{相互适应}（Co-Adaptation）\index{Co-Adaptation}的现象。所谓相互适应是指，一个神经元对输出的贡献与同一层其它神经元的行为是相关的，也就是说这个神经元已经适应到它周围的“环境”中。
\parinterval 神经机器翻译模型是一种典型的多层神经网络模型。每一层都包含若干神经元，负责接收前一层所有神经元的输出，之后进行诸如乘法、加法等变换操作，并有选择地使用非线性的激活函数，最终得到当前层每个神经元的输出。从模型最终预测的角度看，每个神经元都在参与最终的预测。理想的情况下，研究人员希望每个神经元都能相互独立的做出“贡献”。这样的模型会更加健壮，因为即使一部分神经元不能正常工作，其它神经元仍然可以独立做出合理的预测。但是，随着每一层神经元数量的增加以及网络结构的复杂化，神经元之间会出现{\small\bfnew{相互适应}}\index{相互适应}（Co-Adaptation）\index{Co-Adaptation}的现象。所谓相互适应是指，一个神经元对输出的贡献与同一层其它神经元的行为是相关的，也就是说这个神经元已经适应到它周围的“环境”中。
\parinterval 相互适应的好处在于神经网络可以处理更加复杂的问题，因为联合使用两个神经元要比单独使用每个神经元的表示能力强。这也类似于传统机器学习任务中往往会设计一些高阶特征，比如自然语言序列标注中对2-gram和3-gram的使用。不过另一方面，相互适应会导致模型变得更加“脆弱”。因为相互适应的神经元可以更好的描述训练数据中的现象，但是在测试数据上，由于很多现象是未见的，细微的扰动会导致神经元无法适应。具体体现出来就是过拟合问题。
......@@ -281,7 +279,7 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\end{figure}
%----------------------------------------------
\parinterval 具体实现时，可以设置一个参数$p \in (0,1)$。在每次参数更新所使用的前向和反向计算中，每个神经元都以概率$p$停止工作。相当于每层神经网络会有以$p$为比例的神经元被“屏蔽”掉。每一次参数更新中会随机屏蔽不同的神经元，图\ref{fig:13-8}给出了Dropout方法和传统方法计算方式的对比。其中，$x_{i}^{l}$代表第$l$层神经网络的第$i$个输入，$w_{i}^{l}$为输入所对应的权重，$b^{l}$表示第$l$层神经网络输入的偏置，$z_{i}^{l+1}$表示第$l$层神经网络的线性运算的结果，$f(\cdot)$表示激活函数，$r_{j}^{l}$的值服从于参数为$1-p$的伯努利分布。
\parinterval 具体实现时，可以设置一个参数$p \in (0,1)$。在每次参数更新所使用的前向和反向计算中，每个神经元都以概率$p$停止工作。相当于每层神经网络会有以$p$为概率的神经元被“屏蔽”掉。每一次参数更新中会随机屏蔽不同的神经元，图\ref{fig:13-8}给出了Dropout方法和传统方法计算方式的对比。其中，$x_{i}^{l}$代表第$l$层神经网络的第$i$个输入，$w_{i}^{l}$为输入所对应的权重，$b^{l}$表示第$l$层神经网络输入的偏置，$z_{i}^{l+1}$表示第$l$层神经网络的线性运算的结果，$f(\cdot)$表示激活函数，$r_{i}^{l}$的值服从于参数为$1-p$的伯努利分布。
%----------------------------------------------
\begin{figure}[htp]
......@@ -294,7 +292,7 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\parinterval 对于新的样本，可以使用Dropout训练之后的模型对其进行推断，但是每个神经元的输出要乘以$1-p$，以保证每层神经元输出的期望和训练时是一样的。另一种常用的做法是，在训练时对每个神经元的输出乘以$\frac{1}{1-p}$，然后在推断时神经网络可以不经过任何调整就直接使用。
\parinterval Dropout方法的另一种解释是，在训练中屏蔽掉一些神经元相当于从原始的神经网络中抽取出了一个子网络。这样，每次训练都在一个随机生成的子网络上进行，而不同子网络之间的参数是共享的。在推断时，则把所有的子网络集成到一起。这种思想也有一些{\small\bfnew{集成学习}}\index{集成学习}（Ensemble Learning）\index{Ensemble Learning}的味道。只不过Dropout中子模型（或子网络）是在指数级空间中采样出来的。由于Dropout可以很好的缓解复杂神经模型的过拟合问题，因此也成为了大多数神经机器翻译系统的标配。
\parinterval Dropout方法的另一种解释是，在训练中屏蔽掉一些神经元相当于从原始的神经网络中抽取出了一个子网络。这样，每次训练都在一个随机生成的子网络上进行，而不同子网络之间的参数是共享的。在推断时，则把所有的子网络集成到一起。这种思想也有一些{\small\bfnew{集成学习}}\index{集成学习}（Ensemble Learning）\index{Ensemble Learning}的味道，只不过Dropout中子模型（或子网络）是在指数级空间中采样出来的。由于Dropout可以很好的缓解复杂神经网络模型的过拟合问题，因此也成为了大多数神经机器翻译系统的标配。
\parinterval 随着网络层数的增多，相互适应也会出现在不同层之间，甚至会出现在多头注意力机制的不同头之间。因此，Dropout方法也可以用于对模型局部结构的屏蔽，比如，对多层神经网络中的层进行屏蔽，即Layer Dropout。 特别是对于深层神经网络，Layer Dropout 也是一种有效的防止过拟合的方法。关于Layer Dropout的内容在{\chapterfifteen}还会有详细讨论。
......@@ -306,7 +304,7 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\section{对抗样本训练}
\label{sec:adversarial-examples}
\parinterval 同其它基于神经网络的方法一样，提高{\small\bfnew{健壮性}}\index{健壮性}（Robustness）\index{Robustness}也是神经机器翻译研发中需要关注的。比如，大容量模型可以很好的拟合训练数据，但是当测试样本与训练样本差异较大时，会导致很糟糕的翻译结果\upcite{JMLR:v15:srivastava14a,DBLP:conf/amta/MullerRS20}。另一方面，实践中也发现，有些情况下即使输入中有微小的扰动，神经网络模型的输出也会产生巨大变化。或者说，神经网络模型在输入样本上容易受到{\small\bfnew{攻击}}\index{攻击}（Attack）\index{Attack}\upcite{DBLP:conf/sp/Carlini017,DBLP:conf/cvpr/Moosavi-Dezfooli16,DBLP:conf/acl/ChengJM19}。表\ref{tab:13-1}展示了一个神经机器翻译系统的翻译结果，可以看到，把输入句子中的单词“jumped”换成“sunk”会得到完全不同的译文。这时神经机器翻译系统就存在健壮性问题。
\parinterval 同其它基于神经网络的方法一样，提高{\small\bfnew{健壮性}}\index{健壮性}（Robustness）\index{Robustness}也是神经机器翻译研发中需要关注的。比如，大容量模型可以很好地拟合训练数据，但是当测试样本与训练样本差异较大时，会导致很糟糕的翻译结果\upcite{JMLR:v15:srivastava14a,DBLP:conf/amta/MullerRS20}。另一方面，实践中也发现，有些情况下即使输入中有微小的扰动，神经网络模型的输出也会产生巨大变化。或者说，神经网络模型在输入样本上容易受到攻击（Attack）\upcite{DBLP:conf/sp/Carlini017,DBLP:conf/cvpr/Moosavi-Dezfooli16,DBLP:conf/acl/ChengJM19}。表\ref{tab:13-1}展示了一个神经机器翻译系统的翻译结果，可以看到，把输入句子中的单词“jumped”换成“sunk”会得到完全不同的译文。这时神经机器翻译系统就存在健壮性问题。
%----------------------------------------------
\begin{table}[htp]{
......@@ -347,9 +345,9 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\noindent 其中，$(\mathbi{x}',\mathbi{y})$为输入中含有扰动的对抗样本，函数$\funp{C}(\cdot)$为模型。公式\eqref{eq:13-8}中$\Psi(\mathbi{x},\mathbi{x}')$表示扰动后的输入$\mathbi{x}'$和原输入$\mathbi{x}$之间的距离，$\varepsilon$表示扰动的受限范围。当模型对包含噪声的数据容易给出较差的结果时，往往意味着该模型的抗干扰能力差，因此可以利用对抗样本检测现有模型的健壮性\upcite{DBLP:conf/emnlp/JiaL17}。同时，采用类似数据增强的方式将对抗样本混合至训练数据中，能够使模型得到稳定的预测能力，这种方式也被称为对抗训练\upcite{DBLP:journals/corr/GoodfellowSS14,DBLP:conf/emnlp/BekoulisDDD18,DBLP:conf/naacl/YasunagaKR18}。
\parinterval 通过对抗样本训练来提升模型健壮性的首要问题是：如何生成对抗样本。通过当前模型$\funp{C}$和样本$(\mathbi{x},\mathbi{y})$，生成对抗样本的过程被称为{\small\bfnew{对抗攻击}}\index{对抗攻击}（Adversarial Attack）\index{Adversarial Attack}。对抗攻击可以被分为黑盒攻击和白盒攻击。在白盒攻击中，攻击算法可以访问模型的完整信息，包括模型结构、网络参数、损失函数、激活函数、输入和输出数据等。黑盒攻击通常依赖启发式方法来生成对抗样本\upcite{DBLP:conf/emnlp/JiaL17}，由于这种攻击方式不需要知道神经网络的详细信息，仅仅通过访问模型的输入和输出就可以达到攻击的目的。并且在黑盒攻击中，由于神经网络其本身便是一个黑盒模型，因此在神经网络的相关应用中黑盒攻击方法更加实用。
\parinterval 通过对抗样本训练来提升模型健壮性的首要问题是：如何生成对抗样本。通过当前模型$\funp{C}$和样本$(\mathbi{x},\mathbi{y})$，生成对抗样本的过程被称为{\small\bfnew{对抗攻击}}\index{对抗攻击}（Adversarial Attack）\index{Adversarial Attack}。对抗攻击可以被分为黑盒攻击和白盒攻击。在白盒攻击中，攻击算法可以访问模型的完整信息，包括模型结构、网络参数、损失函数、激活函数、输入和输出数据等。黑盒攻击通常依赖启发式方法来生成对抗样本\upcite{DBLP:conf/emnlp/JiaL17}，由于这种攻击方式不需要知道神经网络的详细信息，仅仅通过访问模型的输入和输出就可以达到攻击的目的。并且由于神经网络其本身便是一个黑盒模型，因此在神经网络的相关应用中黑盒攻击方法更加实用。
\parinterval 在神经机器翻译中，输入所包含的细小的扰动会使模型变得脆弱\upcite{DBLP:conf/iclr/BelinkovB18}。但是，图像中的对抗攻击方法难以直接应用于自然语言处理任务，因为图像和文本数据之间存在着一定的差异。对计算机而言，以像素值等表示的图像数据本身就是连续的\upcite{DBLP:conf/naacl/MichelLNP19}，而文本中的一个个单词本身离散的。简单替换这些离散的单词，可能会生成语法错误或者语义错误的句子。而且，简单替换单词产生的扰动过大，模型很容易判别。即使对词嵌入等连续表示的部分进行扰动，也会产生无法与词嵌入空间中的任何词匹配的向量\upcite{Gong2018AdversarialTW}。针对这些问题，下面着重介绍神经机器翻译任务中如何有效生成、使用对抗样本。
\parinterval 在神经机器翻译中，训练数据中含有的细微扰动会使得模型比较脆弱\upcite{DBLP:conf/iclr/BelinkovB18}。研究人员希望借鉴图像任务中的一些对抗攻击方法，并将其应用于自然语言处理任务中。然而，对计算机而言，以像素值等表示的图像数据本身就是连续的\upcite{DBLP:conf/naacl/MichelLNP19}，而文本中的一个个单词本身离散的，这种图像与文本数据间的差异使得这些方法在自然语言处理上并不适用。比如图像任务中对一幅图片的局部图像进行替换的方法，如果用于自然语言处理中，可能会生成语法错误或者语义错误的句子。而且，简单替换单词产生的扰动过大，模型很容易判别。即使对词嵌入等连续表示的部分进行扰动，也会产生无法与词嵌入空间中的任何词匹配的向量\upcite{Gong2018AdversarialTW}。针对这些问题，下面着重介绍神经机器翻译任务中如何有效生成、使用对抗样本。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -357,9 +355,9 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\subsection{基于黑盒攻击的方法}
\parinterval 一个好的对抗样本应该具有这种性质：对文本做最少的修改，并最大程度地保留原文的语义。一种简单的实现方式是对文本加噪声。这里，噪声可以分为自然噪声和人工噪声\upcite{DBLP:conf/iclr/BelinkovB18}。自然噪声一般是指人为的在语料库中收集自然出现的错误，如输入错误、拼写错误等。人为噪声是通过人工设计的自动方法修改文本，例如，可以通过规则或是噪声生成器，在干净的数据中以一定的概率引入拼写错误、语法错误等\upcite{DBLP:conf/naacl/VaibhavSSN19,DBLP:conf/naacl/AnastasopoulosL19,DBLP:conf/acl/SinghGR18}；此外，也可以在文本中加入人为设计过的毫无意义的单词序列。
\parinterval 一个好的对抗样本应该具有这种性质：对文本做最少的修改，并最大程度地保留原文的语义。一种简单的实现方式是对文本加噪声。这里，噪声可以分为自然噪声和人工噪声\upcite{DBLP:conf/iclr/BelinkovB18}。自然噪声一般是指在语料库中自然出现的错误，如输入错误、拼写错误等。人为噪声是通过人工设计的自动方法修改文本，例如，可以通过规则或是噪声生成器，在干净的数据中以一定的概率引入拼写错误、语法错误等\upcite{DBLP:conf/naacl/VaibhavSSN19,DBLP:conf/naacl/AnastasopoulosL19,DBLP:conf/acl/SinghGR18}；此外，也可以在文本中加入人为设计过的毫无意义的单词序列。
\parinterval 除了单纯的在文本中引入各种扰动外，还可以通过文本编辑的方式，在不改变语义的情况下尽可能修改文本，从而构建对抗样本\upcite{DBLP:journals/corr/SamantaM17,DBLP:conf/ijcai/0002LSBLS18}。文本的编辑方式主要包括交换，插入，替换和删除操作。表\ref{tab:13-2}给出了通过这几种方式生成对抗样本的例子。
\parinterval 除了单纯的在文本中引入各种扰动外，还可以通过文本编辑的方式，在不改变语义的情况下尽可能修改文本，从而构建对抗样本\upcite{DBLP:journals/corr/SamantaM17,DBLP:conf/ijcai/0002LSBLS18}。文本的编辑方式主要包括交换、插入、替换和删除操作。表\ref{tab:13-2}给出了通过这几种方式生成对抗样本的例子。
%----------------------------------------------
\begin{table}[htp]{
......@@ -380,7 +378,7 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\parinterval 形式上，可以利用如FGSM等算法\upcite{DBLP:journals/corr/GoodfellowSS14}，验证文本中每一个单词的贡献度，同时为每一个单词构建一个候选池，包括该单词的近义词、拼写错误词、同音词等。对于贡献度较低的词，如语气词、副词等，可以使用插入、删除操作进行扰动。对于其他的单词，可以在候选池中选择相应的单词并进行替换。其中，交换操作可以是基于词级别的，比如交换序列中的单词，也可以是基于字符级别的，例如交换单词中的字符\upcite{DBLP:conf/coling/EbrahimiLD18}。重复进行上述的编辑操作，直至编辑出的文本可以误导模型做出错误的判断。
\parinterval 在机器翻译中，常用的回译技术也是生成对抗样本的一种有效方式。回译就是，通过反向模型将目标语言翻译成源语言，并将翻译得到的双语数据用于模型训练。除了翻译模型，语言模型也可以用于生成对抗样本。{\chaptertwo}已经介绍过，语言模型可以用于检测句子的流畅度，它根据上文预测当前位置可能出现的单词。因此，此时可以使用语言模型预测出当前位置最可能出现的多个单词，并用这些词替换序列中原本的单词。在机器翻译任务中，可以通过与神经机器翻译系统联合训练，共享词向量矩阵的方式得到语言模型\upcite{DBLP:conf/acl/GaoZWXQCZL19}。
\parinterval 在机器翻译中，常用的回译技术也是生成对抗样本的一种有效方式。回译就是，通过反向模型将目标语言翻译成源语言，并将翻译得到的双语数据用于模型训练（见{\chaptersixteen}）。除了翻译模型，语言模型也可以用于生成对抗样本。{\chaptertwo}已经介绍过，语言模型可以用于检测句子的流畅度，它根据上文预测当前位置可能出现的单词。因此，此时可以使用语言模型预测出当前位置最可能出现的多个单词，并用这些词替换序列中原本的单词。在机器翻译任务中，可以通过与神经机器翻译系统联合训练，共享词向量矩阵的方式得到语言模型\upcite{DBLP:conf/acl/GaoZWXQCZL19}。
\parinterval 此外，{\small\bfnew{生成对抗网络}}\index{生成对抗网络}（Generative Adversarial Networks\index{Generative Adversarial Networks}, GANs）也可以被用来生成对抗样本\upcite{DBLP:conf/iclr/ZhaoDS18}。与回译方法类似，基于生成对抗网络的方法将原始的输入映射为潜在分布$\funp{P}$，并在其中搜索出服从相同分布的文本构成对抗样本。一些研究也对这种方法进行了优化\upcite{DBLP:conf/iclr/ZhaoDS18}，在稠密的向量空间中进行搜索，也就是说在定义$\funp{P}$的基础稠密向量空间中找到对抗性表示$\mathbi{z}'$，然后利用生成模型将其映射回$\mathbi{x}'$，使最终生成的对抗样本在语义上接近原始输入。
......@@ -390,9 +388,9 @@ R(\mathbi{w}) & = & ({\Vert{\mathbi{w}}\Vert}_2)^2 \\
\subsection{基于白盒攻击的方法}
\parinterval 除了在单词级别增加扰动以外，还可以在模型内部增加扰动。一种简单的方法是在每一个词的词嵌入上，累加一个正太分布的变量，之后将其作为模型的最终输入。同时，可以在训练目标中增加额外的训练目标。比如，迫使模型在接收到被扰动的输入后，编码器能够生成与正常输入类似的表示，解码器输出正确的翻译结果\upcite{DBLP:conf/acl/LiuTMCZ18}。
\parinterval 除了在单词级别增加扰动以外，还可以在模型内部增加扰动。一种简单的方法是在每一个词的词嵌入上，累加一个正态分布的变量，之后将其作为模型的最终输入。同时，可以在训练阶段增加额外的训练目标。比如，迫使模型在接收到被扰动的输入后，编码器能够生成与正常输入类似的表示，解码器输出正确的翻译结果\upcite{DBLP:conf/acl/LiuTMCZ18}。
\parinterval 还可以根据机器翻译的具体问题增加扰动。例如，针对同音字错误问题，可以将单词的发音转换为一个包含$n$个发音单元的发音序列，如音素，音节等。并训练相应的嵌入矩阵将每一个发音单元转换为对应的向量表示。对发音序列中发音单元的嵌入表示进行平均后，得到当前单词的发音表示。最后将词嵌入与单词的发音表示进行加权求和，并将结果作为模型的输入\upcite{DBLP:conf/acl/LiuMHXH19}。通过这种方式可以提高模型对同音异形词的处理能力。除了在词嵌入层增加扰动，也可以在编码器输出中引入额外的噪声，能起到与在层输入中增加扰动相类似的效果\upcite{DBLP:conf/acl/LiLWJXZLL20}。
\parinterval 还可以根据机器翻译的具体问题增加扰动。例如，针对同音字错误问题，可以将单词的发音转换为一个包含$n$个发音单元的发音序列，如音素，音节等，并训练相应的嵌入矩阵将每一个发音单元转换为对应的向量表示。对发音序列中发音单元的嵌入表示进行平均后，得到当前单词的发音表示。最后将词嵌入与单词的发音表示进行加权求和，并将结果作为模型的输入\upcite{DBLP:conf/acl/LiuMHXH19}。通过这种方式可以提高模型对同音异形词的处理能力。除了在词嵌入层增加扰动，也可以在编码器输出中引入额外的噪声，能起到与在层输入中增加扰动相类似的效果\upcite{DBLP:conf/acl/LiLWJXZLL20}。
\parinterval 此外，对于训练样本$(\mathbi{x},\mathbi{y})$，还可以使用基于梯度的方法来生成对抗样本$(\mathbi{x}',\mathbi{y}')$。例如，可以利用替换词与原始单词词向量之间的差值，以及候选词的梯度之间的相似度来生成对抗样本\upcite{DBLP:conf/acl/ChengJM19}。以源语言为例，生成$\mathbi{x}'$中第$i$个词的过程可以被描述如下：
\begin{eqnarray}
......@@ -417,7 +415,7 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\label{eq:13-12}
\end{eqnarray}
\parinterval 无论是黑盒方法还是白盒方法，本质上都是通过增加噪声使得模型训练更加健壮。类似的思想在很多机器学习方法中都有体现，比如，最大熵模型中使用高斯噪声就是常用的增加模型健壮性的手段之一\upcite{chen1999gaussian}。从噪声信道模型的角度看（见{\chapterfive}），翻译过程也可以被理解为一种加噪和去噪的过程，不论这种噪声是天然存在于数据中的，还是人为添加的。除了对抗样本训练，机器翻译所使用的降噪自编码方法和基于重构的损失函数\upcite{DBLP:conf/icml/VincentLBM08,tu2017neural}，也都体现了类似的思想。广义上，这些方法也可以被看作是利用“加噪+ 去噪”进行健壮性训练的方法。
\parinterval 无论是黑盒方法还是白盒方法，本质上都是通过增加噪声使得模型训练更加健壮。类似的思想在很多机器学习方法中都有体现，比如，在最大熵模型中使用高斯噪声就是常用的增加模型健壮性的手段之一\upcite{chen1999gaussian}。从噪声信道模型的角度看（见{\chapterfive}），翻译过程也可以被理解为一种加噪和去噪的过程，不论这种噪声是天然存在于数据中的，还是人为添加的。除了对抗样本训练，机器翻译所使用的降噪自编码方法和基于重构的损失函数\upcite{DBLP:conf/icml/VincentLBM08,tu2017neural}，也都体现了类似的思想。广义上，这些方法也可以被看作是利用“加噪+ 去噪”进行健壮性训练的方法。
%----------------------------------------------------------------------------------------
% NEW SECTION
......@@ -436,11 +434,13 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\parinterval 极大似然估计已成为机器翻译乃至整个自然语言处理领域中使用最广泛的训练用目标函数。但是，使用极大似然估存在{\small\bfnew{曝光偏置}}\index{曝光偏置}（Exposure Bias\index{Exposure Bias}）问题和训练-推断评价指标不一致问题，具体体现在如下两个方面。
\parinterval 曝光偏置问题：在训练过程中，模型使用标注数据进行训练，因此模型在预测下一个单词时，解码器的输入是正确的译文片段。也就是，预测第$j$个单词时，系统使用了标准答案$\{{y}_1,...,{y}_{j-1}\}$作为历史信息。但是对新的句子进行翻译时，预测第$j$个单词时使用的是模型自己生成的前$j-1$个单词，即$\{\hat{{y}}_1,...,\hat{{y}}_{j-1}\}$。这意味着，训练时使用的输入数据（目标语言端）与真实翻译时的情况不符，如图\ref{fig:13-9} 所示。由于在训练过程中暴露于标注数据，因此模型也适应了标注数据，在推断阶段无法很好地适应模型自动生成的数据，这就是曝光偏置问题\upcite{Bengio2015ScheduledSF,Ranzato2016SequenceLT}。
\begin{itemize}
\vspace{0.5em}
\item {\small\bfnew{曝光偏置问题}}。在训练过程中，模型使用标注数据进行训练，因此模型在预测下一个单词时，解码器的输入是正确的译文片段。也就是，预测第$j$个单词时，系统使用了标准答案$\{{y}_1,...,{y}_{j-1}\}$作为历史信息。但是对新的句子进行翻译时，预测第$j$个单词时使用的是模型自己生成的前$j-1$个单词，即$\{\hat{{y}}_1,...,\hat{{y}}_{j-1}\}$。这意味着，训练时使用的输入数据（目标语言端）与真实翻译时的情况不符，如图\ref{fig:13-9} 所示。由于在训练过程中暴露于标注数据，因此模型也适应了标注数据，在推断阶段无法很好地适应模型自动生成的数据，这就是曝光偏置问题\upcite{Bengio2015ScheduledSF,Ranzato2016SequenceLT}。
\vspace{0.5em}
%----------------------------------------------
\begin{figure}[htp]
\begin{figure}[t]
\centering
\input{./Chapter13/Figures/figure-exposure-bias}
\caption{曝光偏置问题（基于循环神经网络的翻译模型）}
......@@ -448,7 +448,9 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\end{figure}
%----------------------------------------------
\parinterval 训练目标函数与任务评价指标不一致问题：在训练数据上使用极大似然估计，而在新数据上进行推断的时候，通常使用BLEU等外部评价指标来评价模型的性能。在机器翻译任务中，这个问题的一种体现是，训练数据上更低的困惑度不一定能带来BLEU的提升。更加理想的情况是，模型应该直接最大化性能评价指标，而不是训练集数据上的似然函数\upcite{DBLP:conf/acl/ShenCHHWSL16}。但是很多模型性能评价指标不可微分，这使得我们无法直接利用基于梯度的方法来优化这些指标。
\item {\small\bfnew{训练目标函数与任务评价指标不一致问题}}。在训练数据上使用极大似然估计，而在新数据上进行推断的时候，通常使用BLEU等外部评价指标来评价模型的性能。在机器翻译任务中，这个问题的一种体现是，训练数据上更低的困惑度不一定能带来BLEU的提升。更加理想的情况是，模型应该直接最大化性能评价指标，而不是训练集数据上的似然函数\upcite{DBLP:conf/acl/ShenCHHWSL16}。但是很多模型性能评价指标不可微分，这使得研究人员无法直接利用基于梯度的方法来优化这些指标。
\vspace{0.5em}
\end{itemize}
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -497,7 +499,7 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\parinterval 调度采样解决曝光偏置的方法是，把模型前$j-1$步的预测结果作为输入，来预测第$j$步的输出。但是，如果模型预测的结果中有错误，再使用错误的结果预测未来的序列也会产生问题。解决这个问题就需要知道模型预测的好与坏，并在训练中有效的使用它们。如果生成好的结果，那么可以使用它进行模型训练，否则就不使用。生成对抗网络就是这样一种技术，它引入了一个额外的模型（判别器）来对原有模型（生成器）的生成结果进行评价，并根据评价结果同时训练两个模型。
\parinterval 在\ref{sec:adversarial-examples}小节已经提到了生成对抗网络，这里稍微进行一些展开。 在机器翻译中，基于对抗神经网络的架构被命名为{\small\bfnew{对抗神经机器翻译}}\index{对抗神经机器翻译}（Adversarial-NMT）\index{Adversarial-NMT}\upcite{DBLP:conf/acml/WuXTZQLL18}。这里，令$(\seq{x},\seq{y})$表示一个训练样本，令$\hat{\seq{y}}$ 表示神经机器翻译系统对源语言句子$\seq{x}$ 的翻译结果。此时，对抗神经机器翻译的总体框架可以表示为图\ref{fig:13-11}，其中。绿色部分表示神经机器翻译模型$G$，该模型将源语言句子$\seq{x}$翻译为目标语言句子$\hat{\seq{y}}$。红色部分是对抗网络$D$，它的作用是判断目标语言句子是否是源语言句子$\seq{x}$ 的真实翻译。$G$ 和$D$相互对抗，同时生成翻译结果$\hat{\seq{y}}$来训练$D$，并生成奖励信号来通过策略梯度训练$G$。
\parinterval 在\ref{sec:adversarial-examples}小节已经提到了生成对抗网络，这里稍微进行一些展开。 在机器翻译中，基于对抗神经网络的架构被命名为{\small\bfnew{对抗神经机器翻译}}\index{对抗神经机器翻译}（Adversarial-NMT）\index{Adversarial-NMT}\upcite{DBLP:conf/acml/WuXTZQLL18}。这里，令$(\seq{x},\seq{y})$表示一个训练样本，令$\hat{\seq{y}}$ 表示神经机器翻译系统对源语言句子$\seq{x}$ 的翻译结果。此时，对抗神经机器翻译的总体框架可以表示为图\ref{fig:13-11}，其中。绿色部分表示神经机器翻译模型$G$，该模型将源语言句子$\seq{x}$翻译为目标语言句子$\hat{\seq{y}}$。红色部分是对抗网络$D$，它的作用是判断目标语言句子是否是源语言句子$\seq{x}$ 的真实翻译。$G$和$D$相互对抗，用$G$生成的翻译结果$\hat{\seq{y}}$来训练$D$，并生成奖励信号，再使用奖励信号通过策略梯度训练$G$。
%----------------------------------------------
\begin{figure}[htp]
......@@ -528,7 +530,7 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\parinterval 最小风险训练的目标是找到模型参数$\hat{\theta}_{\textrm{MRT}} $，满足如下公式：
\begin{eqnarray}
\hat{\theta}_{\textrm{MRT}} & = & \argmax_{\theta}\{\funp{R}(\theta)\} \label{eq:13-13}
\hat{\theta}_{\textrm{MRT}} & = & \argmin_{\theta}\{\funp{R}(\theta)\} \label{eq:13-13}
\end{eqnarray}
\noindent 其中，$\funp{R}(\theta)$表示预期风险，通常用风险函数的期望表示。假设有$N$个训练样本$\{(x^{[1]},y^{[1]}),...,(x^{[N]},y^{[N]})\}$，$\funp{R}(\theta)$被定义如下：
......@@ -540,11 +542,12 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\noindent 这里，$\hat{\seq{y}}$是模型预测的译文，$\chi(\seq{x}^{[k]})$是$\seq{x}^{[k]}$所对应的所有候选翻译的集合。损失函数$\vartriangle(\hat{\seq{y}},\seq{y}^{[k]})$用来衡量模型预测$\hat{\seq{y}}$与标准答案$\seq{y}^{[k]}$间的差异，损失函数一般用翻译质量评价指标定义，例如，BLEU，TER等\footnote{对于BLEU，损失函数可以被定义为$1-$BLEU。}。在最小风险训练中，对模型参数$\theta$的偏导数为：
\begin{eqnarray}
\frac{\partial \funp{R}(\theta)}{\partial \theta} & = & \sum_{k=1}^N \mathbb{E}_{\hat{\seq{y}}|\seq{x}^{[k]};\theta}[\vartriangle(\hat{\seq{y}},\seq{y}^{[k]}) \times \frac{\partial \funp{P}(\hat{\seq{y}}|\seq{x}^{[k]};\theta)/\partial \theta}{\funp{P}(\hat{\seq{y}}|\seq{x}^{[k]};\theta)}]
\frac{\partial \funp{R}(\theta)}{\partial \theta} & = & \sum_{k=1}^N \mathbb{E}_{\hat{\seq{y}}|\seq{x}^{[k]};\theta}[\vartriangle(\hat{\seq{y}},\seq{y}^{[k]}) \times \frac{\partial \funp{P}(\hat{\seq{y}}|\seq{x}^{[k]};\theta)/\partial \theta}{\funp{P}(\hat{\seq{y}}|\seq{x}^{[k]};\theta)}] \nonumber \\
& = & {\red \sum_{k=1}^N \mathbb{E}_{\hat{\seq{y}}|\seq{x}^{[k]};\theta}[\vartriangle(\hat{\seq{y}},\seq{y}^{[k]}) \times \frac{\partial \log{\funp{P}(\hat{\seq{y}}|\seq{x}^{[k]};\theta)}}{\partial \theta}]}
\label{eq:13-15}
\end{eqnarray}
\noindent 公式\eqref{eq:13-15}使用了{\small\bfnew{策略梯度}}\index{策略梯度}（Policy Gradient\index{Policy Gradient}）的手段将$\vartriangle(\hat{\seq{y}},\seq{y}^{[k]})$提到微分操作之外\upcite{DBLP:conf/nips/Kakade01,DBLP:journals/corr/abs-1810-02525}。这样，就无需对$\vartriangle(\hat{\seq{y}},\seq{y}^{[k]})$进行微分，因此最小风险训练允许任意不可微的损失函数，包括BLEU等常用的评价函数。使用公式\eqref{eq:13-15}就可以求出模型参数相对于风险函数的损失，进而进行基于梯度的优化。
\noindent 公式\eqref{eq:13-15}使用了{\small\bfnew{策略梯度}}\index{策略梯度}（Policy Gradient\index{Policy Gradient}）的手段将$\vartriangle(\hat{\seq{y}},\seq{y}^{[k]})$提到微分操作之外\upcite{DBLP:conf/nips/Kakade01,DBLP:journals/corr/abs-1810-02525}。这样，就无需对$\vartriangle(\hat{\seq{y}},\seq{y}^{[k]})$进行微分，因此最小风险训练允许任意不可微的损失函数，包括BLEU等常用的评价函数。{\red 同时，等式右侧将对概率的求导操作转化为了对log函数的求导，更易于模型进行优化。因此，}使用公式\eqref{eq:13-15}就可以求出模型参数相对于风险函数的损失，进而进行基于梯度的优化。
\parinterval 这里需要注意的是，公式\eqref{eq:13-15}中求期望的过程是无法直接实现的，因为无法遍历所有的译文句子。通常，会使用采样的方法搜集一定数量的译文，来模拟译文空间。例如，可以使用推断系统生成若干译文。同时，为了保证生成的译文之间具有一定的差异性，也可以对推断过程进行一些“干扰”。从实践的角度看，采样方法是影响强化学习系统的重要因素，因此往往需要对不同的任务设计相适应的采样方法。最简单的方法就是在产生译文的每一个词时候，根据模型产生的下一个词的分布随机选取词当作模型预测，直到选到句子结束符或者达到特定长度的时候停止\upcite{DBLP:conf/emnlp/EdunovOAG18}。其他方法还包括随机束搜索，它把束搜索中选取Top-$k$的操作替换成随机选取$k$个词。这个方法不会采集到重复的样本。还可以使用基于Gumbel-Top-$k$的随机束搜索更好地控制了样本里的噪声\upcite{DBLP:conf/icml/KoolHW19}。
......@@ -566,14 +569,19 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\subsubsection{2. 演员-评论家方法}
\parinterval 基于策略的强化学习是要寻找一个策略$\funp{p}(a|\hat{{y}}_{1 \ldots j},\seq{x})$，使得该策略选择的行动$a$未来可以获得的奖励期望（也被称为{\small\bfnew{动作价值函数}}\index{动作价值函数}（Action-value Function）\index{Action-value Function}）最大化。这个过程通常用函数$Q$来描述：
\parinterval 基于策略的强化学习是要寻找一个策略$\funp{p}(a|\hat{{y}}_{1 \ldots j-1},\seq{x})$，使得该策略选择的行动$a$未来可以获得的奖励期望最大化，也被称为{\small\bfnew{动作价值函数}}\index{动作价值函数}（Action-value Function）\index{Action-value Function}最大化。这个过程通常用函数$Q$来描述：
\begin{eqnarray}
\funp{Q}(a;\hat{y}_{1 \ldots j},\seq{y}) & = & \mathbb{E}_{\hat{y}_{j+1 \ldots J} \sim \funp{p}(a|\hat{y}_{1 \ldots j} a,\seq{x})}[\funp{r}_j(a;\hat{y}_{1 \ldots j-1},\seq{y}) + \nonumber \\
& & \sum_{i=j+1}^J\funp{r}_i(\hat{{y}}_i;\hat{{y}}_{1 \ldots j-1}a\hat{{y}}_{j+1 \ldots i-1},\seq{y})]
\funp{Q}(a;\hat{y}_{1 \ldots j-1},\seq{y}) & = & \mathbb{E}_{\hat{y}_{j+1 \ldots J} \sim \funp{p}(\cdot|\hat{y}_{1 \ldots j-1} a,\seq{x})}[\funp{r}_j(a;\hat{y}_{1 \ldots j-1},\seq{y}) + \nonumber \\
& & \sum_{i=j}^J\funp{r}_i(\hat{{y}}_i;\hat{{y}}_{1 \ldots j-1}a\hat{{y}}_{j+1 \ldots i},\seq{y})]
\label{eq:13-16}
\end{eqnarray}
{\blue ---------------------------------------------讨论\\
{{ (学长，$\sum_{i=j+1}^J\funp{r}_i(\hat{{y}}_i;\hat{{y}}_{1 \ldots j-1}a\hat{{y}}_{j+1 \ldots i},\seq{y})$想表达的应该是：\\$\funp{r}_{j+1}(\hat{{y}}_{j+1};\hat{{y}}_{1 \ldots j-1}a,\seq{y})$\\$\funp{r}_{j+2}(\hat{{y}}_{j+2};\hat{{y}}_{1 \ldots j-1}a\hat{{y}}_{j+1},\seq{y})$\\$\funp{r}_{j+3}(\hat{{y}}_{j+3};\hat{{y}}_{1 \ldots j-1}a\hat{{y}}_{j+1,j+2},\seq{y})$\\$\cdots$\\这些项的加和对吧，那$a$后面的$y$的最后一项改成$i-1$也不合理，因为$i-1$就是$j$，会跟$a$重复（因为$a$也是$\hat{{y}}_j$，只不过$\hat{{y}}_j$是固定的状态，$a$是任意动作），要不这里就把a改成$\hat{{y}}_j$行吗?或者$a_{\hat{{y}}_j}$这种形式，但是这种形式仍然会和$a$后面的加和冲突。)}}
\noindent 其中，$\funp{r}_j(a;\hat{{y}}_{1 \ldots j-1},\seq{y})$是$j$时刻做出行动$a$获得的奖励，$\funp{r}_i(\hat{{y}}_i;\hat{{y}}_{1 \ldots j-1}a\hat{{y}}_{j+1 \ldots i-1},\seq{y})$是在$j$时刻的行动为$a$的前提下，$i$时刻的做出行动$\hat{{y}}_i$获得的奖励，$\seq{x}$是源语言句子，$\seq{y}$是正确译文，$\hat{{y}}_{1 \ldots j}$是策略$\funp{p}$产生的译文的前$j$个词，$J$是生成译文的长度。对于源语句子$x$，最优策略$\hat{p}$可以被定义为：
{{ 学长觉得这样行吗，公式1.16把a删掉，改成：$\sum_{i=j}^J\funp{r}_i(\hat{{y}}_i;\hat{{y}}_{1 \ldots j-1}\hat{{y}}^{a}_{j \ldots i},\seq{y})$，（下面的段落加说明，此处的$\hat{{y}}^{a}_{j \ldots i}$表示由动作a决定的$\hat{{y}}_{j \ldots i}$）\\}}
---------------------------------------------讨论\\
}
\noindent 其中，$\funp{r}_j(a;\hat{{y}}_{1 \ldots j-1},\seq{y})$是$j$时刻做出行动$a$获得的奖励，$\funp{r}_i(\hat{{y}}_i;\hat{{y}}_{1 \ldots j-1}a\hat{{y}}_{j+1 \ldots i},\seq{y})$是在$j$时刻的行动为$a$的前提下，$i$时刻的做出行动$\hat{{y}}_i$获得的奖励，{\red $\hat{y}_{j+1 \ldots J} \sim \funp{p}(\cdot|\hat{y}_{1 \ldots j-1} a,\seq{x})$表示序列$\hat{y}_{j+1 \ldots J}$是根据$\funp{p}(\cdot|\hat{y}_{1 \ldots j-1} a,\seq{x})$得到的采样结果，概率函数$\funp{p}$中的$\cdot$表示序列$\hat{y}_{j+1 \ldots J}$服从的随机变量，}$\seq{x}$是源语言句子，$\seq{y}$是正确译文，$\hat{{y}}_{1 \ldots j-1}$是策略$\funp{p}$产生的译文的前$j-1$个词，$J$是生成译文的长度。{\red 特别的，对于公式\ref{eq:13-16}中$\hat{{y}}_{j+1 \ldots i}$来说，如果$i<j+1$，则$\hat{{y}}_{j+1 \ldots i}$不存在，}对于源语句子$x$，最优策略$\hat{p}$可以被定义为：
\begin{eqnarray}
\hat{p} & = & \argmax_{\funp{p}}\mathbb{E}_{\hat{\seq{y}} \sim \funp{p}(\hat{\seq{y}} | \seq{x})}\sum_{j=1}^J\sum_{a \in A}\funp{p}(a|\hat{{y}}_{1 \ldots j},\seq{x})\funp{Q}(a;\hat{{y}}_{1 \ldots j},\seq{y})
\label{eq:13-17}
......@@ -602,19 +610,19 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\label{eq:13-19}
\end{eqnarray}
\parinterval 这个等式也被称为{\small\bfnew{贝尔曼方程}}\index{贝尔曼方程}（Bellman Equation\index{Bellman Equation}）\upcite{sutton2018reinforcement}。它告诉我们$j-1$时刻的动作价值函数$\funp{Q}(\hat{{y}}_j;\hat{{y}}_{1 \ldots j-1},\seq{y})$跟下一时刻$j$的动作价值函数$\funp{Q}(a;\hat{{y}}_{1 \ldots j},\seq{y})$之间的关系。因此可以很自然的使用等式右部作为等式左部$\funp{Q}(\hat{{y}}_j;\hat{{y}}_{1 \ldots j-1},\seq{y})$的等价形式。于是，可以定义$j$时刻动作价值函数为：
\parinterval 这个等式也被称为{\small\bfnew{贝尔曼方程}}\index{贝尔曼方程}（Bellman Equation\index{Bellman Equation}）\upcite{sutton2018reinforcement}。它表达了$j-1$时刻的动作价值函数$\funp{Q}(\hat{{y}}_j;\hat{{y}}_{1 \ldots j-1},\seq{y})$跟下一时刻$j$的动作价值函数$\funp{Q}(a;\hat{{y}}_{1 \ldots j},\seq{y})$之间的关系。{\red 在理想情况下，动作价值函数$\funp{Q}$应该满足上述等式，因此可以使用该等式作为可学习的函数$\tilde{\funp{Q}}$的目标}{\red \sout{，因此可以很自然的使用等式右部作为等式左部$\funp{Q}(\hat{{y}}_j;\hat{{y}}_{1 \ldots j-1},\seq{y})$的等价形式}}。于是，可以定义$j$时刻动作价值函数为：
\begin{eqnarray}
\funp{q}_j & = & \funp{r}_j(\hat{{y}}_j;\hat{{y}}_{1 \ldots j-1},\seq{y}) + \sum_{a \in A}\funp{p}(a|\hat{{y}}_{1 \ldots j},\seq{x})\tilde{\funp{Q}}(a;\hat{{y}}_{1 \ldots j},\seq{y})
\label{eq:13-20}
\end{eqnarray}
\parinterval 而评论家对应的目标定义如下：
\noindent {\red 相应的，}评论家对应的目标定义如下：
\begin{eqnarray}
\hat{\tilde{\funp{Q}}} & = & \argmin_{\tilde{\funp{Q}}}\sum_{j=1}^J{(\tilde{\funp{Q}}(\hat{{y}}_j;\hat{{y}}_{1 \ldots j-1},\seq{y}) - \funp{q}_j)}^2
\label{eq:13-21}
\end{eqnarray}
\parinterval 最后，通过同时优化演员和评论家直到收敛，获得的演员（也就是策略$\funp{p}$）就是我们期望的翻译模型。图\ref{fig:13-12}展示了演员和评论家的关系。
\parinterval {\red 此时，公式\ref{eq:13-20}与公式\ref{eq:13-21}共同组成了评论家的学习目标，使得可学习的函数$\tilde{\funp{Q}}$逼近理想的$\funp{Q}$。}最后，通过同时优化演员和评论家直到收敛，获得的演员（也就是策略$\funp{p}$）就是我们期望的翻译模型。图\ref{fig:13-12}展示了演员和评论家的关系。
%----------------------------------------------
\begin{figure}[htp]
......@@ -629,7 +637,7 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\begin{itemize}
\vspace{0.5em}
\item {\small\bfnew{多目标学习}}。演员的优化通常会引入额外的极大似然估计目标函数，同时会使用极大似然估计进行预训练。这样会简化训练，因为随机初始化的演员性能很差，很难获得有效的奖励。同时极大似然估计也被可以当作一种先验知识，通过正则项的形式约束机器翻译模型的学习，防止模型陷入很差的局部最优，并加速模型收敛。
\item {\small\bfnew{多目标学习}}。演员的优化通常会引入额外的极大似然估计目标函数，同时会使用极大似然估计进行预训练。这样会简化训练，因为随机初始化的演员性能很差，很难获得有效的奖励。同时极大似然估计也可以被当作一种先验知识，通过正则项的形式约束机器翻译模型的学习，防止模型陷入很差的局部最优，并加速模型收敛。
\vspace{0.5em}
\item {\small\bfnew{优化目标}}。评论家的优化目标是由自身输出所构造的。当模型更新比较快的时候模型的输出变化也会很快，导致构造的优化目标不稳定，影响模型收敛效果。一个解决方案是，在一定更新次数内固定构造优化目标使用的模型，然后再使用比较新的模型来构造后续一定更新次数内的优化目标，如此往复\upcite{DBLP:journals/nature/SilverHMGSDSAPL16}。
\vspace{0.5em}
......@@ -646,7 +654,7 @@ Loss_{\textrm{robust}}(\theta_{\textrm{mt}}) &=& \frac{1}{N}\sum_{(\mathbi{x},\
\sectionnewpage
\section{知识蒸馏}\label{subsection-7.5.3}
\parinterval 理想的机器翻译系统应该是品质好、速度块、存储占用少。不过，为了追求更好的翻译品质，往往需要更大的模型，但是相应的翻译速度会降低，模型的体积会变大。在很多场景下，这样的模型无法直接使用。比如，Transformer-Big等“大”模型通常在专用GPU服务器上运行，在手机等受限环境下仍很难应用。
\parinterval 理想的机器翻译系统应该是品质好、速度快、存储占用少。不过，为了追求更好的翻译品质，往往需要更大的模型，但是相应的翻译速度会降低，模型的体积会变大。在很多场景下，这样的模型无法直接使用。比如，Transformer-Big等“大”模型通常在专用GPU服务器上运行，在手机等受限环境下仍很难应用。
\parinterval 另一方面，直接训练“小”模型的效果往往并不理想，其翻译品质与“大”模型相比仍有比较明显的差距。既然直接训练小模型无法达到很好的效果，一种有趣的想法是把“大”模型的知识传递给“小”模型。这类似于，教小孩子学习数学，是请一个权威数学家（数据中的标准答案）进行教学，而是会请一个小学数
学教师（“大”模型）来教小孩子。这就是知识蒸馏的基本思想。
......@@ -760,7 +768,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\seq{y}} | \seq{x})
\sectionnewpage
\section{基于样本价值的学习}
\parinterval 当人在学习知识时，通常会遵循序渐进、由易到难的原则，这是一种很自然的学习策略。但是，当训练机器翻译模型时，通常是将全部的样本以随机的方式输入模型中进行学习，换句话说，就是让模型来平等地对待所有的训练样本。这种方式忽略了样本对于模型训练的“价值”，显然，更加理想的方式是优先使用价值高的样本对模型进行训练。围绕训练样本的价值差异产生了诸如数据选择、主动学习、课程学习等一系列的样本使用方法，这些学习策略本质上是在不同任务、不同背景、不同假设下，对如何高效的利用训练样本这一问题进行求解，本节即对这些技术进行介绍。
\parinterval 当人在学习知识时，通常会遵循序渐进、由易到难的原则，这是一种很自然的学习策略。但是，当训练机器翻译模型时，通常是将全部的样本以随机的方式输入模型中进行学习，换句话说，就是让模型来平等地对待所有的训练样本。这种方式忽略了样本对于模型训练的“价值”，显然，更加理想的方式是优先使用价值高的样本对模型进行训练。围绕训练样本的价值差异产生了诸如数据选择、主动学习、课程学习等一系列的样本使用方法，这些学习策略本质上是在不同任务、不同背景、不同假设下，对如何高效地利用训练样本这一问题进行求解，本节即对这些技术进行介绍。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -782,17 +790,17 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\seq{y}} | \seq{x})
\parinterval 当机器翻译系统应用于不同领域时，训练语料与所应用领域的相关性就显得非常重要\upcite{DBLP:journals/mt/EetemadiLTR15,britz2017effective}。不同领域往往具有自己独特的属性，比如语言风格、句子结构、专业术语等，例如，“bank”这个英语单词，在金融领域通常被翻译为“银行”，而在计算机领域，一般被解释为“库”、“存储体”等。这也会导致，使用通用领域数据训练出来的模型在特定领域上的翻译效果往往不理想，这本质上是训练数据和测试数据的领域属性不匹配造成的。
\parinterval 一种解决办法是只使用特定领域的数据进行模型训练，然而这种数据往往比较稀缺。那能不能利用通用领域数据来帮助数据稀少的领域呢？这个研究方向被称为机器翻译的{\small\bfnew{领域适应}}\index{领域适应}（Domain Adaptation\index{Domain Adaptation}），即从资源丰富的领域（称为源领域， Source Domain）向资源稀缺的领域（称为目标领域， Target Domain）迁移。这本身也对应着资源稀缺场景下的机器翻译问题，这类问题会在{\chaptersixteen}进行详细讨论。本章更加关注如何有效地利用训练样本以更好地适应目标领域。具体来说，可以使用{\small\bfnew{数据选择}}\index{数据选择}（Data Selection\index{Selection}）从源领域训练数据中选择与目标领域更加相关的样本进行模型训练。这样做的一个好处是，源领域中混有大量与目标领域不相关的样本，数据选择可以有效降低这部分数据的比例，这样可以更加突出与领域相关样本的作用。
\parinterval 一种解决办法是只使用特定领域的数据进行模型训练，然而这种数据往往比较稀缺。那能不能利用通用领域数据来帮助数据稀少的领域呢？这个研究方向被称为机器翻译的{\small\bfnew{领域适应}}\index{领域适应}（Domain Adaptation\index{Domain Adaptation}），即从资源丰富的领域（称为{\small\bfnew{源领域}}\index{源领域}， Source Domain\index{Source Domain}）向资源稀缺的领域（称为{\small\bfnew{目标领域}}\index{目标领域}， Target Domain\index{Target Domain}）迁移。这本身也对应着资源稀缺场景下的机器翻译问题，这类问题会在{\chaptersixteen}进行详细讨论。本章更加关注如何有效地利用训练样本以更好地适应目标领域。具体来说，可以使用{\small\bfnew{数据选择}}\index{数据选择}（Data Selection\index{Selection}）从源领域训练数据中选择与目标领域更加相关的样本进行模型训练。这样做的一个好处是，源领域中混有大量与目标领域不相关的样本，数据选择可以有效降低这部分数据的比例，这样可以更加突出与领域相关样本的作用。
\parinterval 数据选择所要解决的核心问题是：给定一个目标领域/任务数据集（如，目标任务的开发集），如何衡量原始训练样本与目标领域/任务的相关性？主要方法可以分为以下几类：
\begin{itemize}
\vspace{0.5em}
\item 基于{\small\bfnew{交叉熵差}}\index{交叉熵差}（Cross-entropy Difference\index{Cross-entropy Difference}，CED）的方法\upcite{DBLP:conf/emnlp/AxelrodHG11,DBLP:conf/wmt/AxelrodRHO15,DBLP:conf/emnlp/WangULCS17,DBLP:conf/iwslt/MansourWN11}。该方法在目标领域数据和通用数据上分别训练语言模型，然后用两个语言模型来给句子打分并做差，差越小说明句子与目标领域越相关。
\item {\small\bfnew{基于交叉熵差}}\index{交叉熵差}（Cross-entropy Difference\index{Cross-entropy Difference}，CED）{\small\bfnew{的方法}}\upcite{DBLP:conf/emnlp/AxelrodHG11,DBLP:conf/wmt/AxelrodRHO15,DBLP:conf/emnlp/WangULCS17,DBLP:conf/iwslt/MansourWN11}。该方法在目标领域数据和通用数据上分别训练语言模型，然后用两个语言模型来给句子打分并做差，差越小说明句子与目标领域越相关。
\vspace{0.5em}
\item 基于文本分类的方法\upcite{DBLP:conf/conll/ChenH16,chen2016bilingual,DBLP:conf/aclnmt/ChenCFL17,DBLP:conf/wmt/DumaM17}。将问题转化为文本分类问题，先构造一个领域分类器，之后利用分类器对给定的句子进行领域分类，最后用输出的概率来打分，选择得分高的样本。
\item {\small\bfnew{基于文本分类的方法}}\upcite{DBLP:conf/conll/ChenH16,chen2016bilingual,DBLP:conf/aclnmt/ChenCFL17,DBLP:conf/wmt/DumaM17}。将问题转化为文本分类问题，先构造一个领域分类器，之后利用分类器对给定的句子进行领域分类，最后用输出的概率来打分，选择得分高的样本。
\vspace{0.5em}
\item 基于{\small\bfnew{特征衰减算法}}\index{特征衰减算法}（Feature Decay Algorithms\index{Feature Decay Algorithms}，FDA）的方法\upcite{DBLP:conf/wmt/BiciciY11,poncelas2018feature,DBLP:conf/acl/SotoSPW20}。该算法基于特征匹配，试图从源领域中提取出一个句子集合，这些句子能够最大程度覆盖目标领域的语言特征。
\item {\small\bfnew{基于特征衰减算法}}\index{特征衰减算法}（Feature Decay Algorithms\index{Feature Decay Algorithms}，FDA）{\small\bfnew{的方法}}\upcite{DBLP:conf/wmt/BiciciY11,poncelas2018feature,DBLP:conf/acl/SotoSPW20}。该算法基于特征匹配，试图从源领域中提取出一个句子集合，这些句子能够最大程度覆盖目标领域的语言特征。
\vspace{0.5em}
\end{itemize}
......@@ -826,7 +834,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\seq{y}} | \seq{x})
\subsubsection{3. 主动学习}
\parinterval {\small\bfnew{主动学习}}\index{主动学习}（Active Learning\index{Active Learning}）也是一种数据选择策略。它最初的应用场景式是：标注大量的数据成本过高，因此希望优先标注对模型最有价值的数据，这样可以最大化模型学习的效率，同时降低数据标注的整体代价\upcite{DBLP:conf/coling/ZhuWH08}。主动学习主要由五个部分组成，包括：未标注样本池、筛选策略、标注者、标注样本集、目标模型。在主动学习过程中，会根据当前的模型状态找到未标注样本池中最有价值的样本，之后送给标注者。标注结束后，会把标注的样本加入到标注样本集中，之后用这些标注的样本更新模型。之后，重复这个过程，直到到达某种收敛状态。
\parinterval {\small\bfnew{主动学习}}\index{主动学习}（Active Learning\index{Active Learning}）也是一种数据选择策略。它最初的应用场景是：标注大量的数据成本过高，因此希望优先标注对模型最有价值的数据，这样可以最大化模型学习的效率，同时降低数据标注的整体代价\upcite{DBLP:conf/coling/ZhuWH08}。主动学习主要由五个部分组成，包括：未标注样本池、筛选策略、标注者、标注样本集、目标模型。在主动学习过程中，会根据当前的模型状态找到未标注样本池中最有价值的样本，之后送给标注者。标注结束后，会把标注的样本加入到标注样本集中，之后用这些标注的样本更新模型。之后，重复这个过程，直到到达某种收敛状态。
\parinterval 主动学习的一个核心问题是：如何选择出那些最有价值的未标注样本？通常会假设模型认为最“难”的样本是最有价值的。具体实现有很多思路，例如，基于置信度的方法、基于分类错误的方法等等\upcite{DBLP:journals/tslp/ZhuM12,DBLP:conf/coling/ZhuWYT08}。
......@@ -839,11 +847,11 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\seq{y}} | \seq{x})
\subsection{课程学习}
\label{sec:curriculum-learning}
\parinterval {\small\bfnew{课程学习}}\index{课程学习}（Curriculum Learning）\index{Curriculum Learning}的基本思想是：先学习简单的、普适性的知识，然后逐渐增加难度，学习更复杂、更专业化的知识。在统计模型训练中，这种思想可以体现在让模型按照由“易”到”难“ 的顺序对样本进行学习\upcite{DBLP:conf/icml/BengioLCW09}，这本质上是一种样本使用策略。以神经机器翻译翻译使用的随机梯度下降为例，在传统的方法中，所有训练样本都是随机呈现给模型的，换句话说，就是让模型平等地对待所有的训练样本，这忽略了数据样本的各种复杂性和当前模型的学习状态。所以模拟人类由易到难的学习过程就是一种很自然的想法，这样做的好处在于：
\parinterval {\small\bfnew{课程学习}}\index{课程学习}（Curriculum Learning）\index{Curriculum Learning}的基本思想是：先学习简单的、普适性的知识，然后逐渐增加难度，学习更复杂、更专业化的知识。在统计模型训练中，这种思想可以体现在让模型按照由“易”到“难”的顺序对样本进行学习\upcite{DBLP:conf/icml/BengioLCW09}，这本质上是一种样本使用策略。以神经机器翻译使用的随机梯度下降为例，在传统的方法中，所有训练样本都是随机呈现给模型的，换句话说，就是让模型平等地对待所有的训练样本，这忽略了数据样本的各种复杂性和当前模型的学习状态。所以模拟人类由易到难的学习过程就是一种很自然的想法，这样做的好处在于：
\begin{itemize}
\vspace{0.5em}
\item {\small\bfnew{加速机模型训练}}。在达到相同的性能条件下，课程学习可以加速训练，减少训练迭代步数。
\item {\small\bfnew{加速模型训练}}。在达到相同的性能条件下，课程学习可以加速训练，减少训练迭代步数。
\vspace{0.5em}
\item {\small\bfnew{使模型获得更好的泛化性能}}。即通过对简单样本的学习，让模型不至于过早进入拟合复杂样本的状态。
\vspace{0.5em}
......@@ -874,7 +882,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\seq{y}} | \seq{x})
\parinterval 评估样本的难度和具体的任务相关，在神经机器翻译中，有很多种评估方法，可以利用语言学上的困难准则，比如句子长度、句子平均词频、句法树深度等\upcite{DBLP:conf/naacl/PlataniosSNPM19,DBLP:conf/ranlp/KocmiB17}。这些准则本质上属于人类的先验知识，符合人类的直觉，但不一定和模型相匹配。对人类来说简单的句子对模型来说可能并不简单，所以研究人员也提出了基于模型的方法，比如：语言模型\upcite{DBLP:conf/acl/WangCC19,DBLP:conf/naacl/ZhangSKMCD19}，或者神经机器翻译模型\upcite{zhang2018empirical,DBLP:conf/coling/XuHJFWHJXZ20}都可以用于评价样本的难度。值得注意的是，利用神经机器翻译来打分的方法分为静态和动态两种。静态的方法是利用在小数据集上训练的、更小的翻译模型来打分\upcite{zhang2018empirical}。动态的方法则是利用当前模型的状态来打分，这在广义上也叫作{\small\bfnew{自步学习}}\index{自步学习}（Self-paced Learning\index{Self-paced Learning}），通常可以利用模型的训练误差或变化率等指标进行样本难度的估计\upcite{DBLP:conf/coling/XuHJFWHJXZ20}。
\parinterval 虽然样本难度的度量在不同任务中有所不同，但课程规划通常与数据和任务无关。在各种场景中，大多数课程学习都利用了类似的调度策略。具体而言，调度策略可以分为预定义的和自动两种。预定义的调度策略通常按照难易程度排序好的样本划分为块，每个块中包含一定数量的难度相似的样本。然后按照“先易后难”的原则人工定义一个调度策略，比如，一种较为流行的方法是：在训练早期，模型只在简单块中进行采样，随着训练过程的进行，将下一个块的样本合并到当前训练子集中，继续训练，直到合并了整个数据块，即整个训练集可见为止，之后再继续训练直到收敛。这个过程如图\ref{fig:13-16}所示。类似的还有一些其他变体，比如，训练到模型可见整个数据集之后，将最难的样本块复制并添加到训练集中，或者是将最容易的数据块逐渐删除，然后再添加回来等，这些方法的基本想法都是想让模型在具备一定的能力之后更多关注于困难样本。
\parinterval 虽然样本难度的度量在不同任务中有所不同，但课程规划通常与数据和任务无关。在各种场景中，大多数课程学习都利用了类似的调度策略。具体而言，调度策略可以分为预定义的和自动的两种。预定义的调度策略通常将按照难易程度排序好的样本划分为块，每个块中包含一定数量的难度相似的样本。然后按照“先易后难”的原则人工定义一个调度策略，比如，一种较为流行的方法是：在训练早期，模型只在简单块中进行采样，随着训练过程的进行，将下一个块的样本合并到当前训练子集中，继续训练，直到合并了整个数据块，即整个训练集可见为止，之后再继续训练直到收敛。这个过程如图\ref{fig:13-16}所示。类似的还有一些其他变体，比如，训练到模型可见整个数据集之后，将最难的样本块复制并添加到训练集中，或者是将最容易的数据块逐渐删除，然后再添加回来等，这些方法的基本想法都是想让模型在具备一定的能力之后更多关注于困难样本。
%----------------------------------------------
\begin{figure}[htp]
......@@ -907,7 +915,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\seq{y}} | \seq{x})
\vspace{0.5em}
\end{itemize}
\parinterval 从某种程度上看，多领域、多语言机器翻译等都可以被看做是广义上的持续学习。在多领域神经机器翻译中，我们期望一个在通用数据上学习的模型可以继续在新的领域有良好的表现。在多语言神经机器翻译中，我们期望一个模型可以支持更多语种的翻译，甚至当新的语言到来时不需要修改模型结构。以上这些问题在{\chaptersixteen} 和{\chaptereighteen} 中还会有详细讨论。
\parinterval 从某种程度上看，多领域、多语言机器翻译等都可以被看做是广义上的持续学习。在多领域神经机器翻译中，研究人员期望一个在通用数据上学习的模型可以继续在新的领域有良好的表现。在多语言神经机器翻译中，研究人员期望一个模型可以支持更多语种的翻译，甚至当新的语言到来时不需要修改模型结构。以上这些问题在{\chaptersixteen}和{\chaptereighteen}中还会有详细讨论。
%----------------------------------------------------------------------------------------
% NEW SECTION
......@@ -926,7 +934,7 @@ L_{\textrm{seq}} = - \textrm{logP}_{\textrm{s}}(\hat{\seq{y}} | \seq{x})
\item 此外，在机器翻译中，强化学习的应用也有很多，比如，MIXER算法用混合策略梯度和极大似然估计的目标函数来更新模型\upcite{Ranzato2016SequenceLT}，DAgger\upcite{DBLP:journals/jmlr/RossGB11}以及DAD\upcite{DBLP:conf/aaai/VenkatramanHB15}等算法在训练过程之中逐渐让模型适应推断阶段的模式。此外，强化学习的效果目前还相当不稳定，研究人员提出了大量的方法来进行改善，比如降对动作价值函数$\funp{Q}$的估计的方差\upcite{DBLP:conf/iclr/BahdanauBXGLPCB17,DBLP:conf/emnlp/NguyenDB17}、使用单语语料\upcite{Sennrich2016ImprovingNM,DBLP:conf/emnlp/WuTQLL18}等等。
\vspace{0.5em}
\item 从广义上说，大多数课程学习方法都是遵循由易到难的原则，然而在实践过程中人们逐渐赋予了课程学习更多的内涵，课程学习的含义早已超越了最原始的定义。一方面，课程学习可以与许多任务相结合，此时，评估准则并不一定总是样本的困难度，这取决于具体的任务。或者说，我们更关心的是样本带给模型的“价值”，而非简单的难易标准。另一方面，在一些任务或数据中，由易到难并不总是有效，有时困难优先反而会取得更好的效果\upcite{DBLP:conf/medprai/SurendranathJ18,zhang2018empirical}。实际上这和我们的直觉不太符合，一种合理的解释是课程学习更适合标签噪声、离群值较多或者是目标任务困难的场景，能提高模型的健壮性和收敛速度，而困难优先的策略则更适合数据集干净的场景\upcite{DBLP:conf/nips/ChangLM17}。
\item 从广义上说，大多数课程学习方法都是遵循由易到难的原则，然而在实践过程中人们逐渐赋予了课程学习更多的内涵，课程学习的含义早已超越了最原始的定义。一方面，课程学习可以与许多任务相结合，此时，评估准则并不一定总是样本的困难度，这取决于具体的任务。或者说，我们更关心的是样本带给模型的“价值”，而非简单的难易标准。另一方面，在一些任务或数据中，由易到难并不总是有效，有时困难优先反而会取得更好的效果\upcite{DBLP:conf/medprai/SurendranathJ18,zhang2018empirical}。实际上这和人类的直觉不太符合，一种合理的解释是课程学习更适合标签噪声、离群值较多或者是目标任务困难的场景，能提高模型的健壮性和收敛速度，而困难优先的策略则更适合数据集干净的场景\upcite{DBLP:conf/nips/ChangLM17}。
\vspace{0.5em}
\end{itemize}
Chapter14/Figures/figure-3vs.tex
......@@ -38,7 +38,7 @@
\draw [->,thick]([yshift=-1.2em]eos.south) to (eos.south);
\end{scope}
\begin{scope}[yshift=-1.55in]
\begin{scope}[yshift=-1.45in]
\node (encoder) at (0,0) {来自编码器的信息};
\node (aa)[decoder,anchor=east] at ([xshift=5.5cm]encoder.east) {};
\node (y1y2b)[rectangle,anchor=south,inner sep=0.25em,densely dashed,draw] at ([yshift=-2.6em]aa.south) {$y_1\;y_2$};
......@@ -66,13 +66,13 @@
\draw [->,thick]([yshift=-1.4em]eos.south) to ([yshift=-0.05em]eos.south);
\end{scope}
\begin{scope}[yshift=-3.1in]
\begin{scope}[yshift=-2.9in]
\node (encoder) at (0,0) {来自编码器的信息};
\node (aa)[decoder,anchor=east] at ([xshift=5.5cm]encoder.east) {非自回归解码器};
%\node (encoder)[decoder,anchor=west,fill=red!20] at ([xshift=-2cm]aa.west) {编码器};
\draw [->,thick](encoder.east) to (aa.west);
\node (label)[anchor=south] at ([xshift=-4em,yshift=-4.3em]aa.south) {\small{(c) 非自回归解码}};
\node (label)[anchor=south] at ([xshift=-4em,yshift=-2.3em]aa.south) {\small{(c) 非自回归解码}};
\node (y2a)[anchor=north] at ([xshift=-1.5em,yshift=2.5em]aa.north) {$y_2$};
\node (y1a)[anchor=east] at ([xshift=-3em]y2a.east) {$y_1$};
......
Chapter14/chapter14.tex
......@@ -36,7 +36,6 @@
\item 多模型集成推断。
\vspace{0.5em}
\end{itemize}
%----------------------------------------------------------------------------------------
% NEW SECTION
%----------------------------------------------------------------------------------------
......@@ -116,13 +115,11 @@
\parinterval 机器翻译有两种常用的推断方式\ \dash \ 自左向右推断和自右向左推断。自左向右推断符合现实世界中人类的语言使用规律，因为人在翻译一个句子时，总是习惯从句子开始的部分向后生成\footnote{有些语言中，文字是自右向左书写，这时自右向左推断更符合人类使用这种语言的习惯。}。不过，有时候人也会使用当前单词后面的译文信息。也就是说，翻译也需要“未来” 的文字信息。于是很容易想到使用自右向左的方式对译文进行生成。
\parinterval 以上两种推断方式在神经机器翻译中都有应用，对于源语言句子$\seq{x}=\{x_1,\dots,x_m\}$和目标语言句子$\seq{y}=\{y_1,\dots,y_n\}$，自左向右推断可以被描述为：
\begin{eqnarray}
\funp{P}(\seq{y}\vert\seq{x}) &=& \prod_{j=1}^n \funp{P}(y_j\vert\seq{y}_{<j},\seq{x})
\label{eq:14-1}
\end{eqnarray}
\parinterval 自右向左推断可以被描述为：
\begin{eqnarray}
\funp{P}(\seq{y}\vert\seq{x}) &=&\prod_{j=1}^n \funp{P}(y_{n+1-j}\vert\seq{y}_{>n+1-j},\seq{x})
\label{eq:14-2}
......@@ -155,7 +152,6 @@
\begin{itemize}
\vspace{0.5em}
\item {\small\sffamily\bfseries{长度惩罚因子}}。用译文长度来归一化翻译概率是最常用的方法：对于源语言句子$\seq{x}$和译文句子$\seq{y}$，模型得分$\textrm{score}(\seq{x},\seq{y})$的值会随着译文$\seq{y}$ 的长度增大而减小。为了避免此现象，可以引入一个长度惩罚函数$\textrm{lp}(\seq{y})$，并定义模型得分如公式\eqref{eq:14-12}所示：
\begin{eqnarray}
\textrm{score}(\seq{x},\seq{y}) &=& \frac{\log \funp{P}(\seq{y}\vert\seq{x})}{\textrm{lp}(\seq{y})}
\label{eq:14-12}
......@@ -180,7 +176,6 @@
%----------------------------------------------------------------------------------------------------
\vspace{0.5em}
\item {\small\sffamily\bfseries{译文长度范围约束}}。为了让译文的长度落在合理的范围内，神经机器翻译的推断也会设置一个译文长度约束\upcite{Vaswani2018Tensor2TensorFN,KleinOpenNMT}。令$[a,b]$表示一个长度范围，可以定义:
\begin{eqnarray}
a &=& \omega_{\textrm{low}}\cdot |\seq{x}| \label{eq:14-3}\\
b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
......@@ -194,12 +189,13 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\textrm{cp}(\seq{x},\seq{y}) &=& \beta \cdot \sum_{i=1}^{|\seq{x}|} \log(\textrm{min} (\sum_{j}^{|\seq{y}|} a_{ij} , 1))
\label{eq:14-6}
\end{eqnarray}
\noindent 其中，$\textrm{cp}(\seq{x},\seq{y}) $表示覆盖度模型，它度量了译文对源语言每个单词的覆盖程度。$\textrm{cp}(\seq{x},\seq{y}) $的定义中，$\beta$是一需要自行设置的超参数，$a_{ij}$表示源语言第$i$个位置与译文 第$j$个位置的注意力权重，这样$\sum \limits_{j}^{|\seq{y}|} a_{ij}$就可以用来衡量源语言第$i$个单词被翻译了“多少”，如果它大于1，表明翻译多了；如果小于1，表明翻译少了。公式\eqref{eq:14-6}会惩罚那些欠翻译的翻译假设。对覆盖度模型的一种改进形式是\upcite{li-etal-2018-simple}：
\noindent 其中，$\textrm{cp}(\seq{x},\seq{y}) $表示覆盖度模型，它度量了译文对源语言每个单词的覆盖程度。$\textrm{cp}(\seq{x},\seq{y}) $的定义中，$\beta$是一需要自行设置的超参数，$a_{ij}$表示源语言第$i$个位置与译文 第$j$个位置的注意力权重，这样$\sum \limits_{j}^{|\seq{y}|} a_{ij}$就可以用来衡量源语言第$i$个单词被翻译了“多少”，如果它大于1，表明翻译多了；如果小于1，表明翻译少了。公式\eqref{eq:14-6}会惩罚那些欠翻译的翻译假设。对覆盖度模型的一种改进形式是\upcite{li-etal-2018-simple}：
\begin{eqnarray}
\textrm{cp}(\seq{x},\seq{y}) &=& \sum_{i=1}^{|\seq{x}|} \log( \textrm{max} ( \sum_{j}^{|\seq{y}|} a_{ij},\beta))
\label{eq:14-7}
\end{eqnarray}
\noindent 公式\eqref{eq:14-7}将公式\eqref{eq:14-6}中的向下截断方式改为了向上截断。这样，模型可以对过翻译（或重复翻译）有更好的建模能力。不过，这个模型需要在开发集上细致地调整$\beta$，也带来了一定的额外工作量。此外，也可以将这种覆盖度单独建模并进行参数化，与翻译模型一同训练\upcite{Mi2016CoverageEM,TuModeling,Kazimi2017CoverageFC}。这样可以得到更加精细的覆盖度模型。
\vspace{0.5em}
\end{itemize}
......@@ -425,7 +421,6 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\parinterval 目前主流的神经机器翻译的推断是一种{\small\sffamily\bfseries{自回归翻译}}\index{自回归翻译}（Autoregressive Translation）\index{Autoregressive Translation}过程。所谓自回归是一种描述时间序列生成的方式：对于目标序列$\seq{y}=\{y_1,\dots,y_n\}$，如果$j$时刻状态$y_j$的生成依赖于之前的状态$\{y_1,\dots,y_{j-1}\}$，而且$y_j$与$\{y_1,\dots,y_{j-1}\}$构成线性关系，那么称目标序列$\seq{y}$的生成过程是自回归的。神经机器翻译借用了这个概念，但是并不要求$y_j$与$\{y_1,\dots,y_{j-1}\}$构成线性关系，\ref{sec:14-2-1}节提到的自左向右翻译模型和自右向左翻译模型都属于自回归翻译模型。自回归模型在机器翻译任务上也有很好的表现，特别是配合束搜索往往能够有效地寻找近似最优译文。但是，由于解码器的每个步骤必须顺序地而不是并行地运行，自回归翻译模型会阻碍不同译文单词生成的并行化。特别是在GPU 上，翻译的自回归性会大大降低计算的并行度和设备利用率。
\parinterval 对于这个问题，研究人员也考虑移除翻译的自回归性，进行{\small\sffamily\bfseries{非自回归翻译}}\index{非自回归翻译}（Non-Autoregressive Translation，NAT）\index{Non-Autoregressive Translation}\upcite{Gu2017NonAutoregressiveNM}。一个简单的非自回归翻译模型将问题建模为公式\eqref{eq:14-9}：
\begin{eqnarray}
\funp{P}(\seq{y}|\seq{x}) &=& \prod_{j=1}^n {\funp{P}(y_j|\seq{x})}
\label{eq:14-9}
......@@ -441,8 +436,6 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\parinterval 在介绍非自回归模型的具体结构之前，先来看看如何实现一个简单的非自回归翻译模型。这里用标准的Transformer来举例。首先为了一次性生成所有的词，需要丢弃解码器对未来信息屏蔽的矩阵，从而去掉模型的自回归性。此外，还要考虑生成译文的长度。在自回归模型中，每步的输入是上一步解码出的结果，当预测到终止符<eos>时，序列的生成就自动停止了，然而非自回归模型却没有这样的特性，因此还需要一个长度预测器来预测出其长度，之后再用这个长度得到每个位置的表示，将其作为解码器的输入，进而完成整个序列的生成。
\parinterval 图\ref{fig:14-12}对比了自回归翻译模型和简单的非自回归翻译模型。可以看到这种自回归翻译模型可以一次性生成完整的译文。不过，高并行性也带来了翻译品质的下降。比如，在IWSLT 英德等数据上的BLEU[\%] 值只有个位数，而现在最好的自回归模型已经能够达到30左右的BLEU得分。这是因为每个位置词的预测只依赖于源语言句子$\seq{x}$，使得预测不准确。需要注意的是，图\ref{fig:14-12}(b)中将位置编码作为非自回归模型解码器的输入只是一个最简单的例子，在真实的系统中，非自回归解码器的输入一般是拷贝的源语言句子词嵌入与位置编码的融合。
%----------------------------------------------------------------------
\begin{figure}[htp]
\centering
......@@ -452,6 +445,10 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\end{figure}
%----------------------------------------------------------------------
\parinterval 图\ref{fig:14-12}对比了自回归翻译模型和简单的非自回归翻译模型。可以看到这种自回归翻译模型可以一次性生成完整的译文。不过，高并行性也带来了翻译品质的下降。比如，在IWSLT 英德等数据上的BLEU[\%] 值只有个位数，而现在最好的自回归模型已经能够达到30左右的BLEU得分。这是因为每个位置词的预测只依赖于源语言句子$\seq{x}$，使得预测不准确。需要注意的是，图\ref{fig:14-12}(b)中将位置编码作为非自回归模型解码器的输入只是一个最简单的例子，在真实的系统中，非自回归解码器的输入一般是拷贝的源语言句子词嵌入与位置编码的融合。
\parinterval 完全独立地对每个词建模，会出现什么问题呢？来看一个例子，将汉语句子“干/得/好/！”翻译成英文，可以翻译成“Good job !”或者“Well done !”。假设生成这两种翻译的概率是相等的，即一半的概率是“Good job !”，另一半的概率是“Well done !”。由于非自回归模型的条件独立性假设，推断时第一个词“Good”和“Well”的概率是差不多大的，如果第二个词“job”和“done”的概率也差不多大，会使得模型生成出“Good done !”或者“Well job !”这样错误的翻译，如图\ref{fig:14-13}所示。这便是影响句子质量的关键问题，称之为{\small\sffamily\bfseries{多峰问题}}\index{多峰问题}（Multimodality Problem）\index{Multimodality Problem}\upcite{Gu2017NonAutoregressiveNM}。如何有效处理非自回归模型中的多峰问题 是提升非自回归模型质量的关键。
%----------------------------------------------------------------------
......@@ -630,7 +627,6 @@ b &=& \omega_{\textrm{high}}\cdot |\seq{x}| \label{eq:14-4}
\subsection{局部预测融合}
\parinterval 神经机器翻译模型对每个目标语言位置$j$的单词的概率分布进行预测\footnote{即对于目标语言词汇表中的每个单词$w_r$，计算$\funp{P}(y_j=w_r | \seq{y}_{<j},\seq{x})$。}，假设有$K$个神经机器翻译系统，那么每个系统$k$都可以独立计算这个概率分布，记为$\funp{P}_{k} (y_j | \seq{y}_{<j},\seq{x})$。于是，可以用如下方式融合这$K$个系统的预测：
\begin{eqnarray}
\funp{P}(y_{j} | \seq{y}_{<j},\seq{x}) &=& \sum_{k=1}^K \gamma_{k} \cdot \funp{P}_{k} (y_j | \seq{y}_{<j},\seq{x})
\label{eq:14-11}
......
Chapter15/Figures/figure-dynamic-linear-aggregation-network-structure.tex
......@@ -6,21 +6,21 @@
\node [anchor=west,rectangle, inner sep=0mm,minimum height=1.2em,minimum width=0em,rounded corners=5pt,thick] (n2) at ([xshift=3.5em,yshift=-0.5em]n1.east) {$\mathbi{X}$};
\node [anchor=west,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=3em,fill=orange!20,rounded corners=5pt,thick] (n3) at ([xshift=3.5em,yshift=0em]n2.east) {$\mathbi{x}_1$};
\node [anchor=west,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=3em,fill=orange!30,rounded corners=5pt,thick] (n3) at ([xshift=3.5em,yshift=0em]n2.east) {$\mathbi{x}_1$};
\node [anchor=west,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=3em,fill=orange!20,rounded corners=5pt,thick] (n4) at ([xshift=3.5em,yshift=0em]n3.east) {$\mathbi{x}_2$};
\node [anchor=west,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=3em,fill=orange!30,rounded corners=5pt,thick] (n4) at ([xshift=3.5em,yshift=0em]n3.east) {$\mathbi{x}_2$};
\node [anchor=west,rectangle, inner sep=0mm,minimum height=1.2em,minimum width=1em,rounded corners=5pt,thick] (n6) at ([xshift=1.5em,yshift=0em]n4.east) {$\ldots$};
\node [anchor=west,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=3em,fill=orange!20,rounded corners=5pt,thick] (n5) at ([xshift=3.5em,yshift=0em]n6.east) {$\mathbi{x}_l$};
\node [anchor=west,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=3em,fill=orange!30,rounded corners=5pt,thick] (n5) at ([xshift=3.5em,yshift=0em]n6.east) {$\mathbi{x}_l$};
\node [anchor=west,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=3em,fill=orange!20,rounded corners=5pt,thick] (n7) at ([xshift=1.5em,yshift=0em]n5.east) {$\mathbi{x}_{l+1}$};
\node [anchor=west,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=3em,fill=orange!30,rounded corners=5pt,thick] (n7) at ([xshift=1.5em,yshift=0em]n5.east) {$\mathbi{x}_{l+1}$};
\node [anchor=north,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=15em,fill=teal!17,rounded corners=5pt,thick] (n8) at ([xshift=0em,yshift=-3em]n4.south) {层正则化};
\node [anchor=north,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=15em,fill=teal!30,rounded corners=5pt,thick] (n8) at ([xshift=0em,yshift=-3em]n4.south) {层正则化};
\node [anchor=north,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=15em,fill=purple!17,rounded corners=5pt,thick] (n9) at ([xshift=0em,yshift=-1em]n8.south) {$\mathbi{X}\ \quad \mathbi{h}^1\ \quad \mathbi{h}^2\quad \ldots \quad\ \mathbi{h}^l$};
\node [anchor=north,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=15em,fill=purple!30,rounded corners=5pt,thick] (n9) at ([xshift=0em,yshift=-1em]n8.south) {$\mathbi{X}\ \quad \mathbi{h}^1\ \quad \mathbi{h}^2\quad \ldots \quad\ \mathbi{h}^l$};
\node [anchor=north,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=15em,fill=teal!17,rounded corners=5pt,thick] (n10) at ([xshift=0em,yshift=-2em]n9.south) {权重累加};
\node [anchor=north,rectangle,draw, inner sep=0mm,minimum height=1.2em,minimum width=15em,fill=teal!30,rounded corners=5pt,thick] (n10) at ([xshift=0em,yshift=-2em]n9.south) {权重累加};
\node [anchor=west,rectangle, inner sep=0mm,minimum height=1.2em, rounded corners=5pt,thick] (n11) at ([xshift=0em,yshift=-4.5em]n1.west) {聚合网络};
......
Chapter15/Figures/figure-encoder-of-bidirectional-tree-structure.tex
......@@ -2,10 +2,10 @@
\begin{tikzpicture}
\begin{scope}
\tikzstyle{hnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=3em,rounded corners=5pt,fill=green!20]
\tikzstyle{tnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=3em,rounded corners=5pt,fill=red!20]
\tikzstyle{fnoder}=[rectangle,inner sep=0mm,minimum height=2.4em,minimum width=6.8em,draw,dashed,very thick,rounded corners=5pt,red!40]
\tikzstyle{fnodeg}=[rectangle,inner sep=0mm,minimum height=2.4em,minimum width=6.8em,draw,dashed,very thick,rounded corners=5pt,green!40]
\tikzstyle{hnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=3em,rounded corners=5pt,fill=green!30,draw,thick]
\tikzstyle{tnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=3em,rounded corners=5pt,fill=red!30,draw,thick]
\tikzstyle{fnoder}=[rectangle,inner sep=0em,minimum height=2.6em,minimum width=6.8em,draw,dashed,very thick,rounded corners=5pt,red!50]
\tikzstyle{fnodeg}=[rectangle,inner sep=0em,minimum height=2.6em,minimum width=6.8em,draw,dashed,very thick,rounded corners=5pt,green!50]
\node [anchor=south west,fnodeg] (f1) at (0,0) {};
\node [anchor=west,hnode] (n1) at ([xshift=0.2em,yshift=0em]f1.west) {$\mathbi{h}_1^{\textrm{up}}$};
......
Chapter15/Figures/figure-encoder-structure-of-transformer-model-optimized-by-nas.tex
\begin{tikzpicture}
\tikzstyle{unit}=[draw,rounded corners=2pt,drop shadow,font=\tiny]
\tikzstyle{unit}=[draw,rounded corners=2pt,drop shadow,font=\tiny,thick]
%left
\begin{scope}
\foreach \x/\d in {1/2em, 2/8em}
\node[unit,fill=yellow!20] at (0,\d) (ln_\x) {层正则化};
\node[unit,fill=yellow!30] at (0,\d) (ln_\x) {层正则化};
\foreach \x/\d in {1/4em}
\node[unit,fill=green!20] at (0,\d) (sa_\x) {8头自注意力：512};
\node[unit,fill=green!30] at (0,\d) (sa_\x) {8头自注意力：512};
\foreach \x/\d in {1/6em, 2/16em}
\node[draw,circle,minimum size=1em,inner sep=1pt] at (0,\d) (add_\x) {\scriptsize\bfnew{+}};
\foreach \x/\d in {2/14em}
\node[unit,fill=red!20] at (0,\d) (conv_\x) {卷积$1 \times 1$：512};
\node[unit,fill=red!30] at (0,\d) (conv_\x) {卷积$1 \times 1$：512};
\foreach \x/\d in {1/10em}
\node[unit,fill=red!20] at (0,\d) (conv_\x) {卷积$1 \times 1$：2048};
\node[unit,fill=red!30] at (0,\d) (conv_\x) {卷积$1 \times 1$：2048};
\foreach \x/\d in {1/12em}
\node[unit,fill=blue!20] at (0,\d) (relu_\x) {RELU};
\node[unit,fill=blue!30] at (0,\d) (relu_\x) {RELU};
\draw[->,thick] ([yshift=-1.4em]ln_1.-90) -- ([yshift=-0.1em]ln_1.-90);
\draw[->,thick] ([yshift=0.1em]ln_1.90) -- ([yshift=-0.1em]sa_1.-90);
......@@ -44,17 +44,17 @@
\foreach \x/\d in {1/2em, 2/8em, 3/16em}
\node[unit,fill=yellow!20] at (0,\d) (ln_\x) {层正则化};
\node[unit,fill=yellow!30] at (0,\d) (ln_\x) {层正则化};
\foreach \x/\d in {1/6em, 2/14em, 3/20em}
\node[draw,circle,minimum size=1em,inner sep=1pt] at (0,\d) (add_\x) {\scriptsize\bfnew{+}};
\node[unit,fill=red!20] at (0,4em) (glu_1) {门控线性单元：512};
\node[unit,fill=red!20] at (-3em,10em) (conv_1) {卷积$1 \times 1$：2048};
\node[unit,fill=cyan!20] at (3em,10em) (conv_2) {卷积$3 \times 1$：256};
\node[unit,fill=blue!20] at (-3em,12em) (relu_1) {RELU};
\node[unit,fill=blue!20] at (3em,12em) (relu_2) {RELU};
\node[unit,fill=cyan!20] at (0em,18em) (conv_3) {Sep卷积$9 \times 1$：256};
\node[unit,fill=red!30] at (0,4em) (glu_1) {门控线性单元：512};
\node[unit,fill=red!30] at (-3em,10em) (conv_1) {卷积$1 \times 1$：2048};
\node[unit,fill=cyan!30] at (3em,10em) (conv_2) {卷积$3 \times 1$：256};
\node[unit,fill=blue!30] at (-3em,12em) (relu_1) {RELU};
\node[unit,fill=blue!30] at (3em,12em) (relu_2) {RELU};
\node[unit,fill=cyan!30] at (0em,18em) (conv_3) {Sep卷积$9 \times 1$：256};
\draw[->,thick] ([yshift=-1.4em]ln_1.-90) -- ([yshift=-0.1em]ln_1.-90);
......@@ -81,15 +81,15 @@
\node[font=\scriptsize,align=center] at (0em, -1.5em){(b) 使用结构搜索方法优化后的 \\ Transformer编码器中若干块的结构};
\node[minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=blue!20] (act) at (8em, 20em){};
\node[minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=blue!30] (act) at (8em, 20em){};
\node[anchor=west,font=\footnotesize] at ([xshift=0.1em]act.east){激活函数};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=yellow!20] (nor) at ([yshift=-0.6em]act.south){};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=yellow!30] (nor) at ([yshift=-0.6em]act.south){};
\node[anchor=west,font=\footnotesize] at ([xshift=0.1em]nor.east){层正则化};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=cyan!20] (wc) at ([yshift=-0.6em]nor.south){};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=cyan!30] (wc) at ([yshift=-0.6em]nor.south){};
\node[anchor=west,font=\footnotesize] at ([xshift=0.1em]wc.east){宽卷积};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=green!20] (at) at ([yshift=-0.6em]wc.south){};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=green!30] (at) at ([yshift=-0.6em]wc.south){};
\node[anchor=west,font=\footnotesize] (tag) at ([xshift=0.1em]at.east){注意力机制};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=red!20] (nsl) at ([yshift=-0.6em]at.south){};
\node[anchor=north,minimum size=0.8em,inner sep=0pt,rounded corners=1pt,draw,fill=red!30] (nsl) at ([yshift=-0.6em]at.south){};
\node[anchor=west,font=\footnotesize] at ([xshift=0.1em]nsl.east){非空间层};
\begin{pgfonlayer}{background}
......
Chapter15/Figures/figure-encoder-tree-structure-modeling.tex
......@@ -2,20 +2,20 @@
\begin{tikzpicture}
\begin{scope}
\tikzstyle{hnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=4.5em,rounded corners=5pt,fill=green!30]
\tikzstyle{tnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=4.5em,rounded corners=5pt,fill=red!30]
\tikzstyle{hnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=4.5em,rounded corners=5pt,fill=green!30,draw,thick]
\tikzstyle{tnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=4.5em,rounded corners=5pt,fill=red!30,draw,thick]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.4em,minimum width=4.4em]
\node [anchor=south west,hnode] (n1) at (0,0) {$\mathbi{h}_1$};
\node [anchor=west,hnode] (n2) at ([xshift=1em,yshift=0em]n1.east) {$\mathbi{h}_2$};
\node [anchor=west,hnode] (n3) at ([xshift=1em,yshift=0em]n2.east) {$\mathbi{h}_3$};
\node [anchor=west,hnode] (n4) at ([xshift=1em,yshift=0em]n3.east) {$\cdots$};
\node [anchor=west,hnode] (n5) at ([xshift=1em,yshift=0em]n4.east) {$\mathbi{h}_m$};
\node [anchor=south,tnode] (t1) at ([xshift=2.8em,yshift=1em]n1.north) {$\mathbi{h}_{m+1}$};
\node [anchor=south,tnode] (t2) at ([xshift=2.8em,yshift=1em]t1.north) {$\mathbi{h}_{m+2}$};
\node [anchor=south,tnode] (t3) at ([xshift=2.8em,yshift=1em]t2.north) {$\cdots$};
\node [anchor=south,tnode] (t4) at ([xshift=2.8em,yshift=1em]t3.north) {$\mathbi{h}_{2m-1}$};
\node [anchor=west,hnode] (n2) at ([xshift=2em,yshift=0em]n1.east) {$\mathbi{h}_2$};
\node [anchor=west,hnode] (n3) at ([xshift=2em,yshift=0em]n2.east) {$\mathbi{h}_3$};
\node [anchor=west,hnode] (n4) at ([xshift=2em,yshift=0em]n3.east) {$\cdots$};
\node [anchor=west,hnode] (n5) at ([xshift=2em,yshift=0em]n4.east) {$\mathbi{h}_m$};
\node [anchor=south,tnode] (t1) at ([xshift=3.3em,yshift=1em]n1.north) {$\mathbi{h}_{m+1}$};
\node [anchor=south,tnode] (t2) at ([xshift=3.3em,yshift=1em]t1.north) {$\mathbi{h}_{m+2}$};
\node [anchor=south,tnode] (t3) at ([xshift=3.3em,yshift=1em]t2.north) {$\cdots$};
\node [anchor=south,tnode] (t4) at ([xshift=3.3em,yshift=1em]t3.north) {$\mathbi{h}_{2m-1}$};
\draw [->,thick] ([xshift=0em,yshift=0em]n1.east) -- ([xshift=0em,yshift=0em]n2.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n2.east) -- ([xshift=0em,yshift=0em]n3.west);
......
Chapter15/Figures/figure-evolution-and-change-of-ml-methods.tex
\begin{tikzpicture}
\tikzstyle{opnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=4em,rounded corners=5pt,fill=teal!17]
\tikzstyle{opnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=4em,rounded corners=5pt,fill=teal!30]
\tikzstyle{cnode}=[circle,draw,minimum size=1.2em]
\tikzstyle{mnode}=[rectangle,inner sep=0mm,minimum height=5em,minimum width=11em,rounded corners=5pt,fill=yellow!20]
\tikzstyle{mnode}=[rectangle,inner sep=0mm,minimum height=5em,minimum width=11em,rounded corners=5pt,fill=yellow!30]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.5em]
\begin{pgfonlayer}{background}
......@@ -10,14 +10,14 @@
\node[anchor=west,mnode] (m2) at ([xshift=1em,yshift=0em]m1.east){};
\node[anchor=west,mnode] (m3) at ([xshift=1em,yshift=0em]m2.east){};
\node[anchor=north west,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=3.5em,rounded corners=5pt,fill=blue!20] (ml1) at ([xshift=0em,yshift=-0.5em]m1.south west){};
\node[anchor=west,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=3.5em,rounded corners=5pt,fill=ugreen!20] (ml2) at ([xshift=0.25em,yshift=0em]ml1.east){};
\node[anchor=north east,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=3.5em,rounded corners=5pt,fill=red!20] (ml3) at ([xshift=0em,yshift=-0.5em]m1.south east){};
\node[anchor=north west,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=3.5em,rounded corners=5pt,fill=blue!30] (ml1) at ([xshift=0em,yshift=-0.5em]m1.south west){};
\node[anchor=west,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=3.5em,rounded corners=5pt,fill=green!30] (ml2) at ([xshift=0.25em,yshift=0em]ml1.east){};
\node[anchor=north east,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=3.5em,rounded corners=5pt,fill=red!30] (ml3) at ([xshift=0em,yshift=-0.5em]m1.south east){};
\node[anchor=north west,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=5.25em,rounded corners=5pt,fill=blue!20] (mc1) at ([xshift=0em,yshift=-0.5em]m2.south west){};
\node[anchor=north east,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=5.25em,rounded corners=5pt,fill=red!20] (mc2) at ([xshift=0em,yshift=-0.5em]m2.south east){};
\node[anchor=north west,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=5.25em,rounded corners=5pt,fill=blue!30] (mc1) at ([xshift=0em,yshift=-0.5em]m2.south west){};
\node[anchor=north east,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=5.25em,rounded corners=5pt,fill=red!30] (mc2) at ([xshift=0em,yshift=-0.5em]m2.south east){};
\node[anchor=north,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=11em,rounded corners=5pt,fill=blue!20] (mr1) at ([xshift=0em,yshift=-0.5em]m3.south){};
\node[anchor=north,rectangle,inner sep=0mm,minimum height=2.6em,minimum width=11em,rounded corners=5pt,fill=blue!30] (mr1) at ([xshift=0em,yshift=-0.5em]m3.south){};
\end{pgfonlayer}
......
Chapter15/Figures/figure-introducing-rnn-mechanism-into-transformer.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
%%% 调序模型1：基于距离的调序
\begin{center}
\begin{tikzpicture}
\tikzstyle{tnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=4em,rounded corners=5pt,thick,draw,fill=teal!20]
\tikzstyle{stnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=4em,rounded corners=5pt,thick,fill=red!20,draw]
\tikzstyle{rnnnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=5em,rounded corners=5pt,thick,fill=green!20,draw]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=2em,minimum width=4em]
\begin{scope}[]
\node [anchor=west,rnnnode] (r1) at (0, 0) {循环单元};
\node [anchor=south,rnnnode] (r2) at ([xshift=0em,yshift=1em]r1.north){循环单元};
\node [anchor=south] (r3) at ([xshift=0em,yshift=1em]r2.north){$\cdots$};
\node [anchor=south,rnnnode] (r4) at ([xshift=0em,yshift=1em]r3.north){循环单元};
\node [anchor=east,wnode,font=\footnotesize,align=left,minimum width=3em] (wr1) at ([xshift=-1em,yshift=0em]r1.west) {1时刻\\ 输入};
\node [anchor=east,wnode,font=\footnotesize,align=left,minimum width=3em] (wr2) at ([xshift=-1em,yshift=0em]r2.west) {2时刻\\ 输入};
\node [anchor=east,wnode,font=\footnotesize,align=left,minimum width=3em] (wr3) at ([xshift=-1em,yshift=0em]r4.west) {$n$时刻\\ 输入};
\node [anchor=north,wnode] (input) at ([xshift=0em,yshift=-1em]r1.south) {$\mathbi{h}_0$};
\node [anchor=south,wnode] (output) at ([xshift=0em,yshift=1em]r4.north) {输出};
\draw[->,very thick] ([xshift=-0.3em,yshift=-1em]wr1.west)--([xshift=-0.3em,yshift=1em]wr3.west);
\draw[->,thick] ([xshift=0em,yshift=0em]input.north)--([xshift=0em,yshift=0em]r1.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r1.north)--([xshift=0em,yshift=0em]r2.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r2.north)--([xshift=0em,yshift=0em]r3.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r3.north)--([xshift=0em,yshift=0em]r4.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r4.north)--([xshift=0em,yshift=0em]output.south);
\draw[->,thick] ([xshift=0em,yshift=0em]wr1.east)--([xshift=0em,yshift=0em]r1.west);
\draw[->,thick] ([xshift=0em,yshift=0em]wr2.east)--([xshift=0em,yshift=0em]r2.west);
\draw[->,thick] ([xshift=0em,yshift=0em]wr3.east)--([xshift=0em,yshift=0em]r4.west);
\node [anchor=north,font=\small] (label) at ([xshift=-3em,yshift=-0.7em]input.south) {(a)RNN};
\end{scope}
\begin{scope}[xshift=1.85in]
\node [anchor=west,stnode] (r1) at (0, 0) {第1层};
\node [anchor=south,tnode] (r2) at ([xshift=0em,yshift=1em]r1.north){第2层};
\node [anchor=south] (r3) at ([xshift=0em,yshift=1em]r2.north){$\cdots$};
\node [anchor=south,tnode] (r4) at ([xshift=0em,yshift=1em]r3.north){第$n$层};
\node [anchor=east,wnode,font=\footnotesize,minimum width=3em] (wr1) at ([xshift=-0.3em,yshift=0em]r1.west) {1时刻};
\node [anchor=east,wnode,font=\footnotesize,minimum width=3em] (wr2) at ([xshift=-0.3em,yshift=0em]r2.west) {2时刻};
\node [anchor=east,wnode,font=\footnotesize,minimum width=3em] (wr3) at ([xshift=-0.3em,yshift=0em]r4.west) {$n$时刻};
\node [anchor=north,wnode] (input) at ([xshift=0em,yshift=-1em]r1.south) {$\mathbi{h}_0$};
\node [anchor=south,wnode] (output) at ([xshift=0em,yshift=1em]r4.north) {输出};
\draw[->,very thick] ([xshift=-0.3em,yshift=-1em]wr1.west)--([xshift=-0.3em,yshift=1em]wr3.west);
\draw[->,thick] ([xshift=0em,yshift=0em]input.north)--([xshift=0em,yshift=0em]r1.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r1.north)--([xshift=0em,yshift=0em]r2.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r2.north)--([xshift=0em,yshift=0em]r3.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r3.north)--([xshift=0em,yshift=0em]r4.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r4.north)--([xshift=0em,yshift=0em]output.south);
\node [anchor=north,font=\small] (label) at ([xshift=-1.5em,yshift=-0.7em]input.south) {(b)原始Transformer模型};
\end{scope}
\begin{scope}[xshift=3.9in]
\node [anchor=west,stnode] (r1) at (0, 0) {第1层};
\node [anchor=south,stnode] (r2) at ([xshift=0em,yshift=1em]r1.north){第2层};
\node [anchor=south] (r3) at ([xshift=0em,yshift=1em]r2.north){$\cdots$};
\node [anchor=south,stnode] (r4) at ([xshift=0em,yshift=1em]r3.north){第$n$层};
\node [anchor=east,wnode,font=\footnotesize,align=left] (wr1) at ([xshift=-1em,yshift=0em]r1.west) {1时刻\\ 编码向量};
\node [anchor=east,wnode,font=\footnotesize,align=left] (wr2) at ([xshift=-1em,yshift=0em]r2.west) {2时刻\\ 编码向量};
\node [anchor=east,wnode,font=\footnotesize,align=left] (wr3) at ([xshift=-1em,yshift=0em]r4.west) {$n$时刻\\ 编码向量};
\node [anchor=north,wnode] (input) at ([xshift=0em,yshift=-1em]r1.south) {$\mathbi{h}_0$};
\node [anchor=south,wnode] (output) at ([xshift=0em,yshift=1em]r4.north) {输出};
\draw[->,very thick] ([xshift=-0.3em,yshift=-1em]wr1.west)--([xshift=-0.3em,yshift=1em]wr3.west);
\draw[->,thick] ([xshift=0em,yshift=0em]input.north)--([xshift=0em,yshift=0em]r1.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r1.north)--([xshift=0em,yshift=0em]r2.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r2.north)--([xshift=0em,yshift=0em]r3.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r3.north)--([xshift=0em,yshift=0em]r4.south);
\draw[->,thick] ([xshift=0em,yshift=0em]r4.north)--([xshift=0em,yshift=0em]output.south);
\draw[->,thick] ([xshift=0em,yshift=0em]wr1.east)--([xshift=0em,yshift=0em]r1.west);
\draw[->,thick] ([xshift=0em,yshift=0em]wr2.east)--([xshift=0em,yshift=0em]r2.west);
\draw[->,thick] ([xshift=0em,yshift=0em]wr3.east)--([xshift=0em,yshift=0em]r4.west);
\node [anchor=north,font=\small,align=left] (label) at ([xshift=-3em,yshift=-0.7em]input.south) {(c)共享权重的\\ Transformer模型};
\end{scope}
\end{tikzpicture}
\end{center}
\ No newline at end of file
Chapter15/Figures/figure-layer-fusion-method-2d.tex
......@@ -2,9 +2,9 @@
\begin{tikzpicture}
\begin{scope}
\tikzstyle{lnode}=[rectangle,inner sep=0mm,minimum height=1.5em,minimum width=3.5em,rounded corners=2pt,draw]
\tikzstyle{snode}=[rectangle,inner sep=0mm,minimum height=1.5em,minimum width=0.8em,rounded corners=2pt,draw]
\tikzstyle{vlnode}=[rectangle,inner sep=0mm,minimum height=1em,minimum width=5em,rounded corners=2pt,draw]
\tikzstyle{lnode}=[rectangle,inner sep=0mm,minimum height=1.5em,minimum width=3em,rounded corners=2pt,draw,thick]
\tikzstyle{snode}=[rectangle,inner sep=0mm,minimum height=1.5em,minimum width=0.8em,rounded corners=2pt,draw,thick]
\tikzstyle{vlnode}=[rectangle,inner sep=0mm,minimum height=1em,minimum width=4em,rounded corners=2pt,draw,thick]
\node [anchor=west,lnode] (n1) at (0, 0) {$\mathbi{h}^3$};
......@@ -13,53 +13,53 @@
\node [anchor=south] (d1) at ([xshift=0em,yshift=0.2em]n1.north) {1D};
\node [anchor=west,lnode] (n4) at ([xshift=1.2em,yshift=0em]n1.east) {};
\node [anchor=west,lnode] (n5) at ([xshift=1.2em,yshift=0em]n2.east) {};
\node [anchor=west,lnode] (n6) at ([xshift=1.2em,yshift=0em]n3.east) {};
\node [anchor=west,lnode] (n4) at ([xshift=1em,yshift=0em]n1.east) {};
\node [anchor=west,lnode] (n5) at ([xshift=1em,yshift=0em]n2.east) {};
\node [anchor=west,lnode] (n6) at ([xshift=1em,yshift=0em]n3.east) {};
\node [anchor=south,lnode] (n7) at ([xshift=0em,yshift=1em]n4.north) {$\mathbi{W}_1$};
\node [anchor=west] (sig) at ([xshift=0em,yshift=0.4em]n5.east) {$\sigma$};
\node [anchor=west,snode,fill=purple!30] (nc11) at ([xshift=1.2em,yshift=0em]n4.east) {};
\node [anchor=west,snode,fill=yellow!30] (nc12) at ([xshift=0em,yshift=0em]nc11.east) {};
\node [anchor=west,snode,fill=red!30] (nc13) at ([xshift=0em,yshift=0em]nc12.east) {};
\node [anchor=west,snode,fill=blue!30] (nc14) at ([xshift=0em,yshift=0em]nc13.east) {};
\node [anchor=west,snode,font=\footnotesize,fill=ugreen!30] (nc15) at ([xshift=0em,yshift=0em]nc14.east) {$\mathbi{o}_5^3$};
\node [anchor=west,snode,fill=yellow!30] (nc12) at ([xshift=-0.06em,yshift=0em]nc11.east) {};
\node [anchor=west,snode,fill=red!30] (nc13) at ([xshift=-0.06em,yshift=0em]nc12.east) {};
\node [anchor=west,snode,fill=blue!30] (nc14) at ([xshift=-0.06em,yshift=0em]nc13.east) {};
\node [anchor=west,snode,font=\footnotesize,fill=ugreen!30] (nc15) at ([xshift=-0.06em,yshift=0em]nc14.east) {$\mathbi{o}_5^3$};
\node [anchor=west,snode,fill=purple!30] (nc21) at ([xshift=1.2em,yshift=0em]n5.east) {};
\node [anchor=west,snode,fill=yellow!30] (nc22) at ([xshift=0em,yshift=0em]nc21.east) {};
\node [anchor=west,snode,fill=red!30] (nc23) at ([xshift=0em,yshift=0em]nc22.east) {};
\node [anchor=west,snode,fill=blue!30] (nc24) at ([xshift=0em,yshift=0em]nc23.east) {};
\node [anchor=west,snode,font=\footnotesize,fill=ugreen!30] (nc25) at ([xshift=0em,yshift=0em]nc24.east) {$\mathbi{o}_5^2$};
\node [anchor=west,snode,fill=yellow!30] (nc22) at ([xshift=-0.06em,yshift=0em]nc21.east) {};
\node [anchor=west,snode,fill=red!30] (nc23) at ([xshift=-0.06em,yshift=0em]nc22.east) {};
\node [anchor=west,snode,fill=blue!30] (nc24) at ([xshift=-0.06em,yshift=0em]nc23.east) {};
\node [anchor=west,snode,font=\footnotesize,fill=ugreen!30] (nc25) at ([xshift=-0.06em,yshift=0em]nc24.east) {$\mathbi{o}_5^2$};
\node [anchor=west,snode,fill=purple!30] (nc31) at ([xshift=1.2em,yshift=0em]n6.east) {};
\node [anchor=west,snode,fill=yellow!30] (nc32) at ([xshift=0em,yshift=0em]nc31.east) {};
\node [anchor=west,snode,fill=red!30] (nc33) at ([xshift=0em,yshift=0em]nc32.east) {};
\node [anchor=west,snode,fill=blue!30] (nc34) at ([xshift=0em,yshift=0em]nc33.east) {};
\node [anchor=west,snode,font=\footnotesize,fill=ugreen!30] (nc35) at ([xshift=0em,yshift=0em]nc34.east) {$\mathbi{o}_5^1$};
\node [anchor=west,snode,fill=yellow!30] (nc32) at ([xshift=-0.06em,yshift=0em]nc31.east) {};
\node [anchor=west,snode,fill=red!30] (nc33) at ([xshift=-0.06em,yshift=0em]nc32.east) {};
\node [anchor=west,snode,fill=blue!30] (nc34) at ([xshift=-0.06em,yshift=0em]nc33.east) {};
\node [anchor=west,snode,font=\footnotesize,fill=ugreen!30] (nc35) at ([xshift=-0.06em,yshift=0em]nc34.east) {$\mathbi{o}_5^1$};
\node [anchor=south,lnode] (n8) at ([xshift=0em,yshift=1em]nc13.north) {$\mathbi{W}_2$};
\node [anchor=west,font=\footnotesize] (n9) at ([xshift=0.1em,yshift=0.5em]nc25.east) {Softmax};
\node [anchor=west,snode,fill=purple!30] (ns11) at ([xshift=3.5em,yshift=0em]nc15.east) {};
\node [anchor=west,snode,fill=yellow!30] (ns12) at ([xshift=0em,yshift=0em]ns11.east) {};
\node [anchor=west,snode,fill=red!30] (ns13) at ([xshift=0em,yshift=0em]ns12.east) {};
\node [anchor=west,snode,fill=blue!30] (ns14) at ([xshift=0em,yshift=0em]ns13.east) {};
\node [anchor=west,snode,font=\tiny,fill=ugreen!30] (ns15) at ([xshift=0em,yshift=0em]ns14.east) {0.3};
\node [anchor=west,snode,fill=yellow!30] (ns12) at ([xshift=-0.06em,yshift=0em]ns11.east) {};
\node [anchor=west,snode,fill=red!30] (ns13) at ([xshift=-0.06em,yshift=0em]ns12.east) {};
\node [anchor=west,snode,fill=blue!30] (ns14) at ([xshift=-0.06em,yshift=0em]ns13.east) {};
\node [anchor=west,snode,font=\tiny,fill=ugreen!30] (ns15) at ([xshift=-0.06em,yshift=0em]ns14.east) {0.3};
\node [anchor=west,snode,fill=purple!30] (ns21) at ([xshift=3.5em,yshift=0em]nc25.east) {};
\node [anchor=west,snode,fill=yellow!30] (ns22) at ([xshift=0em,yshift=0em]ns21.east) {};
\node [anchor=west,snode,fill=red!30] (ns23) at ([xshift=0em,yshift=0em]ns22.east) {};
\node [anchor=west,snode,fill=blue!30] (ns24) at ([xshift=0em,yshift=0em]ns23.east) {};
\node [anchor=west,snode,font=\tiny,fill=ugreen!30] (ns25) at ([xshift=0em,yshift=0em]ns24.east) {0.2};
\node [anchor=west,snode,fill=yellow!30] (ns22) at ([xshift=-0.06em,yshift=0em]ns21.east) {};
\node [anchor=west,snode,fill=red!30] (ns23) at ([xshift=-0.06em,yshift=0em]ns22.east) {};
\node [anchor=west,snode,fill=blue!30] (ns24) at ([xshift=-0.06em,yshift=0em]ns23.east) {};
\node [anchor=west,snode,font=\tiny,fill=ugreen!30] (ns25) at ([xshift=-0.06em,yshift=0em]ns24.east) {0.2};
\node [anchor=west,snode,fill=purple!30] (ns31) at ([xshift=3.5em,yshift=0em]nc35.east) {};
\node [anchor=west,snode,fill=yellow!30] (ns32) at ([xshift=0em,yshift=0em]ns31.east) {};
\node [anchor=west,snode,fill=red!30] (ns33) at ([xshift=0em,yshift=0em]ns32.east) {};
\node [anchor=west,snode,fill=blue!30] (ns34) at ([xshift=0em,yshift=0em]ns33.east) {};
\node [anchor=west,snode,font=\tiny,fill=ugreen!30] (ns35) at ([xshift=0em,yshift=0em]ns34.east) {0.5};
\node [anchor=west,snode,fill=yellow!30] (ns32) at ([xshift=-0.06em,yshift=0em]ns31.east) {};
\node [anchor=west,snode,fill=red!30] (ns33) at ([xshift=-0.06em,yshift=0em]ns32.east) {};
\node [anchor=west,snode,fill=blue!30] (ns34) at ([xshift=-0.06em,yshift=0em]ns33.east) {};
\node [anchor=west,snode,font=\tiny,fill=ugreen!30] (ns35) at ([xshift=-0.06em,yshift=0em]ns34.east) {0.5};
\node [anchor=west,vlnode,fill=purple!30] (ln1) at ([xshift=3.5em,yshift=-1.5em]ns15.east) {};
\node [anchor=north west,vlnode,fill=yellow!30] (ln2) at ([xshift=-0.4em,yshift=-0.4em]ln1.north west) {};
......@@ -71,7 +71,7 @@
\node [anchor=south,vlnode,rotate=-90] (ffn) at ([xshift=2em,yshift=0em]ln3.east) {FFN};
\node [anchor=west,rectangle,inner sep=0mm,minimum height=3.5em,minimum width=0.8em,rounded corners=2pt,draw] (fn) at ([xshift=1.5em,yshift=0em]ffn.north) {$\mathbi{g}$};
\node [anchor=west,rectangle,inner sep=0mm,minimum height=3.5em,minimum width=0.8em,rounded corners=2pt,draw,thick] (fn) at ([xshift=1em,yshift=0em]ffn.north) {$\mathbi{g}$};
\draw [->,thick] ([xshift=0em,yshift=0em]n1.east) -- ([xshift=0em,yshift=0em]n4.west);
......@@ -99,7 +99,7 @@
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]n3.south west) to node [midway,font=\small,align=center,xshift=0em,yshift=-0.8em] {$d_{\textrm{model}}$} ([xshift=0em]n3.south east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]n6.south west) to node [midway,font=\small,align=center,xshift=0em,yshift=-0.8em] {$d_{\rm a}$} ([xshift=0em]n6.south east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]n7.north west) to node [midway,font=\small,align=center,xshift=-1.4em,yshift=-0em] {$d_{\textrm{model}}$} ([xshift=0em]n7.south west);
\draw [decorate,decoration={brace}] ([xshift=0em]n7.north west) to node [midway,font=\small,align=center,xshift=0em,yshift=0.7em] {$d_{\textrm{model}}$} ([xshift=0em]n7.north east);
\draw [decorate,decoration={brace}] ([xshift=0em]n7.north west) to node [midway,font=\small,align=center,xshift=0em,yshift=0.7em] {$d_{\rm a}$} ([xshift=0em]n7.north east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]n8.north west) to node [midway,font=\small,align=center,xshift=-0.8em,yshift=-0em] {$d_{\rm a}$} ([xshift=0em]n8.south west);
\draw [decorate,decoration={brace}] ([xshift=0em]n8.north west) to node [midway,font=\small,align=center,xshift=0em,yshift=0.8em] {$n_{\rm hop}$} ([xshift=0em]n8.north east);
\draw [decorate,decoration={brace,mirror}] ([xshift=0em]nc31.south west) to node [midway,font=\small,align=center,xshift=0em,yshift=-0.8em] {$n_{\rm hop}$} ([xshift=0em]nc35.south east);
......
Chapter15/Figures/figure-learning-rate.tex
......@@ -15,7 +15,7 @@
]
\addplot[red,line width=1.25pt] coordinates {(0,0) (1.6,2) (1.8,1.888) (2,1.787) (2.5,1.606) (3,1.462) (3.5,1.3549) (4,1.266) (4.5,1.193) (5,1.131)};
\addlegendentry{\scriptsize 原始学习率}
\addlegendentry{\scriptsize 原始的学习率}
%\addplot[red,line width=1.25pt] coordinates {(0,0) (8000,0.002) (10000,0.00179) (12000,0.00163) (12950,0.001572)};
\addplot[blue,line width=1.25pt] coordinates {(0,0) (0.8,2) (0.9906,1.7983)};
%\addplot[red,line width=1.25pt] coordinates {(0,0) (8000,0.002) (9906,0.0017983)};
......
Chapter15/Figures/figure-light-weight-transformer-module.tex
......@@ -3,9 +3,9 @@
\begin{center}
\begin{tikzpicture}
\tikzstyle{manode}=[rectangle,inner sep=0mm,minimum height=4em,minimum width=4em,rounded corners=5pt,thick,draw,fill=blue!15]
\tikzstyle{ffnnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=6em,rounded corners=5pt,thick,fill=red!15,draw]
\tikzstyle{ebnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=10em,rounded corners=5pt,thick,fill=ugreen!15,draw]
\tikzstyle{manode}=[rectangle,inner sep=0mm,minimum height=4em,minimum width=4em,rounded corners=5pt,thick,draw,fill=blue!30]
\tikzstyle{ffnnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=6em,rounded corners=5pt,thick,fill=red!30,draw]
\tikzstyle{ebnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=10em,rounded corners=5pt,thick,fill=green!30,draw]
\begin{scope}[]
......@@ -15,7 +15,8 @@
\node [anchor=south east,manode] (c1) at ([xshift=0em,yshift=1em]e1.north east){Conv};
\node [anchor=south west,ebnode] (e2) at ([xshift=0em,yshift=1em]a1.north west){Embedding};
\node [anchor=south,draw,circle,inner sep=4pt] (add1) at ([xshift=0em,yshift=0.5em]e2.north){};
\node [anchor=south,inner sep=0mm,minimum height=1.8em] (f2) at ([xshift=0em,yshift=0.5em]add1.north){output};
\node [anchor=south,ffnnode] (f2) at ([xshift=0em,yshift=0.5em]add1.north){FFN};
\node [anchor=south,inner sep=0mm,minimum height=1.8em] (op) at ([xshift=0em,yshift=0.5em]f2.north){output};
\draw[->,thick] ([xshift=0em,yshift=-0.3em]f1.north)--([xshift=0em,yshift=0em]e1.south);
......@@ -24,7 +25,9 @@
\draw[->,thick] ([xshift=0em,yshift=0em]a1.north)--([xshift=0em,yshift=1em]a1.north);
\draw[->,thick] ([xshift=0em,yshift=0em]c1.north)--([xshift=0em,yshift=1em]c1.north);
\draw[-,thick] ([xshift=0em,yshift=0em]e2.north)--([xshift=0em,yshift=0em]add1.south);
\draw[->,thick] ([xshift=0em,yshift=0em]add1.north)--([xshift=0em,yshift=0.3em]f2.south);
\draw[->,thick] ([xshift=0em,yshift=0em]add1.north)--([xshift=0em,yshift=0em]f2.south);
\draw[->,thick] ([xshift=0em,yshift=0em]f2.north)--([xshift=0em,yshift=0.3em]op.south);
\draw[-] ([xshift=0em,yshift=0em]add1.west)--([xshift=-0em,yshift=0em]add1.east);
\draw[-] ([xshift=0em,yshift=0em]add1.south)--([xshift=-0em,yshift=-0em]add1.north);
......
Chapter15/Figures/figure-multi-branch-attention-model.tex
......@@ -3,9 +3,9 @@
\begin{center}
\begin{tikzpicture}
\tikzstyle{manode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=10em,rounded corners=5pt,thick,draw,fill=teal!20]
\tikzstyle{ffnnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,thick,fill=red!20,draw]
\tikzstyle{lnnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=2.5em,rounded corners=5pt,thick,fill=green!20,draw]
\tikzstyle{manode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=10em,rounded corners=5pt,thick,draw,fill=teal!30]
\tikzstyle{ffnnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,thick,fill=red!30,draw]
\tikzstyle{lnnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=2.5em,rounded corners=5pt,thick,fill=green!30,draw]
\begin{scope}[]
......@@ -42,11 +42,11 @@
\node [anchor=west,ublue,font=\footnotesize,align=left] (w1) at ([xshift=5em,yshift=-0.5em]a2.east){以概率\\$p$丢弃};
\node [anchor=west,ublue,font=\footnotesize,align=left] (w2) at ([xshift=0.5em,yshift=0em]f1.east){以概率\\$p$丢弃};
\draw[-] ([xshift=0em,yshift=0em]n2.west)--([xshift=-0em,yshift=0em]n2.east);
\draw[-] ([xshift=0em,yshift=0em]n2.south)--([xshift=-0em,yshift=-0em]n2.north);
\draw[-,thick] ([xshift=0em,yshift=0em]n2.west)--([xshift=-0em,yshift=0em]n2.east);
\draw[-,thick] ([xshift=0em,yshift=0em]n2.south)--([xshift=-0em,yshift=-0em]n2.north);
\draw[-] ([xshift=0em,yshift=0em]n5.west)--([xshift=-0em,yshift=0em]n5.east);
\draw[-] ([xshift=0em,yshift=0em]n5.south)--([xshift=-0em,yshift=-0em]n5.north);
\draw[-,thick] ([xshift=0em,yshift=0em]n5.west)--([xshift=-0em,yshift=0em]n5.east);
\draw[-,thick] ([xshift=0em,yshift=0em]n5.south)--([xshift=-0em,yshift=-0em]n5.north);
\end{scope}
\end{tikzpicture}
......
Chapter15/Figures/figure-multi-scale-local-modeling.tex
\begin{tikzpicture}
\begin{scope}
\tikzstyle{cirnode}=[rectangle,rounded corners=2pt,minimum height=2em,minimum width=3em,font=\footnotesize,draw=blue!50!white!50,fill=blue!20,thick]
\tikzstyle{cirnode}=[rectangle,rounded corners=2pt,minimum height=2em,minimum width=3em,font=\footnotesize,draw,fill=blue!20,thick]
\tikzstyle{recnode}=[rectangle,rounded corners=2pt,inner sep=0mm,minimum height=1.8em,minimum width=6em]
\node [anchor=west,cirnode] (n1) at (0, 0) {$\mathbi{h}_{i-2}^l$};
......@@ -16,9 +16,9 @@
\node [anchor=center,orange!30,minimum height=2.5em,minimum width=4em,very thick,draw] (c1) at ([xshift=0em,yshift=0em]n3.center) {};
\end{pgfonlayer}
\node [anchor=south,recnode,fill=red!20] (r1) at ([xshift=-3.5em,yshift=2.5em]n2.north) {$\textrm{head}_1$};
\node [anchor=south,recnode,fill=orange!20] (r2) at ([xshift=0em,yshift=2.5em]n3.north) {$\textrm{head}_2$};
\node [anchor=south,recnode,fill=ugreen!20] (r3) at ([xshift=3.5em,yshift=2.5em]n4.north) {$\textrm{head}_3$};
\node [anchor=south,recnode,fill=red!30] (r1) at ([xshift=-3.5em,yshift=2.5em]n2.north) {$\textrm{head}_1$};
\node [anchor=south,recnode,fill=orange!30] (r2) at ([xshift=0em,yshift=2.5em]n3.north) {$\textrm{head}_2$};
\node [anchor=south,recnode,fill=ugreen!30] (r3) at ([xshift=3.5em,yshift=2.5em]n4.north) {$\textrm{head}_3$};
\node [anchor=south,cirnode] (n6) at ([xshift=0em,yshift=1.5em]r2.north) {$\mathbi{h}_{i}^{l+1}$};
......
Chapter15/Figures/figure-multi-task-structure.tex
......@@ -2,8 +2,8 @@
\begin{tikzpicture}
\begin{scope}
\tikzstyle{enode}=[rectangle,inner sep=0mm,minimum height=5em,minimum width=5em,rounded corners=7pt,fill=green!30]
\tikzstyle{dnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=6.5em,rounded corners=5pt,fill=red!30]
\tikzstyle{enode}=[rectangle,inner sep=0mm,minimum height=5em,minimum width=5em,rounded corners=7pt,fill=green!30,draw,thick]
\tikzstyle{dnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=6.5em,rounded corners=5pt,fill=red!30,draw,thick]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=2em,minimum width=4em]
\node [anchor=south west] (w1) at (0,0) {汉语（源语言）};
......
Chapter15/Figures/figure-parallel-RNN-structure.tex
......@@ -3,8 +3,8 @@
\begin{center}
\begin{tikzpicture}
\tikzstyle{wrnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=4em,rounded corners=5pt,fill=blue!30]
\tikzstyle{arnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=4em,rounded corners=5pt,fill=red!30]
\tikzstyle{wrnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=4em,rounded corners=5pt,fill=blue!30,draw,thick]
\tikzstyle{arnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=4em,rounded corners=5pt,fill=red!30,draw,thick]
\tikzstyle{dotnode}=[inner sep=0mm,minimum height=0.5em,minimum width=1.5em]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.8em]
{\small
......
Chapter15/Figures/figure-post-norm-vs-pre-norm.tex
......@@ -6,14 +6,14 @@
\begin{scope}[minimum height = 20pt]
\node [anchor=east] (x1) at (-0.5em, 0) {$\mathbi{x}_l$};
\node [anchor=west,draw,fill=red!20,inner xsep=5pt,rounded corners=2pt] (F1) at ([xshift=4em]x1.east){\small{$F$}};
\node [anchor=west,draw,fill=red!20,inner xsep=5pt,rounded corners=2pt,thick] (F1) at ([xshift=4em]x1.east){\small{$F$}};
\node [anchor=west,circle,draw,minimum size=1em] (n1) at ([xshift=4em]F1.east) {};
\node [anchor=west,draw,fill=green!20,inner xsep=5pt,rounded corners=2pt] (ln1) at ([xshift=4em]n1.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=green!20,inner xsep=5pt,rounded corners=2pt,thick] (ln1) at ([xshift=4em]n1.east){\small{\textrm{LN}}};
\node [anchor=west] (x2) at ([xshift=4em]ln1.east) {$\mathbi{x}_{l+1}$};
\node [anchor=north] (x3) at ([yshift=-5em]x1.south) {$\mathbi{x}_l$};
\node [anchor=west,draw,fill=green!20,inner xsep=5pt,rounded corners=2pt] (F2) at ([xshift=4em]x3.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=red!20,inner xsep=5pt,rounded corners=2pt] (ln2) at ([xshift=4em]F2.east){\small{$F$}};
\node [anchor=west,draw,fill=green!20,inner xsep=5pt,rounded corners=2pt,thick] (F2) at ([xshift=4em]x3.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=red!20,inner xsep=5pt,rounded corners=2pt,thick] (ln2) at ([xshift=4em]F2.east){\small{$F$}};
\node [anchor=west,circle,draw,,minimum size=1em] (n2) at ([xshift=4em]ln2.east){};
\node [anchor=west] (x4) at ([xshift=4em]n2.east) {$\mathbi{x}_{l+1}$};
......
Chapter15/Figures/figure-relative-position-coding-and-absolute-position-coding.tex 0 → 100644
\begin{tikzpicture}
\tikzstyle{Sanode} = [minimum height=1.1em,minimum width=7em,inner sep=3pt,rounded corners=1.5pt,draw,thick];
\tikzstyle{Resnode} = [minimum height=1.1em,minimum width=7em,inner sep=3pt,rounded corners=1.5pt,draw,thick];
\tikzstyle{ffnnode} = [minimum height=1.1em,minimum width=7em,inner sep=3pt,rounded corners=1.5pt,draw,thick];
\tikzstyle{outputnode} = [minimum height=1.4em,minimum width=7em,inner sep=3pt,rounded corners=1.5pt,draw,thick];
\tikzstyle{inputnode} = [minimum height=1.4em,minimum width=3.5em,inner sep=3pt,rounded corners=1.5pt,draw,fill=red!20,thick];
\tikzstyle{posnode} = [minimum height=1.4em,minimum width=3.5em,inner sep=3pt,rounded corners=1.5pt,draw,fill=black!10!white,thick];
\tikzstyle{standard} = [rounded corners=3pt];
\begin{scope}
\node [Sanode,anchor=west] (sa1) at (0,0) {\tiny{$\textbf{Self-Attention}$}};
\node [Resnode,anchor=south] (res1) at ([yshift=0.3em]sa1.north) {\tiny{$\textbf{Add \& LayerNorm}$}};
\node [ffnnode,anchor=south] (ffn1) at ([yshift=0.5em]res1.north) {\tiny{$\textbf{Feed Forward Network}$}};
\node [Resnode,anchor=south] (res2) at ([yshift=0.3em]ffn1.north) {\tiny{$\textbf{Add \& LayerNorm}$}};
\node [anchor=south,minimum height=1.4em,minimum width=7em] (dot1) at ([yshift=1.5em]res2.north) {\tiny{$\cdots$}};
\node [Sanode,anchor=south] (sa2) at ([yshift=1.5em]dot1.north) {\tiny{$\textbf{Self-Attention}$}};
\node [Resnode,anchor=south] (res3) at ([yshift=0.3em]sa2.north) {\tiny{$\textbf{Add \& LayerNorm}$}};
\node [ffnnode,anchor=south] (ffn2) at ([yshift=0.5em]res3.north) {\tiny{$\textbf{Feed Forward Network}$}};
\node [Resnode,anchor=south] (res4) at ([yshift=0.3em]ffn2.north) {\tiny{$\textbf{Add \& LayerNorm}$}};
\node [anchor=north west,font=\scriptsize,align=center,ublue] (l1) at ([xshift=0.1em]ffn1.north east) {第 \\ $1$ \\ 层};
\node [anchor=north west,font=\scriptsize,align=center,ublue] (l2) at ([xshift=0.1em]ffn2.north east) {第 \\ $n$ \\ 层};
\node [anchor=south east,font=\scriptsize] (l3) at ([yshift=3em]l1.north east) {};
\node [anchor=north east,font=\scriptsize,align=center,opacity=0.0] (l4) at ([xshift=0.1em]ffn1.north west) {第 \\ $1$ \\ 层};
\node [anchor=north east,font=\scriptsize,align=center,opacity=0.0] (l5) at ([xshift=0.1em]ffn2.north west) {第 \\ $n$ \\ 层};
\node [anchor=south west,font=\scriptsize] (l6) at ([yshift=3em]l4.north west) {};
\node [anchor=south west] (e1) at ([xshift=-1.4em,yshift=0.3em]res4.north west) {{编码器}};
\node [anchor=north,minimum height=0.1em,minimum width=0.1em] (set1) at ([xshift=0em,yshift=0.3em]sa1.south) {};
\node [anchor=north,minimum height=0.1em,minimum width=0.1em] (set2) at ([xshift=0em,yshift=0.3em]sa2.south) {};
\begin{pgfonlayer}{background}
\node [rectangle,inner sep=0.6em,rounded corners=5pt,very thick,dotted,minimum height=1.4em,minimum width=3.5em,draw=red] [fit = (e1) (sa1) (l1) (l4) (set1)] (b4) {};
\node [rectangle,inner sep=0.3em,rounded corners=5pt,very thick,dotted,draw=ublue,minimum height=1.4em,minimum width=7em] [fit = (l1) (sa1) (res2) (l4) (set1)] (b1) {};
\node [rectangle,inner sep=0.3em,rounded corners=5pt,very thick,dotted,draw=ublue,minimum height=1.4em,minimum width=7em] [fit = (dot1) (l3) (l6)] (b2) {};
\node [rectangle,inner sep=0.3em,rounded corners=5pt,very thick,dotted,draw=ublue,minimum height=1.4em,minimum width=7em] [fit = (l2) (sa2) (res4) (l5) (set2)] (b3) {};
\end{pgfonlayer}
\node [inputnode,anchor=north west] (input1) at ([yshift=-1.6em,xshift=-0.5em]sa1.south west) {\tiny{$\textbf{Embedding}$}};
\node [] (add) at ([yshift=-2.2em,xshift=3.5em]sa1.south west) {$+$};
\node [posnode,anchor=north east] (pos1) at ([yshift=-1.6em,xshift=1.6em]sa1.south east) {\tiny{$\textbf{Absolute Position}$}};
\node [anchor=north] (wi) at ([yshift=-0.5em]pos1.south) {\scriptsize{词序信息}};
\draw [->] (wi.north) -- (pos1.south);
\draw [->] (add.north) -- (sa1.south);
\draw [->] (sa1.north) -- (res1.south);
\draw [->] (res1.north) -- (ffn1.south);
\draw [->] (ffn1.north) -- (res2.south);
\draw [->] (res2.north) -- ([yshift=-0.4em]dot1.south);
\draw [->] ([yshift=0.3em]dot1.north) -- (sa2.south);
\draw [->] (sa2.north) -- (res3.south);
\draw [->] (res3.north) -- (ffn2.south);
\draw [->] (ffn2.north) -- (res4.south);
\draw [->] (res4.north) -- ([yshift=1em]res4.north);
\draw[->,standard] ([yshift=-0.3em]sa1.south) -- ([xshift=-4em,yshift=-0.3em]sa1.south) -- ([xshift=-4em,yshift=2em]sa1.south) -- ([xshift=-3.5em,yshift=2em]sa1.south);
\draw[->,standard] ([yshift=0.2em]res1.north) -- ([xshift=-4em,yshift=0.2em]res1.north) -- ([xshift=-4em,yshift=2.5em]res1.north) -- ([xshift=-3.5em,yshift=2.5em]res1.north);
\draw[->,standard] ([yshift=-0.3em]sa2.south) -- ([xshift=-4em,yshift=-0.3em]sa2.south) -- ([xshift=-4em,yshift=2em]sa2.south) -- ([xshift=-3.5em,yshift=2em]sa2.south);
\draw[->,standard] ([yshift=0.2em]res3.north) -- ([xshift=-4em,yshift=0.2em]res3.north) -- ([xshift=-4em,yshift=2.5em]res3.north) -- ([xshift=-3.5em,yshift=2.5em]res3.north);
\begin{pgfonlayer}{background}
\node [rectangle,inner sep=0.2em,rounded corners=1pt,very thick,dotted,fill=red!40] [fit = (input1) (pos1)] (box1) {};
\end{pgfonlayer}
\node [anchor=north,font=\small] (label) at ([yshift=-3em]add.south) {{(a)绝对位置编码}};
\end{scope}
\begin{scope}[xshift=2in]
\node [Sanode,anchor=west] (sa1) at (0,0) {\tiny{$\textbf{Self-Attention}$}};
\node [Resnode,anchor=south] (res1) at ([yshift=0.3em]sa1.north) {\tiny{$\textbf{Add \& LayerNorm}$}};
\node [ffnnode,anchor=south] (ffn1) at ([yshift=0.5em]res1.north) {\tiny{$\textbf{Feed Forward Network}$}};
\node [Resnode,anchor=south] (res2) at ([yshift=0.3em]ffn1.north) {\tiny{$\textbf{Add \& LayerNorm}$}};
\node [anchor=south,minimum height=1.4em,minimum width=7em] (dot1) at ([yshift=1.5em]res2.north) {\tiny{$\cdots$}};
\node [Sanode,anchor=south] (sa2) at ([yshift=1.5em]dot1.north) {\tiny{$\textbf{Self-Attention}$}};
\node [Resnode,anchor=south] (res3) at ([yshift=0.3em]sa2.north) {\tiny{$\textbf{Add \& LayerNorm}$}};
\node [ffnnode,anchor=south] (ffn2) at ([yshift=0.5em]res3.north) {\tiny{$\textbf{Feed Forward Network}$}};
\node [Resnode,anchor=south] (res4) at ([yshift=0.3em]ffn2.north) {\tiny{$\textbf{Add \& LayerNorm}$}};
\node [anchor=north west,font=\scriptsize,align=center,ublue] (l1) at ([xshift=0.1em]ffn1.north east) {第 \\ $1$ \\ 层};
\node [anchor=north west,font=\scriptsize,align=center,ublue] (l2) at ([xshift=0.1em]ffn2.north east) {第 \\ $n$ \\ 层};
\node [anchor=south east,font=\scriptsize] (l3) at ([yshift=3em]l1.north east) {};
\node [anchor=north east,font=\scriptsize,align=center,opacity=0.0] (l4) at ([xshift=0.1em]ffn1.north west) {第 \\ $1$ \\ 层};
\node [anchor=north east,font=\scriptsize,align=center,opacity=0.0] (l5) at ([xshift=0.1em]ffn2.north west) {第 \\ $n$ \\ 层};
\node [anchor=south west,font=\scriptsize] (l6) at ([yshift=3em]l4.north west) {};
\node [anchor=south west] (e1) at ([xshift=-1.4em,yshift=0.3em]res4.north west) {{编码器}};
\node [anchor=north,minimum height=0.1em,minimum width=0.1em] (set1) at ([xshift=0em,yshift=0.3em]sa1.south) {};
\node [anchor=north,minimum height=0.1em,minimum width=0.1em] (set2) at ([xshift=0em,yshift=0.3em]sa2.south) {};
\begin{pgfonlayer}{background}
\node [rectangle,inner sep=0.6em,rounded corners=5pt,very thick,dotted,minimum height=1.4em,minimum width=3.5em,draw=red] [fit = (e1) (sa1) (l1) (l4) (set1)] (b4) {};
\node [rectangle,inner sep=0.3em,rounded corners=5pt,very thick,dotted,draw=ublue,minimum height=1.4em,minimum width=7em] [fit = (l1) (sa1) (res2) (l4) (set1)] (b1) {};
\node [rectangle,inner sep=0.3em,rounded corners=5pt,very thick,dotted,draw=ublue,minimum height=1.4em,minimum width=7em] [fit = (dot1) (l3) (l6)] (b2) {};
\node [rectangle,inner sep=0.3em,rounded corners=5pt,very thick,dotted,draw=ublue,minimum height=1.4em,minimum width=7em] [fit = (l2) (sa2) (res4) (l5) (set2)] (b3) {};
\end{pgfonlayer}
\node [inputnode,anchor=north west] (input1) at ([yshift=-1.6em,xshift=-0.5em]sa1.south west) {\tiny{Embedding}};
\node [] (add) at ([yshift=-2.2em,xshift=3.5em]sa1.south west) {$+$};
\node [posnode,anchor=north east] (pos1) at ([yshift=-1.6em,xshift=1.5em]sa1.south east) {\tiny{Absolute Position}};
\node [anchor=north] (wi) at ([yshift=-0.5em]pos1.south) {\scriptsize{词序信息}};
\node [posnode,anchor=west,font=\tiny,align=center] (pos2) at ([yshift=0em,xshift=1em]pos1.east) {Relative \\ Position 1};
\node [posnode,anchor=west,font=\tiny,align=center,minimum width=1em] (pos3) at ([yshift=0em,xshift=1em]pos2.east) {$\cdots$};
\node [posnode,anchor=west,font=\tiny,align=center] (pos4) at ([yshift=0em,xshift=1em]pos3.east) {Relative \\ Position $n$};
\draw [->] (wi.north) -- (pos1.south);
\draw [->] (add.north) -- (sa1.south);
\draw [->] (sa1.north) -- (res1.south);
\draw [->] (res1.north) -- (ffn1.south);
\draw [->] (ffn1.north) -- (res2.south);
\draw [->] (res2.north) -- ([yshift=-0.4em]dot1.south);
\draw [->] ([yshift=0.3em]dot1.north) -- (sa2.south);
\draw [->] (sa2.north) -- (res3.south);
\draw [->] (res3.north) -- (ffn2.south);
\draw [->] (ffn2.north) -- (res4.south);
\draw [->] (res4.north) -- ([yshift=1em]res4.north);
\draw[->,standard] ([yshift=-0.3em]sa1.south) -- ([xshift=-4em,yshift=-0.3em]sa1.south) -- ([xshift=-4em,yshift=2em]sa1.south) -- ([xshift=-3.5em,yshift=2em]sa1.south);
\draw[->,standard] ([yshift=0.2em]res1.north) -- ([xshift=-4em,yshift=0.2em]res1.north) -- ([xshift=-4em,yshift=2.5em]res1.north) -- ([xshift=-3.5em,yshift=2.5em]res1.north);
\draw[->,standard] ([yshift=-0.3em]sa2.south) -- ([xshift=-4em,yshift=-0.3em]sa2.south) -- ([xshift=-4em,yshift=2em]sa2.south) -- ([xshift=-3.5em,yshift=2em]sa2.south);
\draw[->,standard] ([yshift=0.2em]res3.north) -- ([xshift=-4em,yshift=0.2em]res3.north) -- ([xshift=-4em,yshift=2.5em]res3.north) -- ([xshift=-3.5em,yshift=2.5em]res3.north);
\draw[->,standard] ([xshift=0em]wi.east) -- ([xshift=3.2em,yshift=0em]wi.east) -- ([xshift=-0em,yshift=0em]pos2.south);
\draw[->,standard] ([xshift=0em]wi.east) -- ([xshift=6.7em,yshift=0em]wi.east) -- ([xshift=-0em,yshift=0em]pos3.south);
\draw[->,standard] ([xshift=0em]wi.east) -- ([xshift=10.2em,yshift=0em]wi.east) -- ([xshift=-0em,yshift=0em]pos4.south);
\draw[->,standard] ([xshift=0em]pos2.north) -- ([xshift=0em,yshift=2.1em]pos2.north) -- ([xshift=-0em,yshift=0em]sa1.east);
\draw[->,standard] ([xshift=0em]pos3.north) -- ([xshift=0em,yshift=9.6em]pos3.north) -- ([xshift=-0em,yshift=0em]dot1.east);
\draw[->,standard] ([xshift=0em]pos4.north) -- ([xshift=0em,yshift=12.3em]pos4.north) -- ([xshift=-0em,yshift=0em]sa2.east);
\begin{pgfonlayer}{background}
\node [rectangle,inner sep=0.2em,rounded corners=1pt,very thick,dotted,fill=red!40] [fit = (pos2) (pos3) (pos4)] (box1) {};
\end{pgfonlayer}
\node [anchor=north,font=\small] (label) at ([xshift=4em,yshift=-3em]add.south) {{(b)相对位置编码}};
\end{scope}
\end{tikzpicture}
\ No newline at end of file
Chapter15/Figures/figure-relative-position-weight.tex
\begin{tikzpicture}
\tikzstyle{node1} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=green!80]
\tikzstyle{node2} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=green!40]
\tikzstyle{node3} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=green!20]
\tikzstyle{node1} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=ugreen!80]
\tikzstyle{node2} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=ugreen!50]
\tikzstyle{node3} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=ugreen!20]
\tikzstyle{node4} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt]
\tikzstyle{node5} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=red!20]
\tikzstyle{node6} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=red!40]
\tikzstyle{node7} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=red!80]
\tikzstyle{node5} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=teal!20]
\tikzstyle{node6} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=teal!50]
\tikzstyle{node7} = [anchor=center,draw,minimum height=2em,minimum width=2em,inner sep=0pt,fill=teal!80]
\begin{scope}[scale=1.0]
\foreach \i / \j / \k / \z in
......@@ -27,6 +27,9 @@
{0/0/8, 1/0/9, 2/0/10, 3/0/11, 4/0/12, 5/0/13, 6/0/14}
\node[anchor=north] (n\k) at ([xshift=-0em,yshift=-0.5em]a\i\j.south) {\i};
\node [anchor=east] (l1) at ([xshift=-0.3em,yshift=0em]n8.west) {$i$};
\node [anchor=north] (l2) at ([xshift=0em,yshift=-0em]n7.south) {$j$};
%\node [anchor=north] (n1) at ([xshift=0em,yshift=0em]a00.south west) {};
\end{scope}
......
Chapter15/Figures/figure-structure-search-based-on-gradient-method.tex
......@@ -4,9 +4,9 @@
\begin{tikzpicture}
\tikzstyle{node}=[minimum height=6em,inner sep=4pt,align=left,draw,font=\footnotesize,rounded corners=4pt,thick,drop shadow]
\node[node,fill=red!20] (n1) at (0,0){\scriptsize\bfnew{超网络}： \\ [1ex] 模型结构参数 \\[0.4ex] 网络参数};
\node[anchor=west,node,fill=yellow!20] (n2) at ([xshift=4em]n1.east){\scriptsize\bfnew{优化后的超网络}： \\ [1ex]模型{\color{red}结构参数}（已优化） \\ [0.4ex]网络参数（已优化）};
\node[anchor=west,node,fill=green!20] (n3) at ([xshift=6em]n2.east){\scriptsize\bfnew{找到的模型结构}};
\node[node,fill=red!30] (n1) at (0,0){\scriptsize\bfnew{超网络}： \\ [1ex] 模型结构参数 \\[0.4ex] 网络参数};
\node[anchor=west,node,fill=yellow!30] (n2) at ([xshift=4em]n1.east){\scriptsize\bfnew{优化后的超网络}： \\ [1ex]模型{\color{red}结构参数}（已优化） \\ [0.4ex]网络参数（已优化）};
\node[anchor=west,node,fill=green!30] (n3) at ([xshift=6em]n2.east){\scriptsize\bfnew{找到的模型结构}};
\draw[-latex,thick] (n1.0) -- node[above,align=center,font=\scriptsize]{优化后的\\超网络}(n2.180);
\draw[-latex,thick] (n2.0) -- node[above,align=center,font=\scriptsize]{根据结构参数\\离散化结构}(n3.180);
......
Chapter15/Figures/figure-structure-search-based-on-reinforcement-learning.tex
......@@ -2,15 +2,15 @@
%%% outline
%-------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{node}=[minimum height=2em,minimum width=5em,draw,rounded corners=2pt,thick,drop shadow]
\tikzstyle{node}=[minimum height=2.5em,minimum width=8em,draw,rounded corners=2pt,thick,drop shadow]
\node[node,fill=red!20] (n1) at (0,0){\small\bfnew{环境}};
\node[anchor=south,node,fill=green!20] (n2) at ([yshift=5em]n1.north){\small\bfnew{智能体}};
\node[node,fill=red!30] (n1) at (0,0){\small\bfnew{环境}};
\node[anchor=south,node,fill=green!30] (n2) at ([yshift=5em]n1.north){\small\bfnew{智能体}};
\node[anchor=north,font=\footnotesize] at ([yshift=-0.2em]n1.south){（结构所应用于的任务）};
\node[anchor=south,font=\footnotesize] at ([yshift=0.2em]n2.north){（结构生成器）};
\draw[-latex,thick] ([yshift=.4em]n1.180) .. controls ([xshift=-3.4em,yshift=.4em]n1.180) and ([xshift=-3.4em,yshift=-.4em]n2.180) .. node[right,font=\scriptsize,align=left]{\scriptsize\bfnew{奖励} \\ （对输出结果的评价）}([yshift=-.4em]n2.180);
\draw[-latex,thick] ([yshift=-.4em]n1.180) .. controls ([xshift=-4.4em,yshift=-.4em]n1.180) and ([xshift=-4.4em,yshift=.4em]n2.180) .. node[left,font=\scriptsize,align=right]{\scriptsize\bfnew{状态} \\ （这个结构在任务中应用 \\ 后得到的输出结果）}([yshift=.4em]n2.180);
\draw[-latex,thick] ([yshift=-.4em]n1.180) .. controls ([xshift=-4.4em,yshift=-.4em]n1.180) and ([xshift=-4.4em,yshift=.4em]n2.180) .. node[left,font=\scriptsize,align=right]{\scriptsize\bfnew{状态} \\ （这个结构在任务中应 \\ 用后得到的输出结果）}([yshift=.4em]n2.180);
\draw[-latex,thick] (n2.0) .. controls ([xshift=4em]n2.0) and ([xshift=4em]n1.0) .. node[right,font=\scriptsize,align=left]{\scriptsize\bfnew{动作} \\ （生成一个结构）}(n1.0);
\end{tikzpicture}
......
Chapter15/Figures/figure-sublayer-skip.tex
......@@ -6,24 +6,24 @@
\begin{scope}[minimum height = 20pt]
\node [anchor=east] (x1) at (-0.5em, 0) {$\mathbi{x}_l$};
\node [anchor=west,draw,fill=red!20,inner xsep=5pt,rounded corners=2pt] (ln1) at ([xshift=1em]x1.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=green!20,inner xsep=5pt,rounded corners=2pt] (f1) at ([xshift=0.6em]ln1.east){\small{$F$}};
\node [anchor=west,draw,fill=red!30,inner xsep=5pt,rounded corners=2pt,draw,thick] (ln1) at ([xshift=1em]x1.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=green!30,inner xsep=5pt,rounded corners=2pt,draw,thick] (f1) at ([xshift=0.6em]ln1.east){\small{$F$}};
\node [anchor=west,circle,draw,,minimum size=1em] (n1) at ([xshift=3em]f1.east){};
\node [anchor=west] (x2) at ([xshift=1em]n1.east) {$\mathbi{x}_{l+1}$};
\node [anchor=west,draw,fill=red!20,inner xsep=5pt,rounded corners=2pt] (ln12) at ([xshift=1em]x2.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=green!20,inner xsep=5pt,rounded corners=2pt] (f12) at ([xshift=0.6em]ln12.east){\small{$F$}};
\node [anchor=west,draw,fill=red!30,inner xsep=5pt,rounded corners=2pt,draw,thick] (ln12) at ([xshift=1em]x2.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=green!30,inner xsep=5pt,rounded corners=2pt,draw,thick] (f12) at ([xshift=0.6em]ln12.east){\small{$F$}};
\node [anchor=west,circle,draw,,minimum size=1em] (n12) at ([xshift=3em]f12.east){};
\node [anchor=west] (x22) at ([xshift=1em]n12.east) {$\mathbi{x}_{l+2}$};
\node [anchor=north] (x3) at ([yshift=-5em]x1.south) {$\mathbi{x}_l$};
\node [anchor=west,draw,fill=red!20,inner xsep=5pt,rounded corners=2pt] (ln2) at ([xshift=1em]x3.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=green!20,inner xsep=5pt,rounded corners=2pt] (f2) at ([xshift=0.6em]ln2.east){\small{$F$}};
\node [anchor=west,draw,fill=red!30,inner xsep=5pt,rounded corners=2pt,draw,thick] (ln2) at ([xshift=1em]x3.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=green!30,inner xsep=5pt,rounded corners=2pt,draw,thick] (f2) at ([xshift=0.6em]ln2.east){\small{$F$}};
\node [anchor=west,minimum size=1em] (p1) at ([xshift=1em]f2.east){};
\node [anchor=north] (m1) at ([yshift=0.6em]p1.south){\footnotesize{\red{Mask=1}}};
\node [anchor=west,circle,draw,,minimum size=1em] (n2) at ([xshift=3em]f2.east){};
\node [anchor=west] (x4) at ([xshift=1em]n2.east) {$\mathbi{x}_{l+1}$};
\node [anchor=west,draw,fill=red!20,inner xsep=5pt,rounded corners=2pt] (ln22) at ([xshift=1em]x4.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=green!20,inner xsep=5pt,rounded corners=2pt] (f22) at ([xshift=0.6em]ln22.east){\small{$F$}};
\node [anchor=west,draw,fill=red!30,inner xsep=5pt,rounded corners=2pt,draw,thick] (ln22) at ([xshift=1em]x4.east){\small{\textrm{LN}}};
\node [anchor=west,draw,fill=green!30,inner xsep=5pt,rounded corners=2pt,draw,thick] (f22) at ([xshift=0.6em]ln22.east){\small{$F$}};
\node [anchor=west,minimum size=1em] (p2) at ([xshift=1em]f22.east){};
\node [anchor=north] (m2) at ([yshift=0.6em]p2.south){\footnotesize{\red{Mask=0}}};
\node [anchor=west,circle,draw,,minimum size=1em] (n22) at ([xshift=3em]f22.east){};
......
Chapter15/Figures/figure-three-fusion-methods-of-tree-structure-information-1.tex
......@@ -3,8 +3,8 @@
\begin{center}
\begin{tikzpicture}
\tikzstyle{wrnode}=[rectangle,inner sep=0mm,minimum height=1.6em,minimum width=3em,rounded corners=5pt,fill=blue!30]
\tikzstyle{srnode}=[rectangle,inner sep=0mm,minimum height=1.6em,minimum width=3em,rounded corners=5pt,fill=orange!30]
\tikzstyle{wrnode}=[rectangle,inner sep=0mm,minimum height=1.6em,minimum width=3em,rounded corners=5pt,fill=blue!30,draw,thick]
\tikzstyle{srnode}=[rectangle,inner sep=0mm,minimum height=1.6em,minimum width=3em,rounded corners=5pt,fill=orange!30,draw,thick]
\tikzstyle{dotnode}=[inner sep=0mm,minimum height=0.5em,minimum width=1.5em]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.6em]
{\small
......
Chapter15/Figures/figure-three-fusion-methods-of-tree-structure-information-2.tex
......@@ -3,8 +3,8 @@
\begin{center}
\begin{tikzpicture}
\tikzstyle{wrnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,fill=blue!30]
\tikzstyle{srnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,fill=orange!30]
\tikzstyle{wrnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,fill=blue!30,draw,thick]
\tikzstyle{srnode}=[rectangle,inner sep=0mm,minimum height=1.8em,minimum width=3em,rounded corners=5pt,fill=orange!30,draw,thick]
\tikzstyle{dotnode}=[inner sep=0mm,minimum height=0.5em,minimum width=1.5em]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.8em]
......@@ -48,9 +48,9 @@
\node [anchor=south,wnode] (w10) at ([xshift=0em,yshift=0.5em]c3.north) {$\mathbi{e}_{w_2}$};
\begin{pgfonlayer}{background}
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=green!20,rounded corners=8pt] [fit = (c1) (w8)] (box6) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=green!20,rounded corners=8pt] [fit = (c2) (w9)] (box7) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=green!20,rounded corners=8pt] [fit = (c3) (w10)] (box8) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=green!30,rounded corners=8pt,draw,thick] [fit = (c1) (w8)] (box6) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=green!30,rounded corners=8pt,draw,thick] [fit = (c2) (w9)] (box7) {};
\node [rectangle,minimum height=5em,inner sep=0.6em,fill=green!30,rounded corners=8pt,draw,thick] [fit = (c3) (w10)] (box8) {};
\end{pgfonlayer}
\node [anchor=south,wrnode] (wr1) at ([xshift=0em,yshift=1em]box6.north) {$\mathbi{h}_{w_1}$};
......
Chapter15/Figures/figure-three-fusion-methods-of-tree-structure-information-3.tex
......@@ -3,7 +3,7 @@
\begin{center}
\begin{tikzpicture}
\tikzstyle{hnode}=[rectangle,inner sep=0mm,minimum height=1.6em,minimum width=3em,rounded corners=5pt,fill=red!30]
\tikzstyle{hnode}=[rectangle,inner sep=0mm,minimum height=1.6em,minimum width=3em,rounded corners=5pt,fill=red!30,draw,thick]
\tikzstyle{dotnode}=[inner sep=0mm,minimum height=0.5em,minimum width=1.5em]
\tikzstyle{wnode}=[inner sep=0mm,minimum height=1.6em]
{\small
......
Chapter15/Figures/figure-weight-visualization-of-convergence-DLCL-network.tex
\begin{tikzpicture}[node distance = 0,scale = 1]
\tikzstyle{every node}=[scale=1]
\node[draw=white] (input) at (0,0){\includegraphics[width=0.62\textwidth]{./Chapter15/Figures/DLCL-picture.png}};(1.9,-1.4);
\node[scale = 2] at (4.5,3.6){4};
\node[scale = 2] at (4.5,1.8){2};
\node[scale = 2] at (4.5,0){0};
\node[scale = 2] at (4.5,-1.8){-2};
\node[scale = 2] at (4.5,-3.6){-4};
\node[scale = 1.5] at (-4.5,3.75){$\rm x_{1}$};
\node[scale = 1.5] at (-4.5,2.5){$\rm x_{6}$};
\node[scale = 1.5] at (-4.5,1.4){$\rm x_{11}$};
\node[scale = 1.5] at (-4.5,0.1){$\rm x_{16}$};
\node[scale = 1.5] at (-4.5,-1.1){$\rm x_{21}$};
\node[scale = 1.5] at (-4.5,-2.3){$\rm x_{26}$};
\node[scale = 1.5] at (-4.5,-3.4){$\rm x_{31}$};
\node[scale = 1.5] at (-3.8,-4){$\rm y_{0}$};
\node[scale = 1.5] at (-2.7,-4){$\rm y_{5}$};
\node[scale = 1.5] at (-1.5,-4){$\rm y_{10}$};
\node[scale = 1.5] at (-0.3,-4){$\rm y_{15}$};
\node[scale = 1.5] at (0.9,-4){$\rm y_{20}$};
\node[scale = 1.5] at (2.1,-4){$\rm y_{25}$};
\node[scale = 1.5] at (3.3,-4){$\rm y_{30}$};
\node[draw=white] (input) at (0,0){\includegraphics[width=0.62\textwidth]{./Chapter15/Figures/DLCL-picture.png}};
{\footnotesize
\node[anchor=center] at (4.1,3){4};
\node[anchor=center] at (4.1,1.5){2};
\node[anchor=center] at (4.1,0){0};
\node[anchor=center] at (4.1,-1.5){-2};
\node[anchor=center] at (4.1,-3){-4};
\node[anchor=center] at (-4.2,3.6){$ x_{1}$};
\node[anchor=center] at (-4.2,2.45){$ x_{6}$};
\node[anchor=center] at (-4.2,1.3){$ x_{11}$};
\node[anchor=center] at (-4.2,0.15){$ x_{16}$};
\node[anchor=center] at (-4.2,-1){$ x_{21}$};
\node[anchor=center] at (-4.2,-2.15){$ x_{26}$};
\node[anchor=center] at (-4.2,-3.3){$ x_{31}$};
\node[anchor=center] at (-3.75,-3.8){$ y_{0}$};
\node[anchor=center] at (-2.6,-3.8){$ y_{5}$};
\node[anchor=center] at (-1.45,-3.8){$ y_{10}$};
\node[anchor=center] at (-0.3,-3.8){$ y_{15}$};
\node[anchor=center] at (0.85,-3.8){$ y_{20}$};
\node[anchor=center] at (2,-3.8){$ y_{25}$};
\node[anchor=center] at (3.15,-3.8){$ y_{30}$};
}
\end{tikzpicture}
\ No newline at end of file
Chapter15/chapter15.tex
......@@ -46,7 +46,16 @@
\parinterval 但是，Transformer模型中的自注意力机制本身并不具有这种性质，而且它直接忽略了输入单元之间的位置关系。虽然，Transformer中引入了基于正余弦函数的绝对位置编码（见{\chaptertwelve}），但是该方法仍然无法显性区分局部依赖与长距离依赖\footnote[1]{局部依赖指当前位置与局部的相邻位置之间的联系。}。
\parinterval 针对上述问题，研究人员设计了“相对位置”编码，对原有的“绝对位置”编码进行补充，强化了局部依赖\upcite{Dai2019TransformerXLAL,Shaw2018SelfAttentionWR}。此外，由于模型中每一层均存在自注意力机制计算，因此模型捕获位置信息的能力也逐渐减弱，这种现象在深层模型中尤为明显。而利用相对位置编码能够把位置信息显性加入到每一层的注意力机制的计算中，进而强化深层模型中局部位置的表示能力\upcite{li2020shallow}。{\color{red} 图XXX对比了Transformer中相对位置编码和绝对位置编码方法。}
\parinterval 针对上述问题，研究人员设计了“相对位置”编码，对原有的“绝对位置”编码进行补充，强化了局部依赖\upcite{Dai2019TransformerXLAL,Shaw2018SelfAttentionWR}。此外，由于模型中每一层均存在自注意力机制计算，因此模型捕获位置信息的能力也逐渐减弱，这种现象在深层模型中尤为明显。而利用相对位置编码能够把位置信息显性加入到每一层的注意力机制的计算中，进而强化深层模型中局部位置相对位置编码和绝对位置编码方法的表示能力\upcite{li2020shallow}。图\ref{fig:15-1}对比了Transformer中相对位置编码和绝对位置编码方法。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-relative-position-coding-and-absolute-position-coding}
\caption{绝对位置编码和相对位置编码}
\label{fig:15-1}
\end{figure}
%-------------------------------------------
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -94,12 +103,21 @@
\label{eq:15-9}
\end{eqnarray}
\noindent 其中，$\mathbi{w}^K \in \mathbb{R}^{d_k}$和$\mathbi{w}^V \in \mathbb{R}^{d_k}$是模型中可学习的参数矩阵；$\textrm{clip}(\cdot,\cdot)$表示截断操作，由公式\eqref{eq:15-9}定义。可以看出，$\mathbi{a}^K$ 与$\mathbi{a}^V$ 是根据输入的相对位置信息（由$\textrm{clip}(j-i,k)$确定）对$\mathbi{w}^K$和$\mathbi{w}^V$进行查表得到的向量，即相对位置表示。这里通过预先设定的最大相对位置$k$，强化模型对当前词为中心的左右各$k$ 个词的注意力计算。因此，最终的窗口大小为$2k + 1$。 对于边缘位置窗口大小不足$2k$的单词，采用了裁剪的机制，即只对有效的临近词进行建模。此时，注意力模型的计算可以调整为：
\noindent 其中，$\mathbi{w}^K \in \mathbb{R}^{d_k}$和$\mathbi{w}^V \in \mathbb{R}^{d_k}$是模型中可学习的参数矩阵；$\textrm{clip}(\cdot,\cdot)$表示截断操作，由公式\eqref{eq:15-9}定义。可以看出，$\mathbi{a}^K$ 与$\mathbi{a}^V$ 是根据输入的相对位置信息（由$\textrm{clip}(j-i,k)$确定）对$\mathbi{w}^K$和$\mathbi{w}^V$进行查表得到的向量，即相对位置表示，如图\ref{fig:15-2}所示。这里通过预先设定的最大相对位置$k$，强化模型对当前词为中心的左右各$k$ 个词的注意力计算。因此，最终的窗口大小为$2k + 1$。 对于边缘位置窗口大小不足$2k$的单词，采用了裁剪的机制，即只对有效的临近词进行建模。此时，注意力模型的计算可以调整为：
\begin{eqnarray}
\mathbi{z}_{i} &=& \sum_{j=1}^m \alpha_{ij}(\mathbi{x}_j \mathbi{W}_V + \mathbi{a}_{ij}^V)
\label{eq:15-10}
\end{eqnarray}
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-relative-position-weight}
\caption{相对位置权重$\mathbi{a}_{ij}$\upcite{DBLP:conf/emnlp/HuangLXX20}}
\label{fig:15-2}
\end{figure}
%-------------------------------------------
\noindent 相比于公式\eqref{eq:15-4}，公式\eqref{eq:15-10}在计算$\mathbi{z}_i$时引入了额外的向量$\mathbi{a}_{ij}^V$，用它来表示位置$i$与位置$j$之间的相对位置信息。同时在计算注意力权重时对$\mathbi{K}$进行修改，同样引入了$\mathbi{a}_{ij}^K$向量表示位置$i$与位置$j$之间的相对位置。在公式\eqref{eq:15-6}的基础上，注意力权重的计算方式调整为：
\begin{eqnarray}
\mathbi{e}_{ij} &=& \frac{\mathbi{x}_i \mathbi{W}_Q{(\mathbi{x}_j \mathbi{W}_K + \mathbi{a}_{ij}^K )}^{T}}{\sqrt{d_k}} \nonumber \\
......@@ -109,15 +127,6 @@
\noindent 可以注意到，公式\eqref{eq:15-10}和公式\eqref{eq:15-11}将位置编码信息直接暴露给每一层注意力机制的计算，而不是像标准Transformer中只将其作为整个模型的输入。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-relative-position-weight}
\caption{相对位置权重$\mathbi{a}_{ij}$}
\label{fig:15-1}
\end{figure}
%-------------------------------------------
\vspace{0.5em}
\item Transformer-XL\upcite{Dai2019TransformerXLAL}。在Transformer中，模型的输入由词嵌入表示与绝对位置编码组成，例如，对于输入层有，$x_i = \mathbi{E}_{x_i} + \mathbi{U}_i$，$x_j=\mathbi{E}_{x_j} + \mathbi{U}_j$，其中$\mathbi{E}_{x_i} $和$\mathbi{E}_{x_j} $表示词嵌入，$\mathbi{U}_i$和$\mathbi{U}_j$表示绝对位置编码（正余弦函数）。将其代入公式\eqref{eq:15-6}中可以得到：
\begin{eqnarray}
......@@ -159,7 +168,18 @@ A_{ij}^{\rm rel} &=& \underbrace{\mathbi{E}_{x_i}\mathbi{W}_Q\mathbi{W}_{K}^{T}\
\begin{itemize}
\vspace{0.5em}
\item {\small\bfnew{引入高斯约束}}\upcite{Yang2018ModelingLF}。如图\ref{fig:15-2}所示，这类方法的核心思想是引入可学习的高斯分布$\mathbi{G}$作为局部约束，与注意力权重进行融合，具体的形式如下：
\item {\small\bfnew{引入高斯约束}}\upcite{Yang2018ModelingLF}。如图\ref{fig:15-3}所示，这类方法的核心思想是引入可学习的高斯分布$\mathbi{G}$作为局部约束，与注意力权重进行融合。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-attention-distribution-based-on-gaussian-distribution}
\caption{融合高斯分布的注意力分布}
\label{fig:15-3}
\end{figure}
%-------------------------------------------
\noindent 具体的形式如下：
\begin{eqnarray}
\mathbi{e}_{ij} &=& \frac{(\mathbi{x}_i \mathbi{W}_Q){(\mathbi{x}_j \mathbi{W}_K)}^{T}}{\sqrt{d_k}} + \mathbi{G}
\label{eq:15-15}
......@@ -186,24 +206,15 @@ v_i &=& \mathbi{I}_d^T\textrm{Tanh}(\mathbi{W}_d\mathbi{Q}_i)
\noindent 其中，$\mathbi{W}_p$、$\mathbi{W}_d$、$\mathbi{I}_p$、$\mathbi{I}_d$均为模型中可学习的参数矩阵。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-attention-distribution-based-on-gaussian-distribution}
\caption{融合高斯分布的注意力分布}
\label{fig:15-2}
\end{figure}
%-------------------------------------------
\vspace{0.5em}
\item {\small\bfnew{多尺度局部建模}}\upcite{DBLP:conf/aaai/GuoQLXZ20}。不同于上述方法直接作用于注意力权重，多尺度局部建模通过赋予多头不一样的局部感受野，间接地引入局部约束（图\ref{fig:15-3}）。
\item {\small\bfnew{多尺度局部建模}}\upcite{DBLP:conf/aaai/GuoQLXZ20}。不同于上述方法直接作用于注意力权重，多尺度局部建模通过赋予多头不一样的局部感受野，间接地引入局部约束（图\ref{fig:15-4}）。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-multi-scale-local-modeling}
\caption{多尺度局部建模\upcite{DBLP:conf/aaai/GuoQLXZ20}}
\label{fig:15-3}
\label{fig:15-4}
\end{figure}
%-------------------------------------------
......@@ -242,16 +253,16 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\vspace{0.5em}
\item {\small\bfnew{使用轻量卷积和动态卷积神经网络}}\upcite{Wu2019PayLA,DBLP:conf/interspeech/GulatiQCPZYHWZW20}。比如，分别在编码端和解码端利用轻量卷积或动态卷积神经网络（见{\chapternine}）替换Transformer的自注意力机制，同时保留解码端的编码-解码注意力机制，一定程度上加强了模型对局部信息的建模能力，同时提高了计算效率。
\vspace{0.5em}
\item {\small\bfnew{使用1维卷积注意力网络}}（图\ref{fig:15-4}(b)）。可以使用一维的卷积自注意力网络（1D-CSAN）将关注的范围限制在相近的元素窗口中。其形式上十分简单，只需预先设定好局部建模的窗口大小$D$，并在进行注意力权重计算和对Value值进行加权求和时，将其限制在设定好的窗口范围内即可。
\item {\small\bfnew{使用1维卷积注意力网络}}（图\ref{fig:15-5}(b)）。可以使用一维的卷积自注意力网络（1D-CSAN）将关注的范围限制在相近的元素窗口中。其形式上十分简单，只需预先设定好局部建模的窗口大小$D$，并在进行注意力权重计算和对Value值进行加权求和时，将其限制在设定好的窗口范围内即可。
\vspace{0.5em}
\item {\small\bfnew{使用2维卷积注意力网络}}（图\ref{fig:15-4}(c)）。在一维卷积注意力网络的基础上，对多个注意力头之间的信息进行交互建模，打破了注意力头之间的界限。 1D-CDAN的关注区域为$1\times D$，当将其扩展为二维矩形$D \times N$，长和宽分别为局部窗口的大小和参与建模的自注意力头的个数。这样，模型可以计算某个头中的第$i$个元素和另一个头中的第$j$个元素之间的相关性系数。实现了对不同子空间之间关系的建模，所得到的注意力分布表示了头之间的依赖关系。
\item {\small\bfnew{使用2维卷积注意力网络}}（图\ref{fig:15-5}(c)）。在一维卷积注意力网络的基础上，对多个注意力头之间的信息进行交互建模，打破了注意力头之间的界限。 1D-CDAN的关注区域为$1\times D$，当将其扩展为二维矩形$D \times N$，长和宽分别为局部窗口的大小和参与建模的自注意力头的个数。这样，模型可以计算某个头中的第$i$个元素和另一个头中的第$j$个元素之间的相关性系数。实现了对不同子空间之间关系的建模，所得到的注意力分布表示了头之间的依赖关系。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-convolutional-attention-network}
\caption{卷积注意力模型示意图\upcite{DBLP:journals/corr/abs-1904-03107}}
\label{fig:15-4}
\label{fig:15-5}
\end{figure}
%-------------------------------------------
\end{itemize}
......@@ -272,14 +283,14 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\vspace{0.5em}
\item Weighted Transformer\upcite{DBLP:journals/corr/abs-1711-02132}。其主要思想是在多头自注意力机制的基础上保留不同表示空间的特征。传统方法使用级联操作并通过线性映射矩阵来融合不同头之间的信息，而Weighted Transformer直接利用线性映射将维度为$d_k$ 的向量表示映射到$d_{\rm model}$维的向量。之后，将这个$d_{\rm model}$维向量分别送入每个分支中的前馈神经网络，最后对不同分支的输出进行线性加权。但是，这个模型的计算复杂度要大于标准的Transformer模型。
\vspace{0.5em}
\item 多分支注意力模型\upcite{DBLP:journals/corr/abs-2006-10270}。不同于Weighted Transformer模型，多分支注意力模型直接利用每个分支独立地进行自注意力模型的计算（图\ref{fig:15-5}）。同时为了避免结构相同的多个多头注意力机制之间的协同适应，这种模型使用Dropout方法在训练过程中以一定的概率随机地丢弃一些分支。
\item 多分支注意力模型\upcite{DBLP:journals/corr/abs-2006-10270}。不同于Weighted Transformer模型，多分支注意力模型直接利用每个分支独立地进行自注意力模型的计算（图\ref{fig:15-6}）。同时为了避免结构相同的多个多头注意力机制之间的协同适应，这种模型使用Dropout方法在训练过程中以一定的概率随机地丢弃一些分支。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-multi-branch-attention-model}
\caption{多分支注意力模型}
\label{fig:15-5}
\label{fig:15-6}
\end{figure}
%-------------------------------------------
......@@ -307,7 +318,16 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\parinterval 虽然，Transformer模型完全摒弃了循环单元与卷积单元，仅通过位置编码来区分序列中的不同位置。但是，循环神经网络也非常适用于处理序列结构，且其结构成熟、易于优化。因此，有研究人员尝试将其与Transformer模型融合。这种方式一方面能够发挥循环神经网络简单高效的特点，另一方面也能够发挥Transformer模型在特征提取方面的优势，是一种非常值得探索的思路\upcite{Chen2018TheBO}。
\parinterval 在Transformer模型中引入循环神经网络的一种方法是，对深层网络的不同层使用循环机制。早在残差网络提出时，研究人员已经开始尝试探讨残差网络成功背后的原因\upcite{DBLP:conf/nips/VeitWB16,DBLP:journals/corr/GreffSS16,DBLP:conf/iclr/ChangMHTB18}。本质上，在卷积神经网络中引入残差连接后，神经网络从深度上隐性地利用循环的特性。也就是，多层Transformer的不同层本身也可以被看作是一个处理序列，只是序列中不同位置（对应不同层）的模型参数独立，而非共享。Transformer编码器与解码器分别由$N$个相同结构但参数独立的块堆叠而成，其中编码块与解码块中分别包含2和3个子层。同时，子层之间引入了残差连接保证了网络信息传递的高效性。因此，一个自然的想法是通过共享不同块之间的参数，引入循环神经网络中的归纳偏置\upcite{DBLP:conf/iclr/DehghaniGVUK19}。其中每层的权重是共享的，并引入了基于时序的编码向量用于显著区分不同深度下的时序信息，{\color{red} 如图XXX所示}。在训练大容量预训练模型时同样也采取了共享层间参数的方式\upcite{Lan2020ALBERTAL}。
\parinterval 在Transformer模型中引入循环神经网络的一种方法是，对深层网络的不同层使用循环机制。早在残差网络提出时，研究人员已经开始尝试探讨残差网络成功背后的原因\upcite{DBLP:conf/nips/VeitWB16,DBLP:journals/corr/GreffSS16,DBLP:conf/iclr/ChangMHTB18}。本质上，在卷积神经网络中引入残差连接后，神经网络从深度上隐性地利用循环的特性。也就是，多层Transformer的不同层本身也可以被看作是一个处理序列，只是序列中不同位置（对应不同层）的模型参数独立，而非共享。Transformer编码器与解码器分别由$N$个相同结构但参数独立的块堆叠而成，其中编码块与解码块中分别包含2和3个子层。同时，子层之间引入了残差连接保证了网络信息传递的高效性。因此，一个自然的想法是通过共享不同块之间的参数，引入循环神经网络中的归纳偏置\upcite{DBLP:conf/iclr/DehghaniGVUK19}。其中每层的权重是共享的，并引入了基于时序的编码向量用于显著区分不同深度下的时序信息，如图\ref{fig:15-8}所示。在训练大容量预训练模型时同样也采取了共享层间参数的方式\upcite{Lan2020ALBERTAL}。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-introducing-rnn-mechanism-into-transformer}
\caption{在Transformer中引入循环机制}
\label{fig:15-8}
\end{figure}
%-------------------------------------------
\parinterval 另一种方法是，利用循环神经网络对输入序列进行编码，之后通过门控机制将得到的结果与Transformer进行融合\upcite{DBLP:conf/naacl/HaoWYWZT19}。融合机制可以采用串行计算或并行计算。
......@@ -605,7 +625,6 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\end{eqnarray}
\parinterval 其中$\textrm{Var}(\cdot)$表示求方差操作，由于在大多数情况下，现有模型中的各种标准化方法可以维持$E[w_j]^2$和$E[x_j]^2$等于或者近似为0。因此，模型中一层神经元输出的方差可以表示为：
\begin{eqnarray}
\textrm{Var}(\mathbi{Z}) &=& \sum_{j=1}^{n_i}{\textrm{Var}(x_j) \textrm{Var}(w_j)} \nonumber \\
&=& {n_i}\textrm{Var}(\mathbi{W})\textrm{Var}(\mathbi{X})
......@@ -620,7 +639,7 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\label{eq:15-43}
\end{eqnarray}
\noindent 其中，$l$为对应的神经网络的层次，$\alpha$为预先设定的超参数来控制缩放的比例。这样，可以通过缩减顶层神经网络输出与输入之间的差异，减少顶层神经网络参数的梯度范数，从而缓解由于神经网络过深所带来的梯度消失问题。
\noindent 其中，$l$为对应的神经网络的层数，$\alpha$为预先设定的超参数来控制缩放的比例。这样，可以通过缩减顶层神经网络输出与输入之间的差异，减少顶层神经网络参数的梯度范数，从而缓解由于神经网络过深所带来的梯度消失问题。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -637,25 +656,24 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\item 计算方差：${\bm \sigma}=\textrm{std}⁡(\mathbi{x}_l+\mathbi{y}_l)$
\vspace{0.5em}
\item 根据均值和方差对输入进行放缩，如下：
\begin{eqnarray}
\mathbi{x}_{l+1}^{\textrm{post}} &=& \frac{\mathbi{x}_l+\mathbi{y}_l-{\bm \mu}}{\bm \sigma} \cdot \mathbi{w}+\mathbi{b}
\label{eq:15-41}
\label{eq:15-44}
\end{eqnarray}
\noindent 其中，$\mathbi{w}$和$\mathbi{b}$为可学习参数。进一步将公式\eqref{eq:15-41}展开后可得：
\noindent 其中，$\mathbi{w}$和$\mathbi{b}$为可学习参数。进一步将公式\eqref{eq:15-44}展开后可得：
\begin{eqnarray}
\mathbi{x}_{l+1}^{\textrm{post}} &=& \frac{\mathbi{x}_l+\mathbi{y}_l}{\bm \sigma} \cdot \mathbi{w} - \frac{\bm \mu}{\bm \sigma} \cdot \mathbi{w}+\mathbi{b} \nonumber \\
&=& \frac{\mathbi{w}}{\bm \sigma} \cdot \mathbi{x}_{l+1}^{\textrm{pre}}-\frac{\mathbi{w}}{\bm \sigma} \cdot {\bm \mu}+\mathbi{b}
\label{eq:15-42}
\label{eq:15-45}
\end{eqnarray}
\vspace{0.5em}
%\vspace{0.5em}
\end{itemize}
\parinterval 可以看到相比于Pre-Norm的计算方式，基于Post-Norm的Transformer中子层的输出为Pre-Norm形式的$\frac{\mathbi{w}}{\bm \sigma}$倍。当$\frac{\mathbi{w}}{\bm \sigma}<1$时，$\mathbi{x}_l$较小，输入与输出之间差异过大，导致深层Transformer系统难以收敛。Lipschitz 初始化策略通过维持条件$\frac{\mathbi{w}}{\bm \sigma}>1$，保证网络输入与输出范数一致，进而缓解梯度消失的问题\upcite{DBLP:conf/acl/XuLGXZ20}。一般情况下，$\mathbi{w}$可以被初始化为1，因此Lipschitz 初始化方法最终的约束条件则为：
\begin{eqnarray}
0\ <\ {\bm \sigma} &=& \textrm{std}⁡(\mathbi{x}_l+\mathbi{y}_l) \ \leq\ 1
\label{eq:15-43}
\label{eq:15-46}
\end{eqnarray}
%----------------------------------------------------------------------------------------
......@@ -664,7 +682,7 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\subsubsection{3. T-Fixup初始化策略}
\parinterval 另外一种初始化方法是从神经网络结构与优化器的计算方式入手。Post-Norm结构在Warmup阶段难以很精确地估计参数的二阶动量，导致训练不稳定问题\upcite{huang2020improving}。 也就是，层标准化是导致深层Transformer难以优化的主要原因之一\upcite{WangLearning}。Post-Norm方式下Transformer的底层网络，尤其是编码器的词嵌入层面临严重的梯度消失问题。问题的原因在于，在不改变层标准化位置的条件下，由于Adam优化器利用滑动平均的方式来估计参数的二阶矩，其方差是无界的。这样，在前期模型只能看到有限数量样本的前提下，其二阶矩很难进行有效的估计。因此反向更新参数时会导致参数的梯度方差过大。
\parinterval 另外一种初始化方法是从神经网络结构与优化器的计算方式入手。Post-Norm结构在Warmup阶段难以精确地估计参数的二阶动量，这导致了训练不稳定问题\upcite{huang2020improving}。也就是，层标准化是导致深层Transformer难以优化的主要原因之一\upcite{WangLearning}。Post-Norm方式下Transformer的底层网络，尤其是编码器的词嵌入层面临严重的梯度消失问题。该问题的原因在于，在不改变层标准化位置的条件下，Adam优化器利用滑动平均的方式来估计参数的二阶矩，其方差是无界的。在训练阶段的前期，由于模型只能看到有限数量样本，因此很难有效的估计参数的二阶矩，导致反向更新参数时参数的梯度方差过大。
\parinterval 除了用Pre-Norm代替Post-Norm结构来训练深层网络，也可以采用去除Warmup策略并移除层标准化机制的方式，并对神经网络中不同的参数矩阵制定相应的缩放机制来保证训练的稳定性\upcite{huang2020improving}。具体的缩放策略如下：
......@@ -672,13 +690,13 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\vspace{0.5em}
\item 类似于标准的Transformer初始化方式，使用Xavier初始化方式来初始化除了词嵌入以外的所有参数矩阵。词嵌入矩阵服从$\mathbb{N}(0,d^{-\frac{1}{2}})$的高斯分布，其中$d$代表词嵌入的维度。
\vspace{0.5em}
\item 对编码器中自注意力模型中的参数矩阵以及前馈神经网络中所有参数矩阵进行缩放因子为$0.67 {L}^{-\frac{1}{4}}$的缩放，$M$ 为编码器层数。
\item 对编码器中自注意力机制的参数矩阵以及前馈神经网络中所有参数矩阵进行缩放因子为$0.67 {L}^{-\frac{1}{4}}$的缩放，$M$ 为编码器层数。
\vspace{0.5em}
\item 对解码器中注意力模型中的参数矩阵以及前馈神经网络中所有参数矩阵进行缩放因子为$(9 {M})^{-\frac{1}{4}}$的缩放，其中$L$为解码器层数。
\item 对解码器中全部注意力机制的参数矩阵以及前馈神经网络中所有参数矩阵进行缩放因子为$(9 {M})^{-\frac{1}{4}}$的缩放，其中$L$为解码器层数。
\vspace{0.5em}
\end{itemize}
\parinterval 这种初始化方法由于没有Warmup策略，学习率会直接从峰值根据参数的更新次数进行退火，大幅度增大了模型收敛的时间。但是，如何进一步解决该初始化方法下的模型收敛速度是比较关键的问题。
\parinterval 这种初始化方法由于没有Warmup策略，学习率会直接从峰值根据参数的更新次数进行退火，大幅度增大了模型收敛的时间。因此，如何进一步解决该初始化方法下的模型收敛速度是比较关键的问题。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -686,10 +704,10 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\subsubsection{4. ADMIN初始化策略}
\parinterval 也有研究发现Post-Norm结构在训练过程中过度依赖残差支路，在训练初期很容易发生参数梯度方差过大的现象\upcite{DBLP:conf/emnlp/LiuLGCH20}。经过分析发现，虽然底层神经网络发生梯度消失是导致训练不稳定的重要因素，但并不是唯一因素。例如，标准Transformer模型中梯度消失的原因在于使用Post-Norm 结构的解码器。尽管通过调整模型结构解决梯度消失问题，模型训练不稳定的问题仍然没有很好地解决。研究人员观测到Post-Norm 结构在训练过程中过于依赖残差支路，而Pre-Norm结构在训练过程中逐渐呈现出对残差支路的依赖性，这更易于网络的训练。进一步从参数更新的角度出发，Pre-Norm由于参数的改变导致网络输出变化的方差经推导后可以表示为$O(\log L)$，而Post-Norm对应的方差为O($L$)。因此，可以尝试减小Post-Norm中由于参数更新导致的输出的方差值，从而达到稳定训练的目的。针对该问题，可以采用两阶段的初始化方法。这里，可以重新定义子层之间的残差连接如下：
\parinterval 也有研究发现Post-Norm结构在训练过程中过度依赖残差支路，在训练初期很容易发生参数梯度方差过大的现象\upcite{DBLP:conf/emnlp/LiuLGCH20}。经过分析发现，虽然底层神经网络发生梯度消失是导致训练不稳定的重要因素，但并不是唯一因素。例如，标准Transformer模型中梯度消失的原因在于使用Post-Norm 结构的解码器。尽管通过调整模型结构解决了梯度消失问题，但是模型训练不稳定的问题仍然没有被很好地解决。研究人员观测到Post-Norm结构在训练过程中过于依赖残差支路，而Pre-Norm结构在训练过程中逐渐呈现出对残差支路的依赖性，这更易于网络的训练。进一步，从参数更新的角度出发，Pre-Norm由于参数的改变导致网络输出变化的方差经推导后可以表示为$O(\log L)$，而Post-Norm对应的方差为$O(L)$。因此，可以尝试减小Post-Norm中由于参数更新导致的输出的方差值，从而达到稳定训练的目的。针对该问题，可以采用两阶段的初始化方法。这里，可以重新定义子层之间的残差连接如下：
\begin{eqnarray}
\mathbi{x}_{l+1} &=& \mathbi{x}_l \cdot {\bm \omega_{l+1}} + F_{l+1}(\mathbi{x}_l)
\label{eq:15-44}
\label{eq:15-47}
\end{eqnarray}
\noindent 其两阶段的初始化方法如下所示：
......@@ -698,12 +716,11 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\vspace{0.5em}
\item Profiling阶段：${\bm \omega_{l+1}} = 1$，只进行前向计算，无需进行梯度计算。在训练样本上计算$F_{l+1}(\mathbi{x}_l)$的方差
\vspace{0.5em}
\item Initialization阶段：通过Profiling阶段得到的$F_{l+1}(\mathbi{x}_l)$的方差来初始化$\bm \omega_{l+1}$：
\item Initialization阶段：通过Profiling阶段得到的$F_{l+1}(\mathbi{x}_l)$的方差来初始化$\bm \omega_{l+1}$：
\begin{eqnarray}
{\bm \omega_{l+1}} &=& \sqrt{\sum_{j<l}\textrm{Var}[F_{l+1}(\mathbi{x}_l)]}
\label{eq:15-45}
{\bm \omega_{l+1}} &=& \sqrt{\sum_{j<l}\textrm{Var}[F_{l+1}(\mathbi{x}_l)]}
\label{eq:15-48}
\end{eqnarray}
\vspace{0.5em}
\end{itemize}
\parinterval 这种动态的参数初始化方法不受限于具体的模型结构，方法有较好的通用性。
......@@ -724,7 +741,7 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\parinterval 所谓渐进式训练是指从浅层神经网络开始，在训练过程中逐渐增加模型的深度。一种比较简单的方法是将模型分为浅层部分和深层部分，之后分别进行训练，最终达到提高模型翻译性能的目的\upcite{DBLP:conf/acl/WuWXTGQLL19}。
\parinterval 另一种方式是动态构建深层模型，并尽可能复用浅层部分的训练结果\upcite{li2020shallow}。假设开始的时候模型包含$l$层神经网络，然后训练这个模型至收敛。之后，直接拷贝这$l$ 层神经网络（包括参数），并堆叠出一个$2l$ 层的模型。之后继续训练，重复这个过程。进行$n$次之后就得到了$(n+1)l$层的模型。图\ref{fig:15-15}给出了在编码器上使用渐进式训练的示意图。
\parinterval 另一种方式是动态构建深层模型，并尽可能复用浅层部分的训练结果\upcite{li2020shallow}。假设开始的时候模型包含$l$层神经网络，然后训练这个模型至收敛。之后，直接拷贝这$l$层神经网络（包括参数），并堆叠出一个$2l$ 层的模型。之后继续训练，重复这个过程。进行$n$次之后就得到了$(n+1) \times l$层的模型。图\ref{fig:15-15}给出了在编码器上使用渐进式训练的示意图。
%----------------------------------------------
\begin{figure}[htp]
......@@ -743,7 +760,7 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\subsubsection{2. 分组稠密连接}
\parinterval 很多研究工作已经发现深层模型不同层之间的稠密连接能够很明显地提高信息传递的效率\upcite{WangLearning,DBLP:conf/cvpr/HuangLMW17,Dou2018ExploitingDR,DBLP:conf/acl/WuWXTGQLL19}。与此同时，对之前层信息的不断复用有助于得到更好的表示，但也带来了计算代价过大的问题。在动态线性层聚合方法（DLCL）中，每一次聚合时都需要重新计算之前每一层表示对当前层输入的贡献度，因此伴随着编码器整体深度的增加，这部分的计算代价变得不可忽略。例如，一个基于动态层聚合的48层Transformer模型比不使用动态层聚合进行训练慢近2倍。同时，缓存中间结果也增加了显存的使用量。比如，即使在使用半精度计算的情况，每张12G显存的GPU上计算的词也不能超过2048个，这导致训练开销急剧增大。
\parinterval 很多研究工作已经发现深层模型不同层之间的稠密连接能够很明显地提高信息传递的效率\upcite{WangLearning,DBLP:conf/cvpr/HuangLMW17,Dou2018ExploitingDR,DBLP:conf/acl/WuWXTGQLL19}。与此同时，对之前层信息的不断复用有助于得到更好的表示，但也带来了计算代价过大的问题。在动态线性层聚合方法（DLCL）中，每一次聚合时都需要重新计算之前每一层表示对当前层输入的贡献度，因此伴随着编码器整体深度的增加，这部分的计算代价变得不可忽略。例如，一个基于动态层聚合的48层Transformer模型比不使用动态层聚合进行训练慢近2倍。同时，缓存中间结果也增加了显存的使用量。比如，即使在使用半精度计算的情况下，每张12G显存的GPU上计算的词也不能超过2048个，这导致训练开销急剧增大。
\parinterval 缓解这个问题的一种方法是使用更稀疏的层间连接方式。其核心思想与动态线性层聚合是类似的，不同点在于可以通过调整层之间连接的稠密程度来降低训练代价。比如，可以将每$p$层分为一组，之后动态线性层聚合只在不同组之间进行。这样，通过调节$p$值的大小可以控制神经网络中连接的稠密程度，作为一种训练代价与翻译性能之间的权衡。显然，标准的Transformer模型\upcite{vaswani2017attention} 和DLCL模型\upcite{WangLearning}都可以看作是该方法的一种特例。如图\ref{fig:15-16}所示：当$p=1$时，每一个单独的块被看作一个独立的组，它等价于基于动态层聚合的DLCL模型；当$p=\infty$时，它等价于正常的Transformer模型。值得注意的是，如果配合渐进式训练。在分组稠密连接中可以设置$p$等于模型层数。
......@@ -762,7 +779,7 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\subsubsection{3. 学习率重置}
\parinterval 尽管渐进式训练策略与分组稠密连接结构可以加速深层模型的训练，但使用传统的学习率衰减策略会导致训练深层模型时的学习率较小，因此模型无法快速地达到收敛状态，同时也影响最终的模型性能。
\parinterval 尽管渐进式训练策略与分组稠密连接结构都可以加速深层模型的训练，但使用传统的学习率衰减策略会导致训练深层模型时的学习率较小，因此模型无法快速地达到收敛状态，同时也影响最终的模型性能。
\parinterval 图\ref{fig:15-17}中的红色曲线描绘了在WMT英德翻译任务上标准Transformer模型的学习率曲线，可以看到当模型训练到40k步时，学习率对比峰值有明显的差距，而此时刚开始训练最终的深层模型，过小的学习率并不利于后期深层网络的充分训练。
......@@ -782,14 +799,14 @@ C(\mathbi{x}_j \mathbi{W}_K,\omega) &=& (\mathbi{x}_{j-\omega},\ldots,\mathbi{x}
\item 在训练的初期，模型会先经历一个学习率预热的过程：
\begin{eqnarray}
lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num \cdot warmup\_steps^{-0.5}
\label{eq:15-46}
\label{eq:15-49}
\end{eqnarray}
\noindent 这里，$step\_num$表示参数更新的次数，$warmup\_step$表示预热的更新次数，$d_{\textrm{model}}$表示Transformer模型的隐层大小，$lr$是学习率。
\vspace{0.5em}
\item 在之后的训练过程中，每当增加模型深度时，学习率都会重置到峰值，之后进行相应的衰减：
\begin{eqnarray}
lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\label{eq:15-47}
\label{eq:15-50}
\end{eqnarray}
\noindent 这里$step\_num$代表学习率重置后更新的步数。
\vspace{0.5em}
......@@ -804,7 +821,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\subsection{深层模型的健壮性训练}
\parinterval 伴随着网络的加深，还会面临另外一个比较严峻的问题\ \dash \ 过拟合。由于参数量的增大，深层模型的输入与输出分布之间的差异也会越来越大，然而不同子层之间的相互适应也会更加的明显，这将导致任意子层网络对其他子层的依赖过大。这种现象在训练阶段是有帮助的，因为不同子层可以协同工作从而更好地拟合训练数据。然而这种方式也降低了模型的泛化能力，即深层模型更容易陷入过拟合问题。
\parinterval 伴随着网络的加深，模型的训练还会面临另外一个比较严峻的问题\ \dash \ 过拟合。由于参数量的增大，深层模型的输入与输出分布之间的差异也会越来越大，然而不同子层之间的相互适应也会更加的明显，这将导致任意子层网络对其他子层的依赖过大。这种现象在训练阶段是有帮助的，因为不同子层可以协同工作从而更好地拟合训练数据。然而这种方式也降低了模型的泛化能力，即深层模型更容易陷入过拟合问题。
\parinterval 通常，可以使用Dropout手段用来缓解过拟合问题（见{\chapterthirteen}）。不幸的是,尽管目前Transformer模型使用了多种Dropout手段（如Residual Dropout、Attention Dropout、 ReLU Dropout等），过拟合问题在深层模型中仍然存在。从图\ref{fig:15-18}中可以看到，深层模型比浅层模型在训练集和校验集的困惑度上都有明显的优势，然而模型在训练一段时间后出现校验集困惑度上涨的现象，说明模型已经过拟合于训练数据。
......@@ -818,16 +835,15 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
%-------------------------------------------
\parinterval {\chapterthirteen}提到的Layer Dropout方法可以有效地缓解这个问题。以编码器为例， Layer Dropout的过程可以被描述为：在训练过程中，对自注意力子层或前馈神经网络子层进行随机丢弃，以减少不同子层之间的相互适应。这里选择Pre-Norm结构作为基础架构，它可以被描述为：
\begin{eqnarray}
\mathbi{x}_{l+1} &=& F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\label{eq:15-48}
\label{eq:15-51}
\end{eqnarray}
\noindent 其中，$\textrm{LN}( \cdot )$表示层标准化函数， $F( \cdot )$表示自注意力机制或者前馈神经网络，$\mathbi{x}_l$表示第$l$个子层的输入。之后，使用一个掩码$\textrm{Mask}$（值为0或1）来控制每个子层是正常计算还是丢弃。于是，该子层的计算公式可以被重写为：
\begin{eqnarray}
\mathbi{x}_{l+1} &=& \textrm{Mask} \cdot F(\textrm{LN}(\mathbi{x}_l))+\mathbi{x}_l
\label{eq:15-49}
\label{eq:15-52}
\end{eqnarray}
\noindent $\textrm{Mask}=0$代表该子层被丢弃，而$\textrm{Mask}=1$代表正常进行当前子层的计算。图\ref{fig:15-19}展示了这个方法与标准Pre-Norm结构之间的区别。
......@@ -841,7 +857,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\end{figure}
%-------------------------------------------
\parinterval 除此之外，在残差网络中，研究人员已经发现底层神经网络的作用是对输入进行抽象表示，而上层神经网络进一步修正这种表示来拟合训练目标，因此底层神经网络对模型最终的输出有很大的影响\upcite{DBLP:journals/corr/GreffSS16}。该结论同样适用于Transformer模型，比如，在训练中，残差支路以及底层的梯度范数通常比较大，这也间接表明底层神经网络在整个优化的过程中需要更大的更新。考虑到这个因素，在设计每一个子层被丢弃的概率时，可以采用自底向上线性增大的策略，保证底层的神经网络相比于顶层更容易保留下来。
\parinterval 除此之外，在残差网络中，研究人员已经发现底层神经网络的作用是对输入进行抽象表示，而上层神经网络会进一步修正这种表示来拟合训练目标，因此底层神经网络对模型最终的输出有很大的影响\upcite{DBLP:journals/corr/GreffSS16}。该结论同样适用于Transformer模型，比如，在训练中，残差支路以及底层的梯度范数通常比较大，这也间接表明底层神经网络在整个优化的过程中需要更大的更新。考虑到这个因素，在设计每一个子层被丢弃的概率时，可以采用自底向上线性增大的策略，保证底层的神经网络相比于顶层更容易保留下来。
%----------------------------------------------------------------------------------------
% NEW SECTION
......@@ -850,17 +866,17 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\sectionnewpage
\section{基于句法的神经机器翻译模型}
\parinterval 在统计机器翻译时代，使用句法信息是一种非常有效的机器翻译建模手段（见{\chaptereight}）。由于句法是人类运用语言的高级抽象结果，使用句法信息（如句法树）可以帮助机器翻译系统对句子结构进行建模，例如，利用句法树提升译文语法结构的正确性。在神经机器翻译中，大多数框架均基于词串进行建模，因此在模型中引入句法树等结构也很有潜力\upcite{DBLP:conf/acl/LiXTZZZ17}。 具体来说，由于传统神经机器翻译模型缺少对句子结构的理解，会导致一些翻译问题：
\parinterval 在统计机器翻译时代，使用句法信息是一种非常有效的机器翻译建模手段（见{\chaptereight}）。由于句法是人类运用语言的高级抽象结果，使用句法信息（如句法树）可以帮助机器翻译系统对句子结构进行建模。例如，利用句法树提升译文语法结构的正确性。在神经机器翻译中，大多数框架均基于词串进行建模，因此在模型中引入句法树等结构也很有潜力\upcite{DBLP:conf/acl/LiXTZZZ17}。 具体来说，由于传统神经机器翻译模型缺少对句子结构的理解，会导致一些翻译问题：
\begin{itemize}
\vspace{0.5em}
\item 过度翻译问题，如：
\item {\small\bfnew{过度翻译问题}}，如：
\begin{equation}
\textrm{“ 两/个/女孩 ”}\ \to \ \textrm{“ two girls and two girls ”} \nonumber
\end{equation}
\vspace{0.5em}
\item 翻译不连贯问题，如：
\item {\small\bfnew{翻译不连贯问题}}，如：
\begin{equation}
\textrm{“ 新生/银行/申请/上市 ”}\ \to \ \textrm{“ new listing bank ”} \nonumber
\end{equation}
......@@ -868,15 +884,15 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\vspace{0.5em}
\end{itemize}
\parinterval 显然，神经机器翻译系统并没有按照合理的句法结构生成译文。也就是说，模型并没有理解句子的结构\upcite{DBLP:conf/acl/LiXTZZZ17}。甚至对于一些语言差异很大的语言对，会出现将介词短语翻译成一个词的情况。虽然可以通过很多手段对上述问题进行求解，但是使用句法树是最直接的解决问题的方法\upcite{DBLP:conf/acl/EriguchiHT16}。
\parinterval 显然，神经机器翻译系统并没有按照合理的句法结构生成译文。也就是说，模型并没有理解句子的结构\upcite{DBLP:conf/acl/LiXTZZZ17}。甚至对于一些语言差异很大的语言对，会出现将介词短语翻译成一个词的情况。虽然可以通过很多手段对上述问题进行求解，但是使用句法树是解决该问题的一种最直接的方法\upcite{DBLP:conf/acl/EriguchiHT16}。
\parinterval 那么在神经机器翻译中，如何将这种离散化的树结构融入到基于分布式表示的翻译模型中呢？有以下两种策略：
\begin{itemize}
\vspace{0.5em}
\item 将句法信息加入到编码器，使得编码器更加充分地表示源语言句子。
\item {\small\bfnew{将句法信息加入到编码器}}，使得编码器更加充分地表示源语言句子。
\vspace{0.5em}
\item 将句法信息加入到解码器，使得翻译模型能生成更符合句法的译文。
\item {\small\bfnew{将句法信息加入到解码器}}，使得翻译模型能生成更符合句法的译文。
\vspace{0.5em}
\end{itemize}
......@@ -886,7 +902,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\subsection{编码器使用句法信息}
\parinterval 编码器中使用句法信息有两种思路，一种思路是在编码器中显性使用树结构进行建模，另一种思路是把句法信息作为特征输入到传统的序列编码器中。这两种思路与统计机器翻译中基于句法树结构的模型和基于句法特征的模型十分相似（见{\chaptereight}）。
\parinterval 在编码器中使用句法信息有两种思路，一种思路是在编码器中显性使用树结构进行建模，另一种思路是把句法信息作为特征输入到传统的序列编码器中。这两种思路与统计机器翻译中基于句法树结构的模型和基于句法特征的模型十分相似（见{\chaptereight}）。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -894,17 +910,16 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\subsubsection{1. 基于句法树结构的编码}
\parinterval 一种简单的方法是将源语言句子编码成一个二叉树结构\footnote[6]{所有句法树都可以通过二叉化方法转化为二叉树（见{\chaptereight}）。}，树节点的信息是由左子树和右子树变换而来，如下所示：
\parinterval 使用句法信息的一种简单的方法是将源语言句子编码成一个二叉树结构\footnote[6]{所有句法树都可以通过二叉化方法转化为二叉树（见{\chaptereight}）。}，树节点的信息是由左子树和右子树变换而来，如下所示：
\begin{eqnarray}
\mathbi{h}_p &=& f_\textrm{tree}(\mathbi{h}_l,\mathbi{h}_r)
\label{eq:15-50}
\label{eq:15-53}
\end{eqnarray}
\noindent 其中，$\mathbi{h}_l$和$\mathbi{h}_r$分别代表了左孩子节点和右孩子节点的神经网络输出（隐层状态），通过一个非线性函数$f_\textrm{tree}(\cdot,\cdot)$得到父节点的状态$\mathbi{h}_p$。 图\ref{fig:15-20} 展示了一个基于树结构的循环神经网络编码器\upcite{DBLP:conf/acl/EriguchiHT16}。这些编码器由下自上组成了一个树型结构，这种树结构的具体连接形式由句法分析决定。其中$\{\mathbi{h}_1,\ldots,\mathbi{h}_m\}$是输入序列所对应的循环神经单元（绿色部分），$\{\mathbi{h}_{m+1},\ldots,\mathbi{h}_{2m-1}\}$对应着树中的节点（红色部分），它的输出由其左右子节点通过公式\eqref{eq:15-50}计算得到。对于注意力模型，图中所有的节点都会参与上下文向量的计算，因此仅需要对{\chapterten}所描述的计算方式稍加修改，如下：
\noindent 其中，$\mathbi{h}_l$和$\mathbi{h}_r$分别代表了左孩子节点和右孩子节点的神经网络输出（隐层状态），通过一个非线性函数$f_\textrm{tree}(\cdot,\cdot)$得到父节点的状态$\mathbi{h}_p$。 图\ref{fig:15-20} 展示了一个基于树结构的循环神经网络编码器\upcite{DBLP:conf/acl/EriguchiHT16}。这些编码器由下自上组成了一个树型结构，这种树结构的具体连接形式由句法分析决定。其中$\{\mathbi{h}_1,\ldots,\mathbi{h}_m\}$是输入序列所对应的循环神经单元（绿色部分），$\{\mathbi{h}_{m+1},\ldots,\mathbi{h}_{2m-1}\}$对应着树中的节点（红色部分），它的输出由其左右子节点通过公式\eqref{eq:15-53}计算得到。对于注意力模型，图中所有的节点都会参与上下文向量的计算，因此仅需要对{\chapterten}所描述的计算方式稍加修改，如下：
\begin{eqnarray}
\mathbi{C}_j &=& \sum_{i=1}^{m}\alpha_{i,j}\mathbi{h}_i + \sum_{i=m+1}^{2m-1}\alpha_{i,j}\mathbi{h}_i
\label{eq:15-51}
\label{eq:15-54}
\end{eqnarray}
%----------------------------------------------
......@@ -923,7 +938,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\noindent 可以翻译成：
\begin{equation}
\textrm{“私は緑茶を飲んでいます。”} （{\color{red} 日语单词没有切分？？？可以问一下张妍}）\nonumber
\textrm{“私/は/緑茶/を/飲んでいます。”} \nonumber
\end{equation}
\parinterval 在标准的英语到日语的翻译中，英语短语“a cup of green tea”只会被翻译为“緑茶”一词。在加入句法树后，“a cup of green tea”会作为树中一个节点，这样可以更容易把英语短语作为一个整体进行翻译。
......@@ -948,7 +963,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\parinterval 不同于直接对树结构进行编码，另一种方法是将单词、句法信息等直接转换为特征向量拼接到一起，作为机器翻译系统的输入\upcite{DBLP:conf/wmt/SennrichH16}。这种方法的优点在于，句法信息可以无缝融入到现有神经机器翻译框架，对系统结构的修改很小。以基于循环神经网络的翻译模型为例，可以用如下方式计算输入序列第$i$个位置的表示结果：
\begin{eqnarray}
\mathbi{h}_i &=& \textrm{tanh}(\mathbi{W}(\|_{k=1}^{F}\mathbi{E}_k x_{ik}) + \mathbi{U}\mathbi{h}_{i-1})
\label{eq:15-52}
\label{eq:15-55}
\end{eqnarray}
\noindent 其中，$\mathbi{W}$和$\mathbi{U}$是线性变换矩阵，$F$代表了特征的数量；而$\mathbi{E}_k$是一个特征嵌入矩阵，它记录了第$k$个特征不同取值对应的分布式表示；$x_{ik}$ 代表了第$i$ 个词在第$k$ 个特征上的取值，于是$\mathbi{E}_k x_{ik}$就得到所激活特征的嵌入结果。$\|$操作为拼接操作，它将所有特征的嵌入结果拼接为一个向量。这种方法十分灵活，可以很容易地融合不同句法特征，例如，词根、子词、形态、词性以及依存关系等。
......@@ -964,23 +979,18 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\end{figure}
%-------------------------------------------
\parinterval 在对句法树结构进行序列化的基础上，可以用句法树节点与原始的词信息构造出新的融合表示${\mathbi{h}'}_i$，并使用这种新的表示计算上下文向量，如下：
\parinterval 在对句法树的树结构进行序列化的基础上，可以用句法树节点与原始的词信息一同构造出新的融合表示${\mathbi{h}'}_i$，并使用这种新的表示计算上下文向量，如下：
\begin{eqnarray}
\mathbi{C}_j &=& \sum_{i=1}^m \alpha_{i,j} {\mathbi{h}'}_i
\label{eq:15-53}
\label{eq:15-56}
\end{eqnarray}
\noindent 其中，$m$是源语言句子的长度。新的融合表示${\mathbi{h}'}_i$有如下几种计算方式\upcite{DBLP:conf/acl/LiXTZZZ17}：
\begin{itemize}
\vspace{0.5em}
\item 平行结构。利用两个编码器分别对源语言单词序列和线性化的句法树进行建模，之后在句法树节点序列中寻找每个单词的父节点（或者祖先节点），将这个单词和它的父节点（或者祖先节点）的状态相融合，得到新的表示。如图\ref{fig:15-23}(a)所示，图中$\mathbi{h}_{w_i}$为词$w_i$在单词序列中的状态，$\mathbi{h}_{l_j}$为树节点$l_j$在句法节点序列中的状态。如果单词$w_i$是节点$l_j$ 在句法树中的子节点，则将$\mathbi{h}_{w_i}$和$\mathbi{h}_{l_j}$向量拼接到一起作为这个词的新表示${\mathbi{h}'}_i$；
\vspace{0.5em}
\item 分层结构。将句法表示结果与源语言单词的词嵌入向量进行融合，如图\ref{fig:15-23}(b)所示，其中$\mathbi{e}_{w_i}$为第$i$个词的词嵌入。类似地，如果单词$w_i$是节点$l_j$在句法树中的子节点，则将$\mathbi{e}_{w_i}$和$\mathbi{h}_{l_j}$向量拼接到一起作为原始模型的输入，这样${\mathbi{h}'}_i$直接参与注意力计算。注意，分层结构和平行结构的区别在于，分层结构最终还是使用了一个编码器，句法信息只是与词嵌入进行融合，因此最终的结构和原始的模型是一致的；平行结构相当于使用了两个编码器，因此单词和句法信息的融合是在两个编码器的输出上进行的；
\item {\small\bfnew{平行结构}}。利用两个编码器分别对源语言单词序列和线性化的句法树进行建模，之后在句法树节点序列中寻找每个单词的父节点（或者祖先节点），将这个单词和它的父节点（或者祖先节点）的状态相融合，得到新的表示。如图\ref{fig:15-23}(a)所示，图中$\mathbi{h}_{w_i}$为词$w_i$在单词序列中的状态，$\mathbi{h}_{l_j}$为树节点$l_j$在句法节点序列中的状态。如果单词$w_i$是节点$l_j$ 在句法树（图\ref{fig:15-22}(a)）中的子节点，则将$\mathbi{h}_{w_i}$和$\mathbi{h}_{l_j}$向量拼接到一起作为这个词的新的融合表示向量${\mathbi{h}'}_i$；
\vspace{0.5em}
\item 混合结构。首先对图\ref{fig:15-22}(a)中句法树进行先序遍历，将句法标记和源语言单词融合到同一个序列中，得到如图\ref{fig:15-23}(c)所示序列。之后使用传统的序列编码器对这个序列进行编码，然后使用序列中源语言单词所对应的状态参与注意力模型的计算。有趣的是，相比于前两种方法，这种方法参数量少而且也十分有效\upcite{DBLP:conf/acl/LiXTZZZ17}。
\vspace{0.5em}
\end{itemize}
%----------------------------------------------
\begin{figure}[htp]
......@@ -993,6 +1003,12 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\end{figure}
%-------------------------------------------
\item {\small\bfnew{分层结构}}。将句法表示结果与源语言单词的词嵌入向量进行融合，如图\ref{fig:15-23}(b)所示，其中$\mathbi{e}_{w_i}$为第$i$个词的词嵌入。类似地，如果单词$w_i$是节点$l_j$在句法树（图\ref{fig:15-22}(a)）中的子节点，则将$\mathbi{e}_{w_i}$和$\mathbi{h}_{l_j}$向量拼接到一起作为原始模型的输入，这样${\mathbi{h}'}_i$直接参与注意力计算。注意，分层结构和平行结构的区别在于，分层结构最终还是使用了一个编码器，句法信息只是与词嵌入进行融合，因此最终的结构和原始的模型是一致的；平行结构相当于使用了两个编码器，因此单词和句法信息的融合是在两个编码器的输出上进行的；
\vspace{0.5em}
\item {\small\bfnew{混合结构}}。首先对图\ref{fig:15-22}(a)中句法树进行先序遍历，将句法标记和源语言单词融合到同一个序列中，得到如图\ref{fig:15-23}(c)所示序列。之后使用传统的序列编码器对这个序列进行编码，然后使用序列中源语言单词所对应的状态参与注意力模型的计算。有趣的是，相比于前两种方法，这种方法参数量少而且也十分有效\upcite{DBLP:conf/acl/LiXTZZZ17}。
\vspace{0.5em}
\end{itemize}
\parinterval 需要注意的是，句法分析的错误会在很大程度上影响源语言句子的表示结果。如果获得的句法分析结果不够准确，可能会对翻译系统带来负面的作用。此外，也有研究发现基于词串的神经机器翻译模型本身就能学习到一些源语言的句法信息\upcite{DBLP:conf/emnlp/ShiPK16}，这表明了神经机器翻译模型也有一定的归纳句子结构的能力。除了循环神经网络结构，也有研究人员探索了如何在Transformer中引入树结构信息。比如，可以将词与词之间的依存关系距离作为额外的语法信息融入到注意力模型中\upcite{DBLP:conf/acl/BugliarelloO20}。
%----------------------------------------------------------------------------------------
......@@ -1001,7 +1017,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\subsection{解码器使用句法信息}\label{subsec-15.3.2}
\parinterval 在解码器中使用句法信息，一种最直接的方式是将目标语言句法树结构进行线性化，然后目标语言句子就变成了一个含有句法标记和单词的混合序列。这样，神经机器翻译系统不需要进行修改，直接使用句法树序列化的结果进行训练和推断\upcite{Aharoni2017TowardsSN}。图\ref{fig:15-24}展示了一个目标语言句法树经过线性化后的结果。
\parinterval 在解码器中使用句法信息，一种最直接的方式是将目标语言句法树结构进行线性化，然后目标语言句子就变成了一个含有句法标记和单词的混合序列。这样，神经机器翻译系统不需要进行修改，可以直接使用句法树序列化的结果进行训练和推断\upcite{Aharoni2017TowardsSN}。图\ref{fig:15-24}展示了一个目标语言句法树经过线性化后的结果。
%----------------------------------------------
\begin{figure}[htp]
......@@ -1033,7 +1049,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\begin{figure}[htp]
\centering
\input{./Chapter15/Figures/figure-parallel-RNN-structure}
\caption{词预测模型和动作模型（{\color{red} 看前面的文字：一个叫动作模型，一个叫词预测模型。还有右侧图的依存的箭头方向一定再确定一下！}）}
\caption{词预测模型和动作模型}
\label{fig:15-26}
\end{figure}
%-------------------------------------------
......@@ -1066,7 +1082,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\end{figure}
%-------------------------------------------
\parinterval 那么网络结构搜索究竟是一种什么样的技术呢？如图\ref{fig:15-28}所示，在传统机器学习方法中，研究人员需要设计大量的特征来描述待解决的问题，即“特征工程”。在深度学习时代，神经网络模型可以完成特征的抽取和学习，但是却需要人工设计神经网络结构，这项工作仍然十分繁重。因此一些科研人员开始思考，能否将设计模型结构的工作也交由机器自动完成？深度学习方法中模型参数能够通过梯度下降等方式进行自动优化，那么模型结构是否可以也看做是一种特殊的参数，使用搜索算法自动找到最适用于当前任务的模型结构？网络结构搜索应运而生。
\parinterval 那么网络结构搜索究竟是一种什么样的技术呢？如图\ref{fig:15-28}所示，在传统机器学习方法中，研究人员需要设计大量的特征来描述待解决的问题，即“特征工程”。在深度学习时代，神经网络模型可以完成特征的抽取和学习，但是却需要人工设计神经网络结构，这项工作仍然十分繁重。因此一些科研人员开始思考，能否将设计模型结构的工作也交由机器自动完成？深度学习方法中模型参数能够通过梯度下降等方式进行自动优化，那么模型结构是否可以也看做是一种特殊的参数，使用搜索算法自动找到最适用于当前任务的模型结构？基于上述想法，网络结构搜索应运而生。
%----------------------------------------------
\begin{figure}[htp]
......@@ -1077,7 +1093,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\end{figure}
%-------------------------------------------
\parinterval 早在上世纪八十年代，研究人员就开始使用进化算法对神经网络结构进行设计\upcite{DBLP:conf/icga/MillerTH89}，也引发了之后的很多探索\upcite{koza1991genetic,DBLP:conf/nips/HarpSG89,DBLP:journals/compsys/Kitano90}。近些年，随着深度学习技术的发展，网络结构搜索技术在很多任务中受到关注。例如，例如网络结构索索就很好的应用在语言建模上，并取得了很好的结果\upcite{DBLP:conf/iclr/LiuSY19,DBLP:conf/acl/LiHZXJXZLL20,DBLP:conf/emnlp/JiangHXZZ19}。下面将对网络结构搜索的基本方法和其在机器翻译中的应用进行介绍。
\parinterval 早在上世纪八十年代，研究人员就开始使用进化算法对神经网络结构进行设计\upcite{DBLP:conf/icga/MillerTH89}，也引发了之后的很多探索\upcite{koza1991genetic,DBLP:conf/nips/HarpSG89,DBLP:journals/compsys/Kitano90}。近些年，随着深度学习技术的发展，网络结构搜索技术在很多任务中受到关注。例如，网络结构搜索就很好的应用在语言建模上，并取得了很好的结果\upcite{DBLP:conf/iclr/LiuSY19,DBLP:conf/acl/LiHZXJXZLL20,DBLP:conf/emnlp/JiangHXZZ19}。下面将对网络结构搜索的基本方法和其在机器翻译中的应用进行介绍。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -1089,7 +1105,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\begin{eqnarray}
\hat{a} &=& \arg\max_{a}\sum_{i=1}^{n}{\funp{P}(\mathbi{y}_{i}|\mathbi{x}_{i};a)}
\label{eq:15-54}
\label{eq:15-57}
\end{eqnarray}
\noindent 其中，$\funp{P}(\mathbi{y}_{i}|\mathbi{x}_{i};a)$为模型$a$观察到数据$\mathbi{x}_{i}$后预测$\mathbi{y}_{i}$的概率，而模型结构$a$本身可以看作是输入$\mathbi{x}$到输出$\mathbi{y}$ 的映射函数。图\ref{fig:15-29}展示了神经网络结构搜索方法的主要流程，其中包括三个部分：设计搜索空间、选择搜索策略以及进行性能评估，下面将对上述各个部分进行简要介绍。
......@@ -1124,9 +1140,9 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\begin{itemize}
\vspace{0.5em}
\item 整体框架：如图\ref{fig:15-30}所示，整体框架一般基于经验进行设计。比如，对于包括机器翻译在内的自然语言处理任务而言，一般会更倾向于使用循环神经网络或Transformer模型的相关结构作为搜索空间\upcite{DBLP:conf/icml/SoLL19,DBLP:conf/iclr/ZophL17,DBLP:conf/iclr/LiuSY19}。
\item {\small\bfnew{整体框架}}。如图\ref{fig:15-30}所示，整体框架一般基于经验进行设计。比如，对于包括机器翻译在内的自然语言处理任务而言，一般会更倾向于使用循环神经网络或Transformer模型的相关结构作为搜索空间\upcite{DBLP:conf/icml/SoLL19,DBLP:conf/iclr/ZophL17,DBLP:conf/iclr/LiuSY19}。
\vspace{0.5em}
\item 内部结构：对于内部结构的设计需要考虑到搜索过程中的最小搜索单元，以及搜索单元之间的连接方式。最小搜索单元指的是在结构搜索过程中可被选择的最小独立计算单元，在不同搜索空间的设计中，最小搜索单元的颗粒度各有不同，较小的搜索粒度主要包括如矩阵乘法、张量缩放等基本数学运算\upcite{DBLP:journals/corr/abs-2003-03384}，更大粒度的搜索单元包括常见的激活函数以及一些局部结构，如ReLU、注意力机制等\upcite{DBLP:conf/acl/LiHZXJXZLL20,Chollet2017XceptionDL,DBLP:journals/taslp/FanTXQLL20}。不过，对于搜索颗粒度的问题，目前还缺乏有效的方法针对不同任务进行自动优化。
\item {\small\bfnew{内部结构}}。对于内部结构的设计需要考虑到搜索过程中的最小搜索单元，以及搜索单元之间的连接方式。最小搜索单元指的是在结构搜索过程中可被选择的最小独立计算单元，在不同搜索空间的设计中，最小搜索单元的颗粒度各有不同，较小的搜索粒度主要包括如矩阵乘法、张量缩放等基本数学运算\upcite{DBLP:journals/corr/abs-2003-03384}，更大粒度的搜索单元包括常见的激活函数以及一些局部结构，如ReLU、注意力机制等\upcite{DBLP:conf/acl/LiHZXJXZLL20,Chollet2017XceptionDL,DBLP:journals/taslp/FanTXQLL20}。不过，对于搜索颗粒度的问题，目前还缺乏有效的方法针对不同任务进行自动优化。
\vspace{0.5em}
\end{itemize}
......@@ -1136,14 +1152,13 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\subsubsection{2. 搜索策略}
\parinterval 在定义好搜索空间之后，如何进行网络结构的搜索也同样重要。该过程被称为搜索策略的设计，其主要目的是根据已找到的模型结构计算出下一个最有潜力的模型结构，为保证模型有效性，在一些方法中也会引入外部知识（如经验性的模型结构或张量运算规则）对搜索过程进行剪枝。目前常见的搜索策略一般包括基于进化算法的方法、基于强化学习的方法、基于梯度的方法等方式。
\parinterval 在定义好搜索空间之后，如何进行网络结构的搜索也同样重要。该过程被称为搜索策略的设计，其主要目的是根据已找到的模型结构计算出下一个最有潜力的模型结构，为保证模型有效性，在一些方法中也会引入外部知识（如经验性的模型结构或张量运算规则）对搜索过程进行剪枝。目前常见的搜索策略一般包括基于进化算法的方法、基于强化学习的方法以及基于梯度的方法等等。
\begin{itemize}
\vspace{0.5em}
\item 进化算法：进化算法最初被用来对神经网络模型结构以及权重参数进行优化\upcite{DBLP:conf/icga/MillerTH89,DBLP:journals/tnn/AngelineSP94,stanley2002evolving}。随着最优化算法的发展，近年来，对于网络参数的学习更多地采用梯度下降法的方式，但是进化算法仍被用于对模型结构进行优化\upcite{DBLP:conf/icml/RealMSSSTLK17,DBLP:conf/iclr/ElskenMH19,DBLP:conf/iclr/LiuSVFK18}。从结构优化的角度来说，一般是将模型结构看做遗传算法中种群的个体，使用轮盘赌或锦标赛等抽取方式，对种群中的结构进行取样作为亲本，之后通过亲本模型的突变产生新的模型结构，最终对这些新的模型结构进行适应度评估。根据模型结构在校验集上的性能确定是否将其加入种群。
\item {\small\bfnew{进化算法}}。进化算法最初被用来对神经网络模型结构、以及其中的权重参数进行优化\upcite{DBLP:conf/icga/MillerTH89,DBLP:journals/tnn/AngelineSP94,stanley2002evolving}。随着最优化算法的发展，近年来，对于网络参数的学习开始更多地采用梯度下降的方式，但是进化算法依旧被用于对模型结构进行优化\upcite{DBLP:conf/icml/RealMSSSTLK17,DBLP:conf/iclr/ElskenMH19,DBLP:conf/iclr/LiuSVFK18}。从结构优化的角度来说，一般是将模型结构看做遗传算法中种群的个体，使用轮盘赌或锦标赛等抽取方式，对种群中的结构进行取样作为亲本，之后通过亲本模型的突变产生新的模型结构，最终对这些新的模型结构进行适应度评估。根据模型结构在校验集上的性能确定是否将其加入种群。
\vspace{0.5em}
\item 强化学习：强化学习方法在{\chapterthirteen}已经进行了介绍，这里可以将神经网络结构的设计看做是一种序列生成任务，使用字符序列对网络结构进行表述\upcite{DBLP:conf/iclr/ZophL17}。这种方法的执行过程如图\ref{fig:15-33}所示。
\item {\small\bfnew{强化学习}}。强化学习方法在{\chapterthirteen}已经进行了介绍，这里可以将神经网络结构的设计看做是一种序列生成任务，使用字符序列对网络结构进行表述\upcite{DBLP:conf/iclr/ZophL17}。这种方法的执行过程如图\ref{fig:15-33}所示。
%----------------------------------------------
\begin{figure}[htp]
......@@ -1155,7 +1170,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
%-------------------------------------------
\vspace{0.5em}
\item 基于梯度的方法：这种方法的思想是在连续空间中对模型结构进行表示\upcite{DBLP:conf/iclr/LiuSY19}，通常将模型结构建模为超网络中的权重，使用基于梯度的优化方法对权重进行优化，最终达到归纳结构的目的，如图\ref{fig:15-34}所示。基于梯度的方法十分高效，因此也受到了很多关注\upcite{DBLP:conf/cvpr/WuDZWSWTVJK19,DBLP:conf/iclr/XuX0CQ0X20,DBLP:conf/acl/LiHZXJXZLL20}。
\item {\small\bfnew{基于梯度的方法}}。这种方法的思想是在连续空间中对模型结构进行表示\upcite{DBLP:conf/iclr/LiuSY19}，通常将模型结构建模为超网络中的权重，使用基于梯度的优化方法对权重进行优化，最终达到归纳结构的目的，如图\ref{fig:15-34}所示。基于梯度的方法十分高效，因此也受到了很多关注\upcite{DBLP:conf/cvpr/WuDZWSWTVJK19,DBLP:conf/iclr/XuX0CQ0X20,DBLP:conf/acl/LiHZXJXZLL20}。
\vspace{0.5em}
%----------------------------------------------
......@@ -1175,15 +1190,15 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\subsubsection{3. 性能评估}\label{subsubsec-15.4.2.3}
\parinterval 由于结构搜索过程中会产生大量的中间结构，因此需要快速评估这些结构的性能优劣，以保证搜索中可以有效的挑选高质量的模型结构。有以下三方面问题需要考虑：
\parinterval 由于结构搜索过程中会产生大量的中间结构，因此需要快速评估这些结构的性能优劣，以保证在搜索中可以有效地挑选高质量的模型结构。对于该问题，可以从以下三个方面来考虑：
\begin{itemize}
\vspace{0.5em}
\item 数据以及超参数的调整：具体来说，可以用少量的数据训练模型，以便快速评估其性能\upcite{DBLP:conf/aistats/KleinFBHH17,DBLP:journals/corr/ChrabaszczLH17}。在超参数的调整方面，也可以通过减少模型训练轮数、减少模型的层数等方式来简化模型参数，达到加速训练、评估的目的\upcite{DBLP:conf/cvpr/ZophVSL18,Real2019AgingEF,DBLP:journals/corr/abs-1807-06906}。
\item {\small\bfnew{数据以及超参数的调整}}。具体来说，可以用少量的数据训练模型，以便快速评估其性能\upcite{DBLP:conf/aistats/KleinFBHH17,DBLP:journals/corr/ChrabaszczLH17}。在超参数的调整方面，也可以通过减少模型训练轮数、减少模型的层数等方式来简化模型参数，达到加速训练、评估的目的\upcite{DBLP:conf/cvpr/ZophVSL18,Real2019AgingEF,DBLP:journals/corr/abs-1807-06906}。
\vspace{0.5em}
\item 现有参数的继承及复用：另一类方法在现有的模型参数基础上，继续优化中间过程产生的模型结构，以加快待评价模型的收敛进程\upcite{DBLP:conf/icml/RealMSSSTLK17,DBLP:conf/iclr/ElskenMH19,DBLP:conf/aaai/CaiCZYW18}。这种方式无需从头训练搜索过程中间过程产生的模型结构，通过“热启动”的方式对模型参数进行优化，大幅减少性能评估过程的时间消耗。
\item {\small\bfnew{现有参数的继承及复用}}。通过在现有的模型参数基础上，继续优化中间过程产生的模型结构，来加快待评价模型的收敛进程\upcite{DBLP:conf/icml/RealMSSSTLK17,DBLP:conf/iclr/ElskenMH19,DBLP:conf/aaai/CaiCZYW18}。这种方式无需从头训练搜索过程中间过程产生的模型结构，通过“热启动”的方式对模型参数进行优化，能够大幅减少性能评估过程的时间消耗。
\vspace{0.5em}
\item 模型性能的预测：这种方式使用训练过程中的性能变化曲线来预估模型是否具有潜力，从而快速终止低性能模型的训练过程\upcite{DBLP:conf/ijcai/DomhanSH15,DBLP:conf/iclr/KleinFSH17,DBLP:conf/iclr/BakerGRN18}。
\item {\small\bfnew{模型性能的预测}}。这种方式使用训练过程中的性能变化曲线来预估模型是否具有潜力，从而快速终止低性能模型的训练过程\upcite{DBLP:conf/ijcai/DomhanSH15,DBLP:conf/iclr/KleinFSH17,DBLP:conf/iclr/BakerGRN18}。
\vspace{0.5em}
\end{itemize}
......@@ -1193,7 +1208,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\subsection{机器翻译任务下的结构搜索}
\parinterval 对于自然语言处理的任务来说，网络结构搜索方法更多是在语言建模、命名实体识别等任务上进行的尝试\upcite{DBLP:conf/acl/LiHZXJXZLL20,DBLP:conf/emnlp/JiangHXZZ19}。其中，大多数工作是在基于循环神经网络的模型结构上进行探索，相较目前在机器翻译领域中广泛使用的Transformer模型结构来说，它们在性能上并没有体现出绝对优势。此外，由于机器翻译任务的复杂性，针对基于Transformer 的机器翻译模型的结构搜索方法会更少一些。不过仍有部分工作在机器翻译任务上取得了很好的表现。例如，在WMT19机器翻译比赛中，神经网络结构优化方法在多个任务上取得了很好的成绩\upcite{DBLP:conf/nips/LuoTQCL18,DBLP:conf/wmt/XiaTTGHCFGLLWWZ19}。对于结构搜索在机器翻译领域的应用目前主要包括两个方面，分别是对模型性能的改进以及模型效率的优化：
\parinterval 对于自然语言处理任务来说，网络结构搜索方法更多是在语言建模、命名实体识别等任务上进行尝试\upcite{DBLP:conf/acl/LiHZXJXZLL20,DBLP:conf/emnlp/JiangHXZZ19}。其中，大多数工作是在基于循环神经网络的模型结构上进行探索的，相较于目前在机器翻译领域中广泛使用的Transformer模型结构来说，这些搜索到的结构在性能上并没有体现出绝对的优势。此外，由于机器翻译任务的复杂性，针对基于Transformer的机器翻译模型的结构搜索方法会更少一些。不过仍有部分工作在机器翻译任务上取得了很好的表现。例如，在WMT19机器翻译比赛中，神经网络结构优化方法在多个任务上取得了很好的成绩\upcite{DBLP:conf/nips/LuoTQCL18,DBLP:conf/wmt/XiaTTGHCFGLLWWZ19}。对于结构搜索在机器翻译领域的应用，目前主要包括两个方面：分别是对模型性能的改进以及模型效率的优化。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -1205,23 +1220,20 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\begin{itemize}
\vspace{0.5em}
\item 搜索模型中的局部结构：在机器翻译任务中，一种典型的局部模型结构搜索方法是面向激活函数的搜索\upcite{DBLP:conf/iclr/RamachandranZL18}，该方法将激活函数看作是一元、二元函数的若干次复合。例如，Swish 激活函数就是一种被找到的新的激活函数，如下：
\item {\small\bfnew{搜索模型中的局部结构}}。在机器翻译任务中，一种典型的局部模型结构搜索方法是面向激活函数的搜索\upcite{DBLP:conf/iclr/RamachandranZL18}，该方法将激活函数看作是一元、二元函数的若干次复合。例如，Swish 激活函数就是一种被找到的新的激活函数，如下：
\begin{eqnarray}
f(x) &=& x \cdot \delta(\beta x) \\
\delta(z) &=& {(1 + \exp{(-z)})}^{-1}
\label{eq:15-60}
\end{eqnarray}
\noindent 相比传统人工设计的激活函数ReLU而言，Swish函数在多个机器翻译任务取得了不错的效果。
\noindent 相比于人工设计的激活函数ReLU而言，Swish函数在多个机器翻译任务取得了不错的效果。
\vspace{0.5em}
\item 搜索模型中局部结构的组合：在基于Transformer模型的网络结构搜索任务中，对于局部结构的组合方式的学习也受到了很多关注，其中包括基于进化算法的方法和基于梯度对现有Transformer模型结构进行改良\upcite{DBLP:conf/icml/SoLL19,DBLP:journals/taslp/FanTXQLL20}。与前文所述的对局部结构的改良不同，此处更多地是对现有经验性的局部结构进行组合，找到最佳的整体结构。在模型结构的表示方法上，这些方法会根据先验知识为搜索单元设定一个部分框架，如每当信息传递过来之后先进行层标准化，之后再对候选位置上的操作使用对应的搜索策略进行搜索。另外这类方法也会在Transformer结构中引入多分支结构，一个搜索单元的输出可以被多个后续单元所使用，这种方式有效扩大了结构搜索过程中的搜索空间，能够在现有Transformer结构的基础上找到更优的模型结构。
\item {\small\bfnew{搜索模型中局部结构的组合}}。在基于Transformer模型的网络结构搜索任务中，对于局部结构的组合方式的学习也受到了很多关注，其中包括基于进化算法的方法和基于梯度对现有Transformer模型结构的改良\upcite{DBLP:conf/icml/SoLL19,DBLP:journals/taslp/FanTXQLL20}。与前文所述的对局部结构的改良不同，此处更多地是对现有经验性的局部结构进行组合，找到最佳的整体结构。在模型结构的表示方法上，这些方法会根据先验知识为搜索单元设定一个部分框架，如每当信息传递过来之后先进行层标准化，之后再对候选位置上的操作使用对应的搜索策略进行搜索。另外这类方法也会在Transformer结构中引入多分支结构，一个搜索单元的输出可以被多个后续单元所使用，这种方式有效扩大了结构搜索过程中的搜索空间，能够在现有Transformer结构的基础上找到更优的模型结构。
\vspace{0.5em}
\end{itemize}
\parinterval 此外对模型结构中超参数的自动搜索同样能够有效提升模型的性能\upcite{DBLP:journals/corr/abs-2009-02070}，在机器翻译中也有应用\upcite{Li2020NeuralMT}。
\parinterval 此外对模型结构中超参数的自动搜索同样能够有效提升模型的性能\upcite{DBLP:journals/corr/abs-2009-02070}，这种方法在机器翻译中也有应用\upcite{Li2020NeuralMT}。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -1229,14 +1241,13 @@ f(x) &=& x \cdot \delta(\beta x) \\
\subsubsection{2. 模型效率优化}
\parinterval 除了能够提高机器翻译模型性能之外，网络结构搜索也能够优化模型的执行效率。从实用的角度出发，可以在进行结构搜索的同时考虑设备的计算能力，希望找到更适合运行设备的模型结构。同时也可以对大模型进行压缩，加速其在推断过程中的效率，这方面的工作不仅限于在机器翻译模型上，也有部分工作对基于注意力机制的预训练模型进行压缩。
\parinterval 网络结构搜索除了能够提高机器翻译模型性能之外，也能够优化模型的执行效率。从实用的角度出发，可以在进行结构搜索的同时考虑设备的计算能力，希望找到更适合运行设备的模型结构。同时，网络结构搜索也可以用来对大模型进行压缩，加速其在推断过程中的效率，这方面的工作不仅限于在机器翻译模型上，也有部分工作对基于注意力机制的预训练模型进行压缩。
\begin{itemize}
\vspace{0.5em}
\item 面向特定设备的模型结构优化：可以在结构优化的过程中将设备的算力作为一个约束\upcite{DBLP:conf/acl/WangWLCZGH20}。具体来说，可以将搜索空间中各种结构建模在同一个超网络中，通过权重共享的方式进行训练。使用设备算力约束子模型，并通过进化算法对子模型进行搜索，搜索到适用于目标设备的模型结构。该方法搜索到的模型能够在保证模型性能不变前提下获得较大的效率提升。
\item {\small\bfnew{面向特定设备的模型结构优化}}。可以在结构优化的过程中将设备的算力作为一个约束\upcite{DBLP:conf/acl/WangWLCZGH20}。具体来说，可以将搜索空间中各种结构建模在同一个超网络中，通过权重共享的方式进行训练。使用设备算力约束子模型，并通过进化算法对子模型进行搜索，搜索到适用于目标设备的模型结构。该方法搜索到的模型能够在保证模型性能不变前提下获得较大的效率提升。
\vspace{0.5em}
\item 模型压缩：此外，在不考虑设备算力的情况下，也可以通过结构搜索方法对基于Transformer的预训练模型进行压缩。例如，将Transformer模型拆分为若干小组件，然后通过基于采样的结构搜索方法对压缩后的模型结构进行搜索，尝试找到最优且高效的推断模型\upcite{DBLP:journals/corr/abs-2008-06808}。类似的，也可以在基于BERT的预训练模型上通过结构搜索方法进行模型压缩，通过基于梯度的结构搜索方法，针对不同的下游任务将BERT模型压缩为小模型\upcite{DBLP:conf/ijcai/ChenLQWLDDHLZ20}。
\item {\small\bfnew{模型压缩}}。此外，在不考虑设备算力的情况下，也可以通过结构搜索方法对基于Transformer的预训练模型进行压缩。例如，将Transformer模型拆分为若干小组件，然后通过基于采样的结构搜索方法对压缩后的模型结构进行搜索，尝试找到最优且高效的推断模型\upcite{DBLP:journals/corr/abs-2008-06808}。类似的，也可以在基于BERT的预训练模型上通过结构搜索方法进行模型压缩，通过基于梯度的结构搜索方法，针对不同的下游任务将BERT模型压缩为小模型\upcite{DBLP:conf/ijcai/ChenLQWLDDHLZ20}。
\vspace{0.5em}
\end{itemize}
......@@ -1251,18 +1262,18 @@ f(x) &=& x \cdot \delta(\beta x) \\
\sectionnewpage
\section{小结及拓展阅读}
\parinterval 模型结构优化一直是机器翻译研究的重要方向。一方面，对于通用框架（如注意力机制）的结构改良可以服务于多种自然语言处理任务，另一方面，针对机器翻译的问题设计相适应的模型结构也是极具价值的。本章节重点介绍了神经机器翻译中结构优化的几种方法，内容涉及注意力机制的改进、深层神经网络的构建、句法结构的使用以及自动结构搜索等几个方面。此外，还有若干问题值得关注：
\parinterval 模型结构优化一直是机器翻译研究的重要方向。一方面，对于通用框架（如注意力机制）的结构改良可以服务于多种自然语言处理任务，另一方面，针对机器翻译中存在的问题设计相适应的模型结构也是极具价值的。本章节重点介绍了神经机器翻译中几种结构优化方法，内容涉及注意力机制的改进、深层神经网络的构建、句法结构的使用以及自动结构搜索等几个方面。此外，还有若干问题值得关注：
\begin{itemize}
\vspace{0.5em}
\item 多头注意力机制是近些年神经机器翻译中常用的结构。多头机制可以让模型从更多维度提取特征，也反应了一种多分支建模的思想。研究人员针对Transformer编码器的多头机制进行了分析，发现部分头在神经网络的学习过程中扮演至关重要的角色，并且蕴含语言学解释\upcite{DBLP:journals/corr/abs-1905-09418}。 而另一部分头本身则不具备很好的解释，对模型的帮助也不大，因此可以被剪枝掉。而且并不是头数越多，模型的性能就越强。此外也有研究人员发现，如果在训练过程中使用多头机制，并在推断过程中去除大部分头，模型性能不仅没有明显变化，还能够提高在CPU上的执行效率\upcite{Michel2019AreSH}。
\item 多头注意力是近些年神经机器翻译中常用的结构。多头机制可以让模型从更多维度提取特征，也反应了一种多分支建模的思想。研究人员针对Transformer编码器的多头机制进行了分析，发现部分头在神经网络的学习过程中扮演了至关重要的角色，并且蕴含语言学解释\upcite{DBLP:journals/corr/abs-1905-09418}。 而另一部分头本身则不具备很好的解释，对模型的帮助也不大，因此可以被剪枝掉。而且也有研究人员发现，在Transformer模型中并不是头数越多模型的性能就越强。如果在训练过程中使用多头机制，并在推断过程中去除大部分头，可以在模型性能不变的前提下提高模型在CPU上的执行效率\upcite{Michel2019AreSH}。
\vspace{0.5em}
\item 此外，也可以利用正则化手段，在训练过程中增大不同头之间的差异\upcite{DBLP:conf/emnlp/LiTYLZ18}。也可以引入多尺度的思想,对输入的特征进行分级表示，并引入短语的信息\upcite{DBLP:conf/emnlp/HaoWSZT19}。还可以通过对注意力权重进行调整，实现对序列中的实词与虚词进行区分\upcite{DBLP:conf/emnlp/Lin0RLS18}。 除了上述基于编码端-解码端的建模范式，还可以定义隐变量模型来捕获句子中潜在的语义信息\upcite{Su2018VariationalRN,DBLP:conf/acl/SetiawanSNP20}，或直接对源语言和目标语言序列进行联合表示\upcite{Li2020NeuralMT}。
\item 此外，也可以利用正则化手段，在训练过程中增大不同头之间的差异\upcite{DBLP:conf/emnlp/LiTYLZ18}。或引入多尺度的思想,对输入的特征进行分级表示，并引入短语的信息\upcite{DBLP:conf/emnlp/HaoWSZT19}。还可以通过对注意力权重进行调整，来区分序列中的实词与虚词\upcite{DBLP:conf/emnlp/Lin0RLS18}。除了上述基于编码器端-解码器端的建模范式，还可以定义隐变量模型来捕获句子中潜在的语义信息\upcite{Su2018VariationalRN,DBLP:conf/acl/SetiawanSNP20}，或直接对源语言和目标语言序列进行联合表示\upcite{Li2020NeuralMT}。
\vspace{0.5em}
\item Transformer等模型处理超长序列也是较为困难的。一种比较直接的解决办法是优化自注意力机制，降低模型计算复杂度。例如，采用基于滑动窗口的局部注意力的Longformer 模型\upcite{DBLP:journals/corr/abs-2004-05150}、基于随机特征的Performer\upcite{DBLP:journals/corr/abs-2006-04768}、使用低秩分解的Linformer\upcite{DBLP:journals/corr/abs-2009-14794}、应用星型拓扑排序的Star-Transformer\upcite{DBLP:conf/naacl/GuoQLSXZ19}。
\item 对Transformer等模型来说，处理超长序列是较为困难的。一种比较直接的解决办法是优化自注意力机制，降低模型计算复杂度。例如，采用了基于滑动窗口的局部注意力的Longformer模型\upcite{DBLP:journals/corr/abs-2004-05150}、基于随机特征的Performer\upcite{DBLP:journals/corr/abs-2006-04768}、使用低秩分解的Linformer\upcite{DBLP:journals/corr/abs-2009-14794}和应用星型拓扑排序的Star-Transformer\upcite{DBLP:conf/naacl/GuoQLSXZ19}。
\vspace{0.5em}
\end{itemize}
Chapter16/chapter16.tex
......@@ -674,12 +674,10 @@
\parinterval 无监督神经机器翻译还有两个关键的技巧：
\begin{itemize}
\vspace{0.5em}
\item {\small\bfnew{词表共享}}：对于源语言和目标语言里都一样的词使用同一个词嵌入，而不是源语言和目标语言各自对应一个词嵌入，比如，阿拉伯数字或者一些实体名字。这样相当于告诉模型这个词在源语言和目标语言里面表达同一个意思，隐式地引入了单词翻译的监督信号。在无监督神经机器翻译里词表共享搭配子词切分会更加有效，因为子词的覆盖范围广，比如，多个不同的词可以包含同一个子词。
\vspace{0.5em}
\item {\small\bfnew{模型共享}}：与多语言翻译系统类似，使用同一个翻译模型来进行正向翻译（源语言$\to$目标语言）和反向翻译（目标语言$\to$源语言）。这样做降低了模型的参数量。而且，两个翻译方向可以互相为对方起到正则化的作用，减小了过拟合的风险。
\vspace{0.5em}
\end{itemize}
\parinterval 最后图\ref{fig:16-19}简单总结了无监督神经机器翻译的流程。下面分别讨论：无监督神经机器翻译里面模型的初始化，以及语言模型目标函数的选择。
......@@ -746,7 +744,7 @@
\end{example}
%----------------------------------------------
\parinterval 在机器翻译任务中，新闻等领域的双语数据相对容易获取，所以机器翻译在这些领域上表现较佳。然而，即使在富资源语种上，化学、医学等专业领域的双语数据依然十分有限。如果直接使用这些低资源领域的数据来训练机器翻译模型，由于数据稀缺问题，会导致模型的性能较差\upcite{DBLP:conf/iccv/SunSSG17}。如果混合多个领域的数据增大训练数据规模，不同领域数据量之间的不平衡会导致数据较少的领域训练不充分，使得在低资源领域上的翻译结果不尽人意\upcite{DBLP:conf/acl/DuhNST13}。
\parinterval 在机器翻译任务中，新闻等领域的双语数据相对容易获取，所以机器翻译在这些领域上表现较佳。然而，即使在富资源语种上，化学、医学等专业领域的双语数据也十分有限。如果直接使用这些低资源领域的数据来训练机器翻译模型，由于数据稀缺问题，会导致模型的性能较差\upcite{DBLP:conf/iccv/SunSSG17}。如果混合多个领域的数据增大训练数据规模，不同领域数据量之间的不平衡会导致数据较少的领域训练不充分，使得在低资源领域上的翻译结果不尽人意\upcite{DBLP:conf/acl/DuhNST13}。
\parinterval 领域适应方法是利用源领域的知识来改进目标领域模型效果的方法，该方法可以有效地减少模型对目标领域数据的依赖。领域适应主要有两类方法：
......@@ -783,7 +781,7 @@
\parinterval 一种观点认为，数据量较少的领域数据应该在训练过程中获得更大的权重，从而使这些更有价值的数据发挥出更大的作用\upcite{DBLP:conf/emnlp/MatsoukasRZ09,DBLP:conf/emnlp/FosterGK10}。实际上，基于数据加权的方法与{\chapterthirteen}中基于样本价值的学习方法是一致的，只是描述的场景略有不同。这类方法本质上在解决{\small\bfnew{类别不均衡问题}}\index{类别不均衡问题}（Class Imbalance Problem\index{Class Imbalance Problem}）\upcite{DBLP:conf/emnlp/ZhuH07}。数据加权可以通过修改损失函数，将其缩放$\alpha$ 倍来实现（$\alpha$ 是样本的权重）。在具体实践中，也可以直接将低资源的领域数据进行复制\footnote{相当于对数据进行重采样}达到与其相同的效果\upcite{DBLP:conf/wmt/ShahBS10}。
\parinterval 数据选择是数据加权的一种特殊情况，它可以被看做是样本权重非零即一的情况。具体来说，可以直接选择与领域相关的数据参与训练\upcite{DBLP:conf/acl/DuhNST13}。由于这种方法并不需要使用全量数据进行训练，因此模型的训练成本较低。由于{\chapterthirteen}已经对数据加权和数据选择方法进行了详细介绍，这里不再赘述。
\parinterval 数据选择是数据加权的一种特殊情况，它可以被看做是样本权重非零即一的情况。具体来说，可以直接选择与领域相关的数据参与训练\upcite{DBLP:conf/acl/DuhNST13}。这种方法并不需要使用全部数据进行训练，因此模型的训练成本较低。由于{\chapterthirteen}已经对数据加权和数据选择方法进行了详细介绍，这里不再赘述。
%----------------------------------------------------------------------------------------
% NEW SUB-SUB-SECTION
......@@ -797,7 +795,7 @@
%----------------------------------------------------------------------------------------
\subsubsection{3. 多领域数据的使用}
\parinterval 领域适应中的目标领域往往不止一个，想要同时提升多个目标领域的效果，一种简单的思路是使用前文所述的单领域适应方法对每一个目标领域进行领域适应。不过，与多语言翻译一样，多领域适应也往往伴随着严重的数据稀缺问题，由于大多数领域的数据量很小，因此无法保证单个领域的领域适应效果。
\parinterval 领域适应中的目标领域往往不止一个，想要同时提升多个目标领域的效果，一种简单的思路是使用前文所述的单领域适应方法对每一个目标领域进行领域适应。不过，与多语言翻译一样，多领域适应也往往伴随着严重的数据稀缺问题，大多数领域的数据量很小，因此无法保证单个领域的领域适应效果。
\parinterval 解决该问题的一种思路是将所有数据混合使用，并训练一个能够同时适应所有领域的模型。同时，为了区分不同领域的数据，可以在样本上增加领域标签\upcite{DBLP:conf/acl/ChuDK17}。事实上，这种方法与\ref{sec:multi-lang-single-model}节所描述的方法是一样的。它也是一种典型的小样本学习策略，旨在让模型自己从不同类型的样本中寻找联系，进而更加充分地利用数据，改善模型在低资源任务上的表现。
......@@ -862,7 +860,7 @@
\parinterval 另一种方法是不从随机状态开始训练网络，而是使用翻译性能较好的源领域模型作为初始状态，因为源领域模型中包含着一些通用知识可以被目标领域借鉴。比如，想获得口语的翻译模型，可以使用新闻的翻译模型作为初始状态进行训练。这也可以被看作是一种预训练-微调方法。
\parinterval 不过这种方法经常会带来灾难性遗忘问题，即在目标领域上过拟合，导致在源领域上的翻译性能大幅度下降（见{\chapterthirteen}）。如果想要保证模型在目标领域和源领域上都有较好的性能，一个比较常用的方法是进行混合微调\upcite{DBLP:conf/acl/ChuDK17}。具体做法是先在源领域数据上训练一个神经机器翻译模型，然后将目标领域数据复制数倍和源领域数据量相等，之后将数据混合后对神经机器翻译模型进行微调。混合微调方法既降低了目标领域数据量小导致的过拟合问题，又带来了更好的微调性能。除了混合微调外，也可以使用知识蒸馏方法缓解灾难性遗忘问题（见\ref{multilingual-translation-model}节），即对源领域和目标领域进行多次循环知识蒸馏，迭代学习对方领域的知识，可以保证在源领域和目标领域上的翻译性能共同逐步上升\upcite{DBLP:conf/emnlp/ZengLSGLYL19}。此外，还可以使用L2正则化和Dropout方法来缓解这个问题\upcite{barone2017regularization}。
\parinterval 不过这种方法经常会带来灾难性遗忘问题，即在目标领域上过拟合，导致在源领域上的翻译性能大幅度下降（见{\chapterthirteen}）。如果想要保证模型在目标领域和源领域上都有较好的性能，一个比较常用的方法是进行混合微调\upcite{DBLP:conf/acl/ChuDK17}。具体做法是先在源领域数据上训练一个神经机器翻译模型，然后将目标领域数据复制数倍和源领域数据量相等，之后将数据混合对神经机器翻译模型进行微调。混合微调方法既降低了目标领域数据量小导致的过拟合问题的影响，又带来了更好的微调性能。除了混合微调外，也可以使用知识蒸馏方法缓解灾难性遗忘问题（见\ref{multilingual-translation-model}节），即对源领域和目标领域进行多次循环知识蒸馏，迭代学习对方领域的知识，可以保证在源领域和目标领域上的翻译性能共同逐步上升\upcite{DBLP:conf/emnlp/ZengLSGLYL19}。此外，还可以使用L2正则化和Dropout方法来缓解这个问题\upcite{barone2017regularization}。
%----------------------------------------------------------------------------------------
% NEW SUB-SUB-SECTION
......@@ -882,7 +880,7 @@
\begin{itemize}
\vspace{0.5em}
\item 如何更高效地利用已有双语数据或单语数据进行数据增强始终是一个热点问题。研究人员分别探索了源语言单语数据和目标语言单语数据的使用方法\upcite{DBLP:conf/emnlp/ZhangZ16,DBLP:conf/emnlp/WuWXQLL19,DBLP:conf/acl/XiaKAN19}，以及如何对已有双语数据进行修改\upcite{DBLP:conf/emnlp/WangPDN18,DBLP:conf/acl/GaoZWXQCZL19}。经过数据增强得到的伪数据的质量时好时坏，如何提高伪数据的质量，以及更好地利用伪数据进行训练也是十分重要的问题\upcite{DBLP:conf/emnlp/FadaeeM18,DBLP:conf/nlpcc/XuLXLLXZ19,DBLP:conf/wmt/CaswellCG19,DBLP:journals/corr/abs200403672,DBLP:conf/emnlp/WangLWLS19}。此外，还有一些工作对数据增强技术进行了理论分析\upcite{DBLP:conf/emnlp/LiLHZZ19,DBLP:conf/acl/MarieRF20}。
\item 如何更高效地利用已有双语数据或单语数据进行数据增强始终是一个热点问题。研究人员分别探索了源语言单语数据和目标语言单语数据的使用方法\upcite{DBLP:conf/emnlp/ZhangZ16,DBLP:conf/emnlp/WuWXQLL19,DBLP:conf/acl/XiaKAN19}，以及如何对已有双语数据进行修改的问题\upcite{DBLP:conf/emnlp/WangPDN18,DBLP:conf/acl/GaoZWXQCZL19}。经过数据增强得到的伪数据的质量时好时坏，如何提高伪数据的质量，以及更好地利用伪数据进行训练也是十分重要的问题\upcite{DBLP:conf/emnlp/FadaeeM18,DBLP:conf/nlpcc/XuLXLLXZ19,DBLP:conf/wmt/CaswellCG19,DBLP:journals/corr/abs200403672,DBLP:conf/emnlp/WangLWLS19}。此外，还有一些工作对数据增强技术进行了理论分析\upcite{DBLP:conf/emnlp/LiLHZZ19,DBLP:conf/acl/MarieRF20}。
\vspace{0.5em}
\item 预训练模型也是自然语言处理的重要突破之一，也给低资源机器翻译提供了新的思路。除了基于语言模型或掩码语言模型的方法，也有很多新的架构和模型被提出，如排列语言模型、降噪自编码器等\upcite{DBLP:conf/nips/YangDYCSL19,DBLP:conf/acl/LewisLGGMLSZ20,DBLP:conf/iclr/LanCGGSS20,DBLP:conf/acl/ZhangHLJSL19}。预训练技术也逐渐向多语言领域扩展\upcite{DBLP:conf/nips/ConneauL19,DBLP:conf/emnlp/HuangLDGSJZ19,song2019mass}，甚至不再只局限于文本任务\upcite{DBLP:conf/iccv/SunMV0S19,DBLP:conf/nips/LuBPL19,DBLP:conf/interspeech/ChuangLLL20}。对于如何将预训练模型高效地应用到下游任务中，也进行了很多的经验性对比与分析\upcite{Peters2018DeepCW,DBLP:conf/rep4nlp/PetersRS19,DBLP:conf/cncl/SunQXH19}。
......
Chapter17/Figures/figure-an-end-to-end-voice-translation-model-based-on-transformer.tex
\begin{tikzpicture}
\tikzstyle{layer}=[draw,rounded corners=2pt,font=\scriptsize,align=center,minimum width=5em]
\tikzstyle{layer}=[draw,rounded corners=2pt,font=\scriptsize,align=center,minimum width=7.1em]
\tikzstyle{word}=[font=\scriptsize]
%%%%encoder
\node[layer,fill=red!20] (en_sa) at (0,0){Multi-Head \\ Attention};
\node[layer,anchor=south,fill=green!20] (en_ffn) at ([yshift=1.4em]en_sa.north){Feed Forward \\ Network};
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=north] (en_add) at ([yshift=-1.4em]en_sa.south){};
\draw[] (en_add.90) -- (en_add.-90);
\draw[] (en_add.0) -- (en_add.180);
\node[layer,anchor=north,fill=yellow!20] (en_cnn) at ([yshift=-1.4em]en_add.south){CNN};
\node[anchor=south,layer,fill=yellow!20](en_add1) at ([yshift=1.0em]en_sa.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=green!20] (en_ffn) at ([yshift=1.0em]en_add1.north){Feed Forward \\ Network};
\node[anchor=south,layer,fill=yellow!20](en_add2) at ([yshift=1.0em]en_ffn.north) {Add \& LayerNorm};
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=north,thick] (en_add) at ([yshift=-1.4em]en_sa.south){};
\draw[thick] (en_add.90) -- (en_add.-90);
\draw[thick] (en_add.0) -- (en_add.180);
\node[layer,anchor=north,fill=yellow!20] (en_cnn) at ([yshift=-1.0em]en_add.south){CNN};
\node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){位置编码};
\node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){源语言语音特征\\（FBank/MFCC）};
\draw[->,thick] (en_input.90) -- ([yshift=-0.1em]en_cnn.-90);
\draw[->,thick] ([yshift=0.1em]en_cnn.90) -- ([yshift=-0.1em]en_add.-90);
\draw[->,thick] ([yshift=0.1em]en_add.90) -- ([yshift=-0.1em]en_sa.-90);
\draw[->,thick] ([yshift=0.1em]en_sa.90) -- ([yshift=-0.1em]en_add1.-90);
\draw[->,thick] ([yshift=0.1em]en_add1.90) -- ([yshift=-0.1em]en_ffn.-90);
\draw[->,thick] ([yshift=0.1em]en_ffn.90) --([yshift=-0.1em]en_add2.-90);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]en_sa.south)--([yshift=-0.6em,xshift=-4.0em]en_sa.south)--([xshift=-0.43em]en_add1.west)--(en_add1.west);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]en_ffn.south)--([yshift=-0.6em,xshift=-4.0em]en_ffn.south)--([xshift=-0.43em]en_add2.west)--(en_add2.west);
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=west] (de_add) at ([xshift=7em]en_add.east){};
\draw[] (de_add.90) -- (de_add.-90);
\draw[] (de_add.0) -- (de_add.180);
%%%%decoder
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=west,thick] (de_add) at ([xshift=9em]en_add.east){};
\draw[thick] (de_add.90) -- (de_add.-90);
\draw[thick] (de_add.0) -- (de_add.180);
\node[layer,anchor=south,fill=red!20] (de_sa) at ([yshift=1.4em]de_add.north){Masked \\Multi-Head\\Attention};
\node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.4em]de_sa.north){Multi-Head \\ Attention};
\node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.4em]de_ca.north){Feed Forward \\ Network};
\node[anchor=south,layer,fill=yellow!20](de_add1) at ([yshift=1.0em]de_sa.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.0em]de_add1.north){Multi-Head \\ Attention};
\node[anchor=south,layer,fill=yellow!20](de_add2) at ([yshift=1.0em]de_ca.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.0em]de_add2.north){Feed Forward \\ Network};
\node[anchor=south,layer,fill=yellow!20](de_add3) at ([yshift=1.0em]de_ffn.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=1.2em]de_add3.north){Softmax};
\node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1.1em]de_add.south){目标语言文本\\编码表示};
\node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=1.6em]de_ffn.north){Softmax};
%\node[layer,anchor=south,fill=orange!20] (output) at ([yshift=1.4em]sf.north){STLoss};
\node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){位置编码};
\node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){语音特征\\(FBank/MFCC)};
\node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1.1em]de_add.south){标注文本\\编码表示};
\draw[->,thick] (de_input.90) -- ([yshift=-0.1em]de_add.-90);
\draw[->,thick] ([yshift=0.1em]de_add.90) -- ([yshift=-0.1em]de_sa.-90);
\draw[->,thick] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_add1.-90);
\draw[->,thick] ([yshift=0.1em]de_add1.90) -- ([yshift=-0.1em]de_ca.-90);
\draw[->,thick] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_add2.-90);
\draw[->,thick] ([yshift=0.1em]de_add2.90) -- ([yshift=-0.1em]de_ffn.-90);
\draw[->,thick] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]de_add3.-90);
\draw[->,thick] ([yshift=0.1em]de_add3.90) -- ([yshift=-0.1em]sf.-90);
\draw[->,thick] ([yshift=0.1em]sf.90) -- ([yshift=1.0em]sf.90);
\draw[->,thick] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180);
\draw[->,thick] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]de_sa.south)--([yshift=-0.6em,xshift=4.0em]de_sa.south)--([xshift=0.43em]de_add1.east)--(de_add1.east);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]de_ca.south)--([yshift=-0.6em,xshift=4.0em]de_ca.south)--([xshift=0.43em]de_add2.east)--(de_add2.east);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]de_ffn.south)--([yshift=-0.6em,xshift=4.0em]de_ffn.south)--([xshift=0.43em]de_add3.east)--(de_add3.east);
\draw[->,rounded corners=2pt,thick] ([yshift=0.1em]en_add2.90) -- ([yshift=1.5em]en_add2.90) -- ([xshift=5.0em,yshift=1.5em]en_add2.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west);
\node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){位置编码};
\node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){位置编码};
\draw[->] (en_input.90) -- ([yshift=-0.1em]en_cnn.-90);
\draw[->] ([yshift=0.1em]en_cnn.90) -- ([yshift=-0.1em]en_add.-90);
\draw[->] ([yshift=0.1em]en_add.90) -- ([yshift=-0.1em]en_sa.-90);
\draw[->] ([yshift=0.1em]en_sa.90) -- ([yshift=-0.1em]en_ffn.-90);
\draw[->] (de_input.90) -- ([yshift=-0.1em]de_add.-90);
\draw[->] ([yshift=0.1em]de_add.90) -- ([yshift=-0.1em]de_sa.-90);
\draw[->] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_ca.-90);
\draw[->] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_ffn.-90);
\draw[->] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]sf.-90);
\draw[->] ([yshift=0.1em]sf.90) -- ([yshift=1.5em]sf.90);
\draw[->] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180);
\draw[->] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0);
\draw[->,rounded corners=2pt] ([yshift=0.1em]en_ffn.90) -- ([yshift=2em]en_ffn.90) -- ([xshift=4em,yshift=2em]en_ffn.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west);
\begin{pgfonlayer}{background}
\node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(en_sa)(en_ffn)]{};
\node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(de_sa)(de_ca)(de_ffn)]{};
\node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick,xshift=-0.2em,yshift=-0.2em][fit=(en_add1)(en_add2)(en_sa)(en_ffn)](box1){};
\node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick,xshift=0.2em,yshift=-0.2em][fit=(de_sa)(de_ca)(de_ffn)(de_add3)](box2){};
\end{pgfonlayer}
\node[anchor=east,font=\scriptsize,text=ugreen] at ([xshift=-0.1em]box1.west){$N \times$};
\node[anchor=west,font=\scriptsize,text=red] at ([xshift=0.1em]box2.east){$\times N$};
\node[anchor=east,font=\scriptsize] at ([xshift=-0.1em]en_cnn.west){$2 \times$};
\node[anchor=east,font=\scriptsize,align=center,text=ugreen] at ([xshift=-0.1em,yshift=3em]box1.west){ST\\ 编码器};
\node[anchor=west,font=\scriptsize,align=center,text=red] at ([xshift=0.1em,yshift=5em]box2.east){ST\\解码器};
\node[anchor=east,font=\scriptsize,align=center,text=ugreen] at ([xshift=-0.1em,yshift=3em]box1.west){ST \\ 编码器};
\node[anchor=west,font=\scriptsize,align=center,text=red] at ([xshift=0.1em,yshift=5em]box2.east){ST \\ 解码器};
\end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-application-of-multimodal-machine-translation-to-multitask-learning.tex
\tikzstyle{coder} = [rectangle,rounded corners,minimum height=2.2em,minimum width=4.3em,text centered,draw=black,fill=red!25]
\tikzstyle{coder} = [rectangle,thick,rounded corners,minimum height=2.2em,minimum width=4.3em,text centered,draw=black,fill=red!20]
\begin{tikzpicture}[node distance = 0,scale = 0.75]
\tikzstyle{every node}=[scale=0.75]
\node(x)[]{$x$};
\node(encoder)[coder, above of = x,yshift=4em]{{编码器}};
\node(decoder_left)[coder, above of = encoder, yshift=6em,fill=blue!25]{{解码器}};
\node(encoder)[coder, above of = x,yshift=4em]{\large{编码器}};
\node(decoder_left)[coder, above of = encoder, yshift=6em,fill=blue!20]{\large{解码器}};
\node(y_hat)[above of = decoder_left, yshift=4em]{{$y$}};
\node(y)[above of = decoder_left, xshift=-6em]{{$y_{<}$}};
\node(decoder_right)[coder, above of = encoder, xshift=11em,fill=yellow!25]{{解码器}};
\node(decoder_right)[coder, above of = encoder, xshift=11em,fill=yellow!20]{\large{解码器}};
\node(figure)[draw=white,above of = decoder_right,yshift=6.5em,scale=0.25] {\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-bank-without-attention.jpg}};
\node [anchor=south,scale=1.2] (node1) at ([xshift=-2.5em,yshift=4.5em]y.north) {\small{$x$：源语言文本数据}};
\node [anchor=north,scale=1.2] (node2) at ([xshift=0.57em]node1.south){\small{$y$：目标语言文本数据}};
\node [anchor=south,scale=1.2] (node1) at ([xshift=-2.5em,yshift=4.5em]y.north) {{$x$：源语言文本数据}};
\node [anchor=north,scale=1.2] (node2) at ([xshift=0.57em]node1.south){{$y$：目标语言文本数据}};
\draw[->,thick](x)to(encoder);
\draw[->,thick](encoder)to(decoder_left)node[right,xshift=-0.1cm,yshift=-1.25cm,scale=1.2]{\small{翻译}};
\draw[->,thick](encoder)to(decoder_left)node[right,xshift=-0.1cm,yshift=-1.25cm,scale=1.2]{{翻译}};
\draw[->,thick](decoder_left)to(y_hat);
\draw[->,thick](y)to(decoder_left);
\draw[->,thick](encoder)to(decoder_right)node[left,xshift=-3.1em,yshift=0.25cm,scale=1.2]{\small{生成图片}};
\draw[->,thick](encoder)to(decoder_right)node[left,xshift=-3.1em,yshift=0.25cm,scale=1.2]{{生成图片}};
\draw[->,thick](decoder_right)to(figure);
\end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-audio-processing.tex
......@@ -36,6 +36,7 @@
\draw[->,very thick](process_2.east)to([xshift=1.8cm]process_2.east);
%%%%音频
\node(signal)[right of = process_2,xshift=5.5cm]{};
\node(text_3)[below of = signal,yshift=-1.98cm,scale=1.3]{语音信号};
\draw[-,thick,]([xshift=-1.2cm]signal.center)--([xshift=1.2cm]signal.center);
\draw[-,thick]([xshift=-1cm,yshift=-0.8cm]signal.center)--([xshift=-0.9cm,yshift=0.4cm]signal.center)--([xshift=-0.8cm,yshift=-0.3cm]signal.center)--([xshift=-0.7cm,yshift=0.7cm]signal.center)--([xshift=-0.6cm,yshift=-0.1cm]signal.center)--([xshift=-0.5cm,yshift=0.3cm]signal.center)--([xshift=-0.4cm,yshift=-0.5cm]signal.center)--([xshift=-0.3cm,yshift=0.7cm]signal.center)--([xshift=-0.2cm,yshift=-0.2cm]signal.center)--([xshift=-0.1cm,yshift=0.4cm]signal.center)--([xshift=0cm,yshift=-0.9cm]signal.center)--([xshift=0.1cm,yshift=0.5cm]signal.center)--([xshift=0.2cm,yshift=-0.4cm]signal.center)--([xshift=0.3cm,yshift=0.3cm]signal.center)--([xshift=0.4cm,yshift=-0.2cm]signal.center)--([xshift=0.5cm,yshift=0.1cm]signal.center)--([xshift=0.6cm,yshift=-0.8cm]signal.center)--([xshift=0.7cm,yshift=0.4cm]signal.center)--([xshift=0.8cm,yshift=-0.6cm]signal.center)--([xshift=0.9cm,yshift=0.7cm]signal.center)--([xshift=1cm,yshift=-0.2cm]signal.center);
\end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-cache.tex
......@@ -13,8 +13,8 @@
\draw[] ([yshift=-0.5em]value.180) -- ([yshift=-0.5em]value.0);
\draw[] ([yshift=-1.5em]value.180) -- ([yshift=-1.5em]value.0);
\node[anchor=south,font=\footnotesize,inner sep=0pt] at ([yshift=0.1em]key.north){key};
\node[anchor=south,font=\footnotesize,inner sep=0pt] at ([yshift=0.2em]value.north){value};
\node[anchor=south,font=\footnotesize,inner sep=0pt] at ([yshift=0.1em]key.north){键};
\node[anchor=south,font=\footnotesize,inner sep=0pt] at ([yshift=0.1em]value.north){值};
\node[anchor=south,font=\footnotesize,inner sep=0pt] (cache)at ([yshift=2em,xshift=1.5em]key.north){\small\bfnew{缓存}};
\node[draw,anchor=east,thick,minimum size=1.8em,fill=orange!30] (dt) at ([yshift=2.1em,xshift=-4em]key.west){${\mathbi{d}}_{t}$};
......
Chapter17/Figures/figure-cascading-speech-translation.tex
......@@ -34,7 +34,7 @@
\node(text)[below of = process_3,yshift=-1.8cm,scale=1.8]{你是谁};
\node(process_4)[process,fill=ugreen!20,right of = process_3,xshift=8.2cm,text width=4cm,align=center]{\Large\textbf{Who are you?}};
\node(text_4)[below of = process_4,yshift=-2cm,scale=1.5]{翻译译文};
\node(text_4)[below of = process_4,yshift=-2cm,scale=1.5]{翻译结果};
\draw[->,very thick](process_1.east)to(process_2.west);
\draw[->,very thick](process_2.east)to(process_3.west);
......
Chapter17/Figures/figure-multiencoder.tex
......@@ -6,7 +6,7 @@
\tikzstyle{every node}=[scale=0.7]
\node(encoder_c)[coder]{\large{编码器}};
\node(encoder_s)[coder, right of = encoder_c, xshift=3.5cm, fill=red!30]{\large{编码器}};
\node(h_pre)[above of = encoder_c, yshift=1.3cm,scale=1.3]{${\mathbi{h}}_{\rm pre}$};
\node(h_pre)[above of = encoder_c, yshift=1.3cm,scale=1.3]{${\mathbi{h}}^{\rm pre}$};
\node(h)[above of = encoder_s, yshift=1.3cm,scale=1.3]{$\mathbi{h}$};
\node(cir)[circle,very thick, right of = h, draw=black!90,minimum width=0.5cm,xshift=1.1cm]{};
\draw[-,very thick,draw=black!90]([xshift=0.04cm]cir.west)--([xshift=-0.04cm]cir.east);
......@@ -23,20 +23,20 @@
\node(point_above)[above of = attention_right, yshift=1.8cm]{\Huge{...}};
\node(target_above)[above of = attention_right, yshift=3.3cm]{\large{目标语言句子}};
\draw[->, very thick](last)to([yshift=-0.05cm]encoder_c.south);
\draw[->, very thick](current)to([yshift=-0.05cm]encoder_s.south);
\draw[->, very thick](target.north)to([yshift=-0.05cm]point_below.south);
\draw[->, very thick]([yshift=0.05cm]encoder_c.north)to([yshift=0.03cm]h_pre.south);
\draw[->, very thick]([yshift=0.05cm]encoder_s.north)to(h.south);
\draw[->, very thick]([yshift=0cm]h.north)to([yshift=0.95cm]h.north);
\draw[->, very thick,in=270,out=90]([yshift=-0.15cm]h_pre.north)to([xshift=1.25cm,yshift=0.9cm]h_pre.north);
\draw[->, very thick,in=270,out=80]([yshift=-0.15cm]h_pre.north)to([xshift=2.4cm,yshift=0.9cm]h_pre.north);
\draw[->, very thick]([yshift=0.03cm]attention_left.north)to([yshift=0.1cm]d.south);
\draw[->, very thick]([xshift=-0.03cm]h.east)to([xshift=-0.03cm]cir.west);
\draw[->, very thick](point_below.north)to([yshift=2.03cm]point_below.north);
\draw[->, very thick](attention_right.north)to([yshift=-0.03cm]point_above.south);
\draw[->, very thick](point_above.north)to([yshift=0.83cm]point_above.north);
\draw[->, very thick, in=270,out=0]([xshift=0.2cm]cir.east)to([xshift=3cm,yshift=0.88cm]cir.east);
\draw[->, very thick, in=270,out=0]([xshift=0.2cm]cir.east)to([xshift=2cm,yshift=0.88cm]cir.east);
\draw[->,thick](last)to([yshift=-0.05cm]encoder_c.south);
\draw[->,thick](current)to([yshift=-0.05cm]encoder_s.south);
\draw[->,thick](target.north)to([yshift=-0.05cm]point_below.south);
\draw[->,thick]([yshift=0.05cm]encoder_c.north)to([yshift=0.03cm]h_pre.south);
\draw[->,thick]([yshift=0.05cm]encoder_s.north)to(h.south);
\draw[->,thick]([yshift=0cm]h.north)to([yshift=0.95cm]h.north);
\draw[->,thick,in=270,out=90]([yshift=-0.15cm]h_pre.north)to([xshift=1.25cm,yshift=0.9cm]h_pre.north);
\draw[->,thick,in=270,out=80]([yshift=-0.15cm]h_pre.north)to([xshift=2.4cm,yshift=0.9cm]h_pre.north);
\draw[->,thick]([yshift=0.03cm]attention_left.north)to([yshift=0.1cm]d.south);
\draw[->,thick]([xshift=-0.03cm]h.east)to([xshift=-0.03cm]cir.west);
\draw[->,thick](point_below.north)to([yshift=2.03cm]point_below.north);
\draw[->,thick](attention_right.north)to([yshift=-0.03cm]point_above.south);
\draw[->,thick](point_above.north)to([yshift=0.83cm]point_above.north);
\draw[->,thick, in=270,out=0]([xshift=0.2cm]cir.east)to([xshift=3cm,yshift=0.88cm]cir.east);
\draw[->,thick, in=270,out=0]([xshift=0.2cm]cir.east)to([xshift=2cm,yshift=0.88cm]cir.east);
\draw[->,very thick,]([xshift=0.1cm]d.east)to([xshift=1.92cm]d.east)to([yshift=0.03cm]cir.north);
\end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-picture-translation.tex
......@@ -3,16 +3,16 @@
\begin {scope}
\node[draw=white,scale=0.6] (input) at (0,0){\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-bank-without-attention.jpg}};(1.9,-1.4);
\node[anchor=west] (label1) at ([xshift=-3.5em]input.west) {\begin{tabular}{l}{\normalsize{图片：}}\end{tabular}};
\node[anchor=south] (label2) at ([yshift=-6em]label1.south) {\begin{tabular}{l}{\normalsize{源文：}}\end{tabular}};
\node[anchor=south] (english1) at ([xshift=-0.35em,yshift=-2.3em]input.south) {\begin{tabular}{l}{\large{A\; girl\; jumps\; off\; a\; {\red{\underline{bank}}}\quad .}}\end{tabular}};
\node[anchor=south] (label2) at ([yshift=-6em]label1.south) {\begin{tabular}{l}{\normalsize{源语言：}}\end{tabular}};
\node[anchor=south] (english1) at ([xshift=-0.28em,yshift=-2.3em]input.south) {\begin{tabular}{l}{\large{A\; girl\; jumps\; off\; a\; {\red{\underline{bank}}}\quad .}}\end{tabular}};
\draw[decorate,decoration={brace,amplitude=4mm},very thick] ([xshift=6.3em]input.90) -- ([xshift=0.3em,yshift=-0em]english1.east);
\draw[decorate,decoration={brace,amplitude=4mm},thick] ([xshift=6.3em]input.90) -- ([xshift=0.3em,yshift=-0em]english1.east);
\node[anchor=east,rectangle,thick,rounded corners,minimum width=3.5em,minimum height=2.5em,text centered,draw=black!70,fill=red!25](trans)at ([xshift=7.4em,yshift=5.27em]english1.east){\normalsize{翻译模型}};
\draw[->,very thick]([xshift=-1.4em]trans.west) to (trans.west);
\draw[->,very thick](trans.east) to ([xshift=1.4em]trans.east);
\node[anchor=east] (de1) at ([xshift=4.5cm,yshift=-0.1em]trans.east) {\begin{tabular}{l}{\normalsize{译文：}}{\normalsize{一个/女孩/从/{\red{河床}}/}}\end{tabular}};
\node[anchor=south] (de2) at ([xshift=-0em,yshift=-1.5em]de1.south) {\begin{tabular}{l}{\normalsize{上/跳下来/。}} \end{tabular}};
\draw[->,thick]([xshift=-1.4em]trans.west) to (trans.west);
\node[anchor=east] (de1) at ([xshift=5.2cm,yshift=-0.1em]trans.east) {\begin{tabular}{l}{\normalsize{目标语言：}}{\normalsize{一个/女孩/从/{\red{河床}}/}}\end{tabular}};
\node[anchor=south] (de2) at ([xshift=1.1em,yshift=-1.5em]de1.south) {\begin{tabular}{l}{\normalsize{上/跳下来/。}} \end{tabular}};
\draw[->,thick](trans.east) to ([xshift=0.5em,yshift=0.1em]de1.west);
\end {scope}
\end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-speech-recognition-model-based-on-transformer.tex
\begin{tikzpicture}
\tikzstyle{layer}=[draw,rounded corners=2pt,font=\scriptsize,align=center,minimum width=5em]
\tikzstyle{layer}=[draw,rounded corners=2pt,font=\scriptsize,align=center,minimum width=7.1em]
\tikzstyle{word}=[font=\scriptsize]
%%%%encoder
\node[layer,fill=red!20] (en_sa) at (0,0){Multi-Head \\ Attention};
\node[layer,anchor=south,fill=green!20] (en_ffn) at ([yshift=1.4em]en_sa.north){Feed Forward \\ Network};
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=north] (en_add) at ([yshift=-1.4em]en_sa.south){};
\draw[] (en_add.90) -- (en_add.-90);
\draw[] (en_add.0) -- (en_add.180);
\node[layer,anchor=north,fill=yellow!20] (en_cnn) at ([yshift=-1.4em]en_add.south){CNN};
\node[anchor=south,layer,fill=yellow!20](en_add1) at ([yshift=1.0em]en_sa.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=green!20] (en_ffn) at ([yshift=1.0em]en_add1.north){Feed Forward \\ Network};
\node[anchor=south,layer,fill=yellow!20](en_add2) at ([yshift=1.0em]en_ffn.north) {Add \& LayerNorm};
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=north,thick] (en_add) at ([yshift=-1.4em]en_sa.south){};
\draw[thick] (en_add.90) -- (en_add.-90);
\draw[thick] (en_add.0) -- (en_add.180);
\node[layer,anchor=north,fill=yellow!20] (en_cnn) at ([yshift=-1.0em]en_add.south){CNN};
\node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){位置编码};
\node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){语音特征\\（FBank/MFCC）};
\draw[->,thick] (en_input.90) -- ([yshift=-0.1em]en_cnn.-90);
\draw[->,thick] ([yshift=0.1em]en_cnn.90) -- ([yshift=-0.1em]en_add.-90);
\draw[->,thick] ([yshift=0.1em]en_add.90) -- ([yshift=-0.1em]en_sa.-90);
\draw[->,thick] ([yshift=0.1em]en_sa.90) -- ([yshift=-0.1em]en_add1.-90);
\draw[->,thick] ([yshift=0.1em]en_add1.90) -- ([yshift=-0.1em]en_ffn.-90);
\draw[->,thick] ([yshift=0.1em]en_ffn.90) --([yshift=-0.1em]en_add2.-90);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]en_sa.south)--([yshift=-0.6em,xshift=-4.0em]en_sa.south)--([xshift=-0.43em]en_add1.west)--(en_add1.west);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]en_ffn.south)--([yshift=-0.6em,xshift=-4.0em]en_ffn.south)--([xshift=-0.43em]en_add2.west)--(en_add2.west);
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=west] (de_add) at ([xshift=7em]en_add.east){};
\draw[] (de_add.90) -- (de_add.-90);
\draw[] (de_add.0) -- (de_add.180);
%%%%decoder
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=west,thick] (de_add) at ([xshift=9em]en_add.east){};
\draw[thick] (de_add.90) -- (de_add.-90);
\draw[thick] (de_add.0) -- (de_add.180);
\node[layer,anchor=south,fill=red!20] (de_sa) at ([yshift=1.4em]de_add.north){Masked \\Multi-Head\\Attention};
\node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.4em]de_sa.north){Multi-Head \\ Attention};
\node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.4em]de_ca.north){Feed Forward \\ Network};
\node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=1.6em]de_ffn.north){Softmax};
%\node[layer,anchor=south,fill=orange!20] (output) at ([yshift=1.4em]sf.north){Output Probabilities};
\node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){语音特征\\(FBank/MFCC)};
\node[anchor=south,layer,fill=yellow!20](de_add1) at ([yshift=1.0em]de_sa.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.0em]de_add1.north){Multi-Head \\ Attention};
\node[anchor=south,layer,fill=yellow!20](de_add2) at ([yshift=1.0em]de_ca.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.0em]de_add2.north){Feed Forward \\ Network};
\node[anchor=south,layer,fill=yellow!20](de_add3) at ([yshift=1.0em]de_ffn.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=1.2em]de_add3.north){Softmax};
\node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1.1em]de_add.south){标注文本\\编码表示};
\node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){位置编码};
\node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){位置编码};
\draw[->] (en_input.90) -- ([yshift=-0.1em]en_cnn.-90);
\draw[->] ([yshift=0.1em]en_cnn.90) -- ([yshift=-0.1em]en_add.-90);
\draw[->] ([yshift=0.1em]en_add.90) -- ([yshift=-0.1em]en_sa.-90);
\draw[->] ([yshift=0.1em]en_sa.90) -- ([yshift=-0.1em]en_ffn.-90);
\draw[->] (de_input.90) -- ([yshift=-0.1em]de_add.-90);
\draw[->] ([yshift=0.1em]de_add.90) -- ([yshift=-0.1em]de_sa.-90);
\draw[->] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_ca.-90);
\draw[->] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_ffn.-90);
\draw[->] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]sf.-90);
\draw[->] ([yshift=0.1em]sf.90) -- ([yshift=1.5em]sf.90);
\draw[->] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180);
\draw[->] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0);
\draw[->,rounded corners=2pt] ([yshift=0.1em]en_ffn.90) -- ([yshift=2em]en_ffn.90) -- ([xshift=4em,yshift=2em]en_ffn.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west);
\draw[->,thick] (de_input.90) -- ([yshift=-0.1em]de_add.-90);
\draw[->,thick] ([yshift=0.1em]de_add.90) -- ([yshift=-0.1em]de_sa.-90);
\draw[->,thick] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_add1.-90);
\draw[->,thick] ([yshift=0.1em]de_add1.90) -- ([yshift=-0.1em]de_ca.-90);
\draw[->,thick] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_add2.-90);
\draw[->,thick] ([yshift=0.1em]de_add2.90) -- ([yshift=-0.1em]de_ffn.-90);
\draw[->,thick] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]de_add3.-90);
\draw[->,thick] ([yshift=0.1em]de_add3.90) -- ([yshift=-0.1em]sf.-90);
\draw[->,thick] ([yshift=0.1em]sf.90) -- ([yshift=1.0em]sf.90);
\draw[->,thick] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180);
\draw[->,thick] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]de_sa.south)--([yshift=-0.6em,xshift=4.0em]de_sa.south)--([xshift=0.43em]de_add1.east)--(de_add1.east);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]de_ca.south)--([yshift=-0.6em,xshift=4.0em]de_ca.south)--([xshift=0.43em]de_add2.east)--(de_add2.east);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]de_ffn.south)--([yshift=-0.6em,xshift=4.0em]de_ffn.south)--([xshift=0.43em]de_add3.east)--(de_add3.east);
\draw[->,rounded corners=2pt,thick] ([yshift=0.1em]en_add2.90) -- ([yshift=1.5em]en_add2.90) -- ([xshift=5.0em,yshift=1.5em]en_add2.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west);
\begin{pgfonlayer}{background}
\node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(en_sa)(en_ffn)](box1){};
\node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(de_sa)(de_ca)(de_ffn)](box2){};
\node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick,xshift=-0.2em,yshift=-0.2em][fit=(en_add1)(en_add2)(en_sa)(en_ffn)](box1){};
\node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick,xshift=0.2em,yshift=-0.2em][fit=(de_sa)(de_ca)(de_ffn)(de_add3)](box2){};
\end{pgfonlayer}
\node[anchor=east,font=\scriptsize,text=ugreen] at ([xshift=-0.1em]box1.west){$N \times$};
......
Chapter17/Figures/figure-speech-translation-model-based-on-CTC.tex
\begin{tikzpicture}
\tikzstyle{layer}=[draw,rounded corners=2pt,font=\scriptsize,align=center,minimum width=5em]
\tikzstyle{layer}=[draw,rounded corners=2pt,font=\scriptsize,align=center,minimum width=7.1em]
\tikzstyle{word}=[font=\scriptsize]
%%%%encoder
\node[layer,fill=red!20] (en_sa) at (0,0){Multi-Head \\ Attention};
\node[layer,anchor=south,fill=green!20] (en_ffn) at ([yshift=1.4em]en_sa.north){Feed Forward \\ Network};
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=north] (en_add) at ([yshift=-1.4em]en_sa.south){};
\draw[] (en_add.90) -- (en_add.-90);
\draw[] (en_add.0) -- (en_add.180);
\node[layer,anchor=north,fill=yellow!20] (en_cnn) at ([yshift=-1.4em]en_add.south){CNN};
\node[anchor=south,layer,fill=yellow!20](en_add1) at ([yshift=1.0em]en_sa.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=green!20] (en_ffn) at ([yshift=1.0em]en_add1.north){Feed Forward \\ Network};
\node[anchor=south,layer,fill=yellow!20](en_add2) at ([yshift=1.0em]en_ffn.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=blue!20] (en_sf) at ([yshift=2.4em]en_add2.north){Softmax};
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=north,thick] (en_add) at ([yshift=-1.4em]en_sa.south){};
\draw[thick] (en_add.90) -- (en_add.-90);
\draw[thick] (en_add.0) -- (en_add.180);
\node[layer,anchor=north,fill=yellow!20] (en_cnn) at ([yshift=-1.0em]en_add.south){CNN};
\node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){位置编码};
\node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){源语言语音特征\\（FBank/MFCC）};
\draw[->,thick] (en_input.90) -- ([yshift=-0.1em]en_cnn.-90);
\draw[->,thick] ([yshift=0.1em]en_cnn.90) -- ([yshift=-0.1em]en_add.-90);
\draw[->,thick] ([yshift=0.1em]en_add.90) -- ([yshift=-0.1em]en_sa.-90);
\draw[->,thick] ([yshift=0.1em]en_sa.90) -- ([yshift=-0.1em]en_add1.-90);
\draw[->,thick] ([yshift=0.1em]en_add1.90) -- ([yshift=-0.1em]en_ffn.-90);
\draw[->,thick] ([yshift=0.1em]en_ffn.90) --([yshift=-0.1em]en_add2.-90);
\draw[->,thick] ([yshift=0.1em]en_add2.90) -- ([yshift=-0.1em]en_sf.-90);
\draw[->,thick] ([yshift=0.1em]en_sf.90) -- ([yshift=1.5em]en_sf.90)node[left,pos=0.5]{\scriptsize{CTC Loss}};
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]en_sa.south)--([yshift=-0.6em,xshift=-4.0em]en_sa.south)--([xshift=-0.43em]en_add1.west)--(en_add1.west);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]en_ffn.south)--([yshift=-0.6em,xshift=-4.0em]en_ffn.south)--([xshift=-0.43em]en_add2.west)--(en_add2.west);
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=west] (de_add) at ([xshift=7em]en_add.east){};
\draw[] (de_add.90) -- (de_add.-90);
\draw[] (de_add.0) -- (de_add.180);
%%%%decoder
\node[draw,circle,inner sep=0pt, minimum size=1em,anchor=west,thick] (de_add) at ([xshift=9em]en_add.east){};
\draw[thick] (de_add.90) -- (de_add.-90);
\draw[thick] (de_add.0) -- (de_add.180);
\node[layer,anchor=south,fill=red!20] (de_sa) at ([yshift=1.4em]de_add.north){Masked \\Multi-Head\\Attention};
\node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.4em]de_sa.north){Multi-Head \\ Attention};
\node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.4em]de_ca.north){Feed Forward \\ Network};
\node[anchor=south,layer,fill=yellow!20](de_add1) at ([yshift=1.0em]de_sa.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=red!20] (de_ca) at ([yshift=1.0em]de_add1.north){Multi-Head \\ Attention};
\node[anchor=south,layer,fill=yellow!20](de_add2) at ([yshift=1.0em]de_ca.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=green!20] (de_ffn) at ([yshift=1.0em]de_add2.north){Feed Forward \\ Network};
\node[anchor=south,layer,fill=yellow!20](de_add3) at ([yshift=1.0em]de_ffn.north) {Add \& LayerNorm};
\node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=1.2em]de_add3.north){Softmax};
\node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1.1em]de_add.south){目标语言文本\\编码表示};
\node[layer,anchor=south,fill=blue!20] (en_sf) at ([yshift=3em]en_ffn.north){Softmax};
\node[layer,anchor=south,fill=blue!20] (sf) at ([yshift=2em]de_ffn.north){Softmax};
\node[layer,anchor=south,fill=orange!20] (en_output) at ([yshift=1.4em]en_sf.north){CTC Output};
%\node[layer,anchor=south,fill=orange!20] (output) at ([yshift=1.4em]sf.north){ST Output};
\node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){位置编码};
\node[anchor=north,font=\scriptsize,align=center] (en_input) at ([yshift=-1em]en_cnn.south){语音特征\\(FBank/MFCC)};
\node[anchor=north,font=\scriptsize,align=center] (de_input) at ([yshift=-1em]de_add.south){标注文本\\编码表示};
\draw[->,thick] (de_input.90) -- ([yshift=-0.1em]de_add.-90);
\draw[->,thick] ([yshift=0.1em]de_add.90) -- ([yshift=-0.1em]de_sa.-90);
\draw[->,thick] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_add1.-90);
\draw[->,thick] ([yshift=0.1em]de_add1.90) -- ([yshift=-0.1em]de_ca.-90);
\draw[->,thick] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_add2.-90);
\draw[->,thick] ([yshift=0.1em]de_add2.90) -- ([yshift=-0.1em]de_ffn.-90);
\draw[->,thick] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]de_add3.-90);
\draw[->,thick] ([yshift=0.1em]de_add3.90) -- ([yshift=-0.1em]sf.-90);
\draw[->,thick] ([yshift=0.1em]sf.90) -- ([yshift=1.0em]sf.90);
\draw[->,thick] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180);
\draw[->,thick] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]de_sa.south)--([yshift=-0.6em,xshift=4.0em]de_sa.south)--([xshift=0.43em]de_add1.east)--(de_add1.east);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]de_ca.south)--([yshift=-0.6em,xshift=4.0em]de_ca.south)--([xshift=0.43em]de_add2.east)--(de_add2.east);
\draw[->,rounded corners=2pt,thick] ([yshift=-0.6em]de_ffn.south)--([yshift=-0.6em,xshift=4.0em]de_ffn.south)--([xshift=0.43em]de_add3.east)--(de_add3.east);
\draw[->,rounded corners=2pt,thick] ([yshift=0.1em]en_add2.90) -- ([yshift=1.5em]en_add2.90) -- ([xshift=5.0em,yshift=1.5em]en_add2.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west);
\node[anchor=east,font=\scriptsize,align=center] (en_pos) at ([xshift=-2em]en_add.west){位置编码};
\node[anchor=west,font=\scriptsize,align=center] (de_pos) at ([xshift=2em]de_add.east){位置编码};
\draw[->] (en_input.90) -- ([yshift=-0.1em]en_cnn.-90);
\draw[->] ([yshift=0.1em]en_cnn.90) -- ([yshift=-0.1em]en_add.-90);
\draw[->] ([yshift=0.1em]en_add.90) -- ([yshift=-0.1em]en_sa.-90);
\draw[->] ([yshift=0.1em]en_sa.90) -- ([yshift=-0.1em]en_ffn.-90);
\draw[->] (de_input.90) -- ([yshift=-0.1em]de_add.-90);
\draw[->] ([yshift=0.1em]de_add.90) -- ([yshift=-0.1em]de_sa.-90);
\draw[->] ([yshift=0.1em]de_sa.90) -- ([yshift=-0.1em]de_ca.-90);
\draw[->] ([yshift=0.1em]de_ca.90) -- ([yshift=-0.1em]de_ffn.-90);
\draw[->] ([yshift=0.1em]en_ffn.90) -- ([yshift=-0.1em]en_sf.-90);
\draw[->] ([yshift=0.1em]en_sf.90) -- ([yshift=-0.1em]en_output.-90);
\draw[->] ([yshift=0.1em]de_ffn.90) -- ([yshift=-0.1em]sf.-90);
\draw[->] ([yshift=0.1em]sf.90) -- ([yshift=1.5em]sf.90);
\draw[->] ([xshift=0.1em]en_pos.0) -- ([xshift=-0.1em]en_add.180);
\draw[->] ([xshift=-0.1em]de_pos.180) -- ([xshift=0.1em]de_add.0);
\draw[->,rounded corners=2pt] ([yshift=2em]en_ffn.90) -- ([xshift=4em,yshift=2em]en_ffn.90) -- ([xshift=-1.5em]de_ca.west) -- ([xshift=-0.1em]de_ca.west);
\begin{pgfonlayer}{background}
\node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(en_sa)(en_ffn)]{};
\node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick][fit=(de_sa)(de_ca)(de_ffn)]{};
\node[draw=ugreen,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick,xshift=-0.2em,yshift=-0.2em][fit=(en_add1)(en_add2)(en_sa)(en_ffn)](box1){};
\node[draw=red,rounded corners=2pt,inner xsep=6pt,inner ysep=8pt,dashed,thick,xshift=0.2em,yshift=-0.2em][fit=(de_sa)(de_ca)(de_ffn)(de_add3)](box2){};
\end{pgfonlayer}
\node[anchor=east,font=\scriptsize,text=ugreen] at ([xshift=-0.1em]box1.west){$N \times$};
\node[anchor=west,font=\scriptsize,text=red] at ([xshift=0.1em]box2.east){$\times N$};
\node[anchor=east,font=\scriptsize] at ([xshift=-0.1em]en_cnn.west){$2 \times$};
\node[anchor=east,font=\scriptsize,align=center,text=ugreen] at ([xshift=-0.1em,yshift=3em]box1.west){ST\\ 编码器};
\node[anchor=west,font=\scriptsize,align=center,text=red] at ([xshift=0.1em,yshift=5em]box2.east){ST\\解码器};
\node[anchor=east,font=\scriptsize,align=center,text=ugreen] at ([xshift=-0.1em,yshift=3em]box1.west){ST \\ 编码器};
\node[anchor=west,font=\scriptsize,align=center,text=red] at ([xshift=0.1em,yshift=5em]box2.east){ST \\ 解码器};
\end{tikzpicture}
\ No newline at end of file
Chapter17/Figures/figure-three-ways-of-dual-decoder-speech-translation.tex
\tikzstyle{coder} = [rectangle,thick,rounded corners,minimum height=2.2em,minimum width=4.3em,text centered,draw=black!70,fill=red!20]
\tikzstyle{coder} = [rectangle,thick,rounded corners,minimum height=2.2em,minimum width=4.3em,text centered,draw=black,fill=red!20]
\begin{tikzpicture}[node distance = 0,scale = 0.75]
\tikzstyle{every node}=[scale=0.75]
......
Chapter17/Figures/figure-traditional-methods-of-image-description.tex
......@@ -2,31 +2,31 @@
\definecolor{color_green}{rgb}{0.663,0.82,0.557}
\definecolor{color_orange}{rgb}{0.957,0.694,0.514}
\definecolor{color_blue}{rgb}{0.335,0.708,0.735}
\tikzstyle{description} = [rectangle,rounded corners=1mm, minimum width=3cm,minimum height=0.6cm,text centered]
\tikzstyle{description} = [rectangle,rounded corners=1mm, minimum width=3cm,minimum height=0.6cm,text centered,draw,thick]
\begin{tikzpicture}[node distance = 0,scale = 0.8]
\tikzstyle{every node}=[scale=0.8]
\node(figure-1)[draw=white,scale=0.25] at (0,0){\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-dog-with-hat.png}};
\node(ground-1)[rectangle,rounded corners, minimum width=5cm, minimum height=3.5cm,right of = figure-1, xshift=5cm,fill=blue!20]{};
\node(text-1)[right of = figure-1, xshift=3.6cm,yshift=2cm,scale=1.2]{\textcolor{color_gray}{描述候选池}};
\node(text_1-1)[description, right of = figure-1, xshift=4.2cm,yshift=1.2cm,fill=color_gray!50]{\textcolor{white}{天空中有很多鸟。}};
\node(text_2-1)[description, right of = figure-1, xshift=5.3cm,yshift=0.5cm,fill=color_green]{\textcolor{white}{孩子从河岸上跳下来。}};
\node(text_3-1)[description, right of = figure-1, xshift=4.5cm,yshift=-0.2cm,fill=color_orange]{\textcolor{white}{狗在吐舌头。}};
\node(ground-1)[rectangle,rounded corners, minimum width=5cm, minimum height=3.5cm,right of = figure-1, xshift=5cm,fill=gray!10,draw,thick,drop shadow]{};
\node(text-1)[right of = figure-1, xshift=3.6cm,yshift=2.1cm,scale=1.2]{{描述候选池}};
\node(text_1-1)[description, right of = figure-1, xshift=4.2cm,yshift=1.2cm,fill=gray!20]{{天空中有很多鸟。}};
\node(text_2-1)[description, right of = figure-1, xshift=5.3cm,yshift=0.5cm,fill=green!20]{{孩子从河岸上跳下来。}};
\node(text_3-1)[description, right of = figure-1, xshift=4.5cm,yshift=-0.2cm,fill=orange!20]{{狗在吐舌头。}};
\node(surd-1)[right of = text_3-1, xshift=2cm,scale=1.5]{\textcolor{red}{$\surd$}};
\node(text_4-1)[description, right of = figure-1, xshift=5.2cm,yshift=-0.9cm,fill=color_blue]{\textcolor{white}{男人戴着眼镜。}};
\node(text_4-1)[description, right of = figure-1, xshift=5.2cm,yshift=-0.9cm,fill=blue!20]{{男人戴着眼镜。}};
\node(point-1)[right of = figure-1, xshift=5cm,yshift=-1.4cm,scale=1.5]{...};
\draw[->,thick](figure-1)to([xshift=-0.1cm]ground-1.west);
\node(figure)[draw=white,scale=0.25]at ([xshift=20.0em]figure-1.east){\includegraphics[width=0.62\textwidth]{./Chapter17/Figures/figure-dog-with-hat.png}};
\node(ground)[rectangle,rounded corners, minimum width=5cm, minimum height=1.5cm,right of = figure, xshift=5cm,yshift=-2.6em,fill=blue!20]{\large{图片中有\underline{\textcolor{red}{狗}}，\underline{\textcolor{red}{帽子}}，\underline{\quad\ }。}};
\node(dog)[rectangle,rounded corners, minimum width=1cm, minimum height=0.7cm,right of = figure, xshift=3cm,yshift=1.5cm,thick, draw=color_orange,fill=color_orange!50]{狗};
\node(hat)[rectangle,rounded corners, minimum width=1.5cm, minimum height=0.7cm,right of = figure, xshift=4.5cm,yshift=1.5cm,thick, draw=color_green,fill=color_green!50]{帽子};
\draw[->, thick,color=black!60](figure.east)to([xshift=-0.1cm]dog.west)node[left,xshift=-0.2cm,yshift=-0.1cm,color=black]{图片检测};
\draw[->, thick,color=black!60]([yshift=-0.1cm]hat.south)to([yshift=0.1cm]ground.north)node[right,xshift=-0.2cm,yshift=0.5cm,color=black]{模板填充};
\node(ground)[rectangle,rounded corners, minimum width=5cm, minimum height=1.5cm,right of = figure, xshift=5cm,yshift=-2.6em,fill=gray!10,draw,thick,drop shadow]{\large{图片中有\underline{\textcolor{red}{狗}}，\underline{\textcolor{red}{帽子}}，\underline{\quad\ }。}};
\node(dog)[rectangle,rounded corners, minimum width=1cm, minimum height=0.7cm,right of = figure, xshift=3cm,yshift=1.5cm,thick, draw,fill=orange!20,thick]{狗};
\node(hat)[rectangle,rounded corners, minimum width=1.5cm, minimum height=0.7cm,right of = figure, xshift=4.5cm,yshift=1.5cm,thick, draw,fill=green!20,thick]{帽子};
\draw[->, thick](figure.east)to([xshift=-0.1cm]dog.west)node[left,xshift=-0.2cm,yshift=-0.1cm,color=black]{图片检测};
\draw[->, thick]([yshift=-0.1cm]hat.south)to([yshift=0.1cm]ground.north)node[right,xshift=-0.2cm,yshift=0.5cm,color=black]{模板填充};
\node [anchor=north](pos1)at ([xshift=-3.8em,yshift=-0.5em]ground-1.south){(a) 基于检索的图像描述生成};
\node [anchor=north](pos2)at ([xshift=-3.8em,yshift=-0.5em]ground.south){(b) 基于模板的图像描述生成};
\node [anchor=north](pos1)at ([xshift=-3.8em,yshift=-1em]ground-1.south){(a) 基于检索的图像描述生成};
\node [anchor=north](pos2)at ([xshift=-3.8em,yshift=-1em]ground.south){(b) 基于模板的图像描述生成};
\end{tikzpicture}
\ No newline at end of file
Chapter17/chapter17.tex
......@@ -23,9 +23,9 @@
\chapter{多模态、多层次机器翻译}
\parinterval 基于上下文的翻译是机器翻译的一个重要分支。传统方法中，机器翻译通常被定义为对一个句子进行翻译的问题。但是，现实中每句话往往不是独立出现的。比如，人们会使用语音进行表达，或者通过图片来传递信息，这些语音和图片内容都可以伴随着文字一起出现在翻译场景中。此外，句子往往存在于段落或者篇章之中，如果要理解这个句子，也需要整个段落或者篇章的信息。而这些上下文信息都是机器翻译可以利用的。
\parinterval 基于上下文的翻译是机器翻译的一个重要分支。传统方法中，机器翻译通常被定义为对一个句子进行翻译的任务。但是，现实中每句话往往不是独立出现的。比如，人们会使用语音进行表达，或者通过图片来传递信息，这些语音和图片内容都可以伴随着文字一起出现在翻译场景中。此外，句子往往存在于段落或者篇章之中，如果要理解这个句子，也需要整个段落或者篇章的信息，而这些上下文信息都是机器翻译可以利用的。
\parinterval 本章在句子级翻译的基础上将问题扩展为更大上下文中的翻译，具体包括语音翻译、图像翻译、篇章翻译三个主题。这些问题均为机器翻译应用中的真实需求。同时，使用多模态等信息也是当下自然语言处理的热点方向之一。
\parinterval 本章在句子级翻译的基础上将问题扩展为更大的上下文中的翻译，具体包括语音翻译、图像翻译、篇章翻译三个主题。这些问题均为机器翻译应用中的真实需求。同时，使用多模态等信息也是当下自然语言处理的热点研究方向之一。
%----------------------------------------------------------------------------------------
% NEW SECTION
......@@ -45,7 +45,7 @@
\label{fig:17-1}
\end{figure}
%-------------------------------------------
\parinterval {\small\bfnew{模态}}\index{模态}（Modality）\index{Modality}是指某一种信息来源。例如，视觉、听觉、嗅觉、味觉都可以被看作是不同的模态。因此视频、语音、文字等都可以被看作是承载这些模态的媒介。在机器翻译中使用多模态这个概念，是为了区分某些不同于文字的信息。除了图像等视觉模态信息，机器翻译也可以利用语音模态信息。比如，直接对语音进行翻译，甚至直接用语音表达出翻译结果。
\parinterval {\small\bfnew{模态}}\index{模态}（Modality）\index{Modality}是指某一种信息来源。例如，视觉、听觉、嗅觉、味觉都可以被看作是不同的模态。因此视频、语音、文字等都可以被看作是承载这些模态的媒介。在机器翻译中使用多模态这个概念，是为了区分某些不同于文字的信息。除了图像等视觉模态信息，机器翻译也可以利用听觉模态信息。比如，直接对语音进行翻译，甚至直接用语音表达出翻译结果。
\parinterval 除了不同信息源所引入的上下文，机器翻译也可以利用文字本身的上下文。比如，翻译一篇文章中的某个句子时，可以根据整个篇章的内容进行翻译。显然这种篇章的语境是有助于机器翻译的。在本章接下来的内容中，会对机器翻译中使用不同上下文（多模态和篇章信息）的方法展开讨论。
......@@ -62,7 +62,7 @@
\subsection{音频处理}
\parinterval 为了保证对相关内容描述的完整性，这里对语音处理的基本知识作简要介绍。不同于文本，音频本质上是经过若干信号处理之后的{\small\bfnew{波形}}（Waveform）\index{Waveform}。具体来说，声音是一种空气的震动，因此可以被转换为模拟信号。模拟信号是一段连续的信号，经过采样变为离散的数字信号。采样是每隔固定的时间记录一下声音的振幅，采样率表示每秒的采样点数，单位是赫兹（Hz）。采样率越高，结果的损失则越小。通常来说，采样的标准是能够通过离散化的数字信号重现原始语音。日常生活中使用的手机和电脑设备的采样率一般为16kHz，表示每秒16000个采样点；而音频CD的采样率可以达到44.1kHz。 经过进一步的量化，将采样点的值转换为整型数值保存，从而减少占用的存储空间，通常采用的是16位量化。将采样率和量化位数相乘，就可以得到{\small\bfnew{比特率}}\index{比特率}（Bits Per Second，BPS）\index{Bits Per Second}，表示音频每秒占用的位数。例如，16kHz采样率和16位量化的音频，比特率为256kb/s。音频处理的整体流程如图\ref{fig:17-2}所示\upcite{洪青阳2020语音识别原理与应用,陈果果2020语音识别实战}。
\parinterval 为了保证对相关内容描述的完整性，这里对语音处理的基本知识作简要介绍。不同于文本，音频本质上是经过若干信号处理之后的{\small\bfnew{波形}}（Waveform）\index{Waveform}。具体来说，声音是一种空气的震动，因此可以被转换为模拟信号。模拟信号是一段连续的信号，经过采样变为离散的数字信号。采样是每隔固定的时间记录一下声音的振幅，采样率表示每秒的采样点数，单位是赫兹（Hz）。采样率越高，采样的结果与原始的语音越相像。通常来说，采样的标准是能够通过离散化的数字信号重现原始语音。日常生活中使用的手机和电脑设备的采样率一般为16kHz，表示每秒16000个采样点；而音频CD的采样率可以达到44.1kHz。 经过进一步的量化，将采样点的值转换为整型数值保存，从而减少占用的存储空间，通常采用的是16位量化。将采样率和量化位数相乘，就可以得到{\small\bfnew{比特率}}\index{比特率}（Bits Per Second，BPS）\index{Bits Per Second}，表示音频每秒占用的位数。例如，16kHz采样率和16位量化的音频，比特率为256kb/s。音频处理的整体流程如图\ref{fig:17-2}所示\upcite{洪青阳2020语音识别原理与应用,陈果果2020语音识别实战}。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
......@@ -75,7 +75,7 @@
\parinterval 经过上面的描述可以看出，音频的表示实际上是一个非常长的采样点序列，这导致了直接使用现有的深度学习技术处理音频序列较为困难。并且，原始的音频信号中可能包含着较多的噪声、环境声或冗余信息，也会对模型产生干扰。因此，一般会对音频序列进行处理来提取声学特征，具体为将长序列的采样点序列转换为短序列的特征向量序列，再用于下游系统。虽然已有一些工作不依赖特征提取，直接在原始的采样点序列上进行声学建模和模型训练\upcite{DBLP:conf/interspeech/SainathWSWV15}，但目前的主流方法仍然是基于声学特征进行建模\upcite{DBLP:conf/icassp/MohamedHP12}。
\parinterval 声学特征提取的第一步是预处理。其流程主要是对音频进行预加重、分帧和加窗。预加重用来提升音频信号中的高频部分，目的是使频谱更加平滑。分帧（原理如图\ref{fig:17-3}所示）是基于短时平稳假设，即根据生物学特征，语音信号是一个缓慢变化的过程，10ms$\thicksim$30ms的信号片段是相对平稳的。基于这个假设，一般将每25ms作为一帧来提取特征，这个时间称为{\small\bfnew{帧长}}\index{帧长}（Frame Length）\index{Frame Length}。同时，为了保证不同帧之间的信号平滑性，使每两个相邻帧之间存在一定的重合部分。一般每隔10ms取一帧，这个时长称为{\small\bfnew{帧移}}\index{帧移}（Frame Shift）\index{Frame Shift}。为了缓解分帧带来的频谱泄漏，对每帧的信号进行加窗处理使其幅度在两段渐变到0，一般采用的是{\small\bfnew{汉明窗}}\index{汉明窗}（Hamming）\index{Hamming}\upcite{洪青阳2020语音识别原理与应用}。
\parinterval 声学特征提取的第一步是预处理。其流程主要是对音频进行{\small\bfnew{预加重}}（Pre-emphasis）\index{预加重}\index{Pre-emphasis}、{\small\bfnew{分帧}}\index{分帧}（Framing）\index{Framing}和{\small\bfnew{加窗}}\index{加窗}（Windowing）\index{Windowing}。预加重是通过增强音频信号中的高频部分来减弱语音中对高频信号的抑制，使频谱更加顺滑。分帧（原理如图\ref{fig:17-3}所示）是基于短时平稳假设，即根据生物学特征，语音信号是一个缓慢变化的过程，10ms$\thicksim$30ms的信号片段是相对平稳的。基于这个假设，一般将每25ms作为一帧来提取特征，这个时间称为{\small\bfnew{帧长}}\index{帧长}（Frame Length）\index{Frame Length}。同时，为了保证不同帧之间的信号平滑性，使每两个相邻帧之间存在一定的重合部分。一般每隔10ms取一帧，这个时长称为{\small\bfnew{帧移}}\index{帧移}（Frame Shift）\index{Frame Shift}。为了缓解分帧带来的频谱泄漏问题，需要对每帧的信号进行加窗处理使其幅度在两段渐变到0，一般采用的是{\small\bfnew{汉明窗}}\index{汉明窗}（Hamming）\index{Hamming}\upcite{洪青阳2020语音识别原理与应用}。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
\centering
......@@ -85,9 +85,7 @@
\end{figure}
%----------------------------------------------------------------------------------------------------
\parinterval 经过了上述的预处理操作，可以得到音频对应的帧序列，之后通过不同的操作来提取不同类型的声学特征。常用的声学特征包括{\small\bfnew{Mel频率倒谱系数}}\index{Mel频率倒谱系数}（Mel-frequency Cepstral Coefficient，MFCC）\index{Mel-Frequency Cepstral Coefficient}、{\small\bfnew{感知线性预测系数}}\index{感知线性预测系数}（Perceptual Lienar Predictive，PLP）\index{Perceptual Lienar Predictive}、{\small\bfnew{滤波器组}}\index{滤波器组}（Filter-bank，Fbank）\index{Filter-bank}等。MFCC、PLP和Fbank特征都需要对预处理后的音频做{\small\bfnew{短时傅里叶变换}}\index{短时傅里叶变换}（Short-time Fourier Tranform，STFT）\index{Short-time Fourier Tranform}，得到具有规律的线性分辨率。之后再经过特定的操作，得到各种声学特征。不同声学特征的特点是不同的，MFCC去相关性较好，PLP抗噪性强，FBank可以保留更多的语音原始特征。在语音翻译中，比较常用的声学特征为FBank或MFCC\upcite{洪青阳2020语音识别原理与应用}。
\parinterval 实际上，提取到的声学特征可以类比于计算机视觉中的像素特征，或者自然语言处理中的词嵌入表示。不同之处在于，声学特征更加复杂多变，可能存在着较多的噪声和冗余信息。此外，相比对应的文字序列，音频提取到的特征序列长度要大十倍以上。比如，人类正常交流中每秒钟一般可以说2-3个字，而每秒钟的语音可以提取得到100帧的特征序列。巨大的长度比差异也为声学特征建模带来了挑战。
\parinterval 经过了上述的预处理操作，可以得到音频对应的帧序列，之后通过不同的操作来提取不同类型的声学特征。在语音翻译中，比较常用的声学特征为{\small\bfnew{滤波器组}}\index{滤波器组}（Filter-bank，Fbank）\index{Filter-bank}和{\small\bfnew{Mel频率倒谱系数}}\index{Mel频率倒谱系数}（Mel-frequency Cepstral Coefficient，MFCC）\upcite{洪青阳2020语音识别原理与应用}。实际上，提取到的声学特征可以类比于计算机视觉中的像素特征，或者自然语言处理中的词嵌入表示。不同之处在于，声学特征更加复杂多变，可能存在着较多的噪声和冗余信息。此外，相比对应的文字序列，音频提取到的特征序列长度要大十倍以上。比如，人类正常交流中每秒钟一般可以说2-3个字，而每秒钟的语音可以提取得到100帧的特征序列。巨大的长度比差异也为声学特征建模带来了挑战。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -109,45 +107,21 @@
\parinterval 由于声学特征提取在上一节中已经进行了描述，而且文本翻译可以直接使用本书介绍的统计机器翻译或者神经机器翻译方法。因此下面简要介绍一下语音识别模型，以便读者对级联式语音翻译系统有一个完整的认识。其中的部分概念在后续介绍的端到端语言翻译中也会有所涉及。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{1. 语音识别方法}
\parinterval 传统的语音识别模型和统计机器翻译相似，需要利用声学模型、语言模型和发音词典联合进行识别，系统较为复杂\upcite{DBLP:journals/ftsig/GalesY07,DBLP:journals/taslp/MohamedDH12,DBLP:journals/spm/X12a}。而近些年来，随着神经网络的发展，基于神经网络的端到端语音识别模型逐渐受到关注，大大简化了训练流程\upcite{DBLP:conf/nips/ChorowskiBSCB15,DBLP:conf/icassp/ChanJLV16}。目前的端到端语音识别模型主要基于序列到序列结构，编码器根据输入的声学特征进一步提取高级特征，解码器根据编码器提取的特征识别对应的文本。在后文中即将介绍的端到端语音翻译模型也是基于十分相似的结构。因此，从某种意义上说，语音识别和翻译所使用的端到端方法与神经机器翻译是一致的。
\parinterval 语音识别目前广泛使用基于Transformer的模型结构（见{\chaptertwelve}），如图\ref{fig:17-5}所示。可以看出，相比文本翻译，模型结构上唯一的区别在于编码器的输入为声学特征，以及编码器底层会使用额外的卷积层来减小输入序列的长度，从而降低长序列带来的显存占用以及建模难度。由于语音对应的特征序列过长，在计算注意力模型的时候，会占用大量的内存/显存，并增加训练时间。因此，通常会先对语音特征做一个下采样，缩小语音的序列长度。目前一个常用的做法，是在输入的语音特征上进行两层步长为2的卷积操作，从而将输入序列的长度缩小为之前的1/4。 通过大量的语音-标注平行数据对模型进行训练，可以得到高质量的语音识别模型。
\parinterval 传统的语音识别模型和统计机器翻译相似，需要利用声学模型、语言模型和发音词典联合进行识别，系统较为复杂\upcite{DBLP:journals/ftsig/GalesY07,DBLP:journals/taslp/MohamedDH12,DBLP:journals/spm/X12a}。而近些年来，随着神经网络的发展，基于神经网络的端到端语音识别模型逐渐受到关注，训练流程也大大被简化\upcite{DBLP:conf/nips/ChorowskiBSCB15,DBLP:conf/icassp/ChanJLV16}。目前的端到端语音识别模型主要基于序列到序列结构，编码器根据输入的声学特征进一步提取高级特征，解码器根据编码器提取的特征识别对应的文本。在后文中即将介绍的端到端语音翻译模型也是基于十分相似的结构。因此，从某种意义上说，语音识别和翻译所使用的端到端方法与神经机器翻译是一致的。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter17/Figures/figure-speech-recognition-model-based-on-transformer}
\setlength{\abovecaptionskip}{-0.2em}
\caption{基于Transformer的语音识别模型}
\label{fig:17-5}
\end{figure}
%----------------------------------------------------------------------------------------------------
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{2. 语音识别结果的表示}
\parinterval 级联语音翻译模型利用翻译模型将语音识别结果翻译为目标语言文本，但存在的一个问题是语音识别模型只输出One-best，其中可能存在一些识别错误，这些错误在翻译过程中会被放大，也就是错误传播问题。传统级联语音模型的一个主要方向是丰富语音识别模型的预测结果，为翻译模型提供更多的信息，具体做法是在语音识别模型中，声学模型解码得到词格来取代One-best 识别结果。词格是一种有向无环图，包含单个起点和终点，图中的每条边记录了每个词和对应的转移概率，如图\ref{fig:17-6}所示。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter17/Figures/figure-word-lattice.tex}
\caption{词格示例}
\label{fig:17-6}
\end{figure}
%----------------------------------------------------------------------------------------------------
\parinterval 可以看出，词格可以保存多条搜索路径，路径中保存了输入序列的时间信息以及解码过程。翻译模型基于词格进行翻译，可以降低语音识别模型带来的误差\upcite{DBLP:conf/acl/ZhangGCF19,DBLP:conf/acl/SperberNPW19}。但在端到端语音识别模型中，一般使用基于束搜索的方法进行解码，解码序列的长度与输入序列并不匹配，相比传统声学模型解码丢失了语音的时间信息，因此这种基于词格的方法主要集中在传统语音识别系统上。
\vspace{-1em}
\parinterval 语音识别目前广泛使用基于Transformer的模型结构（见{\chaptertwelve}），如图\ref{fig:17-5}所示。可以看出，相比文本翻译，模型结构上唯一的区别在于编码器的输入为声学特征，以及编码器底层会使用额外的卷积层来减小输入序列的长度。这是由于语音对应的特征序列过长，在计算注意力模型的时候，会占用大量的内存/显存，并增加训练时间。因此，一个常用的做法是在语音特征上进行两层步长为2的卷积操作，从而将输入序列的长度缩小为之前的1/4。通过使用大量的语音-标注平行数据对模型进行训练，可以得到高质量的语音识别模型。
\parinterval 为了降低错误传播问题带来的影响，一种思路是通过一个后处理模型修正识别结果中的错误，再送给文本翻译模型进行翻译。也可以进一步对文本做{\small\bfnew{顺滑}}\index{顺滑}（Disfluency Detection\index{Disfluency Detection}）处理，使得送给翻译系统的文本更加干净、流畅，比如除去一些导致停顿的语气词。这一做法在工业界得到了广泛应用，但由于每个模型只能串行地计算，也会带来额外的计算代价以及运算时间。另外一种思路是训练更加健壮的文本翻译模型，使其可以处理输入中存在的噪声或误差\upcite{DBLP:conf/acl/LiuTMCZ18}。
\parinterval 为了降低语音识别的错误对下游系统的影响，通常也会用词格来取代One-best语音识别结果。另一种思路是通过一个后处理模型修正识别结果中的错误，再送给文本翻译模型进行翻译。也可以进一步对文本做{\small\bfnew{顺滑}}\index{顺滑}（Disfluency Detection\index{Disfluency Detection}）处理，使得送给翻译系统的文本更加干净、流畅，比如除去一些导致停顿的语气词。这一做法在工业界得到了广泛应用，但由于每个模型只能串行地计算，也会带来额外的计算代价以及运算时间。另外一种思路是训练更加健壮的文本翻译模型，使其可以处理输入中存在的噪声或误差\upcite{DBLP:conf/acl/LiuTMCZ18}。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -159,17 +133,25 @@
%----------------------------------------------------------------------------------------------------
\begin{itemize}
\vspace{0.5em}
\item {\small\bfnew{错误传播问题}}。级联模型导致的一个很严重的问题在于，语音识别模型得到的文本如果存在错误，这些错误很可能在翻译过程中被放大，从而使最后翻译结果出现比较大的偏差。比如识别时在句尾少生成了个“吗”，会导致翻译模型将疑问句翻译为陈述句。
\vspace{0.5em}
\item {\small\bfnew{翻译效率问题}}。由于语音识别模型和文本标注模型只能串行地计算，翻译效率相对较低，而实际很多场景中都需要低延时的翻译。
\item {\small\bfnew{翻译效率问题}}。由于语音识别模型和文本标注模型只能串行地计算，翻译效率相对较低，而实际很多场景中都需要实现低延时的翻译。
\vspace{0.5em}
\item {\small\bfnew{语音中的副语言信息丢失}}。将语音识别为文本的过程中，语音中包含的语气、情感、音调等信息会丢失，而同一句话在不同的语气中表达的意思很可能是不同的。尤其是在实际应用中，由于语音识别结果通常并不包含标点，还需要额外的后处理模型将标点还原，也会带来额外的计算代价。
\vspace{0.5em}
\end{itemize}
%----------------------------------------------------------------------------------------------------
\parinterval 针对级联语音翻译模型存在的缺陷，研究者们提出了{\small\bfnew{端到端的语音翻译模型}}\index{端到端的语音翻译模型}（End-to-End Speech Translation, E2E-ST）\index{End-to-End Speech Translation}\upcite{DBLP:conf/naacl/DuongACBC16,DBLP:conf/interspeech/WeissCJWC17,DBLP:journals/corr/BerardPSB16}，也就是模型的输入是源语言语音，输出是对应的目标语言文本。相比级联模型，端到端模型有如下优点：
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter17/Figures/figure-an-end-to-end-voice-translation-model-based-on-transformer}
\setlength{\abovecaptionskip}{-0.2em}
\caption{基于Transformer的端到端语音翻译模型}
\label{fig:17-7}
\end{figure}
%----------------------------------------------------------------------------------------------------
\parinterval 针对级联语音翻译模型存在的缺陷，研究人员提出了{\small\bfnew{端到端的语音翻译模型}}\index{端到端的语音翻译模型}（End-to-End Speech Translation，E2E-ST）\index{End-to-End Speech Translation}\upcite{DBLP:conf/naacl/DuongACBC16,DBLP:conf/interspeech/WeissCJWC17,DBLP:journals/corr/BerardPSB16}，也就是模型的输入是源语言语音，输出是对应的目标语言文本。相比级联模型，端到端模型有如下优点：
%----------------------------------------------------------------------------------------------------
\begin{itemize}
......@@ -178,22 +160,13 @@
\vspace{0.5em}
\item 同样地，端到端模型所涉及的模块更少，容易控制模型体积。
\vspace{0.5em}
\item 由于端到端模型语音信号可以直接作用于翻译过程，因此可以使得副语言信息得以体现。
\item 端到端模型语音信号可以直接作用于翻译过程，因此可以使得副语言信息得以体现。
\vspace{0.5em}
\end{itemize}
%----------------------------------------------------------------------------------------------------
\parinterval 以Transformer模型为例，图\ref{fig:17-7}展示了端到端语音翻译的架构（下文中语音翻译模型均指端到端的模型）。该模型采用的也是序列到序列架构，编码器的输入是从语音中提取的特征（比如FBank特征）。编码器底层采用和语音识别模型相同的卷积结构来降低序列的长度（见\ref{sec:cascaded-speech-translation}节）。之后的流程和标准的神经机器翻译是完全一致的，编码器对语音特征进行编码，解码器根据编码结果生成目标语言的翻译结果。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter17/Figures/figure-an-end-to-end-voice-translation-model-based-on-transformer}
\caption{基于Transformer的端到端语音翻译模型}
\label{fig:17-7}
\end{figure}
%----------------------------------------------------------------------------------------------------
\parinterval 虽然端到端语音翻译模型解决了级联模型存在的问题，但同时也面临着两个严峻的问题：
%----------------------------------------------------------------------------------------------------
......@@ -206,7 +179,7 @@
\end{itemize}
%----------------------------------------------------------------------------------------------------
\parinterval 针对这两个问题，研究人员们也提出了很多方法进行缓解，包括多任务学习、迁移学习等，主要思想都是利用语音识别或文本翻译数据来指导模型的学习。并且，文本翻译的很多方法对语音翻译技术的发展提供了思路。如何将其他领域现有的工作在语音翻译任务上验证，也是语音翻译研究当前所关注的\upcite{DBLP:conf/mtsummit/GangiNCDT19}。
\parinterval 针对这两个问题，研究人员们也提出了很多方法进行缓解，包括多任务学习、迁移学习等，主要思想都是利用语音识别或文本翻译数据来指导模型的学习。并且，文本翻译的很多方法对语音翻译技术的发展提供了思路。如何将其他领域现有的工作在语音翻译任务上验证，也是语音翻译研究人员当前所关注的\upcite{DBLP:conf/mtsummit/GangiNCDT19}。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -215,7 +188,7 @@
\parinterval 一种思路是进行多任务学习，让模型在训练过程中得到更多的监督信息。使用多个任务强化主任务（机器翻译），在本书的{\chapterfifteen}和{\chaptersixteen}也有所涉及。从这个角度说，机器翻译中很多问题的解决手段都是一致的。
\parinterval 语音翻译中多任务学习主要借助语音对应的标注信息，也就是源语言文本。{\small\bfnew{连接时序分类}}\index{连接时序分类}（Connectionist Temporal Classification，CTC）\index{Connectionist Temporal Classification}\upcite{DBLP:conf/icml/GravesFGS06}是语音处理中最简单有效的一种多任务学习方法\upcite{DBLP:journals/jstsp/WatanabeHKHH17,DBLP:conf/icassp/KimHW17}，也被广泛应用于文本识别任务中\upcite{DBLP:journals/pami/ShiBY17}。CTC可以将输入序列的每一位置都对应到标注文本中，学习语音和文字之间的软对齐关系。比如，对于下面的音频序列，CTC可以将每个位置分别对应到同一个词。需要注意的是，CTC会额外新增一个词$\epsilon$，类似于一个空白词，表示这个位置没有声音或者没有任何对应的预测结果。在对齐完成之后，将相同且连续的词合并，去除$\epsilon$，就可以得到预测结果，如图\ref{fig:17-8} 所示。
\parinterval 语音翻译中多任务学习主要借助语音对应的标注信息，也就是源语言文本。{\small\bfnew{连接时序分类}}\index{连接时序分类}（Connectionist Temporal Classification，CTC）\index{Connectionist Temporal Classification}\upcite{DBLP:conf/icml/GravesFGS06}是语音处理中最简单有效的一种多任务学习方法\upcite{DBLP:journals/jstsp/WatanabeHKHH17,DBLP:conf/icassp/KimHW17}，被广泛应用于文本识别任务中\upcite{DBLP:journals/pami/ShiBY17}。CTC可以将输入序列的每一位置都对应到标注文本中，学习语音和文字之间的软对齐关系。如图\ref{fig:17-8} ，对于下面的音频序列，CTC可以将每个位置分别对应到同一个词。需要注意的是，CTC会额外新增一个词$\epsilon$，类似于一个空白词，表示这个位置没有声音或者没有任何对应的预测结果。在对齐完成之后，将相同且连续的词合并，去除$\epsilon$，就可以得到预测结果。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
......@@ -231,7 +204,7 @@
%----------------------------------------------------------------------------------------------------
\begin{itemize}
\vspace{0.5em}
\item {\small\bfnew{输入和输出之间的对齐是单调的}}。也就是后面的输入只会预测与前面序列相同的后面的输出内容。比如对于图\ref{fig:17-8}中的例子，如果输入的位置t已经对齐了字符“l”，那么t之后的位置不会再对齐前面的字符“h”和“e”。
\item {\small\bfnew{输入和输出之间的对齐是单调的}}。对于音频输入序列$\{ s_1,...,s_m \} $，其对应的预测输出序列为$\{x_1,...,x_n \} $。假设$s_i$对应的预测输出结果为$x_j$，那么$s_{i+1}$相对应的预测结果只能是$x_j$、$x_{j+1}$和$\epsilon$三者中的一个。例如对于图\ref{fig:17-8}中的例子，如果输入的位置$s_i$已经对齐了字符“e”，那么$s_{i+1}$的对齐结果只能是“e”、“l”和$\epsilon$三者中的一个。
\vspace{0.5em}
\item {\small\bfnew{输入和输出之间是多对一的关系}}。也就是多个输入会对应到同一个输出上。这对于语音序列来说是非常自然的一件事情，由于输入的每个位置只包含非常短的语音特征，因此多个输入才可以对应到一个输出字符。
\vspace{0.5em}
......@@ -249,7 +222,7 @@
\end{figure}
%----------------------------------------------------------------------------------------------------
\parinterval 另外一种多任务学习的思想是通过两个解码器，分别预测语音对应的源语言句子和目标语言句子，具体有图\ref{fig:17-10}展示的三种方式\upcite{DBLP:conf/naacl/AnastasopoulosC18,DBLP:conf/asru/BaharBN19}。图\ref{fig:17-10}(a)中采用单编码器-双解码器的方式，两个解码器根据编码器的表示，分别预测源语言句子和目标语言句子，从而使编码器训练地更加充分。这种做法的好处在于源语言的文本生成任务成可以辅助翻译过程，相当于为源语言语音提供了额外的“模态”信息。图\ref{fig:17-10}(b)则通过使用两个级联的解码器，先利用第一个解码器生成源语言句子，然后再利用第一个解码器的表示，通过第二个解码器生成目标语言句子。这种方法通过增加一个中间输出，降低了模型的训练难度，但同时也会带来额外的解码耗时，因为两个解码器需要串行地进行生成。图\ref{fig:17-10}(c) 中模型更进一步，第二个编码器联合编码器和第一个解码器的表示进行生成，更充分地利用了已有信息。
\parinterval 另外一种多任务学习的思想是通过两个解码器，分别预测语音对应的源语言句子和目标语言句子，具体有图\ref{fig:17-10}展示的三种方式\upcite{DBLP:conf/naacl/AnastasopoulosC18,DBLP:conf/asru/BaharBN19}。图\ref{fig:17-10}(a)中采用单编码器-双解码器的方式，两个解码器根据编码器的表示，分别预测源语言句子和目标语言句子，从而使编码器训练地更加充分。这种做法的好处在于源语言的文本生成任务可以辅助翻译过程，相当于为源语言语音提供了额外的“模态”信息。图\ref{fig:17-10}(b)则通过使用两个级联的解码器，先利用第一个解码器生成源语言句子，然后再利用第一个解码器的表示，通过第二个解码器生成目标语言句子。这种方法通过增加一个中间输出，降低了模型的训练难度，但同时也会带来额外的解码耗时，因为两个解码器需要串行地进行生成。图\ref{fig:17-10}(c) 中模型更进一步，第二个编码器联合编码器和第一个解码器的表示进行生成，更充分地利用了已有信息。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
\centering
......@@ -271,7 +244,7 @@
%----------------------------------------------------------------------------------------
\subsubsection{3. 数据增强}
\parinterval 数据增强是增加训练数据最直接的一种方法。不同于文本翻译的回译等方法（见{\chaptersixteen}），语音翻译并不具有简单的“可逆性”。如果要利用回译的思想，需要通过一个模型，将目标语言文本转化为源语言语音，但实际上这种模型是不能简单得到的。因此，一个简单的思路是通过一个反向翻译模型和语音合成模型级联来生成伪数据\upcite{DBLP:conf/icassp/JiaJMWCCALW19}。 另外，正向翻译模型生成的伪数据在文本翻译中也被验证了对模型训练有一定的帮助，因此同样可以利用语音识别和文本翻译模型，将源语言语音生成目标语言翻译，得到伪平行语料。
\parinterval 数据增强是增加训练数据最直接的一种方法。不同于文本翻译的回译等方法（见{\chaptersixteen}），语音翻译并不具有简单的“可逆性”。如果要利用回译的思想，需要通过一个模型，将目标语言文本转化为源语言语音，但实际上这种模型是不能简单得到的。因此，一个简单的思路是通过一个反向翻译模型和语音合成模型级联来生成伪数据\upcite{DBLP:conf/icassp/JiaJMWCCALW19}。 另外，正向翻译模型生成的伪数据在文本翻译中也被验证了对模型训练有一定的帮助，因此同样可以利用语音识别和文本翻译模型，将源语言语音翻译成目标语言文本，得到伪平行语料。
%----------------------------------------------------------------------------------------------------
......@@ -311,7 +284,7 @@
\subsubsection{1. 基于特征融合的方法}
\parinterval 早期，通常将图像信息作为输入句子的一部分\upcite{DBLP:conf/emnlp/CalixtoL17,DBLP:conf/wmt/HuangLSOD16}，或者用其对编码器、解码器的状态进行初始化\upcite{DBLP:conf/emnlp/CalixtoL17,Elliott2015MultilingualID,DBLP:conf/wmt/MadhyasthaWS17}。如图\ref{fig:17-12}所示，图中$y_{<}$表示当前时刻之前的单词序列，对图像特征的提取通常是基于卷积神经网络，有关卷积神经网络的内容，可以参考{\chaptereleven}内容。通过卷积神经网络得到全局视觉特征，在进行维度变换后，将其作为源语言输入的一部分或者初始化状态引入到模型当中。但是，这种图像信息的引入方式有以下两个缺点：
\parinterval 早期，通常将图像信息作为输入句子的一部分\upcite{DBLP:conf/emnlp/CalixtoL17,DBLP:conf/wmt/HuangLSOD16}，或者用其对编码器、解码器的状态进行初始化\upcite{DBLP:conf/emnlp/CalixtoL17,Elliott2015MultilingualID,DBLP:conf/wmt/MadhyasthaWS17}。如图\ref{fig:17-12}所示，图中$y_{<}$表示当前时刻之前的单词序列，对图像特征的提取通常是基于卷积神经网络，有关卷积神经网络的内容，可以参考{\chaptereleven}内容。通过卷积神经网络得到全局图像特征，在进行维度变换后，将其作为源语言输入的一部分或者初始化状态引入到模型当中。但是，这种图像信息的引入方式有以下两个缺点：
\begin{itemize}
\vspace{0.5em}
......@@ -336,7 +309,7 @@
\centerline{中午/没/吃饭/，/又/刚/打/了/ 一/下午/篮球/，/我/现在/很/饿/ ，/我/想\underline{\quad \quad} 。}
\vspace{0.8em}
\parinterval 想在横线处填写“吃饭”，“吃东西”的原因是我们在读句子的过程中，关注到了“没/吃饭”，“很/饿”等关键息。这是在语言生成中注意力机制所解决的问题，即对于要生成的目标语言单词，相关性更高的语言片段应该更加“重要”，而不是将所有单词一视同仁。同样的，注意力机制也应用在多模态机器翻译中，即在生成目标单词时，更应该关注与目标单词相关的图像部分，而弱化对其他部分的关注。另外，注意力机制的引入，也使图像信息更加直接地参与目标语言的生成，解决了在不使用注意力机制的方法中图像信息传递损失的问题。
\parinterval 想在横线处填写“吃饭”，“吃东西”的原因是在读句子的过程中，关注到了“没/吃饭”，“很/饿”等关键息。这是在语言生成中注意力机制所解决的问题，即对于要生成的目标语言单词，相关性更高的语言片段应该更加“重要”，而不是将所有单词一视同仁。同样的，注意力机制也应用在多模态机器翻译中，即在生成目标单词时，更应该关注与目标单词相关的图像部分，而弱化对其他部分的关注。另外，注意力机制的引入，也使图像信息更加直接地参与目标语言的生成，解决了在不使用注意力机制的方法中图像信息传递损失的问题。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
......@@ -364,9 +337,9 @@
\parinterval 基于联合模型的方法通常是把翻译任务与其他视觉任务结合，进行联合训练。这种方法也可以被看做是一种多任务学习，只不过这里仅关注翻译和视觉任务。一种常见的方法是共享模型的部分参数来学习不同任务之间相似的部分，并通过特定的模块来学习每个任务特有的部分。
\parinterval 如图\ref{fig:17-14}所示，图中$y_{<}$表示当前时刻之前的单词序列，可以将多模态机器翻译任务分解为两个子任务：机器翻译和图片生成\upcite{DBLP:conf/ijcnlp/ElliottK17}。其中机器翻译作为主任务，图片生成作为子任务。这里的图片生成指的是从一个图片描述生成对应图片，对于图片生成任务在后面还会有描述。通过单个编码器对源语言数据进行建模，然后通过两个解码器（翻译解码器和图像解码器）来学习翻译任务和图像生成任务。顶层任务学习每个任务的独立特征，底层共享参数层能够学习到更丰富的文本表示。
\parinterval 如图\ref{fig:17-14}所示，图中$y_{<}$表示当前时刻之前的单词序列，可以将多模态机器翻译任务分解为两个子任务：机器翻译和图片生成\upcite{DBLP:conf/ijcnlp/ElliottK17}。其中机器翻译作为主任务，图片生成作为子任务。这里的图片生成指的是从一个图片描述生成对应图片，对于图片生成任务在后面还会有描述。通过单个编码器对源语言数据进行建模，然后通过两个解码器（翻译解码器和图像解码器）来分别学习翻译任务和图像生成任务。顶层学习每个任务的独立特征，底层共享参数能够学习到更丰富的文本表示。
\parinterval 另外在视觉问答领域有研究表明，在多模态任务中，不宜引入过多层的注意力机制，因为过深的模型会导致多模态模型的过拟合\upcite{DBLP:conf/nips/LuYBP16}。这一方面是由于深模型本身对数据的拟合能力，另一方面也是由于多模态任务的数据普遍较小，容易造成复杂模型的过拟合。从另一角度来说，利用多任务学习的方式，提高模型的泛化能力，也是一种有效防止过拟合现象的方式。类似的思想，也大量使用在多模态自然语言处理任务中，例如图像描述生成、视觉问答等\upcite{DBLP:conf/iccv/AntolALMBZP15}。
\parinterval 另外在视觉问答领域有研究表明，在多模态任务中，不宜引入过多层的注意力机制，因为过深的模型会导致多模态模型的过拟合\upcite{DBLP:conf/nips/LuYBP16}。这一方面是由于深层模型本身对数据的拟合能力较强，另一方面也是由于多模态任务的数据普遍较少，容易造成复杂模型的过拟合。从另一角度来说，利用多任务学习的方式，提高模型的泛化能力，也是一种有效防止过拟合现象的方式。类似的思想，也大量使用在多模态自然语言处理任务中，例如图像描述生成、视觉问答等\upcite{DBLP:conf/iccv/AntolALMBZP15}。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
......@@ -394,7 +367,7 @@
\end{figure}
%----------------------------------------------------------------------------------------------------
\parinterval 传统图像描述生成有两种范式：基于检索的方法和基于模板的方法。其中图\ref{fig:17-15}(a)展示了一个基于检索的图像描述生成实例，这种方法在图像描述的候选中选择一个描述输出。但是，弊端是所选择的句子可能会和图像很大程度上不相符。而\ref{fig:17-15}(b)展示的是一种基于模版的方法，这种方法需要在图像上提取视觉特征，然后把内容填在实现设计好的模板当中，这种方法的缺点是生成的图像描述过于呆板，“像是在一个模子中刻出来的”说的就是这个意思。近几年来 ，受到机器翻译领域等任务的启发，图像描述生成也开始大量使用编码器-解码器框架。这里会从基础的图像描述范式编码器-解码器框架展开\upcite{DBLP:conf/cvpr/VinyalsTBE15,DBLP:conf/icml/XuBKCCSZB15}，并从编码器的改进和解码器的改进两个方面进行介绍。
\parinterval 传统图像描述生成有两种范式：基于检索的方法和基于模板的方法。其中图\ref{fig:17-15}(a)展示了一个基于检索的图像描述生成实例，这种方法在图像描述的候选中选择一个描述输出。但是，弊端是所选择的句子可能会和图像很大程度上不相符。而\ref{fig:17-15}(b)展示的是一种基于模版的方法，这种方法需要在图像上提取视觉特征，然后把内容填在实现设计好的模板当中，这种方法的缺点是生成的图像描述过于呆板，“像是在一个模子中刻出来的”说的就是这个意思。近几年来 ，受到机器翻译领域等任务的启发，图像描述生成任务也开始大量使用编码器-解码器框架。这里会从基础的图像描述范式编码器-解码器框架展开\upcite{DBLP:conf/cvpr/VinyalsTBE15,DBLP:conf/icml/XuBKCCSZB15}，并从编码器的改进和解码器的改进两个方面进行介绍。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -402,7 +375,7 @@
\subsubsection{1. 基础框架}
\parinterval 在编码器-解码器框架中，编码器将输入的图像转换为一种新的“表示”形式，这种“表示”包含了输入图像的所有信息。之后解码器把这种“表示”转换为自然语言描述。比如，可以通过卷积神经网络提取图像特征为一个向量表示。然后，利用长短时记忆网络（LSTM）解码生成文字描述，这个过程中与机器翻译的解码过程类似。这种建模方式存在与\ref{sec:image-augmented-translation}描述一样的问题：生成的描述单词不一定需要所有的图像信息，将全局的图像信息送入模型中，可能会引入噪音。这时可以使用注意力机制来缓解该问题\upcite{DBLP:conf/icml/XuBKCCSZB15}。
\parinterval 在编码器-解码器框架中，编码器将输入的图像转换为一种新的“表示”形式，这种“表示”包含了输入图像的所有信息。之后解码器把这种“表示”转换为自然语言描述。比如，可以通过卷积神经网络提取图像特征为一个向量表示。然后，利用长短时记忆网络（LSTMs）解码生成文字描述，这个过程中与机器翻译的解码过程类似。这种建模方式存在与\ref{sec:image-augmented-translation}描述一样的问题：生成的描述单词不一定需要所有的图像信息，将全局的图像信息送入模型中，可能会引入噪音。这时可以使用注意力机制来缓解该问题\upcite{DBLP:conf/icml/XuBKCCSZB15}。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -412,7 +385,7 @@
\parinterval 要想使编码器-解码器框架在图像描述生成中充分发挥作用，编码器也要更好的表示图像信息。对于编码器的改进，通常体现在向编码器中添加图像的语义信息\upcite{DBLP:conf/cvpr/YouJWFL16,DBLP:conf/cvpr/ChenZXNSLC17,DBLP:journals/pami/FuJCSZ17}和位置信息\upcite{DBLP:conf/cvpr/ChenZXNSLC17,DBLP:conf/ijcai/LiuSWWY17}。
\parinterval 图像的语义信息一般是指图像中存在的实体、属性、场景等等。如图\ref{fig:17-17}所示，从图像中利用属性或实体检测器提取出“girl”、“river”、“bank”等属性词和实体词，将他们作为图像的语义信息编码的一部分，再利用注意力机制计算目标语言单词与这些属性词或实体词之间的注意力权重\upcite{DBLP:conf/cvpr/YouJWFL16}。当然，除了图像中的实体和属性作为语义信息外，也可以将图片的场景信息加入到编码器当中\upcite{DBLP:journals/pami/FuJCSZ17}。有关如何做属性、实体和场景的检测，涉及到目标检测任务的工作，例如Faster-RCNN\upcite{DBLP:journals/pami/RenHG017}、YOLO\upcite{DBLP:journals/corr/abs-1804-02767,DBLP:journals/corr/abs-2004-10934}等等,这里不再赘述。
\parinterval 图像的语义信息一般是指图像中存在的实体、属性、场景等等。如图\ref{fig:17-17}所示，从图像中利用属性或实体检测器提取出“jump”、“girl”、“river”、“bank”等属性词和实体词，将他们作为图像的语义信息编码的一部分，再利用注意力机制计算目标语言单词与这些属性词或实体词之间的注意力权重\upcite{DBLP:conf/cvpr/YouJWFL16}。当然，除了图像中的实体和属性作为语义信息外，也可以将图片的场景信息加入到编码器当中\upcite{DBLP:journals/pami/FuJCSZ17}。有关如何做属性、实体和场景的检测，涉及到目标检测任务的工作，例如Faster-RCNN\upcite{DBLP:journals/pami/RenHG017}、YOLO\upcite{DBLP:journals/corr/abs-1804-02767,DBLP:journals/corr/abs-2004-10934}等等,这里不再赘述。
%----------------------------------------------------------------------------------------------------
\begin{figure}[htp]
......@@ -423,7 +396,7 @@
\end{figure}
%----------------------------------------------------------------------------------------------------
\parinterval 以上的方法大都是将图像中的实体、属性、场景等映射到文字上，并把这些信息显式地添加到编码器中。另一种方式，把图像中的语义特征隐式地引入编码中\upcite{DBLP:conf/cvpr/ChenZXNSLC17}。例如，图像数据可以分解为三个通道（红、绿、蓝），简单来说，就是将图像的每一个像素点按照红色、绿色、蓝色分成三个部分，这样就将图像分成了三个通道。在很多图像中，不同通道伴随的特征是不一样的，可以将其作用于编码器。另一种方法是基于位置信息的编码增强。位置信息指的是图像中对象（物体）的位置。利用目标检测技术检测系统获得图中的对象和对应的特征，这样就确定了图中的对象位置。显然，这些信息可以加强编码器的表示能力\upcite{DBLP:conf/eccv/YaoPLM18}。
\parinterval 以上的方法大都是将图像中的实体、属性、场景等映射到文字上，并把这些信息显式地输入到编码器中。另一种方式，把图像中的语义特征隐式地引入编码中\upcite{DBLP:conf/cvpr/ChenZXNSLC17}。例如，图像数据可以分解为三个通道（红、绿、蓝），简单来说，就是将图像的每一个像素点按照红色、绿色、蓝色分成三个部分，这样就将图像分成了三个通道。在很多图像中，不同通道伴随的特征是不一样的，可以将其作用于编码器。另一种方法是基于位置信息的编码增强。位置信息指的是图像中对象（物体）的位置。利用目标检测技术检测系统获得图中的对象和对应的特征，这样就确定了图中的对象位置。显然，这些信息可以加强编码器的表示能力\upcite{DBLP:conf/eccv/YaoPLM18}。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -433,7 +406,7 @@
\parinterval 由于解码器输出的是语言文字序列，因此需要考虑语言的特点对其进行改进。 例如，解码过程中， “the”,“on”，“at”这种介词或者冠词与图像的相关性较低\upcite{DBLP:conf/cvpr/LuXPS17}。因此，可以通过门控单元，控制视觉信号作用于文字生成的程度。另外,在解码过程中，生成的每个单词对应着图像的区域可能是不同的。因此也可以设计更为有效的注意力机制来捕捉解码器端对不同图像局部信息的关注程度\upcite{DBLP:conf/cvpr/00010BT0GZ18}。
\parinterval 除了更好地使生成文本与图像特征进行相互作用以外，还有一些改进方法。例如，用卷积神经网络或者Transformer代替解码器所使用的循环神经网络\upcite{DBLP:conf/cvpr/AnejaDS18}。或者使用更深层的神经网络学习动词或者名词等视觉中不易表现出来的单词\upcite{DBLP:journals/mta/FangWCT18}，其思想与深层神经机器翻译模型有相通之处（见{\chapterfifteen}）。
\parinterval 除了更好地使生成文本与图像特征进行相互作用以外，还有一些改进方法。例如，用卷积神经网络或者Transformer代替解码器所使用的循环神经网络\upcite{DBLP:conf/cvpr/AnejaDS18}。或者使用更深层的神经网络学习动词或者形容词等视觉中不易表现出来的单词\upcite{DBLP:journals/mta/FangWCT18}，其思想与深层神经机器翻译模型有相通之处（见{\chapterfifteen}）。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -445,7 +418,7 @@
\parinterval 在计算机视觉中，图像风格变换、图像超分辨率重建等任务，都可以被视为{\small\bfnew{图像到图像的翻译}}\index{图像到图像的翻译}（Image-to-Image Translation）\index{Image-to-Image Translation}问题。与机器翻译类似，这些问题的共同目标是学习从一个对象到另一个对象的映射，只不过这里的对象是指图像，而非机器翻译中的文字。例如，给定物体的轮廓生成真实物体图片，或者给定白天照片生成夜晚的照片等。图像到图像的翻译有广阔的应用场景，如图片补全、风格迁移等。{\small\bfnew{文本到图像的翻译}}\index{文本到图像的翻译}（Text-to-Image Translation）\index{Text-to-Image Translation}是指给定描述物体颜色和形状等细节的自然语言文字，生成对应的图像。该任务也可以看作是图像描述生成的逆任务。
\parinterval 无论是图像到图像的生成，还是文本到图像的生成，也可直接使用编码器-解码器框架进行实现。比如，在文本到图像生成中，可以使用机器翻译中的编码器对输入文本进行编码，之后用反卷积神经网络将编码结果转化为图像。近些年，图像生成类任务也取得了很大的进展，这主要得益于生成对抗网络的使用\upcite{DBLP:conf/nips/GoodfellowPMXWOCB14,DBLP:journals/corr/abs-1908-06616,DBLP:conf/icml/ReedAYLSL16,DBLP:journals/corr/DashGALA17}。在{\chapterthirteen}已经介绍了生成对抗网络，而且图像生成也不是本书的重点，感兴趣的读者可以参考{\chapterthirteen}的内容或者自行查阅相关文献进行了解。
\parinterval 无论是图像到图像的生成，还是文本到图像的生成，均可直接使用编码器-解码器框架进行实现。比如，在文本到图像生成中，可以使用机器翻译中的编码器对输入文本进行编码，之后用对抗生成网络将编码结果转化为图像\upcite{DBLP:conf/icml/ReedAYLSL16}。近些年，图像生成类任务也取得了很大的进展，这主要得益于生成对抗网络的使用\upcite{DBLP:conf/nips/GoodfellowPMXWOCB14,DBLP:journals/corr/abs-1908-06616,DBLP:journals/corr/DashGALA17}。在{\chapterthirteen}已经介绍了生成对抗网络，而且图像生成也不是本书的重点，感兴趣的读者可以参考{\chapterthirteen}的内容或者自行查阅相关文献进行了解。
%----------------------------------------------------------------------------------------
% NEW SECTION
......@@ -461,7 +434,7 @@
\subsection{篇章级翻译的挑战}
\parinterval “篇章”在这里是指一系列连续的段落或句子所构成的整体，其中各个句子间从形式和内容上都具有一定的连贯性和一致性\upcite{jurafsky2000speech}。这些联系主要体现在{\small\sffamily\bfseries{衔接}}\index{衔接}（Cohesion \index{Cohesion}）以及连贯两个方面。其中衔接体现在显性的语言成分和结构上，包括篇章中句子间的语法和词汇的联系，而连贯体现在各个句子之间的逻辑和语义的联系上。因此，篇章级翻译就是要将这些上下文之间的联系考虑在内，从而生成比句子级翻译更连贯和准确的翻译结果。实例\ref{eg:17-1}就展示了一个使用篇章信息进行机器翻译的实例。
\parinterval “篇章”在这里是指一系列连续的段落或句子所构成的整体，其中各个句子间从形式和内容上都具有一定的连贯性和一致性\upcite{jurafsky2000speech}。这些联系主要体现在衔接以及连贯两个方面。其中衔接体现在显性的语言成分和结构上，包括篇章中句子间的语法和词汇的联系，而连贯体现在各个句子之间的逻辑和语义的联系上。因此，篇章级翻译就是要将这些上下文之间的联系考虑在内，从而生成比句子级翻译更连贯和准确的翻译结果。实例\ref{eg:17-1}就展示了一个使用篇章信息进行机器翻译的实例。
\begin{example}
上下文句子：我/上周/针对/这个/问题/做出/解释/并/咨询/了/他的/意见/。
......@@ -477,7 +450,7 @@
\parinterval 不过由于不同语言的特性多种多样，上下文信息在篇章级翻译中的作用也不尽相同。比如，在德语中名词是分词性的，因此在代词翻译的过程中需要根据其先行词的词性进行区分，而这种现象在其它不区分名词词性的语言中是不存在的。这意味着篇章级翻译在不同的语种中可能对应不同的上下文现象。
\parinterval 正是由于这种上下文现象的多样性，使评价篇章级翻译模型的性能变得相对困难。目前篇章级机器翻译主要针对一些常见的上下文现象进行优化，比如代词翻译、省略、连接和词汇衔接等，而{\chapterfour}介绍的BLEU等通用自动评价指标通常对这些上下文依赖现象不敏感，因此篇章级翻译需要采用一些专用方法来对这些具体现象进行评价。
\parinterval 正是这种上下文现象的多样性，使评价篇章级翻译模型的性能变得相对困难。目前篇章级机器翻译主要针对一些常见的上下文现象进行优化，比如代词翻译、省略、连接和词汇衔接等，而{\chapterfour}介绍的BLEU等通用自动评价指标通常对这些上下文依赖现象不敏感，因此篇章级翻译需要采用一些专用方法来对这些具体现象进行评价。
\parinterval 在统计机器翻译时代就已经有大量的研究工作专注于篇章信息的建模，这些工作大多针对某一具体的上下文现象，比如，篇章结构\upcite{DBLP:conf/anlp/MarcuCW00,foster2010translating,DBLP:conf/eacl/LouisW14}、代词回指\upcite{DBLP:conf/iwslt/HardmeierF10,DBLP:conf/wmt/NagardK10,DBLP:conf/eamt/LuongP16,}、词汇衔接\upcite{tiedemann2010context,DBLP:conf/emnlp/GongZZ11,DBLP:conf/ijcai/XiongBZLL13,xiao2011document}和篇章连接词\upcite{DBLP:conf/sigdial/MeyerPZC11,DBLP:conf/hytra/MeyerP12,}等。区别于篇章级统计机器翻译，篇章级神经机器翻译不需要针对某一具体的上下文现象构造相应的特征，而是通过翻译模型本身从上下文句子中抽取和融合的上下文信息。通常情况下，篇章级机器翻译可以采用局部建模的手段将前一句或者周围几句作为上下文送入模型。针对需要长距离上下文的情况，也可以使用全局建模的手段直接从篇章的所有句子中提取上下文信息。近几年多数研究工作都在探索更有效的局部建模或全局建模方法，主要包括改进输入\upcite{DBLP:conf/discomt/TiedemannS17,DBLP:conf/naacl/BawdenSBH18,DBLP:conf/wmt/GonzalesMS17,DBLP:journals/corr/abs-1910-07481}、多编码器结构\upcite{DBLP:journals/corr/JeanLFC17,DBLP:journals/corr/abs-1805-10163,DBLP:conf/emnlp/ZhangLSZXZL18}、层次结构\upcite{DBLP:conf/naacl/MarufMH19,DBLP:conf/acl/HaffariM18,DBLP:conf/emnlp/YangZMGFZ19,DBLP:conf/ijcai/ZhengYHCB20}以及基于缓存的方法\upcite{DBLP:conf/coling/KuangXLZ18,DBLP:journals/tacl/TuLSZ18}等。
......@@ -501,7 +474,7 @@
\subsection{篇章级翻译的建模}
\parinterval 在理想情况下，篇章级翻译应该以整个篇章为单位作为模型的输入和输出。然而由于现实中篇章对应的序列过长，因此直接建模整个篇章的词序列难度很大，这使得主流的序列到序列模型很难直接使用。一种思路是采用能够处理超长序列的模型对篇章序列建模，比如，使用{\chapterfifteen}中提到的处理长序列的Transformer模型就是一种的解决方法\upcite{Kitaev2020ReformerTE}。不过，这类模型并不针对篇章级翻译的具体问题，因此并不是篇章级翻译中的主流方法。
\parinterval 在理想情况下，篇章级翻译应该以整个篇章为单位作为模型的输入和输出。然而由于现实中篇章对应的序列过长，因此直接建模整个篇章序列难度很大，这使得主流的序列到序列模型很难直接使用。一种思路是采用能够处理超长序列的模型对篇章序列建模，比如，使用{\chapterfifteen}中提到的处理长序列的Transformer模型就是一种的解决方法\upcite{Kitaev2020ReformerTE}。不过，这类模型并不针对篇章级翻译的具体问题，因此并不是篇章级翻译中的主流方法。
\parinterval 现在常见的端到端做法还是从句子级翻译出发，通过额外的模块来对篇章中的上下文句子进行表示，然后提取相应的上下文信息并融入到当前句子的翻译过程中。形式上，篇章级翻译的建模方式如下：
\begin{eqnarray}
......@@ -546,17 +519,17 @@
\subsubsection{2. 多编码器结构}
\parinterval 另一种思路是对传统的编码器-解码器框架进行更改，引入额外的编码器来对上下文句子进行编码，该结构被称为多编码器结构\upcite{DBLP:conf/acl/LiLWJXZLL20,DBLP:conf/discomt/SugiyamaY19}。这种结构最早被应用在基于循环神经网络的篇章级翻译模型中\upcite{DBLP:journals/corr/JeanLFC17,DBLP:conf/coling/KuangX18,DBLP:conf/naacl/BawdenSBH18,DBLP:conf/pacling/YamagishiK19}，后期证明在Transformer模型上同样适用\upcite{DBLP:journals/corr/abs-1805-10163,DBLP:conf/emnlp/ZhangLSZXZL18}。图\ref{fig:17-18}展示了一个基于Transformer模型的多编码器结构，基于源语言当前待翻译句子的编码表示$\mathbi{h}$和上下文句子的编码表示$\mathbi{h}^{\textrm pre}$，模型首先通过注意力机制提取上下文信息$\mathbi{d}$：
\parinterval 另一种思路是对传统的编码器-解码器框架进行更改，引入额外的编码器来对上下文句子进行编码，该结构被称为多编码器结构\upcite{DBLP:conf/acl/LiLWJXZLL20,DBLP:conf/discomt/SugiyamaY19}。这种结构最早被应用在基于循环神经网络的篇章级翻译模型中\upcite{DBLP:journals/corr/JeanLFC17,DBLP:conf/coling/KuangX18,DBLP:conf/naacl/BawdenSBH18,DBLP:conf/pacling/YamagishiK19}，后期证明在Transformer模型上同样适用\upcite{DBLP:journals/corr/abs-1805-10163,DBLP:conf/emnlp/ZhangLSZXZL18}。图\ref{fig:17-18}展示了一个基于Transformer模型的多编码器结构，基于源语言当前待翻译句子的编码表示$\mathbi{h}$和上下文句子的编码表示$\mathbi{h}^{\textrm {pre}}$，模型首先通过注意力机制提取句子间上下文信息$\mathbi{d}$：
\begin{eqnarray}
\mathbi{d}&=&\textrm{Attention}(\mathbi{h},\mathbi{h}^{\textrm pre},\mathbi{h}^{\textrm pre})
\mathbi{d}&=&\textrm{Attention}(\mathbi{h},\mathbi{h}^{\textrm {pre}},\mathbi{h}^{\textrm {pre}})
\label{eq:17-3-3}
\end{eqnarray}
其中，$\mathbi{h}$作为Query（查询），$\mathbi{h}^{\textrm pre}$作为Key（键）和Value（值）。然后通过门控机制将待翻译句子中每个位置的编码表示和该位置对应的上下文信息进行融合，具体方式如下：
\begin{eqnarray}
\widetilde{\mathbi{h}_{t}}&=&\lambda_{t}\mathbi{h}_{t}+(1-\lambda_{t})\mathbi{d}_{t}
\label{eq:17-3-4}\\
\lambda_{t}&=&\sigma(\mathbi{W}_{\lambda}[\mathbi{h}_{t};\mathbi{d}_{t}]+\mathbi{b}_{\lambda})
\label{eq:17-3-5}
\label{eq:17-3-5}\\
\widetilde{\mathbi{h}_{t}}&=&\lambda_{t}\mathbi{h}_{t}+(1-\lambda_{t})\mathbi{d}_{t}
\label{eq:17-3-4}
\end{eqnarray}
其中，$\widetilde{\mathbi{h}}$为融合了上下文信息的最终序列表示结果，$\widetilde{\mathbi{h}_{t}}$为其第$t$个位置的表示。$\mathbi{W}_{\lambda}$和$\mathbi{b}_{\lambda}$为模型可学习的参数，$\sigma$为Sigmoid函数，用来获取门控权值$\lambda$。除了在编码端融合源语言上下文信息，也可以直接用类似机制在解码器内完成源语言上下文信息的融合\upcite{DBLP:conf/emnlp/ZhangLSZXZL18}。
......@@ -580,7 +553,7 @@
\parinterval 多编码器结构通过额外的编码器对前一句进行编码，但是当处理更多上下文句子的时候仍然面临效率低下的问题。为了捕捉更大范围的上下文，可以采用层次结构来对更多的上下文句子进行建模。层次结构是一种有效的序列表示方法，而且人类语言中天然就具有层次性，比如，句法树、篇章结构树等。类似的思想也成功的应用在基于树的句子级翻译模型中（见{\chaptereight}和{\chapterfifteen}）。
\parinterval 图\ref{fig:17-19}描述了一个基于层次注意力的模型结构\upcite{Werlen2018DocumentLevelNM}。首先通过翻译模型的编码器获取前$K$个句子的词序列编码表示$(\mathbi{h}^{\textrm{pre}1},\dots,\mathbi{h}^{\textrm{pre}K})$，然后针对前文每个句子的词序列编码表示$\mathbi{h}^{\textrm{pre}k}$，使用词级注意力提取句子级的上下文信息$\mathbi{s}^{k}$，然后在这$K$个句子级上下文信息$\mathbi{s}=(\mathbi{s}^1,\dots,\mathbi{s}^K)$的基础上，使用句子级注意力提取篇章上下文信息$\mathbi{d}$。由于上下文信息$\mathbi{d}$的获取涉及到词级和句子级两个不同层次的注意力操作，因此将该过程称为层次注意力。实际上，这种方法并没有使用语言学的篇章层次结构。但是，句子级注意力在归纳统计意义上的篇章结构，因此这种方法也可以捕捉不同句子之间的关系。
\parinterval 图\ref{fig:17-19}描述了一个基于层次注意力的模型结构\upcite{Werlen2018DocumentLevelNM}。首先通过翻译模型的编码器获取前$K$个句子的词序列编码表示$(\mathbi{h}^{\textrm{pre}1},\dots,\mathbi{h}^{\textrm{pre}K})$，然后针对前文每个句子的词序列编码表示$\mathbi{h}^{\textrm{pre}k}$，使用词级注意力提取当前句子内部的注意力信息$\mathbi{s}^{k}$，然后在这$K$个句子级上下文信息$\mathbi{s}=(\mathbi{s}^1,\dots,\mathbi{s}^K)$的基础上，使用句子级注意力提取篇章上下文信息$\mathbi{d}$。由于上下文信息$\mathbi{d}$的获取涉及到词级和句子级两个不同层次的注意力操作，因此将该过程称为层次注意力。实际上，这种方法并没有使用语言学的篇章层次结构。但是，句子级注意力在归纳统计意义上的篇章结构，因此这种方法也可以捕捉不同句子之间的关系。
%----------------------------------------------
\begin{figure}[htp]
......@@ -591,12 +564,12 @@
\end{figure}
%----------------------------------------------
\parinterval 为了增强模型的表示能力，层次注意力中并未直接使用当前句子第$t$个位置的编码表示$\mathbi{h}_{t}$作为查询，而是通过$f_w$和$f_s$两个线性变换分别获取词级注意力和句子级注意力的查询$\mathbi{q}_{w}$ 和$\mathbi{q}_{s}$，定义如下：
\parinterval 为了增强模型的表示能力，层次注意力中并未直接使用当前句子第$t$个位置的编码表示$\mathbi{h}_{t}$作为注意力操作的Query（查询），而是通过两个线性变换分别获取词级注意力和句子级注意力的查询$\mathbi{q}_{w}$ 和$\mathbi{q}_{s}$，定义如公式\eqref{eq:17-3-6}\eqref{eq:17-3-8}，其中${\mathbi W}_w$、${\mathbi W}_s$、${\mathbi b}_w$、${\mathbi b}_s$分别是两个线性变换的权重和偏置。
\begin{eqnarray}
\mathbi{q}_{w}&=&f_w(\mathbi{h}_t)
\mathbi{q}_{w}&=&{\mathbi W}_w \mathbi{h}_t+{\mathbi b}_w
\label{eq:17-3-6}\\
\mathbi{q}_{s}&=&f_s(\mathbi{h}_t)
\mathbi{q}_{s}&=&{\mathbi W}_s \mathbi{h}_t+{\mathbi b}_s
\label{eq:17-3-8}
\end{eqnarray}
......@@ -604,7 +577,7 @@
\noindent 之后，分别计算词级和句子级注意力模型。需要注意的是句子级注意力添加了一个前馈全连接网络子层FFN。其具体计算方式如下：
\begin{eqnarray}
\mathbi{s}^k&=&\textrm{WordAttention}(\mathbi{q}_{w},\mathbi{h}^{k},\mathbi{h}^{k})
\mathbi{s}^k&=&\textrm{WordAttention}(\mathbi{q}_{w},\mathbi{h}^{\textrm {pre}k},\mathbi{h}^{\textrm{pre}k})
\label{eq:17-3-7}\\
\mathbi{d}_t&=&\textrm{FFN}(\textrm{SentAttention}(\mathbi{q}_{s},\mathbi{s},\mathbi{s}))
\label{eq:17-3-9}
......@@ -622,7 +595,7 @@
\parinterval 除了以上提到的建模方法，还有一类基于缓存的方法\upcite{DBLP:journals/tacl/TuLSZ18,DBLP:conf/coling/KuangXLZ18}。这类方法最大的特点在于将篇章翻译看作一个连续的过程，即依次翻译篇章中的每一个句子，该过程中通过一个额外的缓存来记录一些相关信息，且在每个句子的推断过程中都使用这个缓存来提供上下文信息。图\ref{fig:17-20}描述了一种基于缓存的篇章级翻译模型结构\upcite{DBLP:journals/tacl/TuLSZ18}。 在这里，翻译模型基于循环神经网络（见{\chapterten}），但是这种方法同样适用于包括Transformer在内的其他神经机器翻译模型。
\parinterval 模型中篇章上下文的建模依赖于缓存的读和写操作。缓存的写操作指的是：按照一定规则，将翻译历史中一些译文单词对应的上下文向量作为键，将其解码器端的隐藏状态作为值，共同写入到缓存中。而缓存的读操作是指将待翻译句子中第$t$个单词的上下文向量$\mathbi{C}_t$作为查询，与缓存中的所有键分别进行匹配，并根据其匹配程度进行带权相加，最后得到当前待翻译句子的篇章上下文信息 $\mathbi{d}$。 该方法中，解码器端隐藏状态$\mathbi{s}_t$与对应位置的上下文信息$\mathbi{d}_t$的融合也是基于门控机制。事实上，由于该方法中缓存空间是有限的，其内容的更新也存在一定的规则：在当前句子的翻译结束后，如果单词$y_t$的对应信息未曾写入缓存，则写入其中的空槽或者替换最久未使用的键值对；如果$y_t$ 已作为翻译历史存在于缓存中，则将对应的键值对按照以下规则进行更新:
\parinterval 模型中篇章上下文的建模依赖于缓存的读和写操作。缓存的写操作指的是：按照一定规则，将翻译历史中一些译文单词对应的上下文向量作为键，将其解码器端的隐藏状态作为值，共同写入到缓存中。而缓存的读操作是指将待翻译句子中第$t$个单词的上下文向量$\mathbi{C}_t$作为Query（查询），与缓存中的所有键分别进行匹配，并根据其匹配程度进行带权相加，最后得到当前待翻译句子的篇章上下文信息 $\mathbi{d}$。 该方法中，解码器端隐藏状态$\mathbi{s}_t$与对应位置的上下文信息$\mathbi{d}_t$的融合也是基于门控机制。事实上，由于该方法中缓存空间是有限的，其内容的更新也存在一定的规则：在当前句子的翻译结束后，如果单词$y_t$的对应信息未曾写入缓存，则写入其中的空槽或者替换最久未使用的键值对；如果$y_t$ 已作为翻译历史存在于缓存中，则将对应的键值对按照以下规则进行更新:
\begin{eqnarray}
\mathbi{k}_{i}&=&\frac{\mathbi{k}_{i}+\mathbi{c}_{t}}{2}
\label{eq:17-3-10}\\
......@@ -648,9 +621,6 @@
\parinterval 前面介绍的方法主要是对篇章中待翻译句子的上下文句子进行建模，通过端到端的方式对上下文信息进行提取和融合。由于篇章级双语数据相对稀缺，这种复杂的篇章级翻译模型很难得到充分训练，通常可以采用两阶段训练或参数共享的方式来缓解这个问题。此外，由于句子级双语数据更为丰富，一个自然的想法是以高质量的句子级翻译模型为基础，通过在推断过程中结合上下文信息来构造篇章级翻译模型。
\parinterval 在句子级翻译模型中引入目标语言端的篇章级语言模型是一种结合上下文信息的常用手段\upcite{DBLP:conf/discomt/GarciaCE19,DBLP:journals/tacl/YuSSLKBD20,DBLP:journals/corr/abs-2010-12827}。 相比于篇章级双语数据，篇章级单语数据更容易获取。在双语数据稀缺的情况下，通过引入目标语言端的篇章级语言模型可以更充分的利用这些单语数据，比如，可以把这个语言模型与翻译模型做插值，也可以将其作为重排序阶段的一种特征。
\parinterval 另一种方法是两阶段翻译。这种方法不影响句子级翻译模型的推断过程，而是在完成翻译后使用额外的模块进行第二阶段的翻译\upcite{DBLP:conf/aaai/XiongH0W19,DBLP:conf/acl/VoitaST19}。如图\ref{fig:17-21}所示，这种两阶段翻译的做法相当于将篇章级翻译的问题进行了分离和简化，适用于篇章级双语数据稀缺的场景两阶段翻译。基于类似的思想，也可以使用后编辑的做法对翻译结果进行修正。区别于两阶段翻译的方法，后编辑的方法无需参考源语言信息，只是对译文结果进行修正\upcite{DBLP:conf/emnlp/VoitaST19}。
%----------------------------------------------
\begin{figure}[htp]
\centering
......@@ -659,6 +629,9 @@
\label{fig:17-21}
\end{figure}
%----------------------------------------------
\parinterval 另一种方法是两阶段翻译。这种方法不影响句子级翻译模型的推断过程，而是在完成翻译后使用额外的模块进行第二阶段的翻译\upcite{DBLP:conf/aaai/XiongH0W19,DBLP:conf/acl/VoitaST19}。如图\ref{fig:17-21}所示，这种两阶段翻译的做法相当于将篇章级翻译的问题进行了分离和简化：在第一阶段翻译中使用句子级翻译模型完成对篇章中某个句子的翻译，为了进一步地引入篇章上下文信息，第二阶段的翻译过程在第一阶段翻译结果的基础上，利用两次注意力操作，融合并引入源语言和目标语言的篇章上下文信息和当前句子信息。该方法适用于篇章级双语数据稀缺的场景。基于类似的思想，也可以使用后编辑的做法对翻译结果进行修正。区别于两阶段翻译的方法，后编辑的方法无需参考源语言信息，只利用目标语言端的上下文信息对译文结果进行修正\upcite{DBLP:conf/emnlp/VoitaST19}。
%----------------------------------------------------------------------------------------
% NEW SECTION
%----------------------------------------------------------------------------------------
......@@ -668,19 +641,13 @@
\parinterval 使用更大上下文进行机器翻译建模是极具潜力的研究方向，包括多模态翻译在内的多个领域也非常活跃。有许多问题值得进一步思考与讨论：
\begin{itemize}
\vspace{0.5em}
\item 本章仅对音频处理和语音识别进行了简单的介绍，具体内容可以参考一些经典书籍，比如关于信号处理的基础知识\upcite{Oppenheim2001DiscretetimeSP,Quatieri2001DiscreteTimeSS}，以及语音识别的传统方法\upcite{DBLP:books/daglib/0071550,Huang2001SpokenLP}和基于深度学习的最新方法\upcite{benesty2008automatic}。
\vspace{0.5em}
\item 此外，语音翻译的一个重要应用是机器同声传译。机器同声传译的一个难点在于不同语言的文字顺序不同。目前，同声传译的一种思路是基于目前已经说出的语音进行翻译\upcite{DBLP:conf/acl/MaHXZLZZHLLWW19}，比如，等待源语$k$个词语，然后再进行翻译，同时改进束搜索方式来预测未来的词序列，从而提升准确度\upcite{DBLP:conf/emnlp/ZhengMZH19}。或者，对当前语音进行翻译，但需要判断翻译的词是否能够作为最终结果，已决定是否根据之后的语音重新进行翻译\upcite{DBLP:conf/naacl/DalviDSV18,DBLP:journals/corr/ChoE16}。第二种思路是动态预测当前时刻是应该继续等待还是开始翻译，这种方式更符合人类进行同传的行为。但是这种策略的难点在于标注每一时刻的决策状态十分耗时且标准难以统一，目前主流的方式是利用强化学习方法\upcite{DBLP:conf/eacl/NeubigCGL17,DBLP:conf/emnlp/GrissomHBMD14}，对句子进行不同决策方案采样，最终学到最优的决策方案。此外，还有一些工作设计不同的学习策略\upcite{DBLP:conf/acl/ZhengLZMLH20,DBLP:conf/emnlp/ZhengZMH19,DBLP:conf/acl/ZhengZMH19}或改进注意力机制\upcite{DBLP:conf/acl/ArivazhaganCMCY19}以提升机器同声传译的性能。
\vspace{0.5em}
\item 在篇章级翻译方面，一些研究工作对这类模型的上下文建模能力进行了探索\upcite{DBLP:conf/discomt/KimTN19,DBLP:conf/acl/LiLWJXZLL20}，发现模型性能在小数据集上的BLEU提升并不完全来自于上下文信息的利用。同时，受限于数据规模，篇章级翻译模型相对难以训练。一些研究人员通过调整训练策略使得模型更容易捕获上下文信息\upcite{DBLP:journals/corr/abs-1903-04715,DBLP:conf/acl/SaundersSB20,DBLP:conf/mtsummit/StojanovskiF19}。除了训练策略的调整，也可以使用数据增强和预训练的手段来缓解数据稀缺的问题\upcite{DBLP:conf/discomt/SugiyamaY19,DBLP:journals/corr/abs-1911-03110,DBLP:journals/corr/abs-2001-08210}。此外，区别于传统的篇章级翻译，一些对话翻译也需要使用长距离上下文信息\upcite{DBLP:conf/wmt/MarufMH18}。
\vspace{0.5em}
\item 此外，多模态机器翻译、图像描述生成、视觉问答等多模态任务受到广泛关注。如何将多个模态的信息充分融合，是研究多模态任务的重要问题。另外，数据稀缺是大多数多模态任务的瓶颈之一，可以采取数据增强的方式缓解\upcite{DBLP:conf/emnlp/GokhaleBBY20,DBLP:conf/eccv/Tang0ZWY20}。但是，这时仍需要回答在：模型没有充分训练时，图像等模态信息究竟在翻译里发挥了多少作用？类似的问题在篇章级机器翻译中也存在，上下文模型在训练数据量很小的时候对翻译的作用十分微弱\upcite{DBLP:conf/acl/LiLWJXZLL20}。此外，受到预训练模型的启发，在多模态信息处理中，图像和文本联合预训练的工作也相继开展\upcite{DBLP:conf/eccv/Li0LZHZWH0WCG20,DBLP:conf/aaai/ZhouPZHCG20,DBLP:conf/iclr/SuZCLLWD20}。
\item 在多模态机器翻译任务和篇章级机器翻译任务中，数据规模往往受限，导致模型训练困难，很难取得较好的性能。比如在篇章级机器翻译中，一些研究工作对这类模型的上下文建模能力进行了探索\upcite{DBLP:conf/discomt/KimTN19,DBLP:conf/acl/LiLWJXZLL20}，发现模型在小数据集上对上下文信息的利用并不能带来明显的性能提升。针对数据稀缺导致的训练问题，一些研究人员通过调整训练策略使得模型更容易捕获上下文信息\upcite{DBLP:journals/corr/abs-1903-04715,DBLP:conf/acl/SaundersSB20,DBLP:conf/mtsummit/StojanovskiF19}。除了训练策略的调整，也可以使用数据增强的方式（例如，构造伪数据）来提升整体数据量\upcite{DBLP:conf/emnlp/GokhaleBBY20,DBLP:conf/eccv/Tang0ZWY20,DBLP:conf/discomt/SugiyamaY19}，或者使用预训练的手段来利用额外地单语或图像数据\upcite{DBLP:conf/aaai/ZhouPZHCG20,DBLP:conf/iclr/SuZCLLWD20,DBLP:journals/corr/abs-1911-03110}。
\vspace{0.5em}
\end{itemize}
......
Chapter2/Figures/figure-word-frequency-distribution.tex
\definecolor{ublue}{rgb}{0.152,0.250,0.545}
\begin{tikzpicture}
\begin{axis}[
width=11cm,
width=13cm,
height=5.5cm,
xlabel={WikiText-103上的词表},
ylabel={词汇出现总次数},
......
Chapter2/chapter2.tex
......@@ -862,9 +862,6 @@ c(\cdot) & \textrm{当计算最高阶模型时} \\
\parinterval 当任务对单词序列长度没有限制时，上述两种方法枚举出的单词序列也是无穷无尽的。因此这两种枚举策略并不具备完备性而且会导致枚举过程无法停止。由于日常生活中通常不会见到特别长的句子，因此可以通过限制单词序列的最大长度来避免这个问题。一旦单词序列的最大长度被确定，以上两种枚举策略就可以在一定时间内枚举出所有可能的单词序列，因而一定可以找到最优的单词序列，即具备最优性。
\parinterval 此时上述生成策略虽然可以满足完备性和最优性，但其仍然算不上是优秀的生成策略，因为这两种算法在时间复杂度和空间复杂度上的表现很差，如表\ref{tab:2-4}所示。其中$|V|$为词表大小，$m$ 为序列长度。值得注意的是，在之前的遍历过程中，除了在序列开头一定会挑选<sos>之外，其他位置每次可挑选的单词并不只有词表中的单词，还有结束符号<eos>，因此实际上生成过程中每个位置的单词候选数量为$|V|+1$。
\vspace{0.5em}
%------------------------------------------------------
\begin{table}[htp]{
\begin{center}
......@@ -881,6 +878,8 @@ c(\cdot) & \textrm{当计算最高阶模型时} \\
}\end{table}
%------------------------------------------------------
\parinterval 此时上述生成策略虽然可以满足完备性和最优性，但其仍然算不上是优秀的生成策略，因为这两种算法在时间复杂度和空间复杂度上的表现很差，如表\ref{tab:2-4}所示。其中$|V|$为词表大小，$m$ 为序列长度。值得注意的是，在之前的遍历过程中，除了在序列开头一定会挑选<sos>之外，其他位置每次可挑选的单词并不只有词表中的单词，还有结束符号<eos>，因此实际上生成过程中每个位置的单词候选数量为$|V|+1$。
\parinterval 那么是否有比枚举策略更高效的方法呢？答案是肯定的。一种直观的方法是将搜索的过程表示成树型结构，称为解空间树。它包含了搜索过程中可生成的全部序列。该树的根节点恒为<sos>，代表序列均从<sos> 开始。该树结构中非叶子节点的兄弟节点有$|V|+1$个，由词表和结束符号<eos>构成。从图\ref{fig:2-13}可以看到，对于一个最大长度为4的序列的搜索过程，生成某个单词序列的过程实际上就是访问解空间树中从根节点<sos> 开始一直到叶子节点<eos>结束的某条路径，而这条的路径上节点按顺序组成了一段独特的单词序列。此时对所有可能单词序列的枚举就变成了对解空间树的遍历。并且枚举的过程与语言模型打分的过程也是一致的，每枚举一个词$i$也就是在图\ref{fig:2-13}选择$w_i$一列的一个节点，语言模型就可以为当前的树节点$w_i$给出一个分值，即$\funp{P}(w_i | w_1 w_2 \ldots w_{i-1})$。对于$n$-gram语言模型，这个分值可以表示为$\funp{P}(w_i | w_1 w_2 \ldots w_{i-1})=\funp{P}(w_i | w_{i-n+1} \ldots w_{i-1})$
%----------------------------------------------
......
Chapter3/chapter3.tex
......@@ -211,7 +211,6 @@ $计算这种切分的概率值。
%-------------------------------------------
\parinterval 以“确实现在数据很多”这个实例来说，如果把这句话按照“确实/现在/数据/很/多”这样的方式进行切分，这个句子切分的概率$\funp{P}$(确实/现在/数据/很/多) 可以通过每个词出现概率相乘的方式进行计算。
\begin{eqnarray}
&\funp&{P}\textrm{(确实/现在/数据/很/多)} \nonumber \\
& = &\funp{P}\textrm{(确实)} \cdot \funp{P}\textrm{(现在)} \cdot \funp{P}\textrm{(数据)} \cdot \funp{P}\textrm{(很)} \cdot \funp{P}\textrm{(多)}
......@@ -250,6 +249,8 @@ $计算这种切分的概率值。
\vspace{0.5em}
\end{itemize}
\parinterval 图\ref{fig:3.3-1}给出了不同标注格式所对应的标注结果。可以看出文本序列中的非命名实体直接被标注为“O”，而命名实体的标注则被分为了两部分：位置和命名实体类别，图中的“B”、“I”、“E”等标注出了位置信息，而“CIT”和“CNT”则标注出了命名实体类别（“CIT”表示城市，“CNT”表示国家）。可以看到，命名实体的识别结果可以通过BIO、BIOES这类序列标注结果归纳出来：例如在BIOES格式中，标签“B-CNT”后面的标签只会是“I-CNT”或“E-CNT”，而不会是其他的标签。同时，在命名实体识别任务中涉及到实体边界的确定，而“BIO”或“BIOES”的标注格式本身就暗含着边界问题：在“BIO”格式下，实体左边界只能在“B”的左侧，右边界只能在“B”或“I”的右侧；在“BIOES”格式下，实体左边界只能在“B”或“S”的左侧，右边界只能在“E”和“S”的右侧。
%----------------------------------------------
\begin{figure}[htp]
\centering
......@@ -259,8 +260,6 @@ $计算这种切分的概率值。
\label{fig:3.3-1}
\end{figure}
%-------------------------------------------
%
\parinterval 图\ref{fig:3.3-1}给出了不同标注格式所对应的标注结果。可以看出文本序列中的非命名实体直接被标注为“O”，而命名实体的标注则被分为了两部分：位置和命名实体类别，图中的“B”、“I”、“E”等标注出了位置信息，而“CIT”和“CNT”则标注出了命名实体类别（“CIT”表示城市，“CNT”表示国家）。可以看到，命名实体的识别结果可以通过BIO、BIOES这类序列标注结果归纳出来：例如在BIOES格式中，标签“B-CNT”后面的标签只会是“I-CNT”或“E-CNT”，而不会是其他的标签。同时，在命名实体识别任务中涉及到实体边界的确定，而“BIO”或“BIOES”的标注格式本身就暗含着边界问题：在“BIO”格式下，实体左边界只能在“B”的左侧，右边界只能在“B”或“I”的右侧；在“BIOES”格式下，实体左边界只能在“B”或“S”的左侧，右边界只能在“E”和“S”的右侧。
\parinterval 需要注意的是，虽然图\ref{fig:3.3-1}中的命名实体识别以单词为基本单位进行标注，但真实系统中也可以在字序列上进行命名实体识别，其方法与基于词序列的命名实体识别是一样的。因此，这里仍然以基于词序列的方法为例进行介绍。
......@@ -345,6 +344,15 @@ $计算这种切分的概率值。
\parinterval 由于隐含状态序列之间存在转移概率，并且隐马尔可夫模型中隐含状态和可见状态之间存在着发射概率，因此根据可见状态的转移猜测隐含状态序列并非无迹可循。图\ref{fig:3.3-3}描述了如何使用隐马尔可夫模型来根据“抛硬币”结果推测挑选的硬币序列。可见，通过隐含状态之间的联系（绿色方框及它们之间的连线）可以对有序的状态进行描述，进而得到隐含状态序列所对应的可见状态序列（红色圆圈）。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter3/Figures/figure-example-of-hmm-in-coin-toss}
\caption{抛硬币的隐马尔可夫模型实例}
\label{fig:3.3-3}
\end{figure}
%-------------------------------------------
\parinterval 从统计建模的角度看，上述过程本质上是在描述隐含状态和可见状态出现的联合概率。这里，用$\seq{x}=(x_1,...,x_m)$表示可见状态序列，用$\seq{y}=(y_1,...,y_m)$表示隐含状态序列。（一阶）隐马尔可夫模型假设：
\begin{itemize}
......@@ -366,14 +374,6 @@ $计算这种切分的概率值。
\noindent 这里，$y_{0}$表示一个虚拟的隐含状态。这样，可以定义$\funp{P}(y_1|y_{0}) \equiv \funp{P}(y_1)$，它表示起始隐含状态出现的概率。隐马尔可夫模型的假设也大大化简了问题，因此可以通过式\eqref{eq:joint-prob-xy}很容易地计算隐含状态序列和可见状态序列出现的概率。值得注意的是，发射概率和转移概率都可以被看作是描述序列生成过程的“特征”。但是，这些“特征”并不是随意定义的，而是符合问题的概率解释。而这种基于事件发生的逻辑所定义的概率生成模型，通常可以被看作是一种{\small\sffamily\bfseries{生成式模型}}\index{生成式模型}（Generative Model）\index{Generative Model}。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter3/Figures/figure-example-of-hmm-in-coin-toss}
\caption{抛硬币的隐马尔可夫模型实例}
\label{fig:3.3-3}
\end{figure}
%-------------------------------------------
\parinterval 一般来说，隐马尔可夫模型中包含下面三个问题：
\begin{itemize}
......@@ -399,10 +399,7 @@ $计算这种切分的概率值。
\parinterval 一种简单的办法是使用相对频次估计得到转移概率和发射概率估计值。令$x_i$表示第$i$个位置的可见状态，$y_i$表示第$i$个位置的隐含状态，$\funp{P}(y_i|y_{i-1})$表示第$i-1$个位置到第$i$个位置的状态转移概率，$\funp{P}(x_i|y_{i}) $表示第$i$个位置的发射概率，于是有：
\begin{eqnarray}
\funp{P}(y_i|y_{i-1}) &=& \frac{{c}(y_{i-1},y_i)}{{c}(y_{i-1})}
\label{eq:3.3-1}
\end{eqnarray}
\begin{eqnarray}
\label{eq:3.3-1}\\
\funp{P}(x_i|y_{i}) &=& \frac{{c}(x_i,y_i)}{{c}(y_i)}
\label{eq:3.3-2}
\end{eqnarray}
......@@ -422,7 +419,6 @@ $计算这种切分的概率值。
\end{eqnarray}
\parinterval 将式\eqref{eq:joint-prob-xy}带入式\eqref{eq:markov-sequence-argmax}可以得到最终计算公式，如下：
\begin{eqnarray}
\hat{\seq{y}} &=& \arg\max_{\seq{y}}\prod_{i=1}^{m}\funp{P}(x_i|y_i)\funp{P}(y_i|y_{i-1})
\label{eq:3.3-5}
......@@ -446,7 +442,6 @@ $计算这种切分的概率值。
\subsubsection{2. 条件随机场}
\parinterval 隐马尔可夫模型有一个很强的假设：一个隐含状态出现的概率仅由上一个隐含状态决定。这个假设也会带来一些问题，举个例子：在某个隐马尔可夫模型中，隐含状态集合为\{$A, B, C, D$\}，可见状态集合为\{$T, F$\}，其中隐含状态$A$可能的后继隐含状态集合为\{$A, B$\}，隐含状态$B$可能的后继隐含状态集合为\{$A, B, C, D$\}，于是有：
\begin{eqnarray}
\funp{P}(A|A)+\funp{P}(A|B) & = & 1 \label{eq:3.3-6} \\
\funp{P}(A|B)+\funp{P}(B|B)+\funp{P}(C|B)+\funp{P}(D|B) & = & 1 \label{eq:3.3-7}
......@@ -474,14 +469,12 @@ F(y_{i-1},y_i,\seq{x},i) & = & t(y_{i-1},y_i,\seq{x},i)+s(y_i,\seq{x},i)
\end{eqnarray}
\parinterval 实际上，基于特征函数的方法更像是对隐含状态序列的一种打分：根据人为设计的模板（特征函数），测试隐含状态之间的转换以及隐含状态与可见状态之间的对应关系是否符合这种模板。在处理序列问题时，假设可见状态序列$\seq{x}$的长度和待预测隐含状态序列$\seq{y}$的长度均为$m$，且共设计了$k$个特征函数，则有：
\begin{eqnarray}
\funp{P}(\seq{y}|\seq{x}) & = & \frac{1}{Z(\seq{x})}\exp(\sum_{i=1}^m\sum_{j=1}^{k}\lambda_{j}F_{j}(y_{i-1},y_i,\seq{x},i))
\label{eq:3.3-9}
\end{eqnarray}
\parinterval 公式\eqref{eq:3.3-9}中的$Z(x)$即为上面提到的实现全局统计归一化的归一化因子，其计算方式为：
\begin{eqnarray}
Z(\seq{x})&=&\sum_{\seq{y}}\exp(\sum_{i=1}^m\sum_{j=1}^k\lambda_{j}F_{j}(y_{i-1},y_i,\seq{x},i))
\label{eq:3.3-10}
......@@ -510,6 +503,8 @@ Z(\seq{x})&=&\sum_{\seq{y}}\exp(\sum_{i=1}^m\sum_{j=1}^k\lambda_{j}F_{j}(y_{i-1}
\parinterval 基于概率图的模型将序列表示为有向图或无向图，如图\ref{fig:3.3-7}(a)、(b)所示。这种方法增加了建模的复杂度。既然要得到每个位置的类别输出，另一种更加直接的方法是使用分类器对每个位置进行独立预测。分类器是机器学习中广泛使用的方法，它可以根据输入自动地对类别进行预测。如图\ref{fig:3.3-7}(c)所示，对于序列标注任务，分类器把每一个位置所对应的所有特征看作是输入，而把这个位置对应的标签看作输出。从这个角度说，隐马尔可夫模型等方法实际上也是在进行一种“分类”操作，只不过这些方法考虑了不同位置输出（或隐含状态）之间的依赖。
\parinterval 值得注意的是分类模型可以被应用于序列标注之外的很多任务，在后面的章节中还会看到，机器翻译中的很多模块也借鉴了统计分类的思想。其中使用到的基础数学模型和特征定义形式，与这里提到的分类器本质上是一样的。
%----------------------------------------------
\begin{figure}[htp]
\centering
......@@ -521,8 +516,6 @@ Z(\seq{x})&=&\sum_{\seq{y}}\exp(\sum_{i=1}^m\sum_{j=1}^k\lambda_{j}F_{j}(y_{i-1}
\end{figure}
%-------------------------------------------
\parinterval 值得注意的是分类模型可以被应用于序列标注之外的很多任务，在后面的章节中还会看到，机器翻译中的很多模块也借鉴了统计分类的思想。其中使用到的基础数学模型和特征定义形式，与这里提到的分类器本质上是一样的。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
......@@ -575,6 +568,8 @@ Z(\seq{x})&=&\sum_{\seq{y}}\exp(\sum_{i=1}^m\sum_{j=1}^k\lambda_{j}F_{j}(y_{i-1}
\parinterval {\small\sffamily\bfseries{句法}}\index{句法}（Syntax）\index{Syntax}是研究句子的每个组成部分和它们之间的组合方式。一般来说，句法和语言是相关的，比如，英文是主谓宾结构，而日语是主宾谓结构，因此不同的语言也会有不同的句法描述方式。自然语言处理领域最常用的两种句法分析形式是{\small\sffamily\bfseries{短语结构分析}}\index{短语结构分析}（Phrase Structure Parsing）\index{Phrase Structure Parsing}和{\small\sffamily\bfseries{依存分析}}\index{依存分析}（Dependency Parsing）\index{Dependency Parsing}。图\ref{fig:3.4-1}展示了这两种的句法表示形式的实例。其中，左侧是短语结构树，它描述的是短语的结构功能，比如“吃”是动词（记为VV），“鱼”是名词（记为NN），“吃/鱼”组成动词短语，这个短语再与“喜欢”这一动词组成新的动词短语。短语结构树的每个子树都是一个句法功能单元，比如，子树VP(VV(吃) NN(鱼))就表示了“吃/鱼”这个动词短语的结构，其中子树根节点VP是句法功能标记。短语结构树利用嵌套的方式描述了语言学的功能，短语结构树中，每个词都有词性(或词类)，不同的词或者短语可以组成名动结构、动宾结构等语言学短语结构，短语结构分析一般也被称为{\small\sffamily\bfseries{成分分析}}\index{成分分析}（Constituency Parsing）或{\small\sffamily\bfseries{完全分析}}\index{完全分析}（Full Parsing）\index{Full Parsing}。
\parinterval 图\ref{fig:3.4-1}右侧展示的是另一种句法结构，被称作依存句法树。依存句法树表示了句子中单词和单词之间的依存关系。比如，从这个例子可以了解，“猫”依赖“喜欢”，“吃”依赖“喜欢”，“鱼”依赖“吃”。
%----------------------------------------------
\begin{figure}[htp]
\centering
......@@ -584,8 +579,6 @@ Z(\seq{x})&=&\sum_{\seq{y}}\exp(\sum_{i=1}^m\sum_{j=1}^k\lambda_{j}F_{j}(y_{i-1}
\end{figure}
%---------------------------
\parinterval 图\ref{fig:3.4-1}右侧展示的是另一种句法结构，被称作依存句法树。依存句法树表示了句子中单词和单词之间的依存关系。比如，从这个例子可以了解，“猫”依赖“喜欢”，“吃”依赖“喜欢”，“鱼”依赖“吃”。
\parinterval 短语结构树和依存句法树的结构和功能有很大不同。短语结构树的叶子节点是单词，中间节点是词性或者短语句法标记。在短语结构分析中，通常把单词称作{\small\sffamily\bfseries{终结符}}\index{终结符}（Terminal）\index{Terminal}，把词性称为{\small\sffamily\bfseries{预终结符}}\index{预终结符}（Pre-terminal）\index{Pre-terminal}，而把其他句法标记称为{\small\sffamily\bfseries{非终结符}}\index{非终结符}（Non-terminal）\index{Non-terminal}。依存句法树没有预终结符和非终结符，所有的节点都是句子里的单词，通过不同节点间的连线表示句子中各个单词之间的依存关系。每个依存关系实际上都是有方向的，头和尾分别指向“接受”和“发出”依存关系的词。依存关系也可以进行分类，例如，图\ref{fig:3.4-1}中的对每个依存关系的类型都有一个标记，这也被称作是有标记的依存分析。如果不生成这些标记，这样的句法分析被称作无标记的依存分析。
\parinterval 虽然短语结构树和依存树的句法表现形式有很大不同，但是它们在某些条件下能相互转化。比如，可以使用启发性规则将短语结构树自动转化为依存树。从应用的角度，依存分析由于形式更加简单，而且直接建模词语之间的依赖，因此在自然语言处理领域中受到很多关注。在机器翻译中，无论是哪种句法树结构，都已经被证明会对机器翻译系统产生帮助。特别是短语结构树，在机器翻译中的应用历史更长，研究更为深入，因此本节将会以短语结构分析为例介绍句法分析的相关概念。
......@@ -722,6 +715,8 @@ s_0 \overset{r_1}{\Rightarrow} s_1 \overset{r_2}{\Rightarrow} s_2 \overset{r_3}{
\parinterval 比如，使用前面的示例文法，可以对“猫/喜欢/吃/鱼”进行分析，并形成句法分析树（图\ref{fig:3.4-3}）。从起始非终结符IP开始，使用唯一拥有IP作为左部的规则$r_8$推导出NP和VP，之后依次使用规则$r_5$、$r_1$、$r_7$、$r_2$、$r_6$、$r_3$、$r_4$，得到了完整的句法树。
\parinterval 通常，可以把推导简记为$d=r_1 \circ r_2 \circ ... \circ r_n$，其中$ \circ $表示规则的组合。显然，$d$也对应了树形结构，也就是句法分析结果。从这个角度看，推导就是描述句法分析树的一种方式。此外，规则的推导也把规则的使用过程与生成的字符串对应起来。一个推导所生成的字符串，也被称作文法所产生的一个{\small\sffamily\bfseries{句子}}\index{句子}（Sentence）\index{Sentence}。而一个文法所能生成的所有句子的集合是这个文法所对应的{\small\sffamily\bfseries{语言}}\index{语言}（Language）\index{Language}。
%-------------------------------------------
\begin{figure}[htp]
\centering
......@@ -731,8 +726,6 @@ s_0 \overset{r_1}{\Rightarrow} s_1 \overset{r_2}{\Rightarrow} s_2 \overset{r_3}{
\end{figure}
%-------------------------------------------
\parinterval 通常，可以把推导简记为$d=r_1 \circ r_2 \circ ... \circ r_n$，其中$ \circ $表示规则的组合。显然，$d$也对应了树形结构，也就是句法分析结果。从这个角度看，推导就是描述句法分析树的一种方式。此外，规则的推导也把规则的使用过程与生成的字符串对应起来。一个推导所生成的字符串，也被称作文法所产生的一个{\small\sffamily\bfseries{句子}}\index{句子}（Sentence）\index{Sentence}。而一个文法所能生成的所有句子的集合是这个文法所对应的{\small\sffamily\bfseries{语言}}\index{语言}（Language）\index{Language}。
\parinterval 但是，句子和规则的推导并不是一一对应的。同一个句子，往往有很多推导的方式，这种现象被称为{\small\sffamily\bfseries{歧义}}\index{歧义}（Ambiguity）\index{Ambiguity}。甚至同一棵句法树，也可以对应不同的推导，图\ref{fig:3.4-4} 给出同一棵句法树所对应的两种不同的规则推导。
%-------------------------------------------
......@@ -747,6 +740,10 @@ s_0 \overset{r_1}{\Rightarrow} s_1 \overset{r_2}{\Rightarrow} s_2 \overset{r_3}{
\parinterval 显然，规则顺序的不同会导致句法树的推导这一确定的过程变得不确定，因此，需要进行{\small\sffamily\bfseries{消歧}}\index{消歧}（Disambiguation）\index{Disambiguation}。这里，可以使用启发式方法：要求规则使用都服从最左优先原则，这样得到的推导被称为{\small\sffamily\bfseries{最左优先推导}}\index{最左优先推导}（Left-most Derivation）\index{Left-most Derivation}。图\ref{fig:3.4-4}中的推导1 就是符合最左优先原则的推导。
\parinterval 这样，对于一个上下文无关文法，每一棵句法树都有唯一的最左推导与之对应。于是，句法分析可以被描述为：对于一个句子找到能够生成它的最佳推导，这个推导所对应的句法树就是这个句子的句法分析结果。
\parinterval 不过问题又回来了，怎样才能知道什么样的推导或者句法树是“最佳”的呢？如图\ref{fig:3.4-5}所示，对于语言学专家，他们可以很确定地分辨出哪些句法树是正确的，哪些句法树是错误。甚至普通人也可以通过一些课本中学到的知识产生一些模糊的判断。而计算机如何进行判别呢？沿着前面介绍的统计建模的思想，计算机可以得出不同句法树出现的概率，进而选择概率最高的句法树作为输出，而这正是统计句法分析所做的事情。
%-------------------------------------------
\begin{figure}[htp]
\centering
......@@ -756,10 +753,6 @@ s_0 \overset{r_1}{\Rightarrow} s_1 \overset{r_2}{\Rightarrow} s_2 \overset{r_3}{
\end{figure}
%-------------------------------------------
\parinterval 这样，对于一个上下文无关文法，每一棵句法树都有唯一的最左推导与之对应。于是，句法分析可以被描述为：对于一个句子找到能够生成它的最佳推导，这个推导所对应的句法树就是这个句子的句法分析结果。
\parinterval 不过问题又回来了，怎样才能知道什么样的推导或者句法树是“最佳”的呢？如图\ref{fig:3.4-5}所示，对于语言学专家，他们可以很确定地分辨出哪些句法树是正确的，哪些句法树是错误。甚至普通人也可以通过一些课本中学到的知识产生一些模糊的判断。而计算机如何进行判别呢？沿着前面介绍的统计建模的思想，计算机可以得出不同句法树出现的概率，进而选择概率最高的句法树作为输出，而这正是统计句法分析所做的事情。
\parinterval 在统计句法分析中，需要对每个推导进行统计建模，于是定义一个模型$\funp{P}( \cdot )$，对于任意的推导$d$，都可以用$\funp{P}(d)$计算出推导$d$的概率。这样，给定一个输入句子，我们可以对所有可能的推导用$\funp{P}(d)$计算其概率值，并选择概率最大的结果作为句法分析的结果输出（图\ref{fig:3.4-6}）。
%-------------------------------------------
......@@ -829,7 +822,6 @@ r_6: & & \textrm{VP} \to \textrm{VV}\ \textrm{NN} \nonumber
\parinterval 这也对应了词串“吃/鱼”的生成过程。首先，从起始非终结符VP开始，使用规则$r_6$生成两个非终结符VV和NN；进一步，分别使用规则$r_3$和$r_4$从VV和NN进一步生成单词“吃”和“鱼”。整个过程的概率等于三条规则概率的乘积。
\parinterval 新的问题又来了，如何得到规则的概率呢？这里仍然可以从数据中学习文法规则的概率。假设有人工标注的数据，它包括很多人工标注句法树的句法，称之为{\small\sffamily\bfseries{树库}}\index{树库}（Treebank）\index{Treebank}。然后，对于规则$\textrm{r}:\alpha \to \beta$可以使用基于频次的方法：
\begin{eqnarray}
\funp{P}(r) &=& \frac{\text{规则$r$在树库中出现的次数}}{\alpha \text{在树库中出现的次数}}
\label{eq:3.4-8}
......
Chapter4/Figures/figure-schematic-diagram-of-phrase-level-quality-assessment-task.tex
......@@ -50,10 +50,10 @@
\node[bad_tag,anchor=north] at ([yshift=-2pt]box2_3.south){BAD};
\node[ok_tag,anchor=north] (tag_1) at ([yshift=-2pt]box2_4.south){OK};
\node[ok_tag,anchor=north] (gap_1) at ([xshift=-5.8em,yshift=-3em]box2_1.south){OK};
\node[bad_tag,anchor=north] (gap_2) at ([xshift=5.6em,yshift=-3em]box2_1.south){BAD\_omission};
\node[ok_tag,anchor=north] (gap_3) at ([xshift=5.6em,yshift=-3em]box2_2.south){OK};
\node[ok_tag,anchor=north] (gap_4) at ([xshift=6.4em,yshift=-3em]box2_3.south){OK};
\node[ok_tag,anchor=north] (gap_1) at ([xshift=-7em,yshift=-3em]box2_1.south){OK};
\node[bad_tag,anchor=north] (gap_2) at ([xshift=7em,yshift=-3em]box2_1.south){BAD\_omission};
\node[ok_tag,anchor=north] (gap_3) at ([xshift=6.8em,yshift=-3em]box2_2.south){OK};
\node[ok_tag,anchor=north] (gap_4) at ([xshift=7.5em,yshift=-3em]box2_3.south){OK};
\node[ok_tag,anchor=north] (tag_2) at ([xshift=2.5em,yshift=-3em]box2_4.south){OK};
......
Chapter4/Figures/figure-schematic-diagram-of-word-level-quality-assessment-task.tex
......@@ -56,14 +56,14 @@
\node[ok_tag,anchor=north] at ([yshift=-3pt]n3_8.south){OK};
\node[ok_tag,anchor=north] (tag2) at ([yshift=-3pt]n3_9.south){OK};
\node[ok_tag,anchor=north] (gap_1)at ([xshift=-2.6em,yshift=-2em]n3_2.south){OK};
\node[bad_tag,anchor=north] (gap_2)at ([xshift=2.55em,yshift=-2em]n3_2.south){BAD};
\node[ok_tag,anchor=north] (gap_3)at ([xshift=1.85em,yshift=-2em]n3_3.south){OK};
\node[ok_tag,anchor=north] (gap_4)at ([xshift=2.3em,yshift=-2em]n3_4.south){OK};
\node[ok_tag,anchor=north] (gap_5)at ([xshift=1.5em,yshift=-2em]n3_5.south){OK};
\node[ok_tag,anchor=north] (gap_6)at ([xshift=1.8em,yshift=-2em]n3_6.south){OK};
\node[ok_tag,anchor=north] (gap_7)at ([xshift=2.0em,yshift=-2em]n3_7.south){OK};
\node[ok_tag,anchor=north] (gap_8)at ([xshift=1.60em,yshift=-2em]n3_8.south){OK};
\node[ok_tag,anchor=north] (gap_1)at ([xshift=-3.2em,yshift=-2em]n3_2.south){OK};
\node[bad_tag,anchor=north] (gap_2)at ([xshift=3.5em,yshift=-2em]n3_2.south){BAD};
\node[ok_tag,anchor=north] (gap_3)at ([xshift=2.1em,yshift=-2em]n3_3.south){OK};
\node[ok_tag,anchor=north] (gap_4)at ([xshift=3em,yshift=-2em]n3_4.south){OK};
\node[ok_tag,anchor=north] (gap_5)at ([xshift=1.85em,yshift=-2em]n3_5.south){OK};
\node[ok_tag,anchor=north] (gap_6)at ([xshift=2em,yshift=-2em]n3_6.south){OK};
\node[ok_tag,anchor=north] (gap_7)at ([xshift=2.25em,yshift=-2em]n3_7.south){OK};
\node[ok_tag,anchor=north] (gap_8)at ([xshift=1.75em,yshift=-2em]n3_8.south){OK};
\node[ok_tag,anchor=north] (tag3) at ([xshift=1.7em,yshift=-2em]n3_9.south){OK};
\draw[dash pattern=on 2pt off 1pt,gray,line width=1pt](gap_1.north) -- ([yshift=2em]gap_1.north);
......
Chapter4/chapter4.tex
......@@ -147,7 +147,6 @@
\begin{itemize}
\item {\small\sffamily\bfseries{根据系统胜出的次数进行排序}}\upcite{DBLP:conf/wmt/Callison-BurchK12}。以系统${S}_j$和系统${S}_k$为例，两个系统都被比较了$\textrm{C}_n^5 \times 4 \times 3$ 次，其中系统${S}_j$获胜20次，系统${S}_k$获胜30次，总体排名中系统${S}_k$优于系统${S}_j$。
\item {\small\sffamily\bfseries{根据冲突次数进行排序}}\upcite{DBLP:conf/wmt/Lopez12}。第一种排序策略中存在冲突现象：例如在每次两两比较中，系统${S}_j$胜过系统${S}_k$ 的次数比系统${S}_j$不敌系统${S}_k$的次数多，若待评价系统仅有系统${S}_j$、${S}_k$，显然系统${S}_j$的排名高于系统${S}_k$。但当待评价系统很多时，可能系统${S}_j$在所有比较中获胜的次数低于系统${S}_k$，此时就出现了总体排序与局部排序不一致的冲突。因此，有研究者提出，能够与局部排序冲突最少的总体排序才是最合理的。令$O$表示一个对若干个系统的排序，该排序所对应的冲突定义为：
\begin{eqnarray}
\textrm{conflict}(O) =\sum\limits_{{{S}_j},{{S}_k} \in O,j \ne k} {{\textrm{max}}(0,\textrm{count}_{\textrm{win}}({{S}_j},{{S}_k}) - \textrm{count}_{\textrm{loss}}({{S}_j},{{S}_k}))}
\label{eq:4-1}
......@@ -155,7 +154,6 @@
其中，${S}_j$和${S}_k$是成对比较的两个系统，$\textrm{count}_{\textrm{win}}({S}_j,{S}_k)$和$\textrm{count}_{\textrm{loss}}({S}_j,{S}_k)$分别是${S}_j$、${S}_k$进行成对比较时系统${S}_j$ 胜利和失败的次数。而使得$\textrm{conflict}(O)$最低的$O$就是最终的系统排序结果。
\item {\small\sffamily\bfseries{根据某系统最终获胜的期望进行排序}}\upcite{DBLP:conf/iwslt/Koehn12}。以系统${S}_j$为例，若共有$n$个待评价的系统，则进行总体排序时系统 ${S}_j$ 的得分为其最终获胜的期望，即：
\begin{eqnarray}
\textrm{score}({{S}_j}) &=& \frac{1}{n}\sum\limits_{k,k \ne j} {\frac{\textrm{count}_{\textrm{win}}({{S}_j},{{S}_k})}{{\textrm{count}_{\textrm{win}}({{S}_j},{{S}_k}) + \textrm{count}_{\textrm{loss}}({{S}_j},{{S}_k})}}}
\label{eq:4-2}
......@@ -213,7 +211,7 @@
\parinterval 在这个实例中，将机器译文序列转换为参考答案序列，需要进行两次替换操作，将“A” 替换为“The”，将“in” 替换为“on”。所以$\textrm{edit}(c,r)$ = 2，归一化因子$l$为参考答案的长度8（包括标点符号），所以该机器译文的TER 结果为2/8。
\parinterval PER与TER的基本思想与WER相同，这三种方法的主要区别在于对“错误” 的定义和考虑的操作类型略有不同。WER使用的编辑操作包括：增加、删除、替换，由于没有移位操作，当机器译文出现词序问题时，会发生多次替代，因而一般会低估译文质量；而PER只考虑增加和删除两个动作，在不考虑词序的情况下，PER计算两个句子中出现相同单词的次数，根据机器译文与参考答案的长度差距，其余操作无非是插入词或删除词，这样往往会高估译文质量。
\parinterval PER与WER的基本思想与TER相同，这三种方法的主要区别在于对“错误” 的定义和考虑的操作类型略有不同。WER使用的编辑操作包括：增加、删除、替换，由于没有移位操作，当机器译文出现词序问题时，会发生多次替代，因而一般会低估译文质量；而PER只考虑增加和删除两个动作，在不考虑词序的情况下，PER计算两个句子中出现相同单词的次数，根据机器译文与参考答案的长度差距，其余操作无非是插入词或删除词，这样往往会高估译文质量。
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -334,7 +332,6 @@
\label{fig:4-6}
\end{figure}
%----------------------------------------------
\vspace{0.5em}
\item 在得到机器译文与参考答案的对齐关系后，需要基于对齐关系计算准确率和召回率。
准确率：机器译文中命中单词数与机器译文单词总数的比值。即：
......@@ -358,7 +355,7 @@
\vspace{0.5em}
\end{itemize}
\parinterval 在上文提到的评价指标中，无论是准确率、召回率还是$\textrm F_{mean}$，都是基于单个词汇信息衡量译文质量，而忽略了语序问题。为了将语序问题考虑进来，Meteor会考虑更长的匹配：将机器译文按照最长匹配长度分块，并对“块数”较多的机器译文给予惩罚。例如图\ref{fig:4-6}显示的最终词对齐结果中，机器译文被分为了三个“块”——“Can I have it”、“like he”、“？”在这种情况下，看起来上例中的准确率、召回率都还不错，但最终会受到很严重的惩罚。这种罚分机制能够识别出机器译文中的词序问题，因为当待测译文词序与参考答案相差较大时，机器译文将会被分割得比较零散，这种惩罚机制的计算公式如式\eqref{eq:4-11}，其中$\textrm {count}_{\textrm{chunks}}$表示匹配的块数。
\parinterval 在上文提到的评价指标中，无论是准确率、召回率还是$\textrm F_{mean}$，都是基于单个词汇信息衡量译文质量，而忽略了语序问题。为了将语序问题考虑进来，Meteor会考虑更长的匹配：将机器译文按照最长匹配长度分块，由于“块数”较多的机器译文与参考答案的对齐更加散乱，意味着其语序问题更多，因此Meteor会对这样的译文给予惩罚。例如图\ref{fig:4-6}显示的最终词对齐结果中，机器译文被分为了三个“块”——“Can I have it”、“like he”、“？”在这种情况下，看起来上例中的准确率、召回率都还不错，但最终会受到很严重的惩罚。这种罚分机制能够识别出机器译文中的词序问题，因为当待测译文词序与参考答案相差较大时，机器译文将会被分割得比较零散，这种惩罚机制的计算公式如式\eqref{eq:4-11}，其中$\textrm {count}_{\textrm{chunks}}$表示匹配的块数。
\begin{eqnarray}
\textrm {Penalty} &=& 0.5 \cdot {\left({\frac{{\textrm {count}}_{\textrm {chunks}}}{\textrm {count}_{\textrm{hit}}}} \right)^3}
\label{eq:4-11}
......@@ -523,6 +520,11 @@ His house is on the south bank of the river .
\parinterval 在DREEM中，分布式表示的选取是一个十分关键的问题，理想的情况下，分布式表示应该涵盖句子在词汇、句法、语法、语义、依存关系等各个方面的信息。目前常见的分布式表示方式如表\ref{tab:4-2}所示。除此之外，还可以通过词袋模型、循环神经网络等将词向量表示转换为句子向量表示。
\parinterval DREEM方法中选取了能够反映句子中使用的特定词汇的One-hot向量、能够反映词汇信息的词嵌入向量\upcite{bengio2003a}、能够反映句子的合成语义信息的{\small\sffamily\bfseries{递归自动编码}}\index{递归自动编码}（Recursive Auto-encoder Embedding，RAE）\index{Recursive Auto-encoder Embedding}，这三种表示级联在一起，最终形成句子的向量表示。在得到机器译文和参考答案的上述分布式表示后，利用余弦相似度和长度惩罚对机器译文质量进行评价。机器译文$o$和参考答案$g$之间的相似度如公式\eqref{eq:4-16}所示，其中${v_i}(o)$和${v_i}(g)$分别是机器译文和参考答案的向量表示中的第$i$ 个元素，$N$是向量表示的维度大小。
\begin{eqnarray}
\textrm {cos}(t,r) &=& \frac{{\sum\limits_{i = 1}^N {{v_i}(o) \cdot {v_i}(g)} }}{{\sqrt {\sum\limits_{i = 1}^N {v_i^2(o)} } \sqrt {\sum\limits_{i = 1}^N {v_i^2(g)} } }}
\label{eq:4-16}
\end{eqnarray}
\begin{table}[htp]{
\begin{center}
\caption{常见的单词及句子分布表示}
......@@ -542,12 +544,6 @@ His house is on the south bank of the river .
\end{center}
}\end{table}
\parinterval DREEM方法中选取了能够反映句子中使用的特定词汇的One-hot向量、能够反映词汇信息的词嵌入向量\upcite{bengio2003a}、能够反映句子的合成语义信息的{\small\sffamily\bfseries{递归自动编码}}\index{递归自动编码}（Recursive Auto-encoder Embedding，RAE）\index{Recursive Auto-encoder Embedding}，这三种表示级联在一起，最终形成句子的向量表示。在得到机器译文和参考答案的上述分布式表示后，利用余弦相似度和长度惩罚对机器译文质量进行评价。机器译文$o$和参考答案$g$之间的相似度如公式\eqref{eq:4-16}所示，其中${v_i}(o)$和${v_i}(g)$分别是机器译文和参考答案的向量表示中的第$i$ 个元素，$N$是向量表示的维度大小。
\begin{eqnarray}
\textrm {cos}(t,r) &=& \frac{{\sum\limits_{i = 1}^N {{v_i}(o) \cdot {v_i}(g)} }}{{\sqrt {\sum\limits_{i = 1}^N {v_i^2(o)} } \sqrt {\sum\limits_{i = 1}^N {v_i^2(g)} } }}
\label{eq:4-16}
\end{eqnarray}
\parinterval 在此基础上，DREEM方法还引入了长度惩罚项，对与参考答案长度相差太多的机器译文进行惩罚，长度惩罚项如公式\eqref{eq:4-17}所示，其中${l_o}$和${l_g}$分别是机器译文和参考答案长度：
\begin{eqnarray}
\textrm{BP} &=& \left\{ \begin{array}{l}
......@@ -569,15 +565,12 @@ His house is on the south bank of the river .
\parinterval 本质上，分布式表示是一种对句子语义的一种统计表示。因此，它可以帮助评价系统捕捉一些从简单的词或者句子片段中不易发现的现象，进而进行更深层的句子匹配。
\parinterval 在DREEM方法取得成功后，基于词嵌入的词对齐自动评价方法被提出\upcite{DBLP:journals/corr/MatsuoKS17}，该方法中先得到机器译文与参考答案的词对齐关系后，通过对齐关系中两者的词嵌入相似度来计算机器译文与参考答案的相似度，公式如下：
\parinterval 在DREEM方法取得成功后，基于词嵌入的词对齐自动评价方法被提出\upcite{DBLP:journals/corr/MatsuoKS17}，该方法中先得到机器译文与参考答案的词对齐关系后，通过对齐关系中两者的词嵌入相似度来计算机器译文与参考答案的相似度，公式如\eqref{eq:4-19}。其中，$o$是机器译文，$g$是参考答案，$m$表示译文$o$的长度，$l$表示参考答案$g$的长度，函数$\varphi(o,g,i,j)$用来计算$o$中第$i$个词和$g$中第$j$个词之间对齐关系的相似度。：
\begin{eqnarray}
\textrm{ASS}(o,g) &=& \frac{1}{{m \cdot l}}\sum\limits_{i = 1}^{m} {\sum\limits_{j = 1}^{l} {\varphi (o,g,i,j)} }
\label{eq:4-19}
\end{eqnarray}
\noindent 其中，$o$是机器译文，$g$是参考答案，$m$表示译文$o$的长度，$l$表示参考答案$g$的长度，函数$\varphi(o,g,i,j)$用来计算$o$中第$i$个词和$g$中第$j$个词之间对齐关系的相似度。
\parinterval 此外，将分布式表示与相对排序融合也是一个很有趣的想法\upcite{DBLP:journals/csl/GuzmanJMN17}，在这个尝试中，研究人员利用分布式表示提取参考答案和多个机器译文中的句法信息和语义信息，利用神经网络模型对多个机器译文进行排序。
\parinterval 在基于分布式表示的这类译文质量评价方法中，译文和参考答案的所有词汇信息和句法语义信息都被包含在句子的分布式表示中，克服了单一参考答案的限制。但是同时也带来了新的问题，一方面将句子转化成分布式表示使评价过程变得不那么具有可解释性，另一方面分布式表示的质量也会对评价结果有较大的影响。
......@@ -647,7 +640,6 @@ His house is on the south bank of the river .
%----------------------------------------------
\parinterval 回到机器翻译的问题中来。一个更加基础的问题是：一个系统评价结果的变化在多大范围内是不显著的。利用假设检验的原理，这个问题可以被描述为：评价结果落在$[x-d,x+d]$区间的置信度是$1-\alpha$。换句话说，当系统性能落在$[x-d, x+d]$外，就可以说这个结果与原始的结果有显著性差异。这里$x$通常是系统译文的BLEU计算结果，$[x-d,x+d]$是其对应的置信区间。而$d$和$\alpha$有很多计算方法，比如，如果假设评价结果服从正态分布，可以简单的计算$d$。
\begin{eqnarray}
d&=&t \frac{s}{\sqrt{n}}
\label{eq:4-21}
......@@ -798,7 +790,7 @@ d&=&t \frac{s}{\sqrt{n}}
\label{eq:4-20}
\end{eqnarray}
\parinterval 这种质量评估方式往往以单词级质量评估为基础，在其结果的基础上进行计算。以实例\ref{eg:4-7}中词级质量评估结果为例，与编辑后结果相比较，机器翻译译文中有四处漏译（“Mit”、“können”、“Sie”、“einzelne”）、三处误译（“dem”、\\“Scharfzeichner”、“scharfzeichnen”分别被误译为“Der”、“Schärfen-Werkezug”、“Schärfer”）、一处多译（“erscheint”），因而需要进行4次插入操作、3次替换操作和1次删除操作，而最终译文长度为12，则有$\textrm HTER=(4+3+1)/12=0.667$。需要注意的是，即便这种评估方式以单词级质量评估为基础，也不意味这句子级质量评估只是在单词级质量评估的结果上通过简单的计算来获得其得分，在实际研究中，常将其视为一个回归问题，利用大量数据学习其评分规则。
\parinterval 这种质量评估方式往往以单词级质量评估为基础，在其结果的基础上进行计算。以实例\ref{eg:4-7}中词级质量评估结果为例，与编辑后结果相比较，机器翻译译文中有四处漏译（“Mit”、“können”、“Sie”、“einzelne”）、三处误译（“dem”、\\“Scharfzeichner”、“scharfzeichnen”分别被误译为“Der”、“Schärfen-Werkezug”、\\“Schärfer”）、一处多译（“erscheint”），因而需要进行4次插入操作、3次替换操作和1次删除操作，而最终译文长度为12，则有${\textrm {HTER}}=(4+3+1)/12=0.667$。需要注意的是，即便这种评估方式以单词级质量评估为基础，也不意味这句子级质量评估只是在单词级质量评估的结果上通过简单的计算来获得其得分，在实际研究中，常将其视为一个回归问题，利用大量数据学习其评分规则。
\vspace{0.5em}
\end{itemize}
......@@ -873,7 +865,6 @@ d&=&t \frac{s}{\sqrt{n}}
\item {\small\sffamily\bfseries{充分度特征}}：反映了源文和机器译文在不同语言层次上的密切程度或关联程度。
\vspace{0.5em}
\end{itemize}
\parinterval 随着深度学习技术的发展，另一种思路是使用表示学习技术生成句子的分布式表示，并在此基础上利用神经网络自动提取高度抽象的句子特征\upcite{DBLP:conf/wmt/KreutzerSR15,DBLP:conf/wmt/MartinsAHK16,DBLP:conf/wmt/ChenTZXZLW17}，这样就避免了人工设计特征所带来的时间以及人工代价，同时表示学习所得到的分布式表示可以涵盖更多人工设计难以捕获到的特征，更加全面地反映句子的特点，因此在质量评估任务上也取得了很好的效果\upcite{kreutzer2015quality,DBLP:conf/wmt/ShahLPBBBS15,DBLP:conf/wmt/ScartonBSSS16,DBLP:conf/wmt/AbdelsalamBE16,DBLP:conf/wmt/BasuPN18}。比如，最近的一些工作中大量使用了神经机器翻译模型来获得双语句子的表示结果，并用于质量评估\upcite{DBLP:conf/wmt/Qi19,DBLP:conf/wmt/ZhouZH19,DBLP:conf/wmt/Hokamp17,wang2019niutrans}。这样做的好处在于，质量评估可以直接复用机器翻译的模型，从某种意义上降低了质量评估系统开发的代价。此外，随着近几年各种预训练模型的出现，使用预训练模型来获取用于质量评估的句子表示也成为一大流行趋势，这种方法大大减少了质量评估模型自身的训练时间，在该领域内的表现也十分亮眼\upcite{kepler2019unbabel,DBLP:conf/wmt/YankovskayaTF19,DBLP:conf/wmt/KimLKN19}。关于表示学习、神经机器翻译、预训练模型的内容在第九章和第十章会有进一步介绍。
\parinterval 在得到句子表示之后，可以使用质量评估模块对译文质量进行预测。质量评估模型通常由回归算法或分类算法实现：
......
Chapter7/chapter7.tex
......@@ -124,14 +124,14 @@
\subsection{机器翻译中的短语}
\parinterval 基于短语的机器翻译的基本假设是：双语句子的生成可以用短语之间的对应关系进行表示。图\ref{fig:7-9}展示了一个基于短语的翻译实例。可以看到，这里的翻译单元是连续的词串。比如，“进口”的译文“The imports have”就包含了三个单词，而“下降/了”也是一个包含两个单词的源语言片段。
\parinterval 基于短语的机器翻译的基本假设是：双语句子的生成可以用短语之间的对应关系进行表示。图\ref{fig:7-6}展示了一个基于短语的翻译实例。可以看到，这里的翻译单元是连续的词串。比如，“进口”的译文“The imports have”就包含了三个单词，而“下降/了”也是一个包含两个单词的源语言片段。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-example-of-zh2en-translation-base-phrase}
\caption{基于短语的汉英翻译实例}
\label{fig:7-9}
\label{fig:7-6}
\end{figure}
%-------------------------------------------
......@@ -204,7 +204,7 @@ p_4 &=& \text{任务}\nonumber
\parinterval 基于短语的翻译推导定义了一种从源语言短语序列到目标语言短语序列的对应，其中源语言短语序列是源语言句子的一种切分，同样的，目标语言短语序列是目标语言句子的一种切分。翻译推导提供了一种描述翻译过程的手段：对于一个源语言句子，可以找到从它出发的翻译推导，推导中短语的目标语部分就构成了译文。也就是，每个源语言句子$\seq{s}$上的一个推导$d$都蕴含着一个目标语句子$\seq{t}$。
\parinterval 图\ref{fig:7-10}给出了一个由三个双语短语$\{(\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$。这里，可以把这三个短语对的组合看作是翻译推导，形式化表示为如下公式：
\parinterval 图\ref{fig:7-7}给出了一个由三个双语短语$\{(\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$。这里，可以把这三个短语对的组合看作是翻译推导，形式化表示为如下公式：
\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)}
......@@ -218,7 +218,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\centering
\input{./Chapter7/Figures/figure-derivation-consist-of-bilingual-phrase}
\caption{三个双语短语$\{(\bar{s}_{\bar{a}_1},\bar{t}_1),(\bar{s}_{\bar{a}_2},\bar{t}_2),(\bar{s}_{\bar{a}_3},\bar{t}_3)\}$构成的翻译推导}
\label{fig:7-10}
\label{fig:7-7}
\end{figure}
%-------------------------------------------
......@@ -366,14 +366,14 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
在基于短语的翻译模型中，通常包含三类特征：短语翻译特征、调序特征、语言模型相关的特征。这些特征都需要从训练数据中学习。
\parinterval 图\ref{fig:7-11}展示了一个基于短语的机器翻译模型的搭建流程。其中的训练数据包括双语平行语料和目标语言单语语料。首先，需要从双语平行数据中学习短语的翻译，并形成一个短语翻译表；然后，再从双语平行数据中学习调序模型；最后，从目标语单语数据中学习语言模型。短语翻译表、调序模型、语言模型都会作为特征被送入判别式模型，由解码器完成对新句子的翻译。而这些特征的权重可以在额外的开发集上进行调优。关于短语抽取、调序模型和翻译特征的学习，会在本章的\ref{section-7.3}-\ref{section-7.6}节进行介绍。
\parinterval 图\ref{fig:7-8}展示了一个基于短语的机器翻译模型的搭建流程。其中的训练数据包括双语平行语料和目标语言单语语料。首先，需要从双语平行数据中学习短语的翻译，并形成一个短语翻译表；然后，再从双语平行数据中学习调序模型；最后，从目标语单语数据中学习语言模型。短语翻译表、调序模型、语言模型都会作为特征被送入判别式模型，由解码器完成对新句子的翻译。而这些特征的权重可以在额外的开发集上进行调优。关于短语抽取、调序模型和翻译特征的学习，会在本章的\ref{section-7.3}-\ref{section-7.6}节进行介绍。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-process-of-machine-translation-base-phrase}
\caption{基于短语的机器翻译的系统流程}
\label{fig:7-11}
\label{fig:7-8}
\end{figure}
%-------------------------------------------
......@@ -384,14 +384,14 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\sectionnewpage
\section{短语抽取}\label{section-7.3}
\parinterval 在基于短语的模型中，学习短语翻译是重要的步骤之一。获得短语翻译的方法有很多种，最常用的方法是从双语平行语料中进行{\small\bfnew{短语抽取}}\index{短语抽取}（Phrase Extraction）\index{Phrase Extraction}。前面已经介绍过短语的概念，句子中任意的连续子串都被称为短语。例如在图\ref{fig:7-12}中，用点阵的形式来表示双语之间的对应关系，那么图中任意一个矩形框都可以构成一个双语短语（或短语对），例如“什么/都/没”对应“learned nothing ？”。
\parinterval 在基于短语的模型中，学习短语翻译是重要的步骤之一。获得短语翻译的方法有很多种，最常用的方法是从双语平行语料中进行{\small\bfnew{短语抽取}}\index{短语抽取}（Phrase Extraction）\index{Phrase Extraction}。前面已经介绍过短语的概念，句子中任意的连续子串都被称为短语。例如在图\ref{fig:7-9}中，用点阵的形式来表示双语之间的对应关系，那么图中任意一个矩形框都可以构成一个双语短语（或短语对），例如“什么/都/没”对应“learned nothing ？”。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-unlimited-phrase-extraction}
\caption{无限制的短语抽取}
\label{fig:7-12}
\label{fig:7-9}
\end{figure}
%-------------------------------------------
......@@ -403,7 +403,7 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\subsection{与词对齐一致的短语}
\parinterval 图\ref{fig:7-13}中大蓝色方块代表词对齐。通过词对齐信息，可以很容易地获得双语短语“天气 $\leftrightarrow$ The weather”。这里称其为与词对齐一致（兼容）的双语短语。具体定义如下：
\parinterval 图\ref{fig:7-10}中大蓝色方块代表词对齐。通过词对齐信息，可以很容易地获得双语短语“天气 $\leftrightarrow$ The weather”。这里称其为与词对齐一致（兼容）的双语短语。具体定义如下：
%-------------------------------------------
\vspace{0.5em}
......@@ -420,29 +420,29 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\centering
\input{./Chapter7/Figures/figure-phrase-extraction-consistent-with-word-alignment}
\caption{与词对齐一致的短语抽取}
\label{fig:7-13}
\label{fig:7-10}
\end{figure}
%-------------------------------------------
\parinterval 如图\ref{fig:7-14}所示，左边的例子中的$t_1$和$t_2$严格地对应到$s_1$、$s_2$、$s_3$，所以短语是与词对齐相一致的；中间例子中的$t_2$对应到短语$s_1$和$s_2$的外面，所以短语是与词对齐不一致的；类似的，右边的例子中短语与词对齐也是相一致的。
\parinterval 如图\ref{fig:7-11}所示，左边的例子中的$t_1$和$t_2$严格地对应到$s_1$、$s_2$、$s_3$，所以短语是与词对齐相一致的；中间例子中的$t_2$对应到短语$s_1$和$s_2$的外面，所以短语是与词对齐不一致的；类似的，右边的例子中短语与词对齐也是相一致的。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-consistence-of-word-alignment}
\caption{词对齐一致性示例}
\label{fig:7-14}
\label{fig:7-11}
\end{figure}
%-------------------------------------------
\parinterval 图\ref{fig:7-15}展示了与词对齐一致的短语抽取过程，首先判断抽取得到的双语短语是否与词对齐保持一致，若一致，则抽取出来。在实际抽取过程中，通常需要对短语的最大长度进行限制，以免抽取过多的无用短语。比如，在实际系统中，最大短语长度一般是5-7个词。
\parinterval 图\ref{fig:7-12}展示了与词对齐一致的短语抽取过程，首先判断抽取得到的双语短语是否与词对齐保持一致，若一致，则抽取出来。在实际抽取过程中，通常需要对短语的最大长度进行限制，以免抽取过多的无用短语。比如，在实际系统中，最大短语长度一般是5-7个词。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-phrase-extraction-consistent-with-word-alignment-1}
\caption{与词对齐一致的短语抽取}
\label{fig:7-15}
\label{fig:7-12}
\end{figure}
%-------------------------------------------
......@@ -454,14 +454,14 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\parinterval 如何获得词对齐呢？{\chapterfive}和{\chaptersix}介绍的IBM模型本身就是一个词对齐模型，因此一种常用的方法是直接使用IBM模型生成词对齐。IBM模型约定每个源语言单词必须对应、也只能对应到一个目标语单词。因此，IBM 模型得到的词对齐结果是不对称的。正常情况下词对齐可以是一个源语言单词对应多个目标语言单词，或者多对一，甚至多对多的情况。为了获得对称的词对齐，一种简单的方法是，分别进行正向翻译和反向翻译的词对齐，然后利用启发性方法生成对称的词对齐，例如，双向词对齐取交集、并集等。
\parinterval 如图\ref{fig:7-16}中，左边两个图就是正向和反向两种词对齐的结果。右边的图是融合双向词对齐的结果，取交集是蓝色的方框，取并集是红色的方框。当然，还可以设计更多的启发性规则生成词对齐\upcite{koehn2000estimating}。
\parinterval 如图\ref{fig:7-13}中，左边两个图就是正向和反向两种词对齐的结果。右边的图是融合双向词对齐的结果，取交集是蓝色的方框，取并集是红色的方框。当然，还可以设计更多的启发性规则生成词对齐\upcite{koehn2000estimating}。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-get-word-alignment}
\caption{词对齐的获取}
\label{fig:7-16}
\label{fig:7-13}
\end{figure}
%-------------------------------------------
......@@ -489,25 +489,25 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\parinterval 它表达的意思是短语$\bar{s}$和$\bar{t}$存在词汇级的对应关系，其中$a(j,i)=1$表示双语句对$(\seq{s},\seq{t})$中单词$s_j$和单词$t_i$对齐，$\sigma $表示词汇翻译概率用来度量两个单词之间翻译的可能性大小（见{\chapterfive}），作为两个词之间对应的强度。
\parinterval 下面来看一个具体的例子，如图\ref{fig:7-17}所示。对于一个双语短语，将它们的词对齐关系代入到公式\eqref{eq:7-14}就会得到短语的词汇翻译概率。对于词汇翻译概率，可以使用IBM 模型中的单词翻译表，也可以通过统计获得\upcite{koehn2002learning}。如果一个单词的词对齐为空，则用$N$表示它翻译为空的概率。和短语翻译概率一样，可以使用双向的词汇化翻译概率来评价双语短语的好坏。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-example-of-vocabulary-translation-probability}
\caption{词汇翻译概率实例}
\label{fig:7-17}
\label{fig:7-14}
\end{figure}
%-------------------------------------------
\parinterval 经过上面的介绍，可以从双语平行语料中把双语短语抽取出来，同时得到相应的翻译概率（即特征），组成{\small\bfnew{短语表}}\index{短语表}（Phrase Table）\index{Phrase Table}。图\ref{fig:7-18}展示了一个真实短语表的片段。其中包括源语言短语和目标语言短语，用|||进行分割。每个双语对应的得分，包括正向和反向的词汇翻译概率以及短语翻译概率，还包括词对齐信息（0-0、1-1）等其他信息。
\parinterval 来看一个具体的例子，如图\ref{fig:7-14}所示。对于一个双语短语，将它们的词对齐关系代入到公式\eqref{eq:7-14}就会得到短语的词汇翻译概率。对于词汇翻译概率，可以使用IBM 模型中的单词翻译表，也可以通过统计获得\upcite{koehn2002learning}。如果一个单词的词对齐为空，则用$N$表示它翻译为空的概率。和短语翻译概率一样，可以使用双向的词汇化翻译概率来评价双语短语的好坏。
\parinterval 经过上面的介绍，可以从双语平行语料中把双语短语抽取出来，同时得到相应的翻译概率（即特征），组成{\small\bfnew{短语表}}\index{短语表}（Phrase Table）\index{Phrase Table}。图\ref{fig:7-15}展示了一个真实短语表的片段。其中包括源语言短语和目标语言短语，用|||进行分割。每个双语对应的得分，包括正向和反向的词汇翻译概率以及短语翻译概率，还包括词对齐信息（0-0、1-1）等其他信息。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-example-of-phrase-table}
\caption{短语表实例}
\label{fig:7-18}
\label{fig:7-15}
\end{figure}
%-------------------------------------------
......@@ -519,14 +519,14 @@ d & = & {(\bar{s}_{\bar{a}_1},\bar{t}_1)} \circ {(\bar{s}_{\bar{a}_2},\bar{t}_2)
\parinterval 尽管已经知道了如何将一个源语言短语翻译成目标语言短语，但是想要获得一个高质量的译文，仅有互译的双语短语是远远不够的。
\parinterval 如图\ref{fig:7-19}所示，按照从左到右的顺序对一个句子“在/桌子/上/的/苹果”进行翻译，得到的译文“on the table the apple”的语序是不对的。虽然可以使用$n$-gram语言模型对语序进行建模，但是此处仍然需要用更加准确的方式描述目标语短语间的次序。一般，把这个问题称为短语调序，或者简称{\small\bfnew{调序}}\index{调序}（Reordering）\index{Reordering}。通常，基于短语的调序模型会作为判别式模型的特征参与到翻译过程中来。接下来，会介绍3 种不同的调序方法，分别是基于距离的调序、基于方向的调序（MSD模型）以及基于分类的调序。
\parinterval 如图\ref{fig:7-16}所示，按照从左到右的顺序对一个句子“在/桌子/上/的/苹果”进行翻译，得到的译文“on the table the apple”的语序是不对的。虽然可以使用$n$-gram语言模型对语序进行建模，但是此处仍然需要用更加准确的方式描述目标语短语间的次序。一般，把这个问题称为短语调序，或者简称{\small\bfnew{调序}}\index{调序}（Reordering）\index{Reordering}。通常，基于短语的调序模型会作为判别式模型的特征参与到翻译过程中来。接下来，会介绍3 种不同的调序方法，分别是基于距离的调序、基于方向的调序（MSD模型）以及基于分类的调序。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-reorder-base-phrase-translation}
\caption{基于短语翻译的调序}
\label{fig:7-19}
\label{fig:7-16}
\end{figure}
%-------------------------------------------
......@@ -546,14 +546,14 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\label{eq:7-15}
\end{eqnarray}
\parinterval 在图\ref{fig:7-20}的例子中，“the apple”所对应的调序距离为4，“on the table”所对应的调序距离为$-5$。显然，如果两个源语短语按顺序翻译，则$\rm{start}_i = \rm{end}_{i-1} + 1$，这时调序距离为0。
\parinterval 在图\ref{fig:7-17}的例子中，“the apple”所对应的调序距离为4，“on the table”所对应的调序距离为$-5$。显然，如果两个源语短语按顺序翻译，则$\rm{start}_i = \rm{end}_{i-1} + 1$，这时调序距离为0。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-reorder-base-distance}
\caption{基于距离的调序}
\label{fig:7-20}
\label{fig:7-17}
\end{figure}
%-------------------------------------------
......@@ -567,14 +567,14 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\parinterval 基于方向的调序模型是另一种常用的调序模型。该模型是一种典型的词汇化调序模型，因此调序的结果会根据不同短语有所不同。简单来说，在两个短语目标语言端连续的情况下，该模型会判断两个双语短语在源语言端的调序情况，包含三种调序类型：顺序的单调翻译（M）、与前一个短语交换位置（S）、非连续翻译（D）。因此，这个模型也被称作MSD调序模型，也是Moses等经典的机器翻译系统所采用的调序模型\upcite{Koehn2007Moses}。
\parinterval 图\ref{fig:7-21}展示了这三种调序类型，当两个短语对在源语言和目标语言中都是按顺序排列时，它们就是单调的（如：从左边数前两个短语）；如果对应的短语顺序在目标语中是反过来的，属于交换调序（如：从左边数第三和第四个短语）；如果两个短语之间还有其他的短语，就是非连续调序（如：从右边数的前两个短语）。
\parinterval 图\ref{fig:7-18}展示了这三种调序类型，当两个短语对在源语言和目标语言中都是按顺序排列时，它们就是单调的（如：从左边数前两个短语）；如果对应的短语顺序在目标语中是反过来的，属于交换调序（如：从左边数第三和第四个短语）；如果两个短语之间还有其他的短语，就是非连续调序（如：从右边数的前两个短语）。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-three-types-of-reorder-method-in-msd}
\caption{词汇化调序模型的三种调序类型}
\label{fig:7-21}
\label{fig:7-18}
\end{figure}
%-------------------------------------------
......@@ -586,14 +586,14 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\noindent 其中，$o_i$表示（目标语言）第$i$个短语的调序方向，$\seq{o}=\{o_i\}$表示短语序列的调序方向，$K$表示短语的数量。短语之间的调序概率是由双语短语以及短语对齐决定的，$o$表示调序的种类，可以取M、S、D 中的任意一种。而整个句子调序的好坏就是把相邻的短语之间的调序概率相乘（对应取log后的加法）。这样，公式\eqref{eq:7-16}把调序的好坏定义为新的特征，对于M、S、D总共就有三个特征。除了当前短语和前一个短语的调序特征，还可以定义当前短语和后一个短语的调序特征，即将上述公式中的$a_{i-1}$换成$a_{i+1}$。 于是，又可以得到三个特征。因此在MSD调序中总共可以有6个特征。
\parinterval 具体实现时，通常使用词对齐对两个短语间的调序关系进行判断。图\ref{fig:7-22}展示了这个过程。先判断短语的左上角和右上角是否存在词对齐，再根据其位置对调序类型进行划分。每个短语对应的调序概率都可以用相对频次估计进行计算。而MSD调序模型也相当于在短语表中的每个双语短语后添加6个特征。不过，调序模型一般并不会和短语表一起存储，因此在系统中通常会看到两个独立的模型文件，分别保存短语表和调序模型。
\parinterval 具体实现时，通常使用词对齐对两个短语间的调序关系进行判断。图\ref{fig:7-19}展示了这个过程。先判断短语的左上角和右上角是否存在词对齐，再根据其位置对调序类型进行划分。每个短语对应的调序概率都可以用相对频次估计进行计算。而MSD调序模型也相当于在短语表中的每个双语短语后添加6个特征。不过，调序模型一般并不会和短语表一起存储，因此在系统中通常会看到两个独立的模型文件，分别保存短语表和调序模型。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-judge-type-of-reorder-method}
\caption{调序类型的判断}
\label{fig:7-22}
\label{fig:7-19}
\end{figure}
%-------------------------------------------
......@@ -628,7 +628,6 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\item 短语翻译概率（取对数），包含正向翻译概率$\textrm{log}(\funp{P}(\bar{t}|\bar{s}))$和反向翻译概率$\textrm{log}(\funp{P}(\bar{s}$\\$|\bar{t}))$，它们是基于短语的模型中最主要的特征。
\vspace{0.5em}
\item 词汇化翻译概率（取对数），同样包含正向词汇化翻译概率$\textrm{log}(\funp{P}_{\textrm{lex}}(\bar{t}|\bar{s}))$和反向词汇化翻译概率$\textrm{log}(\funp{P}_{\textrm{lex}}(\bar{s}|\bar{t}))$，它们用来描述双语短语中单词间对应的好坏。
\vspace{0.5em}
\item $n$-gram语言模型，用来度量译文的流畅程度，可以通过大规模目标端单语数据得到。
\vspace{0.5em}
\item 译文长度，避免模型倾向于短译文，同时让系统自动学习对译文长度的偏好。
......@@ -677,29 +676,29 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\parinterval 需要注意的是， BLEU本身是一个不可微分函数。因此，无法使用梯度下降等方法对式\eqref{eq:7-19}进行求解。那么如何能快速得到最优解？这里会使用一种特殊的优化方法，称作{\small\bfnew{线搜索}}\index{线搜索}（Line Search）\index{Line Search}，它是Powell搜索的一种形式\upcite{powell1964an}。这种方法也构成了最小错误率训练的核心。
\parinterval 首先，重新看一下特征权重的搜索空间。按照前面的介绍，如果要进行暴力搜索，需要把特征权重的取值按小的间隔进行划分。这样，所有特征权重的取值可以用图\ref{fig:7-23}的网格来表示。
\parinterval 首先，重新看一下特征权重的搜索空间。按照前面的介绍，如果要进行暴力搜索，需要把特征权重的取值按小的间隔进行划分。这样，所有特征权重的取值可以用图\ref{fig:7-20}的网格来表示。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-search-space-representation-of-feature-weight}
\caption{特征权重的搜索空间表示}
\label{fig:7-23}
\label{fig:7-20}
\end{figure}
%-------------------------------------------
\parinterval 其中横坐标为所有的$M$个特征函数，纵坐标为权重可能的取值。假设每个特征都有$V$种取值，那么遍历所有特征权重取值的组合有$M^V$种。每组$\lambda = \{\lambda_i\}$的取值实际上就是一个贯穿所有特征权重的折线，如图\ref{fig:7-23}中间蓝线所展示的路径。当然，可以通过枚举得到很多这样的折线（图\ref{fig:7-23}右）。假设计算BLEU的时间开销为$B$，那么遍历所有的路径的时间复杂度为$O(M^V \cdot B)$，由于$V$可能很大，而且$B$往往也无法忽略，因此这种计算方式的时间成本是极高的。如果考虑对每一组特征权重都需要重新解码得到$n$-best译文，那么基于这种简单枚举的方法是无法使用的。
\parinterval 其中横坐标为所有的$M$个特征函数，纵坐标为权重可能的取值。假设每个特征都有$V$种取值，那么遍历所有特征权重取值的组合有$M^V$种。每组$\lambda = \{\lambda_i\}$的取值实际上就是一个贯穿所有特征权重的折线，如图\ref{fig:7-20}中间蓝线所展示的路径。当然，可以通过枚举得到很多这样的折线（图\ref{fig:7-20}右）。假设计算BLEU的时间开销为$B$，那么遍历所有的路径的时间复杂度为$O(M^V \cdot B)$，由于$V$可能很大，而且$B$往往也无法忽略，因此这种计算方式的时间成本是极高的。如果考虑对每一组特征权重都需要重新解码得到$n$-best译文，那么基于这种简单枚举的方法是无法使用的。
\parinterval 对全搜索的一种改进是使用局部搜索。循环处理每个特征，每一次只调整一个特征权重的值，找到使BLEU达到最大的权重。反复执行该过程，直到模型达到稳定状态（例如BLEU不再降低）。
\parinterval 图\ref{fig:7-24}左侧展示了这种方法。其中蓝色部分为固定的权重，相应的虚线部分为当前权重所有可能的取值，这样搜索一个特征权重的时间复杂度为$O(V \cdot B)$。而整个算法的时间复杂度为$O(L \cdot V \cdot B)$，其中$L$为循环访问特征的总次数。这种方法也被称作{\small\bfnew{格搜索}}\index{格搜索}（Grid Search）\index{Grid Search}。
\parinterval 图\ref{fig:7-21}左侧展示了这种方法。其中蓝色部分为固定的权重，相应的虚线部分为当前权重所有可能的取值，这样搜索一个特征权重的时间复杂度为$O(V \cdot B)$。而整个算法的时间复杂度为$O(L \cdot V \cdot B)$，其中$L$为循环访问特征的总次数。这种方法也被称作{\small\bfnew{格搜索}}\index{格搜索}（Grid Search）\index{Grid Search}。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-grid-search}
\caption{格搜索（左侧：所有点都访问（蓝色）；右侧：避开无效点（绿色））}
\label{fig:7-24}
\label{fig:7-21}
\end{figure}
%-------------------------------------------
......@@ -715,14 +714,14 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\label{eq:7-20}
\end{eqnarray}
\parinterval 这里，$a = h_i(d)$是直线的斜率，$b = \sum_{k \neq i}^{M} \lambda_k \cdot h_k (d)$是截距。有了关于权重$\lambda_i$的直线表示，可以将$d_1$和$d_2$分别画成两条直线，如图\ref{fig:7-25}所示。在两条直线交叉点的左侧，$d_2$是最优的翻译结果；在交叉点右侧，$d_1$是最优的翻译结果。也就是说，只需知道交叉点左侧和右侧谁的BLEU 值高，$\lambda_i$的最优值就应该落在相应的范围，比如，这个例子中交叉点右侧（即$d_2$）所对应的BLEU值更高，因此最优特征权重$\hat{\lambda}_i$应该在交叉点右侧（$\lambda_x \sim \lambda_i$任意取值都可以）。
\parinterval 这里，$a = h_i(d)$是直线的斜率，$b = \sum_{k \neq i}^{M} \lambda_k \cdot h_k (d)$是截距。有了关于权重$\lambda_i$的直线表示，可以将$d_1$和$d_2$分别画成两条直线，如图\ref{fig:7-22}所示。在两条直线交叉点的左侧，$d_2$是最优的翻译结果；在交叉点右侧，$d_1$是最优的翻译结果。也就是说，只需知道交叉点左侧和右侧谁的BLEU 值高，$\lambda_i$的最优值就应该落在相应的范围，比如，这个例子中交叉点右侧（即$d_2$）所对应的BLEU值更高，因此最优特征权重$\hat{\lambda}_i$应该在交叉点右侧（$\lambda_x \sim \lambda_i$任意取值都可以）。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-function-image-about-weight-and-Bleu}
\caption{推导得分关于权重的函数（左）以及对应的BLEU值变化（右）}
\label{fig:7-25}
\label{fig:7-22}
\end{figure}
%-------------------------------------------
......@@ -761,7 +760,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\parinterval 然而想要找到得分最高的翻译推导并不是一件简单的事情。对于每一句源语言句子，可能的翻译结果是指数级的。由于机器翻译解码是一个NP完全问题\upcite{knight1999decoding}，简单的暴力搜索显然不现实。因此，在机器翻译中会使用特殊的解码策略来确保搜索的效率。本节将介绍基于栈的自左向右解码方法。它是基于短语的模型中的经典解码方法，非常适于处理语言生成的各种任务。
\parinterval 首先，看一下翻译一个句子的基本流程。如图\ref{fig:7-26}所示，首先需要得到译文句子的第一个单词。在基于短语的模型中，可以从源语言端找出生成句首译文的短语，之后把译文放到目标语言端，例如，源语言的“有”对应的译文是“There is”。这个过程可以重复执行，直到生成完整句子的译文。但是，有两点需要注意：
\parinterval 首先，看一下翻译一个句子的基本流程。如图\ref{fig:7-23}所示，首先需要得到译文句子的第一个单词。在基于短语的模型中，可以从源语言端找出生成句首译文的短语，之后把译文放到目标语言端，例如，源语言的“有”对应的译文是“There is”。这个过程可以重复执行，直到生成完整句子的译文。但是，有两点需要注意：
\begin{itemize}
\vspace{0.5em}
......@@ -776,7 +775,7 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\centering
\input{./Chapter7/Figures/figure-basic-process-of-translation}
\caption{按目标语言短语自左向右生成的翻译实例}
\label{fig:7-26}
\label{fig:7-23}
\end{figure}
%-------------------------------------------
......@@ -788,14 +787,14 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\subsection{翻译候选匹配}
\parinterval 在解码时，首先要知道每个源语言短语可能的译文都是什么。对于一个源语言短语，每个可能的译文也被称作翻译候选。实现翻译候选的匹配很简单。只需要遍历输入的源语言句子中所有可能的短语，之后在短语表中找到相应的翻译即可。比如，图\ref{fig:7-27}展示了句子“桌子/上/有/一个/苹果”的翻译候选匹配结果。可以看到，不同的短语会对应若干翻译候选。这些翻译候选会保存在所对应的范围（被称为跨度）中。这里，跨度$[a,b]$表示从第$a+1$个词开始到第$b$个词为止所表示的词串。比如，“upon the table” 是短语“桌子/上/有”的翻译候选，即对应源语言跨度[0,3]。
\parinterval 在解码时，首先要知道每个源语言短语可能的译文都是什么。对于一个源语言短语，每个可能的译文也被称作翻译候选。实现翻译候选的匹配很简单。只需要遍历输入的源语言句子中所有可能的短语，之后在短语表中找到相应的翻译即可。比如，图\ref{fig:7-24}展示了句子“桌子/上/有/一个/苹果”的翻译候选匹配结果。可以看到，不同的短语会对应若干翻译候选。这些翻译候选会保存在所对应的范围（被称为跨度）中。这里，跨度$[a,b]$表示从第$a+1$个词开始到第$b$个词为止所表示的词串。比如，“upon the table” 是短语“桌子/上/有”的翻译候选，即对应源语言跨度[0,3]。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-translation-option}
\caption{一个句子匹配的短语翻译候选}
\label{fig:7-27}
\label{fig:7-24}
\end{figure}
%-------------------------------------------
......@@ -807,14 +806,14 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\parinterval 接下来，需要使用这些翻译候选生成完整的译文。在机器翻译中，一个很重要的概念是{\small\bfnew{翻译假设}}\index{翻译假设}（Translation Hypothesis）\index{Translation Hypothesis}。 它可以被当作是一个局部译文所对应的短语翻译推导。在解码开始时，只有一个空假设，也就是任何译文单词都没有被生成出来。接着，可以挑选翻译选项来扩展当前的翻译假设。
\parinterval 图\ref{fig:7-28}展示了翻译假设扩展的过程。在翻译假设扩展时，需要保证新加入的翻译候选放置在旧翻译假设译文的右侧，也就是要确保翻译自左向右的连续性。而且，同一个翻译假设可以使用不同的翻译候选进行扩展。例如，扩展第一个翻译假设时，可以选择“桌子”的翻译候选“table”；也可以选择“有”的翻译候选“There is”。扩展完之后需要记录输入句子中已翻译的短语，同时计算当前所有翻译假设的模型得分。这个过程相当于生成了一个图的结构，每个节点代表了一个翻译假设。当翻译假设覆盖了输入句子所有的短语，不能被继续扩展时，就生成了一个完整的翻译假设（译文）。最后需要找到得分最高的完整翻译假设，它对应了搜索图中的最优路径。
\parinterval 图\ref{fig:7-25}展示了翻译假设扩展的过程。在翻译假设扩展时，需要保证新加入的翻译候选放置在旧翻译假设译文的右侧，也就是要确保翻译自左向右的连续性。而且，同一个翻译假设可以使用不同的翻译候选进行扩展。例如，扩展第一个翻译假设时，可以选择“桌子”的翻译候选“table”；也可以选择“有”的翻译候选“There is”。扩展完之后需要记录输入句子中已翻译的短语，同时计算当前所有翻译假设的模型得分。这个过程相当于生成了一个图的结构，每个节点代表了一个翻译假设。当翻译假设覆盖了输入句子所有的短语，不能被继续扩展时，就生成了一个完整的翻译假设（译文）。最后需要找到得分最高的完整翻译假设，它对应了搜索图中的最优路径。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-translation-hypothesis-extension}
\caption{翻译假设扩展}
\label{fig:7-28}
\label{fig:7-25}
\end{figure}
%-------------------------------------------
......@@ -836,18 +835,18 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\vspace{0.5em}
\end{itemize}
\parinterval 对翻译假设进行重新组合又被称作{\small\bfnew{假设重组}}\index{假设重组}（Hypothesis Recombination）\index{Hypothesis Recombination}。其核心思想是，把代表同一个译文的不同翻译假设融合为一个翻译假设。如图\ref{fig:7-29}所示，对于给定的输入短语“一个\ \ 苹果”，系统可能将两个单词“一个”、“苹果”分别翻译成“an”和“apple”，也可能将这两个单词作为一个短语直接翻译成“an apple”。虽然这两个翻译假设得到的译文相同，并且覆盖了相同的源语言短语，但是却是两个不同的翻译假设，模型给它们的打分也是不一样的。这时，可以舍弃两个翻译假设中分数较低的那个，因为分数较低的翻译假设永远不可能成为最优路径的一部分。这也就相当于把两个翻译假设重组为一个假设。
\parinterval 对翻译假设进行重新组合又被称作{\small\bfnew{假设重组}}\index{假设重组}（Hypothesis Recombination）\index{Hypothesis Recombination}。其核心思想是，把代表同一个译文的不同翻译假设融合为一个翻译假设。如图\ref{fig:7-26}所示，对于给定的输入短语“一个\ \ 苹果”，系统可能将两个单词“一个”、“苹果”分别翻译成“an”和“apple”，也可能将这两个单词作为一个短语直接翻译成“an apple”。虽然这两个翻译假设得到的译文相同，并且覆盖了相同的源语言短语，但是却是两个不同的翻译假设，模型给它们的打分也是不一样的。这时，可以舍弃两个翻译假设中分数较低的那个，因为分数较低的翻译假设永远不可能成为最优路径的一部分。这也就相当于把两个翻译假设重组为一个假设。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-example-of-hypothesis-recombination}
\caption{假设重组示例}
\label{fig:7-29}
\label{fig:7-26}
\end{figure}
%-------------------------------------------
\parinterval 即使翻译假设对应的译文不同也可以进行假设重组。图\ref{fig:7-29}的下半部分给出了一个这样的实例。在两个翻译假设中，第一个单词分别被翻译成了“it”和“he”，紧接着它们后面的部分都被翻译成了“is not”。这两个翻译假设是非常相似的，因为它们译文的最后两个单词是相同的，而且翻译假设都覆盖了相同的源语言部分。这时，也可以对这两个翻译假设进行假设重组：如果得分较低的翻译假设和得分较高的翻译假设都使用相同的翻译候选进行扩展，且两个翻译假设都覆盖相同的源语言单词，分数低的翻译假设可以被剪枝掉。此外，还有两点需要注意：
\parinterval 即使翻译假设对应的译文不同也可以进行假设重组。图\ref{fig:7-26}的下半部分给出了一个这样的实例。在两个翻译假设中，第一个单词分别被翻译成了“it”和“he”，紧接着它们后面的部分都被翻译成了“is not”。这两个翻译假设是非常相似的，因为它们译文的最后两个单词是相同的，而且翻译假设都覆盖了相同的源语言部分。这时，也可以对这两个翻译假设进行假设重组：如果得分较低的翻译假设和得分较高的翻译假设都使用相同的翻译候选进行扩展，且两个翻译假设都覆盖相同的源语言单词，分数低的翻译假设可以被剪枝掉。此外，还有两点需要注意：
\begin{itemize}
\vspace{0.5em}
......@@ -883,14 +882,14 @@ dr & = & {\rm{start}}_i-{\rm{end}}_{i-1}-1
\parinterval 比如，第一个堆栈包含了覆盖一个源语言单词的翻译假设，第二个堆栈包含了覆盖两个源语言单词的翻译假设，以此类推。利用覆盖源语言单词数进行栈的划分的原因在于：翻译相同数量的单词所对应的翻译假设一般是“可比的”，因此在同一个栈里对它们进行剪枝带来的风险较小。
\parinterval 在基于栈的解码中，每次都会从所有的栈中弹出一个翻译假设，并选择一个或者若干个翻译假设进行扩展，之后把新得到的翻译假设重新压入解码栈中。这个过程不断执行，并可以配合束剪枝、假设重组等技术。最后在覆盖所有源语言单词的栈中得到整个句子的译文。图\ref{fig:7-30}展示了一个简单的栈解码过程。第一个栈（0号栈）用来存放空翻译假设。之后通过假设扩展，不断将翻译假设填入对应的栈中。
\parinterval 在基于栈的解码中，每次都会从所有的栈中弹出一个翻译假设，并选择一个或者若干个翻译假设进行扩展，之后把新得到的翻译假设重新压入解码栈中。这个过程不断执行，并可以配合束剪枝、假设重组等技术。最后在覆盖所有源语言单词的栈中得到整个句子的译文。图\ref{fig:7-27}展示了一个简单的栈解码过程。第一个栈（0号栈）用来存放空翻译假设。之后通过假设扩展，不断将翻译假设填入对应的栈中。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter7/Figures/figure-example-of-stack-decode}
\caption{栈解码示例}
\label{fig:7-30}
\label{fig:7-27}
\end{figure}
%-------------------------------------------
......
Chapter8/Figures/figure-combination-of-translation-with-different-rules.tex
......@@ -5,7 +5,7 @@
\begin{scope}%[scale=0.2]
\node[anchor=north] (q1) at (0,0) {\scriptsize\sffamily\bfseries{输入字符串：}};
\node[anchor=west] (q2) at ([xshift=0em,yshift=-2em]q1.west) {\footnotesize{进口$\quad$和$\quad$出口$\quad$大幅度$\quad$下降$\quad$了}};
\node[anchor=west] (q2) at ([xshift=0em,yshift=-1.5em]q1.west) {\footnotesize{进口$\quad$和$\quad$出口$\quad$大幅度$\quad$下降$\quad$了}};
\node[anchor=north,fill=blue!20,minimum height=4em,minimum width=1em] (f1) at ([xshift=2.7em,yshift=-0.7em]q2.south) {};
......
Chapter8/Figures/figure-hierarchical-phrase-rule-match-generate.tex
......@@ -5,7 +5,7 @@
\begin{scope}%[scale=0.2]
\node[anchor=north] (q1) at (0,0) {\scriptsize\sffamily\bfseries{输入字符串：}};
\node[anchor=west] (q2) at ([xshift=0em,yshift=-2em]q1.west) {\footnotesize{进口$\quad$和$\quad$出口$\quad$大幅度$\quad$下降$\quad$了}};
\node[anchor=west] (q2) at ([xshift=0em,yshift=-1.5em]q1.west) {\footnotesize{进口$\quad$和$\quad$出口$\quad$大幅度$\quad$下降$\quad$了}};
\node[anchor=north,fill=blue!20,minimum height=1em,minimum width=1em] (f1) at ([xshift=-4.2em,yshift=-0.8em]q2.south) {};
......
Chapter8/Figures/figure-one-best-node-alignment-and-alignment-matrix.tex
......@@ -107,7 +107,7 @@
\vspace{-1em}
\footnotesize{(a)节点对齐矩阵（1-best vs Matrix）}
\end{center}
\vspace{-3em}
\begin{center}
\begin{tabular}[t]{C{0.48\linewidth} C{0.48\linewidth} }
......
Chapter8/chapter8.tex
......@@ -301,9 +301,6 @@ d & = & {r_1} \circ {r_2} \circ {r_3} \circ {r_4}
%----------------------------------------------------------------------------------------
\subsubsection{4. 处理流程}
\parinterval 层次短语系统的流程如图\ref{fig:8-6}所示。其核心是从双语数据中学习同步翻译文法，并进行翻译特征的学习，形成翻译模型（即规则+特征）。同时，要从目标语言数据中学习语言模型。最终，把翻译模型和语言模型一起送入解码器，在特征权重调优后，完成对新输入句子的翻译。
%----------------------------------------------
\begin{figure}[htp]
\centering
......@@ -313,6 +310,8 @@ d & = & {r_1} \circ {r_2} \circ {r_3} \circ {r_4}
\end{figure}
%-------------------------------------------
\parinterval 层次短语系统的流程如图\ref{fig:8-6}所示。其核心是从双语数据中学习同步翻译文法，并进行翻译特征的学习，形成翻译模型（即规则+特征）。同时，要从目标语言数据中学习语言模型。最终，把翻译模型和语言模型一起送入解码器，在特征权重调优后，完成对新输入句子的翻译。
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
%----------------------------------------------------------------------------------------
......@@ -543,34 +542,38 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
\subsection{立方剪枝}
\parinterval 相比于基于短语的模型，基于层次短语的模型引入了“变量”的概念。这样，可以根据变量周围的上下文信息对变量进行调序。变量的内容由其所对应的跨度上的翻译假设进行填充。图\ref{fig:8-11}展示了一个层次短语规则匹配词串的实例。可以看到，规则匹配词串之后，变量$\seq{X}$的位置对应了一个跨度。这个跨度上所有标记为X的局部推导都可以作为变量的内容。
\vspace{-0.5em}
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-hierarchical-phrase-rule-match-generate}
\setlength{\abovecaptionskip}{-0.5em}
\setlength{\belowcaptionskip}{-0.5em}
\caption{层次短语规则匹配及译文生成}
\label{fig:8-11}
\end{figure}
%-------------------------------------------
\parinterval 真实的情况会更加复杂。对于一个规则的源语言端，可能会有多个不同的目标语言端与之对应。比如，如下规则的源语言端完全相同，但是译文不同：
\vspace{-0.5em}
\begin{eqnarray}
\funp{X} & \to & \langle\ \funp{X}_1\ \text{大幅度}\ \text{下降}\ \text{了},\ \funp{X}_1\ \textrm{have}\ \textrm{drastically}\ \textrm{fallen}\ \rangle \nonumber \\
\funp{X} & \to & \langle\ \funp{X}_1\ \text{大幅度}\ \text{下降}\ \text{了},\ \funp{X}_1\ \textrm{have}\ \textrm{fallen}\ \textrm{drastically}\ \rangle \nonumber \\
\funp{X} & \to & \langle\ \funp{X}_1\ \text{大幅度}\ \text{下降}\ \text{了},\ \funp{X}_1\ \textrm{has}\ \textrm{drastically}\ \textrm{fallen}\ \rangle \nonumber
\end{eqnarray}
\parinterval 这也就是说，当匹配规则的源语言部分“$\funp{X}_1$\ \ 大幅度\ \ 下降\ \ 了”时会有三个译文可以选择。而变量$\funp{X}_1$部分又有很多不同的局部翻译结果。不同的规则译文和不同的变量译文都可以组合出一个局部翻译结果。图\ref{fig:8-12}展示了这种情况的实例。
\vspace{-2em}
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-combination-of-translation-with-different-rules}
\setlength{\abovecaptionskip}{-0.5em}
\caption{不同规则目标语端及变量译文的组合}
\label{fig:8-12}
\end{figure}
%-------------------------------------------
\parinterval 这也就是说，当匹配规则的源语言部分“$\funp{X}_1$\ \ 大幅度\ \ 下降\ \ 了”时会有三个译文可以选择。而变量$\funp{X}_1$部分又有很多不同的局部翻译结果。不同的规则译文和不同的变量译文都可以组合出一个局部翻译结果。图\ref{fig:8-12}展示了这种情况的实例。
\parinterval 假设有$n$个规则的源语言端相同，规则中每个变量可以被替换为$m$个结果，对于只含有一个变量的规则，一共有$nm$种不同的组合。如果规则含有两个变量，这种组合的数量是$n{m}^2$。由于翻译中会进行大量的规则匹配，如果每个匹配的源语言端都考虑所有$n{m}^2$种译文的组合，解码速度会很慢。
\parinterval 在层次短语系统中，会进一步对搜索空间剪枝。简言之，此时并不需要对所有$n{m}^2$种组合进行遍历，而是只考虑其中的一部分组合。这种方法也被称作{\small\bfnew{立方剪枝}}\index{立方剪枝}（Cube Pruning）\index{Cube Pruning}。所谓“ 立方”是指组合译文时的三个维度：规则的目标语端、第一个变量所对应的翻译候选、第二个变量所对应的翻译候选。立方剪枝假设所有的译文候选都经过排序，比如，按照短语翻译概率排序。这样，每个译文都对应一个坐标，比如，$(i,j,k)$就表示第$i$个规则目标语端、第一个变量的第$j$个翻译候选、第二个变量的第$k$个翻译候选的组合。于是，可以把每种组合看作是一个三维空间中的一个点。在立方剪枝中，开始的时候会看到$(0,0,0)$这个翻译假设，并把这个翻译假设放入一个优先队列中。之后每次从这个优先队里中弹出最好的结果，之后沿着三个维度分别将坐标加1，比如，如果优先队列弹出$(i,j,k)$，则会生成$(i+1,j,k)$、$(i,j+1,k)$和$(i,j,k+1)$这三个新的翻译假设。之后，计算出它们的模型得分，并压入优先队列。这个过程不断被执行，直到达到终止条件，比如，扩展次数达到一个上限。
......@@ -579,6 +582,7 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-execution-of-cube-pruning}
\setlength{\abovecaptionskip}{-0.5em}
\caption{立方剪枝执行过程（行表示规则，列表示变量可替换的内容）}
\label{fig:8-13}
\end{figure}
......@@ -678,6 +682,16 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
&此翻译可以被看作从句法树到句法树的转换 \\
\rule{0pt}{15pt}基于句法 & 使用语言学句法 \\
\rule{0pt}{15pt}基于树 &（源语言）使用树结构（大多指句法树） \\
\end{tabular}
}
\end{center}
}\end{table}
\begin{table}[htp]{
\begin{center}
{
\begin{tabular}{p{6.5em} | l}
术语 & 说明 \\
\hline
\rule{0pt}{15pt}基于串 &（源语言）使用词串，比如串到树翻译系统的解码器一般\\
&都是基于串的解码方法 \\
\rule{0pt}{15pt}基于森林 &（源语言）使用句法森林，这里森林只是对多个句法树的一 \\
......@@ -686,26 +700,11 @@ span\textrm{[0,4]}&=&\textrm{“猫} \quad \textrm{喜欢} \quad \textrm{吃} \q
\rule{0pt}{15pt}非词汇规则 & 不含有终结符的规则 \\
\rule{0pt}{15pt}句法软约束 & 不强制规则推导匹配语言学句法树，通常把句法信息作为特\\
&征使用 \\
\rule{0pt}{15pt}句法硬约束 & 要求推导必须符合语言学句法树，不符合的推导会被过滤掉
\rule{0pt}{15pt}句法硬约束 & 要求推导必须符合语言学句法树，不符合的推导会被过滤掉 \\
\end{tabular}
}
\end{center}
}\end{table}
%\begin{table}[htp]{
%\begin{center}
%{
%\begin{tabular}{p{6.5em} | l}
%术语 & 说明 \\
%\hline
%\rule{0pt}{15pt}词汇化规则 & 含有终结符的规则 \\
%\rule{0pt}{15pt}非词汇规则 & 不含有终结符的规则 \\
%\rule{0pt}{15pt}句法软约束 & 不强制规则推导匹配语言学句法树，通常把句法信息作为特\\
%&征使用 \\
%\rule{0pt}{15pt}句法硬约束 & 要求推导必须符合语言学句法树，不符合的推导会被过滤掉 \\
%\end{tabular}
%}
%\end{center}
%}\end{table}
%----------------------------------------------
\parinterval 基于句法的翻译模型可以被分为两类：基于形式化文法的模型和语言学上基于句法的模型（图\ref{fig:8-17}）。基于形式化文法的模型的典型代表包括，基于反向转录文法的模型\upcite{wu1997stochastic}和基于层次短语的模型\upcite{chiang2007hierarchical}。而语言学上基于句法的模型包括，句法树到串的模型\upcite{liu2006tree,huang2006statistical}、串到句法树的模型\upcite{galley2006scalable,galley2004s}、句法树到句法树的模型\upcite{eisner2003learning,zhang2008tree}等。
......@@ -884,7 +883,9 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex
& \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 \\
& & \ \ \textrm{S(NP(DT(the) NNS(imports))}\ \textrm{VP(VBP}^{[6]}\ \textrm{ADVP(RB}^{[4]}\ \textrm{VBN}^{[5]})))\ \rangle \hspace{4.5em} \nonumber \\
& \xrightarrow[r_3]{\textrm{AD}^{[4]} \Leftrightarrow \textrm{RB}^{[4]}} & \langle\ \textrm{IP(NN(进口)}\ \textrm{VP(AD(大幅度)}\ \textrm{VP(VV}^{[5]}\ \textrm{AS}^{[6]}))), \nonumber \\
& & \ \ \textrm{S(NP(DT(the) NNS(imports))}\ \textrm{VP(VBP}^{[6]}\ \textrm{ADVP(RB(drastically)}\ \textrm{VBN}^{[5]})))\ \rangle \nonumber \\
& & \ \ \textrm{S(NP(DT(the) NNS(imports))}\ \textrm{VP(VBP}^{[6]}\ \textrm{ADVP(RB(drastically)}\ \textrm{VBN}^{[5]})))\ \rangle \nonumber
\end{eqnarray}
\begin{eqnarray}
& \xrightarrow[r_4]{\textrm{VV}^{[5]} \Leftrightarrow \textrm{VBN}^{[5]}} & \langle\ \textrm{IP(NN(进口)}\ \textrm{VP(AD(大幅度)}\ \textrm{VP(VV(减少)}\ \textrm{AS}^{[6]}))), \hspace{10em} \nonumber \\
& & \ \ \textrm{S(NP(DT(the) NNS(imports))}\ \textrm{VP(VBP}^{[6]}\ \nonumber \\
& & \ \ \textrm{ADVP(RB(drastically)}\ \textrm{VBN(fallen)})))\ \rangle \nonumber \\
......@@ -1097,7 +1098,6 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
\subsubsection{2. 空对齐处理}
\parinterval 空对齐是翻译中的常见现象。比如，一些虚词经常找不到在另一种语言中的对应，因此不会被翻译，这种情况也被称作空对齐。在图\ref{fig:8-27}中目标语中的“was”就是一个空对齐单词。空对齐的使用可以大大增加翻译的灵活度。具体到树到串规则抽取任务，需要把空对齐考虑进来，这样能够覆盖更多的语言现象。
......@@ -1258,27 +1258,30 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex
\subsubsection{1. 基于节点对齐的规则抽取}
\parinterval 不过，GHKM方法的问题在于过于依赖词对齐结果。在树到树翻译中，真正需要的是树结构（节点）之间的对应关系，而不是词对齐。特别是在两端都加入句法树结构约束的情况下，词对齐的错误可能会导致较为严重的规则抽取错误。图\ref{fig:8-34}就给出了一个实例，其中，中文的“了”被错误的对齐到了英文的“the”，导致很多高质量的规则无法被抽取出来。
\vspace{-0.5em}
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-tree-to-tree-rule-extraction-base-word-alignment}
%\setlength{\abovecaptionskip}{-0.1em}
\caption{基于词对齐的树到树规则抽取}
\label{fig:8-34}
\end{figure}
%-------------------------------------------
\parinterval 换一个角度来看，词对齐实际上只是帮助模型找到两种语言句法树中节点的对应关系。如果能够直接得到句法树节点的对应，就可以避免掉词对齐的错误。也就是，可以直接使用节点对齐来进行树到树规则的抽取。首先，利用外部的节点对齐工具获得两棵句法树节点之间的对齐关系。之后，将每个对齐的节点看作是树片段的根节点，再进行规则抽取。图\ref{fig:8-35}展示了基于节点对齐的规则抽取结果。
\vspace{-2em}
%----------------------------------------------
\begin{figure}[htb]
\centering
\input{./Chapter8/Figures/figure-tree-to-tree-rule-extraction-base-node-alignment}
%\setlength{\abovecaptionskip}{-0.1em}
\caption{基于节点对齐的树到树规则抽取}
\label{fig:8-35}
\end{figure}
%-------------------------------------------
\vspace{-1.0em}
\parinterval 换一个角度来看，词对齐实际上只是帮助模型找到两种语言句法树中节点的对应关系。如果能够直接得到句法树节点的对应，就可以避免掉词对齐的错误。也就是，可以直接使用节点对齐来进行树到树规则的抽取。首先，利用外部的节点对齐工具获得两棵句法树节点之间的对齐关系。之后，将每个对齐的节点看作是树片段的根节点，再进行规则抽取。图\ref{fig:8-35}展示了基于节点对齐的规则抽取结果。
\parinterval 可以看到，节点对齐可以避免词对齐错误造成的影响。不过，节点对齐需要开发额外的工具，有很多方法可以参考，比如可以基于启发性规则\upcite{DBLP:conf/coling/GrovesHW04}、基于分类模型\upcite{DBLP:conf/coling/SunZT10}、基于无指导的方法\upcite{xiao2013unsupervised}等。
%----------------------------------------------------------------------------------------
......@@ -1288,16 +1291,18 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex
\subsubsection{2. 基于对齐矩阵的规则抽取}
\parinterval 同词对齐一样，节点对齐也会存在错误，这样就不可避免地造成规则抽取的错误。既然单一的对齐中含有错误，那能否让系统看到更多样的对齐结果，进而提高正确规则被抽取到的几率呢？答案是肯定的。实际上，在基于短语的模型中就有基于多个词对齐（如$n$-best词对齐）进行规则抽取的方法\upcite{liu2009weighted}，这种方法可以在一定程度上提高短语的召回率。在树到树规则抽取中也可以使用多个节点对齐结果进行规则抽取。但是，简单使用多个对齐结果会使系统运行代价线性增长，而且即使是$n$-best对齐，也无法保证涵盖到正确的对齐结果。对于这个问题，另一种思路是使用对齐矩阵进行规则的“软”抽取。
\vspace{-1em}
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-one-best-node-alignment-and-alignment-matrix}
\setlength{\abovecaptionskip}{-0.5em}
\caption{使用1-best节点对齐和概率化节点对齐矩阵的树到树规则抽取\upcite{xiao2013unsupervised}}
\label{fig:8-36}
\end{figure}
%-------------------------------------------
\vspace{-0.5em}
\parinterval 所谓对齐矩阵，是描述两个句法树节点之间对应强度的数据结构。矩阵的每个单元中都是一个0到1之间的数字。规则抽取时，可以认为所有节点之间都存在对齐，这样可以抽取出很多$n$-best对齐中无法覆盖的规则。图\ref{fig:8-36}展示了一个用对齐矩阵的进行规则抽取的实例。其中矩阵1（Matrix 1）表示的是标准的1-best节点对齐，矩阵2（Matrix 2）表示的是一种概率化的对齐矩阵。可以看到使用矩阵2可以抽取到更多样的规则。另外，值得注意的是，基于对齐矩阵的方法也同样适用于短语和层次短语规则的抽取。关于对齐矩阵的生成可以参考相关论文的内容\upcite{xiao2013unsupervised,liu2009weighted,sun2010exploring,DBLP:conf/coling/SunZT10}。
\parinterval 此外，在基于句法的规则抽取中，一般会对规则进行一些限制，以避免规则数量过大，系统无法处理。比如，可以限制树片段的深度、变量个数、规则组合的次数等等。这些限制往往需要根据具体任务进行设计和调整。
......@@ -1392,16 +1397,18 @@ r_9: \quad \textrm{IP(}\textrm{NN}_1\ \textrm{VP}_2) \rightarrow \textrm{S(}\tex
\textrm{VP} \rightarrow \textrm{VV}\ \textrm{NP} \nonumber \\
\textrm{NP} \rightarrow \textrm{NN}\ \textrm{NP} \nonumber
\end{eqnarray}
\vspace{-3.0em}
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-example-of-hyper-graph}
\setlength{\abovecaptionskip}{-0.1em}
\caption{超图实例}
\label{fig:8-37}
\end{figure}
%-------------------------------------------
\vspace{-1.0em}
\parinterval 对于规则“$\textrm{VP} \rightarrow \textrm{VV}\ \textrm{NP}$”，超边的头指向VP，超边的尾表示规则右部的两个变量VV和NP。规则“$\textrm{NP} \rightarrow \textrm{NN}\ \textrm{NP}$”也可以进行类似的解释。
\parinterval 不难发现，超图提供了一种非常紧凑的数据结构来表示多个推导，因为不同推导之间可以共享节点。如果把图\ref{fig:8-37}中的蓝色和红色部分看作是两个推导，那么它们就共享了同一个节点NN[1,2]，其中NN是句法标记，[1,2]是跨度。能够想象，简单枚举一个句子所有的推导几乎是不可能的，但是用超图的方式却可以很有效地对指数级数量的推导进行表示。另一方面，超图上的运算常常被看作是一种基于半环的代数系统，而且人们发现许多句法分析和机器翻译问题本质上都是{\small\bfnew{半环分析}}\index{半环分析}（Semi-ring Parsing）\index{Semi-ring Parsing}。不过，由于篇幅有限，这里不会对半环等结构展开讨论。感兴趣的读者可以查阅相关文献\upcite{goodman1999semiring,eisner2002parameter}。
......@@ -1439,6 +1446,7 @@ d_1 & = & {d'} \circ {r_5}
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-hyper-graph-representation-of-machine-translation-derivation}
\setlength{\abovecaptionskip}{-0.5em}
\caption{机器翻译推导的超图表示}
\label{fig:8-39}
\end{figure}
......@@ -1492,6 +1500,7 @@ d_1 & = & {d'} \circ {r_5}
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-role-of-syntax-tree-in-different-decoding-methods}
\setlength{\abovecaptionskip}{-0.5em}
\caption{句法树在不同解码方法中的角色}
\label{fig:8-40}
\end{figure}
......@@ -1520,6 +1529,7 @@ d_1 & = & {d'} \circ {r_5}
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-content-of-chart-in-tree-based-decoding}
\setlength{\abovecaptionskip}{-0.5em}
\caption{基于树的解码中Chart的内容}
\label{fig:8-41}
\end{figure}
......@@ -1531,6 +1541,7 @@ d_1 & = & {d'} \circ {r_5}
\begin{figure}[htp]
\centering
\input{./Chapter8/Figures/figure-rule-matching-base-tree}
\setlength{\abovecaptionskip}{-0.5em}
\caption{基于树的规则匹配}
\label{fig:8-42}
\end{figure}
......
Chapter9/Figures/figure-activate-2.tex 0 → 100644
%%%------------------------------------------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{every node}=[scale=1.2]
\begin{scope}
\draw[->, line width=1pt](-1.4,0)--(1.4,0)node[left,below,font=\scriptsize]{$x$};
\draw[->, line width=1pt](0,-1.2)--(0,1.4)node[right,font=\scriptsize]{$y$};
\foreach \x in {-1.0,-0.5,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize,,scale=0.8]at(\x,0.1){\x};}
\node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,0.1){0};
\foreach \y in {0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize,,scale=0.8]at(0.1,\y){\y};}
\draw[color=red ,domain=-1.4:1.2, line width=1pt]plot(\x,{max(\x,0)});
\node[black,anchor=south,scale=0.8] at (0,1.6) {\small $y =\max (0, x)$};
\node [anchor=south east,inner sep=1pt,scale=0.8] (labeld) at (0.8,-2) {\small{(a) ReLU}};
\end{scope}
%%%------------------------------------------------------------------------------------------------------------
\begin{scope}[xshift=1.7in]
\draw[->, line width=1pt](-1.4,0)--(1.4,0)node[left,below,font=\scriptsize]{$x$};
\draw[->, line width=1pt](0,-1.2)--(0,1.4)node[right,font=\scriptsize]{$y$};
\foreach \x in {-1.0,-0.5,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(\x,0.1){\x};}
\node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,0.1){0};
\foreach \y in {0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,\y){};}
\node[left,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,0.5){0.5};
\node[left,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,1.1){1.0};
\draw[color=red ,domain=-1.4:1.4, line width=1pt]plot(\x,{exp(-1*((\x)^2))});
\node[black,anchor=south,scale=0.8] at (0,1.6) {\small $y ={\textrm e}^{-x^2}$};
\node [anchor=south east,inner sep=1pt,scale=0.8] (labele) at (0.8,-2) {\small{(b) Gaussian}};
\end{scope}
%%%------------------------------------------------------------------------------------------------------------
\begin{scope}[xshift=3.4in]
\draw[->, line width=1pt](-1.4,0)--(1.4,0)node[left,below,font=\scriptsize]{$x$};
\draw[->, line width=1pt](0,-1.2)--(0,1.4)node[right,font=\scriptsize]{$y$};
\foreach \x in {-1.0,-0.5,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(\x,0.1){\x};}
\node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,0.1){0};
\foreach \y in {0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,\y){\y};}
\draw[color=red ,domain=-1:1, line width=1pt]plot(\x,\x);
\node[black,anchor=south,scale=0.8] at (0,1.6) {\small $y =x$};
\node [anchor=south east,inner sep=1pt,scale=0.8] (labelf) at (0.8,-2) {\small{(c) Identity}};
\end{scope}
\end{tikzpicture}
%%%------------------------------------------------------------------------------------------------------------
\ No newline at end of file
Chapter9/Figures/figure-activate.tex
%%%------------------------------------------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{every node}=[scale=1.2]
\begin{scope}
\draw[->, line width=1pt](-1.4,0)--(1.4,0)node[left,below,font=\scriptsize]{$x$};
\draw[->, line width=1pt](0,-1.4)--(0,1.4)node[right,font=\scriptsize]{$y$};
\foreach \x in {-1.0,-0.5,0.0,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize]at(\x,0){\x};}
\foreach \y in {1.0,0.5}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize]at(0,\y){\y};}
\draw[color=red ,domain=-1.4:1, line width=1pt]plot(\x,{ln(1+(exp(\x))});
\node[black,anchor=south] at (0,1.6) {\small $y = \ln(1+{\textrm e}^x)$};
\node [anchor=south east,inner sep=1pt] (labela) at (0.8,-2) {\small{(a) Softplus}};
\draw[->, line width=1pt](0,-1.2)--(0,1.4)node[right,font=\scriptsize]{$y$};
\foreach \x in {-1.0,-0.5,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(\x,0.1){\x};}
\node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,0.1){0};
\foreach \y in {1.0,0.5}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,\y){};}
\node[left,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,0.4){0.5};
\node[left,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,1.0){1.0};
\draw[color=red ,domain=-1.4:1.0, line width=1pt]plot(\x,{ln(1+(exp(\x))});
\node[black,anchor=south,scale=0.8] at (0,1.5) {\small $y = \ln(1+{\textrm e}^x)$};
\node [anchor=south east,inner sep=1pt,scale=0.8] (labela) at (0.8,-2) {\small{(a) Softplus}};
\end{scope}
%%%------------------------------------------------------------------------------------------------------------
\begin{scope}[xshift=1.7in]
\draw[->, line width=1pt](-1.4,0)--(1.4,0)node[left,below,font=\scriptsize]{$x$};
\draw[->, line width=1pt](0,-1.4)--(0,1.4)node[right,font=\scriptsize]{$y$};
\draw[->, line width=1pt](0,-1.2)--(0,1.4)node[right,font=\scriptsize,scale=0.8]{$y$};
\draw[dashed](0,1)--(1.4,1);
\foreach \x in {-1,-0.5,0,0.5,1}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize]at(\x,0){
\foreach \x in {-1,-0.5,0.5,1}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(\x,0.1){
\pgfmathparse{(\x)*5}
\pgfmathresult};}
\foreach \y in {0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize]at(-0.15,\y){\y};}
\node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,0.1){0};
\foreach \y in {0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,\y){\y};}
\draw[color=red,domain=-1.4:1.4, line width=1pt]plot(\x,{1/(1+(exp(-5*\x)))});
\node[black,anchor=south] at (0,1.6) {\small $y = \frac{1}{1+{\textrm e}^{-x}}$};
\node [anchor=south east,inner sep=1pt] (labelb) at (0.8,-2) {\small{(b) Sigmoid}};
\node[black,anchor=south,scale=0.8] at (0,1.5) {\small $y = \frac{1}{1+{\textrm {e}}^{-x}}$};
\node [anchor=south east,inner sep=1pt,scale=0.8] (labelb) at (0.8,-2) {\small{(b) Sigmoid}};
\end{scope}
%%%------------------------------------------------------------------------------------------------------------
\begin{scope}[xshift=3.4in]
\draw[->, line width=1pt](-1.4,0)--(1.4,0)node[left,below,font=\scriptsize]{$x$};
\draw[->, line width=1pt](0,-1.4)--(0,1.4)node[right,font=\scriptsize]{$y$};
\draw[->, line width=1pt](0,-1.4)--(0,1.2)node[right,font=\scriptsize]{$y$};
\draw[dashed](0,1)--(1.4,1);
\draw[dashed](-1.4,-1)--(0,-1);
\foreach \x in {-1.0,-0.5,0.0,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize]at(\x,0){\x};}
\foreach \y in {,-1.0-0.5,0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize]at(0,\y){\y};}
\foreach \x in {-1.0,-0.5,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(\x,0.1){\x};}
\node[below,outer sep=2pt,font=\scriptsize,scale=0.8]at(0.1,0.1){0};
\foreach \y in {0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize,scale=0.8]at(0,\y){\y};}
\draw[color=red ,domain=-1.4:1.4, line width=1pt]plot(\x,{tanh(\x)});
\node[black,anchor=south] at (0,1.6) {\small $y = \frac{{\textrm e}^{x}-{\textrm e}^{-x}}{{e}^{x}+e^{-x}}$};
\node [anchor=south east,inner sep=1pt] (labelc) at (0.8,-2) {\small{(c) Tanh}};
\end{scope}
%%%------------------------------------------------------------------------------------------------------------
\begin{scope}[yshift=-1.8in]
\draw[->, line width=1pt](-1.4,0)--(1.4,0)node[left,below,font=\scriptsize]{$x$};
\draw[->, line width=1pt](0,-1.4)--(0,1.4)node[right,font=\scriptsize]{$y$};
\foreach \x in {-1.0,-0.5,0.0,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize]at(\x,0){\x};}
\foreach \y in {0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize]at(0,\y){\y};}
\draw[color=red ,domain=-1.4:1.4, line width=1pt]plot(\x,{max(\x,0)});
\node[black,anchor=south] at (0,1.6) {\small $y =\max (0, x)$};
\node [anchor=south east,inner sep=1pt] (labeld) at (0.8,-2) {\small{(d) ReLU}};
\end{scope}
%%%------------------------------------------------------------------------------------------------------------
\begin{scope}[yshift=-1.8in,xshift=1.7in]
\draw[->, line width=1pt](-1.4,0)--(1.4,0)node[left,below,font=\scriptsize]{$x$};
\draw[->, line width=1pt](0,-1.4)--(0,1.4)node[right,font=\scriptsize]{$y$};
\foreach \x in {-1.0,-0.5,0.0,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize]at(\x,0){\x};}
\foreach \y in {0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize]at(-0.15,\y){\y};}
\draw[color=red ,domain=-1.4:1.4, line width=1pt]plot(\x,{exp(-1*((\x)^2))});
\node[black,anchor=south] at (0,1.6) {\small $y =e^{-x^2}$};
\node [anchor=south east,inner sep=1pt] (labele) at (0.8,-2) {\small{(e) Gaussian}};
\end{scope}
%%%------------------------------------------------------------------------------------------------------------
\begin{scope}[yshift=-1.8in,xshift=3.4in]
\draw[->, line width=1pt](-1.4,0)--(1.4,0)node[left,below,font=\scriptsize]{$x$};
\draw[->, line width=1pt](0,-1.4)--(0,1.4)node[right,font=\scriptsize]{$y$};
\foreach \x in {-1.0,-0.5,0.0,0.5,1.0}{\draw(\x,0)--(\x,0.05)node[below,outer sep=2pt,font=\scriptsize]at(\x,0){\x};}
\foreach \y in {0.5,1.0}{\draw(0,\y)--(0.05,\y)node[left,outer sep=2pt,font=\scriptsize]at(0,\y){\y};}
\draw[color=red ,domain=-1:1, line width=1pt]plot(\x,\x);
\node[black,anchor=south] at (0,1.6) {\small $y =x$};
\node [anchor=south east,inner sep=1pt] (labelf) at (0.8,-2) {\small{(f) Identity}};
\node[black,anchor=south,scale=0.8] at (0,1.5) {\small $y = \frac{{\textrm e}^{x}-{\textrm e}^{-x}}{\textrm{e}^{x}+{\textrm e}^{-x}}$};
\node [anchor=south east,inner sep=1pt,scale=0.8] (labelc) at (0.8,-2) {\small{(c) Tanh}};
\end{scope}
\end{tikzpicture}
%%%------------------------------------------------------------------------------------------------------------
\ No newline at end of file
Chapter9/chapter9.tex
......@@ -410,10 +410,7 @@ f(c{\mathbi{v}})&=&cf({\mathbi{v}})
\parinterval 利用矩阵$ {\mathbi{A}}\in {\mathbb R}^{m\times n} $，可以实现两个有限维欧氏空间的映射函数$f:{\mathbb R}^n\rightarrow {\mathbb R}^m$。例如$ n $维列向量$ {\mathbi{x}} ^{\textrm T}$与$ m\times n $的矩阵$ {\mathbi{A}} $，向量$ {\mathbi{x}} ^{\textrm T}$左乘矩阵$ {\mathbi{A}} $，可将向量$ {\mathbi{x}} ^{\textrm T}$映射为$ m $列向量。公式\eqref{eq:9-11}\eqref{eq:9-12}\eqref{eq:9-13}展示了一个具体的例子，
\begin{eqnarray}
{\mathbi{x}}^{\textrm{T}} & = & {\begin{pmatrix} x_1\\ x_2 \\ \dots \\ x_n \end{pmatrix}}
\label{eq:9-11}
\end{eqnarray}
\begin{eqnarray}
\label{eq:9-11}\\ \\
{\mathbi{A}}&=&
\begin{pmatrix}
a_{11} & a_{12} & \dots & a_{1n}\\
......@@ -673,7 +670,6 @@ x_1\cdot w_1+x_2\cdot w_2+x_3\cdot w_3 & = & 0\cdot 1+0\cdot 1+1\cdot 1 \nonumbe
\parinterval 举个简单的例子，预报天气时，往往需要预测温度、湿度和风力，这就意味着如果使用单层神经网络进行预测，需要设置3个神经元。如图\ref{fig:9-10}所示，此时权重矩阵如下：
\begin{eqnarray}
{\mathbi{W}}&=&\begin{pmatrix} w_{11} & w_{12} & w_{13}\\ w_{21} & w_{22} & w_{23}\end{pmatrix}
\label{eq:9-105}
......@@ -701,22 +697,20 @@ x_1\cdot w_1+x_2\cdot w_2+x_3\cdot w_3 & = & 0\cdot 1+0\cdot 1+1\cdot 1 \nonumbe
\parinterval 在神经网络中，对于输入向量$ {\mathbi{x}}\in {\mathbb R}^m $，一层神经网络首先将其经过线性变换映射到$ {\mathbb R}^n $，再经过激活函数变成${\mathbi{y}}\in {\mathbb R}^n $。还是上面天气预测的例子，每个神经元获得相同的输入，权重矩阵$ {\mathbi{W}} $是一个$ 2\times 3 $矩阵，矩阵中每个元素$ w_{ij} $代表第$ j $个神经元中$ x_{i} $对应的权重值，假设编号为1的神经元负责预测温度，则$ w_{i1} $的含义为预测温度时输入$ x_{i} $对其影响程度。此外所有神经元的偏置$ b_{1} $，$ b_{2} $，$ b_{3} $组成了最终的偏置向量$ {\mathbi{b}}$。在该例中则有，权重矩阵$ {\mathbi{W}}=\begin{pmatrix} w_{11} & w_{12} & w_{13}\\ w_{21} & w_{22} & w_{23}\end{pmatrix} $，偏置向量$ {\mathbi{b}}=(b_1,b_2,b_3) $。
\parinterval 那么，线性变换的本质是什么？
\parinterval 那么，线性变换的本质是什么？图\ref{fig:9-13}正是线性变换的简单示意。
\begin{itemize}
\vspace{0.5em}
\item 从代数角度看，对于线性空间$ \textrm V $，任意$ {\mathbi{a}}$，${\mathbi{a}}\in {\textrm V} $和数域中的任意$ \alpha $，线性变换$ T(\cdot) $需满足：$ T({\mathbi{a}}+{\mathbi{b}})=T({\mathbi{a}})+T({\mathbi{b}}) $，且$ T(\alpha {\mathbi{a}})=\alpha T({\mathbi{a}}) $；
\vspace{0.5em}
\item 从几何角度看，公式中的${\mathbi{x}}\cdot {\mathbi{W}}+{\mathbi{b}}$将${\mathbi{x}}$右乘${\mathbi{W}}$相当于对$ {\mathbi{x}} $进行旋转变换。例如，对三个点$ (0,0) $，$ (0,1) $，$ (1,0) $及其围成的矩形区域右乘如下矩阵：
\begin{eqnarray}
{\mathbi{W}}&=&\begin{pmatrix} 1 & 0 & 0\\ 0 & -1 & 0\\ 0 & 0 & 1\end{pmatrix}
\label{eq:9-106}
\end{eqnarray}
这样，矩形区域由第一象限旋转90度到了第四象限，如图\ref{fig:9-13}第一步所示。公式$ {\mathbi{x}}\cdot {\mathbi{W}}+{\mathbi{b}}$中的公式中的${\mathbi{b}}$相当于对其进行平移变换。其过程如图\ref{fig:9-13} 第二步所示，偏置矩阵$ {\mathbi{b}}=\begin{pmatrix} 0.5 & 0 & 0\\ 0 & 0 & 0\\ 0 & 0 & 0\end{pmatrix} $将矩形区域沿$x$轴向右平移了一段距离。
\vspace{0.5em}
\end{itemize}
%----------------------------------------------
\begin{figure}[htp]
......@@ -726,10 +720,12 @@ x_1\cdot w_1+x_2\cdot w_2+x_3\cdot w_3 & = & 0\cdot 1+0\cdot 1+1\cdot 1 \nonumbe
\label{fig:9-13}
\end{figure}
%-------------------------------------------
\vspace{0.5em}
\end{itemize}
\parinterval 也就是说，线性变换提供了对输入数据进行空间中旋转、平移的能力。当然，线性变换也适用于更加复杂的情况，这也为神经网络提供了拟合不同函数的能力。比如，可以利用线性变换将三维图形投影到二维平面上，或者将二维平面上的图形映射到三维空间。如图\ref{fig:9-14}所示，通过一个简单的线性变换，可以将三维图形投影到二维平面上。
\vspace{-0.5em}
\parinterval 线性变换提供了对输入数据进行空间中旋转、平移的能力。线性变换也适用于更加复杂的情况，这也为神经网络提供了拟合不同函数的能力。比如可以利用线性变换将三维图形投影到二维平面上，或者将二维平面上的图形映射到三维空间。如图\ref{fig:9-14}所示，通过一个简单的线性变换，可以将三维图形投影到二维平面上。
%----------------------------------------------
\begin{figure}[htp]
\centering
......@@ -739,8 +735,7 @@ x_1\cdot w_1+x_2\cdot w_2+x_3\cdot w_3 & = & 0\cdot 1+0\cdot 1+1\cdot 1 \nonumbe
\end{figure}
%-------------------------------------------
\vspace{-0.5em}
\parinterval 那激活函数又是什么？一个神经元在接收到经过线性变换的结果后，通过激活函数的处理，得到最终的输出$ y $。激活函数的目的是解决实际问题中的非线性变换，线性变换只能拟合直线，而激活函数的加入，使神经网络具有了拟合曲线的能力。 特别是在实际问题中，很多现象都无法用简单的线性关系描述，这时可以使用非线性激活函数来描述更加复杂的问题。常见的非线性激活函数有Sigmoid、ReLU、Tanh等。图\ref{fig:9-15}中列举了几种激活函数的形式。
\parinterval 那激活函数又是什么？一个神经元在接收到经过线性变换的结果后，通过激活函数的处理，得到最终的输出$ y $。激活函数的目的是解决实际问题中的非线性变换，线性变换只能拟合直线，而激活函数的加入，使神经网络具有了拟合曲线的能力。 特别是在实际问题中，很多现象都无法用简单的线性关系描述，这时可以使用非线性激活函数来描述更加复杂的问题。常见的非线性激活函数有Sigmoid、ReLU、Tanh等。图\ref{fig:9-15}和\ref{fig:9-15-2}中列举了几种激活函数的形式。
%----------------------------------------------
\begin{figure}[htp]
......@@ -750,6 +745,14 @@ x_1\cdot w_1+x_2\cdot w_2+x_3\cdot w_3 & = & 0\cdot 1+0\cdot 1+1\cdot 1 \nonumbe
\label{fig:9-15}
\end{figure}
%-------------------------------------------
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter9/Figures/figure-activate-2}
\caption{几种常见的激活函数（补）}
\label{fig:9-15-2}
\end{figure}
%-------------------------------------------
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
......@@ -760,6 +763,8 @@ x_1\cdot w_1+x_2\cdot w_2+x_3\cdot w_3 & = & 0\cdot 1+0\cdot 1+1\cdot 1 \nonumbe
\parinterval 单层神经网络由线性变换和激活函数两部分构成，但在实际问题中，单层网络并不能很好地拟合复杂函数。因此很自然地想到将单层网络扩展到多层神经网络，即深层神经网络。将一层神经网络的最终输出向量作为另一层神经网络的输入向量，通过这种方式可以将多个单层神经网络连接在一起。
\parinterval 在多层神经网络中，通常包括输入层、输出层和至少一个隐藏层。图\ref{fig:9-17}展示了一个三层神经网络，包括输入层\footnote{由于输入层不存在神经元，因此在计算神经网络层数时不将其包括在内。}、输出层和两个隐藏层。
%----------------------------------------------
\begin{figure}[htp]
\centering
......@@ -769,8 +774,6 @@ x_1\cdot w_1+x_2\cdot w_2+x_3\cdot w_3 & = & 0\cdot 1+0\cdot 1+1\cdot 1 \nonumbe
\end{figure}
%-------------------------------------------
\parinterval 在多层神经网络中，通常包括输入层、输出层和至少一个隐藏层。图\ref{fig:9-17}展示了一个三层神经网络，包括输入层\footnote{由于输入层不存在神经元，因此在计算神经网络层数时不将其包括在内。}、输出层和两个隐藏层。\\
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
%----------------------------------------------------------------------------------------
......@@ -959,7 +962,6 @@ x_1\cdot w_1+x_2\cdot w_2+x_3\cdot w_3 & = & 0\cdot 1+0\cdot 1+1\cdot 1 \nonumbe
\label{fig:9-27}
\end {figure}
%-------------------------------------------
%----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION
%----------------------------------------------------------------------------------------
......@@ -1019,7 +1021,7 @@ f(x)&=&\begin{cases} 0 & x\le 0 \\x & x>0\end{cases}
\end{figure}
%-------------------------------------------
\parinterval 高阶张量的物理存储方式与多维数组在C++、Python中的物理存储方式相同。
\parinterval 实际上，高阶张量的物理存储方式也与多维数组在C++、Python中的物理存储方式相同。\\
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
......@@ -1107,9 +1109,8 @@ y&=&{\textrm{Sigmoid}}({\textrm{Tanh}}({\mathbi{x}}\cdot {\mathbi{W}}^{[1]}+{\ma
\sectionnewpage
\section{神经网络的参数训练}
\parinterval 简单来说，神经网络可以被看作是由变量和函数组成的表达式，例如：$ {\mathbi{y}}={\mathbi{x}}+{\mathbi{b}} $、$ {\mathbi{y}}={\textrm{ReLU}}({\mathbi{x}}\cdot {\mathbi{W}}+{\mathbi{b}}) $、$ {\mathbi{y}}={\textrm{Sigmoid}}({\textrm{ReLU}}({\mathbi{x}}\cdot {\mathbi{W}}^{[1]}+{\mathbi{b}}^{[1]})\cdot {\mathbi{W}}^{[2]}+{\mathbi{b}}^{[2]}) $等等，其中的$ {\mathbi{x}} $和$ {\mathbi{y}} $作为输入和输出向量， ${\mathbi{W}}$、${\mathbi{b}}$等其他变量作为{\small\sffamily\bfseries{模型参数}}\index{模型参数}（Model Parameters）\index{Model Parameters}。确定了函数表达式和模型参数，也就确定了神经网络模型。通常，表达式的形式需要系统开发者设计，而模型参数的数量有时会非常巨大，因此需要自动学习，这个过程也被称为模型学习或训练。为了实现这个目标，通常会准备一定量的带有标准答案的数据，称之为有标注数据。这些数据会用于对模型参数的学习，这也对应了统计模型中的参数估计过程。在机器学习中，一般把这种使用有标注数据进行统计模型参数训练的过程称为{\small\sffamily\bfseries{有指导的训练}}\index{有指导的训练}或{\small\sffamily\bfseries{有监督的训练}}\index{有监督的训练}（Supervised Training）\index{Supervised Training}。在本章中，如果没有特殊说明，模型训练都是指有监督的训练。那么神经网络内部是怎样利用有标注数据对参数进行训练的呢？\\ \\
\parinterval 简单来说，神经网络可以被看作是由变量和函数组成的表达式，例如：$ {\mathbi{y}}={\mathbi{x}}+{\mathbi{b}} $、$ {\mathbi{y}}={\textrm{ReLU}}({\mathbi{x}}\cdot {\mathbi{W}}+{\mathbi{b}}) $、$ {\mathbi{y}}={\textrm{Sigmoid}}({\textrm{ReLU}}({\mathbi{x}}\cdot {\mathbi{W}}^{[1]}+{\mathbi{b}}^{[1]})\cdot {\mathbi{W}}^{[2]}+{\mathbi{b}}^{[2]}) $等等，其中的$ {\mathbi{x}} $和$ {\mathbi{y}} $作为输入和输出向量， ${\mathbi{W}}$、${\mathbi{b}}$等其他变量作为{\small\sffamily\bfseries{模型参数}}\index{模型参数}（Model Parameters）\index{Model Parameters}。确定了函数表达式和模型参数，也就确定了神经网络模型。通常，表达式的形式需要系统开发者设计，而模型参数的数量有时会非常巨大，因此需要自动学习，这个过程也被称为模型学习或训练。为了实现这个目标，通常会准备一定量的带有标准答案的数据，称之为有标注数据。这些数据会用于对模型参数的学习，这也对应了统计模型中的参数估计过程。在机器学习中，一般把这种使用有标注数据进行统计模型参数训练的过程称为{\small\sffamily\bfseries{有指导的训练}}\index{有指导的训练}或{\small\sffamily\bfseries{有监督的训练}}\index{有监督的训练}（Supervised Training）\index{Supervised Training}。在本章中，如果没有特殊说明，模型训练都是指有监督的训练。那么神经网络内部是怎样利用有标注数据对参数进行训练的呢？
\vspace{-2.5em}
\parinterval 为了回答这个问题，可以把模型参数的学习过程看作是一个优化问题，即找到一组参数，使得模型达到某种最优的状态。这个问题又可以被转化为两个新的问题：
\begin{itemize}
......@@ -1214,7 +1215,6 @@ y&=&{\textrm{Sigmoid}}({\textrm{Tanh}}({\mathbi{x}}\cdot {\mathbi{W}}^{[1]}+{\ma
%
%----------------------------------------------------------------------------------------
\vspace{0.5em}
\noindent {\small\sffamily\bfseries{1）批量梯度下降\index{批量梯度下降}（Batch Gradient Descent）\index{Batch Gradient Descent}}}
\vspace{0.5em}
......@@ -1292,7 +1292,7 @@ J({\bm \theta})&=&\frac{1}{m}\sum_{i=j}^{j+m-1}{L({\mathbi{x}}^{[i]},{\mathbi{y}
\parinterval 截断误差和舍入误差是如何造成的呢？数值微分方法求梯度时，需用极限或无穷过程来求得。然而计算机需要将求解过程化为一系列有限的算术运算和逻辑运算。这样就要对某种无穷过程进行“截断”，即仅保留无穷过程的前段有限序列而舍弃它的后段。这就带来截断误差；舍入误差，是指运算得到的近似值和精确值之间的差异。由于数值微分方法计算复杂函数的梯度问题时，经过无数次的近似，每一次近似都产生了舍入误差，在这样的情况下，误差会随着运算次数增加而积累得很大，最终得出没有意义的运算结果。实际上，截断误差和舍入误差在训练复杂神经网络中，特别是使用低精度计算时，也会出现，因此是实际系统研发中需要注意的问题。
\parinterval 尽管数值微分不适用于大模型中的梯度求解，但是由于其非常简单，因此经常被用于检验其他梯度计算方法的正确性。比如在实现反向传播的时候（详见\ref{sec:9.4.6}节），可以检验求导是否正确（Gradient Check），这个过程就是利用数值微分实现的。\\ \\
\parinterval 尽管数值微分不适用于大模型中的梯度求解，但是由于其非常简单，因此经常被用于检验其他梯度计算方法的正确性。比如在实现反向传播的时候（详见\ref{sec:9.4.6}节），可以检验求导是否正确（Gradient Check），这个过程就是利用数值微分实现的。
%----------------------------------------------------------------------------------------
%
......@@ -1342,7 +1342,6 @@ $+2x^2+x+1)$ & \ \ $(x^4+2x^3+2x^2+x+1)$ & $+6x+1$ \\
\parinterval 由于它只对基本函数或常数运用符号微分法则，所以它非常适合嵌入编程语言的循环条件等结构中，形成一种程序化的微分过程。在具体实现时，自动微分往往被当做是一种基于图的计算，相关的理论和技术方法相对成熟，因此是深度学习中使用最广泛的一种方法。不同于一般的编程模式，图计算先生成计算图，然后按照计算图执行计算过程。
\parinterval 自动微分可以用一种{\small\sffamily\bfseries{反向模式}}\index{反向模式}（Reverse Mode\index{Reverse Mode}/Backward Mode\index{Backward Mode}）即反向传播思想进行描述\upcite{baydin2017automatic}。令${\mathbi{h}}_i$是神经网络的计算图中第$i$个节点的输出。反向模式的自动微分是要计算：
\begin{eqnarray}
\bar{{\mathbi{h}}_i} &=& \frac{\partial L}{\partial {\mathbi{h}}_i} \label{eq:reverse-mode-v}
\end{eqnarray}
......@@ -1501,6 +1500,15 @@ z_t&=&\gamma z_{t-1}+(1-\gamma) \frac{\partial J}{\partial {\theta}_t} \cdot \f
\parinterval 当神经网络较为复杂时，模型训练还是需要几天甚至几周的时间。如果希望尽可能缩短一次学习所需的时间，最直接的想法就是把不同的训练样本分配给多个GPU 或CPU，然后在这些设备上同时进行训练，即实现并行化训练。这种方法也被称作{\small\sffamily\bfseries{数据并行}}\index{数据并行}。具体实现时，有两种常用的并行化策略：（参数）同步更新和（参数）异步更新。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter9/Figures/figure-parallel}
\caption{同步更新与异步更新对比}
\label{fig:9-47}
\end {figure}
%-------------------------------------------
\begin{itemize}
\vspace{0.5em}
\item {\small\sffamily\bfseries{同步更新}}\index{同步更新}（Synchronous Update）\index{Synchronous Update}是指所有计算设备完成计算后，统一汇总并更新参数。当所有设备的反向传播算法完成之后同步更新参数，不会出现单个设备单独对参数进行更新的情况。这种方法效果稳定，但是效率比较低，在同步更新时，每一次参数更新都需要所有设备统一开始、统一结束，如果设备的运行速度不一致，那么每一次参数更新都需要等待最慢的设备结束才能开始。
......@@ -1513,16 +1521,6 @@ z_t&=&\gamma z_{t-1}+(1-\gamma) \frac{\partial J}{\partial {\theta}_t} \cdot \f
\parinterval 此外，在使用多个设备进行并行训练的时候，由于设备间带宽的限制，大量的数据传输会有较高的延时。对于复杂神经网络来说，设备间参数和梯度传递的时间消耗也会成为一个不得不考虑的因素。有时候，设备间数据传输的时间甚至比模型计算的时间都长，大大降低了并行度\upcite{xiao2017fast}。对于这种问题，可以考虑对数据进行压缩或者减少传输的次数来缓解问题。
%----------------------------------------------
\begin{figure}[htp]
\centering
\input{./Chapter9/Figures/figure-parallel}
\caption{同步更新与异步更新对比}
\label{fig:9-47}
\end {figure}
%-------------------------------------------
%----------------------------------------------------------------------------------------
% NEW SUB-SECTION
%----------------------------------------------------------------------------------------
......@@ -1569,12 +1567,19 @@ z_t&=&\gamma z_{t-1}+(1-\gamma) \frac{\partial J}{\partial {\theta}_t} \cdot \f
\item {\small\bfnew{层标准化}}\index{层标准化}（Layer Normalization）\index{Layer Normalization}。类似的，层标准化更多是针对自然语言处理这种序列处理任务\upcite{Ba2016LayerN}，它和批量标准化的原理是一样的，只是标准化操作是在序列上同一层网络的输出结果上进行的，也就是标准化操作沿着序列方向进行。这种方法可以很好的避免序列上不同位置神经网络输出结果的不可比性。同时由于标准化后所有的结果都转化到一个可比的范围，使得隐层状态可以在不同层之间进行自由组合。
\item {\small\bfnew{残差网络}}\index{残差网络}（Residual Networks）\index{Residual Networks}。最初，残差网络是为了解决神经网络持续加深时的模型退化问题\upcite{DBLP:journals/corr/HeZRS15}，但是残差结构对解决梯度消失和梯度爆炸问题也有所帮助。有了残差结构，可以很轻松的构建几十甚至上百层的神经网络，而不用担心层数过深造成的梯度消失问题。残差网络的结构如图\ref{fig:9-51}所示。图\ref{fig:9-51}中右侧的曲线叫做{\small\bfnew{跳接}}\index{跳接}（Skip Connection）\index{Skip Connection}，通过跳接在激活函数前，将上一层（或几层）之前的输出与本层计算的输出相加，将求和的结果输入到激活函数中作为本层的输出。假设残差结构的输入为$ {\mathbi{x}}_l $，输出为$ {\mathbi{x}}_{l+1} $，则有
\begin{eqnarray}
{\mathbi{x}}_{l+1}&=&F({\mathbi{x}}_l)+{\mathbi{x}}_l
\label{eq:9-44}
\end{eqnarray}
相比较于简单的多层堆叠的结构，残差网络提供了跨层连接结构。这种结构在反向传播中有很大的好处，比如，对于一个训练样本，损失函数为$L$，$ \mathbi x_l $处的梯度的计算方式如公式\eqref{eq:9-45}所示。残差网络可以将后一层的梯度$ \frac{\partial L}{\partial {\mathbi{x}}_{l+1}} $不经过任何乘法项直接传递到$ \frac{\partial L}{\partial {\mathbi{x}}_l} $，从而缓解了梯度经过每一层后多次累乘造成的梯度消失问题。在{\chaptertwelve}中还会看到，在机器翻译中残差结构可以和层标准化一起使用，而且这种组合可以取得很好的效果。
\begin{eqnarray}
\frac{\partial L}{\partial {\mathbi{x}}_l}&=&\frac{\partial L}{\partial {\mathbi{x}}_{l+1}} \cdot \frac{\partial {\mathbi{x}}_{l+1}}{\partial {\mathbi{x}}_l}\nonumber\\
&=&\frac{\partial L}{\partial {\mathbi{x}}_{l+1}} \cdot \left(1+\frac{\partial F({\mathbi{x}}_l)}{\partial {\mathbi{x}}_l}\right)\nonumber\\
&=&\frac{\partial L}{\partial {\mathbi{x}}_{l+1}}+\frac{\partial L}{\partial {\mathbi{x}}_{l+1}} \cdot \frac{\partial F({\mathbi{x}}_l)}{\partial {\mathbi{x}}_l}
\label{eq:9-45}
\end{eqnarray}
%----------------------------------------------
\begin{figure}[htp]
......@@ -1584,17 +1589,6 @@ z_t&=&\gamma z_{t-1}+(1-\gamma) \frac{\partial J}{\partial {\theta}_t} \cdot \f
\label{fig:9-51}
\end{figure}
%-------------------------------------------
相比较于简单的多层堆叠的结构，残差网络提供了跨层连接结构。这种结构在反向传播中有很大的好处，比如，对于一个训练样本，损失函数为$L$，$ \mathbi x_l $处的梯度可以进行如下计算：
\begin{eqnarray}
\frac{\partial L}{\partial {\mathbi{x}}_l}&=&\frac{\partial L}{\partial {\mathbi{x}}_{l+1}} \cdot \frac{\partial {\mathbi{x}}_{l+1}}{\partial {\mathbi{x}}_l}\nonumber\\
&=&\frac{\partial L}{\partial {\mathbi{x}}_{l+1}} \cdot \left(1+\frac{\partial F({\mathbi{x}}_l)}{\partial {\mathbi{x}}_l}\right)\nonumber\\
&=&\frac{\partial L}{\partial {\mathbi{x}}_{l+1}}+\frac{\partial L}{\partial {\mathbi{x}}_{l+1}} \cdot \frac{\partial F({\mathbi{x}}_l)}{\partial {\mathbi{x}}_l}
\label{eq:9-45}
\end{eqnarray}
由上式可知，残差网络可以将后一层的梯度$ \frac{\partial L}{\partial {\mathbi{x}}_{l+1}} $不经过任何乘法项直接传递到$ \frac{\partial L}{\partial {\mathbi{x}}_l} $，从而缓解了梯度经过每一层后多次累乘造成的梯度消失问题。在{\chaptertwelve}中还会看到，在机器翻译中残差结构可以和层标准化一起使用，而且这种组合可以取得很好的效果。
\end{itemize}
%----------------------------------------------------------------------------------------
......@@ -1603,11 +1597,11 @@ z_t&=&\gamma z_{t-1}+(1-\gamma) \frac{\partial J}{\partial {\theta}_t} \cdot \f
\subsection{过拟合}\label{sec:9.4.5}
\parinterval 理想中，我们总是希望尽可能地拟合输入和输出之间的函数关系，即让模型尽量模拟训练数据的中由输入预测答案的行为。然而，在实际应用中，模型在训练数据上的表现不一定代表了其在未见数据上的表现。如果模型训练过程中过度拟合训练数据，最终可能无法对未见数据做出准确的判断，这种现象叫做{\small\sffamily\bfseries{过拟合}}\index{过拟合}（Overfitting）\index{Overfitting}。随着模型复杂度增加，特别在神经网络变得更深、更宽时，过拟合问题会表现得更为突出。如果训练数据量较小，而模型又很复杂，可以“完美”地拟合这些数据，这时过拟合也很容易发生。所以在模型训练时，往往不希望去完美拟合训练数据中的每一个样本。
\parinterval 理想中，我们总是希望尽可能地拟合输入和输出之间的函数关系，即让模型尽量模拟训练数据中由输入预测答案的行为。然而，在实际应用中，模型在训练数据上的表现不一定代表了其在未见数据上的表现。如果模型训练过程中过度拟合训练数据，最终可能无法对未见数据做出准确的判断，这种现象叫做{\small\sffamily\bfseries{过拟合}}\index{过拟合}（Overfitting）\index{Overfitting}。随着模型复杂度增加，特别在神经网络变得更深、更宽时，过拟合问题会表现得更为突出。如果训练数据量较小，而模型又很复杂，可以“完美”地拟合这些数据，这时过拟合也很容易发生。所以在模型训练时，往往不希望去完美拟合训练数据中的每一个样本。
\parinterval {\small\sffamily\bfseries{正则化}}\index{正则化}（Regularization）\index{Regularization}是常见的缓解过拟合问题的手段，通过在损失函数中加上用来刻画模型复杂程度的正则项来惩罚过度复杂的模型，从而避免神经网络过度学习造成过拟合。引入正则化处理之后目标函数变为$ J({\bm \theta})+\lambda R({\bm \theta}) $，其中$ J({\bm \theta}) $是原来的代价函数，$ R({\bm \theta}) $即为正则项，$ \lambda $用来调节正则项对结果影响的程度。
\parinterval 过拟合的模型通常会表现为部分非零参数过多或者参数的值过大。这种参数产生的原因在于模型需要复杂的参数才能匹配样本中的个别现象甚至噪声。基于此，常见的正则化方法有L1正则化和L2正则化，其命名方式是由$ R({\bm \theta}) $的计算形式来决定的。在L1正则化中，$ R({\bm \theta}) $即为参数$ {\bm \theta} $的$ l_1 $范数，即$ R({\bm \theta}) ={\Vert {\bm \theta}\Vert}_1=\sum\limits_{i=1}^{n}{\vert \theta_i\vert} $；在L2正则化中，$ R(\bm \theta) $即为参数${\bm \theta} $的$ l_2 $范数的平方，即$ R(\bm \theta) =({\Vert {\bm \theta}\Vert}_2)^2=\sum\limits_{i=1}^{n}{\theta_i^2} $。L1正则化中的正则项衡量了模型权数中的绝对值大小，倾向于生成值为0的参数，从而让参数变得更加稀疏；而L2正则化由于平方的加入，当参数中的某一项小到一定程度，比如0.001的时候，参数的平方结果已经可以忽略不计了，因此L2正则化会倾向生成很小的参数，在这种情况下，即便训练数据中含有少量随机噪音，模型也不太容易通过增加个别参数的值来对噪声进行过度拟合，即提高了模型的抗扰动能力。
\parinterval 过拟合的模型通常会表现为部分非零参数过多或者参数的值过大。这种参数产生的原因在于模型需要复杂的参数才能匹配样本中的个别现象甚至噪声。基于此，常见的正则化方法有L1正则化和L2正则化，其命名方式是由$ R({\bm \theta}) $的计算形式来决定的。在L1正则化中，$ R({\bm \theta}) $即为参数$ {\bm \theta} $的$ l_1 $范数，即$ R({\bm \theta}) ={\Vert {\bm \theta}\Vert}_1=\sum\limits_{i=1}^{n}{\vert \theta_i\vert} $；在L2正则化中，$ R(\bm \theta) $即为参数${\bm \theta} $的$ l_2 $范数的平方，即$ R(\bm \theta) =({\Vert {\bm \theta}\Vert}_2)^2=\sum\limits_{i=1}^{n}{\theta_i^2} $。L1正则化中的正则项衡量了模型中参数的绝对值大小，倾向于生成值为0的参数，从而让参数变得更加稀疏；而L2正则化由于平方的加入，当参数中的某一项小到一定程度，比如0.001的时候，参数的平方结果已经可以忽略不计了，因此L2正则化会倾向生成很小的参数，在这种情况下，即便训练数据中含有少量随机噪音，模型也不太容易通过增加个别参数的值来对噪声进行过度拟合，即提高了模型的抗扰动能力。
\parinterval 此外，在{\chaptertwelve}即将介绍的Dropout和标签平滑方法也可以被看作是一种正则化操作。它们都可以提高模型在未见数据上的泛化能力。
......@@ -1884,7 +1878,8 @@ z_t&=&\gamma z_{t-1}+(1-\gamma) \frac{\partial J}{\partial {\theta}_t} \cdot \f
\subsubsection{1. 模型结构}
\parinterval 最具代表性的神经语言模型是{\small\sffamily\bfseries{前馈神经网络语言模型}}\index{前馈神经网络语言模型}（Feed-forward Neural Network Language Model，FNNLM\index{FNNLM}）。这种语言模型的目标是用神经网络计算$ \funp{P}(w_m|w_{m-n+1}\dots w_{m-1}) $，之后将多个$n$-gram的概率相乘得到整个序列的概率\upcite{bengio2003a}。
\parinterval 最具代表性的神经语言模型是{\small\sffamily\bfseries{前馈神经网络语言模型}}\index{前馈神经网络语言模型}（Feed-forward Neural Network Language Model，FNNLM\index{FNNLM}）。这种语言模型的目标是用神经网络计算$ \funp{P}(w_m|w_{m-n+1}
\\\dots w_{m-1}) $，之后将多个$n$-gram的概率相乘得到整个序列的概率\upcite{bengio2003a}。
%----------------------------------------------
\begin{figure}[htp]
......@@ -1930,7 +1925,6 @@ z_t&=&\gamma z_{t-1}+(1-\gamma) \frac{\partial J}{\partial {\theta}_t} \cdot \f
\subsubsection{3. 隐藏层和输出层}
\parinterval 把得到的$ {\mathbi{e}}_0 $、$ {\mathbi{e}}_1 $、$ {\mathbi{e}}_2 $三个向量级联在一起，经过两层网络，最后通过Softmax函数（橙色方框）得到输出，具体过程为：
\begin{eqnarray}
{\mathbi{y}}&=&{\textrm{Softmax}}({\mathbi{h}}_0{\mathbi{U}})\label{eq:9-61}\\
{\mathbi{h}}_0&=&{\textrm{Tanh}}([{\mathbi{e}}_{i-3},{\mathbi{e}}_{i-2},{\mathbi{e}}_{i-1}]{\mathbi{H}}+{\mathbi{d}})
......@@ -1940,7 +1934,6 @@ z_t&=&\gamma z_{t-1}+(1-\gamma) \frac{\partial J}{\partial {\theta}_t} \cdot \f
\noindent 这里，输出$ {\mathbi{y}}$是词表$V$上的一个分布，来表示$\funp{P}(w_i|w_{i-1},w_{i-2},w_{i-3}) $。$ {\mathbi{U}}$、${\mathbi{H}}$和${\mathbi{d}}$是模型的参数。这样，对于给定的单词$w_i$可以用$y_i$得到其概率，其中$y_i$表示向量${\mathbi{y}}$的第$i$维。
\parinterval Softmax($\cdot$)的作用是根据输入的$|V|$维向量（即${\mathbi{h}}_0{\mathbi{U}}$），得到一个$|V|$维的分布。令${\bm \tau}$表示Softmax($\cdot$)的输入向量，Softmax函数可以被定义为：
\begin{eqnarray}
\textrm{Softmax}(\tau_i)&=&\frac{\textrm{exp}(\tau_i)} {\sum_{i'=1}^{|V|} \textrm{exp}(\tau_{i'})}
\label{eq:9-120}
......
ChapterAcknowledgement/acknowledgement.tex
......@@ -28,17 +28,25 @@
\begin{center}
{\Huge \bfnew{后\ \ \ 记}}
\end{center}
\vspace{2em}
\vspace{5em}
\begin{spacing}{1.18}
\parinterval 我知道这里本应该再写点儿什么，感慨一下蹉跎岁月，最后致敬所有人。
\parinterval 我知道这里本应该再写点什么，感慨一下蹉跎岁月，最后致敬所有人。
\parinterval 不过我还是最想说：谢谢你，我的妻子。没有你的支持与照顾，我应该没有勇气来完成这本书。爱你 $\sim$
\vspace{1em}
\parinterval 不过我还是最想说：
\vspace{1em}
\parinterval 谢谢你，我的妻子。没有你的支持与照顾，我应该没有勇气来完成这本书。爱你 $\sim$
\vspace{8em}
\hfill 肖桐
\hfill 2020.12.27
\end{spacing}
\ No newline at end of file
\end{spacing}
ChapterPostscript/postscript.tex
......@@ -42,12 +42,12 @@
\begin{itemize}
\item 从数据角度来看，大部分语言对的电子化双语句对集合规模非常小，有的甚至只有一个小规模双语词典。因此，针对资源稀缺语种的机器翻译技术研究也成了学术界的研究热点，相信这个课题的突破能大大推动机器翻译技术落地。早些年，机器翻译市场的规模较小，其主要原因是数据规模有限，同时机器翻译的品质不够理想。就算采用最先进的神经机器翻译技术，在缺乏足够大规模的双语句对集合作为训练数据的情况下，研究人员也是巧妇难为无米之炊。从技术研究和应用可行性的角度看，解决资源稀缺语种的机器翻译问题非常有价值。解决资源稀缺语种机器翻译问题的思路，已经在{\chaptersixteen}进行了详细的介绍，本部分就不再赘述。
\item 从机器翻译技术来看，可实用的机器翻译系统的构建，需要多技术互补融合。做研究可以搞单点突破，但它很难能应对实际问题和改善真实应用中的翻译品质。多技术互补融合有很多研究工作，比如说，有的业内研究人员提出采用知识图谱来改善机器翻译模型性能，并希望用于解决稀缺资源语种机器翻译问题；有的引入语言分析技术来改善机器翻译；有的将基于规则的方法、统计机器翻译技术与神经机器翻译技术互补性融合；有的引入预训练技术来改善机器翻译品质等等。总体来说，这些思路都具有良好的研究价值，但是从应用角度来说，构建可实用的机器翻译系统，还需要考虑技术落地可行性。比如大规模知识图谱构建的代价和语言分析技术的精度如何，预训练技术对机器翻译帮助的上限等。
\item 从机器翻译技术来看，可实用的机器翻译系统的构建，需要多技术互补融合。做研究可以搞单点突破，但它很难能应对实际问题和改善真实应用中的翻译品质。多技术互补融合有很多研究工作，比如说，有的业内研究人员提出采用知识图谱来改善机器翻译模型性能，并希望用于解决稀缺资源语种机器翻译问题；有的引入语言分析技术来改善机器翻译；有的将基于规则的方法、统计机器翻译技术与神经机器翻译技术互补性融合；有的引入预训练技术来改善机器翻译品质等等。总体来说，这些思路都具有良好的研究价值，但是从应用角度来说，构建可实用的机器翻译系统，还需要考虑技术落地可行性。比如大规模知识图谱构建的代价和语言分析技术的精度如何，预训练技术对富资源场景下机器翻译的价值等。
\item 错误驱动，即根据用户对机器翻译译文的反馈与纠正，完善机器翻译模型的过程。机器翻译一直被诟病：用户不知道如何有效地干预纠错，来帮助机器翻译系统越做越好，毕竟谁都不希望它“屡教不改”。基于规则的方法和统计机器翻译方法相对容易实现人工干预纠错，实现手段也比较丰富，而神经机器翻译方法存在不可解释性，难以有效地实现人工干预纠错。目前，有研究人员通过引入外部知识库（用户双语术语库）来实现对未登录词翻译的干预纠错；也有的提出使用增量式训练的方法不断迭代优化模型，取得了一些进展；还有研究人员通过融合不同技术来实现更好的机器翻译效果，如引入基于规则的翻译前处理和后处理，或者引入统计机器翻译技术优化译文选择等。这些方法的代价不低，甚至很高， 并且无法保障对机器翻译性能提升的效果，有时可能会降低翻译品质（有点像“跷跷板”现象）。总体来说，这个方向的研究成果还不够丰富，但对用户体验来说非常重要。如果能采用隐性反馈学习方法，在用户不知不觉中不断改善、优化机器翻译品质，就非常酷了，这也许会成为将来的一个研究热点。
\item 错误驱动，即根据用户对机器翻译译文的反馈与纠正，完善机器翻译模型的过程。机器翻译一直被诟病：用户不知道如何有效地干预纠错，来帮助机器翻译系统越做越好，毕竟谁都不希望它“屡教不改”。基于规则的方法和统计机器翻译方法相对容易实现人工干预纠错，实现手段也比较丰富，而神经机器翻译方法很多时候被看做是黑箱，其运行机理与离散的符号系统有很大差别，难以用传统方式有效地实现人工干预纠错。目前，有研究人员通过引入外部知识库（用户双语术语库）来实现对未登录词翻译的干预纠错；也有的提出使用增量式训练的方法不断迭代优化模型，取得了一些进展；还有研究人员通过融合不同技术来实现更好的机器翻译效果，如引入基于规则的翻译前处理和后处理，或者引入统计机器翻译技术优化译文选择等。这些方法的代价不低，甚至很高， 并且无法保障对机器翻译性能提升的效果，有时可能会降低翻译品质（有点像“跷跷板”现象）。总体来说，这个方向的研究成果还不够丰富，但对用户体验来说非常重要。如果能采用隐性反馈学习方法，在用户不知不觉中不断改善、优化机器翻译品质，就非常酷了，这也许会成为将来的一个研究热点。
\end{itemize}
\parinterval 除了翻译品质维度以外，机器翻译还可以从以下三个维度来讨论：语种维度、领域维度和应用模式维度。关于语种维度，机器翻译技术应该为全球用户服务，提供所有国家至少一种官方语言到其他国家语言的自动互译功能。该维度面临的最大问题是双语数据稀缺。关于领域维度，通用领域翻译系统的翻译能力，对于垂直领域数据来说是不足的。最典型的问题是不能恰当地翻译垂直领域术语，计算机不能无中生有。比较直接可行的解决方案至少有两个，一是引入垂直领域术语双语词典来改善机器翻译效果；二是收集加工一定规模的垂直领域双语句对来优化翻译模型。这两种工程方法虽然简单，但效果不错，并且两者结合对于翻译模型性能的提升帮助更大。但很多时候垂直领域双语句对的收集代价太高，可行性低，因此垂直领域翻译问题本质上就转换成为垂直领域资源稀缺问题和领域自适应学习问题。除此之外，小样本学习、迁移学习和联合学习等机器学习技术也被一些研究人员用来解决垂直领域翻译问题。关于应用模式维度，可以从下面几个方面进行讨论：
\parinterval 除了翻译品质维度以外，机器翻译还可以从以下三个维度来讨论：语种维度、领域维度和应用模式维度。关于语种维度，机器翻译技术应该为全球用户服务，提供所有国家至少一种官方语言到其他国家语言的自动互译功能。该维度面临的最大问题是双语数据稀缺。关于领域维度，通用领域翻译系统的翻译能力，对于垂直领域数据来说是不足的。最典型的问题是不能恰当地翻译垂直领域术语，计算机不能无中生有。比较直接可行的解决方案至少有两个，一是引入垂直领域术语双语词典来改善机器翻译效果；二是收集加工一定规模的垂直领域双语句对来优化翻译模型。这两种工程方法虽然简单，但效果不错，并且两者结合对于翻译模型性能的提升帮助更大。但很多时候垂直领域双语句对的收集代价太高，可行性低，因此垂直领域翻译问题本质上就转换成为垂直领域资源稀缺问题和领域自适应学习问题。除此之外，小样本学习、迁移学习等机器学习技术也被一些研究人员用来解决垂直领域翻译问题。关于应用模式维度，可以从下面几个方面进行讨论：
\begin{itemize}
\item 通常，机器翻译的典型应用包括在线翻译公有云服务，用户接入非常简单，只需要联网使用浏览器就可以自由免费使用。在某些行业，用户对数据翻译安全性和保密性的要求非常高，其中可能还会涉及个性化定制，这是在线翻译公有云服务无法满足的，于是，在本地部署机器翻译私有云、离线机器翻译技术和服务成了新的应用模式。在本地部署私有云的问题在于：需要用户自己购买 GPU 服务器并建机房，对硬件的投入高。也许将来机器翻译领域会出现新的应用模式：类似服务托管模式的在线私有云或专有云，以及混合云服务（公有云、私有云和专有云的混合体）。
......@@ -70,11 +70,15 @@
\parinterval 从历史发展观的维度考虑，新一代的技术必然存在，换句话说，第四代机器翻译技术一定会出现，只是不知道在什么时候而已。神经机器翻译的红利还没有被挖尽，还存在很好的发展空间，在可预期的将来，神经机器翻译技术还属于主流技术，但会产生大量变种。我们愿意把新一代机器翻译技术称为面向具体应用场景的第四代机器翻译技术，它在本质上是针对不同应用条件、不同应用场景提出的能力更强的机器翻译技术。它将不是一个简单的技术，而是一个技术集合，这是完全可能的。从另一方面讲，当前的机器翻译不具有很好的解释性，其与语言学的关系并不明确。那么在第四代机器翻译技术中，是否能让研究人员或使用者更方便地了解它的工作原理，并可以根据其原理对其进行干预。甚至，我们还可以研究更合理的面向机器翻译解释性的方法，笔者相信这也是未来需要突破的点。
\parinterval 最后，简单谈谈笔者对机器翻译市场发展趋势的看法。机器翻译本身是个强刚需，用于解决全球用户多语言交流障碍的问题。机器翻译产业真正热起来，应该归功于神经机器翻译技术的应用，虽然基于规则的方法和统计机器翻译技术也在工业界得到了应用，但翻译品质没有达到用户预期，用户付费欲望比较差，没有良好的商业变 现能力，导致机器翻译产业在 2017 年以前类似于“鸡肋”产业。严格来说，从2016 年下半年开始，神经机器翻译技术在工业界的广泛应用快速激活了用户需求，用户对机器翻译的认可度急剧上升，越来越丰富的应用模式和需求被挖掘出来。除了传统计算机辅助翻译，语音和OCR 与机器翻译技术结合，使得语音翻译 APP、翻译机、翻译笔、会议AI 同传和垂直行业（专利、医药、旅游等）的机器翻译解决方案逐渐得到了广泛应用。总体来说，机器翻译产学研正处于快速上升期，每年市场规模达到至少$100\% $增长。随着多模态机器翻译和大数据翻译技术的应用，机器翻译的应用场景会越来越丰富。随着5G ，甚至 6G 技术的发展，视频翻译和电话通信翻译等应用会进一步爆发。另外，随着人工智能芯片领域的发展，机器翻译芯片也会逐渐被广泛应用，如嵌入到手机、打印机、复印机、传真机和电视机等智能终端设备中，实现所有内容皆可翻译，任何场景皆可运行的愿景。机器翻译服务将进入人们的日常生活，无处不在，让生活更加美好！\\
\parinterval 最后，简单谈谈笔者对机器翻译市场发展趋势的看法。机器翻译本身是个强刚需，用于解决全球用户多语言交流障碍的问题。机器翻译产业真正热起来，应该归功于神经机器翻译技术的应用，虽然基于规则的方法和统计机器翻译技术也在工业界得到了应用，但翻译品质没有达到用户预期，用户付费欲望比较差，没有良好的商业变 现能力，导致机器翻译产业在早些年有些“鸡肋”。严格来说，近些年神经机器翻译技术在工业界的广泛应用快速激活了用户需求，用户对机器翻译的认可度急剧上升，越来越丰富的应用模式和需求被挖掘出来。除了传统计算机辅助翻译，语音和OCR 与机器翻译技术结合，使得语音翻译 APP、翻译机、翻译笔、会议AI 同传和垂直行业（专利、医药、旅游等）的机器翻译解决方案逐渐得到了广泛应用。总体来说，机器翻译产学研正处于快速上升期，市场规模每年都会有显著增长。随着多模态机器翻译和大数据翻译技术的应用，机器翻译的应用场景会越来越丰富。随着5G ，甚至 6G 技术的发展，视频翻译和电话通信翻译等应用会进一步爆发。另外，随着人工智能芯片领域的发展，机器翻译芯片也会逐渐被广泛应用，如嵌入到手机、打印机、复印机、传真机和电视机等智能终端设备中，实现所有内容皆可翻译，任何场景皆可运行的愿景。机器翻译服务将进入人们的日常生活，无处不在，让生活更加美好！\\
\vspace{8em}
\hfill 朱靖波 \ \ 肖桐
\hfill 2020.12.16
\hfill 于东北大学
\end{spacing}
ChapterPreface/chapterpreface.tex
......@@ -50,7 +50,7 @@
本书可以供计算机相关专业高年级本科生及研究生学习之用，也可以作为自然语言处理领域，特别是机器翻译方向相关研究人员的参考资料。此外，本书各章主题明确，内容紧凑。因此，读者也可将每章作为某一专题的学习资料。
{\sffamily\bfseries 用最简单的方式阐述机器翻译的基本思想}是笔者所期望达到的目标。但是，书中不可避免会使用一些形式化定义和算法的抽象描述，因此，笔者尽所能通过图例进行解释（本书共XXX张插图）。不过，本书所包含的内容较为广泛，难免会有疏漏，望读者海涵，并指出不当之处。
{\sffamily\bfseries 用最简单的方式阐述机器翻译的基本思想}是笔者所期望达到的目标。但是，书中不可避免会使用一些形式化定义和算法的抽象描述，因此，笔者尽所能通过图例进行解释（本书共396张插图）。不过，本书所包含的内容较为广泛，难免会有疏漏，望读者海涵，并指出不当之处。
\vspace{1.0em}
......
bibliography.bib
......@@ -487,7 +487,7 @@ new
@inproceedings{katz1987estimation,
title={Estimation of probabilities from sparse data for the language model component of a speech recognizer},
author={S. {Katz}},
publisher={IEEE Transactions on Acoustics, Speech, and Signal Processing},
publisher={International Conference on Acoustics, Speech and Signal Processing},
volume={35},
number={3},
pages={400--401},
......@@ -4890,7 +4890,7 @@ author = {Yoshua Bengio and
@inproceedings{Waibel1989PhonemeRU,
title={Phoneme recognition using time-delay neural networks},
author={Alexander Waibel and Toshiyuki Hanazawa and Geoffrey Hinton and Kiyohiro Shikano and Kevin J. Lang},
publisher={IEEE Transactions on Acoustics, Speech, and Signal Processing},
publisher={International Conference on Acoustics, Speech and Signal Processing},
year={1989},
volume={37},
pages={328-339}
......@@ -5061,7 +5061,7 @@ author = {Yoshua Bengio and
@inproceedings{Bengio2013AdvancesIO,
title={Advances in optimizing recurrent networks},
author={Yoshua Bengio and Nicolas Boulanger-Lewandowski and Razvan Pascanu},
publisher={IEEE Transactions on Acoustics, Speech, and Signal Processing},
publisher={International Conference on Acoustics, Speech and Signal Processing},
year={2013},
pages={8624-8628}
}
......@@ -9345,6 +9345,16 @@ author = {Zhuang Liu and
publisher={arXiv preprint arXiv:2002.11794},
year={2020}
}
@inproceedings{DBLP:conf/emnlp/HuangLXX20,
author = {Zhiheng Huang and
Davis Liang and
Peng Xu and
Bing Xiang},
title = {Improve Transformer Models with Better Relative Position Embeddings},
pages = {3327--3335},
publisher = {Conference on Empirical Methods in Natural Language Processing},
year = {2020}
}
%%%%% chapter 15------------------------------------------------------
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
......@@ -11659,7 +11669,7 @@ author = {Zhuang Liu and
@inproceedings{foster2010translating,
title={Translating structured documents},
author={Foster, George and Isabelle, Pierre and Kuhn, Roland},
booktitle={Proceedings of AMTA},
publisher={Proceedings of AMTA},
year={2010}
}
@inproceedings{DBLP:conf/eacl/LouisW14,
......@@ -11738,7 +11748,7 @@ author = {Zhuang Liu and
title = {Multilingual Annotation and Disambiguation of Discourse Connectives
for Machine Translation},
pages = {194--203},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Annual Meeting of the Special Interest Group on Discourse and Dialogue},
year = {2011}
}
@inproceedings{DBLP:conf/hytra/MeyerP12,
......@@ -11747,7 +11757,7 @@ author = {Zhuang Liu and
title = {Using Sense-labeled Discourse Connectives for Statistical Machine
Translation},
pages = {129--138},
publisher = {Annual Conference of the European Association for Machine Translation},
publisher = {Hybrid Approaches to Machine Translation},
year = {2012}
}
@inproceedings{DBLP:conf/emnlp/LaubliS018,
......@@ -11774,7 +11784,7 @@ author = {Zhuang Liu and
Yves Scherrer},
title = {Neural Machine Translation with Extended Context},
pages = {82--92},
publisher = {Association for Computational Linguistics},
publisher = {Proceedings of the Third Workshop on Discourse in Machine Translation},
year = {2017}
}
@inproceedings{DBLP:journals/corr/abs-1910-07481,
......@@ -11819,7 +11829,7 @@ author = {Zhuang Liu and
Cristina Espa{\~{n}}a-Bonet},
title = {Context-Aware Neural Machine Translation Decoding},
pages = {13--23},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Proceedings of the Fourth Workshop on Discourse in Machine Translation},
year = {2019}
}
@inproceedings{DBLP:journals/corr/abs-2010-12827,
......@@ -11856,7 +11866,7 @@ author = {Zhuang Liu and
title = {Validation of an Automatic Metric for the Accuracy of Pronoun Translation
{(APT)}},
pages = {17--25},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Proceedings of the Third Workshop on Discourse in Machine Translation},
year = {2017}
}
@inproceedings{DBLP:conf/emnlp/WongK12,
......@@ -11875,7 +11885,7 @@ author = {Zhuang Liu and
title = {Document-Level Machine Translation Evaluation with Gist Consistency
and Text Cohesion},
pages = {33--40},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Proceedings of the Second Workshop on Discourse in Machine Translation},
year = {2015}
}
@inproceedings{DBLP:conf/cicling/HajlaouiP13,
......@@ -11894,7 +11904,7 @@ author = {Zhuang Liu and
Rico Sennrich},
title = {The Word Sense Disambiguation Test Suite at {WMT18}},
pages = {588--596},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Conference on Empirical Methods in Natural Language Processing},
year = {2018}
}
@inproceedings{DBLP:conf/naacl/BawdenSBH18,
......@@ -11915,13 +11925,13 @@ author = {Zhuang Liu and
title = {A Large-Scale Test Set for the Evaluation of Context-Aware Pronoun
Translation in Neural Machine Translation},
pages = {61--72},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Conference on Empirical Methods in Natural Language Processing},
year = {2018}
}
@inproceedings{agrawal2018contextual,
title={Contextual handling in neural machine translation: Look behind, ahead and on both sides},
author={Agrawal, Ruchit Rajeshkumar and Turchi, Marco and Negri, Matteo},
booktitle={Annual Conference of the European Association for Machine Translation},
publisher={Annual Conference of the European Association for Machine Translation},
pages={11--20},
year={2018}
}
......@@ -11986,7 +11996,7 @@ author = {Zhuang Liu and
title = {Analysing concatenation approaches to document-level {NMT} in two
different domains},
pages = {51--61},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Proceedings of the Fourth Workshop on Discourse in Machine Translation},
year = {2019}
}
@inproceedings{DBLP:conf/wmt/GonzalesMS17,
......@@ -12005,7 +12015,7 @@ author = {Zhuang Liu and
Hermann Ney},
title = {When and Why is Document-level Context Useful in Neural Machine Translation?},
pages = {24--34},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Proceedings of the Fourth Workshop on Discourse in Machine Translation},
year = {2019}
}
@inproceedings{DBLP:conf/discomt/SugiyamaY19,
......@@ -12014,7 +12024,7 @@ author = {Zhuang Liu and
title = {Data augmentation using back-translation for context-aware neural
machine translation},
pages = {35--44},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Proceedings of the Fourth Workshop on Discourse in Machine Translation},
year = {2019}
}
@inproceedings{DBLP:conf/pacling/YamagishiK19,
......@@ -12022,9 +12032,7 @@ author = {Zhuang Liu and
Mamoru Komachi},
title = {Improving Context-Aware Neural Machine Translation with Target-Side
Context},
volume = {1215},
pages = {112--122},
publisher = {Springer},
publisher = {International Conference of the Pacific Association for Computational Linguistics},
year = {2019}
}
@inproceedings{DBLP:conf/emnlp/ZhangLSZXZL18,
......@@ -12066,7 +12074,7 @@ author = {Zhuang Liu and
Haifeng Wang},
title = {Modeling Coherence for Discourse Neural Machine Translation},
pages = {7338--7345},
publisher = {{AAAI} Press},
publisher = {AAAI Conference on Artificial Intelligence},
year = {2019}
}
@inproceedings{DBLP:journals/tacl/YuSSLKBD20,
......@@ -12124,7 +12132,7 @@ author = {Zhuang Liu and
Gholamreza Haffari},
title = {Contextual Neural Model for Translating Bilingual Multi-Speaker Conversations},
pages = {101--112},
publisher = {Annual Meeting of the Association for Computational Linguistics},
publisher = {Conference on Empirical Methods in Natural Language Processing},
year = {2018}
}
@inproceedings{DBLP:conf/interspeech/SainathWSWV15,
......@@ -12135,7 +12143,7 @@ author = {Zhuang Liu and
Oriol Vinyals},
title = {Learning the speech front-end with raw waveform CLDNNs},
pages = {1--5},
publisher = {International Symposium on Computer Architecture},
publisher = {Annual Conference of the International Speech Communication Association},
year = {2015}
}
@inproceedings{DBLP:conf/icassp/MohamedHP12,
......@@ -12144,7 +12152,7 @@ author = {Zhuang Liu and
Gerald Penn},
title = {Understanding how Deep Belief Networks perform acoustic modelling},
pages = {4273--4276},
publisher = {IEEE Transactions on Acoustics, Speech, and Signal Processing},
publisher = {International Conference on Acoustics, Speech and Signal Processing},
year = {2012}
}
@inproceedings{DBLP:journals/ftsig/GalesY07,
......@@ -12190,7 +12198,7 @@ author = {Zhuang Liu and
Oriol Vinyals},
title = {Listen, attend and spell: A neural network for large vocabulary
conversational speech recognition},
publisher = {IEEE Transactions on Acoustics, Speech, and Signal Processing},
publisher = {International Conference on Acoustics, Speech and Signal Processing},
pages = {4960--4964},
year = {2016}
}
......@@ -12232,8 +12240,7 @@ author = {Zhuang Liu and
Laurent Besacier},
title = {Listen and Translate: A Proof of Concept for End-to-End Speech-to-Text
Translation},
publisher = {CoRR},
volume = {abs/1612.01744},
publisher = {Conference and Workshop on Neural Information Processing Systems},
year = {2016}
}
@inproceedings{DBLP:conf/interspeech/WeissCJWC17,
......@@ -12288,7 +12295,7 @@ author = {Zhuang Liu and
title = {Joint CTC-attention based end-to-end speech recognition using multi-task
learning},
pages = {4835--4839},
publisher = {IEEE Transactions on Acoustics, Speech, and Signal Processing},
publisher = {International Conference on Acoustics, Speech and Signal Processing},
year = {2017}
}
@inproceedings{DBLP:journals/pami/ShiBY17,
......@@ -12337,7 +12344,7 @@ author = {Zhuang Liu and
Olivier Pietquin},
title = {End-to-End Automatic Speech Translation of Audiobooks},
pages = {6224--6228},
publisher = {IEEE Transactions on Acoustics, Speech, and Signal Processing},
publisher = {International Conference on Acoustics, Speech and Signal Processing},
year = {2018}
}
@inproceedings{DBLP:conf/icassp/JiaJMWCCALW19,
......@@ -12353,7 +12360,7 @@ author = {Zhuang Liu and
title = {Leveraging Weakly Supervised Data to Improve End-to-end Speech-to-text
Translation},
pages = {7180--7184},
publisher = {IEEE Transactions on Acoustics, Speech, and Signal Processing},
publisher = {International Conference on Acoustics, Speech and Signal Processing},
year = {2019}
}
@inproceedings{DBLP:conf/interspeech/WuWPG20,
......@@ -12376,7 +12383,7 @@ author = {Zhuang Liu and
Chengqing Zong},
title = {End-to-End Speech Translation with Knowledge Distillation},
pages = {1128--1132},
publisher = {International Symposium on Computer Architecture},
publisher = {Annual Conference of the International Speech Communication Association},
year = {2019}
}
@inproceedings{DBLP:conf/emnlp/AlinejadS20,
......@@ -12392,11 +12399,11 @@ author = {Zhuang Liu and
author = {Takatomo Kano and
Sakriani Sakti and
Satoshi Nakamura},
title = {Structured-based Curriculum Learning for End-to-end English-Japanese
title = {Structured-Based Curriculum Learning for End-to-End English-Japanese
Speech Translation},
publisher = {CoRR},
volume = {abs/1802.06003},
year = {2018}
pages = {2630--2634},
publisher = {Annual Conference of the International Speech Communication Association},
year = {2017}
}
@inproceedings{DBLP:conf/acl/WangWLZY20,
author = {Chengyi Wang and
......@@ -12539,23 +12546,24 @@ author = {Zhuang Liu and
year = {2017}
}
@inproceedings{DBLP:conf/wmt/HuangLSOD16,
author = {Po-Yao Huang and
Frederick Liu and
Sz-Rung Shiang and
Jean Oh and
Chris Dyer},
title = {Attention-based Multimodal Neural Machine Translation},
pages = {639--645},
publisher = {Annual Meeting of the Association for Computational Linguistics},
year = {2016}
author = {Yuting Zhao and
Mamoru Komachi and
Tomoyuki Kajiwara and
Chenhui Chu},
title = {Double Attention-based Multimodal Neural Machine Translation with
Semantic Image Regions},
pages = {105--114},
publisher = {Annual Conference of the European Association for Machine Translation},
year = {2020}
}
@inproceedings{Elliott2015MultilingualID,
title={Multilingual Image Description with Neural Sequence Models},
author={Desmond Elliott and
Stella Frank and
Eva Hasler},
publisher ={arXiv: Computation and Language},
year={2015}
@article{Elliott2015MultilingualID,
author = {Desmond Elliott and
Stella Frank and
Eva Hasler},
title = {Multi-Language Image Description with Neural Sequence Models},
journal = {CoRR},
volume = {abs/1510.04709},
year = {2015}
}
@inproceedings{DBLP:conf/wmt/MadhyasthaWS17,
author = {Pranava Swaroop Madhyastha and
......@@ -12605,7 +12613,7 @@ author = {Zhuang Liu and
St{\'{e}}phane Dupont},
title = {Modulating and attending the source image during encoding improves
Multimodal Translation},
publisher = {CoRR},
publisher = {Conference and Workshop on Neural Information Processing Systems},
year = {2017}
}
@inproceedings{DBLP:journals/corr/abs-1807-11605,
......@@ -12680,7 +12688,7 @@ author = {Zhuang Liu and
Dhruv Batra and
Devi Parikh},
title = {Hierarchical Question-Image Co-Attention for Visual Question Answering},
booktitle = {Conference on Neural Information Processing Systems},
publisher = {Conference on Neural Information Processing Systems},
pages = {289--297},
year = {2016}
}
......@@ -12931,7 +12939,7 @@ author = {Zhuang Liu and
Jianfeng Gao},
title = {Oscar: Object-Semantics Aligned Pre-training for Vision-Language Tasks},
pages = {121--137},
publisher = { European Conference on Computer Vision},
publisher = {European Conference on Computer Vision},
year = {2020}
}
@inproceedings{DBLP:conf/aaai/ZhouPZHCG20,
......@@ -13164,7 +13172,7 @@ author = {Zhuang Liu and
title = {Simultaneous Translation with Flexible Policy via Restricted Imitation
Learning},
pages = {5816--5822},
publisher = {Conference on Empirical Methods in Natural Language Processing},
publisher = {Annual Meeting of the Association for Computational Linguistics},
year = {2019}
}
@inproceedings{DBLP:conf/acl/ArivazhaganCMCY19,
......
structure.tex
......@@ -628,6 +628,8 @@ addtohook={%
%\usetikzlibrary{arrows}
%\usetikzlibrary{decorations}
\usetikzlibrary{arrows,shapes}
\usepackage{xeCJK}
\newfontfamily{\yh}{微软雅黑}
%%%%%%%%%%%chapter5图片等---------------------------------------
\usepackage{tikz-3dplot}
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论