---

一、案例介绍

以一个人名分类器的案例，实例化RNN、LSTM和GRU。
数据就是torch官网的人名分类的数据。

二、代码实现

1.引入库并将字符转化为张量

from io import open
import glob
import os
import string
import unicodedata
import random
import time
import math
import torch
import torch.nn as nn
#import matplotlib.pyplot as pltall_letters=string.ascii_letters+".,;"
n_letters=len(all_letters)
#print("n_letters:",n_letters)#函数的作用是去掉一些语言的重音标记
def unicodeToAscii(s):return ''.join(c for c in unicodedata.normalize('NFD',s) if unicodedata.category(c)!='Mn' and c in all_letters)data_path="./data/names/"def readLines(filename):#打开指定的文件并读取所有内容，使用strip（）去掉两侧的空白符，然后以‘\n’为换行符进行切分lines=open(filename,encoding='utf-8').read().strip().split('\n')return [unicodeToAscii(line) for line in lines]#构建一个人名类别与具体人名对应关系的字典
category_lines={}#构建所有类别的列表
all_categories=[]#遍历所有的文件，使用glob.glob可以利用正则表达式的遍历
for filename in glob.glob(data_path+"*.txt"):#获取每个文件的文件名，得到名字的类别category=os.path.splitext(os.path.basename(filename))[0]#逐一将其装入所有类别的列表中all_categories.append(category)#然后读取美俄文件的内容，形成名字的列表lines=readLines(filename)#按照对应的类别，将名字列表写入到category_lines字典中category_lines[category]=linesn_categories=len(all_categories)def lineToTensor(line):#首先初始化一个全零的张量，这个张良的形状是(len(line),1,n_letters)#代表人名中的每一个字母都用一个(1*n_letters)张量来表示tensor=torch.zeros(len(line),1,n_letters)#遍历每个人名中的每个字符，并搜索其对应的索引，将该索引位置置1for li,letter in enumerate(line):tensor[li][0][all_letters.find(letter)]=1return tensor
line="bai"
line_tensor=lineToTensor(line)
print(line_tensor)

这里print的结果为

tensor([[[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0.]],[[1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0.]],[[0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0.]]])

实现了将字符转化为张量的目的。

2.构建RNN、LSTM和GRU类

class RNN(nn.Module):def __init__(self,input_size,hidden_size,output_size,num_layers=1):#input_size:代表RNN输入的最后一个维度，hidden_size:代表RNN隐藏层的最后一个维度，output_size:代表RNN网络最后线性层的输出维度，num_layers:代表RNN网络的层数super(RNN,self).__init__()self.input_size=input_sizeself.hidden_size=hidden_sizeself.output_size=output_sizeself.num_layers=num_layers#实例化预定义的RNN，三个参数分别是input_size,hidden_size,num_layersself.rnn=nn.RNN(input_size,hidden_size,num_layers)#实例化全连接线性层，作用是将RNN的输出维度转换成指定的输出维度self.linear=nn.Linear(hidden_size,output_size)#实例化nn中预定义的softmax层，用于从输出层中获得类别的结果self.softmax=nn.LogSoftmax(dim=-1)def forward(self,input1,hidden):#input1代表人名 分类器中的输入张量，形状是1*n_letters，hidden：代表RNN的隐藏层张量，形状是self.num_layers*1*self.hidden_size#注意一点输入到RNN中的张量要求是三维张量，所以需要用unsqueeze（）函数扩充维度input1=input1.unsqueeze(0)#将input1和hidden输入到RNN的实例化对象中，如果num_layers=1,rr恒等于hnrr,hn=self.rnn(input1,hidden)#将从RNN中获得的结果通过线性层的变换和softmax层的处理，最终返回结果return self.softmax(self.linear(rr)),hndef initHidden(self):#本函数的作用是用来初始化一个全零的隐藏层张量，维度是3return torch.zeros(self.num_layers,1,self.hidden_size)class LSTM(nn.Module):def __init__(self,input_size,hidden_size,output_size,num_layers=1):#input_size:代表输入张量x中最后一个维度，hidden_size:代表隐藏层张量的最后一个维度，output_size:代表线性层最后的输出维度，num_layers:代表LSTM网络的层数super(LSTM,self).__init__()self.input_size=input_sizeself.hidden_size=hidden_sizeself.output_size=output_sizeself.num_layers=num_layers#实例化预定义的LSTM，三个参数分别是input_size,hidden_size,num_layersself.lstm=nn.LSTM(input_size,hidden_size,num_layers)#实例化全连接线性层，作用是将RNN的输出维度转换成指定的输出维度self.linear=nn.Linear(hidden_size,output_size)#实例化nn中预定义的softmax层，用于从输出层中获得类别的结果self.softmax=nn.LogSoftmax(dim=-1)def forward(self,input1,hidden,c):#注意LLSTM网络的输入有3个张量，尤其不要忘记细胞状态cinput1=input1.unsqueeze(0)#将3个参数输入到LSTM对象中rr,(hn,cn)=self.lstm(input1,(hidden,c))#最后将3个张量结果全部返回，同时rr要经过线性层和softmax的处理return self.softmax(self.linear(rr)),hn,cndef initHiddenAndC(self):#对于LSTM来说，初始化的时候同时要初始化hidden和细胞状态c#hidden和c的形状保持一致c=hidden=torch.zeros(self.num_layers,1,self.hidden_size)return hidden,cclass GRU(nn.Module):def __init__(self,input_size,hidden_size,output_size,num_layers=1):#input_size:代表输入张量x的最后一个维度，hidden_size:代表隐藏层的最后一个维度，output_size:代表指定线性层的输出维度，num_layers:代表RNN网络的层数super(GRU,self).__init__()self.input_size=input_sizeself.hidden_size=hidden_sizeself.output_size=output_sizeself.num_layers=num_layers#实例化预定义的GRU，三个参数分别是input_size,hidden_size,num_layersself.gru=nn.GRU(input_size,hidden_size,num_layers)#实例化全连接线性层，作用是将GRU的输出维度转换成指定的输出维度self.linear=nn.Linear(hidden_size,output_size)#实例化nn中预定义的softmax层，用于从输出层中获得类别的结果self.softmax=nn.LogSoftmax(dim=-1)def forward(self,input1,hidden):#input1代表人名 分类器中的输入张量，形状是1*n_letters，hidden：代表GRU的隐藏层张量，形状是self.num_layers*1*self.hidden_size#注意一点输入到GRU中的张量要求是三维张量，所以需要用unsqueeze（）函数扩充维度input1=input1.unsqueeze(0)#将input1和hidden输入到GRU的实例化对象中，如果num_layers=1,rr恒等于hnrr,hn=self.gru(input1,hidden)#将从GRU中获得的结果通过线性层的变换和softmax层的处理，最终返回结果return self.softmax(self.linear(rr)),hndef initHidden(self):#本函数的作用是用来初始化一个全零的隐藏层张量，维度是3return torch.zeros(self.num_layers,1,self.hidden_size)#参数
input_size=n_letters
n_hidden=128
output_size=n_categories
input1=lineToTensor('B').squeeze(0)
print(input1)
hidden=c=torch.zeros(1,1,n_hidden)rnn=RNN(input_size,n_hidden,output_size)
lstm=LSTM(input_size,n_hidden,output_size)
gru=GRU(input_size,n_hidden,output_size)rnn_output,next_hidden=rnn(input1,hidden)
print('rnn:',rnn_output)
print('rnn_shape:',rnn_output.shape)lstm_output,next_hidden1,c=lstm(input1,hidden,c)
print('lstm',lstm_output)
print('lstm_shape:',lstm_output.shape)gru_output,next_hidden2=gru(input1,hidden)
print('gru:',gru_output)
print('gru_shape',gru_output.shape)

这里输入和实例化的输出打印出来如下

#input1
tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0.]])
#output
rnn: tensor([[[-2.8971, -2.8890, -2.9014, -2.7889, -2.9610, -2.9203, -2.8560,-2.8833, -2.9238, -2.9166, -2.8929, -2.9164, -2.9246, -2.9550,-2.8811, -2.8356, -2.8890, -2.8122]]], grad_fn=<LogSoftmaxBackward>)#output_shape
rnn_shape: torch.Size([1, 1, 18])

这里以RNN的输出为例，LSTM和GRU类似。

3.模型训练

def categoryFromOutput(output):#output:从输出结果中得到指定的类别#需要调用topk()函数，得到最大的值和索引，作为我们的类别信息top_n,top_i=output.topk(1)#从top_i中取出索引的值category_i=top_i[0].item()#从前面已经构造好的all_categories中得到对应语言的类别，返回类别和索引return all_categories[category_i],category_icategory,category_i=categoryFromOutput(gru_output)
#print('category:',category)
#print('category_i:',category_i)def randomTrainingExample():#该函数的作用是用于随机产生训练函数#第一步使用random.choice()方法从all_categories中随机选择一个类别category=random.choice(all_categories)#第二步通过category_lines字典取出category类别对应的名字列表line=random.choice(category_lines[category])#第三步将类别封装成tensorcategory_tensor=torch.tensor([all_categories.index(category)],dtype=torch.long)#将随机取到的名字通过lineToTensor()转换成一个onehot张量line_tensor=lineToTensor(line)return category,line,category_tensor,line_tensor
for i in range(10):category,line,category_tensor,line_tensor=randomTrainingExample()#print('category=',category,'/ line=',line,'/ category_tensor=',category_tensor)
#print('line_tensor=',line_tensor)#定义损失函数，nn.NLLLoss()函数，因为和RNN最后一层的nn.LogSoftmax()逻辑匹配
criterion=nn.NLLLoss()#设置学习率为0.005
learning_rate=0.005def trainRNN(category_tensor,line_tensor):#category_tensor:代表训练数据的标签#line_tensor:代表训练数据的特征#第一步初始化一个RNN隐藏层的张量hidden=rnn.intHidden()#关键的一步：将模型结构中的梯度归零rnn.zero_grad()#循环遍历训练数据中line_tensor中的每一个字符，传入RNN中，并且迭代更新hiddenfor i in range(line_tensor.size()[0]):output,hidden=rnn(line_tensor[i],hidden)#因为rnn的输出是三维张量，为了满足category_tensor,需要进行降维操作loss=criterion(output.squeeze(0),category_tensor)#进行反向传播loss.backward()#显示的更新模型中的所有参数for p in rnn.parameters():#要将参数的张量表示与参数的梯度进行乘法运算并乘以学习率，结果加到参数上，并进行覆盖更新p.data.add_(-learning_rate,p.grad.data)#返回RNN最终的输出结果output,和模型的损失lossreturn output,loss.item()def trainLSTM(category_tensor,line_tensor):#初始化隐藏层张量，以及初始化细胞状态hidden,c=lstm.initHiddenAndC()#先要将LSTM网络的梯度归零lstm.zero_grad()#遍历所有的输入时间步的xifor i in range(line_tensor.size()[0]):#注意LSTM每次输入包含三个张量output,hidden,c=lstm(line_tensor[i],hidden,c)#将预测张量，和目标标签张良输入损失函数中loss=criterion(output.squeeze(0),category_tensor)#进行反向传播loss.backward()#进行参数的显示更新for p in lstm.parameters():p.data.add_(-learning_rate,p.grad.data)return output,loss.item()def trainGRU(category_tensor,line_tensor):#注意GRU网络初始化的时候只需要初始化一个隐藏层的张量hidden=gru.initHidden()#首先将GRU网络的梯度进行清零gru.zero_grad()#遍历所有的输入时间步xifor i in range(line_tensor.size()[0]):output,hidden=gru(line_tensor[i],hidden)#将预测的张量值和真实的张量标签传入损失函数中loss=criterion(output.squeeze(0),category_tensor)#进行反向传播loss.backward()for p in gru.parameters():p.data.add_(-learning_rate,p.grad.data)return output,loss.item()def timeSince(since):#本函数的作用是打印每次训练的耗时，since是训练开始的时间#第一步获取当前的时间now=time.time()#第二步得到时间差s=now-since#第三步计算得到分钟数m=math.floor(s/60)#第四步得到秒数s-=m*60#返回指定格式的耗时return '%dm %ds'% (m,s)#设置训练的迭代次数
n_iters=1000
#设置结果的打印间隔
print_every=50
#设置绘制损失曲线上的制图间隔
plot_every=10def train(train_type_fn):#train_type_fn代表选择哪种模型来训练函数，比如选择trainRNN#初始化储存每个制图间隔损失的列表all_losses=[]#获取训练开始的时间start=time.time()#设置初始间隔的损失值等于0current_loss=0#迭代训练for iter in range(1,n_iters+1):#通过randonTrainExample()函数随机获取一组训练数据和标签category,line,category_tensor,line_tensor=randomTrainingExample()#将训练特征和标签张量传入训练函数中，进行模型的训练output,loss=train_type_fn(category_tensor,line_tensor)#累加损失值current_loss+=loss#如果到了迭代次数的打印间隔if iter %print_every==0:#取该迭代步的output通过函数categoryFromOutput()获取对应的类别和索引guess,guess_i=categoryFromOutput(output)#判断和真实的类别标签进行比较，如果相同则为True，如果不同则为Falsecorrect='True' if guess==category else 'Falese(%s)'%category#打印若干信息print('%d %d%% (s%) %.4f %s / %s %s' % (iter,iter/n_iters*100,timeSince(start),loss,line,guess,correct))#如果到了迭代次数的制图间隔if iter%plot_every==0:#将过去若干轮的平均损失值添加到all_losses列表中all_losses.append(current_loss/plot_every)#将间隔损失值重置为0current_loss=0#返回训练的总损失列表，并返回训练的耗时return all_losses,int(time.time()-start)# #调用train函数，分别传入RNN，LSTM，GRU的训练函数
# #返回的损失列表，以及训练时间
all_losses1,period1=train(trainRNN)
all_losses2,period2=train(trainLSTM)
all_losses3,period3=train(trainGRU)# #绘制损失对比曲线
plt.figure(0)
plt.plot(all_losses1,label="RNN")
plt.plot(all_losses2,color="red",label="LSTM")
plt.plot(all_losses3,color="orange",label="GRU")
plt.legend(loc="upper left")
# #绘制训练耗时的柱状图
plt.figure(1)
x_data=["RNN","LSTM","GRU"]
y_data=[period1,period2,period3]
plt.bar(range(len(x_data)),y_data,tick_label=x_data)

4.模型评估

def evaluateRNN(line_tensor):#评估函数仅有一个参数，line_tensor代表名字的张量标识#初始化一个隐藏层的张量hidden=rnn.initHidden()#将评估数据line_tensor中的每一个字符之歌传入RNN中for i in range(line_tensor.size()[0]):output,hidden=rnn(line_tensor[i],hidden)#返回整个RNN的输出outputreturn output.squeeze(0)def evaluateLSTM(line_tensor):hidden,c=lstm.initHiddenAndC()for i in range(line_tensor.size()[0]):output,hidden,c=lstm(line_tensor[i],hidden,c)return output.squeeze(0)def evaluateGRU(line_tensor):hidden=gru.initHidden()for i in range(line_tensor.size()[0]):output,hidden=gru(line_tensor[i],hidden)return output.squeeze(0)line="Bai"
line_tensor=lineToTensor(line)rnn_output=evaluateRNN(line_tensor)
lstm_output=evaluateLSTM(line_tensor)
gru_output=evaluateGRU(line_tensor)
print('rnn_output:',rnn_output)
print('lstm_outpt:',lstm_output)
print('gru_output:',gru_output)

5.模型预测

def predict(input_line,evaluate_fn,n_predictions=3):#input_line:代表输入字符串名字，evaluate_fn:代表评估的模型函数，RNN，LSTM，GRU，n_predictions:代表需要取得最有可能的n_predictions个结果#首先将输入的名字打印出来print('\n>%s'%input_line)#注意：所有的预测函数都不能改变模型的参数with torch.no_grad():#使用输入的人名转换成张量，然后调用评估函数得到预测的结果output=evaluate_fn(line_tensor(input_line))#从预测的结果中取出top3个最大值及其索引topv,topi=output.topk(n_predictions,1,True)#初始化结果的列表predictions=[]#遍历3个最可能的结果for i in range(n_predictions):#首先从topv中取出概率值value=topv[0][i].item()#然后从topi中取出索引值category_index=topi[0][i].item()#打印概率值及其对应的真实国家名称print('(%.2f)%s'%(value,all_categories[category_index]))#将结果封装成列表格式，添加到最终的结果列表中predictions.append([value,all_categories[category_index]])return predictionsfor evaluate_fn in [evaluateRNN,evaluateLSTM,evaluateGRU]:print('-'*20)predict('Dovesky',evaluate_fn)predict('Jackson',evaluate_fn)predict('Satoshi',evaluate_fn)

---

总结

通过案例学会pytorch中的RNN、LSTM和GRU的代码的写法，实现人名分类任务，巩固了分类模型的训练、评估和预测。重点是将字符转为张量后通过RNN、LSTM和GRU中的参数的理解。同时，需要注意的是张量中的数据类型是float不是long。