加入注意力机制的整个Uent模型代码

下面是一个使用注意力机制的Encoder-Decoder模型的代码示例：

import torch
import torch.nn as nn
import torch.nn.functional as F

class Encoder(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers=1):
        super(Encoder, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.embedding = nn.Embedding(input_size, hidden_size)
        self.gru = nn.GRU(hidden_size, hidden_size, num_layers, batch_first=True)

    def forward(self, input):
        embedded = self.embedding(input)
        output, hidden = self.gru(embedded)
        return output, hidden

class Attention(nn.Module):
    def __init__(self, hidden_size):
        super(Attention, self).__init__()
        self.hidden_size = hidden_size
        self.attn = nn.Linear(hidden_size * 2, hidden_size)
        self.v = nn.Linear(hidden_size, 1, bias=False)

    def forward(self, hidden, encoder_outputs):
        seq_len = encoder_outputs.size(1)
        hidden = hidden.unsqueeze(1).repeat(1, seq_len, 1)
        energy = F.relu(self.attn(torch.cat([hidden, encoder_outputs], 2)))
        attention = F.softmax(self.v(energy).squeeze(2), dim=1)
        context = attention.unsqueeze(1).bmm(encoder_outputs).squeeze(1)
        return context

class Decoder(nn.Module):
    def __init__(self, hidden_size, output_size, num_layers=1):
        super(Decoder, self).__init__()
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.num_layers = num_layers
        self.embedding = nn.Embedding(output_size, hidden_size)
        self.gru = nn.GRU(hidden_size, hidden_size, num_layers, batch_first=True)
        self.out = nn.Linear(hidden_size, output_size)
        self.attention = Attention(hidden_size)

    def forward(self, input, hidden, encoder_outputs):
        embedded = self.embedding(input)
        context = self.attention(hidden[-1], encoder_outputs)
        output, hidden = self.gru(torch.cat([embedded, context.unsqueeze(1)], 2), hidden)
        output = self.out(output.squeeze(1))
        output = F.log_softmax(output, dim=1)
        return output, hidden

class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder):
        super(Seq2Seq, self).__init__()
        self.encoder = encoder
        self.decoder = decoder

    def forward(self, input, target):
        encoder_outputs, encoder_hidden = self.encoder(input)
        decoder_hidden = encoder_hidden
        decoder_input = torch.tensor([[SOS_token]])
        decoder_outputs = []
        for i in range(target.size(1)):
            output, decoder_hidden = self.decoder(decoder_input, decoder_hidden, encoder_outputs)
            decoder_outputs.append(output)
            decoder_input = target[:, i].unsqueeze(1)
        output = torch.cat(decoder_outputs, 1)
        return output

该模型由一个编码器（Encoder）和一个解码器（Decoder）组成，并使用注意力机制来提高翻译质量。编码器将输入序列嵌入到连续向量空间中，并通过GRU层进行编码，得到一组编码向量。解码器在每个时间步骤中先通过注意力机制从编码器输出中提取上下文向量，然后将该向量与解码器输入嵌入向量进行拼接，最后通过GRU层进行解码，并使用线性层将其映射到输出词汇表中的单词概率分布。