Skip to content

M
mtbookv2
Commit f66afcf2 by 曹润柘
Options

合并分支 'caorunzhe' 到 'master' 

Caorunzhe

查看合并请求 !1041
parents 16123b24 60fe5d0b
正在显示 包含 67 行增加 和 67 行删除
Chapter10/Figures/figure-encoder-decoder-with-attention.tex
...@@ -82,7 +82,7 @@ ...@@ -82,7 +82,7 @@
\draw [->,thick] ([yshift=3em]s6.north) -- ([yshift=4em]s6.north) -- ([yshift=4em]t1.north) node [pos=0.5,fill=green!30,inner sep=2pt] (c1) {\scriptsize{表示$\mathbi{C}_1$}} -- ([yshift=3em]t1.north) ; \draw [->,thick] ([yshift=3em]s6.north) -- ([yshift=4em]s6.north) -- ([yshift=4em]t1.north) node [pos=0.5,fill=green!30,inner sep=2pt] (c1) {\scriptsize{表示$\mathbi{C}_1$}} -- ([yshift=3em]t1.north) ;
\draw [->,thick] ([yshift=3em]s5.north) -- ([yshift=5.3em]s5.north) -- ([yshift=5.3em]t2.north) node [pos=0.5,fill=green!30,inner sep=2pt] (c2) {\scriptsize{表示$\mathbi{C}_2$}} -- ([yshift=3em]t2.north) ; \draw [->,thick] ([yshift=3em]s5.north) -- ([yshift=5.3em]s5.north) -- ([yshift=5.3em]t2.north) node [pos=0.5,fill=green!30,inner sep=2pt] (c2) {\scriptsize{表示$\mathbi{C}_2$}} -- ([yshift=3em]t2.north) ;
\draw [->,thick] ([yshift=3.5em]s3.north) -- ([yshift=6.6em]s3.north) -- ([yshift=6.6em]t4.north) node [pos=0.5,fill=green!30,inner sep=2pt] (c3) {\scriptsize{表示$\mathbi{C}_i$}} -- ([yshift=3.5em]t4.north) ; \draw [->,thick] ([yshift=3.5em]s3.north) -- ([yshift=6.6em]s3.north) -- ([yshift=6.6em]t4.north) node [pos=0.5,fill=green!30,inner sep=2pt] (c3) {\scriptsize{表示$\mathbi{C}_j$}} -- ([yshift=3.5em]t4.north) ;
\node [anchor=north] (smore) at ([yshift=3.5em]s3.north) {...}; \node [anchor=north] (smore) at ([yshift=3.5em]s3.north) {...};
\node [anchor=north] (tmore) at ([yshift=3.5em]t4.north) {...}; \node [anchor=north] (tmore) at ([yshift=3.5em]t4.north) {...};
......
Chapter10/chapter10.tex
...@@ -121,7 +121,7 @@ ...@@ -121,7 +121,7 @@
\parinterval 在很多量化的评价中也可以看到神经机器翻译的优势。回忆一下{\chapterfour}提到的机器翻译质量的自动评估指标中，使用最广泛的一种指标是BLEU。2010年前，在由美国国家标准和科技机构（NIST）举办的汉英机器翻译评测中（比如汉英MT08数据集），30\%以上的BLEU值对于基于统计方法的翻译系统来说就已经是当时最顶尖的结果了。而现在的神经机器翻译系统，则可以轻松地将BLEU提高至45\%以上。 \parinterval 在很多量化的评价中也可以看到神经机器翻译的优势。回忆一下{\chapterfour}提到的机器翻译质量的自动评估指标中，使用最广泛的一种指标是BLEU。2010年前，在由美国国家标准和科技机构（NIST）举办的汉英机器翻译评测中（比如汉英MT08数据集），30\%以上的BLEU值对于基于统计方法的翻译系统来说就已经是当时最顶尖的结果了。而现在的神经机器翻译系统，则可以轻松地将BLEU提高至45\%以上。
\parinterval 同样，在机器翻译领域中著名评测比赛WMT（Workshop of Machine Translation）中，使用统计机器翻译方法的参赛系统也在逐年减少。而现在获得比赛冠军的系统中几乎没有只使用纯统计机器翻译模型的系统\footnote{但是，仍然有大量的统计机器翻译和神经机器翻译融合的方法。比如，在无指导机器翻译中，统计机器翻译仍然被作为初始模型。} 。图\ref{fig:10-3}展示了近年来WMT比赛冠军系统中神经机器翻译系统的占比，可见神经机器翻译系统的占比在逐年提高。 \parinterval 同样，在机器翻译领域中著名评测比赛WMT（Workshop of Machine Translation）中，使用统计机器翻译方法的参赛系统也在逐年减少。而现在获得比赛冠军的系统中几乎没有只使用纯统计机器翻译模型的系统\footnote{但是，仍然有大量的统计机器翻译和神经机器翻译融合的方法。比如，在无指导机器翻译中，统计机器翻译仍然被作为初始模型。} 。图\ref{fig:10-3}展示了近年来WMT比赛冠军系统中神经机器翻译系统的数量，可见神经机器翻译系统的数量在逐年提高。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -191,13 +191,13 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -191,13 +191,13 @@ NMT & 21.7 & 18.7 & -13.7 \\
\end{table} \end{table}
%---------------------------------------------- %----------------------------------------------
\parinterval 在最近两年，神经机器翻译的发展更加迅速，新的模型及方法层出不穷。表\ref{tab:10-3}给出了到2020年为止，一些主流的神经机器翻译模型在WMT14英德数据集上的表现。可以看到，相比2017年，2018-2020年中机器翻译仍然有明显的进步。 \parinterval 在最近两年，神经机器翻译的发展更加迅速，新的模型及方法层出不穷。表\ref{tab:10-3}给出了到2020年为止，一些主流的神经机器翻译模型在WMT14英德数据集上的表现。可以看到，相比2017年，2018-2020年中机器翻译仍然有进步。
\vspace{0.5em}%全局布局使用 \vspace{0.5em}%全局布局使用
%---------------------------------------------- %----------------------------------------------
\begin{table}[htp] \begin{table}[htp]
\centering \centering
\caption{WMT14英德数据集上不同神经机器翻译系统的表现} \caption{WMT14英德数据集上不同神经机器翻译模型的表现}
\label{tab:10-3} \label{tab:10-3}
\begin{tabular}{ l | l l l} \begin{tabular}{ l | l l l}
模型 &作者 & 年份 & BLEU[\%] \\ \hline 模型 &作者 & 年份 & BLEU[\%] \\ \hline
...@@ -230,7 +230,7 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -230,7 +230,7 @@ NMT & 21.7 & 18.7 & -13.7 \\
\rule{0pt}{15pt} \parbox{12em}{统计机器翻译 } &神经机器翻译\\ \hline \rule{0pt}{15pt} \parbox{12em}{统计机器翻译 } &神经机器翻译\\ \hline
\rule{0pt}{13pt} 基于离散空间的表示模型 &基于连续空间的表示模型 \\ \rule{0pt}{13pt} 基于离散空间的表示模型 &基于连续空间的表示模型 \\
\rule{0pt}{13pt} NLP问题的隐含结构假设 &无隐含结构假设，端到端学习 \\ \rule{0pt}{13pt} NLP问题的隐含结构假设 &无隐含结构假设，端到端学习 \\
\rule{0pt}{13pt} 特征工程为主 &无显性特征，但需要设计网络 \\ \rule{0pt}{13pt} 特征工程为主 &不需要特征工程，但需要设计网络 \\
\rule{0pt}{13pt} 特征、规则的存储耗资源 &模型存储相对小，但计算量大 \\ \rule{0pt}{13pt} 特征、规则的存储耗资源 &模型存储相对小，但计算量大 \\
\end{tabular} \end{tabular}
\end{table} \end{table}
...@@ -239,16 +239,16 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -239,16 +239,16 @@ NMT & 21.7 & 18.7 & -13.7 \\
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 分布式连续空间表示模型，能捕获更多隐藏信息。神经机器翻译与统计机器翻译最大的区别在于对语言文字串的表示方法。在统计机器翻译中，所有词串本质上都是由更小的词串（短语、规则）组合而成，也就是统计机器翻译模型利用了词串之间的组合性来表示更大的词串。统计机器翻译使用多个特征描述翻译结果，但是其仍然对应着离散的字符串的组合，因此可以把模型对问题的表示空间看做是由一个离散结构组成的集合。在神经机器翻译中，词串的表示已经被神经网络转化为多维实数向量，而且也不依赖任何的可组合性假设等其他假设来刻画离散的语言结构，从这个角度说，所有的词串分别对应了一个连续空间上的点（比如，对应多维实数空间中一个点）。这样，模型可以更好地进行优化，而且对未见样本有更好的泛化能力。此外，基于连续可微函数的机器学习算法已经相对完备，可以很容易地对问题进行建模和优化。 \item 连续空间表示模型，能捕获更多隐藏信息。神经机器翻译与统计机器翻译最大的区别在于对语言文字串的表示方法。在统计机器翻译中，所有词串本质上都是由更小的词串（短语、规则）组合而成，也就是统计机器翻译模型利用了词串之间的组合性来表示更大的词串。统计机器翻译使用多个特征描述翻译结果，但是其仍然对应着离散的字符串的组合，因此可以把模型对问题的表示空间看做是由一个离散结构组成的集合。在神经机器翻译中，词串的表示已经被神经网络转化为多维实数向量，而且也不依赖任何的可组合性假设等其他假设来刻画离散的语言结构，从这个角度说，所有的词串分别对应了一个连续空间上的点（比如，对应多维实数空间中一个点）。这样，模型可以更好地进行优化，而且对未见样本有更好的泛化能力。此外，基于连续可微函数的机器学习算法已经相对完备，可以很容易地对问题进行建模和优化。
\vspace{0.5em} \vspace{0.5em}
\item 不含隐含结构假设，端到端学习对问题建模更加直接。传统的自然语言处理任务会对问题进行隐含结构假设。比如，进行翻译时，统计机器翻译会假设翻译过程由短语的拼装完成。这些假设可以大大化简问题的复杂度，但是另一方面也带来了各种各样的约束条件，并且错误的隐含假设往往会导致建模错误。神经机器翻译是一种端到端模型，它并不依赖任何隐含结构假设。这样，模型并不会受到错误的隐含结构的引导。从某种意义上说，端到端学习可以让模型更加“ 自由”地进行学习，因此往往可以学到很多传统认知上不容易理解或者不容易观测到的现象。 \item 不含隐含结构假设，端到端学习对问题建模更加直接。传统的自然语言处理任务会对问题进行隐含结构假设。比如，进行翻译时，统计机器翻译会假设翻译过程由短语的拼装完成。这些假设可以大大化简问题的复杂度，但是另一方面也带来了各种各样的约束条件，并且错误的隐含假设往往会导致建模错误。神经机器翻译是一种端到端模型，它并不依赖任何隐含结构假设。这样，模型并不会受到错误的隐含结构的引导。从某种意义上说，端到端学习可以让模型更加“ 自由”地进行学习，因此往往可以学到很多传统认知上不容易理解或者不容易观测到的现象。
\vspace{0.5em} \vspace{0.5em}
\item 不需要特征工程，特征学习更加全面。经典的统计机器翻译可以通过判别式模型引入任意特征，不过这些特征需要人工设计，因此这个过程也被称为特征工程。特征工程依赖大量的人工，特别是对不同语种、不同场景的翻译任务，所采用的特征可能不尽相同，这也使得设计有效的特征成为了统计机器翻译时代最主要的工作之一。但是，由于人类自身的思维和认知水平的限制，人工设计的特征可能不全面，甚至会遗漏一些重要的翻译现象。神经机器翻译并不依赖任何人工特征的设计，或者说它的特征都隐含在分布式表示中。这些“特征”都是自动学习得到的，因此神经机器翻译并不会受到人工思维的限制，学习到的特征对问题描述更加全面。 \item 不需要特征工程，特征学习更加全面。经典的统计机器翻译可以通过判别式模型引入任意特征，不过这些特征需要人工设计，因此这个过程也被称为特征工程。特征工程依赖大量的人工，特别是对不同语种、不同场景的翻译任务，所采用的特征可能不尽相同，这也使得设计有效的特征成为了统计机器翻译时代最主要的工作之一。但是，由于人类自身的思维和认知水平的限制，人工设计的特征可能不全面，甚至会遗漏一些重要的翻译现象。神经机器翻译并不依赖任何人工特征的设计，或者说它的特征都隐含在分布式表示中。这些“特征”都是自动学习得到的，因此神经机器翻译并不会受到人工思维的限制，学习到的特征将问题描述得更全面。
\vspace{0.5em} \vspace{0.5em}
\item 模型结构统一，存储消耗更小。统计机器翻译系统依赖于很多模块，比如词对齐、短语（规则）表和目标语言模型等等，因为所有的信息（如$n$-gram）都是离散化表示的，因此模型需要消耗大量的存储资源。同时，由于系统模块较多，开发的难度也较大。神经机器翻译的模型都是用神经网络进行表示，模型参数大多是实数矩阵，因此存储资源的消耗很小。而且神经网络可以作为一个整体进行开发和调试，系统搭建的代价相对较低。实际上，由于模型体积小，神经机器翻译也非常合适于离线小设备上的翻译任务。 \item 模型结构统一，存储相对更小。统计机器翻译系统依赖于很多模块，比如词对齐、短语（规则）表和目标语言模型等等，因为所有的信息（如$n$-gram）都是离散化表示的，因此模型需要消耗大量的存储资源。同时，由于系统模块较多，开发的难度也较大。神经机器翻译的模型都是用神经网络进行表示，模型参数大多是实数矩阵，因此存储资源的消耗很小。而且神经网络可以作为一个整体进行开发和调试，系统搭建的代价相对较低。实际上，由于模型体积小，神经机器翻译也非常合适于离线小设备上的翻译任务。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
...@@ -336,7 +336,7 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -336,7 +336,7 @@ NMT & 21.7 & 18.7 & -13.7 \\
\parinterval 翻译过程的神经网络结构如图\ref{fig:10-7}所示，其中左边是编码器，右边是解码器。编码器会顺序处理源语言单词，将每个单词都表示成一个实数向量，也就是每个单词的词嵌入结果（绿色方框）。在词嵌入的基础上运行循环神经网络（蓝色方框）。在编码下一个时间步状态的时候，上一个时间步的隐藏状态会作为历史信息传入循环神经网络。这样，句子中每个位置的信息都被向后传递，最后一个时间步的隐藏状态（红色方框）就包含了整个源语言句子的信息，也就得到了编码器的编码结果$\ \dash\ $源语言句子的分布式表示。 \parinterval 翻译过程的神经网络结构如图\ref{fig:10-7}所示，其中左边是编码器，右边是解码器。编码器会顺序处理源语言单词，将每个单词都表示成一个实数向量，也就是每个单词的词嵌入结果（绿色方框）。在词嵌入的基础上运行循环神经网络（蓝色方框）。在编码下一个时间步状态的时候，上一个时间步的隐藏状态会作为历史信息传入循环神经网络。这样，句子中每个位置的信息都被向后传递，最后一个时间步的隐藏状态（红色方框）就包含了整个源语言句子的信息，也就得到了编码器的编码结果$\ \dash\ $源语言句子的分布式表示。
\parinterval 解码器直接把源语言句子的分布式表示作为输入的隐层状态，之后像编码器一样依次读入目标语言单词，这是一个标准的循环神经网络的执行过程。与编码器不同的是，解码器会有一个输出层，用于根据当前时间步的隐层状态生成目标语言单词及其概率分布。可以看到，解码器当前时刻的输出单词与下一个时刻的输入单词是一样的。从这个角度说，解码器也是一种神经语言模型，只不过它会从另外一种语言（源语言）获得一些信息，而不是仅仅做单语句子的生成。具体来说，当生成第一个单词“I”时，解码器利用了源语言句子表示（红色方框）和目标语言的起始词“<sos>”。在生成第二个单词“am”时，解码器利用了上一个时间步的隐藏状态和已经生成的“I”的信息。这个过程会循环执行，直到生成完整的目标语言句子。 \parinterval 解码器直接把源语言句子的分布式表示作为输入的隐藏层状态，之后像编码器一样依次读入目标语言单词，这是一个标准的循环神经网络的执行过程。与编码器不同的是，解码器会有一个输出层，用于根据当前时间步的隐藏层状态生成目标语言单词及其概率分布。可以看到，解码器当前时刻的输出单词与下一个时刻的输入单词是一样的。从这个角度说，解码器也是一种神经语言模型，只不过它会从另外一种语言（源语言）获得一些信息，而不是仅仅做单语句子的生成。具体来说，当生成第一个单词“I”时，解码器利用了源语言句子表示（红色方框）和目标语言的起始词“<sos>”。在生成第二个单词“am”时，解码器利用了上一个时间步的隐藏状态和已经生成的“I”的信息。这个过程会循环执行，直到生成完整的目标语言句子。
\parinterval 从这个例子可以看出，神经机器翻译的流程其实并不复杂：首先通过编码器神经网络将源语言句子编码成实数向量，然后解码器神经网络利用这个向量逐词生成译文。现在几乎所有的神经机器翻译系统都采用类似的架构。 \parinterval 从这个例子可以看出，神经机器翻译的流程其实并不复杂：首先通过编码器神经网络将源语言句子编码成实数向量，然后解码器神经网络利用这个向量逐词生成译文。现在几乎所有的神经机器翻译系统都采用类似的架构。
...@@ -407,7 +407,7 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -407,7 +407,7 @@ NMT & 21.7 & 18.7 & -13.7 \\
\subsection{建模} \subsection{建模}
\label{sec:10.3.1} \label{sec:10.3.1}
\parinterval 同大多数自然语言处理任务一样，神经机器翻译要解决的一个基本问题是如何描述文字序列，称为序列表示问题。例如，处理语音数据、文本数据都可以被看作是典型的序列表示问题。如果把一个序列看作一个时序上的一系列变量，不同时刻的变量之间往往是存在相关性的。也就是说，一个时序中某个时刻变量的状态会依赖其他时刻变量的状态，即上下文的语境信息。下面是一个简单的例子，假设有一个句子，但是最后的单词被擦掉了，如何猜测被擦掉的单词是什么？ \parinterval 同大多数自然语言处理任务一样，神经机器翻译要解决的一个基本问题是如何描述文字序列，称为序列表示问题。例如，语音数据、文本数据的处理问题都可以被看作经典的序列表示问题。如果把一个序列看作一个时序上的一系列变量，不同时刻的变量之间往往是存在相关性的。也就是说，一个时序中某个时刻变量的状态会依赖其他时刻变量的状态，即上下文的语境信息。下面是一个简单的例子，假设有一个句子，但是最后的单词被擦掉了，如何猜测被擦掉的单词是什么？
\vspace{0.8em} \vspace{0.8em}
\centerline{中午\ 没\ 吃饭\ ，\ 又\ 刚\ 打\ 了\ 一\ 下午\ 篮球\ ，\ 我\ 现在\ 很\ 饿\ ，\ 我\ 想\underline{\quad \quad \quad} 。} \centerline{中午\ 没\ 吃饭\ ，\ 又\ 刚\ 打\ 了\ 一\ 下午\ 篮球\ ，\ 我\ 现在\ 很\ 饿\ ，\ 我\ 想\underline{\quad \quad \quad} 。}
...@@ -439,7 +439,7 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -439,7 +439,7 @@ NMT & 21.7 & 18.7 & -13.7 \\
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 从数学模型上看，神经机器翻译模型与统计机器翻译的目标是一样的：在给定源语言句子$\seq{x}$的情况下，找出翻译概率最大的目标语言译文$\hat{\seq{y}}$，其计算如下式: \parinterval 从数学模型上看，神经机器翻译模型与统计机器翻译模型的目标是一样的：在给定源语言句子$\seq{x}$的情况下，找出翻译概率最大的目标语言译文$\hat{\seq{y}}$，其计算如下式:
\vspace{-1em} \vspace{-1em}
\begin{eqnarray} \begin{eqnarray}
\hat{\seq{{y}}} &=& \argmax_{\seq{{y}}} \funp{P} (\seq{{y}} | \seq{{x}}) \hat{\seq{{y}}} &=& \argmax_{\seq{{y}}} \funp{P} (\seq{{y}} | \seq{{x}})
...@@ -469,7 +469,7 @@ NMT & 21.7 & 18.7 & -13.7 \\ ...@@ -469,7 +469,7 @@ NMT & 21.7 & 18.7 & -13.7 \\
\funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}}) &=& \funp{P} ( {y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}} ) \funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}}) &=& \funp{P} ( {y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}} )
\label{eq:10-3} \label{eq:10-3}
\end{eqnarray} \end{eqnarray}
$\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softmax的输入是循环神经网络$j$时刻的输出。在具体实现时，$\mathbi{C}$可以被简单地作为第一个时刻循环单元的输入，即，当$j=1$ 时，解码器的循环神经网络会读入编码器最后一个隐层状态$ \mathbi{h}_m$（也就是$\mathbi{C}$），而其他时刻的隐层状态不直接与$\mathbi{C}$相关。最终，$\funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}})$ 被表示为： $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softmax的输入是循环神经网络$j$时刻的输出。在具体实现时，$\mathbi{C}$可以被简单地作为第一个时刻循环单元的输入，即，当$j=1$ 时，解码器的循环神经网络会读入编码器最后一个隐藏层状态$ \mathbi{h}_m$（也就是$\mathbi{C}$），而其他时刻的隐藏层状态不直接与$\mathbi{C}$相关。最终，$\funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}})$ 被表示为：
\begin{eqnarray} \begin{eqnarray}
\funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}}) &=& \funp{P} (y_j | \seq{{y}}_{<j},\seq{{x}}) &=&
\left \{ \begin{array}{ll} \left \{ \begin{array}{ll}
...@@ -634,7 +634,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm ...@@ -634,7 +634,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
\subsection{多层神经网络} \subsection{多层神经网络}
\parinterval 实际上，对于单词序列所使用的循环神经网络是一种很“深”的网络，因为从第一个单词到最后一个单词需要经过至少句子长度相当层数的神经元。比如，一个包含几十个词的句子也会对应几十个神经元层。但是，在很多深度学习应用中，更习惯把对输入序列的同一种处理作为“一层”。比如，对于输入序列，构建一个RNN，那么这些循环单元就构成了网络的“一层”。当然，这里并不是要混淆概念。只是要明确，在随后的讨论中，“层”并不是指一组神经元的全连接，它一般指的是网络结构中逻辑上的一层。 \parinterval 实际上，对于单词序列所使用的循环神经网络是一种很“深”的网络，因为从第一个单词到最后一个单词需要经过至少与句子长度相当的层数的神经元。比如，一个包含几十个词的句子也会对应几十个神经元层。但是，在很多深度学习应用中，更习惯把对输入序列的同一种处理作为“一层”。比如，对于输入序列，构建一个RNN，那么这些循环单元就构成了网络的“一层”。当然，这里并不是要混淆概念。只是要明确，在随后的讨论中，“层”并不是指一组神经元的全连接，它一般指的是网络结构中逻辑上的一层。
\parinterval 单层循环神经网络对输入序列进行了抽象，为了得到更深入的抽象能力，可以把多个循环神经网络叠在一起，构成多层循环神经网络。比如，图\ref{fig:10-15}就展示了基于两层循环神经网络的解码器和编码器结构。通常来说，层数越多模型的表示能力越强，因此在很多基于循环神经网络的机器翻译系统中一般会使用4$\sim$8层的网络。但是，过多的层也会增加模型训练的难度，甚至导致模型无法进行训练。{\chapterthirteen}还会对这个问题进行深入讨论。 \parinterval 单层循环神经网络对输入序列进行了抽象，为了得到更深入的抽象能力，可以把多个循环神经网络叠在一起，构成多层循环神经网络。比如，图\ref{fig:10-15}就展示了基于两层循环神经网络的解码器和编码器结构。通常来说，层数越多模型的表示能力越强，因此在很多基于循环神经网络的机器翻译系统中一般会使用4$\sim$8层的网络。但是，过多的层也会增加模型训练的难度，甚至导致模型无法进行训练。{\chapterthirteen}还会对这个问题进行深入讨论。
...@@ -701,7 +701,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm ...@@ -701,7 +701,7 @@ $\funp{P}({y_j | \mathbi{s}_{j-1} ,y_{j-1},\mathbi{C}})$由Softmax实现，Softm
\parinterval 显然，以上问题的根本原因在于所使用的表示模型还比较“弱”。因此需要一个更强大的表示模型，在生成目标语言单词时能够有选择地获取源语言句子中更有用的部分。更准确的说，对于要生成的目标语言单词，相关性更高的源语言片段应该在源语言句子的表示中体现出来，而不是将所有的源语言单词一视同仁。在神经机器翻译中引入注意力机制正是为了达到这个目的\upcite{bahdanau2014neural,DBLP:journals/corr/LuongPM15}。实际上，除了机器翻译，注意力机制也被成功地应用于图像处理、语音识别、自然语言处理等其他任务。也正是注意力机制的引入，使得包括机器翻译在内很多自然语言处理系统得到了飞跃发展。 \parinterval 显然，以上问题的根本原因在于所使用的表示模型还比较“弱”。因此需要一个更强大的表示模型，在生成目标语言单词时能够有选择地获取源语言句子中更有用的部分。更准确的说，对于要生成的目标语言单词，相关性更高的源语言片段应该在源语言句子的表示中体现出来，而不是将所有的源语言单词一视同仁。在神经机器翻译中引入注意力机制正是为了达到这个目的\upcite{bahdanau2014neural,DBLP:journals/corr/LuongPM15}。实际上，除了机器翻译，注意力机制也被成功地应用于图像处理、语音识别、自然语言处理等其他任务。也正是注意力机制的引入，使得包括机器翻译在内很多自然语言处理系统得到了飞跃发展。
\parinterval 神经机器翻译中的注意力机制并不复杂。对于每个目标语言单词$y_j$，系统生成一个源语言表示向量$\mathbi{C}_j$与之对应，$\mathbi{C}_j$会包含生成$y_j$所需的源语言的信息，或者说$\mathbi{C}_j$是一种包含目标语言单词与源语言单词对应关系的源语言表示。相比用一个静态的表示$\mathbi{C}$，注意机制使用的是动态的表示$\mathbi{C}_j$。$\mathbi{C}_j$也被称作对于目标语言位置$j$的{\small\bfnew{上下文向量}}\index{上下文向量}（Context Vector\index{Context Vector}）。图\ref{fig:10-18}对比了未引入注意力机制和引入了注意力机制的编码器- 解码器结构。可以看出，在注意力模型中，对于每一个目标语言单词的生成，都会额外引入一个单独的上下文向量参与运算。 \parinterval 神经机器翻译中的注意力机制并不复杂。对于每个目标语言单词$y_j$，系统生成一个源语言表示向量$\mathbi{C}_j$与之对应，$\mathbi{C}_j$会包含生成$y_j$所需的源语言的信息，或者说$\mathbi{C}_j$是一种包含目标语言单词与源语言单词对应关系的源语言表示。不同于用一个静态的表示$\mathbi{C}$，注意机制使用的是动态的表示$\mathbi{C}_j$。$\mathbi{C}_j$也被称作对于目标语言位置$j$的{\small\bfnew{上下文向量}}\index{上下文向量}（Context Vector\index{Context Vector}）。图\ref{fig:10-18}对比了未引入注意力机制和引入了注意力机制的编码器- 解码器结构。可以看出，在注意力模型中，对于每一个目标语言单词的生成，都会额外引入一个单独的上下文向量参与运算。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -891,7 +891,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -891,7 +891,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 实际上，GNMT的主要贡献在于集成了多种优秀的技术，而且在大规模数据上证明了神经机器翻译的有效性。在引入注意力机制之前，神经机器翻译在较大规模的任务上的性能弱于统计机器翻译。加入注意力机制和深层网络后，神经机器翻译性能有了很大的提升。在英德和英法的任务中，GNMT的BLEU值不仅超过了当时优秀的神经机器翻译系统RNNSearch和LSTM（6层），还超过了当时处于领导地位的基于短语的统计机器翻译系统（PBMT）（表\ref{tab:10-8}）。相比基于短语的统计机器翻译系统，在人工评价中，GNMT能将翻译错误平均减少60\%。这一结果也充分表明了神经机器翻译带来的巨大性能提升。 \parinterval 实际上，GNMT的主要贡献在于集成了多种优秀的技术，而且在大规模数据上证明了神经机器翻译的有效性。在引入注意力机制之前，神经机器翻译在较大规模的任务上的性能弱于统计机器翻译。加入注意力机制和深层网络后，神经机器翻译性能有了很大的提升。在英德和英法的任务中，GNMT的BLEU值不仅超过了当时优秀的神经机器翻译模型RNNSearch和LSTM（6层），还超过了当时处于领导地位的基于短语的统计机器翻译模型（PBMT）（表\ref{tab:10-8}）。相比基于短语的统计机器翻译模型，在人工评价中，GNMT能将翻译错误平均减少60\%。这一结果也充分表明了神经机器翻译带来的巨大性能提升。
%---------------------------------------------- %----------------------------------------------
\begin{table}[htp] \begin{table}[htp]
...@@ -899,7 +899,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -899,7 +899,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
\caption{GNMT与其他翻译模型对比\upcite{Wu2016GooglesNM}} \caption{GNMT与其他翻译模型对比\upcite{Wu2016GooglesNM}}
\label{tab:10-8} \label{tab:10-8}
\begin{tabular}{l l l} \begin{tabular}{l l l}
\multicolumn{1}{l|}{\multirow{3}{*}{}} & \multicolumn{2}{c}{BLEU[\%]} \\ \multicolumn{1}{l|}{\multirow{3}{*}{翻译模型}} & \multicolumn{2}{c}{BLEU[\%]} \\
\multicolumn{1}{l|}{} & 英德 & 英法 \\ \multicolumn{1}{l|}{} & 英德 & 英法 \\
\multicolumn{1}{l|}{} & EN-DE & EN-FR \\ \hline \multicolumn{1}{l|}{} & EN-DE & EN-FR \\ \hline
\multicolumn{1}{l|}{PBMT} & 20.7 & 37.0 \\ \multicolumn{1}{l|}{PBMT} & 20.7 & 37.0 \\
...@@ -940,7 +940,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll} ...@@ -940,7 +940,7 @@ a (\mathbi{s},\mathbi{h}) &=& \left\{ \begin{array}{ll}
\subsubsection{1. 损失函数} \subsubsection{1. 损失函数}
\parinterval 神经机器翻译在目标端的每个位置都会输出一个概率分布，表示这个位置上不同单词出现的可能性。设计损失函数时，需要知道当前位置输出的分布相比于标准答案的“差异”。对于这个问题，常用的是交叉熵损失函数。令$\hat{\mathbi{y}}$ 表示机器翻译模型输出的分布， $\mathbi{y}$ 表示标准答案，则交叉熵损失可以被定义为： \parinterval 神经机器翻译在目标端的每个位置都会输出一个概率分布，表示这个位置上不同单词出现的可能性。设计损失函数时，需要知道当前位置输出的分布相比于标准答案的“差异”。在神经机器翻译中，常用的损失函数是交叉熵损失函数。令$\hat{\mathbi{y}}$ 表示机器翻译模型输出的分布， $\mathbi{y}$ 表示标准答案，则交叉熵损失可以被定义为：
\begin{eqnarray} \begin{eqnarray}
L_{\textrm{ce}}(\hat{\mathbi{y}},\mathbi{y}) &=& - \sum_{k=1}^{|V|} \hat{\mathbi{y}}[k] \textrm{log} (\mathbi{y}[k]) L_{\textrm{ce}}(\hat{\mathbi{y}},\mathbi{y}) &=& - \sum_{k=1}^{|V|} \hat{\mathbi{y}}[k] \textrm{log} (\mathbi{y}[k])
\label{eq:10-25} \label{eq:10-25}
...@@ -991,7 +991,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi ...@@ -991,7 +991,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi
%\vspace{0.5em} %\vspace{0.5em}
\parinterval 公式\eqref{eq:10-24}展示了最基本的优化策略，也被称为标准的SGD优化器。实际上，训练神经机器翻译模型时，还有非常多的优化器可以选择，在{\chapternine}也有详细介绍，本章介绍的循环神经网络考虑使用Adam优化器\upcite{kingma2014adam}。 Adam 通过对梯度的{\small\bfnew{一阶矩估计}}\index{一阶矩估计}（First Moment Estimation）\index{First Moment Estimation}和{\small\bfnew{二阶矩估计}}\index{二阶矩估计}（Second Moment Estimation）\index{Second Moment Estimation}进行综合考虑，计算出更新步长。 \parinterval 公式\eqref{eq:10-24}展示了最基本的优化策略，也被称为标准的SGD优化器。实际上，训练神经机器翻译模型时，还有非常多的优化器可以选择，在{\chapternine}也有详细介绍，本章介绍的循环神经网络考虑使用Adam优化器\upcite{kingma2014adam}。 Adam 通过对梯度的{\small\bfnew{一阶矩估计}}\index{一阶矩估计}（First Moment Estimation）\index{First Moment Estimation}和{\small\bfnew{二阶矩估计}}\index{二阶矩估计}（Second Moment Estimation）\index{Second Moment Estimation}进行综合考虑，计算出更新步长。
\parinterval 通常，Adam收敛地比较快，不同任务基本上可以使用一套配置进行优化，虽性能不算差，但很难达到最优效果。相反，SGD虽能通过在不同的数据集上进行调整，来达到最优的结果，但是收敛速度慢。因此需要根据不同的需求来选择合适的优化器。若需要快速得到模型的初步结果，选择Adam较为合适，若是需要在一个任务上得到最优的结果，选择SGD更为合适。 \parinterval 通常，Adam收敛地比较快，不同任务基本上可以使用同一套配置进行优化，虽性能不算差，但很难达到最优效果。相反，SGD虽能通过在不同的数据集上进行调整，来达到最优的结果，但是收敛速度慢。因此需要根据不同的需求来选择合适的优化器。若需要快速得到模型的初步结果，选择Adam较为合适，若是需要在一个任务上得到最优的结果，选择SGD更为合适。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUBSUB-SECTION % NEW SUBSUB-SECTION
...@@ -1032,7 +1032,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi ...@@ -1032,7 +1032,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi
\vspace{0.5em} \vspace{0.5em}
\parinterval 图\ref{fig:10-26}展示了一种常用的学习率调整策略。它分为两个阶段：预热阶段和衰减阶段。模型训练初期梯度通常很大，如果直接使用较大的学习率很容易让模型陷入局部最优。学习率的预热阶段便是通过在训练初期使学习率从小到大逐渐增加来减缓在初始阶段模型“跑偏”的现象。一般来说，初始学习率太高会使得模型进入一种损失函数曲面非常不平滑的区域，进而使得模型进入一种混乱状态，后续的优化过程很难取得很好的效果。一个常用的学习率预热方法是{\small\bfnew{逐渐预热}}\index{逐渐预热}（Gradual Warmup）\index{Gradual Warmup}。假设预热的更新次数为$N$，初始学习率为$\alpha_0$，则预热阶段第$\textrm{step}$次更新的学习率计算为： \parinterval 图\ref{fig:10-26}展示了一种常用的学习率调整策略。它分为两个阶段：预热阶段和衰减阶段。模型训练初期梯度通常很大，如果直接使用较大的学习率很容易让模型陷入局部最优。学习率的预热阶段是指在训练初期使学习率从小到大逐渐增加的阶段，目的是缓解在初始阶段模型“跑偏”的现象。一般来说，初始学习率太高会使得模型进入一种损失函数曲面非常不平滑的区域，进而使得模型进入一种混乱状态，后续的优化过程很难取得很好的效果。一个常用的学习率预热方法是{\small\bfnew{逐渐预热}}\index{逐渐预热}（Gradual Warmup）\index{Gradual Warmup}。假设预热的更新次数为$N$，初始学习率为$\alpha_0$，则预热阶段第$\textrm{step}$次更新的学习率计算为：
%\vspace{0.5em} %\vspace{0.5em}
\begin{eqnarray} \begin{eqnarray}
\alpha_t &=& \frac{\textrm{step}}{N} \alpha_0 \quad,\quad 1 \leq t \leq T' \alpha_t &=& \frac{\textrm{step}}{N} \alpha_0 \quad,\quad 1 \leq t \leq T'
...@@ -1040,7 +1040,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi ...@@ -1040,7 +1040,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi
\end{eqnarray} \end{eqnarray}
%------- %-------
\noindent 另一方面，当模型训练逐渐接近收敛的时候，使用太大学习率会很容易让模型在局部最优解附近震荡，从而错过局部极小，因此需要通过减小学习率来调整更新的步长，以此来不断地逼近局部最优，这一阶段也称为学习率的衰减阶段。学习率衰减的方法有很多，比如指数衰减以及余弦衰减等，图\ref{fig:10-26}右侧下降部分的曲线展示了{\small\bfnew{分段常数衰减}}\index{分段常数衰减}（Piecewise Constant Decay）\index{Piecewise Constant Decay}，即每经过$m$次更新，学习率衰减为原来的$\beta_m$（$\beta_m<1$）倍，其中$m$和$\beta_m$为经验设置的超参。 \noindent 另一方面，当模型训练逐渐接近收敛的时候，使用太大学习率会很容易让模型在局部最优解附近震荡，从而错过局部极小，因此需要通过减小学习率来调整更新的步长，以此来不断地逼近局部最优，这一阶段也称为学习率的衰减阶段。学习率衰减的方法有很多，比如指数衰减以及余弦衰减等，图\ref{fig:10-26}右侧下降部分的曲线展示了{\small\bfnew{分段常数衰减}}\index{分段常数衰减}（Piecewise Constant Decay）\index{Piecewise Constant Decay}，即每经过$m$次更新，学习率衰减为原来的$\beta_m$（$\beta_m<1$）倍，其中$m$和$\beta_m$为根据经验设置的超参。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -1058,7 +1058,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi ...@@ -1058,7 +1058,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi
\subsubsection{6. 并行训练} \subsubsection{6. 并行训练}
%\vspace{0.5em} %\vspace{0.5em}
\parinterval 机器翻译是自然语言处理中很“重”的任务。因为数据量巨大而且模型较为复杂，模型训练的时间往往很长。比如，使用一千万句的训练数据，性能优异的系统往往需要几天甚至一周的时间。更大规模的数据会导致训练时间更长。特别是使用多层网络同时增加模型容量时（比如增加隐层宽度时），神经机器翻译的训练会更加缓慢。对于这个问题，一个思路是从模型训练算法上进行改进。比如前面提到的Adam就是一种高效的训练策略。另一种思路是利用多设备进行加速，也称作分布式训练。 \parinterval 机器翻译是自然语言处理中很“重”的任务。因为数据量巨大而且模型较为复杂，模型训练的时间往往很长。比如，使用一千万句的训练数据，性能优异的系统往往需要几天甚至一周的时间。更大规模的数据会导致训练时间更长。特别是使用多层网络同时增加模型容量时（比如增加隐藏层宽度时），神经机器翻译的训练会更加缓慢。对于这个问题，一个思路是从模型训练算法上进行改进。比如前面提到的Adam就是一种高效的训练策略。另一种思路是利用多设备进行加速，也称作分布式训练。
\parinterval 常用的多设备并行化加速方法有数据并行和模型并行，其优缺点的简单对比如表\ref{tab:10-9}所示。数据并行是指把同一个批次的不同样本分到不同设备上进行并行计算。其优点是并行度高，理论上有多大的批次就可以有多少个设备并行计算，但模型体积不能大于单个设备容量的极限。而模型并行是指把“模型”切分成若干模块后分配到不同设备上并行计算。其优点是可以对很大的模型进行运算，但只能有限并行，比如，如果按层对模型进行分割，那么有多少层就需要多少个设备，同时这两种方法可以一起使用进一步提高神经网络的训练速度。具体来说： \parinterval 常用的多设备并行化加速方法有数据并行和模型并行，其优缺点的简单对比如表\ref{tab:10-9}所示。数据并行是指把同一个批次的不同样本分到不同设备上进行并行计算。其优点是并行度高，理论上有多大的批次就可以有多少个设备并行计算，但模型体积不能大于单个设备容量的极限。而模型并行是指把“模型”切分成若干模块后分配到不同设备上并行计算。其优点是可以对很大的模型进行运算，但只能有限并行，比如，如果按层对模型进行分割，那么有多少层就需要多少个设备，同时这两种方法可以一起使用进一步提高神经网络的训练速度。具体来说：
...@@ -1068,7 +1068,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi ...@@ -1068,7 +1068,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi
\caption{ 数据并行与模型并行优缺点对比} \caption{ 数据并行与模型并行优缺点对比}
\label{tab:10-9} \label{tab:10-9}
\begin{tabular}{l | p{12em} p{12em} } \begin{tabular}{l | p{12em} p{12em} }
&优点 &缺点 \\ \hline 并行方法 &优点 &缺点 \\ \hline
\rule{0pt}{15pt} 数据并行 &并行度高，理论上有多大的批次（Batch）就可以有多少个设备并行计算 &模型不能大于单个设备的极限 \\ \rule{0pt}{15pt} 数据并行 &并行度高，理论上有多大的批次（Batch）就可以有多少个设备并行计算 &模型不能大于单个设备的极限 \\
\rule{0pt}{15pt} 模型并行 &可以对很大的模型进行运算 &只能有限并行，比如有多少层就有多少个设备 \\ \rule{0pt}{15pt} 模型并行 &可以对很大的模型进行运算 &只能有限并行，比如有多少层就有多少个设备 \\
\end{tabular} \end{tabular}
...@@ -1079,7 +1079,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi ...@@ -1079,7 +1079,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item {\small\bfnew{数据并行}}。如果一台设备能完整放下一个神经机器翻译模型，那么数据并行可以把一个大批次均匀切分成$n$个小批次，然后分发到$n$个设备上并行计算，最后把结果汇总，相当于把运算时间变为原来的${1}/{n}$，数据并行的过程如图\ref{fig:10-27}所示。不过，需要注意的是，多设备并行需要对数据在不同设备间传输，特别是多个GPU的情况，设备间传输的带宽十分有限，设备间传输数据往往会造成额外的时间消耗\upcite{xiao2017fast}。通常，数据并行的训练速度无法随着设备数量增加呈线性增长。不过这个问题也有很多优秀的解决方案，比如采用多个设备的异步训练，但是这些内容已经超出本章的内容，因此这里不做过多讨论。 \item {\small\bfnew{数据并行}}。如果一台设备能完整放下一个神经机器翻译模型，那么数据并行可以把一个大批次均匀切分成$n$个小批次，然后分发到$n$个设备上并行计算，最后把结果汇总，相当于把运算时间变为原来的${1}/{n}$，数据并行的过程如图\ref{fig:10-27}所示。不过，需要注意的是，多设备并行需要在不同设备间传输数据，特别是在多个GPU的情况下，设备间传输的带宽十分有限，设备间传输数据往往会造成额外的时间消耗\upcite{xiao2017fast}。通常，数据并行的训练速度无法随着设备数量增加呈线性增长。不过这个问题也有很多优秀的解决方案，比如采用多个设备的异步训练，但是这些内容已经超出本章的内容，因此这里不做过多讨论。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -1144,7 +1144,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi ...@@ -1144,7 +1144,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi
\label{eq:10-32} \label{eq:10-32}
\end{eqnarray} \end{eqnarray}
\noindent 这里，$\{ \hat{y}_{j1},...,\hat{y}_{jk} \}$表示对于位置$j$翻译概率最大的前$k$个单词，$\{ \hat{\seq{{y}}}_{<j\ast} \}$表示前$j-1$步top-$k$单词组成的所有历史。${\hat{\seq{{y}}}_{<j\ast}}$可以被看作是一个集合，里面每一个元素都是一个目标语言单词序列，这个序列是前面生成的一系列top-$k$单词的某种组成。$\funp{P}(y_j | \{ \hat{\seq{{y}}}_{<{j\ast}} \},\seq{{x}})$表示基于\{$ \hat{\seq{{y}}}_{<j\ast} $\}的某一条路径生成$y_j$的概率\footnote{严格来说，$ \funp{P} (y_j | {\hat{\seq{{y}}}_{<j\ast} })$不是一个准确的数学表达，这里通过这种写法强调$y_j$是由\{$ \hat{\seq{{y}}}_{<j\ast} $\}中的某个译文单词序列作为条件生成的。} 。这种方法也被称为束搜索，意思是搜索时始终考虑一个集束内的候选。 \noindent 这里，$\{ \hat{y}_{j1},...,\hat{y}_{jk} \}$表示对于位置$j$翻译概率最大的前$k$个单词，$\{ \hat{\seq{{y}}}_{<j\ast} \}$表示前$j-1$步top-$k$单词组成的所有历史。${\hat{\seq{{y}}}_{<j\ast}}$可以被看作是一个集合，里面每一个元素都是一个目标语言单词序列，这个序列是前面生成的一系列top-$k$单词的某种组成。$\funp{P}(y_j | \{ \hat{\seq{{y}}}_{<{j\ast}} \},\seq{{x}})$表示基于\{$ \hat{\seq{{y}}}_{<j\ast} $\}的某一条路径生成$y_j$的概率\footnote{严格来说，$ \funp{P} (y_j | {\hat{\seq{{y}}}_{<j\ast} })$不是一个准确的数学表达，公式\eqref{eq:10-32}通过这种写法强调$y_j$是由\{$ \hat{\seq{{y}}}_{<j\ast} $\}中的某个译文单词序列作为条件生成的。} 。这种方法也被称为束搜索，意思是搜索时始终考虑一个集束内的候选。
\parinterval 不论是贪婪搜索还是束搜索都是一个自左向右的过程，也就是每个位置的处理需要等前面位置处理完才能执行。这是一种典型的{\small\bfnew{自回归模型}}\index{自回归模型}（Autoregressive Model）\index{Autoregressive Model}，它通常用来描述时序上的随机过程，其中每一个时刻的结果对时序上其他部分的结果有依赖\upcite{Akaike1969autoregressive}。相对应的，也有{\small\bfnew{非自回归模型}}\index{非自回归模型}（Non-autoregressive Model）\index{Non-autoregressive Model}，它消除了不同时刻结果之间的直接依赖\upcite{Gu2017NonAutoregressiveNM}。由于自回归模型是当今神经机器翻译主流的推断方法，这里仍以自回归的贪婪搜索和束搜索为基础进行讨论。 \parinterval 不论是贪婪搜索还是束搜索都是一个自左向右的过程，也就是每个位置的处理需要等前面位置处理完才能执行。这是一种典型的{\small\bfnew{自回归模型}}\index{自回归模型}（Autoregressive Model）\index{Autoregressive Model}，它通常用来描述时序上的随机过程，其中每一个时刻的结果对时序上其他部分的结果有依赖\upcite{Akaike1969autoregressive}。相对应的，也有{\small\bfnew{非自回归模型}}\index{非自回归模型}（Non-autoregressive Model）\index{Non-autoregressive Model}，它消除了不同时刻结果之间的直接依赖\upcite{Gu2017NonAutoregressiveNM}。由于自回归模型是当今神经机器翻译主流的推断方法，这里仍以自回归的贪婪搜索和束搜索为基础进行讨论。
...@@ -1228,7 +1228,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi ...@@ -1228,7 +1228,7 @@ L(\widehat{\mathbi{Y}},\mathbi{Y}) &=& \sum_{j=1}^n L_{\textrm{ce}}(\hat{\mathbi
\label{eq:10-34} \label{eq:10-34}
\end{eqnarray} \end{eqnarray}
\noindent $\textrm{cp}(\cdot)$会惩罚把某些源语言单词对应到很多目标语言单词的情况（覆盖度），被覆盖的程度用$\sum_j^{|\seq{{y}}|} \alpha_{ij}$度量。$\beta$也是需要经验性设置的超参数，用于对覆盖度惩罚的强度进行控制。 \noindent $\textrm{cp}(\cdot)$会惩罚把某些源语言单词对应到很多目标语言单词的情况（覆盖度），被覆盖的程度用$\sum_j^{|\seq{{y}}|} \alpha_{ij}$度量。$\beta$是需要根据经验设置的超参数，用于对覆盖度惩罚的强度进行控制。
\parinterval 最终，模型得分定义如下： \parinterval 最终，模型得分定义如下：
\begin{eqnarray} \begin{eqnarray}
......
Chapter11/chapter11.tex
...@@ -53,14 +53,14 @@ ...@@ -53,14 +53,14 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 图\ref{fig:11-2}展示了一个标准的卷积神经网络模块，其中包括了卷积层、激活函数和池化层三个部分。本节将对卷积神经网络中的基本结构进行介绍。 \parinterval 图\ref{fig:11-2}展示了一个标准的卷积神经网络结构，其中包括了卷积层、激活函数和池化层三个部分。本节将对卷积神经网络中的基本结构进行介绍。
%---------------------------------------------- %----------------------------------------------
% 图2. % 图2.
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\input{./Chapter11/Figures/figure-standard-convolution-neural-network-module} \input{./Chapter11/Figures/figure-standard-convolution-neural-network-module}
\caption{标准的卷积神经网络模块（卷积、激活函数、池化）} \caption{标准的卷积神经网络结构（卷积、激活函数、池化）}
\label{fig:11-2} \label{fig:11-2}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
...@@ -201,7 +201,7 @@ ...@@ -201,7 +201,7 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\vspace{-1em} \vspace{-1em}
\parinterval 针对不定长序列，一种可行的方法是使用之前介绍过的循环神经网络进行信息提取，其本质也是基于权重共享的想法，在不同的时间步复用相同的循环神经网络单元进行处理。但是，循环神经网络最大的弊端在于每一时刻的计算都依赖于上一时刻的结果，因此只能对序列进行串行处理，无法充分利用硬件设备进行并行计算，导致效率相对较低。此外，在处理较长的序列时，这种串行的方式很难捕捉长距离的依赖关系。相比之下，卷积神经网络采用共享参数的方式处理固定大小窗口内的信息，且不同位置的卷积操作之间没有相互依赖，因此可以对序列进行高效地并行处理。同时，针对序列中距离较长的依赖关系，可以通过堆叠多层卷积层来扩大{\small\bfnew{感受野}}\index{感受野} (Receptive Field)\index{Receptive Field} ，这里感受野指能够影响神经元输出的原始输入数据区域的大小。图\ref{fig:11-9}对比了这两种结构，可以看出，为了捕捉$\mathbi{e}_2$ 和$\mathbi{e}_8$ 之间的联系，串行结构需要顺序地进行6次操作，和序列长度相关。而该卷积神经网络中，卷积操作每次对三个词进行计算，仅需要4层卷积计算就能得到$\mathbi{e}_2$ 和$\mathbi{e}_8$之间的联系，其操作数和卷积核的大小相关，相比于串行的方式具有更短的路径和更少的非线性计算，更容易进行训练。因此，也有许多研究人员在许多自然语言处理任务上尝试使用卷积神经网络进行序列建模\upcite{Kim2014ConvolutionalNN,Santos2014DeepCN,Kalchbrenner2014ACN,DBLP:conf/naacl/Johnson015,DBLP:conf/naacl/NguyenG15}。 \parinterval 针对不定长序列，一种可行的方法是使用之前介绍过的循环神经网络进行信息提取，其本质也是基于权重共享的想法，在不同的时间步复用相同的循环神经网络单元进行处理。但是，循环神经网络最大的弊端在于每一时刻的计算都依赖于上一时刻的结果，因此只能对序列进行串行处理，无法充分利用硬件设备进行并行计算，导致效率相对较低。此外，在处理较长的序列时，这种串行的方式很难捕捉长距离的依赖关系。相比之下，卷积神经网络采用共享参数的方式处理固定大小窗口内的信息，且不同位置的卷积操作之间没有相互依赖，因此可以对序列进行高效地并行处理。同时，针对序列中距离较长的依赖关系，可以通过堆叠多层卷积层来扩大{\small\bfnew{感受野}}\index{感受野} (Receptive Field)\index{Receptive Field} ，这里感受野指能够影响神经元输出的原始输入数据区域的大小。图\ref{fig:11-9}对比了这两种结构，可以看出，为了捕捉$\mathbi{e}_2$ 和$\mathbi{e}_8$ 之间的联系，串行结构需要顺序地进行6次操作，操作次数与序列长度相关。而该卷积神经网络中，卷积操作每次对三个词进行计算，仅需要4层卷积计算就能得到$\mathbi{e}_2$ 和$\mathbi{e}_8$之间的联系，其操作数和卷积核的大小相关，相比于串行的方式具有更短的路径和更少的非线性计算，更容易进行训练。因此，也有许多研究人员在许多自然语言处理任务上尝试使用卷积神经网络进行序列建模\upcite{Kim2014ConvolutionalNN,Santos2014DeepCN,Kalchbrenner2014ACN,DBLP:conf/naacl/Johnson015,DBLP:conf/naacl/NguyenG15}。
\parinterval 区别于传统图像上的卷积操作，在面向序列的卷积操作中，卷积核只在序列这一维度进行移动，用来捕捉连续的多个词之间的特征。需要注意的是，由于单词通常由一个实数向量表示（词嵌入），因此可以将词嵌入的维度看作是卷积操作中的通道数。图\ref{fig:11-10}就是一个基于序列卷积的文本分类模型，模型的输入是维度大小为$m\times O $的句子表示，$m$表示句子长度，$O$表示卷积核通道数，其值等于词嵌入维度，模型使用多个不同（对应图中不同的颜色）的卷积核来对序列进行特征提取，得到了多个不同的特征序列。然后使用池化层降低表示维度，得到了一组和序列长度无关的特征表示。最后模型基于这组压缩过的特征表示，使用全连接网络和Softmax函数进行类别预测。在这过程中卷积层和池化层分别起到了特征提取和特征压缩的作用，将一个不定长的序列转化为一组固定大小的特征表示。 \parinterval 区别于传统图像上的卷积操作，在面向序列的卷积操作中，卷积核只在序列这一维度进行移动，用来捕捉连续的多个词之间的特征。需要注意的是，由于单词通常由一个实数向量表示（词嵌入），因此可以将词嵌入的维度看作是卷积操作中的通道数。图\ref{fig:11-10}就是一个基于序列卷积的文本分类模型，模型的输入是维度大小为$m\times O $的句子表示，$m$表示句子长度，$O$表示卷积核通道数，其值等于词嵌入维度，模型使用多个不同（对应图中不同的颜色）的卷积核来对序列进行特征提取，得到了多个不同的特征序列。然后使用池化层降低表示维度，得到了一组和序列长度无关的特征表示。最后模型基于这组压缩过的特征表示，使用全连接网络和Softmax函数进行类别预测。在这过程中卷积层和池化层分别起到了特征提取和特征压缩的作用，将一个不定长的序列转化为一组固定大小的特征表示。
...@@ -215,7 +215,7 @@ ...@@ -215,7 +215,7 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\vspace{-1em} \vspace{-1em}
\parinterval 和其它自然语言处理任务不同的是，机器翻译中需要对序列进行全局表示，换句话说，模型需要捕捉序列中各个位置之间的关系。因此，基于卷积神经网络的神经机器翻译模型需要堆叠多个卷积层进行远距离的依赖关系的建模。同时，为了在多层网络中维持序列的原有长度，需要在卷积操作前对输入序列进行填充。图\ref{fig:11-11}是一个简单的示例，针对一个长度$m=6$的句子，其隐层表示维度即卷积操作的输入通道数是$O=4$，卷积核大小为$K=3$。首先对序列进行填充，得到一个长度为8的序列，然后使用这些卷积核在这之上进行特征提取。一共使用了$N=4$个卷积核，整体的参数量为$K \times O \times N$，最后的卷积结果为$m \times N$的序列表示。 \parinterval 和其它自然语言处理任务不同的是，机器翻译中需要对序列进行全局表示，换句话说，模型需要捕捉序列中各个位置之间的关系。因此，基于卷积神经网络的神经机器翻译模型需要堆叠多个卷积层进行远距离的依赖关系的建模。同时，为了在多层网络中维持序列的原有长度，需要在卷积操作前对输入序列进行填充。图\ref{fig:11-11}是一个简单的示例，针对一个长度$m=6$的句子，其隐藏层表示维度即卷积操作的输入通道数是$O=4$，卷积核大小为$K=3$。首先对序列进行填充，得到一个长度为8的序列，然后使用这些卷积核在这之上进行特征提取。一共使用了$N=4$个卷积核，整体的参数量为$K \times O \times N$，最后的卷积结果为$m \times N$的序列表示。
%---------------------------------------------- %----------------------------------------------
% 图11. % 图11.
...@@ -254,7 +254,7 @@ ...@@ -254,7 +254,7 @@
\item {\small\bfnew{卷积层}}与{\small\bfnew{门控线性单元}}（Gated Linear Units, GLU\index{Gated Linear Units}）：黄色背景框是卷积模块，这里使用门控线性单元作为非线性函数，之前的研究工作\upcite{Dauphin2017LanguageMW} 表明这种非线性函数更适合于序列建模任务。图中为了简化，只展示了一层卷积，但在实际中为了更好地捕获句子信息，通常使用多层卷积的叠加。 \item {\small\bfnew{卷积层}}与{\small\bfnew{门控线性单元}}（Gated Linear Units, GLU\index{Gated Linear Units}）：黄色背景框是卷积模块，这里使用门控线性单元作为非线性函数，之前的研究工作\upcite{Dauphin2017LanguageMW} 表明这种非线性函数更适合于序列建模任务。图中为了简化，只展示了一层卷积，但在实际中为了更好地捕获句子信息，通常使用多层卷积的叠加。
\item {\small\bfnew{残差连接}}\index{残差连接}（Residual Connection）\index{Residual Connection}：源语言端和目标语言端的卷积层网络之间，都存在一个从输入到输出的额外连接，即跳接\upcite{DBLP:journals/corr/HeZRS15}。该连接方式确保每个隐层输出都能包含输入序列中的更多信息，同时能够有效提高深层网络的信息传递效率（该部分在图\ref{fig:11-12}中没有显示，具体结构详见\ref{sec:11.2.3}节）。 \item {\small\bfnew{残差连接}}\index{残差连接}（Residual Connection）\index{Residual Connection}：源语言端和目标语言端的卷积层网络之间，都存在一个从输入到输出的额外连接，即跳接\upcite{DBLP:journals/corr/HeZRS15}。该连接方式确保每个隐藏层输出都能包含输入序列中的更多信息，同时能够有效提高深层网络的信息传递效率（该部分在图\ref{fig:11-12}中没有显示，具体结构详见\ref{sec:11.2.3}节）。
\item {\small\bfnew{多步注意力机制}}\index{多步注意力机制}（Multi-step Attention）\index{Multi-step Attention}：蓝色框内部展示了基于多步结构的注意力机制模块\upcite{Sukhbaatar2015EndToEndMN}。ConvS2S模型同样使用注意力机制来捕捉两个序列之间不同位置的对应关系。区别于之前的做法，多步注意力在解码器端每一个层都会执行注意力操作。下面将以此模型为例对基于卷积神经网络的机器翻译模型进行介绍。 \item {\small\bfnew{多步注意力机制}}\index{多步注意力机制}（Multi-step Attention）\index{Multi-step Attention}：蓝色框内部展示了基于多步结构的注意力机制模块\upcite{Sukhbaatar2015EndToEndMN}。ConvS2S模型同样使用注意力机制来捕捉两个序列之间不同位置的对应关系。区别于之前的做法，多步注意力在解码器端每一个层都会执行注意力操作。下面将以此模型为例对基于卷积神经网络的机器翻译模型进行介绍。
\end{itemize} \end{itemize}
...@@ -290,7 +290,7 @@ ...@@ -290,7 +290,7 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 门控机制在{\chapterten}中介绍LSTM模型时已经提到过。在LSTM模型中，可以通过引入三个门控单元来控制信息流，使隐层状态能够获得长时间记忆。同时，门控单元的引入简化了不同时间步间状态更新的计算，只包括一些线性计算，缓解了长距离建模中梯度消失的问题。在多层卷积神经网络中，同样可以通过门控机制来起到相同的作用。 \parinterval 门控机制在{\chapterten}中介绍LSTM模型时已经提到过。在LSTM模型中，可以通过引入三个门控单元来控制信息流，使隐藏层状态能够获得长时间记忆。同时，门控单元的引入简化了不同时间步间状态更新的计算，只包括一些线性计算，缓解了长距离建模中梯度消失的问题。在多层卷积神经网络中，同样可以通过门控机制来起到相同的作用。
\parinterval 图\ref{fig:11-14}是单层门控卷积神经网络的基本结构，$\mathbi{x}\in \mathbb{R}^{m\times d}$为单层网络的输入，$\mathbi{y} \in \mathbb{R}^{m \times d}$为单层网络的输出，网络结构主要包括卷积计算和GLU非线性单元两部分。 \parinterval 图\ref{fig:11-14}是单层门控卷积神经网络的基本结构，$\mathbi{x}\in \mathbb{R}^{m\times d}$为单层网络的输入，$\mathbi{y} \in \mathbb{R}^{m \times d}$为单层网络的输出，网络结构主要包括卷积计算和GLU非线性单元两部分。
...@@ -319,7 +319,7 @@ ...@@ -319,7 +319,7 @@
\noindent 其中，$\sigma$为Sigmoid函数，$\otimes$为按位乘运算。Sigmoid将$\mathbi{B}$映射为0-1范围内的实数，用来充当门控。可以看到，门控卷积神经网络中核心部分就是$\sigma ( \mathbi{B} )$，通过这个门控单元来对卷积输出进行控制，确定保留哪些信息。同时，在梯度反向传播的过程中，这种机制使得不同层之间存在线性的通道，梯度传导更加简单，利于深层网络的训练。这种思想和\ref{sec:11.2.3}节将要介绍的残差网络也很类似。 \noindent 其中，$\sigma$为Sigmoid函数，$\otimes$为按位乘运算。Sigmoid将$\mathbi{B}$映射为0-1范围内的实数，用来充当门控。可以看到，门控卷积神经网络中核心部分就是$\sigma ( \mathbi{B} )$，通过这个门控单元来对卷积输出进行控制，确定保留哪些信息。同时，在梯度反向传播的过程中，这种机制使得不同层之间存在线性的通道，梯度传导更加简单，利于深层网络的训练。这种思想和\ref{sec:11.2.3}节将要介绍的残差网络也很类似。
\parinterval 在ConvS2S模型中，为了保证卷积操作之后的序列长度不变，需要对输入进行填充，这一点已经在之前的章节中讨论过了。因此，在编码器每一次卷积操作前，需要对序列的头部和尾部分别做相应的填充（如图\ref{fig:11-14}左侧部分）。而在解码器中，由于需要训练和解码的一致性，模型在训练过程中不能使用未来的信息，需要对未来信息进行屏蔽，也就是屏蔽掉当前译文单词右侧的译文信息。从实践角度来看，只需要对解码器输入序列的头部填充$K-1$ 个空元素，其中$K$为卷积核的宽度（图\ref{fig:11-15}展示了卷积核宽度$K$=3时，解码器对输入序列的填充情况，图中三角形表示卷积操作）。 \parinterval 在ConvS2S模型中，为了保证卷积操作之后的序列长度不变，需要对输入进行填充，这一点已经在之前的章节中讨论过了。因此，在编码器每一次卷积操作前，需要对序列的头部和尾部分别做相应的填充（如图\ref{fig:11-14}左侧部分）。而在解码器中，由于需要训练和解码保持一致，模型在训练过程中不能使用未来的信息，需要对未来信息进行屏蔽，也就是屏蔽掉当前译文单词右侧的译文信息。从实践角度来看，只需要对解码器输入序列的头部填充$K-1$ 个空元素，其中$K$为卷积核的宽度（图\ref{fig:11-15}展示了卷积核宽度$K$=3时，解码器对输入序列的填充情况，图中三角形表示卷积操作）。
%---------------------------------------------- %----------------------------------------------
% 图14-2. % 图14-2.
...@@ -368,7 +368,7 @@ ...@@ -368,7 +368,7 @@
\alpha_{i,j} &=& \frac{ \textrm{exp}(\funp{a} (\mathbi{s}_{j-1},\mathbi{h}_i)) }{\sum_{i'} \textrm{exp}( \funp{a} (\mathbi{s}_{j-1},\mathbi{h}_{i'}))} \label{eq:11-9} \alpha_{i,j} &=& \frac{ \textrm{exp}(\funp{a} (\mathbi{s}_{j-1},\mathbi{h}_i)) }{\sum_{i'} \textrm{exp}( \funp{a} (\mathbi{s}_{j-1},\mathbi{h}_{i'}))} \label{eq:11-9}
\end{eqnarray} \end{eqnarray}
\noindent 其中，$\mathbi{h}_i$表示源语言端第$i$个位置的隐层状态，即编码器在第$i$个位置的输出。$\mathbi{s}_j$表示目标端第$j$个位置的隐层状态。给定$\mathbi{s}_j$和$\mathbi{h}_i$，注意力机制通过函数$\funp{a}(\cdot)$计算目标语言表示$\mathbi{s}_j$与源语言表示$\mathbi{h}_i$之间的注意力权重$\alpha_{i,j}$，通过加权平均得到当前目标语言端位置所需的上下文表示$\mathbi{C}_j$。其中$\funp{a}(\cdot)$的具体计算方式在{\chapterten}已经详细讨论。 \noindent 其中，$\mathbi{h}_i$表示源语言端第$i$个位置的隐藏层状态，即编码器在第$i$个位置的输出。$\mathbi{s}_j$表示目标端第$j$个位置的隐藏层状态。给定$\mathbi{s}_j$和$\mathbi{h}_i$，注意力机制通过函数$\funp{a}(\cdot)$计算目标语言表示$\mathbi{s}_j$与源语言表示$\mathbi{h}_i$之间的注意力权重$\alpha_{i,j}$，通过加权平均得到当前目标语言端位置所需的上下文表示$\mathbi{C}_j$。其中$\funp{a}(\cdot)$的具体计算方式在{\chapterten}已经详细讨论。
%---------------------------------------------- %----------------------------------------------
% 图16. % 图16.
...@@ -386,7 +386,7 @@ ...@@ -386,7 +386,7 @@
\label{eq:11-10} \label{eq:11-10}
\end{eqnarray} \end{eqnarray}
\noindent 不同于公式\eqref{eq:11-9}中使用的目标语言端隐层表示$\mathbi{s}_{j-1}$，公式\eqref{eq:11-10}中的$\mathbi{d}_{j}^l$同时结合了$\mathbi{s}_{j}$的卷积计算结果和目标语言端的词嵌入$\mathbi{g}_j$，其具体计算如公式\eqref{eq:11-11}和\eqref{eq:11-12}所示： \noindent 不同于公式\eqref{eq:11-9}中使用的目标语言端隐藏层表示$\mathbi{s}_{j-1}$，公式\eqref{eq:11-10}中的$\mathbi{d}_{j}^l$同时结合了$\mathbi{s}_{j}$的卷积计算结果和目标语言端的词嵌入$\mathbi{g}_j$，其具体计算如公式\eqref{eq:11-11}和\eqref{eq:11-12}所示：
\begin{eqnarray} \begin{eqnarray}
\mathbi{d}_{j}^l &=& \mathbi{W}_{d}^{l} \mathbi{z}_{j}^{l} + \mathbi{b}_{d}^{l} + \mathbi{g}_j \label{eq:11-11} \\ \mathbi{d}_{j}^l &=& \mathbi{W}_{d}^{l} \mathbi{z}_{j}^{l} + \mathbi{b}_{d}^{l} + \mathbi{g}_j \label{eq:11-11} \\
\mathbi{z}_j^l &=& \textrm{Conv}(\mathbi{s}_j^l) \label{eq:11-12} \mathbi{z}_j^l &=& \textrm{Conv}(\mathbi{s}_j^l) \label{eq:11-12}
...@@ -414,7 +414,7 @@ ...@@ -414,7 +414,7 @@
\parinterval 与基于循环神经网络的翻译模型一致，ConvS2S模型会计算每个目标语言位置上不同单词的概率，并以交叉熵作为损失函数来衡量模型预测分布与标准分布之间的差异。同时，采用基于梯度的方法对网络中的参数进行更新（见{\chapternine}）。 \parinterval 与基于循环神经网络的翻译模型一致，ConvS2S模型会计算每个目标语言位置上不同单词的概率，并以交叉熵作为损失函数来衡量模型预测分布与标准分布之间的差异。同时，采用基于梯度的方法对网络中的参数进行更新（见{\chapternine}）。
\parinterval ConvS2S模型应用了很多工程方面的调整，主要包括： \parinterval ConvS2S模型的训练与基于循环神经网络的翻译模型的训练的主要区别是：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item ConvS2S模型使用了{\small\bfnew{Nesterov加速梯度下降法}} \index{Nesterov加速梯度下降法}（Nesterov Accelerated Gradient，NAG）\index{Nesterov Accelerated Gradient}，动量累计的系数设置为0.99，当梯度范数超过0.1时重新进行规范化\upcite{Sutskever2013OnTI}； \item ConvS2S模型使用了{\small\bfnew{Nesterov加速梯度下降法}} \index{Nesterov加速梯度下降法}（Nesterov Accelerated Gradient，NAG）\index{Nesterov Accelerated Gradient}，动量累计的系数设置为0.99，当梯度范数超过0.1时重新进行规范化\upcite{Sutskever2013OnTI}；
...@@ -439,7 +439,7 @@ ...@@ -439,7 +439,7 @@
\label{eq:11-17} \label{eq:11-17}
\end{eqnarray} \end{eqnarray}
\parinterval Nesterov加速梯度下降法利用了二阶导数的信息，可以做到“向前看”，加速收敛过程\upcite{Bengio2013AdvancesIO}。为了模型的稳定训练。ConvS2S模型也采用了一些网络正则化和参数初始化的策略，使得模型在前向计算和反向计算过程中方差尽可能保持一致。 \parinterval Nesterov加速梯度下降法利用了二阶导数的信息，可以做到“向前看”，加速收敛过程\upcite{Bengio2013AdvancesIO}。ConvS2S 模型也采用了一些网络正则化和参数初始化的策略，使得模型在前向计算和反向计算的过程中，方差尽可能保持一致，模型训练更稳定。
\parinterval 此外，ConvS2S模型为了进一步提升训练效率及性能，还使用了小批量训练，即每次从样本中选择出一小部分数据进行训练。同时，ConvS2S模型中也使用了Dropout方法\upcite{JMLR:v15:srivastava14a}。除了在词嵌入层和解码器输出层应用Dropout外，ConvS2S模型还对卷积块的输入层应用了Dropout。 \parinterval 此外，ConvS2S模型为了进一步提升训练效率及性能，还使用了小批量训练，即每次从样本中选择出一小部分数据进行训练。同时，ConvS2S模型中也使用了Dropout方法\upcite{JMLR:v15:srivastava14a}。除了在词嵌入层和解码器输出层应用Dropout外，ConvS2S模型还对卷积块的输入层应用了Dropout。
...@@ -460,7 +460,7 @@ ...@@ -460,7 +460,7 @@
\subsection{深度可分离卷积} \subsection{深度可分离卷积}
\label{sec:11.3.1} \label{sec:11.3.1}
\parinterval 根据前面的介绍，可以看到卷积神经网络容易用于局部检测和处理位置不变的特征。对于特定的表达，比如地点、情绪等，使用卷积神经网络能达到不错的识别效果，因此它常被用在文本分类中\upcite{Kalchbrenner2014ACN,Kim2014ConvolutionalNN,DBLP:conf/naacl/Johnson015,DBLP:conf/acl/JohnsonZ17}。不过机器翻译所面临的情况更复杂，除了局部句子片段信息，研究人员还希望模型能够捕获句子结构、语义等信息。虽然单层卷积神经网络在文本分类中已经取得了很好的效果\upcite{Kim2014ConvolutionalNN}，但是神经机器翻译等任务仍然需要有效的卷积神经网络。随着深度可分离卷积在机器翻译中的探索\upcite{Kaiser2018DepthwiseSC}，更高效的网络结构被设计出来，获得了比ConvS2S模型更好的性能。 \parinterval 根据前面的介绍，可以看到卷积神经网络适用于局部检测和处理位置不变的特征。对于特定的表达，比如地点、情绪等，使用卷积神经网络能达到不错的识别效果，因此它常被用在文本分类中\upcite{Kalchbrenner2014ACN,Kim2014ConvolutionalNN,DBLP:conf/naacl/Johnson015,DBLP:conf/acl/JohnsonZ17}。不过机器翻译所面临的情况更复杂，除了局部句子片段信息，研究人员还希望模型能够捕获句子结构、语义等信息。虽然单层卷积神经网络在文本分类中已经取得了很好的效果\upcite{Kim2014ConvolutionalNN}，但是神经机器翻译等任务仍然需要有效的卷积神经网络。随着深度可分离卷积在机器翻译中的探索\upcite{Kaiser2018DepthwiseSC}，更高效的网络结构被设计出来，获得了比ConvS2S模型更好的性能。
%---------------------------------------------- %----------------------------------------------
% 图17. % 图17.
......
Chapter12/chapter12.tex
...@@ -25,7 +25,7 @@ ...@@ -25,7 +25,7 @@
循环神经网络和卷积神经网络是两种经典的神经网络结构，在机器翻译中进行应用也是较为自然的想法。但是，这些模型在处理文字序列时也有问题：它们对序列中不同位置之间的依赖关系的建模并不直接。以卷积神经网络为例，如果要对长距离依赖进行描述，需要多层卷积操作，而且不同层之间信息传递也可能有损失，这些都限制了模型的能力。 循环神经网络和卷积神经网络是两种经典的神经网络结构，在机器翻译中进行应用也是较为自然的想法。但是，这些模型在处理文字序列时也有问题：它们对序列中不同位置之间的依赖关系的建模并不直接。以卷积神经网络为例，如果要对长距离依赖进行描述，需要多层卷积操作，而且不同层之间信息传递也可能有损失，这些都限制了模型的能力。
为了更好地描述文字序列，研究人员提出了一种新的模型Transformer。Transformer并不依赖任何循环单元或者卷积单元，而是使用一种被称作自注意力网络的结构来对序列进行表示。自注意力可以非常高效的描述任意距离之间的依赖关系，因此非常适合处理语言文字序列。Transformer一经提出就受到了广泛关注，现在已经成为了机器翻译中最先进的架构之一。本章将会对Transformer的基本结构和实现技术进行介绍。这部分知识也会在本书的前沿部分（{\chapterthirteen}$\sim${\chaptereighteen}）中大量使用。 为了更好地描述文字序列，研究人员提出了一种新的模型Transformer。Transformer并不依赖任何循环单元或者卷积单元，而是使用一种被称作自注意力网络的结构来对序列进行表示。自注意力机制可以非常高效的描述任意距离之间的依赖关系，因此非常适合处理语言文字序列。Transformer一经提出就受到了广泛关注，现在已经成为了机器翻译中最先进的架构之一。本章将会对Transformer的基本结构和实现技术进行介绍。这部分知识也会在本书的前沿部分（{\chapterthirteen}$\sim${\chaptereighteen}）中大量使用。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION 12.1 % NEW SECTION 12.1
...@@ -68,7 +68,7 @@ ...@@ -68,7 +68,7 @@
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\input{./Chapter12/Figures/figure-example-of-self-attention-mechanism-calculation} \input{./Chapter12/Figures/figure-example-of-self-attention-mechanism-calculation}
\caption{自注意力计算实例} \caption{自注意力机制的计算实例}
\label{fig:12-3} \label{fig:12-3}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
...@@ -90,7 +90,7 @@ ...@@ -90,7 +90,7 @@
% NEW SECTION % NEW SECTION
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\sectionnewpage \sectionnewpage
\section{Transformer架构} \section{Transformer模型}
下面对Transformer模型的由来以及总体架构进行介绍。 下面对Transformer模型的由来以及总体架构进行介绍。
...@@ -107,7 +107,7 @@ ...@@ -107,7 +107,7 @@
%---------------------------------------------- %----------------------------------------------
\begin{table}[htp] \begin{table}[htp]
\centering \centering
\caption{ RNN、CNN、Transformer的层类型复杂度对比\upcite{vaswani2017attention} （$n$表示序列长度，$d$表示隐层大小，$k$表示卷积核大小） } \caption{ RNN、CNN、Transformer的层类型复杂度对比\upcite{vaswani2017attention} （$n$表示序列长度，$d$表示隐藏层大小，$k$表示卷积核大小） }
\label{tab:12-1} \label{tab:12-1}
\begin{tabular}{c | c c c c} \begin{tabular}{c | c c c c}
\rule{0pt}{20pt} 模型 & 层类型 & \begin{tabular}[l]{@{}l@{}}复杂度\end{tabular} & \begin{tabular}[l]{@{}l@{}}最小顺序 \\ 操作数\end{tabular} & \begin{tabular}[l]{@{}l@{}}最大路径\\ 长度\end{tabular} \\ \hline \rule{0pt}{20pt} 模型 & 层类型 & \begin{tabular}[l]{@{}l@{}}复杂度\end{tabular} & \begin{tabular}[l]{@{}l@{}}最小顺序 \\ 操作数\end{tabular} & \begin{tabular}[l]{@{}l@{}}最大路径\\ 长度\end{tabular} \\ \hline
...@@ -221,7 +221,7 @@ ...@@ -221,7 +221,7 @@
\textrm{PE}(\textrm{pos},2i+1) & = & \textrm{cos} (\frac{\textrm{pos}}{10000^{2i/d_{\textrm{model}}}}) \label{eq:12-4} \textrm{PE}(\textrm{pos},2i+1) & = & \textrm{cos} (\frac{\textrm{pos}}{10000^{2i/d_{\textrm{model}}}}) \label{eq:12-4}
\end{eqnarray} \end{eqnarray}
\noindent 式中PE($\cdot$)表示位置编码的函数，$\textrm{pos}$表示单词的位置，$i$代表位置编码向量中的第几维，$d_{\textrm{model}}$是Transformer的一个基础参数，表示每个位置的隐层大小。因为，正余弦函数的编码各占一半，因此当位置编码的维度为512 时，$i$ 的范围是0-255。 在Transformer中，位置编码的维度和词嵌入向量的维度相同（均为$d_{\textrm{model}}$），模型通过将二者相加作为模型输入，如图\ref{fig:12-8}所示。 \noindent 式中PE($\cdot$)表示位置编码的函数，$\textrm{pos}$表示单词的位置，$i$代表位置编码向量中的第几维，$d_{\textrm{model}}$是Transformer的一个基础参数，表示每个位置的隐藏层大小。因为，正余弦函数的编码各占一半，因此当位置编码的维度为512 时，$i$ 的范围是0-255。 在Transformer中，位置编码的维度和词嵌入向量的维度相同（均为$d_{\textrm{model}}$），模型通过将二者相加作为模型输入，如图\ref{fig:12-8}所示。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -291,13 +291,13 @@ ...@@ -291,13 +291,13 @@
\parinterval 在此基础上，通过对相关性矩阵累加一个掩码矩阵$\mathbi{Mask}$，来屏蔽掉矩阵中的无用信息。比如，在编码器端，如果需要对多个句子同时处理，由于这些句子长度不统一，需要对句子补齐。再比如，在解码器端，训练的时候需要屏蔽掉当前目标语言位置右侧的单词，因此这些单词在推断的时候是看不到的。 \parinterval 在此基础上，通过对相关性矩阵累加一个掩码矩阵$\mathbi{Mask}$，来屏蔽掉矩阵中的无用信息。比如，在编码器端，如果需要对多个句子同时处理，由于这些句子长度不统一，需要对句子补齐。再比如，在解码器端，训练的时候需要屏蔽掉当前目标语言位置右侧的单词，因此这些单词在推断的时候是看不到的。
\parinterval 随后，使用Softmax函数对相关性矩阵在行的维度上进行归一化操作，这可以理解为对第$i$ 行进行归一化，结果对应了$\mathbi{V}$ 中不同位置上向量的注意力权重。对于$\mathrm{value}$ 的加权求和，可以直接用相关性系数和$\mathbi{V}$ 进行矩阵乘法得到，即$\textrm{Softmax} \parinterval 随后，使用Softmax函数对相关性矩阵在行的维度上进行归一化操作，这可以理解为对第$i$ 行进行归一化，结果对应了$\mathbi{V}$ 中不同位置上向量的注意力权重。对于$\mathrm{value}$ 的加权求和，可以直接用相关性系数和$\mathbi{V}$ 进行矩阵乘法得到，即$\textrm{Softmax}
( \frac{\mathbi{Q}\mathbi{K}^{\textrm{T}}} {\sqrt{d_k}} + \mathbi{Mask} )$和$\mathbi{V}$进行矩阵乘。最终得到自注意力的输出，它和输入的$\mathbi{V}$的大小是一模一样的。图\ref{fig:12-10}展示了点乘注意力计算的全过程。 ( \frac{\mathbi{Q}\mathbi{K}^{\textrm{T}}} {\sqrt{d_k}} + \mathbi{Mask} )$和$\mathbi{V}$进行矩阵乘。最终得到自注意力的输出，它和输入的$\mathbi{V}$的大小是一模一样的。图\ref{fig:12-10}展示了点乘注意力的计算过程。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\input{./Chapter12/Figures/figure-point-product-attention-model} \input{./Chapter12/Figures/figure-point-product-attention-model}
\caption{点乘注意力模型 } \caption{点乘注意力的计算过程}
\label{fig:12-10} \label{fig:12-10}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
...@@ -319,17 +319,17 @@ ...@@ -319,17 +319,17 @@
\subsection{多头注意力机制} \subsection{多头注意力机制}
\parinterval Transformer中使用的另一项重要技术是{\small\bfnew{多头注意力机制}}\index{多头注意力机制}（Multi-head Attention）\index{Multi-head Attention}。“多头”可以理解成将原来的$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$按照隐层维度平均切分成多份。假设切分$h$份，那么最终会得到$\mathbi{Q} = \{ \mathbi{Q}_1,...,\mathbi{Q}_h \}$，$\mathbi{K}=\{ \mathbi{K}_1,...,\mathbi{K}_h \}$，$\mathbi{V}=\{ \mathbi{V}_1,...,\mathbi{V}_h \}$。多头注意力就是用每一个切分得到的$\mathbi{Q}$，$\mathbi{K}$，$\mathbi{V}$独立的进行注意力计算，即第$i$个头的注意力计算结果$\mathbi{head}_i = \textrm{Attention}(\mathbi{Q}_i,\mathbi{K}_i, \mathbi{V}_i)$。 \parinterval Transformer中使用的另一项重要技术是{\small\bfnew{多头注意力机制}}\index{多头注意力机制}（Multi-head Attention）\index{Multi-head Attention}。“多头”可以理解成将原来的$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$按照隐藏层维度平均切分成多份。假设切分$h$份，那么最终会得到$\mathbi{Q} = \{ \mathbi{Q}_1,...,\mathbi{Q}_h \}$，$\mathbi{K}=\{ \mathbi{K}_1,...,\mathbi{K}_h \}$，$\mathbi{V}=\{ \mathbi{V}_1,...,\mathbi{V}_h \}$。多头注意力就是用每一个切分得到的$\mathbi{Q}$，$\mathbi{K}$，$\mathbi{V}$独立的进行注意力计算，即第$i$个头的注意力计算结果$\mathbi{head}_i = \textrm{Attention}(\mathbi{Q}_i,\mathbi{K}_i, \mathbi{V}_i)$。
\parinterval 下面根据图\ref{fig:12-12}详细介绍多头注意力的计算过程： \parinterval 下面根据图\ref{fig:12-12}详细介绍多头注意力的计算过程：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item 首先，将$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$分别通过线性（Linear）变换的方式映射为$h$个子集。即$\mathbi{Q}_i = \mathbi{Q}\mathbi{W}_i^{\,Q} $、$\mathbi{K}_i = \mathbi{K}\mathbi{W}_i^{\,K} $、$\mathbi{V}_i = \mathbi{V}\mathbi{W}_i^{\,V} $，其中$i$表示第$i$个头， $\mathbi{W}_i^{\,Q} \in \mathbb{R}^{d_{\textrm{model}} \times d_k}$, $\mathbi{W}_i^{\,K} \in \mathbb{R}^{d_{\textrm{model}} \times d_k}$, $\mathbi{W}_i^{\,V} \in \mathbb{R}^{d_{\textrm{model}} \times d_v}$是参数矩阵; $d_k=d_v=d_{\textrm{model}} / h$，对于不同的头采用不同的变换矩阵，这里$d_{\textrm{model}}$表示每个隐层向量的维度； \item 首先，将$\mathbi{Q}$、$\mathbi{K}$、$\mathbi{V}$分别通过线性（Linear）变换的方式映射为$h$个子集。即$\mathbi{Q}_i = \mathbi{Q}\mathbi{W}_i^{\,Q} $、$\mathbi{K}_i = \mathbi{K}\mathbi{W}_i^{\,K} $、$\mathbi{V}_i = \mathbi{V}\mathbi{W}_i^{\,V} $，其中$i$表示第$i$个头， $\mathbi{W}_i^{\,Q} \in \mathbb{R}^{d_{\textrm{model}} \times d_k}$, $\mathbi{W}_i^{\,K} \in \mathbb{R}^{d_{\textrm{model}} \times d_k}$, $\mathbi{W}_i^{\,V} \in \mathbb{R}^{d_{\textrm{model}} \times d_v}$是参数矩阵; $d_k=d_v=d_{\textrm{model}} / h$，对于不同的头采用不同的变换矩阵，这里$d_{\textrm{model}}$表示每个隐藏层向量的维度；
\vspace{0.5em} \vspace{0.5em}
\item 其次，对每个头分别执行点乘注意力操作，并得到每个头的注意力操作的输出$\mathbi{head}_i$； \item 其次，对每个头分别执行点乘注意力操作，并得到每个头的注意力操作的输出$\mathbi{head}_i$；
\vspace{0.5em} \vspace{0.5em}
\item 最后，将$h$个头的注意力输出在最后一维$d_v$进行拼接（Concat）重新得到维度为$hd_v$的输出，并通过对其右乘一个权重矩阵$\mathbi{W}^{\,o}$进行线性变换，从而对多头计算得到的信息进行融合，且将多头注意力输出的维度映射为模型的隐层大小（即$d_{\textrm{model}}$），这里参数矩阵$\mathbi{W}^{\,o} \in \mathbb{R}^{h d_v \times d_{\textrm{model}}}$。 \item 最后，将$h$个头的注意力输出在最后一维$d_v$进行拼接（Concat）重新得到维度为$hd_v$的输出，并通过对其右乘一个权重矩阵$\mathbi{W}^{\,o}$进行线性变换，从而对多头计算得到的信息进行融合，且将多头注意力输出的维度映射为模型的隐藏层大小（即$d_{\textrm{model}}$），这里参数矩阵$\mathbi{W}^{\,o} \in \mathbb{R}^{h d_v \times d_{\textrm{model}}}$。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
...@@ -361,7 +361,7 @@ ...@@ -361,7 +361,7 @@
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item {\small\bfnew{句长补全掩码}}\index{句长补全掩码}（Padding Mask\index{Padding Mask}）。在批量处理多个样本时（训练或解码），由于要对源语言和目标语言的输入进行批次化处理，而每个批次内序列的长度不一样，为了方便对批次内序列进行矩阵表示，需要进行对齐操作，即在较短的序列后面填充0来占位（padding操作）。而这些填充的位置没有意义，不参与注意力机制的计算，因此，需要进行掩码 操作，屏蔽其影响。 \item {\small\bfnew{句长补全掩码}}\index{句长补全掩码}（Padding Mask\index{Padding Mask}）。在批量处理多个样本时（训练或解码），由于要对源语言和目标语言的输入进行批次化处理，而每个批次内序列的长度不一样，为了方便对批次内序列进行矩阵表示，需要进行对齐操作，即在较短的序列后面填充0来占位（padding操作）。而这些填充0的位置没有实际意义，不参与注意力机制的计算，因此，需要进行掩码 操作，屏蔽其影响。
\vspace{0.5em} \vspace{0.5em}
\item {\small\bfnew{未来信息掩码}}\index{未来信息掩码}（Future Mask\index{Future Mask}）。对于解码器来说，由于在预测的时候是自左向右进行的，即第$t$时刻解码器的输出只能依赖于$t$时刻之前的输出。且为了保证训练解码一致，避免在训练过程中观测到目标语言端每个位置未来的信息，因此需要对未来信息进行屏蔽。具体的做法是：构造一个上三角值全为-inf的Mask矩阵，也就是说，在解码器计算中，在当前位置，通过未来信息掩码把序列之后的信息屏蔽掉了，避免了$t$ 时刻之后的位置对当前的计算产生影响。图\ref{fig:12-13}给出了一个具体的实例。 \item {\small\bfnew{未来信息掩码}}\index{未来信息掩码}（Future Mask\index{Future Mask}）。对于解码器来说，由于在预测的时候是自左向右进行的，即第$t$时刻解码器的输出只能依赖于$t$时刻之前的输出。且为了保证训练解码一致，避免在训练过程中观测到目标语言端每个位置未来的信息，因此需要对未来信息进行屏蔽。具体的做法是：构造一个上三角值全为-inf的Mask矩阵，也就是说，在解码器计算中，在当前位置，通过未来信息掩码把序列之后的信息屏蔽掉了，避免了$t$ 时刻之后的位置对当前的计算产生影响。图\ref{fig:12-13}给出了一个具体的实例。
...@@ -370,7 +370,7 @@ ...@@ -370,7 +370,7 @@
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\input{./Chapter12/Figures/figure-mask-instance-for-future-positions-in-transformer} \input{./Chapter12/Figures/figure-mask-instance-for-future-positions-in-transformer}
\caption{Transformer中对于未来位置进行的屏蔽的掩码实例} \caption{Transformer模型对未来位置进行屏蔽的掩码实例}
\label{fig:12-13} \label{fig:12-13}
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
...@@ -457,13 +457,13 @@ ...@@ -457,13 +457,13 @@
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval Transformer使用了全连接网络。全连接网络的作用主要体现在将经过注意力操作之后的表示映射到新的空间中，新的空间会有利于接下来的非线性变换等操作。实验证明，去掉全连接网络会对模型的性能造成很大影响。Transformer的全连接前馈神经网络包含两次线性变换和一次非线性变换（ReLU激活函数:ReLU$(\mathbi{x})=\textrm{max}⁡(0,\mathbi{x})$），每层的前馈神经网络参数不共享，具体计算如下： \parinterval Transformer使用了全连接网络。全连接网络的作用主要体现在将经过注意力计算之后的表示映射到新的空间中，新的空间会有利于接下来的非线性变换等操作。实验证明，去掉全连接网络会对模型的性能造成很大影响。Transformer的全连接前馈神经网络包含两次线性变换和一次非线性变换（ReLU激活函数:ReLU$(\mathbi{x})=\textrm{max}⁡(0,\mathbi{x})$），每层的前馈神经网络参数不共享，具体计算如下：
\begin{eqnarray} \begin{eqnarray}
\textrm{FFN}(\mathbi{x}) &=& \textrm{max} (0,\mathbi{x}\mathbi{W}_1 + \mathbi{b}_1)\mathbi{W}_2 + \mathbi{b}_2 \textrm{FFN}(\mathbi{x}) &=& \textrm{max} (0,\mathbi{x}\mathbi{W}_1 + \mathbi{b}_1)\mathbi{W}_2 + \mathbi{b}_2
\label{eq:12-14} \label{eq:12-14}
\end{eqnarray} \end{eqnarray}
\noindent 其中，$\mathbi{W}_1$、$\mathbi{W}_2$、$\mathbi{b}_1$和$\mathbi{b}_2$为模型的参数。通常情况下，前馈神经网络的隐层维度要比注意力部分的隐层维度大，而且研究人员发现这种设置对Transformer是至关重要的。 比如，注意力部分的隐层维度为512，前馈神经网络部分的隐层维度为2048。当然，继续增大前馈神经网络的隐层大小，比如设为4096，甚至8192，还可以带来性能的增益，但是前馈部分的存储消耗较大，需要更大规模GPU 设备的支持。因此在具体实现时，往往需要在翻译准确性和存储/速度之间找到一个平衡。 \noindent 其中，$\mathbi{W}_1$、$\mathbi{W}_2$、$\mathbi{b}_1$和$\mathbi{b}_2$为模型的参数。通常情况下，前馈神经网络的隐藏层维度要比注意力部分的隐藏层维度大，而且研究人员发现这种设置对Transformer是至关重要的。 比如，注意力部分的隐藏层维度为512，前馈神经网络部分的隐藏层维度为2048。当然，继续增大前馈神经网络的隐藏层大小，比如设为4096，甚至8192，还可以带来性能的增益，但是前馈部分的存储消耗较大，需要更大规模GPU 设备的支持。因此在具体实现时，往往需要在翻译准确性和存储/速度之间找到一个平衡。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
...@@ -471,7 +471,7 @@ ...@@ -471,7 +471,7 @@
\section{训练} \section{训练}
\parinterval 与前面介绍的神经机器翻译模型的训练一样，Transformer的训练流程为：首先对模型进行初始化，然后在编码器输入包含结束符的源语言单词序列。前面已经介绍过，解码器每个位置单词的预测都要依赖已经生成的序列。在解码器输入包含起始符号的目标语言序列，通过起始符号预测目标语言的第一个单词，用真实的目标语言的第一个单词去预测第二个单词，以此类推，然后用真实的目标语言序列和预测的结果比较，计算它的损失。Transformer使用了交叉熵损失函数，损失越小说明模型的预测越接近真实输出。然后利用反向传播来调整模型中的参数。由于Transformer 将任意时刻输入信息之间的距离拉近为1，摒弃了RNN中每一个时刻的计算都要基于前一时刻的计算这种具有时序性的训练方式，因此Transformer中训练的不同位置可以并行化训练，大大提高了训练效率。 \parinterval 与前面介绍的神经机器翻译模型的训练一样，Transformer的训练流程为：首先对模型进行初始化，然后在编码器中输入包含结束符的源语言单词序列。前面已经介绍过，解码器每个位置单词的预测都要依赖已经生成的序列。在解码器输入包含起始符号的目标语言序列，通过起始符号预测目标语言的第一个单词，用真实的目标语言的第一个单词去预测第二个单词，以此类推，然后用真实的目标语言序列和预测的结果比较，计算它的损失。Transformer使用了交叉熵损失函数，损失越小说明模型的预测越接近真实输出。然后利用反向传播来调整模型中的参数。由于Transformer 将任意时刻输入信息之间的距离拉近为1，摒弃了RNN中每一个时刻的计算都要基于前一时刻的计算这种具有时序性的训练方式，因此Transformer中训练的不同位置可以并行化训练，大大提高了训练效率。
%---------------------------------------------- %----------------------------------------------
%\begin{figure}[htp] %\begin{figure}[htp]
...@@ -494,7 +494,7 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \ ...@@ -494,7 +494,7 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \
\end{eqnarray} \end{eqnarray}
\vspace{0.5em} \vspace{0.5em}
其中，$\textrm{step}$表示更新的次数（或步数）。通常设置网络更新的前4000步为预热阶段即$\textrm{warmup\_steps}=4000$。Transformer的学习率曲线如图\ref{fig:12-17}所示。在训练初期，学习率从一个较小的初始值逐渐增大（线性增长），当到达一定的步数，学习率再逐渐减小。这样做可以减缓在训练初期的不稳定现象，同时在模型达到相对稳定之后，通过逐渐减小的学习率让模型进行更细致的调整。这种学习率的调整方法是Transformer系统一个很大的工程贡献。 其中，$\textrm{step}$表示更新的次数（或步数）。通常设置网络更新的前4000步为预热阶段即$\textrm{warmup\_steps}=4000$。Transformer的学习率曲线如图\ref{fig:12-17}所示。在训练初期，学习率从一个较小的初始值逐渐增大（线性增长），当到达一定的步数，学习率再逐渐减小。这样做可以减缓在训练初期的不稳定现象，同时在模型达到相对稳定之后，通过逐渐减小的学习率让模型进行更细致的调整。这种学习率的调整方法是Transformer模型一个很大的工程贡献。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
...@@ -507,7 +507,7 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \ ...@@ -507,7 +507,7 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\parinterval 另外，Transformer为了提高模型训练的效率和性能，还进行了以下几方面的操作： \parinterval 另外，为了提高模型训练的效率和性能，Transformer还进行了以下几方面的操作：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
...@@ -522,9 +522,9 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \ ...@@ -522,9 +522,9 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \
\end{figure} \end{figure}
%---------------------------------------------- %----------------------------------------------
\vspace{0.5em} \vspace{0.5em}
\item {\small\bfnew{Dropout}}\index{Dropout}\upcite{JMLR:v15:srivastava14a}：由于Transformer模型网络结构较为复杂，会导致过度拟合训练数据，从而对未见数据的预测结果变差。这种现象也被称作过拟合。为了避免这种现象，Transformer加入了Dropout操作。Transformer中这四个地方用到了Dropout：词嵌入和位置编码、残差连接、注意力操作和前馈神经网络。Dropout比例通常设置为$0.1$。 \item {\small\bfnew{Dropout}}\index{Dropout}\upcite{JMLR:v15:srivastava14a}：由于Transformer模型网络结构较为复杂，会导致过度拟合训练数据，从而对未见数据的预测结果变差。这种现象也被称作过拟合。为了避免这种现象，Transformer加入了Dropout操作。Transformer中这四个地方用到了Dropout：词嵌入和位置编码、残差连接、注意力操作和前馈神经网络。Dropout的比例通常设置为$0.1$。
\vspace{0.5em} \vspace{0.5em}
\item {\small\bfnew{标签平滑}}\index{标签平滑}（Label Smoothing）\index{Label Smoothing}\upcite{Szegedy_2016_CVPR}：在计算损失的过程中，需要用预测概率去拟合真实概率。在分类任务中，往往使用One-hot向量代表真实概率，即真实答案位置那一维对应的概率为1，其余维为0，而拟合这种概率分布会造成两个问题：1)无法保证模型的泛化能力，容易造成过拟合；2) 1和0概率鼓励所属类别和其他类别之间的差距尽可能加大，会造成模型过于相信预测的类别。因此Transformer里引入标签平滑来缓解这种现象，简单的说就是给正确答案以外的类别分配一定的概率，而不是采用非0即1的概率。这样，可以学习一个比较平滑的概率分布，从而提升泛化能力。 \item {\small\bfnew{标签平滑}}\index{标签平滑}（Label Smoothing）\index{Label Smoothing}\upcite{Szegedy_2016_CVPR}：在计算损失的过程中，需要用预测概率去拟合真实概率。在分类任务中，往往使用One-hot向量代表真实概率，即真实答案所在位置那一维对应的概率为1，其余维为0，而拟合这种概率分布会造成两个问题：1)无法保证模型的泛化能力，容易造成过拟合；2) 1和0概率鼓励所属类别和其他类别之间的差距尽可能加大，会造成模型过于相信预测的类别。因此Transformer里引入标签平滑来缓解这种现象，简单的说就是给正确答案以外的类别分配一定的概率，而不是采用非0即1的概率。这样，可以学习一个比较平滑的概率分布，从而提升模型的泛化能力。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
...@@ -532,15 +532,15 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \ ...@@ -532,15 +532,15 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item Transformer Base：标准的Transformer结构，解码器编码器均包含6层，隐层维度为512，前馈神经网络维度为2048，多头注意力机制为8头，Dropout设为0.1。 \item Transformer Base：标准的Transformer结构，解码器编码器均包含6层，隐藏层的维度为512，前馈神经网络的维度为2048，多头注意力机制为8头，Dropout设为0.1。
\vspace{0.5em} \vspace{0.5em}
\item Transformer Big：为了提升网络的容量，使用更宽的网络。在Base的基础上增大隐层维度至1024，前馈神经网络的维度变为4096，多头注意力机制为16头，Dropout设为0.3。 \item Transformer Big：为了提升网络的容量，使用更宽的网络。在Base的基础上增大隐藏层维度至1024，前馈神经网络的维度变为4096，多头注意力机制为16头，Dropout设为0.3。
\vspace{0.5em} \vspace{0.5em}
\item Transformer Deep：加深编码器网络层数可以进一步提升网络的性能，它的参数设置与Transformer Base基本一致，但是层数增加到48层，同时使用Pre-Norm作为层标准化的结构。 \item Transformer Deep：加深编码器网络层数可以进一步提升网络的性能，它的参数设置与Transformer Base基本一致，但是层数增加到48层，同时使用Pre-Norm作为层标准化的结构。
\vspace{0.5em} \vspace{0.5em}
\end{itemize} \end{itemize}
\parinterval 在WMT'16数据 上的实验对比如表\ref{tab:12-3}所示。可以看出，Transformer Base的BLE\\U得分虽不如另外两种模型，但其参数量是最少的。而Transformer Deep的性能整体好于Transformer Big。 \parinterval 在WMT16数据 上的实验对比如表\ref{tab:12-3}所示。可以看出，Transformer Base的BLE\\U得分虽不如另外两种模型，但其参数量是最少的。而Transformer Deep的性能整体好于Transformer Big。
%---------------------------------------------- %----------------------------------------------
\begin{table}[htp] \begin{table}[htp]
...@@ -548,7 +548,7 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \ ...@@ -548,7 +548,7 @@ lrate &=& d_{\textrm{model}}^{-0.5} \cdot \textrm{min} (\textrm{step}^{-0.5} , \
\caption{三种Transformer模型的对比} \caption{三种Transformer模型的对比}
\label{tab:12-3} \label{tab:12-3}
\begin{tabular}{l | l l l} \begin{tabular}{l | l l l}
\multirow{2}{*}{系统} & \multicolumn{2}{c}{BLEU[\%]} & 模型参数量 \\ \multirow{2}{*}{模型} & \multicolumn{2}{c}{BLEU[\%]} & 模型参数量 \\
& EN-DE & EN-FR & \\ \hline & EN-DE & EN-FR & \\ \hline
Transformer Base（6层） & 27.3 & 38.1 & 65$\times 10^{6}$ \\ Transformer Base（6层） & 27.3 & 38.1 & 65$\times 10^{6}$ \\
Transformer Big（6层） & 28.4 & 41.8 & 213$\times 10^{6}$ \\ Transformer Big（6层） & 28.4 & 41.8 & 213$\times 10^{6}$ \\
...@@ -592,9 +592,9 @@ Transformer Deep（48层） & 30.2 & 43.1 & 194$\times 10^ ...@@ -592,9 +592,9 @@ Transformer Deep（48层） & 30.2 & 43.1 & 194$\times 10^
\item 近两年，有研究已经发现注意力机制可以捕捉一些语言现象\upcite{DBLP:journals/corr/abs-1905-09418}，比如，在Transformer 的多头注意力机制中，不同头往往会捕捉到不同的信息，比如，有些头对低频词更加敏感，有些头更适合词意消歧，甚至有些头可以捕捉句法信息。此外，由于注意力机制增加了模型的复杂性，而且随着网络层数的增多，神经机器翻译中也存在大量的冗余，因此研发轻量的注意力模型也是具有实践意义的方向\upcite{Xiao2019SharingAW,DBLP:journals/corr/abs-1805-00631,Lin2020WeightDT,DBLP:conf/iclr/WuLLLH20,Kitaev2020ReformerTE}。 \item 近两年，有研究已经发现注意力机制可以捕捉一些语言现象\upcite{DBLP:journals/corr/abs-1905-09418}，比如，在Transformer 的多头注意力机制中，不同头往往会捕捉到不同的信息，比如，有些头对低频词更加敏感，有些头更适合词意消歧，甚至有些头可以捕捉句法信息。此外，由于注意力机制增加了模型的复杂性，而且随着网络层数的增多，神经机器翻译中也存在大量的冗余，因此研发轻量的注意力模型也是具有实践意义的方向\upcite{Xiao2019SharingAW,DBLP:journals/corr/abs-1805-00631,Lin2020WeightDT,DBLP:conf/iclr/WuLLLH20,Kitaev2020ReformerTE}。
\vspace{0.5em} \vspace{0.5em}
\item 神经机器翻译依赖成本较高的GPU设备，因此对模型的裁剪和加速也是很多系统研发人员所感兴趣的方向。比如，从工程上，可以考虑减少运算强度，比如使用低精度浮点数\upcite{Ott2018ScalingNM} 或者整数\upcite{DBLP:journals/corr/abs-1906-00532,Lin2020TowardsF8}进行计算，或者引入缓存机制来加速模型的推断\upcite{Vaswani2018Tensor2TensorFN}；也可以通过对模型参数矩阵的剪枝来减小整个模型的体积\upcite{DBLP:journals/corr/SeeLM16}；另一种方法是知识蒸馏\upcite{Hinton2015Distilling,kim-rush-2016-sequence}。 利用大模型训练小模型，这样往往可以得到比单独训练小模型更好的效果\upcite{DBLP:journals/corr/ChenLCL17}。 \item 神经机器翻译依赖成本较高的GPU设备，因此对模型的裁剪和加速也是很多系统研发人员所感兴趣的方向。比如，从工程上，可以考虑减少运算强度，比如使用低精度浮点数\upcite{Ott2018ScalingNM} 或者整数\upcite{DBLP:journals/corr/abs-1906-00532,Lin2020TowardsF8}进行计算，或者引入缓存机制来加速模型的推断\upcite{Vaswani2018Tensor2TensorFN}；也可以通过对模型参数矩阵的剪枝来减小整个模型的体积\upcite{DBLP:journals/corr/SeeLM16}；还可以使用知识蒸馏\upcite{Hinton2015Distilling,kim-rush-2016-sequence}。 利用大模型训练小模型，这样往往可以得到比单独训练小模型更好的效果\upcite{DBLP:journals/corr/ChenLCL17}。
\vspace{0.5em} \vspace{0.5em}
\item 自注意力网络作为Transformer模型中重要组成部分，近年来受到研究人员的广泛关注，尝试设计更高效地操作来替代它。比如，利用动态卷积网络来替换编码器与解码器的自注意力网络，在保证推断效率的同时取得了和Transformer相当甚至略好的翻译性能\upcite{Wu2019PayLA}；为了加速Transformer处理较长输入文本的效率，利用局部敏感哈希替换自注意力机制的Reformer模型也吸引了广泛的关注\upcite{Kitaev2020ReformerTE}。此外，在自注意力网络引入额外的编码信息能够进一步提高模型的表示能力。比如，引入固定窗口大小的相对位置编码信息\upcite{Shaw2018SelfAttentionWR,Dai2019TransformerXLAL},或利用动态系统的思想从数据中学习特定的位置编码表示，具有更好的泛化能力\upcite{Liu2020LearningTE}。通过对Transformer模型中各层输出进行可视化分析，研究人员发现Transformer自底向上各层网络依次聚焦于词级-语法级-语义级的表示\upcite{Jawahar2019WhatDB,li2020shallow}，因此在底层的自注意力网络中引入局部编码信息有助于模型对局部特征的抽象\upcite{Yang2018ModelingLF,DBLP:journals/corr/abs-1904-03107}。 \item 随着Transformer 模型受到的关注增多，Transformer 模型的重要组成部分自注意力网络也受到了研究人员的广泛关注，但它存在很多不足，因此研究人员尝试设计更高效的操作来改进它。比如，利用动态卷积网络来替换编码器与解码器的自注意力网络，在保证推断效率的同时取得了和Transformer相当甚至略好的翻译性能\upcite{Wu2019PayLA}；为了加速Transformer处理较长输入文本的效率，利用局部敏感哈希替换自注意力机制的Reformer模型也吸引了广泛的关注\upcite{Kitaev2020ReformerTE}。此外，在自注意力网络引入额外的编码信息能够进一步提高模型的表示能力。比如，引入固定窗口大小的相对位置编码信息\upcite{Shaw2018SelfAttentionWR,Dai2019TransformerXLAL},或利用动态系统的思想从数据中学习特定的位置编码表示，具有更好的泛化能力\upcite{Liu2020LearningTE}。通过对Transformer模型中各层输出进行可视化分析，研究人员发现Transformer自底向上各层网络依次聚焦于词级-语法级-语义级的表示\upcite{Jawahar2019WhatDB,li2020shallow}，因此在底层的自注意力网络中引入局部编码信息有助于模型对局部特征的抽象\upcite{Yang2018ModelingLF,DBLP:journals/corr/abs-1904-03107}。
\vspace{0.5em} \vspace{0.5em}
\item 除了针对Transformer中子层的优化，网络各层之间的连接方式在一定程度上也能影响模型的表示能力。近年来针对网络连接优化的工作如下：在编码器顶部利用平均池化或权重累加等融合手段得到编码器各层的全局表示\upcite{Wang2018MultilayerRF,Bapna2018TrainingDN,Dou2018ExploitingDR,Wang2019ExploitingSC}，利用之前各层表示来生成当前层的输入表示\upcite{WangLearning,Dou2019DynamicLA,Wei2020MultiscaleCD}。 \item 除了针对Transformer中子层的优化，网络各层之间的连接方式在一定程度上也能影响模型的表示能力。近年来针对网络连接优化的工作如下：在编码器顶部利用平均池化或权重累加等融合手段得到编码器各层的全局表示\upcite{Wang2018MultilayerRF,Bapna2018TrainingDN,Dou2018ExploitingDR,Wang2019ExploitingSC}，利用之前各层表示来生成当前层的输入表示\upcite{WangLearning,Dou2019DynamicLA,Wei2020MultiscaleCD}。
\end{itemize} \end{itemize}
Chapter15/chapter15.tex
...@@ -89,7 +89,7 @@ ...@@ -89,7 +89,7 @@
\label{eq:15-6} \label{eq:15-6}
\end{eqnarray} \end{eqnarray}
\noindent 其中，$d_k$为模型中隐层的维度\footnote[3]{在多头注意力中，$d_k$为经过多头分割后每个头的维度。}。$\mathbi{e}_{ij}$实际上就是$\mathbi{Q}$和$\mathbi{K}$的向量积缩放后的一个结果。 \noindent 其中，$d_k$为模型中隐藏层的维度\footnote[3]{在多头注意力中，$d_k$为经过多头分割后每个头的维度。}。$\mathbi{e}_{ij}$实际上就是$\mathbi{Q}$和$\mathbi{K}$的向量积缩放后的一个结果。
\parinterval 基于上述描述，相对位置模型可以按如下方式实现： \parinterval 基于上述描述，相对位置模型可以按如下方式实现：
...@@ -355,7 +355,7 @@ v_i &=& \mathbi{I}_d^{\textrm{T}}\textrm{Tanh}(\mathbi{W}_d\mathbi{Q}_i) ...@@ -355,7 +355,7 @@ v_i &=& \mathbi{I}_d^{\textrm{T}}\textrm{Tanh}(\mathbi{W}_d\mathbi{Q}_i)
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
\item Reformer模型在计算Key和Value时使用相同的线性映射，共享Key和Value的值\upcite{Kitaev2020ReformerTE}，降低了自注意力机制的复杂度。进一步，Reformer引入了一种{\small\bfnew{局部敏感哈希注意力机制}}\index{局部敏感哈希注意力机制}（Locality Sensitive Hashing Attention\index{Locality Sensitive Hashing Attention}，LSH Attention），其提高效率的方式和固定模式中的局部建模一致，减少注意力机制的计算范围。对于每一个Query，通过局部哈希敏感机制找出和其较为相关的Key，并进行注意力的计算。其基本思路就是距离相近的向量以较大的概率被哈希分配到一个桶内，距离较远的向量被分配到一个桶内的概率则较低。此外，Reformer中还采用了一种{\small\bfnew{可逆残差网络结构}}\index{可逆残差网络结构}（The Reversible Residual Network）\index{The Reversible Residual Network}和分块计算前馈神经网络层的机制，即将前馈层的隐层维度拆分为多个块并独立的进行计算，最后进行拼接操作，得到前馈层的输出，这种方式大幅度减少了内存（显存）占用。 \item Reformer模型在计算Key和Value时使用相同的线性映射，共享Key和Value的值\upcite{Kitaev2020ReformerTE}，降低了自注意力机制的复杂度。进一步，Reformer引入了一种{\small\bfnew{局部敏感哈希注意力机制}}\index{局部敏感哈希注意力机制}（Locality Sensitive Hashing Attention\index{Locality Sensitive Hashing Attention}，LSH Attention），其提高效率的方式和固定模式中的局部建模一致，减少注意力机制的计算范围。对于每一个Query，通过局部哈希敏感机制找出和其较为相关的Key，并进行注意力的计算。其基本思路就是距离相近的向量以较大的概率被哈希分配到一个桶内，距离较远的向量被分配到一个桶内的概率则较低。此外，Reformer中还采用了一种{\small\bfnew{可逆残差网络结构}}\index{可逆残差网络结构}（The Reversible Residual Network）\index{The Reversible Residual Network}和分块计算前馈神经网络层的机制，即将前馈层的隐藏层维度拆分为多个块并独立的进行计算，最后进行拼接操作，得到前馈层的输出，这种方式大幅度减少了内存（显存）占用。
\vspace{0.5em} \vspace{0.5em}
\item Routing Transformer通过聚类算法对序列中的不同单元进行分组，分别在组内进行自注意力机制的计算\upcite{DBLP:journals/corr/abs-2003-05997}。该方法是将Query和Key映射到聚类矩阵$\mathbi{S}$： \item Routing Transformer通过聚类算法对序列中的不同单元进行分组，分别在组内进行自注意力机制的计算\upcite{DBLP:journals/corr/abs-2003-05997}。该方法是将Query和Key映射到聚类矩阵$\mathbi{S}$：
...@@ -506,7 +506,7 @@ v_i &=& \mathbi{I}_d^{\textrm{T}}\textrm{Tanh}(\mathbi{W}_d\mathbi{Q}_i) ...@@ -506,7 +506,7 @@ v_i &=& \mathbi{I}_d^{\textrm{T}}\textrm{Tanh}(\mathbi{W}_d\mathbi{Q}_i)
\label{eq:15-33} \label{eq:15-33}
\end{eqnarray} \end{eqnarray}
\noindent 其中，$[\mathbi{h}^1,\ldots,\mathbi{h}^L]$是输入矩阵，$\mathbi{o}$是输出矩阵，$\mathbi{W}_1 \in \mathbb{R}^{d_{\textrm{model}} \times d_{\rm a}}$，$\mathbi{W}_2 \in \mathbb{R}^{d_{\rm a}\times n_{\rm hop}}$，$d_{\rm a}$表示前馈神经网络隐层大小，$n_{\rm hop}$表示跳数。 之后使用Softmax 函数计算不同层沿相同维度上的归一化结果$\mathbi{u}_l$： \noindent 其中，$[\mathbi{h}^1,\ldots,\mathbi{h}^L]$是输入矩阵，$\mathbi{o}$是输出矩阵，$\mathbi{W}_1 \in \mathbb{R}^{d_{\textrm{model}} \times d_{\rm a}}$，$\mathbi{W}_2 \in \mathbb{R}^{d_{\rm a}\times n_{\rm hop}}$，$d_{\rm a}$表示前馈神经网络隐藏层大小，$n_{\rm hop}$表示跳数。 之后使用Softmax 函数计算不同层沿相同维度上的归一化结果$\mathbi{u}_l$：
\begin{eqnarray} \begin{eqnarray}
\mathbi{u}_l &=& \frac{\textrm{exp}(\mathbi{o}_l)}{\sum_{i=1}^L{\textrm{exp}(\mathbi{o}_i)}} \mathbi{u}_l &=& \frac{\textrm{exp}(\mathbi{o}_l)}{\sum_{i=1}^L{\textrm{exp}(\mathbi{o}_i)}}
\label{eq:15-34} \label{eq:15-34}
...@@ -799,7 +799,7 @@ v_i &=& \mathbi{I}_d^{\textrm{T}}\textrm{Tanh}(\mathbi{W}_d\mathbi{Q}_i) ...@@ -799,7 +799,7 @@ v_i &=& \mathbi{I}_d^{\textrm{T}}\textrm{Tanh}(\mathbi{W}_d\mathbi{Q}_i)
lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num \cdot warmup\_steps^{-0.5} lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num \cdot warmup\_steps^{-0.5}
\label{eq:15-49} \label{eq:15-49}
\end{eqnarray} \end{eqnarray}
\noindent 这里，$step\_num$表示参数更新的次数，$warmup\_step$表示预热的更新次数，$d_{\textrm{model}}$表示Transformer模型的隐层大小，$lr$是学习率。 \noindent 这里，$step\_num$表示参数更新的次数，$warmup\_step$表示预热的更新次数，$d_{\textrm{model}}$表示Transformer模型的隐藏层大小，$lr$是学习率。
\vspace{0.5em} \vspace{0.5em}
\item 在之后的训练过程中，每当增加模型深度时，学习率都会重置到峰值，之后进行相应的衰减： \item 在之后的训练过程中，每当增加模型深度时，学习率都会重置到峰值，之后进行相应的衰减：
\begin{eqnarray} \begin{eqnarray}
...@@ -914,7 +914,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5} ...@@ -914,7 +914,7 @@ lr &=& d_{\textrm{model}}^{-0.5}\cdot step\_num^{-0.5}
\label{eq:15-53} \label{eq:15-53}
\end{eqnarray} \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-53}计算得到。对于注意力模型，图中所有的节点都会参与上下文向量的计算，因此仅需要对{\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} \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 \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-54} \label{eq:15-54}
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论