Encoder-Decoder应用——机器翻译

最新推荐文章于 2024-06-25 08:17:17 发布

porridgey

最新推荐文章于 2024-06-25 08:17:17 发布

阅读量821

点赞数 19

文章标签：自然语言处理机器翻译人工智能

本文链接：https://blog.csdn.net/m0_72088520/article/details/139858051

版权

前言

机器翻译是指将一段文本从一种语言自动翻译到另一种语言。因为一段文本序列在不同语言中的长度不一定相同，所以我们使用机器翻译为例来介绍编码器—解码器和注意力机制的应用。

实验环境

GPU：RTX4090

来源：读者报考院校课题组

数据集格式如下所示：

每一行是一句法语和对应的英语翻译。

一、读取和预处理

我们先定义一些特殊符号。其中“<pad>”（padding）符号用来添加在较短序列后，直到每个序列等长，而“<bos>”和“<eos>”符号分别表示序列的开始和结束。

import collections  # 导入collections模块，用于实现特定目标的容器
import os  # 导入os模块，用于提供与操作系统交互的功能
import io  # 导入io模块，用于处理流和缓冲区数据
import math  # 导入math模块，提供数学运算函数
import torch  # 导入PyTorch深度学习库
from torch import nn  # 从torch模块中导入神经网络(nn)模块
import torch.nn.functional as F  # 导入PyTorch中的神经网络操作函数集
import torchtext.vocab as Vocab  # 导入torchtext中的词汇表模块
import torch.utils.data as Data  # 导入PyTorch中的数据加载和预处理模块

import sys  # 导入sys模块，提供对Python运行时环境的访问
# sys.path.append("..")  # 将上级目录添加到系统路径，用于导入上级目录的Python模块
import d2lzh_pytorch as d2l  # 导入d2lzh_pytorch模块，这是一个自定义的深度学习库

PAD, BOS, EOS = '<pad>', '<bos>', '<eos>'  # 定义特殊符号'PAD'、'BOS'和'EOS'
os.environ["CUDA_VISIBLE_DEVICES"] = "0"  # 设置环境变量CUDA_VISIBLE_DEVICES为0，指定使用GPU编号为0
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 根据是否有可用的GPU选择设备

print(torch.__version__, device)  # 打印PyTorch版本信息和运行设备

接着定义两个辅助函数对后面读取的数据进行预处理。

# 将一个序列中所有的词记录在all_tokens中以便之后构造词典，然后在该序列后面添加PAD直到序列
# 长度变为max_seq_len，然后将序列保存在all_seqs中
def process_one_seq(seq_tokens, all_tokens, all_seqs, max_seq_len):
    all_tokens.extend(seq_tokens)#在其后添加seq_tokens
    seq_tokens += [EOS] + [PAD] * (max_seq_len - len(seq_tokens) - 1)#补pad到max_seq_len长
    all_seqs.append(seq_tokens)#补齐好的序列添加到all_seqs数组

# 使用所有的词来构造词典。并将所有序列中的词变换为词索引后构造Tensor
def build_data(all_tokens, all_seqs):
    # 创建词汇表对象，使用词频统计所有词汇，并添加特殊符号
    vocab = Vocab.Vocab(collections.Counter(all_tokens),
                        specials=[PAD, BOS, EOS])
    # 将每个序列中的词汇转换为对应的索引
    indices = [[vocab.stoi[w] for w in seq] for seq in all_seqs]
    return vocab, torch.tensor(indices)

为了演示方便，我们在这里使用一个很小的法语—英语数据集。在这个数据集里，每一行是一对法语句子和它对应的英语句子，中间使用'\t'隔开。在读取数据时，我们在句末附上“<eos>”符号，并可能通过添加“<pad>”符号使每个序列的长度均为max_seq_len。我们为法语词和英语词分别创建词典。法语词的索引和英语词的索引相互独立。

def read_data(max_seq_len):
    # in和out分别是input和output的缩写
    in_tokens, out_tokens, in_seqs, out_seqs = [], [], [], []
    with io.open('fr-en-small.txt') as f:
        #读取每一对语句存放到lines数组
        lines = f.readlines()
    for line in lines:
        #按照\t进行划分，法语分到in_seq,英语分到out_seq
        in_seq, out_seq = line.rstrip().split('\t')
        #按照空格划分单词，每一句话分割成小的token,存放到对应数组
        in_seq_tokens, out_seq_tokens = in_seq.split(' '), out_seq.split(' ')
        if max(len(in_seq_tokens), len(out_seq_tokens)) > max_seq_len - 1:
            continue  # 如果加上EOS后长于max_seq_len，则忽略掉此样本
        #处理法语一个句子至max_seq_len长
        process_one_seq(in_seq_tokens, in_tokens, in_seqs, max_seq_len)
        #处理英语一个句子至max_seq_len长
        process_one_seq(out_seq_tokens, out_tokens, out_seqs, max_seq_len)
    #in_tokens存放所有输入的词,in_seqs存放所有补齐后的序列
    in_vocab, in_data = build_data(in_tokens, in_seqs)
    out_vocab, out_data = build_data(out_tokens, out_seqs)
    return in_vocab, out_vocab, Data.TensorDataset(in_data, out_data)

将序列的最大长度设成7，然后查看读取到的第一个样本。该样本分别包含法语词索引序列和英语词索引序列。

#序列最大长度
max_seq_len = 7
#前者存放法语对应词典、后者英语对应词典、dataset放着两个数据对应的索引
in_vocab, out_vocab, dataset = read_data(max_seq_len)
#显示法语英语各自第一个序列每个token对应的索引
print(dataset[0])

打印结果如下所示：（第一行为导入时打印的Pytorch版本信息）

二、含注意力机制的编码器—解码器

我们将使用含注意力机制的编码器—解码器来将一段简短的法语翻译成英语。下面我们来介绍模型的实现。

1.编码器

在实现之前我们先来回顾一下相关知识：

下图描述了使用编码器—解码器将上述英语句子翻译成法语句子的一种方法。在训练数据集中，我们可以在每个句子后附上特殊符号“<eos>”（end of sequence）以表示序列的终止。编码器每个时间步的输入依次为英语句子中的单词、标点和特殊符号“<eos>”，图中使用了编码器在最终时间步的隐藏状态作为输入句子的表征或编码信息。解码器在各个时间步中使用输入句子的编码信息和上个时间步的输出以及隐藏状态作为输入。我们希望解码器在各个时间步能正确依次输出翻译后的法语单词、标点和特殊符号"<eos>"。需要注意的是，解码器在最初时间步的输入用到了一个表示序列开始的特殊符号"<bos>"（beginning of sequence）

在编码器中，我们将输入语言的词索引通过词嵌入层得到词的表征，然后输入到一个多层门控循环单元中。，PyTorch的nn.GRU实例在前向计算后也会分别返回输出和最终时间步的多层隐藏状态。其中的输出指的是最后一层的隐藏层在各个时间步的隐藏状态，并不涉及输出层计算。注意力机制将这些输出作为键项和值项。

class Encoder(nn.Module):
    def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, drop_prob=0, **kwargs):
        """
        编码器类，用于处理输入序列并生成隐藏状态。
        参数：
        - vocab_size: 词汇表的大小，即词汇的数量
        - embed_size: 词嵌入的维度
        - num_hiddens: GRU 隐藏层的神经元数量
        - num_layers: GRU 的层数
        - drop_prob: dropout 的概率，防止过拟合
        """
        super(Encoder, self).__init__(**kwargs)        
        # nn.Embedding 是 PyTorch 中的一个模块，将输入的整数序列转换为密集向量表示。
        # 参数：字典中词的个数（vocab_size）和每个 token 的嵌入维度（embed_size）。
        self.embedding = nn.Embedding(vocab_size, embed_size)        
        # 定义一个多层 GRU（门控循环单元）网络
        # 参数：输入的维度（embed_size），隐藏层的维度（num_hiddens），层数（num_layers），和 dropout 概率（drop_prob）。
        self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=drop_prob)

    def forward(self, inputs, state):
        """
        前向传播函数，用于将输入序列转换为隐藏状态。
        参数：
        - inputs: 输入序列，形状为 (批量大小, 时间步数)
        - state: 初始的隐藏状态
        返回：
        - GRU 的输出和新的隐藏状态
        """
        # 将输入转换为长整型，并通过嵌入层将其转换为密集向量表示
        embedding = self.embedding(inputs.long()).permute(1, 0, 2) # 将形状转换为 (时间步数, 批量大小, 嵌入维度)
        return self.rnn(embedding, state)
    def begin_state(self):
        """
        初始化隐藏状态，GRU 默认的初始隐藏状态为 None。
        """
        return None

下面我们来创建一个批量大小为4、时间步数为7的小批量序列输入。设门控循环单元的隐藏层个数为2，隐藏单元个数为16。编码器对该输入执行前向计算后返回的输出形状为(时间步数, 批量大小, 隐藏单元个数)。门控循环单元在最终时间步的多层隐藏状态的形状为(隐藏层个数, 批量大小, 隐藏单元个数)。对于门控循环单元来说，state就是一个元素，即隐藏状态；如果使用长短期记忆，state是一个元组，包含两个元素即隐藏状态和记忆细胞。

# 创建一个 Encoder 实例
encoder = Encoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)
# 创建一个形状为 (4, 7) 的输入张量，表示批量大小为 4，时间步数为 7
input_tensor = torch.zeros((4, 7))
# 调用编码器的前向传播函数，并传入初始隐藏状态
output, state = encoder(input_tensor, encoder.begin_state())
# 输出 GRU 的输出张量和隐藏状态的形状
output.shape, state.shape

打印结果如下所示：

2.注意力机制

有了编码器和解码器的一个大致概念，下面我们来介绍引入注意力机制的编解码器

我们先来说什么是注意力：

当大家看到下面图片，会首先看到什么内容？当过载信息映入眼帘时，我们的大脑会把注意力放在主要的信息上，这就是大脑的注意力机制。

我们拿编码器解码器结构图举例：

输入为英语序列“They”“are”“watching”“.”，输出为法语序列“Ils”“regardent”“.”。不难想到，解码器在生成输出序列中的每一个词时可能只需利用输入序列某一部分的信息。例如，在输出序列的时间步1，解码器可以主要依赖“They”“are”的信息来生成“Ils”，在时间步2则主要使用来自“watching”的编码信息生成“regardent”，最后在时间步3则直接映射句号“.”。这看上去就像是在解码器的每一时间步对输入序列中不同时间步的表征或编码信息分配不同的注意力一样。这也是注意力机制的由来。

仍然以循环神经网络为例，注意力机制通过对编码器所有时间步的隐藏状态做加权平均来得到背景变量。解码器在每一时间步调整这些权重，即注意力权重，从而能够在不同时间步分别关注输入序列中的不同部分并编码进相应时间步的背景变量。

说白了，传统的编解码和引入了注意力机制的编解码从公式上看有如下区别：

传统的解码器每个时间步使用同一个背景变量，引入了注意力机制的解码器每个时间步的背景变量可变。

上图描绘了注意力机制如何为解码器在时间步2计算背景变量，首先，函数𝑎根据解码器在时间步1的隐藏状态和编码器在各个时间步的隐藏状态计算softmax运算的输入。softmax运算输出概率分布并对编码器各个时间步的隐藏状态做加权平均，从而得到背景变量。

具体细节读者可以自行查阅更详细的资料。

有了上述基础知识后我们将实现定义的函数𝑎：将输入连结后通过含单隐藏层的多层感知机变换。其中隐藏层的输入是解码器的隐藏状态与编码器在所有时间步上隐藏状态的一一连结，且使用tanh函数作为激活函数。输出层的输出个数为1。两个Linear实例均不使用偏差。其中函数𝑎𝑎定义里向量𝑣𝑣的长度是一个超参数，即attention_size。

def attention_model(input_size, attention_size):
    """
    构建一个注意力模型。
    参数：
    - input_size: 输入的维度大小
    - attention_size: 注意力层的维度大小
    返回：
    - model: 一个包含两层线性变换和一个Tanh激活函数的Sequential模型
    """
    model = nn.Sequential(
        nn.Linear(input_size, attention_size, bias=False),  # 第一层线性变换
        nn.Tanh(),  # Tanh激活函数
        nn.Linear(attention_size, 1, bias=False)  # 第二层线性变换
    )
    return model

注意力机制的输入包括查询项、键项和值项。设编码器和解码器的隐藏单元个数相同。这里的查询项为解码器在上一时间步的隐藏状态，形状为(批量大小, 隐藏单元个数)；键项和值项均为编码器在所有时间步的隐藏状态，形状为(时间步数, 批量大小, 隐藏单元个数)。注意力机制返回当前时间步的背景变量，形状为(批量大小, 隐藏单元个数)。

def attention_forward(model, enc_states, dec_state):
    """
    前向传播计算注意力分数并生成背景变量。
    参数：
    - model: 注意力模型
    - enc_states: 编码器的隐藏状态，形状为 (时间步数, 批量大小, 隐藏单元个数)
    - dec_state: 解码器的隐藏状态，形状为 (批量大小, 隐藏单元个数)
    返回：
    - 背景变量，形状为 (批量大小, 隐藏单元个数)
    """
    # 将解码器隐藏状态增加一个维度，以便广播到编码器隐藏状态的形状
    dec_states = dec_state.unsqueeze(dim=0).expand_as(enc_states)
    # 将编码器和解码器隐藏状态在最后一个维度上进行连结
    enc_and_dec_states = torch.cat((enc_states, dec_states), dim=2)
    # 通过注意力模型计算注意力分数
    e = model(enc_and_dec_states)  # 形状为 (时间步数, 批量大小, 1)
    # 在时间步维度上进行softmax运算，得到注意力权重
    alpha = F.softmax(e, dim=0)
    # 使用注意力权重对编码器隐藏状态进行加权求和，得到背景变量
    return (alpha * enc_states).sum(dim=0)

在下面的例子中，编码器的时间步数为10，批量大小为4，编码器和解码器的隐藏单元个数均为8。注意力机制返回一个小批量的背景向量，每个背景向量的长度等于编码器的隐藏单元个数。因此输出的形状为(4, 8)。

# 定义输入的形状和参数
seq_len, batch_size, num_hiddens = 10, 4, 8
# 创建注意力模型
model = attention_model(2 * num_hiddens, 10) 
# 模拟编码器的隐藏状态，形状为 (时间步数, 批量大小, 隐藏单元个数)
enc_states = torch.zeros((seq_len, batch_size, num_hiddens))
# 模拟解码器的隐藏状态，形状为 (批量大小, 隐藏单元个数)
dec_state = torch.zeros((batch_size, num_hiddens))
# 调用注意力前向传播函数，并输出结果的形状
output_shape = attention_forward(model, enc_states, dec_state).shape
output_shape  # 应该是 (批量大小, 隐藏单元个数)

打印结果如下所示：

3.含注意力机制的解码器

我们直接将编码器在最终时间步的隐藏状态作为解码器的初始隐藏状态。这要求编码器和解码器的循环神经网络使用相同的隐藏层个数和隐藏单元个数。

在解码器的前向计算中，我们先通过刚刚介绍的注意力机制计算得到当前时间步的背景向量。由于解码器的输入来自输出语言的词索引，我们将输入通过词嵌入层得到表征，然后和背景向量在特征维连结。我们将连结后的结果与上一时间步的隐藏状态通过门控循环单元计算出当前时间步的输出与隐藏状态。最后，我们将输出通过全连接层变换为有关各个输出词的预测，形状为(批量大小, 输出词典大小)。

class Decoder(nn.Module):
    def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
                 attention_size, drop_prob=0):
        super(Decoder, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.attention = attention_model(2*num_hiddens, attention_size)
        # GRU的输入包含attention输出的c和实际输入, 所以尺寸是 num_hiddens+embed_size
        self.rnn = nn.GRU(num_hiddens + embed_size, num_hiddens, 
                          num_layers, dropout=drop_prob)
        self.out = nn.Linear(num_hiddens, vocab_size)

    def forward(self, cur_input, state, enc_states):
        """
        cur_input shape: (batch, )
        state shape: (num_layers, batch, num_hiddens)
        """
        # 使用注意力机制计算背景向量
        c = attention_forward(self.attention, enc_states, state[-1])
        # 将嵌入后的输入和背景向量在特征维连结, (批量大小, num_hiddens+embed_size)
        input_and_c = torch.cat((self.embedding(cur_input), c), dim=1) 
        # 为输入和背景向量的连结增加时间步维，时间步个数为1
        output, state = self.rnn(input_and_c.unsqueeze(0), state)
        # 移除时间步维，输出形状为(批量大小, 输出词典大小)
        output = self.out(output).squeeze(dim=0)
        return output, state

    def begin_state(self, enc_state):
        # 直接将编码器最终时间步的隐藏状态作为解码器的初始隐藏状态
        return enc_state

三、训练模型

我们先实现batch_loss函数计算一个小批量的损失。解码器在最初时间步的输入是特殊字符BOS。之后，解码器在某时间步的输入为样本输出序列在上一时间步的词，即强制教学。我们在这里也使用掩码变量避免填充项对损失函数计算的影响。

def batch_loss(encoder, decoder, X, Y, loss):
    """
    计算一批数据的损失。
    参数：
    - encoder: 编码器模型
    - decoder: 解码器模型
    - X: 输入序列，形状为 (batch_size, seq_len)
    - Y: 目标序列，形状为 (batch_size, seq_len)
    - loss: 损失函数
    返回：
    - l: 平均损失
    """
    batch_size = X.shape[0]  # 获取批量大小
    enc_state = encoder.begin_state()  # 初始化编码器的隐藏状态
    enc_outputs, enc_state = encoder(X, enc_state)  # 通过编码器处理输入序列
    # 初始化解码器的隐藏状态
    dec_state = decoder.begin_state(enc_state)
    # 解码器在最初时间步的输入是BOS (序列开始符)
    dec_input = torch.tensor([out_vocab.stoi[BOS]] * batch_size)
    # 我们将使用掩码变量mask来忽略掉标签为填充项PAD的损失, 初始全1
    mask, num_not_pad_tokens = torch.ones(batch_size,), 0
    l = torch.tensor([0.0])  # 初始化损失
    for y in Y.permute(1, 0):  # 遍历目标序列的每一个时间步 (Y shape: (batch, seq_len))
        dec_output, dec_state = decoder(dec_input, dec_state, enc_outputs)  # 通过解码器生成输出
        l = l + (mask * loss(dec_output, y)).sum()  # 计算当前时间步的损失并加到总损失上
        dec_input = y  # 使用强制教学，将当前时间步的目标作为下一时间步的输入
        num_not_pad_tokens += mask.sum().item()  # 更新非填充项的计数
        # EOS后面全是PAD. 下面一行保证一旦遇到EOS接下来的循环中mask就一直是0
        mask = mask * (y != out_vocab.stoi[EOS]).float()  # 遇到EOS后mask置0
    return l / num_not_pad_tokens  # 返回平均损失

在训练函数中，我们需要同时迭代编码器和解码器的模型参数。

def train(encoder, decoder, dataset, lr, batch_size, num_epochs):
    """
    训练编码器和解码器模型。
    参数：
    - encoder: 编码器模型
    - decoder: 解码器模型
    - dataset: 数据集，包含输入和目标序列
    - lr: 学习率
    - batch_size: 每个批次的大小
    - num_epochs: 训练的轮数
    """
    # 使用Adam优化器分别为编码器和解码器创建优化器
    enc_optimizer = torch.optim.Adam(encoder.parameters(), lr=lr)
    dec_optimizer = torch.optim.Adam(decoder.parameters(), lr=lr)
    # 使用交叉熵损失，设置reduction='none'以便之后对损失进行掩码处理
    loss = nn.CrossEntropyLoss(reduction='none')
    # 创建数据加载器，打乱数据集并按批次加载数据
    data_iter = torch.utils.data.DataLoader(dataset, batch_size, shuffle=True)
    # 开始训练过程
    for epoch in range(num_epochs):
        l_sum = 0.0  # 初始化损失累加器
        for X, Y in data_iter:
            # 清空编码器和解码器的梯度
            enc_optimizer.zero_grad()
            dec_optimizer.zero_grad()
            # 计算当前批次的损失
            l = batch_loss(encoder, decoder, X, Y, loss)
            # 反向传播计算梯度
            l.backward()
            # 更新编码器和解码器的参数
            enc_optimizer.step()
            dec_optimizer.step()   
            # 累加当前批次的损失
            l_sum += l.item()
        # 每10个epoch输出一次损失信息
        if (epoch + 1) % 10 == 0:
            print("epoch %d, loss %.3f" % (epoch + 1, l_sum / len(data_iter)))

接下来，创建模型实例并设置超参数。然后，我们就可以训练模型了。

# 设置模型参数
embed_size, num_hiddens, num_layers = 64, 64, 2  # 嵌入维度、隐藏单元数、层数
attention_size, drop_prob, lr, batch_size, num_epochs = 10, 0.5, 0.01, 2, 50  # 注意力大小、丢弃率、学习率、批次大小、训练轮数
# 初始化编码器
encoder = Encoder(len(in_vocab), embed_size, num_hiddens, num_layers, drop_prob)
# 参数说明：
# len(in_vocab): 输入词汇表的大小
# embed_size: 嵌入维度
# num_hiddens: 隐藏单元数
# num_layers: RNN层数
# drop_prob: 丢弃率
# 初始化解码器
decoder = Decoder(len(out_vocab), embed_size, num_hiddens, num_layers, attention_size, drop_prob)
# 参数说明：
# len(out_vocab): 输出词汇表的大小
# embed_size: 嵌入维度
# num_hiddens: 隐藏单元数
# num_layers: RNN层数
# attention_size: 注意力机制的大小
# drop_prob: 丢弃率
# 训练模型
train(encoder, decoder, dataset, lr, batch_size, num_epochs)
# 参数说明：
# encoder: 编码器模型
# decoder: 解码器模型
# dataset: 数据集，包含输入和目标序列
# lr: 学习率
# batch_size: 每个批次的大小
# num_epochs: 训练的轮数

打印结果如下所示：

四、预测不定长的序列

def translate(encoder, decoder, input_seq, max_seq_len):
    """
    使用编码器和解码器将输入序列翻译为输出序列。
    参数：
    - encoder: 编码器模型
    - decoder: 解码器模型
    - input_seq: 输入序列（字符串形式）
    - max_seq_len: 最大序列长度
    返回：
    - output_tokens: 翻译后的输出序列（字符串列表形式）
    """
    # 将输入序列按空格分割成词汇列表
    in_tokens = input_seq.split(' ')
    # 添加结束标志，并用填充标志填充到最大序列长度
    in_tokens += [EOS] + [PAD] * (max_seq_len - len(in_tokens) - 1)
    # 将输入词汇列表转换为对应的词汇表索引
    enc_input = torch.tensor([[in_vocab.stoi[tk] for tk in in_tokens]])  # batch=1
    # 初始化编码器的隐藏状态
    enc_state = encoder.begin_state()
    # 获取编码器的输出和最终的隐藏状态
    enc_output, enc_state = encoder(enc_input, enc_state)
    # 解码器的初始输入是BOS标志
    dec_input = torch.tensor([out_vocab.stoi[BOS]])
    # 初始化解码器的隐藏状态
    dec_state = decoder.begin_state(enc_state)
    # 初始化输出令牌列表
    output_tokens = []
    for _ in range(max_seq_len):
        # 获取解码器的输出和隐藏状态
        dec_output, dec_state = decoder(dec_input, dec_state, enc_output)
        # 选择具有最高概率的预测值
        pred = dec_output.argmax(dim=1)
        # 将预测的索引转换为对应的词汇
        pred_token = out_vocab.itos[int(pred.item())]
        # 如果预测是EOS，表示翻译结束
        if pred_token == EOS:
            break
        else:
            # 否则将预测的词汇添加到输出令牌列表中
            output_tokens.append(pred_token)
            # 将当前预测作为下一时间步的解码器输入
            dec_input = pred
    return output_tokens

简单测试一下模型。输入法语句子“ils regardent.”，翻译后的英语句子应该是“they are watching.”。

input_seq = 'ils regardent .'
translate(encoder, decoder, input_seq, max_seq_len)

打印结构如下所示：

五、评价翻译结果

使用BLEU评价指标，相关内容可以参考一下博客：

机器翻译评价指标BLEU介绍_bleu指标-CSDN博客

下列代码实现bleu

def bleu(pred_tokens, label_tokens, k):
    """
    计算预测序列与标签序列之间的BLEU得分。
    参数：
    - pred_tokens: 预测序列（词汇列表）
    - label_tokens: 标签序列（词汇列表）
    - k: 最大n-gram长度
    返回：
    - score: BLEU得分
    """
    # 获取预测序列和标签序列的长度
    len_pred, len_label = len(pred_tokens), len(label_tokens)
    # 计算BP（Brevity Penalty，长度惩罚）
    # 如果预测序列比标签序列长，BP为1，否则BP为exp(1 - len_label / len_pred)
    score = math.exp(min(0, 1 - len_label / len_pred))
    # 遍历每一个n-gram长度，从1到k
    for n in range(1, k + 1):
        num_matches, label_subs = 0, collections.defaultdict(int)
        # 构建标签序列中的n-gram子序列字典
        for i in range(len_label - n + 1):
            label_subs[''.join(label_tokens[i: i + n])] += 1
        # 计算预测序列中匹配的n-gram子序列数量
        for i in range(len_pred - n + 1):
            n_gram = ''.join(pred_tokens[i: i + n])
            if label_subs[n_gram] > 0:
                num_matches += 1
                label_subs[n_gram] -= 1
        # 更新BLEU得分
        # num_matches / (len_pred - n + 1) 是精确率，math.pow(0.5, n) 是权重
        score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))
    return score

接下来，定义一个辅助打印函数。

def score(input_seq, label_seq, k):
    """
    计算给定输入序列的翻译结果的BLEU评分，并打印预测序列。
    参数：
    - input_seq: 输入序列（字符串形式）
    - label_seq: 标签序列（字符串形式）
    - k: 最大n-gram长度
    """
    # 使用编码器和解码器翻译输入序列，得到预测序列（词汇列表）
    pred_tokens = translate(encoder, decoder, input_seq, max_seq_len)
    # 将标签序列按空格分割成词汇列表
    label_tokens = label_seq.split(' ')
    # 计算预测序列和标签序列之间的BLEU评分
    bleu_score = bleu(pred_tokens, label_tokens, k)
    # 打印BLEU评分和预测序列
    print('bleu %.3f, predict: %s' % (bleu_score, ' '.join(pred_tokens)))

预测正确则分数为1

score('ils regardent .', 'they are watching .', k=2)

总结

作者能力有限，如果有不理解的地方还请见谅。

porridgey

关注

19
点赞
踩
29

收藏

觉得还不错? 一键收藏
1
评论
Encoder-Decoder应用——机器翻译

机器翻译是指将一段文本从一种语言自动翻译到另一种语言。因为一段文本序列在不同语言中的长度不一定相同，所以我们使用机器翻译为例来介绍编码器—解码器和注意力机制的应用。实验环境来源：读者报考院校课题组每一行是一句法语和对应的英语翻译。一、读取和预处理我们先定义一些特殊符号。其中“<pad>”（padding）符号用来添加在较短序列后，直到每个序列等长，而“<bos>”和“<eos>”符号分别表示序列的开始和结束。import collections # 导入collections模块，用于实现特定目标的容器。
复制链接

扫一扫