手把手带你学习神经机器翻译--模型篇
Posted 真不错鸭
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了手把手带你学习神经机器翻译--模型篇相关的知识，希望对你有一定的参考价值。
文章目录
1、深度神经网络
1.1、全连接神经网络
全连接神经网络(FullyConnected Neural Network,FCNN)，是深度神经网络中最基本的一种结构，如图所示。按照神经元所处的位置划分，全连接网络由输入层，隐藏层和输出层组成，通常第一层为输入层，最后一层为输出层，中间部分全为隐藏层。顾名思义，全连接神经网络中每一个神经元都与下一层的神经元全部连接，因而每个层又称为全连接层。网络中同层次的神经元之间无连接，层次间的神经元关系由下述公式得出：
其中，当l=1时，h0t=xt即为输入。显然，公式21的计算过程是线性的，若每个神经元由该线性计算得出，无论网络的层数有多少，模型解决问题的能力仅限于线性划分问题。为了使神经网络可以处理任意非线性问题，引入了非线性激活函数(Nonlinear Activeation Function，下简称为激活函数)，用以增强神经网络的泛化性。常用的激活函数有sigmoid,tanh和ReLU。
引入激活函数后层次间神经元关系计算为：
其中，σ代表激活函数。
全连接网络通过对每一个神经元进行计算，得出输出层神经元的结果。近年来，随着各种特异的网络结构的 出，纯粹由全连接层组成的全连接网络并不多见，通常全连接层和其他结构搭配出现，作为一个线性或非线性的映射层。
1.2、循环神经网络
在实际场景中，许多问题的建模都是和时间序列信息有关系的。尤其是在自然语言处理的许多任务中，数据间的上下文的依赖性很高。考虑到对这类问题进行建模，Elman出循环神经网络(Recurrent Neural Network,RNN)，其结构如图所示。显然，循环神经网络的输入和输出之间有一个循环过程，将循环过程展开后可以发现，循环神经网络的隐藏层节点关系建立在两个输入之上，一是当前时刻的标准输入，另一个是上一个节点的隐藏层信息，体现为：
其中，o代表循环神经单元的输出值，h代表循环神经单元的隐藏层值。显然，和全连接网络不同的是，循环神经元有两个输出。此外，循环神经网络中的参数是所有输入共享的，也就是说，同一层输入所使用的参数是相同的。这样的参数共享不仅能够使得模型的参数量大大减少，同时还能增强模型的泛化能力，尤其是在自然语言处理的相关问题上，当模型接收到超过训练样本长度的输入时，模型仍然能够 取到输入的特征，但这样的参数共享同时也为模型误差传播带来了一定的障碍。目前，对RNN的训练采用的是时序方向传播方法(BackpropagationThrough Time,BPTT)，从图22右边的展开式中可以看出，展开后的RNN在时序上的深度取决于序列的长度，而BPTT算法的求导链和这个长度息息相关。因此当序列变长时，BPTT面临两个问题：梯度消失和梯度爆炸。梯度消失是指BPTT反馈到一定长度之后，出现梯度趋近于零无法学习的问题，梯度爆炸则正好相反，它表示梯度呈现很大的值导致长程神经元学习无用的情况。无论BPTT出现哪一种问题，都会使得序列中的上下文关系无法被体现，背离了RNN结构建模序列关系的初衷。目前解决这两个问题的主流方案是在RNN的神经元上增加门控机制来控制数据流向，保证有用数据的传递，其中最著名的是长短期记忆单元(longshortTerm Memory,LSTM)和门控循环单元(Gated Recurrent Units,GRU)。
长短期记忆单元LSTM在普通的RNN神经元内增加了三个门控单元来控制数据流向，可以形象的将其称为输入门、遗忘门和输出门，三个门分别对应了三个并列的全连接层。最后，输出由三个门的结果和前一个神经元的状态融合产生，具体公式如下：
其中，i,f,o分别对应输入门、遗忘门和输出门，c表示神经元的细胞态，h为当前神经元隐藏状态值，也是当前神经元的输出，它融合了三个门的结果和前一个神经元的状态信息。Wi,f,o,c,Ui,f,o,c,bi,f,o,c对应不同门的可学习参数，同时，和普通的RNN一样，这些参数也是所有神经元共享的。
因此，当序列通过采用LSTM单元作为基础单元的RNN时，序列信息流的传播会由门控单元来进行控制，保证有用信息的传递，在一定程度上减少模型学习无用的问题。但LSTM在神经元内部进行的一系列全连接计算也导致了模型效率的降低。Cho等人在基于LSTM的基础上，对门控单元进行简化后 出了一种变体结构：门控循环单元GRU。在GRU中，门控单元被减少到了两个：重置门®和更新门(z)，其结构由图给出，计算如下：
不难发现，GRU直接使用重置门对前一时刻神经元隐藏状态进行刷新,随后融合该状态和当前输入值得到一个新的细胞态，而更新门则根据该细胞态和前一时刻神经元的隐藏状态来控制数据的传递。由于GRU显式的减少了一个门控单元，因此GRU所需的参数量较LSTM更少，在序列任务上的计算效率也比LSTM更高，性能鲜有损失。
1.2.1、RNN模型代码
from __future__ import absolute_import
from recurrentshop import LSTMCell, RecurrentSequential
from .cells import LSTMDecoderCell, AttentionDecoderCell
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, TimeDistributed, Bidirectional, Input
def SimpleSeq2Seq(output_dim, output_length, hidden_dim=None, input_shape=None,
batch_size=None, batch_input_shape=None, input_dim=None,
input_length=None, depth=1, dropout=0.0, unroll=False,
stateful=False):
'''
Simple model for sequence to sequence learning.
The encoder encodes the input sequence to vector (called context vector)
The decoder decodes the context vector in to a sequence of vectors.
There is no one on one relation between the input and output sequence
elements. The input sequence and output sequence may differ in length.
Arguments:
output_dim : Required output dimension.
hidden_dim : The dimension of the internal representations of the model.
output_length : Length of the required output sequence.
depth : Used to create a deep Seq2seq model. For example, if depth = 3,
there will be 3 LSTMs on the enoding side and 3 LSTMs on the
decoding side. You can also specify depth as a tuple. For example,
if depth = (4, 5), 4 LSTMs will be added to the encoding side and
5 LSTMs will be added to the decoding side.
dropout : Dropout probability in between layers.
'''
if isinstance(depth, int):
depth = (depth, depth)
if batch_input_shape:
shape = batch_input_shape
elif input_shape:
shape = (batch_size,) + input_shape
elif input_dim:
if input_length:
shape = (batch_size,) + (input_length,) + (input_dim,)
else:
shape = (batch_size,) + (None,) + (input_dim,)
else:
# TODO Proper error message
raise TypeError
if hidden_dim is None:
hidden_dim = output_dim
encoder = RecurrentSequential(unroll=unroll, stateful=stateful)
encoder.add(LSTMCell(hidden_dim, batch_input_shape=(shape[0], shape[-1])))
for _ in range(1, depth[0]):
encoder.add(Dropout(dropout))
encoder.add(LSTMCell(hidden_dim))
decoder = RecurrentSequential(unroll=unroll, stateful=stateful,
decode=True, output_length=output_length)
decoder.add(Dropout(dropout, batch_input_shape=(shape[0], hidden_dim)))
if depth[1] == 1:
decoder.add(LSTMCell(output_dim))
else:
decoder.add(LSTMCell(hidden_dim))
for _ in range(depth[1] - 2):
decoder.add(Dropout(dropout))
decoder.add(LSTMCell(hidden_dim))
decoder.add(Dropout(dropout))
decoder.add(LSTMCell(output_dim))
_input = Input(batch_shape=shape)
x = encoder(_input)
output = decoder(x)
return Model(_input, output)
def Seq2Seq(output_dim, output_length, batch_input_shape=None,
input_shape=None, batch_size=None, input_dim=None, input_length=None,
hidden_dim=None, depth=1, broadcast_state=True, unroll=False,
stateful=False, inner_broadcast_state=True, teacher_force=False,
peek=False, dropout=0.):
'''
Seq2seq model based on [1] and [2].
This model has the ability to transfer the encoder hidden state to the decoder's
hidden state(specified by the broadcast_state argument). Also, in deep models
(depth > 1), the hidden state is propogated throughout the LSTM stack(specified by
the inner_broadcast_state argument. You can switch between [1] based model and [2]
based model using the peek argument.(peek = True for [2], peek = False for [1]).
When peek = True, the decoder gets a 'peek' at the context vector at every timestep.
[1] based model:
Encoder:
X = Input sequence
C = LSTM(X); The context vector
Decoder:
y(t) = LSTM(s(t-1), y(t-1)); Where s is the hidden state of the LSTM (h and c)
y(0) = LSTM(s0, C); C is the context vector from the encoder.
[2] based model:
Encoder:
X = Input sequence
C = LSTM(X); The context vector
Decoder:
y(t) = LSTM(s(t-1), y(t-1), C)
y(0) = LSTM(s0, C, C)
Where s is the hidden state of the LSTM (h and c), and C is the context vector
from the encoder.
Arguments:
output_dim : Required output dimension.
hidden_dim : The dimension of the internal representations of the model.
output_length : Length of the required output sequence.
depth : Used to create a deep Seq2seq model. For example, if depth = 3,
there will be 3 LSTMs on the enoding side and 3 LSTMs on the
decoding side. You can also specify depth as a tuple. For example,
if depth = (4, 5), 4 LSTMs will be added to the encoding side and
5 LSTMs will be added to the decoding side.
broadcast_state : Specifies whether the hidden state from encoder should be
transfered to the deocder.
inner_broadcast_state : Specifies whether hidden states should be propogated
throughout the LSTM stack in deep models.
peek : Specifies if the decoder should be able to peek at the context vector
at every timestep.
dropout : Dropout probability in between layers.
'''
if isinstance(depth, int):
depth = (depth, depth)
if batch_input_shape:
shape = batch_input_shape
elif input_shape:
shape = (batch_size,) + input_shape
elif input_dim:
if input_length:
shape = (batch_size,) + (input_length,) + (input_dim,)
else:
shape = (batch_size,) + (None,) + (input_dim,)
else:
# TODO Proper error message
raise TypeError
if hidden_dim is None:
hidden_dim = output_dim
encoder = RecurrentSequential(readout=True, state_sync=inner_broadcast_state,
unroll=unroll, stateful=stateful,
return_states=broadcast_state)
for _ in range(depth[0]):
encoder.add(LSTMCell(hidden_dim, batch_input_shape=(shape[0], hidden_dim)))
encoder.add(Dropout(dropout))
dense1 = TimeDistributed(Dense(hidden_dim))
dense1.supports_masking = True
dense2 = Dense(output_dim)
decoder = RecurrentSequential(readout='add' if peek else 'readout_only',
state_sync=inner_broadcast_state, decode=True,
output_length=output_length, unroll=unroll,
stateful=stateful, teacher_force=teacher_force)
for _ in range(depth[1]):
decoder.add(Dropout(dropout, batch_input_shape=(shape[0], output_dim)))
decoder.add(LSTMDecoderCell(output_dim=output_dim, hidden_dim=hidden_dim,
batch_input_shape=(shape[0], output_dim)))
_input = Input(batch_shape=shape)
_input._keras_history[0].supports_masking = True
encoded_seq = dense1(_input)
encoded_seq = encoder(encoded_seq)
if broadcast_state:
assert type(encoded_seq) is list
states = encoded_seq[-2:]
encoded_seq = encoded_seq[0]
else:
states = None
encoded_seq = dense2(encoded_seq)
inputs = [_input]
if teacher_force:
truth_tensor = Input(batch_shape=(shape[0], output_length, output_dim))
truth_tensor._keras_history[0].supports_masking = True
inputs += [truth_tensor]
decoded_seq = decoder(encoded_seq,
ground_truth=inputs[1] if teacher_force else None,
initial_readout=encoded_seq, initial_state=states)
model = Model(inputs, decoded_seq)
model.encoder = encoder
model.decoder = decoder
return model
def AttentionSeq2Seq(output_dim, output_length, batch_input_shape=None,
batch_size=None, input_shape=None, input_length=None,
input_dim=None, hidden_dim=None, depth=1,
bidirectional=True, unroll=False, stateful=False, dropout=0.0,):
'''
This is an attention Seq2seq model based on [3].
Here, there is a soft allignment between the input and output sequence elements.
A bidirection encoder is used by default. There is no hidden state transfer in this
model.
The math:
Encoder:
X = Input Sequence of length m.
H = Bidirection_LSTM(X); Note that here the LSTM has return_sequences = True,
so H is a sequence of vectors of length m.
Decoder:
y(i) = LSTM(s(i-1), y(i-1), v(i)); Where s is the hidden state of the LSTM (h and c)
and v (called the context vector) is a weighted sum over H:
v(i) = sigma(j = 0 to m-1) alpha(i, j) * H(j)
The weight alpha[i, j] for each hj is computed as follows:
energy = a(s(i-1), H(j))
alpha = softmax(energy)
Where a is a feed forward network.
'''
if isinstance(depth, int):
depth = (depth, depth)
if batch_input_shape:
shape = batch_input_shape
elif input_shape:
shape = (batch_size,) + input_shape
elif input_dim:
if input_length:
shape = (batch_size,) + (input_length,) + (input_dim,)
else:
shape = (batch_size,) + (None,) + (input_dim,)
else:
# TODO Proper error message
raise TypeError
if hidden_dim is None:
hidden_dim = output_dim
_input = Input(batch_shape=shape)
_input._keras_history[0].supports_masking = True
encoder = RecurrentSequential(unroll=unroll, stateful=stateful,
return_sequences=True)
encoder.add(LSTMCell(hidden_dim, batch_input_shape=(shape[0], shape[2])))
for _ in range(1, depth[0]):
encoder.add(Dropout(dropout))
encoder.add(LSTMCell(hidden_dim))
if bidirectional:
encoder = Bidirectional(encoder, merge_mode='sum')
encoder.forward_layer.build(shape)
encoder.backward_layer.build(shape)
# patch
encoder.layer = encoder.forward_layer
encoded = encoder(_input)
decoder = RecurrentSequential(decode=True, output_length=output_length,
unroll=unroll, stateful=stateful)
decoder.add(Dropout(dropout, batch_input_shape=(shape[0], shape[1], hidden_dim)))
if depth[1] == 1:
decoder.add(AttentionDecoderCell(output_dim=output_dim, hidden_dim=hidden_dim))
else:
decoder.add(AttentionDecoderCell(output_dim=output_dim, hidden_dim=hidden_dim))
for _ in range(depth[1] - 2):
decoder.add(Dropout(dropout))
decoder.add(LSTMDecoderCell(output_dim=hidden_dim, hidden_dim=hidden_dim))
decoder.add(Dropout(dropout))
decoder.add(LSTMDecoderCell(output_dim=output_dim, hidden_dim=hidden_dim))
inputs = [_input]
decoded = decoder(encoded)
model = Model(inputs, decoded)
return model
1.3、卷积神经网络
和循环神经网络 出的原因一样，卷积神经网络(Convolutional Neural Network,CNN) 出也是为了针对性的处理问题。与循环神经网络的 出是针对序列关系建模不同的是，卷积神经网络最初的 出是为了高效处理非序列数据问题，例如取图像中的特征问题。具体地，图像由于其具有空间三维性且包含的数据量过大，使用全连接网络会导致网络庞大且效率低下，为了 高神经网络对图像等类似数据的高效处理，基于局部特征取的卷积神经网络被出。它通过模拟生物捕捉图像特征的方法，对输入进行局部特征的 取，再依靠深度网络对高层特征的捕捉能力实现对图像的特征取。后来卷积神经网络被证明也可应用于自然语言处理任务，并且效率更高。一个完整的卷积神经网络包含三个部分，卷积层、池化层、全连接层。
卷积层是卷积神经网络的核心计算层，用于取输入的特征。一个卷积层由多个卷积核(Kernel)组成，每个卷积核负责取输入的一部分局部特征，其深度和输入相同，但高度和宽度都远小于输入。一次卷积计算，卷积核仅能和在其视野内，也就是在其高度和宽度范围内的输入数据交互，这个视野也被称之为感受野，是由人为设定的。通过滑动，卷积核的感受野不断变换，从而完成和输入的所有数据交互。感受野滑动的幅度称之为步长，是一个人为设定的经验值，一般设为1。卷积的计算过程用公式表示如下：
其中，h[m,n]代表尺寸为m×n的输入经过卷积后得到的隐藏层输出值，卷积核集合为K×L,一次卷积从中取出一个k×l的卷积核进行操作，I为输入数据，可以是输入源数据，也可以是前一隐藏层的输出数据。σ代表激活函数。图演示了一个卷积核尺寸为3×3的一次卷积计算示例。
显然，若想获得输入的更多特征，则需要设定多种不同的卷积核去捕捉输入，这样仍然会使得模型庞大。为了减少网络的参数量，卷积神经网络引入下采样操作周期性的在卷积层之后进行操作，被称为池化层。池化层的计算方法一般有两种，最大池化(Max Pooling)和平均池化(Average Pooling)，顾名思义，最大池化即是在池化区域中取最大值作为输出，而平均池化是取池化区域中的平均值作为输出。同卷积层操作一样，池化层也需要人工设定工作区域和移动步长，图2演示了一个池化区域为2×2，在步长为2时的最大池化/平均池化示例。
卷积神经网络通过堆叠卷积层和池化层获取到输入的特征，再将该特征拉伸为向量后通过一个全连接层后输出整个网络的结果。
1.4、基于循环神经网络的深度神经序列模型
对深度神经序列模型的追溯，最早可到2013年，由Kalchbrenner等人出采用编码解码的思想解决自然语言生成问题，它为后续序列模型结构奠定了基础，该思想为：将给定输入文本通过一个编码器网络重构成一个新的表示，再采用一个解码器网络解构这个表示并根据解构后的信息生成目标文本。具体地，Kalchbrenner等人在文中采用卷积神经网络作为编码器对输入进行重构，采用循环神经网络作为解码器进行生成。该模型当时虽并未取得非常理想的结果，但却引发了领域内众人的热烈讨论。考虑到模型采用卷积神经网络作为编码器并不能完全切合语言的特点，同时解码器采用的循环神经单元未做门控处理会有梯度消失/爆炸的问题，Sutckever等人将LSTM单元引入该模型替换了原模型中的基本循环神经单元，同时将编码器中的卷积神经网络替换为更贴合语言特点的循环神经网络，该模型如图所示，其在机器翻译任务上取得的成功验证了深度神经网络模型在自动机器翻译任务上的可行性。几乎同时，Cho等人对此种序列到序列的模型归纳为编码解码模型，并通过对上下文表示的强调进一步升该模型的性能，如图所示。
自此，序列到序列模型在自然语言处理生成问题上奠定了基础，任何可建模为“序列映射到序列”的问题都可采用该框架，并且采用LSTM或GRU的循环神经网络也成为自然语言处理任务的标准结构。计算过程一般分为3步，首先编码器对输入文本X=(x1,x2,…,xm)进行重构，其中xi表示输入文本中第i个最小组成部分，也就是一个标记。对于中文来说，如果是基于中文词语的模型，一个标记就代表一个词语，如果是基于中文分字的模型，一个标记就代表一个字符；对于英文或其它类似西文来说，一个标记代表一个单词。编码器重构的方式为：
其中fRNN代表采用了LSTM或GRU的循环神经单元，h为循环神经单元的隐藏值，l代表层数，此处定义i代表当前编码时序，显然i−1是前一个时序。根据循环神经网络的特点，一般采用最后一层最后一个时序计算后的输出作为重构后的向量表示，定义为c，该向量由于融合了前序序列经门控后的特征，被认为是输入文本的高层语义表示。接下来解码器使用c作为上下文语义表示进行解码计算，定义为：
其中，gRNN代表采用了LSTM或GRU的循环神经单元，s为循环神经单元的隐藏值，t代表当前解码时序，o为循环神经单元的输出值，y为当前时刻解码器的输入，同时它也是前一时序模型的预测输出，这种模式被称为自回归解码模式，即每一时刻解码器的预测值都是基于前一时刻解码器的预测值计算的。模型的输出部分采用一个线性层对解码器的输出进行线性转换并映射到词表上进行选词：
值得一 的是，目前在文本生成技术中广泛采用teacherforcing学习算法，该算法在模型训练阶段采用右移标签作为解码器输入，即丢弃训练阶段模型的预测值，转而使用t−1时刻的标签值作为解码器的输入以帮助模型尽快学习。到模型预测阶段时，才真正使用前一时刻的预测值来预测输出。由于这个学习算法能加快模型拟合，因此该方法也是目前自然语言处理任务的标准有监督学习方法。
1.4.1 Lstm模型实现代码
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Dict, List, Optional, Tuple
import torch
import torch.nn as nn
import torch.nn.functional as F
from fairseq import utils
from fairseq.models import (
FairseqEncoder,
FairseqEncoderDecoderModel,
FairseqIncrementalDecoder,
register_model,
register_model_architecture,
)
from fairseq.modules import AdaptiveSoftmax, FairseqDropout
from torch import Tensor
DEFAULT_MAX_SOURCE_POSITIONS = 1e5
DEFAULT_MAX_TARGET_POSITIONS = 1e5
@register_model("lstm")
class LSTMModel(FairseqEncoderDecoderModel):
def __init__(self, encoder, decoder):
super().__init__(encoder, decoder)
@staticmethod
def add_args(parser):
"""Add model-specific arguments to the parser."""
# fmt: off
parser.add_argument('--dropout', type=float, metavar='D',
help='dropout probability')
parser.add_argument('--encoder-embed-dim', type=int, metavar='N',
help='encoder embedding dimension')
parser.add_argument('--encoder-embed-path', type=str, metavar='STR',
help='path to pre-trained encoder embedding')
parser.add_argument('--encod以上是关于手把手带你学习神经机器翻译--模型篇的主要内容，如果未能解决你的问题，请参考以下文章
7天掌握神经网络？AI算法实战营来了！带你轻松掌握机器学习+神经网络算法（手慢无）
Google发布机器学习平台Tensorflow游乐场～带你玩神经网络（转载）