要想在循环神经网络中有一种机制，使其具有前瞻性，就需要修改循环神经网络的设计。只需添加一个循环神经网络，从最后一个单词开始，从后到前运行，而不仅仅是一个循环神经网络，在前向模式下从第一个单词开始运行。 双向循环神经网络（bidirectional RNNs）为了更灵活地处理的隐藏层，以便更灵活地处理此类信息。 下图描述了具有单个隐藏层的双向循环神经网络的结构。

任何时间步 t t t，给定一个小批量的输入数据 X t ∈ R n × d \mathbf{X}_t \in \mathbb{R}^{n \times d} Xt∈Rn×d（样本数： n n n，每个示例中的输入数： d d d），使隐藏层激活函数为 ? \phi ?。在双向结构中，我们将时间步的前向和反向隐藏状态分别设置为 H → t ∈ R n × h \overrightarrow{\mathbf{H}}_t \in \mathbb{R}^{n \times h} H t​∈Rn×h 和 H ← t ∈ R n × h \overleftarrow{\mathbf{H}}_t \in \mathbb{R}^{n \times h} H t​∈Rn×h，其中 h h h 是隐藏单元的数目。前向和反向隐藏状态的更新如下：

H → t = ϕ ( X t W x h ( f ) + H → t − 1 W h h ( f ) + b h ( f ) ) , H ← t = ϕ ( X t W x h ( b ) + H ← t + 1 W h h ( b ) + b h ( b ) ) , \begin{aligned} \overrightarrow{\mathbf{H}}_t &= \phi(\mathbf{X}_t \mathbf{W}_{xh}^{(f)} + \overrightarrow{\mathbf{H}}_{t-1} \mathbf{W}_{hh}^{(f)} + \mathbf{b}_h^{(f)}),\\ \overleftarrow{\mathbf{H}}_t &= \phi(\mathbf{X}_t \mathbf{W}_{xh}^{(b)} + \overleftarrow{\mathbf{H}}_{t+1} \mathbf{W}_{hh}^{(b)} + \mathbf{b}_h^{(b)}), \end{aligned} H t​H t​​=ϕ(Xt​Wxh(f)​+H t−1​Whh(f)​+bh(f)​),=ϕ(Xt​Wxh(b)​+H t+1​Whh(b)​+bh(b)​),​

其中，权重 W x h ( f ) ∈ R d × h , W h h ( f ) ∈ R h × h , W x h ( b ) ∈ R d × h , W h h ( b ) ∈ R h × h \mathbf{W}_{xh}^{(f)} \in \mathbb{R}^{d \times h}, \mathbf{W}_{hh}^{(f)} \in \mathbb{R}^{h \times h}, \mathbf{W}_{xh}^{(b)} \in \mathbb{R}^{d \times h}, \mathbf{W}_{hh}^{(b)} \in \mathbb{R}^{h \times h} Wxh(f)​∈Rd×h,Whh(f)​∈Rh×h,Wxh(b)​∈Rd×h,Whh(b)​∈Rh×h 和偏置 b h ( f ) ∈ R 1 × h , b h ( b ) ∈ R 1 × h \mathbf{b}_h^{(f)} \in \mathbb{R}^{1 \times h}, \mathbf{b}_h^{(b)} \in \mathbb{R}^{1 \times h} bh(f)​∈R1×h,bh(b)​∈R1×h 都是模型参数。

接下来，将前向隐藏状态 H → t \overrightarrow{\mathbf{H}}_t H t​ 和反向隐藏状态 H ← t \overleftarrow{\mathbf{H}}_t H t​ ，拼接进行，获得需要送入输出层的隐藏状态 H t ∈ R n × 2 h \mathbf{H}_t \in \mathbb{R}^{n \times 2h} Ht​∈Rn×2h。在具有多个隐藏层的深度双向循环神经网络中，该信息作为输入传递到下一个双向层。最后，输出层计算得到的输出为 O t ∈ R n × q \mathbf{O}_t \in \mathbb{R}^{n \times q} Ot​∈Rn×q（ q q q 是输出单元的数目）：

O t = H t W h q + b q . \mathbf{O}_t = \mathbf{H}_t \mathbf{W}_{hq} + \mathbf{b}_q. Ot​=Ht​Whq​+bq​.

机器翻译是序列转换模型的一个核心问题，其输入和输出都是长度可变的序列。为了处理这种类型的输入和输出，我们可以设计一个包含两个主要组件的结构。第一个组件是一个 编码器（encoder）：它接受一个长度可变的序列作为输入，并将其转换为具有固定形状的编码状态。第二个组件是 解码器（decoder）：它将固定形状的编码状态映射到长度可变的序列。

图中是一个更普遍的编码-解码器（Decoder也加上一个input )

小结：使用编码器-解码器架构模型，编码器负责表示输入，解码器负责表示输出。

（编码器） 在编码器接口中，我们只指定长度可变的序列作为编码器的输入 X。任何继承这个 Encoder 基类的模型将完成代码实现。

from torch import nn
#@save
class Encoder(nn.Module):
    """编码器-解码器结构的基本编码器接口。"""
    def __init__(self, **kwargs):
        super(Encoder, self).__init__(**kwargs)

    def forward(self, X, *args):
        raise NotImplementedError

（解码器） 解码器接口中，新增一个 init_state 函数用于将编码器的输出（enc_outputs）转换为编码后的状态。注意，此步骤可能需要额外的输入，（例如：输入序列的有效长度）。为了逐个地生成长度可变的词元序列，解码器在每个时间步都会将输入（例如：在前一时间步生成的词元）和编码后的状态映射成当前时间步的输出词元。

#@save
class Decoder(nn.Module):
    """编码器-解码器结构的基本解码器接口。"""
    def __init__(self, **kwargs):
        super(Decoder, self).__init__(**kwargs)

    def init_state(self, enc_outputs, *args):
        raise NotImplementedError

    def forward(self, X, state):
        raise NotImplementedError

[合并编码器和解码器]

最后，“编码器-解码器”结构包含了一个编码器和一个解码器，并且还拥有可选的额外的参数。在前向传播中，编码器的输出用于生成编码状态，这个状态又被解码器作为其输入的一部分。

#@save
class EncoderDecoder(nn.Module):
    """编码器-解码器结构的基类。"""
    def __init__(self, encoder, decoder, **kwargs):
        super(EncoderDecoder, self).__init__(**kwargs)
        self.encoder = encoder
        self.decoder = decoder

    def forward(self, enc_X, dec_X, *args):
        enc_outputs = self.encoder(enc_X, *args)
        dec_state = self.decoder.init_state(enc_outputs, *args)
        return self.decoder(dec_X, dec_state)

在下节中，将学习如何应用循环神经网络，来设计基于“编码器－解码器”结构的序列转换模型。

seq2seq最早就是用在机器翻译上的，在机器翻译中的输入序列和输出序列都是长度可变的。 为了解决这类问题，设计了一个通用的”编码器－解码器“结构。 编码器在大多数情况下，是会搞成双向的；但解码器不行，由于它不能看到全局。

其中，特定的eos表示序列结束词元。 一旦输出序列生成此词元，模型就可以停止执行预测。 在循环神经网络解码器的初始化时间步，有两个特定的设计决定。 首先，特定的bos表示序列开始词元，它是解码器的输入序列的第一个词元。 其次，使用循环神经网络编码器最终的隐藏状态来初始化解码器的隐藏状态。