第N9周：seq2seq翻译实战-Pytorch复现-小白版-EW帮帮网

>- **🍨 本文为[🔗365天深度学习训练营]中的学习记录博客**
>- **🍖 原作者：[K同学啊]**

本人往期文章可查阅：深度学习总结

🏡 我的环境：

语言环境：Python3.11

编译器：PyCharm

深度学习环境：Pytorch

- torch==2.0.0+cu118

- torchvision==0.18.1+cu118
显卡：NVIDIA GeForce GTX 1660

Seq2Seq(Sequence to Sequence)是一个用于处理序列数据的模型架构，广泛应用于自然语言处理（NLP）任务，如机器翻译、文本摘要和对话系统等。Seq2Seq 模型的核心思想是将输入序列转换为输出序列，通常包含两个主要部分：

1. 编码器（Encoder）：将输入序列编码为一个固定大小的上下文向量（context vector），即捕捉输入信息的表示。

2. 解码器（Decoder）：接收编码器传入的上下文向量，使用上下文向量生成输出序列。

本周任务：

理解文本代码并跑通

本文数据：eng-fra.txt

一、前期准备工作

from __future__ import unicode_literals,print_function,division
from io import open
import unicodedata,string,re,random

import torch
import torch.nn as nn
from torch import optim
import torch.nn.functional as F

device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

输出：

device(type='cuda')

1. 搭建语言类

定义了两个常量 SOS_token 和 EOS_token，其分别代表序列的开始和结束。Lang类，用于方便对语料库进行操作：

word2index 是一个字典，将单词映射到索引
word2count 是一个字典，记录单词出现的次数
index2word 是一个字典，将索引映射到单词
n_words 是单词的数量，初始值为2，因为序列开始和结束的单词已经被添加

addSentence 方法：用于向 Lang 类中添加一个句子，它会调用 addWord 方法将句子中的每个单词添加到 Lang 类中

addWord 方法：将单词添加到 word2inde、word2count 和 index2word 字典中，并对 n_words 进行更新。如果单词已经存在于 word2index 中，则将 word2count 中对应的计数器加1

SOS_token=0  # 序列的开始
EOS_token=1  # 序列的结束

# 语言类，方便对语料库进行操作
class Lang:
    def __init__(self,name):
        self.name=name  # 语言名称，如：“English”或“French”
        self.word2index={}  # 单词映射到索引
        self.word2count={}  # 记录单词出现次数
        self.index2word={0:"SOS",1:"EOS"}  # 索引映射到单词
        self.n_words=2  # Count SOS and EOS  # 单词数量，因序列开始和结束单词已被添加，故初始值为2
        
    def addSentence(self,sentence):
        for word in sentence.split(' '):
            self.addWord(word)
            
    def addWord(self,word):
        if word not in self.word2index:
            self.word2index[word]=self.n_words
            self.word2count[word]=1
            self.index2word[self.n_words]=word
            self.n_words+=1
        else:
            self.word2count[word]+=1

（1） addSentence 方法：通过空格将句子分割成单词，并逐个调用 addWord 方法将单词加入词汇表。

（2）addWord 方法：

如果单词不在 word2index 中，说明它是新单词：
- 为该单词分配一个唯一的索引（当前的 n_words 值）。
- 在 word2count 中记录该单词出现的次数为 1。
- 将索引和单词的映射关系添加到 index2word 中。
- 增加 n_words 的值。

示例：

lang = Lang("English")
lang.addSentence("hello world")
lang.addSentence("hello moon")

print(lang.word2index)  # {'hello': 2, 'world': 3, 'moon': 4}
print(lang.word2count)  # {'hello': 2, 'world': 1, 'moon': 1}
print(lang.index2word)  # {0: 'SOS', 1: 'EOS', 2: 'hello', 3: 'world', 4: 'moon'}
print(lang.n_words)     # 5

2. 文本处理函数

def unicodeToAscii(s):
    return ''.join(
        c for c in unicodedata.normalize('NFD',s)
        if unicodedata.category(c)!='Mn'
    )

# 小写化，剔除标点与非字母符号
def normalizeString(s):
    s=unicodeToAscii(s.lower().strip())
    s=re.sub(r"([.!?])",r" \1",s)
    s=re.sub(r"[^a-zA-Z.!?]+",r" ",s)
    return s

unicodeToAscii 函数：

使用了Python 的 unicodedata 模块（是Python 的标准库模块，用于处理 Unicode 数据），通过 normalize 方法将字符串 s 转换为 Unicode 规范化形式 NFD
normalize('NFD', s) 是将字符串 s 转换为 NFD（Normalization Form Decomposed） 形式。在这种形式下，字符会被分解为其基本字符和变音符。例如："é" 在 Unicode 中是一个单独的字符，但在 NFD 形式下会被分解为两个字符："e" 和 "́"（重音符号）；"naïve" 会被分解为 "na", "ï"（分解为 "i" 和 "̈"），"ve"
使用条件判断语句过滤掉了 unicodedata.category(c) 为 'Mn' 的字符（Mn 表示 非间距标记（Mark, Nonspacing），即变音符或其他修饰符号，如："́"（重音符号）的类别是 Mn；"̈"（分音符）的类别也是 Mn）
剩下的字符通过 join 组成了一个新的字符串

"Mn" （即 " Nonspacing_Mark" ）是表示“非间隔标记”的字符类别之一，“非间隔标记”是指那些不会独立显示的标记或符号，它们通常附加在其他字符上面以改变该字符的发音或外观。例如，重音符号（如 "é" 中的 "第二声" ）和分音符号（如 "ā" 中的 "第一声"）就属于“非间隔标记”。

示例：

import unicodedata

def unicodeToAscii(s):
    return ''.join(
        c for c in unicodedata.normalize('NFD', s)
        if unicodedata.category(c) != 'Mn'
    )

# 测试
print(unicodeToAscii("café"))  # 输出: cafe
print(unicodeToAscii("naïve"))  # 输出: naive
print(unicodeToAscii("résumé"))  # 输出: resume
print(unicodeToAscii("São Paulo"))  # 输出: Sao Paulo

normalizeString 函数：

将字符串 s 转换为小写字母形式，并去除首尾空格，随后将字符串输入 unicodeToAscii 函数：s.lower()：将字符串转换为小写，以消除大小写差异；strip()：去除字符串首尾的空白字符。
通过正则表达式替换，将句子中的标点符号（'.'、'!'、'?'）前添加一个空格：（例如，将 "Hello!" 转换为 "Hello !"），这一步的目的是确保标点符号与单词之间有明确的分隔，方便后续的分词处理
将非字母符号（除了 .、!、?）替换为空格。正则表达式 [^a-zA-Z.!?]+ 匹配一个或多个非字母字符（除了标点符号 .、!、?）；将这些字符替换为空格，从而只保留字母和特定标点符号。
最后返回处理后的字符串 s

示例：

# 测试
print(normalizeString("Hello, World!"))  # 输出: "hello world !"
print(normalizeString("Café au lait. It's great!"))  # 输出: "cafe au lait . it s great !"
print(normalizeString("Naïve! Isn't it?"))  # 输出: "naive ! is n t it ?"
print(normalizeString("São Paulo's weather is nice."))  # 输出: "sao paulo s weather is nice ."

3. 文件读取函数

3.1 readLangs() 函数

接受两个参数 lang1 和 lang2，分别表示要读取的语言。

函数使用 Python 的 open 函数读取指定的文件，文件名格式为 lang1-lang2.txt ，以行为单位读取文件内容，并使用 strip 方法去掉每行末尾的换行符。接着，使用 split 方法将文本按照换行符分割成一个字符串列表 lines。

对于列表 lines 中的每一行，使用 split 方法将其按照制表符分割成两个元素，分别表示 A 语言文本和 B 语言文本。对于每个元素，调用 normalizeString 函数进行预处理，并将处理后的 A 语言文本和 B 语言文本组成一个新的列表 pairs。

参数 reverse 的值，创建 input_lang 和 output_lang 两个 Lang 类的实例，分别表示输入语言和输出语言。如果 reverse 为 True，则将 pairs 列表中的每个元素反转，并将 input_lang 和 output_lang 交换。最后，返回 input_lang、output_lang 和 pairs 三个值。

其实举个例子可以方便理解，比如文件为 eng-fra.txt ，对应的 lang1: eng 、 lang2: fra 。我们按照行读取数据，随便抽一行： I see. Je comprends. ，中间使用制表符 '\t' 分割，读取会将这一行放入列表的同一行，随后使用 normalizeString 函数进行处理，将处理后的 I see. 和 Je comprends. 组成一个新的列表 pairs。如果 reverse 为 False，则 input_lang 对应对应 lang1 表示的源语言，output_lang 对象对应 lang2 表示的目标语言。

def readLangs(lang1,lang2,reverse=False):
    print("Reading lines...")
    
    # 以行为单位读取文件
    lines=open(r'E:\DATABASE\N-series\N9\%s-%s.txt'%(lang1,lang2),encoding='utf-8').\
          read().strip().split('\n')
    
    # 将每一行放入一个列表中
    # 一个列表中有两个元素，A语言文本与B语言文本
    pairs=[[normalizeString(s) for s in l.split('\t')] for l in lines]
    
    # 创建Lang实例，并确认是否反转语言顺序
    if reverse:
        pairs=[list(reversed(p)) for p in pairs]
        input_lang=Lang(lang2)
        output_lang=Lang(lang1)
    else:
        input_lang=Lang(lang1)
        output_lang=Lang(lang2)
        
    return input_lang,output_lang,pairs

示例：假设文件 en-fr.txt 的内容如下：

Hello\tBonjour
Goodbye\tAu revoir
Thank you\tMerci

运行代码：

input_lang, output_lang, pairs = readLangs('en', 'fr', reverse=False)
print(input_lang.name)  # 输出: en
print(output_lang.name)  # 输出: fr
print(pairs)  # 输出: [['hello', 'bonjour'], ['goodbye', 'au revoir'], ['thank you', 'merci']]

如果设置 reverse=True：

input_lang, output_lang, pairs = readLangs('en', 'fr', reverse=True)
print(input_lang.name)  # 输出: fr
print(output_lang.name)  # 输出: en
print(pairs)  # 输出: [['bonjour', 'hello'], ['au revoir', 'goodbye'], ['merci', 'thank you']]

3.2 过滤语料库函数

这里定义了两个函数 filterPair 和 filterPairs，用于过滤语料库中的文本对。过滤的目的是确保语料库中的文本对符合特定条件，例如长度限制和特定的英文前缀。

.startswith(eng_prefixes) 是字符串方法 startswith() 的调用。它用于检查一个字符串是否以指定的前缀开始。

MAX_LENGTH=10  # 定义语料最长长度

eng_prefixes=(
    "i am","i m ",
    "he is","he s ",
    "she is","she s ",
    "you are","you re ",
    "we are","we re ",
    "they are","they re "
)

def filterPair(p):
    return len(p[0].split(' '))<MAX_LENGTH and \
           len(p[1].split(' '))<MAX_LENGTH and \
           p[1].startswith(eng_prefixes)

def filterPairs(pairs):
    # 选取仅仅包含 eng_prefixes 开头的语料
    return [pair for pair in pairs if filterPair(pair)]

3.2.1 `filterPair` 函数

（1）长度限制：

len(p[0].split(' ')) < MAX_LENGTH：第一个句子（通常是源语言）的单词数少于 MAX_LENGTH。
len(p[1].split(' ')) < MAX_LENGTH：第二个句子（通常是目标语言，这里是英文）的单词数少于 MAX_LENGTH。

（2）前缀限制：

p[1].startswith(eng_prefixes)：第二个句子（英文句子）以 eng_prefixes 中的某个短语开头。

（3）如果文本对满足所有条件，返回 True；否则返回 False。

3.2.2 `filterPairs` 函数

使用列表推导式遍历 pairs，并调用 filterPair 函数检查每个文本对是否符合条件。
只保留返回值为 True 的文本对。

示例：

假设我们有以下文本对列表：

pairs = [
    ["je suis un étudiant", "i am a student"],  # 符合条件
    ["tu es un ami", "you are a friend"],       # 符合条件
    ["il est professeur", "he is a teacher"],   # 符合条件
    ["nous sommes heureux", "we are happy"],    # 符合条件
    ["ils sont étudiants", "they are students"], # 符合条件
    ["elle est médecin", "she is a doctor"],    # 符合条件
    ["je vais à l'école", "i go to school"],    # 不符合条件（没有前缀）
    ["il a un livre", "he has a book"],         # 不符合条件（没有前缀）
    ["c'est un bon livre", "it is a good book"] # 不符合条件（没有前缀）
]

运行代码后输出：

["je suis un étudiant", "i am a student"]
["tu es un ami", "you are a friend"]
["il est professeur", "he is a teacher"]
["nous sommes heureux", "we are happy"]
["ils sont étudiants", "they are students"]
["elle est médecin", "she is a doctor"]

3.3 prepareData() 函数

def prepareData(lang1,lang2,reverse=False):
    # 读取文件中的数据
    input_lang,output_lang,pairs=readLangs(lang1,lang2,reverse)
    print("Read %s sentence pairs" % len(pairs))
    
    # 按条件选取语料
    pairs=filterPairs(pairs[:])
    print("Trimmed to %s sentence pairs" % len(pairs))
    print("Counting words...")
    
    # 将语料保存至相应的语言类
    for pair in pairs:
        input_lang.addSentence(pair[0])
        output_lang.addSentence(pair[1])
        
    # 打印语言类的信息
    print("Counted words:")
    print(input_lang.name,input_lang.n_words)
    print(output_lang.name,output_lang.n_words)
    return input_lang,output_lang,pairs

input_lang,output_lang,pairs=prepareData('eng','fra',True)
print(random.choice(pairs))

输出：

Reading lines...
Read 135842 sentence pairs
Trimmed to 10601 sentence pairs
Counting words...
Counted words:
fra 4346
eng 2803
['vous allez gagner aujourd hui .', 'you re going to win today .']

二、Seq2Seq 模型

1. 编码器（Encoder）

class EncoderRNN(nn.Module):
    def __init__(self,input_size,hidden_size):
        super(EncoderRNN,self).__init__()
        self.hidden_size=hidden_size
        self.embedding=nn.Embedding(input_size,hidden_size)
        self.gru=nn.GRU(hidden_size,hidden_size)
        
    def forward(self,input,hidden):
        embedded=self.embedding(input).view(1,1,-1)
        output=embedded
        output,hidden=self.gru(output,hidden)
        return output,hidden
    
    def initHidden(self):
        return torch.zeros(1,1,self.hidden_size,device=device)

这段代码定义了一个基于 PyTorch 的 EncoderRNN 类，用于实现一个简单的循环神经网络（RNN）编码器。该编码器通常用于序列到序列（Seq2Seq）模型中，例如机器翻译、文本摘要等任务。

1.1 类的定义

（1）继承

EncoderRNN 继承自 PyTorch 的 nn.Module，这是所有神经网络模块的基类。

（2）初始化方法 __init__

参数：
- input_size：输入词汇表的大小（即输入单词的索引范围）。
- hidden_size：隐藏层的维度，也是 GRU 的输出维度。
成员变量：
- self.hidden_size：隐藏层的维度。
- self.embedding：一个嵌入层（nn.Embedding），将输入单词的索引转换为固定大小的密集向量。
  - 输入大小为 input_size，输出大小为 hidden_size。
- self.gru：一个单向的 GRU（门控循环单元）层，用于处理序列数据。
  - 输入维度为 hidden_size，输出维度也为 hidden_size。

1.2 前向传播方法 forward

（1）输入参数

input：当前时间步的输入单词索引（一个标量）。
hidden：上一个时间步的隐藏状态（一个张量）。

（2）嵌入层

将输入单词索引通过嵌入层转换为嵌入向量。
使用 .view(1, 1, -1) 将嵌入向量的形状调整为 [1, 1, hidden_size]，以满足 GRU 的输入要求。
- 第一个维度是序列长度（时间步）。
- 第二个维度是批量大小（这里为 1，表示单个输入）。
- 第三个维度是特征维度（即 hidden_size）。

（3）GRU层

将嵌入向量 embedded 作为输入传递给 GRU 层。
GRU 的输出包括：
- output：当前时间步的输出，形状为 [1, 1, hidden_size]。
- hidden：当前时间步的隐藏状态，形状为 [1, 1, hidden_size]。
返回值：
- output：GRU 的输出。
- hidden：当前时间步的隐藏状态，用于下一个时间步。

1.3 初始化隐藏状态方法 initHidden

(1) 作用

初始化 GRU 的隐藏状态。
返回一个形状为 [1, 1, hidden_size] 的零张量。
device 是一个全局变量，表示计算设备（例如 CPU 或 GPU）。

(2) 返回值

返回一个初始化的隐藏状态张量，用于第一个时间步。

示例：

import torch
import torch.nn as nn

# 假设设备是 CPU
device = torch.device("cpu")

# 创建 EncoderRNN 实例
input_size = 10000  # 输入词汇表大小
hidden_size = 256   # 隐藏层维度
encoder = EncoderRNN(input_size, hidden_size).to(device)

# 初始化隐藏状态
hidden = encoder.initHidden()

# 输入一个单词索引（假设输入单词索引为 5）
input_tensor = torch.tensor([5], dtype=torch.long, device=device)

# 前向传播
output, hidden = encoder(input_tensor, hidden)

print("Output shape:", output.shape)  # 输出形状：[1, 1, 256]
print("Hidden shape:", hidden.shape)  # 隐藏状态形状：[1, 1, 256]

2. 解码器（Decoder）

这里是不带注意力机制的解码器

class DecoderRNN(nn.Module):
    def __init__(self,hidden_size,output_size):
        super(DecoderRNN,self).__init__()
        self.hidden_size=hidden_size
        self.embedding=nn.Embedding(output_size,hidden_size)
        self.gru=nn.GRU(hidden_size,hidden_size)
        self.out=nn.Linear(hidden_size,output_size)
        self.softmax=nn.LogSoftmax(dim=1)
        
    def forward(self,input,hidden):
        output=self.embedding(input).view(1,1,-1)
        output=F.relu(output)
        output,hidden=self.gru(output,hidden)
        output=self.softmax(self.out(output[0]))
        return output,hidden
    
    def initHidden(self):
        return torch.zeros(1,1,self.hidden_sizei,device=device)

三、训练

1. 数据预处理

# 将文本数字化，获取词汇index
def indexesFromSentence(lang,sentence):
    return [lang.word2index[word] for word in sentence.split(' ')]

# 将数字化的文本，转化为tensro数据
def tensorFromSentence(lang,sentence):
    indexes=indexesFromSentence(lang,sentence)
    indexes.append(EOS_token)
    return torch.tensor(indexes,dtype=torch.long,device=device).view(-1,1)

# 输入pair文本，输出预处理好的数据
def tensorsFromPair(pair):
    input_tensor=tensorFromSentence(input_lang,pair[0])
    target_tensor=tensorFromSentence(output_lang,pair[1])
    return (input_tensor,target_tensor)

1.1 `indexesFromSentence` 函数

将一个句子（由空格分隔的单词序列）转换为单词索引列表，每个单词通过 lang.word2index 映射为对应的索引。

示例：

lang = Lang("English")
lang.addSentence("hello world")
lang.addSentence("goodbye world")

sentence = "hello world"
indexes = indexesFromSentence(lang, sentence)
print(indexes)  # 输出：[2, 3]

1.2 `tensorFromSentence` 函数

功能：

将一个句子转换为 PyTorch 张量。
在句子末尾添加 EOS_token（结束标记）。
将索引列表转换为张量，并调整形状为 [sequence_length, 1]，以满足模型输入的要求。

示例：

sentence = "hello world"
tensor = tensorFromSentence(lang, sentence)
print(tensor)
# 输出：
# tensor([[2],
#         [3],
#         [1]], device='cpu')

1.3 `tensorsFromPair` 函数

功能：

将一个双语句子对（源语言句子和目标语言句子）转换为两个张量。
用于准备训练数据，将文本对转换为模型可以直接处理的张量形式。

参数：

pair：一个包含两个句子的列表或元组，例如 ["hello world", "bonjour monde"]。
input_lang 和 output_lang：分别表示源语言和目标语言的 Lang 实例。

返回值：

一个元组，包含两个张量：
- input_tensor：源语言句子的张量。
- target_tensor：目标语言句子的张量。

示例：

input_lang = Lang("English")
output_lang = Lang("French")
input_lang.addSentence("hello world")
output_lang.addSentence("bonjour monde")

pair = ["hello world", "bonjour monde"]
input_tensor, target_tensor = tensorsFromPair(pair)

print(input_tensor)
# 输出：
# tensor([[2],
#         [3],
#         [1]], device='cpu')

print(target_tensor)
# 输出：
# tensor([[2],
#         [3],
#         [1]], device='cpu')

2. 训练函数

2.1 Seq2Seq 训练函数

teacher_forcing_ratio=0.5

def train(input_tensor,target_tensor,
          encoder,decoder,
          encoder_optimizer,decoder_optimizer,
          criterion,max_length=MAX_LENGTH):
    
    # 编码器初始化
    encoder_hidden=encoder.initHidden()
    
    # grad 属性归零
    encoder_optimizer.zero_grad()
    decoder_optimizer.zero_grad()
    
    input_length=input_tensor.size(0)
    target_length=target_tensor.size(0)
    
    # 用于创建一个指定大小的全零张量（tensor），用作默认编码器输出
    encoder_outputs=torch.zeros(max_length,encoder.hidden_size,device=device)
    
    loss=0
    
    # 将处理好的语料送入编码器
    for ei in range(input_length):
        encoder_output,encoder_hidden=encoder(input_tensor[ei],encoder_hidden)
        encoder_outputs[ei]=encoder_output[0,0]
        
    # 解码器默认输出
    decoder_input=torch.tensor([[SOS_token]],device=device)
    decoder_hidden=encoder_hidden
    
    use_teacher_forcing=True if random.random()<teacher_forcing_ratio else False
    
    # 将编码器处理好的输出送入编码器
    if use_teacher_forcing:
        # Teacher forcing: Feed the target as the next input
        for di in range(target_length):
            decoder_output,decoder_hidden=decoder(decoder_input,decoder_hidden)
            loss+=criterion(decoder_output,target_tensor[di])
            decoder_input=target_tensor[di]  # Teacher forcing
    else:
        # Without teacher forcing:use its own predictions as the next input
        for di in range(target_length):
            decoder_output,decoder_hidden=decoder(decoder_input,decoder_hidden)
            
            topv,topi=decoder_output.topk(1)
            decoder_input=topi.squeeze().detach() # detach from history as input
            loss+=criterion(decoder_output,target_tensor[di])
            if decoder_input.item()==EOS_token:
                break
                
    loss.backward()
    
    encoder_optimizer.step()
    decoder_optimizer.step()
    
    return loss.item()/target_length

在序列生成的任务重，如机器翻译或文本生成，解码器（decoder）的输入通常是由解码器自己生成的预测结果，即前一个时间步的输出。然而，这种自回归方式可能存在一个问题，即在训练过程中，解码器可能会产生累积误差，并导致输出与目标序列逐渐偏离。

为了解决这个问题，引入了一种称为“Teacher Forcing”的技术。在训练过程中，Teacher Forcing 将目标序列的真实值作为解码器的输入，而不是使用解码器自己的预测结果。这样可以提供准确的指导信号，帮助解码器更快地学习到正确的输出。

在这段代码中， use_teacher_forcing 变量用于确定解码器在训练阶段使用何种策略作为下一个输入。

当 use_teacher_forcing 为True 时，采用“Teacher Forcing”的策略，即将目标序列中的真实标签作为解码器的下一个输入。而当 use_teacher_forcing 为 False 时，采用“Without Teacher Forcing” 的策略，即将解码器自身的预测作为下一个输入。

使用 use_teacher_forcing 的目的是在训练过程中平衡解码器的预测能力和稳定性。以下是对两种策略的解释：

（1）Teacher Forcing：在每个时间步（ di 循环中），解码器的输入都是目标序列中的真实标签。这样做的好处是，解码器可以直接获得正确的输入信息，加快训练速度，并且在训练早期提供准确的梯度信号，帮助解码器更好地学习。然而，过度以来目标序列可能会导致模型过于敏感，一旦目标序列中出现错误，可能会在解码器中产生累积的误差。

（2）Without Teacher Forcing：在每个时间步，解码器的输入是前一个时间步的预测输出。这样做的好处是，解码器需要依靠自身的预测能力来生成下一个输入，从而更好地适应真实应用场景中可能出现的输入变化。这种策略可以提高模型的稳定性，但可能会导致训练过程更加困难，特别是在初始阶段。

一般来说，Teacher Forcing策略在训练过程中可以帮助模型快速收敛，而Without Teacher Forcing 策略则更接近真实应用的生成场景。通常会使用一定比例的 Teacher Forcing ，在训练过程中逐渐减小这个比例，以便模型逐渐过渡到更自主的生成模式。

综上所述，通过使用 use_teacher_forcing 来选择不同的策略，可以在训练解码器时平衡模型的预测能力和稳定性，同时也提供了更灵活的生成模式选择。

（1）topv,topi=decoder_output.topk(1)：这一行代码使用 .topk(1) 函数从 decoder_output 中获取最大的元素及其对应的索引。decoder_output 是一个张量（tensor），它包含了解码器的输出结果，可能是一个概率分布或是其他的数值。 .topk(1) 函数将返回两个张量：topv 和 topi 。topv 是最大的元素值，而 topi 是对应的索引值。

示例：

1. 选择概率最高的 1 个值

import torch

# 假设的输出概率分布
decoder_output = torch.tensor([[0.1, 0.2, 0.3, 0.4]], dtype=torch.float32)

topv, topi = torch.topk(decoder_output, k=1)
print("Top values:", topv)    # 输出：tensor([[0.4]])
print("Top indices:", topi)   # 输出：tensor([[3]])

2. 选择概率最高的 2 个值

topv, topi = torch.topk(decoder_output, k=2)
print("Top values:", topv)    # 输出：tensor([[0.4, 0.3]])
print("Top indices:", topi)   # 输出：tensor([[3, 2]])

3. 选择概率最低的 2 个值

topv, topi = torch.topk(decoder_output, k=2, largest=False)
print("Top values:", topv)    # 输出：tensor([[0.1, 0.2]])
print("Top indices:", topi)   # 输出：tensor([[0, 1]])

4. 多维张量

tensor = torch.tensor([[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]], dtype=torch.float32)
topv, topi = torch.topk(tensor, k=2)
print("Top values:", topv)    # 输出：tensor([0.6, 0.5])
print("Top indices:", topi)   # 输出：tensor([5, 4])

（2）decoder_input=topi.squeeze().detach()：这一行代码对 topi 进行处理，以便作为下一个解码器的输入。首先，.squeeze() 函数被调用，它的作用是去除张量中维度为1的维度，从而将 topi 的形状进行压缩。然后，.detach() 函数被调用，它的作用是将张量从计算图中分离出来，使得在后续的计算中不会对该张量进行梯度计算。最后，将处理后的张量赋值给 decoder_input ，作为下一个解码器的输入。

2.2 处理和显示时间函数

import time,math

def asMinutes(s):
    m=math.floor(s/60)
    s-=m*60
    return '%dm %ds' % (m,s)

def timeSince(since,percent):
    now=time.time()
    s=now-since
    es=s/(percent)
    rs=es-s
    return '%s (-%s)' % (asMinutes(s),asMinutes(rs))

（1） asMinutes 函数：将秒数转换为分钟和秒的格式

如：

print(asMinutes(125))  # 输出：2m 5s

（2）timeSince 函数

计算从某个时间点 since 到现在的时间差，并估计剩余时间。
since 是开始时间，percent 是当前完成的百分比。

2.3 训练模型

def trainIters(encoder,decoder,n_iters,print_every=1000,
               plot_every=100,learning_rate=0.01):
    
    start=time.time()
    plot_losses=[]
    print_loss_total=0 # Reset every print_every
    plot_loss_total=0 # Reset every plot_every
    
    encoder_optimizer=optim.SGD(encoder.parameters(),lr=learning_rate)
    decoder_optimizer=optim.SGD(decoder.parameters(),lr=learning_rate)
    
    # 在 pairs 中随机选取 n_iters 条数据用作训练集
    training_pairs=[tensorsFromPair(random.choice(pairs)) for i in range(n_iters)]
    criterion=nn.NLLLoss()
    
    for iter in range(1,n_iters+1):
        training_pair=training_pairs[iter-1]
        input_tensor=training_pair[0]
        target_tensor=training_pair[1]
        
        loss=train(input_tensor,target_tensor,encoder,decoder,
                   encoder_optimizer,decoder_optimizer,criterion)
        print_loss_total+=loss
        plot_loss_total+=loss
        
        if iter % print_every==0:
            print_loss_avg=print_loss_total/print_every
            print_loss_total=0
            print('%s (%d %d%%) %.4f' % (timeSince(start,iter/n_iters),
                                         iter,iter/n_iters*100,print_loss_avg))
        
        if iter % plot_every==0:
            plot_loss_avg=plot_loss_total/plot_every
            plot_losses.append(plot_loss_avg)
            plot_loss_total=0
            
    return plot_losses

2.3.1 函数参数

def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.01):

encoder 和 decoder：编码器和解码器模型。
n_iters：训练的总迭代次数。
print_every：每隔多少次迭代打印一次训练进度（默认为 1000 次）。
plot_every：每隔多少次迭代记录一次损失值（默认为 100 次）。
learning_rate：学习率，默认为 0.01。

2.3.2 初始化及准备

start = time.time()：记录训练开始的时间，用于计算训练进度。

plot_losses：用于存储每次记录的平均损失值，方便后续绘制损失曲线。
print_loss_total 和 plot_loss_total：分别用于累计打印和绘制所需的损失值。

training_pairs：从 pairs 中随机选择 n_iters 条数据，并将每对文本转换为张量（通过 tensorsFromPair 函数）。
criterion：使用负对数似然损失（nn.NLLLoss）作为损失函数。

四、训练与评估

hidden_size=256
encoder1=EncoderRNN(input_lang.n_words,hidden_size).to(device)
attn_decoder1=DecoderRNN(hidden_size,output_lang.n_words).to(device)

plot_losses=trainIters(encoder1,attn_decoder1,20000,print_every=5000)

输出：

1m 6s (-3m 18s) (5000 25%) 2.9394
2m 9s (-2m 9s) (10000 50%) 2.3767
3m 12s (-1m 4s) (15000 75%) 2.0504
4m 15s (-0m 0s) (20000 100%) 1.8045

import matplotlib.pyplot as plt
# 隐藏警告
import warnings
warnings.filterwarnings("ignore") #忽略警告信息

plt.rcParams['font.sans-serif']=['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False # 用来正常显示负号
plt.rcParams['figure.dpi']=300 # 分辨率

epochs_range=range(len(plot_losses))

plt.figure(figsize=(8,3))

plt.subplot(1,1,1)
plt.plot(epochs_range,plot_losses,label='Training Loss')
plt.legend(loc='upper right')
plt.title('Training Loss')
plt.show()

输出：

五、心得体会

大体了解了seq2seq的流程，完成了代码的实现。

第N9周：seq2seq翻译实战-Pytorch复现-小白版

一、前期准备工作

1. 搭建语言类

2. 文本处理函数

3. 文件读取函数

3.1 readLangs() 函数

3.2 过滤语料库函数

3.2.1 `filterPair` 函数

3.2.2 `filterPairs` 函数

3.3 prepareData() 函数

二、Seq2Seq 模型

1. 编码器（Encoder）

1.1 类的定义

1.2 前向传播方法 forward

1.3 初始化隐藏状态方法 initHidden

2. 解码器（Decoder）

三、训练

1. 数据预处理

1.1 `indexesFromSentence` 函数

1.2 `tensorFromSentence` 函数

功能：

1.3 `tensorsFromPair` 函数

2. 训练函数

2.1 Seq2Seq 训练函数

2.2 处理和显示时间函数

2.3 训练模型

2.3.1 函数参数

2.3.2 初始化及准备

四、训练与评估

五、心得体会

网站公告

今日签到

热门文章

最新发布

第N9周：seq2seq翻译实战-Pytorch复现-小白版

一、前期准备工作

1. 搭建语言类

2. 文本处理函数

3. 文件读取函数

3.1 readLangs() 函数

3.2 过滤语料库函数

3.2.1 filterPair 函数

3.2.2 filterPairs 函数

3.3 prepareData() 函数

二、Seq2Seq 模型

1. 编码器（Encoder）

1.1 类的定义

1.2 前向传播方法 forward

1.3 初始化隐藏状态方法 initHidden

2. 解码器（Decoder）

三、训练

1. 数据预处理

1.1 indexesFromSentence 函数

1.2 tensorFromSentence 函数

功能：

1.3 tensorsFromPair 函数

2. 训练函数

2.1 Seq2Seq 训练函数

2.2 处理和显示时间函数

2.3 训练模型

2.3.1 函数参数

2.3.2 初始化及准备

四、训练与评估

五、心得体会

网站公告

今日签到

热门文章

最新发布

3.2.1 `filterPair` 函数

3.2.2 `filterPairs` 函数

1.1 `indexesFromSentence` 函数

1.2 `tensorFromSentence` 函数

1.3 `tensorsFromPair` 函数