def get_params(vocab_size, num_hiddens, device):
    num_inputs = num_outputs = vocab_size

    def normal(shape):
        return torch.randn(size=shape, device=device)*0.01

    def three():
        return (normal((num_inputs, num_hiddens)),
                normal((num_hiddens, num_hiddens)),
                torch.zeros(num_hiddens, device=device))

    W_xz, W_hz, b_z = three()  # 更新门参数
    W_xr, W_hr, b_r = three()  # 重置门参数
    W_xh, W_hh, b_h = three()  # 候选隐状态参数
    # 输出层参数
    W_hq = normal((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)
    # 附加梯度
    params = [W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params

def init_gru_state(batch_size, num_hiddens, device):
    return (torch.zeros((batch_size, num_hiddens), device=device), )

def gru(inputs, state, params):
    W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q = params
    H, = state
    outputs = []
    for X in inputs:
        Z = torch.sigmoid((X @ W_xz) + (H @ W_hz) + b_z)
        R = torch.sigmoid((X @ W_xr) + (H @ W_hr) + b_r)
        H_tilda = torch.tanh((X @ W_xh) + ((R * H) @ W_hh) + b_h)
        H = Z * H + (1 - Z) * H_tilda
        Y = H @ W_hq + b_q
        outputs.append(Y)
    return torch.cat(outputs, dim=0), (H,)

vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu()
num_epochs, lr = 500, 1
model = d2l.RNNModelScratch(len(vocab), num_hiddens, device, get_params,
                            init_gru_state, gru)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

"""
perplexity 1.1, 19911.5 tokens/sec on cuda:0
time traveller firenis i heidfile sook at i jomer and sugard are
travelleryou can show black is white by argument said filby
"""

num_inputs = vocab_size
gru_layer = nn.GRU(num_inputs, num_hiddens)
model = d2l.RNNModel(gru_layer, len(vocab))
model = model.to(device)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

from mxnet import np, npx
from mxnet.gluon import rnn
from d2l import mxnet as d2l

npx.set_np()

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)

def get_lstm_params(vocab_size, num_hiddens, device):
    num_inputs = num_outputs = vocab_size

    def normal(shape):
        return torch.randn(size=shape, device=device)*0.01

    def three():
        return (normal((num_inputs, num_hiddens)),
                normal((num_hiddens, num_hiddens)),
                torch.zeros(num_hiddens, device=device))

    W_xi, W_hi, b_i = three()  # 输入门参数
    W_xf, W_hf, b_f = three()  # 遗忘门参数
    W_xo, W_ho, b_o = three()  # 输出门参数
    W_xc, W_hc, b_c = three()  # 候选记忆元参数
    # 输出层参数
    W_hq = normal((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)
    # 附加梯度
    params = [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc,
              b_c, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params

def init_lstm_state(batch_size, num_hiddens, device):
    return (torch.zeros((batch_size, num_hiddens), device=device),
            torch.zeros((batch_size, num_hiddens), device=device))

def lstm(inputs, state, params):
    [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c,
     W_hq, b_q] = params
    (H, C) = state
    outputs = []
    for X in inputs:
        I = torch.sigmoid((X @ W_xi) + (H @ W_hi) + b_i)
        F = torch.sigmoid((X @ W_xf) + (H @ W_hf) + b_f)
        O = torch.sigmoid((X @ W_xo) + (H @ W_ho) + b_o)
        C_tilda = torch.tanh((X @ W_xc) + (H @ W_hc) + b_c)
        C = F * C + I * C_tilda
        H = O * torch.tanh(C)
        Y = (H @ W_hq) + b_q
        outputs.append(Y)
    return torch.cat(outputs, dim=0), (H, C)

vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu()
num_epochs, lr = 500, 1
model = d2l.RNNModelScratch(len(vocab), num_hiddens, device, get_lstm_params,
                            init_lstm_state, lstm)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)
"""
perplexity 1.3, 17736.0 tokens/sec on cuda:0
time traveller for so it will leong go it we melenot ir cove i s
traveller care be can so i ngrecpely as along the time dime
"""

import torch
from torch import nn
from d2l import torch as d2l

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)

vocab_size, num_hiddens, num_layers = len(vocab), 256, 2
num_inputs = vocab_size
device = d2l.try_gpu()
lstm_layer = nn.LSTM(num_inputs, num_hiddens, num_layers)
model = d2l.RNNModel(lstm_layer, len(vocab))
model = model.to(device)

num_epochs, lr = 500, 2
d2l.train_ch8(model, train_iter, vocab, lr*1.0, num_epochs, device)

"""
perplexity 1.0, 186005.7 tokens/sec on cuda:0
time traveller for so it will be convenient to speak of himwas e
travelleryou can show black is white by argument said filby
"""

import os
import torch
from d2l import torch as d2l

#@save
d2l.DATA_HUB['fra-eng'] = (d2l.DATA_URL + 'fra-eng.zip',
                           '94646ad1522d915e7b0f9296181140edcf86a4f5')

#@save
def read_data_nmt():
    """载入“英语－法语”数据集"""
    data_dir = d2l.download_extract('fra-eng')
    with open(os.path.join(data_dir, 'fra.txt'), 'r',
             encoding='utf-8') as f:
        return f.read()

raw_text = read_data_nmt()
print(raw_text[:75])

"""
Go. Va !
Hi. Salut !
Run!        Cours !
Run!        Courez !
Who?        Qui ?
Wow!        Ça alors !
"""

#@save
def preprocess_nmt(text):
    """预处理“英语－法语”数据集"""
    def no_space(char, prev_char):
        return char in set(',.!?') and prev_char != ' '

    # 使用空格替换不间断空格
    # 使用小写字母替换大写字母
    text = text.replace('\u202f', ' ').replace('\xa0', ' ').lower()
    # 在单词和标点符号之间插入空格
    out = [' ' + char if i > 0 and no_space(char, text[i - 1]) else char
           for i, char in enumerate(text)]
    return ''.join(out)

text = preprocess_nmt(raw_text)
print(text[:80])

"""
go .        va !
hi .        salut !
run !       cours !
run !       courez !
who ?       qui ?
wow !       ça alors !
"""

#@save
def tokenize_nmt(text, num_examples=None):
    """词元化“英语－法语”数据数据集"""
    source, target = [], []
    for i, line in enumerate(text.split('\n')):
        if num_examples and i > num_examples:
            break
        parts = line.split('\t')
        if len(parts) == 2:
            source.append(parts[0].split(' '))
            target.append(parts[1].split(' '))
    return source, target

source, target = tokenize_nmt(text)
source[:6], target[:6]

"""
([['go', '.'],
  ['hi', '.'],
  ['run', '!'],
  ['run', '!'],
  ['who', '?'],
  ['wow', '!']],
 [['va', '!'],
  ['salut', '!'],
  ['cours', '!'],
  ['courez', '!'],
  ['qui', '?'],
  ['ça', 'alors', '!']])
"""

# source: 包含文本数据的变量，通常是一个列表，其中每个元素是一个句子或单词。
# min_freq=2: 表示只有在数据集中出现至少两次的单词才会被加入到词汇表中。
#             这有助于去除一些罕见词，减少模型的复杂度。
# reserved_tokens=['<pad>', '<bos>', '<eos>']: 指定了一些保留的标记（tokens），
#             分别是填充标记（<pad>）、句子开始标记（<bos>）和句子结束标记（<eos>）。
#             这些标记在训练循环神经网络时非常有用，例如在自然语言处理任务中。
src_vocab = d2l.Vocab(source, min_freq=2,
                      reserved_tokens=['<pad>', '<bos>', '<eos>'])

# 获取词汇表的长度，即词汇表中不同单词的总数。
# 这个长度包括了因min_freq条件而筛选的单词，以及添加的保留标记。
len(src_vocab)

#@save
def truncate_pad(line, num_steps, padding_token):
    """截断或填充文本序列"""
    if len(line) > num_steps:
        return line[:num_steps]  # 截断
    return line + [padding_token] * (num_steps - len(line))  # 填充

truncate_pad(src_vocab[source[0]], 10, src_vocab['<pad>'])

#@save
def build_array_nmt(lines, vocab, num_steps):
    """
    将机器翻译的文本序列转换成小批量。
    lines: 包含多个句子的列表，其中每个句子是由单词组成的列表。
    vocab: 一个Vocab类的实例，用于将文本数据转换为数字索引。
    num_steps: 指定每个句子在转换后的最大长度，如果句子长度不足会进行填充，过长则会被截断。
    """
    
    # 将每个句子中的单词转换为对应的索引。
    lines = [vocab[l] for l in lines]
    
    # 在每个索引列表的末尾添加'<eos>'标记的索引。
    lines = [l + [vocab['<eos>']] for l in lines]
    
    # 对每个索引列表进行填充或截断，使它们的长度统一为num_steps。
    # 使用vocab['<pad>']的索引值作为填充值。
    array = torch.tensor([truncate_pad(
        l, num_steps, vocab['<pad>']) for l in lines])
    
    # 计算每个序列的有效长度（不包括填充部分）。
    valid_len = (array != vocab['<pad>']).type(torch.int32).sum(1)
    
    # 返回处理后的索引列表和每个列表的有效长度。
    return array, valid_len

#@save
def load_data_nmt(batch_size, num_steps, num_examples=600):
    """
    返回翻译数据集的迭代器和词表。
    batch_size: 指定每个小批量的样本数量。
    num_steps: 指定每个样本的最大长度（超过这个长度的部分将被截断，不足的部分将被填充）。
    num_examples: 从数据集中读取的样本数量，默认为600。
    """
    
    # 预处理数据集，包括读取数据和初步处理。
    text = preprocess_nmt(read_data_nmt())
    
    # 将文本数据分割成源语言数据和目标语言数据，并根据num_examples限制样本数量。
    source, target = tokenize_nmt(text, num_examples)
    
    # 为源语言和目标语言各自创建词汇表。
    # min_freq=2表示只包括至少出现两次的单词。
    # reserved_tokens包括特殊标记：<pad>填充标记，<bos>句子开始标记，<eos>句子结束标记。
    src_vocab = d2l.Vocab(source, min_freq=2,
                          reserved_tokens=['<pad>', '<bos>', '<eos>'])
    tgt_vocab = d2l.Vocab(target, min_freq=2,
                          reserved_tokens=['<pad>', '<bos>', '<eos>'])
    
    # 将源语言和目标语言的文本数据转换为小批量的数值数据（包括填充或截断处理）。
    src_array, src_valid_len = build_array_nmt(source, src_vocab, num_steps)
    tgt_array, tgt_valid_len = build_array_nmt(target, tgt_vocab, num_steps)
    
    # 将处理后的数据组合成一个元组，准备进行批量读取。
    data_arrays = (src_array, src_valid_len, tgt_array, tgt_valid_len)
    
    # 使用d2l.load_array创建数据迭代器，用于批量读取数据。
    data_iter = d2l.load_array(data_arrays, batch_size)
    
    # 返回数据迭代器和两个语言的词汇表。
    return data_iter, src_vocab, tgt_vocab

train_iter, src_vocab, tgt_vocab = load_data_nmt(batch_size=2, num_steps=8)
for X, X_valid_len, Y, Y_valid_len in train_iter:
    print('X:', X.type(torch.int32))
    print('X的有效长度:', X_valid_len)
    print('Y:', Y.type(torch.int32))
    print('Y的有效长度:', Y_valid_len)
    break
"""
X: tensor([[ 7, 43,  4,  3,  1,  1,  1,  1],
        [44, 23,  4,  3,  1,  1,  1,  1]], dtype=torch.int32)
X的有效长度: tensor([4, 4])
Y: tensor([[ 6,  7, 40,  4,  3,  1,  1,  1],
        [ 0,  5,  3,  1,  1,  1,  1,  1]], dtype=torch.int32)
Y的有效长度: tensor([5, 3])

"""

from torch import nn


#@save
class Encoder(nn.Module):
    """编码器-解码器架构的基本编码器接口"""
    def __init__(self, **kwargs):
        super(Encoder, self).__init__(**kwargs)

    def forward(self, X, *args):
        raise NotImplementedError

from torch import nn
#@save
class Decoder(nn.Module):
    """编码器-解码器架构的基本解码器接口"""
    def __init__(self, **kwargs):
        super(Decoder, self).__init__(**kwargs)

    def init_state(self, enc_outputs, *args):
        raise NotImplementedError

    def forward(self, X, state):
        raise NotImplementedError

# 引入必要的库
import nn  # 假设这是从某个深度学习框架中导入的神经网络库

#@save
class EncoderDecoder(nn.Block):
    """编码器-解码器架构的基类。
    
    这个类是编码器-解码器架构的一个通用实现，可以用于多种不同的任务，如机器翻译、
    自动摘要等。它由两部分组成：一个编码器和一个解码器。
    
    参数:
    encoder: 编码器部分，负责处理输入数据，将其转换成一个内部表示。
    decoder: 解码器部分，负责将编码器的输出转换成最终的输出序列。
    """
    def __init__(self, encoder, decoder, **kwargs):
        super(EncoderDecoder, self).__init__(**kwargs)
        # 初始化编码器和解码器
        self.encoder = encoder
        self.decoder = decoder

    def forward(self, enc_X, dec_X, *args):
        """
        前向传播方法。
        
        参数:
        enc_X: 编码器的输入数据。
        dec_X: 解码器的输入数据。
        *args: 可能会传递给编码器和解码器的额外参数。
        
        返回:
        解码器的输出，这通常是一个序列，比如翻译的文本或者生成的文本摘要。
        """
        # 通过编码器处理输入
        enc_outputs = self.encoder(enc_X, *args)
        # 使用编码器的输出来初始化解码器的状态
        dec_state = self.decoder.init_state(enc_outputs, *args)
        # 使用解码器生成最终的输出序列
        return self.decoder(dec_X, dec_state)

import collections
import math
import torch
from torch import nn
from d2l import torch as d2l

#@save
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

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

import torch
import torch.nn as nn
import d2l  # 假设d2l是已经导入的深度学习库

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)
        # GRU层：循环神经网络核心，处理输入序列和上下文向量。
        self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers,
                          dropout=dropout)
        # 全连接层：将RNN的输出转换为最终的词汇表预测。
        self.dense = nn.Linear(num_hiddens, vocab_size)

    def init_state(self, enc_outputs, *args):
        # 初始化解码器的状态，这里简单地使用编码器的最终隐藏状态。
        return enc_outputs[1]

    def forward(self, X, state):
        # 将输入序列X通过嵌入层转换为词向量。
        X = self.embedding(X).permute(1, 0, 2)  # 改变X的形状以匹配RNN的输入要求。
        # 获取上下文向量，并扩展其维度以匹配输入序列的时间步。
        context = state[-1].repeat(X.shape[0], 1, 1)
        # 将词向量和上下文向量在特征维度上连接。
        X_and_context = torch.cat((X, context), 2)
        # 通过GRU处理输入序列。
        output, state = self.rnn(X_and_context, state)
        # 将RNN的输出通过全连接层转换为词汇预测。
        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

import torch

def sequence_mask(X, valid_len, value=0):
    """
    在序列中屏蔽不相关的项。
    
    参数:
    X: 输入的张量，形状为(batch_size, sequence_length)，包含了需要被屏蔽处理的序列。
    valid_len: 一个张量，形状为(batch_size,)，包含了每个序列中有效元素的数量。
    value: 屏蔽后的填充值，默认为0。
    
    返回:
    经过屏蔽处理的输入张量X。
    """
    # 获取输入序列的最大长度。
    maxlen = X.size(1)
    # 生成一个与序列长度相同的掩码，掩码中每个位置的值表示该位置是否应该被保留。
    mask = torch.arange((maxlen), dtype=torch.float32,
                        device=X.device)[None, :] < valid_len[:, None]
    # 使用生成的掩码对输入X进行屏蔽处理，不需要的元素被设置为指定的value。
    X[~mask] = value
    return X

# 示例输入序列
X = torch.tensor([[1, 2, 3], [4, 5, 6]])
# 应用序列掩码，指定每个序列的有效长度。
sequence_mask(X, torch.tensor([1, 2]))

class MaskedSoftmaxCELoss(nn.CrossEntropyLoss):
    """带遮蔽的softmax交叉熵损失函数。"""
    def forward(self, pred, label, valid_len):
        """
        前向传播方法，计算损失。
        
        参数:
        pred: 预测值，形状为(batch_size, num_steps, vocab_size)，其中包含了对每个时间步的词汇预测。
        label: 真实标签，形状为(batch_size, num_steps)，包含了每个时间步的真实词汇索引。
        valid_len: 有效长度，形状为(batch_size,)，指示了每个序列中有效词汇的数量。
        
        返回:
        加权的损失值，其中不应计算损失的部分已被遮蔽。
        """
        # 创建一个与label形状相同的权重张量，初始全为1。
        weights = torch.ones_like(label)
        # 使用sequence_mask函数根据valid_len遮蔽weights中的不相关部分。
        weights = sequence_mask(weights, valid_len)
        # 设置损失计算模式为'none'，以获取逐个元素的损失而不是平均损失。
        self.reduction = 'none'
        # 计算未加权的损失，需要调整pred的维度以符合CrossEntropyLoss的输入要求。
        unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(
            pred.permute(0, 2, 1), label)
        # 将未加权的损失与权重相乘，然后沿着时间步的维度取平均，得到加权损失。
        weighted_loss = (unweighted_loss * weights).mean(dim=1)
        # 返回加权损失的平均值。
        return weighted_loss

import torch
import torch.nn as nn
import d2l  # 假设d2l是已经导入的深度学习库

def train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):
    """训练序列到序列模型"""
def xavier_init_weights(m):
    """使用Xavier初始化网络权重"""
    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)

# 使用Adam优化器
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
# 使用自定义的MaskedSoftmaxCELoss计算损失
loss = MaskedSoftmaxCELoss()
net.train()

# 使用d2l库的Animator绘制训练过程中的损失变化
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:
        optimizer.zero_grad()
        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)  # 更新累积的损失和词元数量

    # 每隔一定epoch更新动画
    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)

#@save
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

import math
import collections

def bleu(pred_seq, label_seq, k):  #@save
    """计算BLEU分数。
    
    参数:
    pred_seq: 预测序列，即机器翻译的输出文本。
    label_seq: 标签序列，即参考翻译的文本。
    k: 最高考虑的n-gram的阶数。
    
    返回:
    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))
    
    # 对于从1到k的每个n，计算n-gram精确度。
    for n in range(1, k + 1):
        num_matches = 0
        label_subs = collections.defaultdict(int)
        
        # 为标签序列中的所有n-gram建立字典。
        for i in range(len_label - n + 1):
            label_subs[' '.join(label_tokens[i: i + n])] += 1
        
        # 对于预测序列中的每个n-gram，如果在标签序列的字典中，则匹配数加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
        
        # 计算n-gram精确度并累乘到分数中。
        score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))
    
    # 返回最终的BLEU分数。
    return score