​

!tar -xf d2lzh_pytorch.tar

import collections  # 导入 Python 标准库中的 collections 模块，提供额外的数据结构
import os  # 导入 Python 标准库中的 os 模块，用于与操作系统进行交互
import io  # 导入 Python 标准库中的 io 模块，提供对流式数据的核心工具
import math  # 导入 Python 标准库中的 math 模块，提供数学运算功能
import torch  # 导入 PyTorch 深度学习库
from torch import nn  # 从 PyTorch 中导入神经网络模块 nn
import torch.nn.functional as F  # 导入 PyTorch 中的函数模块 functional
import torchtext.vocab as Vocab  # 导入 PyTorch 文本处理库中的 vocab 模块
import torch.utils.data as Data  # 导入 PyTorch 中的数据处理工具模块 utils.data


import sys
# sys.path.append("..") 
import d2lzh_pytorch as d2l

# 定义常量（填充、开始和结束的特殊标记）
PAD, BOS, EOS = '<pad>', '<bos>', '<eos>'  # 定义填充、序列开始和序列结束的特殊标记，使用 HTML 转义字符表示尖括号 < >
os.environ["CUDA_VISIBLE_DEVICES"] = "0"  # 设置环境变量 CUDA_VISIBLE_DEVICES，指定使用 GPU 编号为 0
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 根据 CUDA 是否可用选择设备，优先选择 GPU，否则选择 CPU

print(torch.__version__, device)

# 将一个序列中所有的词记录在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('fr-en-small.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[0]

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 对象，指定词汇表大小为 10，嵌入大小为 8，隐藏单元数为 16，层数为 2
encoder = Encoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)

# 对 Encoder 进行前向计算，输入是一个形状为 (4, 7) 的张量，初始状态通过 begin_state() 获得
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):
    """
    创建注意力模型的函数。

    参数：
    - input_size: 输入特征的大小
    - attention_size: 注意力机制中间层的大小

    返回：
    - model: 注意力模型，包含两个线性层和一个 Tanh 激活函数

    注意力模型结构：
    - 第一个线性层：将输入特征映射到注意力中间层大小，没有偏置
    - Tanh 激活函数：增加非线性
    - 第二个线性层：将注意力中间层映射到一个注意力权重，没有偏置

    """
    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)  # 返回背景变量

seq_len, batch_size, num_hiddens = 10, 4, 8  # 序列长度、批量大小、隐藏单元数
model = attention_model(2*num_hiddens, 10)  # 创建注意力模型，输入特征大小为 2*num_hiddens，注意力大小为 10
enc_states = torch.zeros((seq_len, batch_size, num_hiddens))  # 编码器状态，形状为 (seq_len, batch_size, num_hiddens)
dec_state = torch.zeros((batch_size, num_hiddens))  # 解码器初始状态，形状为 (batch_size, num_hiddens)
attention_forward(model, enc_states, dec_state).shape  # 使用注意力模型进行前向传播，输出形状的注释

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

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.stoi[EOS]).float()
    return l / num_not_pad_tokens

def train(encoder, decoder, dataset, lr, batch_size, num_epochs):
    """
    训练函数，用于训练编码器-解码器模型。

    参数：
    - encoder: 编码器模型
    - decoder: 解码器模型
    - dataset: 训练数据集
    - lr: 学习率
    - batch_size: 批量大小
    - num_epochs: 训练轮数

    返回：
    无返回值，直接对 encoder 和 decoder 进行训练。

    每个epoch过程：
    - 使用 Adam 优化器对编码器和解码器的参数进行优化
    - 使用交叉熵损失函数计算批量损失
    - 执行反向传播和优化步骤
    - 计算并打印每个epoch的平均损失

    """
    enc_optimizer = torch.optim.Adam(encoder.parameters(), lr=lr)  # 编码器优化器
    dec_optimizer = torch.optim.Adam(decoder.parameters(), lr=lr)  # 解码器优化器

    loss = nn.CrossEntropyLoss(reduction='none')   # 交叉熵损失函数
    data_iter = 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  # 注意力大小、dropout概率、学习率、批量大小、训练轮数

# 创建编码器和解码器模型
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)

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)  # 补充 EOS 和 PAD
    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)  # 编码器得到输出和最终状态

    dec_input = torch.tensor([out_vocab.stoi[BOS]])  # 解码器初始输入为 BOS
    dec_state = decoder.begin_state(enc_state)  # 解码器初始状态使用编码器的最终状态
    output_tokens = []  # 输出序列的 token

    for _ in range(max_seq_len):
        dec_output, dec_state = decoder(dec_input, dec_state, enc_output)  # 解码器得到输出和新状态
        pred = dec_output.argmax(dim=1)  # 获取预测结果中概率最大的 token
        pred_token = out_vocab.itos[int(pred.item())]  # 将预测结果转换为 token
        if pred_token == EOS:  # 如果预测出 EOS，表示输出序列完成
            break
        else:
            output_tokens.append(pred_token)  # 将预测的 token 添加到输出序列
            dec_input = pred  # 将当前预测的 token 作为下一个时间步的输入

    return output_tokens

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

def bleu(pred_tokens, label_tokens, k):
    """
    计算 BLEU 分数的函数。

    参数：
    - pred_tokens: 预测的 token 列表
    - label_tokens: 标签的 token 列表
    - k: 最大 n-gram 的 n 值

    返回：
    - score: BLEU 分数

    计算过程：
    - 计算预测序列和标签序列的长度比例的指数分数
    - 对每个 n-gram 进行匹配计数，并根据匹配数计算分数
    """
    len_pred, len_label = len(pred_tokens), len(label_tokens)
    score = math.exp(min(0, 1 - len_label / len_pred))  # 根据预测序列和标签序列的长度比例计算指数分数

    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):
            if label_subs[''.join(pred_tokens[i: i + n])] > 0:
                num_matches += 1
                label_subs[''.join(pred_tokens[i: i + n])] -= 1

        # 计算 n-gram 的精确率和召回率
        precision_recall = num_matches / (len_pred - n + 1)
        
        # 根据精确率和召回率计算 n-gram 的加权分数
        score *= math.pow(precision_recall, math.pow(0.5, n))

    return score

def score(input_seq, label_seq, k):
    """
    计算并打印输入序列的 BLEU 分数及其预测。

    参数：
    - input_seq: 输入序列（字符串形式）
    - label_seq: 标签序列（字符串形式）
    - k: 最大 n-gram 的 n 值
    """
    pred_tokens = translate(encoder, decoder, input_seq, max_seq_len)#使用 translate 函数预测输出序列
    label_tokens = label_seq.split(' ')  # 将标签序列分词
    print('bleu %.3f, predict: %s' % (bleu(pred_tokens, label_tokens, k),
                                      ' '.join(pred_tokens)))  # 打印 BLEU 分数及其预测结果

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

score('ils sont canadienne .', 'they are canadian .', k=2)

import math  # 导入数学库
import torchtext  # 导入torchtext库
import torch  # 导入PyTorch库
import torch.nn as nn  # 导入PyTorch的神经网络模块
from torch import Tensor  # 导入张量数据类型
from torch.nn.utils.rnn import pad_sequence  # 导入序列填充函数
from torch.utils.data import DataLoader  # 导入数据加载器
from collections import Counter  # 导入计数器类
from torchtext.vocab import Vocab  # 导入词汇表类
from torch.nn import TransformerEncoder, TransformerDecoder, TransformerEncoderLayer, TransformerDecoderLayer  # 导入Transformer模型相关类
import io  # 导入io库
import time  # 导入时间库
import pandas as pd  # 导入pandas库
import numpy as np  # 导入numpy库
import pickle  # 导入pickle库
import tqdm  # 导入进度条库
import sentencepiece as spm  # 导入SentencePiece库
torch.manual_seed(0)  # 设置随机种子以保证实验的可重复性
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 检测CUDA是否可用，选择运行设备为GPU或CPU
#print(torch.cuda.get_device_name(0)) ## 如果你有GPU，请在你自己的电脑上尝试运行这一套代码

df = pd.read_csv('zh-ja.bicleaner05.txt', sep='\\t', engine='python', header=None)
trainen = df[2].values.tolist()  # 将第三列数据转换为列表，即英文训练数据
trainja = df[3].values.tolist()  # 将第四列数据转换为列表，即日文训练数据
# 注释：上面两行代码用于从文件 'zh-ja.bicleaner05.txt' 中读取数据。将第三列和第四列的内容分别存储为英文训练数据（trainen）和日文训练数据（trainja）。
# 如果需要限制数据量，可以取消注释[:10000]部分，以仅使用前10000条数据。

# trainen.pop(5972)
# trainja.pop(5972)

print(trainen[500])
print(trainja[500])

# 加载英文句子分割器
en_tokenizer = spm.SentencePieceProcessor(model_file='spm.en.nopretok.model')  
# 加载日文句子分割器
ja_tokenizer = spm.SentencePieceProcessor(model_file='spm.ja.nopretok.model') 

en_tokenizer.encode("All residents aged 20 to 59 years who live in Japan must enroll in public pension system.", out_type='str')

​

ja_tokenizer.encode("年金 日本に住んでいる20歳~60歳の全ての人は、公的年金制度に加入しなければなりません。", out_type='str')

​

def build_vocab(sentences, tokenizer):
    counter = Counter()  # 创建一个计数器对象用于统计词频
    for sentence in sentences:
        counter.update(tokenizer.encode(sentence, out_type=str))  # 使用指定的tokenizer对每个句子进行编码（分词），并更新计数器
    return Vocab(counter, specials=['<unk>', '<pad>', '<bos>', '<eos>'])  # 基于计数器构建词汇表，包括特殊标记

ja_vocab = build_vocab(trainja, ja_tokenizer)  # 构建日文词汇表，使用trainja数据和日文tokenizer
en_vocab = build_vocab(trainen, en_tokenizer)  # 构建英文词汇表，使用trainen数据和英文tokenizer

def data_process(ja, en):
    data = []  # 初始化一个空列表用于存储处理后的数据
    for (raw_ja, raw_en) in zip(ja, en):
        # 对于每一对（raw_ja, raw_en），分别进行处理
        ja_tensor_ = torch.tensor([ja_vocab[token] for token in ja_tokenizer.encode(raw_ja.rstrip("\n"), out_type=str)],
                            dtype=torch.long)
        # 使用日文tokenizer对raw_ja进行编码，并根据日文词汇表ja_vocab将每个token转换为对应的索引，创建torch.tensor对象
        en_tensor_ = torch.tensor([en_vocab[token] for token in en_tokenizer.encode(raw_en.rstrip("\n"), out_type=str)],
                            dtype=torch.long)
        # 使用英文tokenizer对raw_en进行编码，并根据英文词汇表en_vocab将每个token转换为对应的索引，创建torch.tensor对象
        data.append((ja_tensor_, en_tensor_))  # 将处理后的（日文tensor, 英文tensor）元组添加到data列表中
    return data  # 返回处理后的数据列表

train_data = data_process(trainja, trainen)  # 对训练数据trainja和trainen进行数据处理，存储结果到train_data中

BATCH_SIZE = 8  # 定义批量大小为8

PAD_IDX = ja_vocab['<pad>']  # 获取日文词汇表中 '<pad>' 标记对应的索引
BOS_IDX = ja_vocab['<bos>']  # 获取日文词汇表中 '<bos>' 标记对应的索引
EOS_IDX = ja_vocab['<eos>']  # 获取日文词汇表中 '<eos>' 标记对应的索引

def generate_batch(data_batch):
    ja_batch, en_batch = [], []  # 初始化空列表用于存储日文和英文的批量数据
    for (ja_item, en_item) in data_batch:
        # 对于每个数据批次中的（ja_item, en_item），分别进行处理
        ja_batch.append(torch.cat([torch.tensor([BOS_IDX]), ja_item, torch.tensor([EOS_IDX])], dim=0))
        # 在日文数据的开头添加<BOS>（序列开始）标记，结尾添加<EOS>（序列结束）标记，并拼接成一个tensor序列
        en_batch.append(torch.cat([torch.tensor([BOS_IDX]), en_item, torch.tensor([EOS_IDX])], dim=0))
        # 在英文数据的开头添加<BOS>（序列开始）标记，结尾添加<EOS>（序列结束）标记，并拼接成一个tensor序列

    ja_batch = pad_sequence(ja_batch, padding_value=PAD_IDX)  # 对日文数据批量进行填充，使用PAD_IDX作为填充值
    en_batch = pad_sequence(en_batch, padding_value=PAD_IDX)  # 对英文数据批量进行填充，使用PAD_IDX作为填充值

    return ja_batch, en_batch  # 返回填充后的日文和英文批量数据

train_iter = DataLoader(train_data, batch_size=BATCH_SIZE,
                        shuffle=True, collate_fn=generate_batch)

BATCH_SIZE = 8  # 批量大小为8

PAD_IDX = ja_vocab['<pad>']  # 获取日语词汇表中 '<pad>' 标记的索引
BOS_IDX = ja_vocab['<bos>']  # 获取日语词汇表中 '<bos>' 标记的索引
EOS_IDX = ja_vocab['<eos>']  # 获取日语词汇表中 '<eos>' 标记的索引

def generate_batch(data_batch):
    ja_batch, en_batch = [], []  # 初始化空列表用于存储日语和英语的批量数据
    for (ja_item, en_item) in data_batch:
        # 对于每个数据批次中的（ja_item, en_item），分别进行处理
        ja_batch.append(torch.cat([torch.tensor([BOS_IDX]), ja_item, torch.tensor([EOS_IDX])], dim=0))
        # 在日语数据的开头添加<BOS>（序列开始）标记，结尾添加<EOS>（序列结束）标记，并拼接成一个tensor序列
        en_batch.append(torch.cat([torch.tensor([BOS_IDX]), en_item, torch.tensor([EOS_IDX])], dim=0))
        # 在英语数据的开头添加<BOS>（序列开始）标记，结尾添加<EOS>（序列结束）标记，并拼接成一个tensor序列

    ja_batch = pad_sequence(ja_batch, padding_value=PAD_IDX)  # 对日语数据批量进行填充，使用PAD_IDX作为填充值
    en_batch = pad_sequence(en_batch, padding_value=PAD_IDX)  # 对英语数据批量进行填充，使用PAD_IDX作为填充值

    return ja_batch, en_batch  # 返回填充后的日语和英语批量数据

train_iter = DataLoader(train_data, batch_size=BATCH_SIZE,
                        shuffle=True, collate_fn=generate_batch)

class PositionalEncoding(nn.Module):
    def __init__(self, emb_size: int, dropout, maxlen: int = 5000):
        super(PositionalEncoding, self).__init__()
        
        # 计算denominator，即公式中的分母部分
        den = torch.exp(- torch.arange(0, emb_size, 2) * math.log(10000) / emb_size)
        
        # 生成位置编码所需的位置索引，从0到maxlen-1，并且reshape成(maxlen, 1)的形状
        pos = torch.arange(0, maxlen).reshape(maxlen, 1)
        
        # 初始化位置编码矩阵，形状为(maxlen, emb_size)，并用0填充
        pos_embedding = torch.zeros((maxlen, emb_size))
        
        # 根据公式计算位置编码的sin部分和cos部分，并将其分别赋值给位置编码矩阵的奇数列和偶数列
        pos_embedding[:, 0::2] = torch.sin(pos * den)
        pos_embedding[:, 1::2] = torch.cos(pos * den)
        
        # 在倒数第二个维度上增加一个维度，形状变为(maxlen, emb_size, 1)，以便与token_embedding相加
        pos_embedding = pos_embedding.unsqueeze(-2)

        # 定义Dropout层，用于在前向传播时对token_embedding和位置编码进行随机置零
        self.dropout = nn.Dropout(dropout)
        
        # 将位置编码矩阵转换为不可训练的buffer，以便在模型中保持固定
        self.register_buffer('pos_embedding', pos_embedding)

    def forward(self, token_embedding: Tensor):
        # 返回经过Dropout处理后的token_embedding与位置编码相加的结果
        return self.dropout(token_embedding +
                            self.pos_embedding[:token_embedding.size(0), :])

class TokenEmbedding(nn.Module):
    def __init__(self, vocab_size: int, emb_size):
        super(TokenEmbedding, self).__init__()
        
        # 定义一个词嵌入层，将输入的词索引tokens转换为词嵌入向量，维度为(词汇量大小, emb_size)
        self.embedding = nn.Embedding(vocab_size, emb_size)
        
        # 保存词嵌入向量的维度大小
        self.emb_size = emb_size
    
    def forward(self, tokens: Tensor):
        # 将输入的tokens转换为长整型，并通过词嵌入层获取词嵌入向量，并乘以sqrt(emb_size)进行缩放
        return self.embedding(tokens.long()) * math.sqrt(self.emb_size)

def generate_square_subsequent_mask(sz):
    # 生成一个大小为(sz, sz)的上三角矩阵，并转置为(sz, sz)的形状
    mask = (torch.triu(torch.ones((sz, sz), device=device)) == 1).transpose(0, 1)
    mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
    return mask

def create_mask(src, tgt):
    # 获取源序列和目标序列的长度
    src_seq_len = src.shape[0]
    tgt_seq_len = tgt.shape[0]

    # 生成目标序列的mask，这里使用generate_square_subsequent_mask生成
    tgt_mask = generate_square_subsequent_mask(tgt_seq_len)
    
    # 创建一个全零的(src_seq_len, src_seq_len)大小的bool型张量，作为源序列的mask
    src_mask = torch.zeros((src_seq_len, src_seq_len), device=device).type(torch.bool)

    # 生成源序列和目标序列的填充mask
    # src_padding_mask: 将src中等于PAD_IDX的位置转置为(src_seq_len, batch_size)的形状
    src_padding_mask = (src == PAD_IDX).transpose(0, 1)
    
    # tgt_padding_mask: 将tgt中等于PAD_IDX的位置转置为(tgt_seq_len, batch_size)的形状
    tgt_padding_mask = (tgt == PAD_IDX).transpose(0, 1)
    
    # 返回源mask、目标mask以及源填充mask和目标填充mask
    return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask

SRC_VOCAB_SIZE = len(ja_vocab)  # 源语言词汇表大小
TGT_VOCAB_SIZE = len(en_vocab)  # 目标语言词汇表大小
EMB_SIZE = 512  # 词嵌入维度大小
NHEAD = 8  # 注意力头数
FFN_HID_DIM = 512  # FeedForward层隐藏单元数
BATCH_SIZE = 16  # 批量大小
NUM_ENCODER_LAYERS = 3  # 编码器层数
NUM_DECODER_LAYERS = 3  # 解码器层数
NUM_EPOCHS = 16  # 训练轮数

# 创建一个Seq2SeqTransformer模型实例
transformer = Seq2SeqTransformer(NUM_ENCODER_LAYERS, NUM_DECODER_LAYERS,
                                 EMB_SIZE, SRC_VOCAB_SIZE, TGT_VOCAB_SIZE,
                                 FFN_HID_DIM)

# 对模型参数进行初始化（Xavier初始化）
for p in transformer.parameters():
    if p.dim() > 1:
        nn.init.xavier_uniform_(p)

transformer = transformer.to(device)  # 将模型移动到指定的设备（如GPU）

# 定义损失函数为交叉熵损失，忽略填充标记的损失计算
loss_fn = torch.nn.CrossEntropyLoss(ignore_index=PAD_IDX)

# 使用Adam优化器进行模型参数的优化
optimizer = torch.optim.Adam(
    transformer.parameters(), lr=0.0001, betas=(0.9, 0.98), eps=1e-9
)

# 定义训练函数，每个epoch训练一次模型
def train_epoch(model, train_iter, optimizer):
    model.train()
    losses = 0
    for idx, (src, tgt) in enumerate(train_iter):
        src = src.to(device)
        tgt = tgt.to(device)

        tgt_input = tgt[:-1, :]  # 去掉目标序列的最后一个标记作为输入

        # 创建输入序列和目标序列的掩码
        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)

        # 前向传播得到预测结果logits
        logits = model(src, tgt_input, src_mask, tgt_mask,
                       src_padding_mask, tgt_padding_mask, src_padding_mask)

        optimizer.zero_grad()  # 梯度清零

        tgt_out = tgt[1:, :]  # 去掉目标序列的第一个标记作为输出
        # 计算损失
        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))
        loss.backward()  # 反向传播计算梯度

        optimizer.step()  # 更新模型参数
        losses += loss.item()  # 累加损失值
    return losses / len(train_iter)  # 返回平均损失

# 定义评估函数，评估模型在验证集上的表现
def evaluate(model, val_iter):
    model.eval()
    losses = 0
    for idx, (src, tgt) in enumerate(val_iter):
        src = src.to(device)
        tgt = tgt.to(device)

        tgt_input = tgt[:-1, :]  # 去掉目标序列的最后一个标记作为输入

        # 创建输入序列和目标序列的掩码
        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)

        # 前向传播得到预测结果logits
        logits = model(src, tgt_input, src_mask, tgt_mask,
                       src_padding_mask, tgt_padding_mask, src_padding_mask)
        tgt_out = tgt[1:, :]  # 去掉目标序列的第一个标记作为输出
        # 计算损失
        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))
        losses += loss.item()  # 累加损失值
    return losses / len(val_iter)  # 返回平均损失

for epoch in tqdm.tqdm(range(1, NUM_EPOCHS+1)):
    start_time = time.time()
    train_loss = train_epoch(transformer, train_iter, optimizer)
    end_time = time.time()
    print((f"Epoch: {epoch}, Train loss: {train_loss:.3f}, "
           f"Epoch time = {(end_time - start_time):.3f}s"))

def greedy_decode(model, src, src_mask, max_len, start_symbol):
    """
    使用贪心算法生成目标序列。

    Args:
    - model (nn.Module): Transformer模型用于解码。
    - src (torch.Tensor): 形状为 (seq_len, 1) 的源序列索引张量。
    - src_mask (torch.Tensor): 源序列的布尔掩码。
    - max_len (int): 生成序列的最大长度。
    - start_symbol (int): 目标词汇表中的起始符号索引。

    Returns:
    - ys (torch.Tensor): 形状为 (seq_len, 1) 的生成目标序列索引张量。
    """
    src = src.to(device)
    src_mask = src_mask.to(device)
    memory = model.encode(src, src_mask)
    ys = torch.ones(1, 1).fill_(start_symbol).type(torch.long).to(device)
    for i in range(max_len-1):
        memory = memory.to(device)
        memory_mask = torch.zeros(ys.shape[0], memory.shape[0]).to(device).type(torch.bool)
        tgt_mask = (generate_square_subsequent_mask(ys.size(0))
                                    .type(torch.bool)).to(device)
        out = model.decode(ys, memory, tgt_mask)
        out = out.transpose(0, 1)
        prob = model.generator(out[:, -1])
        _, next_word = torch.max(prob, dim = 1)
        next_word = next_word.item()
        ys = torch.cat([ys,
                        torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=0)
        if next_word == EOS_IDX:
        break
    return ys

def translate(model, src, src_vocab, tgt_vocab, src_tokenizer):
    """
    使用Transformer模型进行翻译任务。

    Args:
    - model (nn.Module): Transformer模型用于翻译。
    - src (str): 源语言句子（字符串格式）。
    - src_vocab (Vocab): 源语言词汇表对象。
    - tgt_vocab (Vocab): 目标语言词汇表对象。
    - src_tokenizer (Tokenizer): 源语言的分词器。

    Returns:
    - translation (str): 翻译后的目标语言句子（字符串格式）。
    """
    model.eval()
    tokens = [BOS_IDX] + [src_vocab.stoi[tok] for tok in src_tokenizer.encode(src, out_type=str)]+ [EOS_IDX]
    num_tokens = len(tokens)
    src = (torch.LongTensor(tokens).reshape(num_tokens, 1) )
    src_mask = (torch.zeros(num_tokens, num_tokens)).type(torch.bool)
    tgt_tokens = greedy_decode(model,  src, src_mask, max_len=num_tokens + 5, start_symbol=BOS_IDX).flatten()
    return " ".join([tgt_vocab.itos[tok] for tok in tgt_tokens]).replace("<bos>", "").replace("<eos>", "")

translate(transformer, "HSコード 8515 はんだ付け用、ろう付け用又は溶接用の機器(電気式(電気加熱ガス式を含む。)", ja_vocab, en_vocab, ja_tokenizer)

​

trainen.pop(5)

trainja.pop(5)

import pickle
# 打开一个文件，用于存储数据
file = open('en_vocab.pkl', 'wb')
# 将en_vocab对象序列化并写入文件中
pickle.dump(en_vocab, file)
file.close()

# 打开一个文件，用于存储数据
file = open('ja_vocab.pkl', 'wb')
# 将ja_vocab对象序列化并写入文件中
pickle.dump(ja_vocab, file)
file.close()

#保存模型
torch.save(transformer.state_dict(), 'inference_model')

#验证模型
torch.save({
  'epoch': NUM_EPOCHS,
  'model_state_dict': transformer.state_dict(),
  'optimizer_state_dict': optimizer.state_dict(),
  'loss': train_loss,
  }, 'model_checkpoint.tar')