PyTorch深度学习实践循环神经网络高级篇

用RNN做一个分类器&＃xff0c;现在有一个数据集&＃xff0c;数据集里有人名和对应的国家&＃xff0c;我们需要训练一个模型&＃xff0c;输入一个新的名字&＃xff0c;模型能预测出是基于哪种语言的&＃xff08;18种不同的语言&＃xff0c;18分类&＃xff09;&＃xff0c;

在自然语言处理中&＃xff0c;通常先把词或字编程一个one-hot向量&＃xff0c;one-hot向量维度高&＃xff0c;而且过于稀疏&＃xff0c;所以
一般来说呀先通过嵌入层&＃xff08;Embed&＃xff09;把one-hot向量转化成低维的稠密向量&＃xff0c;然后经过RNN&＃xff0c;隐层的输出不一定和最终要求的目标一致&＃xff0c;所以要用一个线性层把输出映射成和我们的要求一致&＃xff0c;我们的需求是输出名字所属的语言分类&＃xff0c;我们对01-05这些输出是没有要求的&＃xff0c;即不需要对所有的隐层输出做线性变换&＃xff0c;为了解决这个问题&＃xff0c;我们可以把网络变得更简单&＃xff0c;如下图

输入向量经过嵌入层之后&＃xff0c;输入到RNN,输出最终的隐层状态&＃xff0c;最终的隐层状态经过一个线性层&＃xff0c;我们分成18个类别&＃xff0c;就可以实现名字分类的任务了
输入的每一个名字都是一个序列&＃xff0c;序列的长短是不一样的

模型的处理过程

输入是数据集里面的名字&＃xff0c;经过模型之后我们得到相应的国家

classifier &＃061; RNNClassifier(N_CHARS, HIDDEN_SIZE, N_COUNTRY, N_LAYER)


N_CHARS&＃xff1a;字符数量&＃xff08;输入的是英文字母&＃xff0c;每一个字符都要转变成独热向量&＃xff0c;所以这是我们自己设置的字母表的大小&＃xff09;
HIDDEN_SIZE&＃xff1a;隐层数量&＃xff08;GRU输出的隐层的维度&＃xff09;
N_COUNTRY&＃xff1a;一共有多少个分类
N_LAYER&＃xff1a;设置用基层的GRU

for epoch in range(1, N_EPOCHS &＃043; 1):
# Train cycle
trainModel()
acc &＃061; testModel()
acc_list.append(acc)


在每一个epoch做一次训练和测试&＃xff0c;把测试的结果添加到 acc_list列表&＃xff08;可以用来绘图&＃xff0c;可以看到训练的损失是如何变化的&＃xff09;
准备数据–定义模型–定义损失函数和优化器–写训练过程

准备数据

拿到的是字符串&＃xff0c;先转变成序列&＃xff0c;转成列表&＃xff0c;列表里面的每一个数就是名字里面的每一个字符
接下来做词典&＃xff0c;可以用ASCII表&＃xff0c;ASCII表是128个字符&＃xff0c;我们把字典长度设置成128&＃xff0c;求每一个字符对应的ASCII值&＃xff0c;拼成我们想要的序列
上图中的最右表中每一个数并不是一个数字&＃xff0c;而是一个独热向量例如 77。就是一个128维的向量&＃xff0c;第77个数的值为1&＃xff0c;其他的值都是0.
对于Embed(嵌入层)来说&＃xff0c;只要告诉嵌入层第几个维度是1就行了&＃xff0c;所以只需要把ASCII值放在这就行了。

序列长短不一怎么解决&＃xff1f;

如上图左&＃xff0c;每一行是一个序列&＃xff0c;我们解决序列长短不一的方法是padding&＃xff08;因为张量必须保证所有的数据都贴满&＃xff0c;不然就不是张量&＃xff09;&＃xff0c;如右图&＃xff0c;就是在做一个batch的时候&＃xff0c;我们看这一个batch里面哪一个字符串的长度最长&＃xff0c;然后把其他字符串填充成和它一样的长度&＃xff0c;就能保证可以构成一个张量&＃xff0c;因为每个维度的数量不一样是没办法构成张量的

分类的处理

我们需要把各个分类&＃xff08;国家&＃xff09;转成一个分类索引&＃xff0c;不嫩直接用字符串作为我们的分类标签

读取数据集

filename &＃061; &＃039;data/names_train.csv.gz&＃039; if is_train_set else &＃039;data/names_test.csv.gz&＃039; with gzip.open(filename, &＃039;rt&＃039;) as f:
reader &＃061; csv.reader(f)
rows &＃061; list(reader) #一个元组


Reading data from .gz file with package gzip and csv . gzip和csv这两个包可以帮我们读取gz文件
有很多种不同的方式可以访问数据集&＃xff0c;比如有些数据集不是.gz,而是.pickle就可以用pickle包&＃xff0c;还有HDFS,HD5得用HDFS的包读取&＃xff0c;根据拿到的数据类型不一样&＃xff0c;用相应的包把数据读出来。
我们读到的rows是一个元组&＃xff0c;形式是&＃xff08;name,language&＃xff09;

self.names &＃061; [row[0] for row in rows] #先把名字都取出来
self.len &＃061; len(self.names) #记录样本数量
self.countries &＃061; [row[1] for row in rows]#把标签取出来
self.country_list &＃061; list(sorted(set(self.countries)))#set是先把列表变成集合&＃xff0c;即去除重复的元素&＃xff0c;
#这样每一个语言就只剩下一个实例&＃xff0c;然后用sorted排序变成列表&＃xff08;如上图&＃xff09;
self.country_dict &＃061; self.getCountryDict() #根据列表&＃xff0c;把列表转变成词典


def __getitem__(self, index):
return self.names[index], self.country_dict[self.countries[index]]
#__getitem__根据输入的名字找到对应国家的索引
#返回两项&＃xff0c;一项是输入样本
#拿到输入样本之后&＃xff0c;先把国家取出来&＃xff0c;然后根据国家去查找对应的索引


def getCountryDict(self):
country_dict &＃061; dict()
for idx, country_name in enumerate(self.country_list, 0):
country_dict[country_name] &＃061; idx
return country_dict


数据准备

trainset &＃061; NameDataset(is_train_set&＃061;True)
trainloader &＃061; DataLoader(trainset, batch_size&＃061;BATCH_SIZE, shuffle&＃061;True)
testset &＃061; NameDataset(is_train_set&＃061;False)
testloader &＃061; DataLoader(testset, batch_size&＃061;BATCH_SIZE, shuffle&＃061;False)
N_COUNTRY &＃061; trainset.getCountriesNum()


模型设计

class RNNClassifier(torch.nn.Module):
def __init__(self, input_size, hidden_size, output_size, n_layers&＃061;1, bidirectional&＃061;True): super(RNNClassifier, self).__init__()
self.hidden_size &＃061; hidden_size
self.n_layers &＃061; n_layers
self.n_directions &＃061; 2 if bidirectional else 1
self.embedding &＃061; torch.nn.Embedding(input_size, hidden_size)
self.gru &＃061; torch.nn.GRU(hidden_size, hidden_size, n_layers, bidirectional&＃061;bidirectional) self.fc &＃061; torch.nn.Linear(hidden_size * self.n_directions, output_size)
def _init_hidden(self, batch_size):
hidden &＃061; torch.zeros(self.n_layers * self.n_directions, batch_size, self.hidden_size) return create_tensor(hidden)


__init__函数的参数
input_size用于构建嵌入层

双向循环神经网络

lstm gru rnn 都有双向的
下图是单向的RNN,其中 RNN Cell共享权重和偏置&＃xff0c;所以w和b是一样的&＃xff0c;Xn-1的输出只包含它之前的序列的信息&＃xff0c;即只考虑过去的信息&＃xff0c;实际上在自然语言处理&＃xff08;NLP&＃xff09;我们还需要考虑来自未来的信息
正向算完之后&＃xff0c;再反向算一下&＃xff0c;然后把算出来的隐层输出做拼接&＃xff0c;如下图 hN是h(0,b)和h(N,f)拼接起来的&＃xff0c;h(N-1)是把h&＃xff08;1,b&＃xff09;和h(N-1,f)拼接起来&＃xff0c;这样的循环神经网络叫双向循环神经网络
最终&＃xff0c;反向得到一个h(N,b)

每一次调用GRU会输出out和hidden两个项&＃xff0c;其中hidden包含的项如下

self.fc &＃061; torch.nn.Linear(hidden_size * self.n_directions, output_size)
%在线性层的时候要把hidden_size转换成输出的维度&＃xff0c;所以要乘以一个self.n_directions&＃xff0c;
%双向RNN的self.n_directions是2&＃xff0c;单向RNN是1


def _init_hidden(self, batch_size):
hidden &＃061; torch.zeros(self.n_layers * self.n_directions, batch_size, self.hidden_size)
return create_tensor(hidden)
%_init_hidden的作用是创建一个全0的初始隐层&＃xff0c;根据输入的batch_size构建全0的张量&＃xff0c;
张量的第一个维度是n_layers * self.n_directions&＃xff0c;第二个维度是 batch_size&＃xff0c;第三个维度是self.hidden_size
%这是一个工具函数&＃xff0c;训练的时候可以调用


双向循环神经网络的forward过程

def forward(self, input, seq_lengths):
# input shape : B x S - > S x B&＃xff08;S:sequential(序列)&＃xff0c;B&＃xff1a;batch&＃xff09;
input &＃061; input.t() %矩阵转置input shape : B x S - > S x B
batch_size &＃061; input.size(1) %保存batch_size用来构建最初始的隐层
hidden &＃061; self._init_hidden(batch_size) %创建隐层
embedding &＃061; self.embedding(input) %把input扔到嵌入层里面&＃xff0c;做嵌入
%嵌入之后&＃xff0c;输入的维度就变成了&＃xff08;&＃x1d460;&＃x1d452;&＃x1d45e;&＃x1d43f;&＃x1d452;&＃x1d45b;,&＃x1d44f;&＃x1d44e;&＃x1d461;&＃x1d450;ℎ&＃x1d446;&＃x1d456;&＃x1d467;&＃x1d452;,ℎ&＃x1d456;&＃x1d451;&＃x1d451;&＃x1d452;&＃x1d45b;&＃x1d446;&＃x1d456;&＃x1d467;&＃x1d452;&＃xff09;
# pack them up
gru_input &＃061; pack_padded_sequence(embedding, seq_lengths)
output, hidden &＃061; self.gru(gru_input, hidden) %第二个hidden是初始的隐层&＃xff0c;
%我们想要得到的是第一个hidden的值
if self.n_directions &＃061;&＃061; 2:
hidden_cat &＃061; torch.cat([hidden[-1], hidden[-2]], dim&＃061;1)
%如果是双向的循环神经网络&＃xff0c;会有两个hidden&＃xff0c;需要把他们拼接起来
else:
hidden_cat &＃061; hidden[-1] %如果是单向的循环神经网络&＃xff0c;就只有1个hidden
fc_output &＃061; self.fc(hidden_cat) %把最后的隐层输出经过全连接层变换成我们想要的维度做分类
return fc_output


input &＃061; input.t()%矩阵转置input shape : B x S - > S x B
%功能如下图


embedding &＃061; self.embedding(input) %把input扔到嵌入层里面&＃xff0c;做嵌入
%嵌入之后&＃xff0c;输入的维度就变成了&＃xff08;&＃x1d460;&＃x1d452;&＃x1d45e;&＃x1d43f;&＃x1d452;&＃x1d45b;,&＃x1d44f;&＃x1d44e;&＃x1d461;&＃x1d450;ℎ&＃x1d446;&＃x1d456;&＃x1d467;&＃x1d452;,ℎ&＃x1d456;&＃x1d451;&＃x1d451;&＃x1d452;&＃x1d45b;&＃x1d446;&＃x1d456;&＃x1d467;&＃x1d452;&＃xff09;


为了提高运行效率&＃xff0c;GRU支持一种提速&＃xff0c;尤其是面对序列长短不一的时候&＃xff0c;在pyTorch中&＃xff0c; pack_padded_sequence的功能如下

先根据长度排序
排好序之后&＃xff0c;再经过嵌入层
使用pack_padded_sequence做成下面这样的数据&＃xff0c;GRU的运算效率更高哦(即把没有计算意义的padding 0去掉)
所以pack_padded_sequenceh函数需要输入数据的长度 seq_lengths

gru_input &＃061; pack_padded_sequence(embedding, seq_lengths)


GRU根据上图的batch_sizes就决定每一时刻取多少行&＃xff0c;GRU的工作效率就提高了

由名字转换成Tensor的过程

过程如下&＃xff1a;
1&＃xff1a;字符串—>字符—>相应的ASCII值
然后做padding填充
填充之后转置
转置之后排序

def make_tensors(names, countries):
sequences_and_lengths &＃061; [name2list(name) for name in names]
%name2list(name)把每一个名字都变成一个ASCII列表
name_sequences &＃061; [sl[0] for sl in sequences_and_lengths]
%单独拿出列表
seq_lengths &＃061; torch.LongTensor([sl[1] for sl in sequences_and_lengths])
%单独拿出列表长度&＃xff0c;并转换成LongTensor
countries &＃061; countries.long()
%countries本身就是一个整数&＃xff0c;我们再转换成long张量
# make tensor of name, BatchSize x SeqLen
seq_tensor &＃061; torch.zeros(len(name_sequences), seq_lengths.max()).long()
for idx, (seq, seq_len) in enumerate(zip(name_sequences, seq_lengths), 0):
seq_tensor[idx, :seq_len] &＃061; torch.LongTensor(seq)
# sort by length to use pack_padded_sequence
seq_lengths, perm_idx &＃061; seq_lengths.sort(dim&＃061;0, descending&＃061;True)
seq_tensor &＃061; seq_tensor[perm_idx]
countries &＃061; countries[perm_idx]
return create_tensor(seq_tensor), \
create_tensor(seq_lengths),\
create_tensor(countries)


def name2list(name):
arr &＃061; [ord(c) for c in name]
return arr, len(arr)
%name2list返回两个&＃xff0c;一个是元组&＃xff0c;代表列表本身&＃xff0c;一个是列表的长度


name_sequences &＃061; [sl[0] for sl in sequences_and_lengths]
%单独拿出列表


# make tensor of name, BatchSize x SeqLen
seq_tensor &＃061; torch.zeros(len(name_sequences), seq_lengths.max()).long()
for idx, (seq, seq_len) in enumerate(zip(name_sequences, seq_lengths), 0):
seq_tensor[idx, :seq_len] &＃061; torch.LongTensor(seq)


我们是先构建了一个全0的张量&＃xff0c;然后把值复制进去

# sort by length to use pack_padded_sequence
seq_lengths, perm_idx &＃061; seq_lengths.sort(dim&＃061;0, descending&＃061;True)
seq_tensor &＃061; seq_tensor[perm_idx]
countries &＃061; countries[perm_idx]


按照序列的长度进行排序&＃xff0c;pyTorch的sort函数返回两个值&＃xff0c;一个是排完序后的序列&＃xff0c;另一个是么排完序之后对应元素的id&＃xff08;索引&＃xff09;&＃xff0c;我们可以根据这个索引&＃xff0c;对序列的张量以及国家标签进行排序

return create_tensor(seq_tensor), \
create_tensor(seq_lengths),\
create_tensor(countries)
def create_tensor(tensor):
if USE_GPU:
device &＃061; torch.device("cuda:0")
tensor &＃061; tensor.to(device)
return tensor


接下来把需要的序列的张量&＃xff0c;每一个序列的长度&＃xff0c;标签都转化成一个Tensor
create_tensor主要是判定是否需要使用GPU&＃xff0c;要用GPU的haul就把Tensor放到Cuda上&＃xff0c;否则就不做任何操作

训练过程

训练&＃xff1a;1 前向&＃xff1a;计算模型输出-----计算损失–梯度清零—反向传播—更新梯度

测试模型&＃xff1a;测试模型是不需要求梯度的

with torch.no_grad():


本文地址：https://blog.csdn.net/ningmengshuxiawo/article/details/109149735