Skip to content

M
mtbookv2
Commit 50fa02fd by 曹润柘
Options

合并分支 'caorunzhe' 到 'master' 

Caorunzhe

查看合并请求 !569
parents 3eb99a54 a185cd71
正在显示 包含 439 行增加 和 36 行删除
Chapter15/Figures/figure-activation-function-swish-structure-diagram.tex 0 → 100644
%%% outline
%-------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{opt}=[draw,minimum height=2em,minimum width=4em,rounded corners=2pt,thick]
\node[circle,minimum size=2em,draw,fill=red!20] (x1) at (0,0) {\small\bfnew{X}};
\node[circle,minimum size=2em,draw,fill=red!20] (x2) at (0,4em) {\small\bfnew{X}};
\node[circle,minimum size=2em,draw,fill=red!20] (x3) at (0,-5em) {\small\bfnew{X}};
\node[anchor=west,opt,fill=yellow!20] (unary1) at ([xshift=3em]x1.east){\small\bfnew{Unary}};
\node[anchor=west,opt,fill=yellow!20] (unary2) at ([xshift=3em]x2.east){\small\bfnew{Unary}};
\node[opt,fill=blue!20] (binary1) at (12em,2em){\small\bfnew{Binary}};
\node[opt,fill=blue!20] (binary2) at (25em,-1.5em){\small\bfnew{Binary}};
\node[anchor=west,opt,fill=yellow!20] (unary3) at ([xshift=3em]binary1.east){\small\bfnew{Unary}};
\node[anchor=west,opt,fill=yellow!20] (unary4) at ([xshift=16em]x3.east){\small\bfnew{Unary}};
\draw[-latex,very thick] (x1.0) -- (unary1.180);
\draw[-latex,very thick] (x2.0) -- (unary2.180);
\draw[-latex,very thick] (x3.0) -- (unary4.180);
\draw[-latex,very thick] (unary1.0) -- ([yshift=-0.2em]binary1.180);
\draw[-latex,very thick] (unary2.0) -- ([yshift=0.2em]binary1.180);
\draw[-latex,very thick] (binary1.0) -- (unary3.180);
\draw[-latex,very thick] (unary3.0) -- ([yshift=0.2em]binary2.180);
\draw[-latex,very thick] (unary4.0) -- ([yshift=-0.2em]binary2.180);
\begin{pgfonlayer}{background}
\node[draw=lightgray,fill=lightgray!50,rounded corners=2pt,inner sep=8pt][fit=(x2)(x1)(binary1)]{};
\end{pgfonlayer}
\node[anchor=south] at ([yshift=1em]binary1.north){\small\bfnew{Core Unit}};
\end{tikzpicture}
Chapter15/Figures/figure-layer-fusion-method.tex 0 → 100644
\begin{tikzpicture}
\begin{scope}
\tikzstyle{encnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=4.5em,rounded corners=5pt,thick]
\tikzstyle{decnode}=[rectangle,inner sep=0mm,minimum height=2em,minimum width=4.5em,rounded corners=5pt,thick]
\node [anchor=north,encnode] (n1) at (0, 0) {编码器};
\node [anchor=north,rectangle,minimum height=1.5em,minimum width=2.5em,rounded corners=5pt] (n2) at ([xshift=0em,yshift=-0.2em]n1.south) {$\mathbi{X}$};
\node [anchor=west,encnode,draw=red!60!black!80,fill=red!20] (n3) at ([xshift=1.5em,yshift=0em]n2.east) {$\mathbi{h}_0$};
\node [anchor=west,encnode,draw=red!60!black!80,fill=red!20] (n4) at ([xshift=1.5em,yshift=0em]n3.east) {$\mathbi{h}_1$};
\node [anchor=west,encnode,draw=red!60!black!80,fill=red!20] (n5) at ([xshift=1.5em,yshift=0em]n4.east) {$\mathbi{h}_2$};
\node [anchor=west,rectangle,minimum height=1.5em,minimum width=2.5em,rounded corners=5pt] (n6) at ([xshift=1em,yshift=0em]n5.east) {$\ldots$};
\node [anchor=west,encnode,draw=red!60!black!80,fill=red!20] (n7) at ([xshift=1em,yshift=0em]n6.east) {$\mathbi{h}_{N-1}$};
\node [anchor=north,rectangle,draw=teal!80, inner sep=0mm,minimum height=2em,minimum width=8em,fill=teal!17,rounded corners=5pt,thick] (n8) at ([xshift=3em,yshift=-1.2em]n4.south) {权重聚合$\mathbi{g}$};
\node [anchor=west,decnode] (n9) at ([xshift=0em,yshift=-7.2em]n1.west) {解码器};
\node [anchor=north,rectangle,minimum height=1.5em,minimum width=2.5em,rounded corners=5pt] (n10) at ([xshift=0em,yshift=-0.2em]n9.south) {$\mathbi{y}_{<j}$};
\node [anchor=west,decnode,draw=ublue,fill=blue!10] (n11) at ([xshift=1.5em,yshift=0em]n10.east) {$\mathbi{s}_j^0$};
\node [anchor=west,decnode,draw=ublue,fill=blue!10] (n12) at ([xshift=1.5em,yshift=0em]n11.east) {$\mathbi{s}_j^1$};
\node [anchor=west,decnode,draw=ublue,fill=blue!10] (n13) at ([xshift=1.5em,yshift=0em]n12.east) {$\mathbi{s}_j^2$};
\node [anchor=west,rectangle,minimum height=1.5em,minimum width=2.5em,rounded corners=5pt] (n14) at ([xshift=1em,yshift=0em]n13.east) {$\ldots$};
\node [anchor=west,decnode,draw=ublue,fill=blue!10] (n15) at ([xshift=1em,yshift=0em]n14.east) {$\mathbi{s}_j^{M-1}$};
\node [anchor=west,rectangle,minimum height=1.5em,minimum width=2.5em,rounded corners=5pt] (n16) at ([xshift=1.5em,yshift=0em]n15.east) {$\mathbi{y}_{j}$};
\node [anchor=south,minimum height=1.5em,minimum width=2.5em] (n17) at ([xshift=0em,yshift=6em]n16.north) {};
\node [anchor=north,minimum height=0.5em,minimum width=4em] (n18) at ([xshift=0em,yshift=-0.7em]n4.south) {};
\node [anchor=north,minimum height=0.5em,minimum width=4em] (n19) at ([xshift=0em,yshift=-0.7em]n13.south) {};
\node [anchor=west,minimum height=0.5em,minimum width=4em] (n20) at ([xshift=0em,yshift=0.7em]n8.east) {};
\node [anchor=west,minimum height=0.5em,minimum width=4em] (n21) at ([xshift=0em,yshift=-0.7em]n8.east) {};
\begin{pgfonlayer}{background}
{
\node[rectangle,inner sep=2pt,fill=blue!7] [fit = (n1) (n7) (n17) (n18) (n20)] (bg1) {};
\node[rectangle,inner sep=2pt,fill=red!7] [fit = (n9) (n16) (n19) (n21)] (bg2) {};
}
\end{pgfonlayer}
\draw [->,thick] ([xshift=0em,yshift=0em]n2.east) -- ([xshift=0em,yshift=0em]n3.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n3.east) -- ([xshift=0em,yshift=0em]n4.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n4.east) -- ([xshift=0em,yshift=0em]n5.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n5.east) -- ([xshift=0em,yshift=0em]n6.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n6.east) -- ([xshift=0em,yshift=0em]n7.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n2.south) -- ([xshift=0em,yshift=0em]n8.north);
\draw [->,thick] ([xshift=0em,yshift=0em]n3.south) -- ([xshift=0em,yshift=0em]n8.north);
\draw [->,thick] ([xshift=0em,yshift=0em]n4.south) -- ([xshift=0em,yshift=0em]n8.north);
\draw [->,thick] ([xshift=0em,yshift=0em]n5.south) -- ([xshift=0em,yshift=0em]n8.north);
\draw [->,thick] ([xshift=0em,yshift=0em]n7.south) -- ([xshift=0em,yshift=0em]n8.north);
\draw [->,thick] ([xshift=0em,yshift=0em]n10.east) -- ([xshift=0em,yshift=0em]n11.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n11.east) -- ([xshift=0em,yshift=0em]n12.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n12.east) -- ([xshift=0em,yshift=0em]n13.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n13.east) -- ([xshift=0em,yshift=0em]n14.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n14.east) -- ([xshift=0em,yshift=0em]n15.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n15.east) -- ([xshift=0em,yshift=0em]n16.west);
\draw [->,thick] ([xshift=0em,yshift=0em]n8.south) -- ([xshift=0em,yshift=0em]n11.north);
\draw [->,thick] ([xshift=0em,yshift=0em]n8.south) -- ([xshift=0em,yshift=0em]n12.north);
\draw [->,thick] ([xshift=0em,yshift=0em]n8.south) -- ([xshift=0em,yshift=0em]n13.north);
\draw [->,thick] ([xshift=0em,yshift=0em]n8.south) -- ([xshift=0em,yshift=0em]n15.north);
\end{scope}
\end{tikzpicture}
\ No newline at end of file
Chapter15/Figures/figure-learning-of-local-structure-combination.tex 0 → 100644
%%% outline
%-------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{opt}=[minimum height=1em,minimum width=5em,rounded corners=2pt,thick]
\node[opt] (opt1_0) at (0,0) {固定操作};
\node[draw,anchor=south,opt,fill=green!20] (opt1_1) at ([yshift=0.8em]opt1_0.north) {操作3};
\node[draw,anchor=south,opt,fill=cyan!20] (opt1_2) at ([yshift=0.8em]opt1_1.north) {操作2};
\node[anchor=south,opt] (opt1_3) at ([yshift=0.8em]opt1_2.north) {固定操作};
\node[draw,anchor=south,opt,fill=yellow!20] (opt1_4) at ([yshift=0.8em]opt1_3.north) {操作4};
\node[anchor=south,opt] (opt1_5) at ([yshift=0.8em]opt1_4.north) {$\cdots$};
\node[draw,anchor=south,opt,fill=blue!10] (opt1_6) at ([yshift=0.8em]opt1_5.north) {操作1};
\node[anchor=south,opt] (opt1_7) at ([yshift=0.8em]opt1_6.north) {};
\node[opt] (opt2_0) at (3,0) {固定操作};
\node[draw,anchor=south,opt,fill=blue!10] (opt2_1) at ([yshift=0.8em]opt2_0.north) {操作1};
\node[draw,anchor=south,opt,fill=green!20] (opt2_2) at ([yshift=0.8em]opt2_1.north) {操作3};
\node[anchor=south,opt] (opt2_3) at ([yshift=0.8em]opt2_2.north) {固定操作};
\node[draw,anchor=south,opt,fill=red!20] (opt2_4) at ([yshift=0.8em]opt2_3.north) {操作5};
\node[anchor=south,opt] (opt2_5) at ([yshift=0.8em]opt2_4.north) {$\cdots$};
\node[draw,anchor=south,opt,fill=cyan!20] (opt2_6) at ([yshift=0.8em]opt2_5.north) {操作2};
\node[anchor=south,opt] (opt2_7) at ([yshift=0.8em]opt2_6.north) {};
\node[opt] (opt3_0) at (6,0) {固定操作};
\node[draw,anchor=south,opt,fill=yellow!20] (opt3_1) at ([yshift=0.8em]opt3_0.north) {操作4};
\node[draw,anchor=south,opt,fill=cyan!20] (opt3_2) at ([yshift=0.8em]opt3_1.north) {操作2};
\node[anchor=south,opt] (opt3_3) at ([yshift=0.8em]opt3_2.north) {固定操作};
\node[draw,anchor=south,opt,fill=yellow!20] (opt3_4) at ([yshift=0.8em]opt3_3.north) {操作4};
\node[anchor=south,opt] (opt3_5) at ([yshift=0.8em]opt3_4.north) {$\cdots$};
\node[draw,anchor=south,opt,fill=red!20] (opt3_6) at ([yshift=0.8em]opt3_5.north) {操作5};
\node[anchor=south,opt] (opt3_7) at ([yshift=0.8em]opt3_6.north) {};
\begin{pgfonlayer}{background}
\node[draw,fill=yellow!20,rounded corners=6pt,inner ysep=2.6em,inner xsep=2.6em] [fit=(opt1_0) (opt3_7)](box4){};
\node[draw,fill=gray!10,rounded corners=2pt,inner sep=8pt] [fit=(opt1_0) (opt1_7)](box1){};
\node[draw,fill=gray!10,rounded corners=2pt,inner sep=8pt] [fit=(opt2_0) (opt2_7)](box2){};
\node[draw,fill=gray!10,rounded corners=2pt,inner sep=8pt] [fit=(opt3_0) (opt3_7)](box3){};
\end{pgfonlayer}
\draw[->,thick] (opt1_0) -- (opt1_1);
\draw[->,thick] (opt1_1) -- (opt1_2);
\draw[->,thick] (opt1_2) -- (opt1_3);
\draw[->,thick] (opt1_3) -- (opt1_4);
\draw[->,thick] (opt1_4) -- (opt1_5);
\draw[->,thick] (opt1_5) -- (opt1_6);
\draw[->,thick] (opt2_0) -- (opt2_1);
\draw[->,thick] (opt2_1) -- (opt2_2);
\draw[->,thick] (opt2_2) -- (opt2_3);
\draw[->,thick] (opt2_3) -- (opt2_4);
\draw[->,thick] (opt2_4) -- (opt2_5);
\draw[->,thick] (opt2_5) -- (opt2_6);
\draw[->,thick] (opt3_0) -- (opt3_1);
\draw[->,thick] (opt3_1) -- (opt3_2);
\draw[->,thick] (opt3_2) -- (opt3_3);
\draw[->,thick] (opt3_3) -- (opt3_4);
\draw[->,thick] (opt3_4) -- (opt3_5);
\draw[->,thick] (opt3_5) -- (opt3_6);
\node[] at ([xshift=-1.2em,yshift=0.2em]opt1_7){\small\bfnew{分支1}};
\node[] at ([xshift=-1.2em,yshift=0.2em]opt2_7){\small\bfnew{分支2}};
\node[] at ([xshift=-1.2em,yshift=0.2em]opt3_7){\small\bfnew{分支3}};
\node[] (input) at ([yshift=-5em]opt2_0){\small\bfnew{输入}};
\node[] (output) at ([yshift=5em]opt2_7){\small\bfnew{输出}};
\draw[->,thick,out=140,in=-30] (box4.-90) to (box1.-90);
\draw[->,thick,out=40,in=-150] (box4.-90) to (box3.-90);
\draw[->,thick] (box4.-90) -- (box2.-90);
\draw[->,thick,out=50,in=-130] (box1.90) to (box4.90);
\draw[->,thick,out=130,in=-50] (box3.90) to (box4.90);
\draw[->,thick] (box2.90) -- (box4.90);
\draw[->,thick] (input.90) -- (box4.-90);
\draw[->,thick] (box4.90) -- (output.-90);
\node[] at ([xshift=-2.8em,yshift=1.1em]box1.90){\small\bfnew{模型结构}};
\node[] at ([xshift=-0.8em]box4.0){$\cdots$};
\end{tikzpicture}
Chapter15/Figures/figure-structure-search-based-on-evolutionary-algorithm.tex 0 → 100644
%%% outline
%-------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{node}=[minimum height=2em,minimum width=4.6em,rounded corners=2pt,thick,font=\footnotesize]
\node[node,draw,fill=green!20] (n11) at (0,0) {模型结构1};
\node[anchor=west,draw,node,fill=red!20] (n12) at ([xshift=0.6em]n11.east){模型结构6};
\node[anchor=north,draw,node,fill=orange!20] (n13) at ([yshift=-1em]n11.south){模型结构2};
\node[anchor=west,draw,node,fill=blue!15] (n14) at ([xshift=0.6em]n13.east){模型结构5};
\node[anchor=north,draw,node,fill=cyan!30] (n15) at ([yshift=-1em]n13.south){模型结构1};
\node[anchor=west,draw,node,fill=yellow!20] (n16) at ([xshift=0.6em]n15.east){模型结构4};
\node[inner sep=0pt] (kind) at (-0.7,0.8){\small\bfnew{种群}};
\node[node,draw,fill=green!20] (n21) at (5,0){模型结构1};
\node[anchor=west,draw,node,fill=red!20] (n22) at ([xshift=0.6em]n21.east){模型结构4};
\node[anchor=north,node] (n23) at ([yshift=-1em]n21.south){};
\node[anchor=west,node] (n24) at ([xshift=0.6em]n23.east){};
\node[anchor=north,node] (n25) at ([yshift=-1em]n23.south){};
\node[anchor=west,node] (n26) at ([xshift=0.6em]n25.east){};
\node[inner sep=0pt] (choice) at (4.8,0.8){\small\bfnew{选中的亲本}};
\node[node,draw,fill=green!20,dotted] (n31) at (10,0){模型结构1};
\node[anchor=west,draw,node,fill=red!20,dotted] (n32) at ([xshift=0.6em]n31.east){模型结构4};
\node[anchor=north,node] (n33) at ([yshift=-1em]n31.south){};
\node[anchor=west,node] (n34) at ([xshift=0.6em]n33.east){};
\node[anchor=north,draw,node,fill=green!40] (n35) at ([yshift=-1em]n33.south){模型结构1};
\node[anchor=west,draw,node,fill=red!40] (n36) at ([xshift=0.6em]n35.east){模型结构1};
\node[inner sep=0pt] (change) at (9.7,0.8){\small\bfnew{亲本变异}};
\begin{pgfonlayer}{background}
\node[rounded corners=4pt,draw,thick,fill=yellow!10,inner sep=4pt,drop shadow][fit=(kind)(n16)](box1){};
\node[rounded corners=4pt,draw,thick,fill=yellow!10,inner sep=4pt,drop shadow][fit=(choice)(n26)](box2){};
\node[rounded corners=4pt,draw,thick,fill=yellow!10,inner sep=4pt,drop shadow][fit=(change)(n36)](box3){};
\end{pgfonlayer}
\draw[->,very thick] (box1.0) -- (box2.180);
\draw[->,very thick] (box2.0) -- (box3.180);
\draw[->,very thick] (n31.-90) -- (n35.90);
\draw[->,very thick] (n32.-90) -- (n36.90);
\draw[->,very thick] (box3.-90) .. controls ([yshift=-2em,xshift=-1em]box3.-90) and ([yshift=-2em,xshift=1em]box1.-90) .. node[font=\scriptsize,below]{对变异后的结构进行性能评估，选择优秀的结构加入原始种群} (box1.-90);
\end{tikzpicture}
Chapter15/Figures/figure-structure-search-based-on-gradient-method.tex 0 → 100644
%%% outline
%-------------------------------------------------------------------------
\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=blue!20] (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);
\draw[-latex,out=90,in=100,thick] ([xshift=-2em]n1.90) to node[above,font=\scriptsize]{参数优化}([xshift=2em]n1.90);
\end{tikzpicture}
Chapter15/Figures/figure-structure-search-based-on-reinforcement-learning.tex 0 → 100644
%%% outline
%-------------------------------------------------------------------------
\begin{tikzpicture}
\tikzstyle{node}=[minimum height=2em,minimum width=5em,draw,rounded corners=2pt,thick,drop shadow]
\node[node,fill=red!20] (n1) at (0,0){\small\bfnew{环境}};
\node[anchor=south,node,fill=blue!20] (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] (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-swish-function-image.tex 0 → 100644
%%% outline
%-------------------------------------------------------------------------
\begin{tikzpicture}
\begin{axis}[
width=10cm,height=6cm,
legend style={legend pos=north west,font=\footnotesize,align=center},
xtick={-5,-4,-3,-2,-1,0,1,2,3},
ytick={-2,-1,0,1,2,3},
x tick label style={font=\scriptsize},
y tick label style={font=\scriptsize},
xmin=-5,xmax=3,
ymin=-2,ymax=3,
y tick style={opacity=0},
x tick style={opacity=0},
grid=major,
title={\small\bfnew{Swish}},
]
\addplot[cyan,smooth,thick]{x*(1+exp(-10*x))^-1};
\addplot[red,smooth,thick]{x*(1+exp(-1*x))^-1};
\addplot[brown,smooth,thick]{x*(1+exp(-0.1*x))^-1};
\addplot[gray!60, very thick] coordinates {(0,-2) (0,3)};
\addplot[gray!60, very thick] coordinates {(0,0) (3,0)};
\legend{$\beta=0.1$,$\beta=1.0$,$ \ \ \beta=10.0$}
\end{axis}
\end{tikzpicture}
Chapter15/Figures/figure-whole-structure-and-internal-structure-in-rnn.tex 0 → 100644
%%% outline
%-------------------------------------------------------------------------
\begin{tikzpicture}[scale=0.8]
\tikzstyle{every node}=[scale=0.8]
\tikzstyle{node}=[draw,minimum height=1.4em,minimum width=2em,rounded corners=3pt,thick]
\node[node] (n1) at (0,0){};
\node[node] (n2) at (1.5,0){};
\node[node] (n3) at (3,0){};
\node[node] (n4) at (4.5,0){};
\node[node] (n5) at (1.5,-1.3){};
\node[node] (n6) at (3,-1.3){};
\node[node] (n7) at (2.25,-2.4){};
\node[node] (n8) at (3,1.3){};
\draw[->,thick] (n1.0) -- (n2.180);
\draw[->,thick] (n2.0) -- (n3.180);
\draw[->,thick] (n3.0) -- (n4.180);
\draw[->,thick,out=60,in=180] (n1.90) to (n8.180);
\draw[->,thick,out=-10,in=90] (n8.0) to (n4.90);
\draw[->,thick,out=90,in=-90] (n5.90) to (n3.-90);
\draw[->,thick,out=90,in=-90] (n6.90) to (n4.-90);
\draw[->,thick,out=90,in=-90] (n7.90) to (n5.-90);
\draw[->,thick,out=90,in=-90] (n7.90) to (n6.-90);
\node[font=\huge] (ht) at (-0.2,2.2){$\mathbi h_t$};
\node[draw,font=\huge,inner sep=0pt,minimum width=4em,minimum height=4em,very thick,rounded corners=2pt] (ht-1) at (-3,0) {$\mathbi h_{t-1}$};
\node[draw,font=\huge,inner sep=0pt,minimum width=4em,minimum height=4em,very thick,rounded corners=2pt] (ht+1) at (7.5,0) {$\mathbi h_{t+1}$};
\node[font=\huge] (xt) at (2.25,-4.2){$x_t$};
\node[font=\Huge] at (9,0){$\cdots$};
\node[font=\Huge] at (-4.5,0){$\cdots$};
\node[minimum width=3em,minimum height=2em,fill=red!20,rounded corners=6pt] (b1) at (6,-3.8){};
\node[] (w1) at (7.8,-3.8){\Large 整体框架};
\node[minimum width=3em,minimum height=2em,fill=yellow!30,rounded corners=6pt] (b2) at (6,-4.8){};
\node[] (w2) at (7.8,-4.8){\Large 内部结构};
\begin{pgfonlayer}{background}
\node[draw,rounded corners=6pt,very thick,fill=yellow!30,minimum width=16em,minimum height=15em] (box1) at (2.25,0){};
\node[draw=ublue,very thick,drop shadow,inner sep=1.2em,fill=white,xshift=-0.1em] [fit=(b1)(w2)]{};
\draw[fill=red!20,red!20,rounded corners=6pt] ([yshift=2.4em,xshift=1em]ht-1.east) -- ([yshift=2.4em,xshift=-0.1em]box1.west) -- ([xshift=-8em,xshift=-0.1em]box1.south) -- ([xshift=2em]box1.south) -- ([xshift=2em,yshift=-5em]box1.south) -- ([xshift=0em,yshift=-5em]box1.south) .. controls ([xshift=-12em,yshift=-5em]box1.south) and ([yshift=-2em]ht-1.east) ..([yshift=2.4em]ht-1.east) -- ([yshift=2.4em,xshift=1em]ht-1.east) ;
\end{pgfonlayer}
\draw[->,very thick] (ht-1.0) -- (box1.180);
\draw[->,very thick] (box1.0) -- (ht+1.180);
\draw[->,very thick] (ht-1.90) -- ([yshift=2em]ht-1.90);
\draw[->,very thick] (ht+1.90) -- ([yshift=2em]ht+1.90);
\draw[->,very thick] (box1.90) -- ([yshift=2em]box1.90);
\draw[->,very thick] ([yshift=-2em]ht-1.-90) -- (ht-1.-90);
\draw[->,very thick] ([yshift=-2em]ht+1.-90) -- (ht+1.-90);
\draw[->,very thick] ([yshift=-2em]box1.-90) -- (box1.-90);
\end{tikzpicture}
Chapter15/chapter15.tex
...@@ -476,7 +476,7 @@ ...@@ -476,7 +476,7 @@
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\includegraphics[scale=0.4]{./Chapter15/Figures/figure-layer-fusion-method.png} \input{./Chapter15/Figures/figure-layer-fusion-method}
\caption{层融合方法} \caption{层融合方法}
\label{fig:15-10} \label{fig:15-10}
\end{figure} \end{figure}
...@@ -854,24 +854,29 @@ lr=d_{model}^{-0.5}\cdot step\_num^{-0.5} ...@@ -854,24 +854,29 @@ lr=d_{model}^{-0.5}\cdot step\_num^{-0.5}
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 在{\chapterthirteen}提到的Layer Dropout方法可以有效地缓解这个问题。以编码端为例， Layer Dropout的过程可以被描述为：在训练过程中，对自注意力子层或前馈神经网络子层进行随机丢弃，以减少不同子层之间的相互适应。这里选择Pre-Norm结构作为基础架构，它可以被描述为： \parinterval 在{\chapterthirteen}提到的Layer Dropout方法可以有效地缓解这个问题。以编码端为例， Layer Dropout的过程可以被描述为：在训练过程中，对自注意力子层或前馈神经网络子层进行随机丢弃，以减少不同子层之间的相互适应。这里选择Pre-Norm结构作为基础架构，它可以被描述为：
\begin{equation} \begin{equation}
x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l \mathbi{x}_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\label{eq:15-44} \label{eq:15-44}
\end{equation} \end{equation}
\noindent 其中$\textrm{LN}( \cdot )$表示层标准化函数， $F( \cdot )$表示自注意力机制或者前馈神经网络，$\mathbi{x}_l$表示第$l$个子层的输出。之后，使用一个掩码$\textrm{Mask}$（值为0或1）来控制每一子层是正常计算还是丢弃。于是，该子层的计算公式可以被重写为： \noindent 其中$\textrm{LN}( \cdot )$表示层标准化函数， $F( \cdot )$表示自注意力机制或者前馈神经网络，$\mathbi{x}_l$表示第$l$个子层的输出。之后，使用一个掩码$\textrm{Mask}$（值为0或1）来控制每个子层是正常计算还是丢弃。于是，该子层的计算公式可以被重写为：
\begin{equation} \begin{equation}
\mathbi{x}_{l+1}=\textrm{Mask} \cdot F(\textrm{LN}(\mathbi{x}_l))+\mathbi{x}_l \mathbi{x}_{l+1}=\textrm{Mask} \cdot F(\textrm{LN}(\mathbi{x}_l))+\mathbi{x}_l
\label{eq:15-45} \label{eq:15-45}
\end{equation} \end{equation}
\noindent $\textrm{Mask}=0$代表该子层被丢弃，而$\textrm{Mask}=1$代表正常进行当前子层的计算。图\ref{fig:15-19}展示了这个方法与标准Pre-Norm结构之间的区别。 \noindent $\textrm{Mask}=0$代表该子层被丢弃，而$\textrm{Mask}=1$代表正常进行当前子层的计算。图\ref{fig:15-19}展示了这个方法与标准Pre-Norm结构之间的区别。
%---------------------------------------------- %----------------------------------------------
...@@ -883,7 +888,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -883,7 +888,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 除此之外，有研究者已经发现残差网络中底层的子网络通过对输入进行抽象得到的表示对最终的输出有很大的影响，上层网络通过对底层网络得到的表示不断修正来拟合训练目标\upcite{DBLP:journals/corr/GreffSS16}。该结论同样适用于Transformer模型，比如，在训练中，残差支路以及底层的梯度范数通常比较大，这也间接表明底层网络在整个优化的过程中需要更大的更新。考虑到这个因素，在设计每一个子层被丢弃的概率时可以采用自底向上线性增大的策略，保证底层的网络相比于顶层更容易保留下来。 \parinterval 除此之外，有研究者已经发现残差网络中底层的子网络的作用是对输入进行抽象，而上层网络通过对底层网络计算得到的表示进行不断地修正来拟合训练目标，因此底层的子网络的计算结果对最终的输出有很大的影响\upcite{DBLP:journals/corr/GreffSS16}。该结论同样适用于Transformer模型，比如，在训练中，残差支路以及底层的梯度范数通常比较大，这也间接表明底层网络在整个优化的过程中需要更大的更新。考虑到这个因素，在设计每一个子层被丢弃的概率时可以采用自底向上线性增大的策略，保证底层的网络相比于顶层更容易保留下来。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
...@@ -892,7 +897,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -892,7 +897,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\sectionnewpage \sectionnewpage
\section{基于树结构的模型} \section{基于树结构的模型}
\parinterval 在统计机器翻译时代，使用句法树是一种非常有效的机器翻译建模手段（见{\chaptereight}）。由于句法树是人类运用语言的高级抽象结果，使用句法树可以非常有效地帮助机器翻译系统捕捉句子的结构。将这种知识引入到机器翻译中，能使得翻译系统在译文语法、流畅度等方面获得进一步的提升，同时消除翻译句子中的歧义，进而得到更准确的译文。在神经机器翻译中，虽然标准的框架并没有使用句法结构信息，但是引入句法树结构仍然能够进一步提升翻译的质量\upcite{DBLP:conf/acl/LiXTZZZ17}。具体来说，由于神经机器翻译模型缺少对于句子结构的理解，会导致一些明显的翻译问题： \parinterval 在统计机器翻译时代，使用句法树是一种非常有效的机器翻译建模手段（见{\chaptereight}）。由于句法树是人类运用语言的高级抽象结果，使用句法树可以非常有效地帮助机器翻译系统捕捉句子的结构。将这种知识引入到机器翻译中，能使得翻译系统在译文语法正确性以及流畅度等方面获得进一步的提升，同时也可以消除翻译句子中的歧义，进而得到更准确的译文。在神经机器翻译中，虽然标准的框架并没有使用句法结构信息，但是引入句法树结构仍然能够进一步提升翻译的质量\upcite{DBLP:conf/acl/LiXTZZZ17}。具体来说，由于神经机器翻译模型缺少对于句子结构的理解，会导致一些明显的翻译问题：
\begin{itemize} \begin{itemize}
\vspace{0.5em} \vspace{0.5em}
...@@ -916,7 +921,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -916,7 +921,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\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}
...@@ -934,7 +939,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -934,7 +939,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\label{eq:15-46} \label{eq:15-46}
\end{equation} \end{equation}
\parinterval 图\ref{fig:15-20}展示了一个基于树结构的神经机器翻译编码器，这些编码器由下自上组成了一颗树型结构，这种树结构的具体了连接形式由句法分析决定。其中$\mathbi{h}_1,\mathbi{h}_2,\cdots,\mathbi{h}_n$与原始RNN中隐藏节点的计算方式一致，代表了一个句子中词汇的表示。$\mathbi{h}_{n+1},\mathbi{h}_{n+2},\cdots,\mathbi{h}_{2n-1}$由其左右子节点通过公式\eqref{eq:15-46}计算得到，代表了一个句子中句法的表示。在计算注意力的时候，不同于{\chapterten}的计算方式，基于树结构的编码器模型利用编码端树中的所有节点计算编码信息$\mathbi{C}$,如公式\eqref{eq:15-47}。 \parinterval 图\ref{fig:15-20}展示了一个基于树结构的神经机器翻译编码器，这些编码器由下自上组成了一颗树型结构，这种树结构的具体了连接形式由句法分析决定。其中$\mathbi{h}_1,\mathbi{h}_2,\cdots,\mathbi{h}_n$相当于原始RNN中隐藏节点，$\mathbi{h}_{n+1},\mathbi{h}_{n+2},\cdots,\mathbi{h}_{2n-1}$由其左右子节点通过公式\eqref{eq:15-46}计算得到。在计算注意力的时候，不同于{\chapterten}的计算方式，基于树结构的编码器模型利用编码端树结构中的所有节点计算上下文向量$\mathbi{C}$,如公式\eqref{eq:15-47}。
\begin{equation} \begin{equation}
\mathbi{C}_j = \sum_{i=1}^{n}\alpha_{i,j}\mathbi{h}_i + \sum_{i=n+1}^{2n-1}\alpha_{i,j}\mathbi{h}_i \mathbi{C}_j = \sum_{i=1}^{n}\alpha_{i,j}\mathbi{h}_i + \sum_{i=n+1}^{2n-1}\alpha_{i,j}\mathbi{h}_i
\label{eq:15-47} \label{eq:15-47}
...@@ -949,7 +954,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -949,7 +954,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\end{figure} \end{figure}
%-------------------------------------------s %-------------------------------------------s
\parinterval 这样的好处是编码端能更加方便地将一个短语结构表示成一个单元，进而在解码端映射成一个整体。比如，对于英文句子： \parinterval $\mathbi{C}_j$代表生成第$j$个目标语言单词所需的源语言信息{\red{（见10.4.1）}}，这样的好处是编码端能更加方便地将一个短语结构表示成一个单元，进而在解码端映射成一个整体。比如，对于英文句子：
\begin{equation} \begin{equation}
\textrm{“ I am having a cup of green tea. ”} \nonumber \textrm{“ I am having a cup of green tea. ”} \nonumber
\end{equation} \end{equation}
...@@ -961,7 +966,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -961,7 +966,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\noindent 其中，“a cup of green tea”实际上只对应目标语“緑茶”一个词。使用句法树后，“a cup of green tea”会作为树中一个节点，这样可以更好地把它作为一个整体进行翻译。 \noindent 其中，“a cup of green tea”实际上只对应目标语“緑茶”一个词。使用句法树后，“a cup of green tea”会作为树中一个节点，这样可以更好地把它作为一个整体进行翻译。
\parinterval 虽然这种单向自底向上使用树结构的证明了：句法信息能够帮助源语言端学到更好的表示结果，但是每个树节点的状态里并不能包含树中其它位置的信息。也就是说，从每个节点上看，其表示结果没有很好的利用上下文。因此，有研究者提出了双向树编码器\upcite{Yang2017TowardsBH,DBLP:conf/acl/ChenHCC17}，将自下而上和自上而下的信息传递方式应用于句法树的表示，这样增加了树中每个节点对其覆盖的子树以及周围的上下文的建模能力，如图\ref{fig:15-21}所示，图中$\mathbi{h}^{up}$和$\mathbi{h}^{down}$分别代表向上传输节点和向下传输节点的隐藏状态，虚线框代表了$\mathbi{h}^{up}$和$\mathbi{h}^{down}$会拼接到一起作为这个节点的整体表示参与注意力计算。此外，这种方法也有利于改进覆盖度模型\upcite{TuModeling}。 \parinterval 虽然这种自底向上的单向树结构取得了一定的效果，证明了句法信息能够帮助源语言端学到更好的表示结果，但是每个树节点的状态里并不能包含树中其它位置的信息。也就是说，从每个节点上看，其表示结果没有很好的利用上下文。因此，有研究者提出了双向树编码器\upcite{Yang2017TowardsBH,DBLP:conf/acl/ChenHCC17}，将自下而上和自上而下的信息传递方式应用于句法树的表示，这样增加了树中每个节点对其覆盖的子树以及周围的上下文的建模能力。如图\ref{fig:15-21}所示，图中$\mathbi{h}^{up}$和$\mathbi{h}^{down}$分别代表向上传输节点和向下传输节点的隐藏状态，虚线框代表了$\mathbi{h}^{up}$和$\mathbi{h}^{down}$会拼接到一起，并作为这个节点的整体表示参与注意力计算。此外，这种方法也有利于改进覆盖度模型\upcite{TuModeling}{\red{（见14.2.2）}}。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -972,15 +977,15 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -972,15 +977,15 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 不同于直接对树结构进行编码，另一种方法是将词语、句法信息等信息直接转换为特征向量拼接到一起，作为机器翻译系统的输入\upcite{DBLP:conf/wmt/SennrichH16}。这种方法的优点在于，句法信息可以无缝的融入现有神经机器翻译框架，对系统结构的修改很小。以基于循环神经网络的翻译模型为例，对于输入序列的$i$个单词，可以用如下公式计算其表示向量$\mathbi{h}_i$：如公式\eqref{eq:15-48}所示其在RNN编码端输入时将添加上词根，子词，形态，词性以及依存的标签特征向量{\red{下面的ik是否合适，还是说改成i,k}} \parinterval 不同于直接对树结构进行编码，另一种方法是将词语、句法信息等信息直接转换为特征向量拼接到一起，作为机器翻译系统的输入\upcite{DBLP:conf/wmt/SennrichH16}。这种方法的优点在于，句法信息可以无缝融入到现有神经机器翻译框架，对系统结构的修改很小。以基于循环神经网络的翻译模型为例，对于输入序列的$i$个单词，可以用公式\eqref{eq:15-48}计算其表示向量$\mathbi{h}_i$时添加特征向量：{\red{下面的ik是否合适，还是说改成i,k}}
\begin{equation} \begin{equation}
\mathbi{h}_i = \textrm{tanh}(\mathbi{W}(\|_{k=1}^{|F|}\mathbi{E}_h x_{ik}) + \mathbi{U}\mathbi{h}_{i-1}) \mathbi{h}_i = \textrm{tanh}(\mathbi{W}(\|_{k=1}^{|F|}\mathbi{E}_h x_{ik}) + \mathbi{U}\mathbi{h}_{i-1})
\label{eq:15-48} \label{eq:15-48}
\end{equation} \end{equation}
\noindent 其中，$\mathbi{W}$是转换矩阵，$mathbi{U}$是权重矩阵，$F$代表了特征的数量，而$\mathbi{E}$是一个特征矩阵，包含了不同种类特征的数量，$x_{ik}$代表了第$i$个词在第$k$种特征中所表达的值，$\|$操作为拼接操作。公式\eqref{eq:15-48}将从共$F$个特征向量连接成固定大小的向量，作为编码端输入。这种方法可以很容易地融合多种特征，如词根，子词，形态，词性以及依存标签等特征{\red{和上一段最后一句重复}}。 \noindent 其中，$\mathbi{W}$是转换矩阵，$\mathbi{U}$是权重矩阵，$F$代表了特征的数量，而$\mathbi{E}$是一个特征矩阵，它包含了不同种类特征的数量，$x_{ik}$代表了第$i$个词在第$k$种特征中所表达的值，$\|$操作为拼接操作。公式\eqref{eq:15-48}将从共$F$个特征向量连接成固定大小的向量，作为编码端的输入。这种方法可以很容易地融合如词根，子词，形态，词性以及依存标签等特征。
\parinterval 那么是否有更有效的方法，将句法信息融入到编码端呢？如图\ref{fig:15-22}(a)所示，对于英文“I love dogs”，有如下句法解析树： \parinterval 此外是否有更有效的方法，将句法信息融入到编码端呢？如图\ref{fig:15-22}(a)所示，对于英文“I love dogs”，有如下句法解析树：
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -991,17 +996,23 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -991,17 +996,23 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 其中，图\ref{fig:15-22}(b)和图\ref{fig:15-22}(c)使用$w_i$表示句法解析树中第$i$个单词，$l_j$表示句法解析树中第$j$个语法标签。通过观察句法树的结构可以看出，对一个单词来说，句法树中该单词的父节点代表了该单词最精确的句法信息，因此直接用单词父节点的句法信息与原始的词信息构造出新的融合表示${\mathbi{h}'}_i$，并使用这种新的表示计算编码信息$\mathbi{C}$，如公式\eqref{eq:15-49}所示： \parinterval 对于该句法解析树，可以使用$w_i$表示句法解析树中第$i$个单词，如图\ref{fig:15-22}(b)所示。使用$l_j$表示句法解析树中第$j$个语法标签，如图\ref{fig:15-22}(c)所示。通过观察句法树的结构可以看出，对一个单词来说，句法树中该单词的父节点代表了该单词最精确的句法信息，因此一个直观的想法是直接使用单词父节点的句法信息与原始的词信息构造出新的融合表示${\mathbi{h}'}_i$，并使用这种新的表示计算上下文向量$\mathbi{C}$，如公式\eqref{eq:15-49}所示：
\begin{equation} \begin{equation}
\mathbi{C}_j = \sum_{i=1}^m \alpha_{i,j} {\mathbi{h}'}_i \mathbi{C}_j = \sum_{i=1}^m \alpha_{i,j} {\mathbi{h}'}_i
\label{eq:15-49} \label{eq:15-49}
\end{equation} \end{equation}
\parinterval 其中，$m$是源语言句子的长度。基于这种想法，有如下几种思路\upcite{DBLP:conf/acl/LiXTZZZ17}：第一种是利用两个编码端构成平行结构，分别对源语言词汇和线性化的句法树进行建模，之后在词语RNN和句法RNN中寻找句法解析树中每个词汇以及他们的父节点，将他们的隐层状态相融合，得到新的表示。如图\ref{fig:15-23}(a)所示，图中$\mathbi{h}_{w_i}$为词$w_i$在词语RNN中的隐藏状态，$\mathbi{h}_{l_j}$为树结构标签$l_i$在句法RNN中的隐藏状态，其中如果词语$w_i$是标签$l_j$在句法树中的子节点，则将$\mathbi{h}_{w_i}$和$\mathbi{h}_{l_j}$向量拼接到一起作为这个词的新表示${\mathbi{h}'}_i$； \parinterval 其中，$m$是源语言句子的长度。基于这种想法，有如下几种实现方式\upcite{DBLP:conf/acl/LiXTZZZ17}：
\parinterval 第二种想法是分层结构，将句法RNN与源语言单词的词嵌入向量进行融合，如图\ref{fig:15-23}(b)所示，其中$\mathbi{e}_{w_i}$为第$i$个词的词嵌入。类似地，如果$w_i$词语是$l_j$标签在句法树中的子节点，则将$\mathbi{e}_{w_i}$和$\mathbi{h}_{l_j}$向量拼接到一起作为词语RNN的输入，输出得${\mathbi{h}'}_i$直接参与注意力计算； \begin{itemize}
\vspace{0.5em}
\parinterval 此外还可以使用混合结构的方式在编码端融入句法信息，首先对图\ref{fig:15-22}(a)中句法解析树进行先序遍历，将句法标签和源语言单词融合到同一个序列中，得到如图\ref{fig:15-23}(c)所示序列，之后使用同一个RNN结构处理这些表示，然后使用源语词位置的隐藏信息参与注意力的计算。有趣的是，相比于前两种方法，使用混合结构的方式不仅参数量最少而且最为有效\upcite{DBLP:conf/acl/LiXTZZZ17}。 \item 平行结构。利用两个编码端构成平行结构，分别对源语言词汇和线性化的句法树进行建模，之后在词语RNN和句法RNN中寻找句法解析树中每个词汇以及他们的父节点，将他们的隐层状态相融合，得到新的表示。如图\ref{fig:15-23}(a)所示，图中$\mathbi{h}_{w_i}$为词$w_i$在词语RNN中的隐藏状态，$\mathbi{h}_{l_j}$为树结构标签$l_i$在句法RNN中的隐藏状态，其中如果词语$w_i$是标签$l_j$在句法树中的子节点，则将$\mathbi{h}_{w_i}$和$\mathbi{h}_{l_j}$向量拼接到一起作为这个词的新表示${\mathbi{h}'}_i$；
\vspace{0.5em}
\item 分层结构。将句法RNN与源语言单词的词嵌入向量进行融合，如图\ref{fig:15-23}(b)所示，其中$\mathbi{e}_{w_i}$为第$i$个词的词嵌入。类似地，如果$w_i$词语是$l_j$标签在句法树中的子节点，则将$\mathbi{e}_{w_i}$和$\mathbi{h}_{l_j}$向量拼接到一起作为词语RNN的输入，输出得${\mathbi{h}'}_i$直接参与注意力计算；
\vspace{0.5em}
\item 混合结构。使用混合结构的方式在编码端融入句法信息，首先对图\ref{fig:15-22}(a)中句法解析树进行先序遍历，将句法标签和源语言单词融合到同一个序列中，得到如图\ref{fig:15-23}(c)所示序列，之后使用同一个RNN结构处理这些表示，然后使用源语词位置的隐藏信息参与注意力的计算。有趣的是，相比于前两种方法，使用混合结构的方式不仅参数量最少而且最为有效\upcite{DBLP:conf/acl/LiXTZZZ17}。
\vspace{0.5em}
\end{itemize}
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -1014,15 +1025,15 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -1014,15 +1025,15 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 总的来说，对于源语言端使用句法信息的情况，由于句法信息的生成依赖句法分析装置，因此句法分析的错误会很大程度上影响源语言句子的表示结果。如果得到的句法信息不够精确，可能会带来负面作用。此外，也有研究发现基于词串的神经机器翻译模型本身就能学习到源语言的句法信息\upcite{DBLP:conf/emnlp/ShiPK16}，这表明了神经机器翻译模型也有一定归纳句法的能力。除了循环神经网络结构，也有学者探索如何在Transformer中引入树结构信息。比如，可以在计算编码端自注意力分布的时候，将词与词之间的依存变换成距离表示作为额外的语法信息融入到注意力计算中\upcite{DBLP:conf/acl/BugliarelloO20}。 \parinterval 总的来说，对于在源语言端使用句法信息的情况，由于句法信息的生成依赖于句法分析装置，因此句法分析的错误会在很大程度上影响源语言句子的表示结果。如果获得的句法信息不够精确，可能会对翻译系统带来负面的作用。此外，也有研究发现基于词串的神经机器翻译模型本身就能学习到源语言的句法信息\upcite{DBLP:conf/emnlp/ShiPK16}，这表明了神经机器翻译模型也有一定的归纳句法的能力。除了循环神经网络结构，也有学者探索如何在Transformer中引入树结构信息。比如，可以在计算编码端自注意力分布的时候，将词与词之间的依存变换成距离表示作为额外的语法信息融入到注意力计算中\upcite{DBLP:conf/acl/BugliarelloO20}。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SUB-SECTION % NEW SUB-SECTION
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
\subsection{解码端使用句法信息} \subsection{解码端使用句法信息}\label{subsec-15.3.2}
\parinterval 也有大量的工作探索如何将将句法树加入到解码端中。一种最直接的方式是将目标语句法树结构进行线性化，这样目标语言句子变成了一个含有句法信息的序列，神经机器翻译系统不需要进行修改即可完成训练\upcite{Aharoni2017TowardsSN}。图\ref{fig:15-24}展示了一个目标语言句法树经过线性化后的结果。这种方法的最大优点是简单、易于实现，而且同时适用于在源语言和目标语言引入句法树的情况。不过，这种方式的问题是，推断时预测的目标语言串可能并不对应合理的句法树结构，需要额外的模块对结果进行修正或者调整，以得到合理的译文。 \parinterval 也有大量的工作探索如何将句法树加入到解码端中。一种最直接的方式是将目标语句法树结构进行线性化，这样目标语言句子就变成了一个含有句法信息的序列，神经机器翻译系统不需要进行修改即可完成训练\upcite{Aharoni2017TowardsSN}。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -1033,11 +1044,13 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -1033,11 +1044,13 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 另一种方式是直接用目标语句法树完成翻译建模。与源语言句法树的建模不同，目标语言句法树的生成伴随着译文的生成，因此无法像源语言端一样将整个句法树一次输入。这样译文生成问题本质上变成了目标语树结构的生成，从这个角度说，这个过程与统计机器翻译中串到树的模型是类似的（见{\chaptereight}）。树的结构生成有很多种策略，基本的思想均是根据已经生成的局部结构预测新的局部结构，并将这些局部结构拼装成更大的结构，直到得到完整的句法树结构\upcite{DBLP:conf/iclr/Alvarez-MelisJ17}。 \parinterval 图\ref{fig:15-24}展示了一个目标语言句法树经过线性化后的结果。这种方法的最大优点是简单、易于实现，而且同时适用于在源语言和目标语言引入句法树的情况。不过，这种方法的问题是，推断时预测的目标语言串可能并不对应合理的句法树结构，此时需要额外的模块对结果进行修正或者调整，以得到合理的译文。
\parinterval 另一种方式是直接使用目标语言句法树完成翻译建模。与源语言句法树的建模不同，目标语言句法树的生成伴随着译文的生成，因此无法像源语言端一样将整个句法树一次输入。这样译文生成问题本质上就变成了目标语言树结构的生成，从这个角度说，这个过程与统计机器翻译中串到树的模型是类似的（见{\chaptereight}）。树结构的生成有很多种策略，基本的思想均是根据已经生成的局部结构预测新的局部结构，并将这些局部结构拼装成更大的结构，直到得到完整的句法树结构\upcite{DBLP:conf/iclr/Alvarez-MelisJ17}。
\parinterval 实现目标语句法树生成的一种手段是将形式文法扩展到神经网络模型。这样，我们可以使用形式文法描述句法树的生成过程（见{\chapterthree}），同时利用分布式表示来进行建模和学习。比如，可以使用基于循环神经网络的文法描述方法，把句法分析过程看作是一个循环神经网络的执行过程\upcite{DBLP:conf/naacl/DyerKBS16}。这个过程对应一个移进-规约分析过程\upcite{aho1972theory}，因此句法分析实质上就是一个移进-规约动作序列。这样（目标语）句法树就可以通过基于循环神经网络的移进-规约过程实现。 \parinterval 实现目标语句法树生成的一种手段是将形式文法扩展到神经网络模型。这样，我们可以使用形式文法描述句法树的生成过程（见{\chapterthree}），同时利用分布式表示来进行建模和学习。比如，可以使用基于循环神经网络的文法描述方法，把句法分析过程看作是一个循环神经网络的执行过程\upcite{DBLP:conf/naacl/DyerKBS16}。这个过程对应一个移进-规约分析过程\upcite{aho1972theory}，因此句法分析实质上就是一个移进-规约动作序列。这样（目标语）句法树就可以通过基于循环神经网络的移进-规约过程实现。
\parinterval 另一种方式从多任务角度出发，用多个解码端共同完成目标语言句子的生成\upcite{DBLP:journals/corr/LuongLSVK15}。图\ref{fig:15-25}展示了一个由一个编码器（英语）-三个解码器组成的序列生成模型。其中三个解码器分别负责三个任务：第一个用于预测翻译结果，即翻译任务；第二个用于预测句法结构；第三个用于重新生成源语言序列，进行自编码。其设计思想是通过各个任务之间能够相互辅助，使得编码端的表示能包含更多的信息，进而让多个任务都获得性能提升。而且这种方法可以使用多个编码器，其思想是类似的。 \parinterval 另一种方式从多任务角度出发，用多个解码端共同完成目标语言句子的生成\upcite{DBLP:journals/corr/LuongLSVK15}。图\ref{fig:15-25}展示了由一个编码器（汉语）和多个解码器组成的序列生成模型。其中不同解码器分别负责不同的任务：第一个用于预测翻译结果，即翻译任务；第二个用于预测句法结构；第三个用于重新生成源语言序列，进行自编码。其设计思想是各个任务之间能够相互辅助，使得编码器的表示能包含更多的信息，进而让多个任务都获得性能提升。这种方法也可以使用多个编码器，其思想是类似的。{\red{图中改成编码器}}
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -1048,9 +1061,9 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -1048,9 +1061,9 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 当然，也有研究者提出了两个问题：紧密的融合词串和句法结构的学习是否优于多任务学习？以及目标语句法信息的引入是否真的帮助到了机器翻译？\upcite{DBLP:conf/wmt/NadejdeRSDJKB17}。为了回答这个问题，研究者尝试利用{\small\bfnew{CCG}}\index{CCG}CCG（Combinatory Categorial Grammar）\index{Combinatory Categorial Grammar}中的supertags作为句法信息，并比较了直接将CCG标签与句子进行融合（如图\ref{fig:15-24}）和将句子与标签分开作为多任务（如图\ref{fig:15-25}）两种融合方式进行训练，最后发现第一种方式是更加有效的。 \parinterval 针对上述两种在解码端融入句法信息的方法，也有研究者提出过以下问题：紧密的融合词串和句法结构的学习是否优于多任务学习？以及目标语句法信息的引入是否真的帮助到了机器翻译？\upcite{DBLP:conf/wmt/NadejdeRSDJKB17}。为了回答这个问题，研究者尝试利用{\small\bfnew{CCG}}\index{CCG}（Combinatory Categorial Grammar）\index{Combinatory Categorial Grammar}中的supertags作为句法信息，并比较了直接将CCG标签与句子进行融合（如图\ref{fig:15-24}）和将句子与标签分开作为多任务（如图\ref{fig:15-25}）两种融合方式进行训练，最后发现第一种方式是更加有效的。
\parinterval 虽然融合树结构和目标语言词串的方法优于基于多任务的方法，但是前者会导致解码端的序列过长，进而难以训练。为了缓解这个问题可以在这两种方法之间设计两个循环神经网络结构，一个生成句子，另一个生成树结构\upcite{DBLP:conf/acl/WuZYLZ17,DBLP:journals/corr/abs-1808-09374}。以生成目标语言依存树为例，生成依存树的循环神经网络仍然是一个移进-规约序列的生成模型。另一个循环神经网络负责预测目标语词序列，它只有在第一个循环神经网络移进操作的时候才会预测一下词，同时会将当前词状态作为信息送入到第一个循环神经网络中。整个过程如图\ref{fig:15-26}所示，其中$\mathbi{h}_i^{action}$表示动作RNN的隐藏层状态，$\mathbi{h}_i^{word}$表示词语RNN的隐藏层状态。动作RNN会结合词语RNN的状态预测出“移位”，“左规约”，“右规约”三种动作，只有当动作RNN预测出“移位”操作时，词语RNN才会预测下一时刻的词语。最后词语RNN预测出结束符号<eos>时，整个过程结束。需要注意的是，这种方法并不依赖循环神经网络结构，也可以将其替换为Transformer等结构完成序列的生成。 \parinterval 虽然融合树结构和目标语言词串的方法优于基于多任务的方法，但是前者会导致解码端的序列过长，因此会面临难以训练的问题。为了缓解这种现象可以在这两种方法之间设计两个循环神经网络结构，一个生成句子，另一个生成树结构\upcite{DBLP:conf/acl/WuZYLZ17,DBLP:journals/corr/abs-1808-09374}。以生成目标语言依存树为例，生成依存树的循环神经网络仍然是一个移进-规约序列的生成模型。另一个循环神经网络负责预测目标语词序列，它只有在第一个循环神经网络移进操作的时候才会预测一下词，同时会将当前词状态作为信息送入到第一个循环神经网络中。整个过程如图\ref{fig:15-26}所示，其中$\mathbi{h}_i^{action}$表示动作RNN的隐藏层状态，$\mathbi{h}_i^{word}$表示词语RNN的隐藏层状态。动作RNN会结合词语RNN的状态预测出“移位”，“左规约”，“右规约”三种动作，只有当动作RNN预测出“移位”操作时，词语RNN才会预测下一时刻的词语。最后词语RNN预测出结束符号<eos>时，整个过程结束。需要注意的是，这种方法并不依赖循环神经网络结构，也可以将其替换为Transformer等结构来完成序列的生成。
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
...@@ -1061,7 +1074,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -1061,7 +1074,7 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\end{figure} \end{figure}
%------------------------------------------- %-------------------------------------------
\parinterval 相较于编码端使用句法信息，在解码端融入句法信息更为困难。由于解码过程存在着前向依赖，因此树结构信息与词语的生成反而是一个相互影响的过程，如果严格按照给定的树结构翻译，即先生成结构再根据结构生成标签，那么一旦结构有误则解码结果会受到影响，而如果用一种不太严格的方式，即将树结构和目标语一起预测，树结构对译文的预测作用又会减弱。在统计机器翻译中，句法信息究竟应该使用到什么程度已经有一些讨论\upcite{Tong2016Syntactic}，而在神经机器翻译中，如何更有效地引入树结构信息以及如何平衡树结构信息与词串的作用还有待进一步确认。 \parinterval 相较于在编码端融入句法信息，在解码端融入句法信息更为困难。由于解码过程存在着前向依赖，因此树结构信息与词语的生成反而是一个相互影响的过程，如果严格按照给定的树结构翻译，即先生成结构再根据结构生成标签，那么一旦结构有误解码结果就会受到影响，而如果用一种不太严格的方式，即将树结构和目标语一起预测，树结构对译文的预测作用又会减弱。在统计机器翻译中，句法信息究竟应该使用到什么程度已经有一些讨论\upcite{Tong2016Syntactic}，而在神经机器翻译中，如何更有效地引入树结构信息以及如何平衡树结构信息与词串的作用还有待进一步确认。
%---------------------------------------------------------------------------------------- %----------------------------------------------------------------------------------------
% NEW SECTION % NEW SECTION
...@@ -1076,6 +1089,11 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l ...@@ -1076,6 +1089,11 @@ x_{l+1}=F(\textrm{LN}(\mathbi{x}_l)) + \mathbi{x}_l
\subsection{神经网络结构搜索} \subsection{神经网络结构搜索}
\parinterval 目前为止，对模型的很多改良都来自于研究人员自身的经验及灵感。从某种意义上说，很多时候，模型结构的优化依赖于研究人员对任务的理解以及自身的想象力，同时所设计出的模型结构还需要在对应任务上进行实验。优秀的模型往往需要很长时间的探索与验证。因此，人们希望在无需过多外部干预的情况下，让计算机自动地找到最适用于当前任务的神经网络模型结构，这种方法被称作{\small\bfnew{神经架构搜索}}\index{神经架构搜索}（Neural Architecture Search）\index{Neural Architecture Search}，在神经网络模型中有时也被称作{\small\bfnew{神经网络结构搜索}}\index{神经网络结构搜索}或{\small\bfnew{网络结构搜索}}\index{网络结构搜索}\upcite{DBLP:conf/iclr/ZophL17,DBLP:conf/cvpr/ZophVSL18,Real2019AgingEF}。 \parinterval 目前为止，对模型的很多改良都来自于研究人员自身的经验及灵感。从某种意义上说，很多时候，模型结构的优化依赖于研究人员对任务的理解以及自身的想象力，同时所设计出的模型结构还需要在对应任务上进行实验。优秀的模型往往需要很长时间的探索与验证。因此，人们希望在无需过多外部干预的情况下，让计算机自动地找到最适用于当前任务的神经网络模型结构，这种方法被称作{\small\bfnew{神经架构搜索}}\index{神经架构搜索}（Neural Architecture Search）\index{Neural Architecture Search}，在神经网络模型中有时也被称作{\small\bfnew{神经网络结构搜索}}\index{神经网络结构搜索}或{\small\bfnew{网络结构搜索}}\index{网络结构搜索}\upcite{DBLP:conf/iclr/ZophL17,DBLP:conf/cvpr/ZophVSL18,Real2019AgingEF}。
\parinterval 网络结构搜索属于{\small\bfnew{自动机器学习}}\index{自动机器学习}（Automated Machine Learning）\index{Automated Machine Learning}的范畴，其目的在于根据对应任务上的数据找到最合适的模型结构。在这个过程中，模型结构就像传统神经网络中的模型参数一样自动地被学习出来。以机器翻译任务为例，通过网络结构搜索的方法能够在Transformer模型的基础上对神经网络结构进行自动优化，找到更适用于机器翻译任务的模型结构。图\ref{fig:15-27}(a) 给出传统人工设计的Transformer模型编码器中若干层的结构，图\ref{fig:15-27}(b) 给出该结构经过进化算法优化后的编码器中相应的结构\upcite{DBLP:conf/icml/SoLL19}。可以看到，网络结构搜索系统得到的模型中，出现了与传统人工设计的Transformer结构不同的跨层连接，同时还搜索到了全新的多分支网络结构，而这种结构是人工不易设计出来的。 \parinterval 网络结构搜索属于{\small\bfnew{自动机器学习}}\index{自动机器学习}（Automated Machine Learning）\index{Automated Machine Learning}的范畴，其目的在于根据对应任务上的数据找到最合适的模型结构。在这个过程中，模型结构就像传统神经网络中的模型参数一样自动地被学习出来。以机器翻译任务为例，通过网络结构搜索的方法能够在Transformer模型的基础上对神经网络结构进行自动优化，找到更适用于机器翻译任务的模型结构。图\ref{fig:15-27}(a) 给出传统人工设计的Transformer模型编码器中若干层的结构，图\ref{fig:15-27}(b) 给出该结构经过进化算法优化后的编码器中相应的结构\upcite{DBLP:conf/icml/SoLL19}。可以看到，网络结构搜索系统得到的模型中，出现了与传统人工设计的Transformer结构不同的跨层连接，同时还搜索到了全新的多分支网络结构，而这种结构是人工不易设计出来的。
...@@ -1167,7 +1185,7 @@ a = \funp{P}(\cdot|\mathbi{x};a) ...@@ -1167,7 +1185,7 @@ a = \funp{P}(\cdot|\mathbi{x};a)
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\includegraphics[scale=0.3]{./Chapter15/Figures/figure-whole-structure-and-internal-structure-in-rnn.png} \input{./Chapter15/Figures/figure-whole-structure-and-internal-structure-in-rnn}
\caption{循环神经网络模型中的整体结构和内部结构} \caption{循环神经网络模型中的整体结构和内部结构}
\label{fig:15-31} \label{fig:15-31}
\end{figure} \end{figure}
...@@ -1215,7 +1233,7 @@ a = \funp{P}(\cdot|\mathbi{x};a) ...@@ -1215,7 +1233,7 @@ a = \funp{P}(\cdot|\mathbi{x};a)
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\includegraphics[scale=0.25]{./Chapter15/Figures/figure-structure-search-based-on-evolutionary-algorithm.png} \input{./Chapter15/Figures/figure-structure-search-based-on-evolutionary-algorithm}
\caption{基于进化算法的结构搜索} \caption{基于进化算法的结构搜索}
\label{fig:15-32} \label{fig:15-32}
\end{figure} \end{figure}
...@@ -1227,7 +1245,7 @@ a = \funp{P}(\cdot|\mathbi{x};a) ...@@ -1227,7 +1245,7 @@ a = \funp{P}(\cdot|\mathbi{x};a)
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\includegraphics[scale=0.25]{./Chapter15/Figures/figure-structure-search-based-on-reinforcement-learning.png} \input{./Chapter15/Figures/figure-structure-search-based-on-reinforcement-learning}
\caption{基于强化学习的结构搜索} \caption{基于强化学习的结构搜索}
\label{fig:15-33} \label{fig:15-33}
\end{figure} \end{figure}
...@@ -1240,7 +1258,7 @@ a = \funp{P}(\cdot|\mathbi{x};a) ...@@ -1240,7 +1258,7 @@ a = \funp{P}(\cdot|\mathbi{x};a)
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\includegraphics[scale=0.25]{./Chapter15/Figures/figure-structure-search-based-on-gradient-method.png} \input{./Chapter15/Figures/figure-structure-search-based-on-gradient-method}
\caption{基于梯度方法的结构搜索} \caption{基于梯度方法的结构搜索}
\label{fig:15-34} \label{fig:15-34}
\end{figure} \end{figure}
...@@ -1307,7 +1325,7 @@ f(x) &=& x \cdot \delta(\beta x) \\ ...@@ -1307,7 +1325,7 @@ f(x) &=& x \cdot \delta(\beta x) \\
%---------------------------------------------- %----------------------------------------------
\begin{figure}[htp] \begin{figure}[htp]
\centering \centering
\includegraphics[scale=0.5]{./Chapter15/Figures/figure-swish-function-image.png} \input{./Chapter15/Figures/figure-swish-function-image}
\caption{Swish函数图像} \caption{Swish函数图像}
\label{fig:15-36} \label{fig:15-36}
\end{figure} \end{figure}
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论