序列到序列学习（seq2seq）

阅读目录

seq2seq
代码
预测
- 预测序列的评估(BLEU)

seq2seq

seq2seq最早应用于机器翻译，给定一个源语言的句子，自动翻译成目标语言。

我们可以看出，机器翻译中的输入序列和输出序列都是长度可变的。为了解决这类问题，我们设计了⼀个通用的"编码器－解码器"架构。本节，我们将使用两个循环神经网络的编码器和解码器，并将其应用于序列到序列（sequence to sequence，seq2seq）类的学习任务。

遵循编码器－解码器架构的设计原则，循环神经网络编码器使用长度可变的序列作为输入，将其转换为固定形状的隐状态。换言之，输入序列的信息被编码到循环神经网络编码器的隐状态中。为了连续生成输出序列的词元，独立的循环神经网络解码器是基于输入序列的编码信息和输出序列已经看见的或者生成的词元来预测下⼀个词元。下图演示了如何在机器翻译中使⽤两个循环神经⽹络进⾏序列到序列学习。

在上图中，特定的"<eos>"表示序列结束词元。⼀旦输出序列生成此词元，模型就会停止预测。在循环神经网络解码器的初始化时间步，有两个特定的设计决定：首先，特定的"<bos>"表示序列开始词元，它是解码器的输入序列的第一个词元。其次，使用循环神经网络编码器最终的隐状态来初始化解码器的隐状态。编码器最终的隐状态在每⼀个时间步都作
为解码器的输⼊序列的⼀部分。它可以允许标签成为原始的输出序列，从源序列词元"<bos>""Ils""regardent""."到新序列词元"Ils""regardent"".""<eos>"来移动预测的位置。

seq2seq指的是一个特定的模型，它的编码器是一个RNN(循环神经网络)，使用长度可变的序列作为输入，将其转换为固定形状的隐状态;然后将最终的隐藏状态传给解码器，隐藏状态包括了整个源句子(输入序列)的信息。解码器使用另外一个RNN，基于输入序列的编码信息和输出序列已经看见的或者生成的词元来预测下一个词元，从而连续生成输出序列的词元
编码器将长度可变的输入序列转换成形状固定的上下文变量，并且将输入序列的信息在该上下文变量中进行编码，编码器最终的隐状态在每⼀个时间步都作为解码器的输入序列的⼀部分
编码器可以是单向的循环神经网络，其中的隐藏状态只依赖于输入子序列，这个子序列是由输入序列的开始位置到隐藏状态所在的时间步的位置（包括隐藏状态所在的时间步)组成
编码器也可以是双向的循环神经网络，其中隐藏状态依赖于两个输入子序列，两个子序列是由隐藏状态所在的时间步的位置之前的序列和之后的序列(包含隐藏状态所在的时间步)，因此隐藏状态对整个序列的信息都进行了编码。双向不能做语言模型，但是双向可以做翻译;双向可以做编码器，但不能做解码器，解码器需要做预测，编码器不需要
<bos>表示序列开始词元，代表一个句子的开始，它是解码器的输入序列的第-个词元
<eos>表示序列结束词元，代表一个句子的结束(解码器输出的句子长度是可以变化的，一旦输出序列生成此词元，模型就会停止预测)
RNN做编码器可以输入任意长度的序列，最后返回最后时刻的隐藏状态，使用RNN编码器最终的隐状态来初始化解码器的隐状态，解码器一直输出，直到看到句子的结束标志为止
seq2seq也可以做可变长度到可变长度的句子之间的翻译

编码器-解码器细节

编码器是没有输出的RNN
编码器最后时间步的隐藏状态作为解码器的初始隐藏状态

训练

训练时将特定的开始词元("<bos>")和原始的输出序列(不包括序列结束词元"<eos>")拼接在一起作为解码器的输入，这也称为强制教学(teacher forcing，因为原始的输出序列(词元的标签）被送入了解码器)
也可以将来自上一个时间步的预测得到的词元作为解码器的当前输入
训练和推理是不同的: 编码器是相同的，但是在训练的时候，解码器是知道目标句子的，它知道真正的翻译是什么样子的，所以解码器的输入(每个RNN 时刻的输出）所使用的实际上是真正的目标句子的输入，所以就算是在训练的时候翻译错了，下一个时刻的输入还是正确的输入，也就是说，在训练的时候所使用的是真正的目标句子来帮助训练，这样就降低了预测长句子的难度

预测

推理的时候没有真正的目标句子作为参考，每一个时刻只能将上一个时刻的输出作为这一时刻的输入，以此来不断地进行预测，即每个解码器当前时间步的输入都来自前一个时间步的预测词元，因此能够一个词元接一个词元地预测输出序列·和训练类似，序列开始词元("<bos>")在初始时间步就被输入到了解码器中·当输出序列的预测遇到序列结束词元("<eos>")时，预测就结束了。

但是要注意的是这里：编码器最终的隐状态在每⼀个时间步都作为解码器的输⼊序列的⼀部分

预测序列的评估

我们可以通过与真实的标签序列进行比较来评估预测序列。虽然(Papineni et al., 2002)提出的BLEU（bilingual
evaluation understudy）最先是用于评估机器翻译的结果，但现在它已经被广泛用于测量许多应用的输出序列的质量。其中BLEU的值越大越好，最大值为1，越小的话效果越差，原则上说，对于预测序列中的任意n元语法（n-grams），BLEU的评估都是这个n元语法是否出现在标签序列中。
BLEU定义：

其中 $len_{label}$ 表示标签序列中的词元数和 $len_{pred}$ 表示预测序列中的词元数， $k$ 是用于匹配的最长的n元语法。另外，用 $p_n$ 表示 $n$ 元语法的精确度，它是两个数量的比值：第一个是预测序列与标签序列中匹配的n元语法的数量，第⼆个是预测序列中n元语法的数量的比率。
例如：给定标签序列 $A、B、C、D、E、F$ 和预测序
列 $A、B、B、C、D$ 。我们有 $p_1 = \frac{4}{5}、p2 = \frac{3}{4}、p3 = \frac{1}{3}和p4 = 0。$

p1:考虑预测序列中所有的1-gram，有5个1-gram，即 $A、B、B、C、D$ ，所以分母为5,再考虑这5个1-gram，是不是每一个1-gram都在标签序列中出现过(预测序列中除了第二个B并没有出现，因为在标签序列中B只出现了一次，其它都出现了，所以p1= 4/5)
p2:考虑预测序列中所有的2-gram，有4个2-gram，即 $AB、BB、BC、CD$ ，所以分母为4,再考虑这4个2-gram，是不是每一个2-gram都在标签序列中出现过(预测序列中除了第二个BB并没有出现，因为在标签序列中B只出现了一次，其它都出现了，所以p2=3/4)
p3:考虑预测序列中所有的3-gram，有3个3-gram，即 $ABB、BBC、BCD$ ，所以分母为3,再考虑这3个3-gram，是不是每一个3-gram都在标签序列中出现过（预测序列中只有BCD在标签序列中出现了一次，其它都没有出现了，所以p3=1/3)
p4:考虑预测序列中所有的4-gram，有2个4-gram，即 $ABBC、BBCD$ 所以分母为2;再考虑这2个4-gram，是不是每一个4-gram都在标签序列中出现过(预测序列中所有的4-gram 都没有在标签序列中出现过，所以p4 = 0/2

根据BLEU的定义，当预测序列与标签序列完全相同时，BLEU为1。此外，由于n元语法越长则匹配难度越大，所以BLEU为更长的n元语法的精确度分配更大的权重。具体来说，当 $p_n$ 固定时， $p^{\frac{1}{2^n}}_n$ 会随着n的增长而增加（原始论⽂使⽤ $p^{\frac{1}{n}}_n$ ）。而且，由于预测的序列越短获得的 $p_n$ 值越高，所以乘法项之前的系数用于惩罚较短的预测序列。例如，当k = 2时，给定标签序列 $A、B、C、D、E、F$ 和预测序列 $A、B$ ，尽管 $p_1 = p_2 = 1$ ，惩罚因子exp(1 − 6/2) ≈ 0.14会降低BLEU。

$len_{label}$ 、 $len_{pred}$ 分别表示标签序列中的词元数和预测序列中的词元数，两个序列的词元数可以是不一样的

如果预测的长度比标签(真实)的长度少很多的话len(label)/len(pred)就会大于1，整个指数项就会变成一个很小的数
所以说真实的标签很长，预测的长度很短的话，会导致前面的指数项比较小，因为预测的长度很短的话，就会越容易命中真实的标签，所以前半部分的指数项是为了惩罚较短的预测序列，防止预测的长度过短
$p_n$ 都是一个小于等于1的数，当预测序列和标签序列完全相同时，BLEU为1
由于n元语法越长则匹配难度越大，所以BLEU为更长的n元语法的精确度分配了更大的权重

回到顶部

代码

编码器

从技术上讲，编码器将长度可变的输入序列转换成形状固定的上下文变量c，并且将输入序列的信息在该上下文变量中进行编码。可以使用循环神经网络来设计编码器。考虑由⼀个序列组成的样本（批量大小是1）。假设输⼊序列是 $x_1, . . . , x_T$ ，其中 $x_t$ 是输入文本序列中的第 $t$ 个词元。在时间步 $t$ ，循环神经网络将词元 $x_t$ 的输入特征向量 $x_t$ 和 $h_{t−1}$ （即上一时间步的隐状态）转换为 $h_t$ （即当前步的隐状态）。使用一个函数 $f$ 来描述循环神经网络的循环层所做的变换：

h_{t} = f (x_{t}, h_{t - 1}) .

$h_t = f(x_t, h_{t−1}).$

总之，编码器通过选定的函数q，将所有时间步的隐状态转换为上下文变量：

c = q (h_{1}, . . ., h_{T}) .

$c = q(h_1, . . . , h_T).$

比如，当选择 $q(h_1, . . . , h_T ) = h_T$ 时，上下文变量仅仅是输入序列在最后时间步的隐状态 $h_T$ 。
到目前为止，我们使用的是⼀个单向循环神经网络来设计编码器，其中隐状态只依赖于输入子序列，这个子序列是由输入序列的开始位置到隐状态所在的时间步的位置（包括隐状态所在的时间步）组成。我们也可以使用双向循环神经网络构造编码器，其中隐状态依赖于两个输入子序列，两个子序列是由隐状态所在的时间步的位置之前的序列和之后的序列（包括隐状态所在的时间步），因此隐状态对整个序列的信息都进行了编
码。
现在，让我们实现循环神经网络编码器。注意，我们使用了嵌入层（embedding layer）来获得输入序列中每个词元的特征向量。嵌入层的权重是一个矩阵，其行数等于输入词表的大小（vocab_size），其列数等于特征向量的维度（embed_size）。对于任意输入词元的索引i，嵌入层获取权重矩阵的第i行（从0开始）以返回其特征向量。另外，本文选择了GRU实现编码器。

nn.Embedding(vocab_size, embed_size)
vocab_size：表示一共有多少个字需要embedding，
embed_size:表示我们希望一个字向量的维度是多少
它其实和one-hat的效果差不多
例如：当整个输入数据X只有一句话时
X（1, max_length, num_embeddings）
字典为（num_embeddings, embedding_dim）
则经过翻译之后，这句话变成（1，max_length，embedding_dim）
当输入数据X有多句话时，即Batch_size不等于1,有
X（batch_size, max_length, num_embeddings）
字典为（num_embeddings, embedding_dim）
则经过翻译之后，输入数据X变成（batch_size，max_length，embedding_dim）

还是看不懂可以参考这个：传送门

class Seq2SeqEncoder(d2l.Encoder):
    """用于序列到序列学习的循环神经网络编码器。"""
    def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
                 dropout=0, **kwargs):
        super(Seq2SeqEncoder, self).__init__(**kwargs)
        # 嵌⼊层
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.rnn = nn.GRU(embed_size, num_hiddens, num_layers,
                          dropout=dropout)

    def forward(self, X, *args):
        # 输出'X'的形状：(batch_size,num_steps,embed_size)
        X = self.embedding(X)
        # 在循环神经⽹络模型中，第⼀个轴对应于时间步
        X = X.permute(1, 0, 2)
        # 如果未提及状态，则默认为0
        output, state = self.rnn(X)
        # output的形状:(num_steps,batch_size,num_hiddens)
        # state的形状:(num_layers,batch_size,num_hiddens)
        return output, state

下面，我们实例化上述编码器的实现：我们使用一个两层门控循环单元编码器，其隐藏单元数为16。给定一小批量的输入序列X（批量大小为4，时间步为7）。在完成所有时间步后，最后一层的隐状态的输出是一个张量（output由编码器的循环层返回），其形状为（时间步数，批量大小，隐藏单元数）。

encoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16,
num_layers=2)
encoder.eval()
X = torch.zeros((4, 7), dtype=torch.long)
output, state = encoder(X)
output.shape

# torch.Size([7, 4, 16])

由于这里使用的是门控循环单元，所以在最后一个时间步的多层隐状态的形状是（隐藏层的数量，批量大小，隐藏单元的数量）。如果使用长短期记忆网络，state中还将包含记忆单元信息。

state.shape

# torch.Size([2, 4, 16])

解码器

正如上文提到的，编码器输出的上下文变量 $c$ 对整个输入序列 $x_1, . . . , x_T$ 进行编码。来自训练数据集的输出序
列 $y1, y2, . . . , yT′$ ，对于每个时间步 $t′$ （与输入序列或编码器的时间步 $t$ 不同），解码器输出 $y_{t′}$ 的概率取决于先前的输出子序列 $y_1, . . . , y_{t′−1}$ 和上下文变量 $c$ ，即 $P(y_{t′} | y_1, . . . , y_{t′−1},c)$ 。为了在序列上模型化这种条件概率，我们可以使用另⼀个循环神经网络作为解码器。在输出序列上的任意时间步 $t′$ ，循环神经网络将来自上一时间步的输出 $y_{t′−1}$ 和上下文变量c作为其输入，然后在当前时间步将它们和上一隐状态 $s_{t′−1}$ 转换为隐状态 $s_t′$ 。因此，可以使用函数g来表示解码器的隐藏层的变换：

s_{t'} = g (y_{t' - 1}, c, s_{t' - 1}) .

$s_{t′} = g(y_{t′−1}, c, s_{t′−1}).$

在获得解码器的隐状态之后，我们可以使用输出层和softmax操作来计算在时间步 $t′$ 时输出 $y_{t′}$ 的条件概率分布 $P(y_{t′} | y_1, . . . , y_{t′−1}, c)$ 。
当实现解码器时，我们直接使用编码器最后一个时间步的隐状态来初始化解码器的隐状态。这就要求使用循环神经网络实现的编码器和解码器具有相同数量的层和隐藏单元。为了进⼀步包含经过编码的输入序列的信息，上下文变量在所有的时间步与解码器的输入进行拼接（concatenate）。为了预测输出词元的概率分布，在循环神经⽹络解码器的最后⼀层使⽤全连接层来变换隐状态。
我们来看看拼接的时候的维度，再拼接之前输入的X的维度为(num_steps,batch_size,embed_size),然后因为我们是用的编码器的最后一层的state，所以state[-1].shape为(batch_size,num_hiddens)，然后我们context=state[-1].repeat(X.shape[0], 1, 1)这时候context的维度为(num_steps,batch_size,num_hiddens),然后拼接完之后就是(num_steps,batch_size,embed_size+num_hiddens)

# 解码器
class Seq2SeqDecoder(d2l.Decoder):
    """用于序列到序列学习的循环神经网络解码器"""
    def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
                 dropout=0, **kwargs):
        super(Seq2SeqDecoder, self).__init__(**kwargs)
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers,
                          dropout=dropout)
        self.dense = nn.Linear(num_hiddens, vocab_size)

    def init_state(self, enc_outputs, *args):
        return enc_outputs[1] #因为这个encoutputs的输出有有两个，output和state,所以这个enc_outputs[1]就是state,也就是编码器最后一层的state

    def forward(self,X,state):
        # 输出'X'的形状：(batch_size,num_steps,embed_size)
        X=self.embedding(X).permute(1,0,2)
        #print(state[-1].shape)#因为是state[-1]所以他的shape为(batch_size,num_hiddens)
        # 广播context，使其具有与X相同的num_steps     #X:(num_steps,batch_size,embed_size)
        context=state[-1].repeat(X.shape[0], 1, 1)#转化为是(num_steps,batch_size,num_hiddens)
        X_and_context=torch.cat((X,context),2)#为(num_steps,batch_size,embed_size+num_hiddens)
       # print(X.shape,context.shape,X_and_context.shape)
        output,state=self.rnn(X_and_context,state)
        output=self.dense(output).permute(1,0,2)
        # output的形状:(batch_size,num_steps,vocab_size)
        # state的形状:(num_layers,batch_size,num_hiddens)
        return output, state

下面，我们用与前面提到的编码器中相同的超参数来实例化解码器。如我们所见，解码器的输出形状变为（批量大小，时间步数，词表大小），其中张量的最后⼀个维度存储预测的词元分布。

decoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16,
                         num_layers=2)
decoder.eval()
state = decoder.init_state(encoder(X))
output, state = decoder(X, state)
output.shape, state.shape

# (torch.Size([4, 7, 10]), torch.Size([2, 4, 16]))

损失函数

在每个时间步，解码器预测了输出词元的概率分布。类似于语言模型，可以使用softmax来获得分布，并通过计算交叉熵损失函数来进行优化。回想⼀下之前，特定的填充词元被添加到序列的末尾，因此不同长度的序列可以以相同形状的小批量加载。但是，我们应该将填充词元的预测排除在损失函数的计算之外。为此，我们可以使用下面的sequence_mask函数通过零值化屏蔽不相关的项，以便后面任何不相关预测的计算都是与零的乘积，结果都等于零。例如，如果两个序列的有效长度（不包括填充词元）分别为1和2，则第一个序列的第⼀项和第二个序列的前两项之后的剩余项将被清除为零。

def sequence_mask(X, valid_len, value=0):
    """在序列中屏蔽不相关的项。"""
    maxlen = X.size(1)
    mask = torch.arange((maxlen), dtype=torch.float32,
                        device=X.device)[None, :] < valid_len[:, None]
    X[~mask] = value
    return X

X = torch.tensor([[1, 2, 3], [4, 5, 6]])
sequence_mask(X, torch.tensor([1, 2]))
# 这个指的是第一个[1, 2, 3]有一个元素，第二个[4, 5, 6]有两个元素。

# tensor([[1, 0, 0],
#         [4, 5, 0]])

我们还可以使用此函数屏蔽最后几个轴上的所有项。如果愿意，也可以使用指定的非零值来替换这些项

X = torch.ones(2, 3, 4)
sequence_mask(X, torch.tensor([1, 2]), value=-1)

现在，我们可以通过扩展softmax交叉熵损失函数来遮蔽不相关的预测。最初，所有预测词元的掩码都设置为1。一旦给定了有效长度，与填充词元对应的掩码将被设置为0。最后，将所有词元的损失乘以掩码，以过滤掉损失中填充词元产生的不相关预测。

class MaskedSoftmaxCELoss(nn.CrossEntropyLoss):
    """带遮蔽的softmax交叉熵损失函数"""
    # pred的形状：(batch_size,num_steps,vocab_size)
    # label的形状：(batch_size,num_steps)
    # valid_len的形状：(batch_size,)
    def forward(self, pred, label, valid_len):
        weights = torch.ones_like(label)
        weights = sequence_mask(weights, valid_len)
        self.reduction = 'none'
        unweighted_loss = super(MaskedSoftmaxCELoss,
                                self).forward(pred.permute(0, 2, 1), label)
        weighted_loss = (unweighted_loss * weights).mean(dim=1)
        return weighted_loss

我们可以创建三个相同的序列来进行代码健全性检查，然后分别指定这些序列的有效长度为4、2和0。结果就是，第⼀个序列的损失应为第二个序列的两倍，而第三个序列的损失应零。

loss = MaskedSoftmaxCELoss()
loss(torch.ones(3, 4, 10), torch.ones((3, 4), dtype=torch.long),
     torch.tensor([4, 2, 0]))
	 
# tensor([2.3026, 1.1513, 0.0000])

训练

在下面的循环训练过程中，特定的序列开始词元（"<bos>"）和原始的输出序列（不包括序列结束词元"<eos>"）拼接在⼀起作为解码器的输⼊。这被称为强制教学（teacher forcing），因为原始的输出序列（词元的标签）被送⼊解码器。或者，将来⾃上⼀个时间步的预测得到的词元作为解码器的当前输⼊。

def train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):
    """训练序列到序列模型。"""
    def xavier_init_weights(m):
        if type(m) == nn.Linear:
            nn.init.xavier_uniform_(m.weight)
        if type(m) == nn.GRU:
            for param in m._flat_weights_names:
                if "weight" in param:
                    nn.init.xavier_uniform_(m._parameters[param])

    net.apply(xavier_init_weights)
    net.to(device)
    optimizer = torch.optim.Adam(net.parameters(), lr=lr)
    loss = MaskedSoftmaxCELoss()
    net.train()
    animator = d2l.Animator(xlabel='epoch', ylabel='loss',
                            xlim=[10, num_epochs])
    for epoch in range(num_epochs):
        timer = d2l.Timer()
        metric = d2l.Accumulator(2)# 训练损失总和，词元数量
        for batch in data_iter:
            X, X_valid_len, Y, Y_valid_len = [x.to(device) for x in batch]
            bos = torch.tensor([tgt_vocab['<bos>']] * Y.shape[0],
                               device=device).reshape(-1, 1)
            dec_input = torch.cat([bos, Y[:, :-1]], 1) # 强制教学
            Y_hat, _ = net(X, dec_input, X_valid_len)
            l = loss(Y_hat, Y, Y_valid_len)
            l.sum().backward()  # 损失函数的标量进⾏“反向传播”
            d2l.grad_clipping(net, 1)
            num_tokens = Y_valid_len.sum()
            optimizer.step()
            with torch.no_grad():
                metric.add(l.sum(), num_tokens)
        if (epoch + 1) % 10 == 0:
            animator.add(epoch + 1, (metric[0] / metric[1],))
    print(f'loss {metric[0] / metric[1]:.3f}, {metric[1] / timer.stop():.1f} '
          f'tokens/sec on {str(device)}')

现在，在机器翻译数据集上，我们可以创建和训练一个循环神经网络"编码器－解码器"模型用于序列到序列的学习。

embed_size, num_hiddens, num_layers, dropout = 32, 32, 2, 0.1
batch_size, num_steps = 64, 10
lr, num_epochs, device = 0.005, 300, d2l.try_gpu()

train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)
encoder = Seq2SeqEncoder(len(src_vocab), embed_size, num_hiddens, num_layers,
dropout)
decoder = Seq2SeqDecoder(len(tgt_vocab), embed_size, num_hiddens, num_layers,
dropout)
net = d2l.EncoderDecoder(encoder, decoder)
train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)

loss 0.020, 11258.5 tokens/sec on cuda:0

回到顶部

预测

为了采用一个接着⼀个词元的方式预测输出序列，每个解码器当前时间步的输⼊都将来自于前⼀时间步的预测词元。与训练类似，序列开始词元（"<bos>"）在初始时间步被输⼊到解码器中。预测过程入下图所示，当输出序列的预测遇到序列结束词元（"<eos>"）时，预测就结束了。

def predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps,
                    device, save_attention_weights=False):
    """序列到序列模型的预测"""
    # 在预测时将net设置为评估模式
    net.eval()
    src_tokens = src_vocab[src_sentence.lower().split(' ')] + [
        src_vocab['<eos>']]
    enc_valid_len = torch.tensor([len(src_tokens)], device=device)
    src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab['<pad>'])
    # 添加批量轴
    enc_X = torch.unsqueeze(
        torch.tensor(src_tokens, dtype=torch.long, device=device), dim=0)
    enc_outputs = net.encoder(enc_X, enc_valid_len)
    dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)
    # 添加批量轴
    dec_X = torch.unsqueeze(
        torch.tensor([tgt_vocab['<bos>']], dtype=torch.long, device=device),
        dim=0)
    output_seq, attention_weight_seq = [], []
    for _ in range(num_steps):
        Y, dec_state = net.decoder(dec_X, dec_state)
        # 我们使⽤具有预测最⾼可能性的词元，作为解码器在下⼀时间步的输⼊
        dec_X = Y.argmax(dim=2)
        pred = dec_X.squeeze(dim=0).type(torch.int32).item()
        # 保存注意⼒权重（稍后讨论）
        if save_attention_weights:
            attention_weight_seq.append(net.decoder.attention_weights)
        # ⼀旦序列结束词元被预测，输出序列的⽣成就完成了
        if pred == tgt_vocab['<eos>']:
            break
        output_seq.append(pred)
    return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq

预测序列的评估(BLEU)

def bleu(pred_seq, label_seq, k):  
    """计算 BLEU"""
    pred_tokens, label_tokens = pred_seq.split(' '), label_seq.split(' ')
    len_pred, len_label = len(pred_tokens), len(label_tokens)
    score = math.exp(min(0, 1 - len_label / len_pred))
    for n in range(1, k + 1):
        num_matches, label_subs = 0, collections.defaultdict(int)
        for i in range(len_label - n + 1):
            label_subs[''.join(label_tokens[i:i + n])] += 1
        for i in range(len_pred - n + 1):
            if label_subs[''.join(pred_tokens[i:i + n])] > 0:
                num_matches += 1
                label_subs[''.join(pred_tokens[i:i + n])] -= 1
        score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))
    return score

最后，利⽤训练好的循环神经⽹络“编码器－解码器”模型，将几个英语句⼦翻译成法语，并计算BLEU的最终结果。

engs = ['go .', "i lost .", 'he\'s calm .', 'i\'m home .']
fras = ['va !', 'j\'ai perdu .', 'il est calme .', 'je suis chez moi .']
for eng, fra in zip(engs, fras):
    translation, attention_weight_seq = predict_seq2seq(
        net, eng, src_vocab, tgt_vocab, num_steps, device)
    print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')

go . => va !, bleu 1.000
i lost . => j'ai perdu ., bleu 1.000
he's calm . => il est <unk> ., bleu 0.658
i'm home . => je suis chez vous ., bleu 0.752

posted @ 2023-10-25 21:13 lipu123 阅读(178) 评论(0) 编辑收藏举报

刷新页面返回顶部

（评论功能已被禁用）

相关博文：

· 循环神经网络-RNN

· 使用注意力机制的seq2seq

· 《动手学深度学习 Pytorch版》 9.7 序列到序列学习（seq2seq）

· 机器学习——序列到序列学习（seq2seq）

· 62序列到序列seq2seq

阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）

历史上的今天：
2020-10-25 反方向dfs
2020-10-25 格子
2020-10-25 除数函数求和 1(分块+欧拉筛）

公告

昵称： lipu123
园龄： 5年2个月
粉丝： 9
关注： 3

+加关注

2025年3月

日

一

二

三

四

五

六

lipu123

序列到序列学习（seq2seq）

阅读目录

seq2seq

编码器-解码器细节

训练

预测

预测序列的评估

代码

编码器

解码器

损失函数

训练

预测

预测序列的评估(BLEU)

公告

搜索

常用链接

积分与排名

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论