NLP实战练手项目之机器翻译(使用Tatoeba Project英法数据集)

本文链接：https://blog.csdn.net/Lin_Yiyun/article/details/140065497

基本原理

机器翻译的基本模型是“序列到序列”模型（Seq2Seq），它是一种通用自然语言模型，可以用于多种任务，例如机器翻译、文本生成和对话生成等。
在机器翻译中，Seq2Seq模型主要包括两个部分：编码器和解码器。编码器将源语言文本逐词转换成一种内部表示（或称为“向量”），解码器则将该向量逐词解码成目标语言文本。

具体而言，编码器会采用采用循环神经网络（RNN）或长短时记忆网络（LSTM）等深度学习模型，将源语言文本的每个词汇转换为向量表示。这些向量可以被视为该词汇在语言中的“特征”，从而将文本转换为一组向量的序列。本文将使用GRU(门控循环单元,RNN的一种，可以解决RNN中不能长期记忆和反向传播中的梯度等问题，与LSTM的作用类似，不过比LSTM简单，容易进行训练)实现编码器。

解码器也采用类似的方法，将目标语言文本的每个词汇转换为向量表示。这些向量可以构成目标语言文本的“特征”，从而将文本转换为一组向量的序列。解码器采用类似的方法，根据前面已经翻译过的词汇和其对应的向量表示，逐词解码出目标语言文本。本文将使用使用注意力机制构建解码器。

让我们开始吧!

数据准备

Tab-delimited Bilingual Sentence Pairs from the Tatoeba Project (Good for Anki and Similar Flashcard Applications)These files can easily be imported into Anki or similar flashcard program.http://www.manythings.org/anki/在上面的链接中下载法语-英语对照数据集

不过该数据集需要我们稍作处理

需要把CC-BY即后面的内容都删掉

# 删除Tatoeba Project的双语句子对中多余的元素
def remove_cc_by_content(input_file_path, output_file_path):
    with open(input_file_path, 'r', encoding='utf-8') as file_read:
        lines = file_read.readlines()  # 读取所有行包括换行符
    
    # 处理每一行，移除"CC-BY"及其后面的内容，并保持每行末尾的换行符
    cleaned_lines = []
    for line in lines:
        if "CC-BY" in line:
            index = line.find("CC-BY")  # 找到"CC-BY"的位置
            # 保留"CC-BY"之前的内容并确保每行以换行符结束
            cleaned_line = line[:index].rstrip('\n') + '\n'
            cleaned_lines.append(cleaned_line)
        else:
            # 如果行中没有"CC-BY"，直接保留原行
            cleaned_lines.append(line)

    # 写入处理后的内容到新文件，确保每行末尾有换行符
    with open(output_file_path, 'w', encoding='utf-8') as file_write:
        for line in cleaned_lines:
            file_write.write(line)

# 指定输入和输出文件的路径
input_file_path = '0617/fra.txt'  
output_file_path = '0617/fra.txt'

remove_cc_by_content(input_file_path, output_file_path)

print("处理完成，结果已保存至", output_file_path)

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

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

PAD, BOS, EOS = '<pad>', '<bos>', '<eos>'

# 将一个序列中所有的词记录在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 += [EOS] + [PAD] * (max_seq_len - len(seq_tokens) - 1)
    all_seqs.append(seq_tokens)

# 使用所有的词来构造词典。并将所有序列中的词变换为词索引后构造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)
def read_data(max_seq_len):
    # in和out分别是input和output的缩写
    in_tokens, out_tokens, in_seqs, out_seqs = [], [], [], []
    with io.open('0617/fra.txt') as f:
        lines = f.readlines()
    for line in lines:
        in_seq, out_seq = line.rstrip().split('\t')
        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，则忽略掉此样本
        process_one_seq(in_seq_tokens, in_tokens, in_seqs, max_seq_len)
        process_one_seq(out_seq_tokens, out_tokens, out_seqs, max_seq_len)
    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)
max_seq_len = 7
in_vocab, out_vocab, dataset = read_data(max_seq_len)
dataset[20]

模型构建

先来做编码器

# 使用GRU完成编码器
class Encoder(nn.Module):
    def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
                 drop_prob=0, **kwargs):
        super(Encoder, self).__init__(**kwargs)
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=drop_prob)

    def forward(self, inputs, state):
        # 输入形状是(批量大小, 时间步数)。将输出互换样本维和时间步维
        embedding = self.embedding(inputs.long()).permute(1, 0, 2) # (seq_len, batch, input_size)
        return self.rnn(embedding, state)

    def begin_state(self):
        return None
encoder = Encoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)
output, state = encoder(torch.zeros((4, 7)), encoder.begin_state())
output.shape, state.shape # GRU的state是h, 而LSTM的是一个元组(h, c)

再基于注意力机制做解码器

def attention_model(input_size, attention_size):
    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):
    """
    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)
    alpha = F.softmax(e, dim=0)  # 在时间步维度做softmax运算
    return (alpha * enc_states).sum(dim=0)  # 返回背景变量
seq_len, batch_size, num_hiddens = 10, 4, 8 #编码器的时间步数为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))
attention_forward(model, enc_states, dec_state).shape
torch.Size([4, 8])
# 使用注意力机制构建解码器
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):
    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.sto

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

def train(encoder, decoder, dataset, lr, batch_size, num_epochs):
    # 初始化编码器和解码器的优化器，使用Adam优化算法，学习率设置为lr
    enc_optimizer = torch.optim.Adam(encoder.parameters(), lr=lr)
    dec_optimizer = torch.optim.Adam(decoder.parameters(), lr=lr)

    loss = nn.CrossEntropyLoss(reduction='none') # 实例化交叉熵损失函数，用于评估预测结果与真实标签的差异
    
    # 使用DataLoader对数据集进行封装，以便于按批次(batch)读取数据，同时设置随机打乱数据顺序以增强模型训练
    data_iter = Data.DataLoader(dataset, batch_size, shuffle=True)
    # 主循环遍历指定的训练轮数(num_epochs)
    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()
        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
# 调高num_epochs 观察loss是否能持续下降
attention_size, drop_prob, lr, batch_size, num_epochs = 10, 0.5, 0.01, 2, 100
encoder = Encoder(len(in_vocab), embed_size, num_hiddens, num_layers,
                  drop_prob)
decoder = Decoder(len(out_vocab), embed_size, num_hiddens, num_layers,
                  attention_size, drop_prob)
train(encoder, decoder, dataset, lr, batch_size, num_epochs)

评价翻译结果

下面来实现BLEU的计算

def bleu(pred_tokens, label_tokens, k):
    # 计算预测序列和参考序列的长度
    len_pred, len_label = len(pred_tokens), len(label_tokens)
    
    # 初始化BLEU分数，并应用长度惩罚因子
    score = math.exp(min(0, 1 - len_label / len_pred))  # 长度惩罚
    
    # 遍历1-gram到k-gram
    for n in range(1, k + 1):
        # 初始化n-gram匹配数和构建参考序列的n-gram计数字典
        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):
            if label_subs[''.join(pred_tokens[i: i + n])] > 0:
                num_matches += 1
                label_subs[''.join(pred_tokens[i: i + n])] -= 1
        
        # 更新BLEU分数，乘以当前n-gram的精度
        # 使用0.5的n次方作为权重，这是BLEU公式的一部分
        score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))
    
    # 返回最终的BLEU分数
    return score

再定义一个辅助打印函数便于结果的可视化

def score(input_seq, label_seq, k):
    pred_tokens = translate(encoder, decoder, input_seq, max_seq_len)
    label_tokens = label_seq.split(' ')
    print('bleu %.3f, predict: %s' % (bleu(pred_tokens, label_tokens, k),
                                      ' '.join(pred_tokens)))