实验13：机器翻译

最新推荐文章于 2024-10-16 10:08:57 发布

三千838

最新推荐文章于 2024-10-16 10:08:57 发布

阅读量1.4k

点赞数 24

文章标签：深度学习

本文链接：https://blog.csdn.net/weixin_66648504/article/details/140064634

版权

1. 编码器-解码器架构

编码器-解码器架构是一种常用于序列到序列（sequence-to-sequence）任务的神经网络架构。在这个架构中，一个编码器将输入序列编码成一个固定长度的向量，而一个解码器则根据这个向量生成输出序列。

编码器

编码器将输入序列编码成一个固定长度的向量。它通常由一个嵌入层和一个循环神经网络（如GRU或LSTM）组成。在本文中，我们将使用一个GRU作为编码器。

解码器

解码器根据编码器的输出生成输出序列。它也通常由一个嵌入层和一个循环神经网络组成。在本文中，我们将使用一个带有注意力机制的GRU作为解码器。

2. 注意力机制

注意力机制是一种用于提高序列到序列模型性能的技术。它允许解码器在生成输出序列时，根据输入序列的不同部分赋予不同的权重。

注意力机制的实现

注意力机制是编码器-解码器模型中一个非常重要的组成部分，它允许解码器在生成输出序列时，根据输入序列的不同部分赋予不同的权重。在本文中，我们将实现一个基于GRU的编码器和一个带有注意力机制的GRU解码器。下面是注意力机制模块的代码实现：

def attention_model(input_size, attention_size):
    model = nn.Sequential(
        nn.Linear(input_size, attention_size, bias=False),
        nn.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)  # 返回背景变量

在这段代码中，attention_model函数定义了一个多层感知机，用于计算注意力权重。attention_forward函数实现了一个注意力机制的前向传播过程，它将编码器的隐藏状态和解码器的隐藏状态作为输入，并输出一个加权平均值，即背景变量。

注意力机制的输入包括查询项（解码器的隐藏状态）、键项（编码器的隐藏状态）和值项（编码器的隐藏状态）。在attention_forward函数中，我们首先将解码器的隐藏状态广播到和编码器隐藏状态形状相同，然后将编码器和解码器的隐藏状态在特征维连结。接下来，我们将连结后的结果输入到attention_model中，得到注意力权重e。最后，我们使用F.softmax函数对注意力权重进行归一化，得到注意力分布alpha。最后，我们使用注意力分布alpha对编码器的隐藏状态进行加权平均，得到背景变量。

通过这种方式，解码器可以根据输入序列的不同部分赋予不同的权重，从而生成更准确的输出序列

3. 训练模型

为了训练模型，我们将使用一个小型法语-英语数据集。数据集的每一行包含一对法语句子和对应的英语句子，中间使用'\\t'分隔。我们将使用一个批处理大小为4、序列最大长度为7的小批量序列输入。

在机器翻译中，预测不定长序列的翻译结果是一个关键步骤。这个模块通常涉及到解码器，它根据编码器的输出生成输出序列。下面是预测不定长序列的翻译结果模块的代码实现：

def translate(encoder, decoder, input_seq, max_seq_len):
    # 将输入序列按空格分割成单词列表
    in_tokens = input_seq.split(' ')
    
    # 在单词列表末尾添加EOS（结束符）和PAD（填充符），以确保序列长度达到max_seq_len
    in_tokens += ['<eos>'] + ['<pad>'] * (max_seq_len - len(in_tokens) - 1)
    
    # 将单词列表转换为索引列表，并包装成batch_size=1的二维张量，这是编码器的输入
    enc_input = torch.tensor([[in_vocab.stoi[tk] for tk in in_tokens]])
    
    # 获取编码器的初始状态
    enc_state = encoder.begin_state()
    
    # 通过编码器前向传播，得到编码器的输出和最终状态
    enc_output, enc_state = encoder(enc_input, enc_state)
    
    # 创建解码器的输入，即BOS（开始符）的索引，包装成batch_size=1的二维张量
    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())]
        
        if pred_token == '<eos>':  # 当任一时间步搜索出EOS时，输出序列即完成
            break
        else:
            output_tokens.append(pred_token)
            
            # 如果不是EOS，则将单词添加到输出列表中
            dec_input = pred
            
    return output_tokens  # 返回输出单词列表，即翻译结果

在这个模块中，我们首先将输入序列按空格分割成单词列表，并添加EOS和PAD符号以确保序列长度达到max_seq_len。然后，我们将单词列表转换为索引列表，并包装成batch_size=1的二维张量，作为编码器的输入。接下来，我们通过编码器前向传播，得到编码器的输出和最终状态。然后，我们创建解码器的输入，即BOS（开始符）的索引，并使用编码器的最终状态来初始化解码器的状态。最后，我们通过解码器前向传播，得到解码器的输出和最终状态，并从解码器输出中获取最高概率的单词索引。如果当前单词是EOS，则输出序列完成；否则，将单词添加到输出列表中，并将预测的单词作为下一次迭代解码器的输入。

通过这种方式，我们可以预测不定长序列的翻译结果。这个模块是机器翻译中的一个关键步骤，它直接决定了翻译结果的质量和准确性。

4. 预测不定长序列的翻译结果

在训练完成后，我们可以使用模型来预测不定长序列的翻译结果。我们将使用一个贪婪搜索策略来生成输出序列。

def translate(encoder, decoder, input_seq, max_seq_len):
    # 将输入序列按空格分割成单词列表
    in_tokens = input_seq.split(' ')
    
    # 在单词列表末尾添加EOS（结束符）和PAD（填充符），以确保序列长度达到max_seq_len
    in_tokens += ['<eos>'] + ['<pad>'] * (max_seq_len - len(in_tokens) - 1)
    
    # 将单词列表转换为索引列表，并包装成batch_size=1的二维张量，这是编码器的输入
    enc_input = torch.tensor([[in_vocab.stoi[tk] for tk in in_tokens]])
    
    # 获取编码器的初始状态
    enc_state = encoder.begin_state()
    
    # 通过编码器前向传播，得到编码器的输出和最终状态
    enc_output, enc_state = encoder(enc_input, enc_state)
    
    # 创建解码器的输入，即BOS（开始符）的索引，包装成batch_size=1的二维张量
    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())]
        
        if pred_token == '<eos>':  # 当任一时间步搜索出EOS时，输出序列即完成
            break
        else:
            output_tokens.append(pred_token)
            
            # 如果不是EOS，则将单词添加到输出列表中
            dec_input = pred
            
    return output_tokens  # 返回输出单词列表，即翻译结果

通过这种方式，我们可以预测不定长序列的翻译结果。这个模块是机器翻译中的一个关键步骤，它直接决定了翻译结果的质量和准确性。