PyTorch深度学习学习记录7_2

vzvzvzv

已于 2022-12-02 13:20:14 修改

阅读量81

点赞数

分类专栏： pytorch 文章标签：深度学习 pytorch 学习

于 2022-12-02 10:26:00 首次发布

本文链接：https://blog.csdn.net/vzvzvzv/article/details/128129602

版权

pytorch 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章目录

GRU(门控循环单元)
pack_padded_sequence
名字分类

GRU(门控循环单元)

LSTM（长短期记忆）的提出是为了解决RNN梯度消失和梯度爆炸的问题，而且由于引入的记忆细胞相比于RNN对长序列的学习有更好的优势，当然就算这样它也只是长一点的”短期记忆“，具体一点就看这吧在这里插入图片描述 GRU是LSTM的一个变体或者说是一个简化版，它减少了LSTM中门的数量从而提高了训练效率。它的前向传播公式如下： $z_t=\sigma(W_z\cdot[h_{t-1,x_t}])$ $r_t=\sigma(W_r\cdot[h_{t-1,x_t}])$ $\widetilde{h}=\tanh(W\cdot[r_t*h_{t-1},x_t])$ $h_t=(1-z_t)*h_{t-1}+z_t*\widetilde{h}$

$r_t$ 被称作复位门，它控制了当前状态中哪些部分用于计算下一个目标状态,在过去状态和未来状态之间引入了附加的非线性效应
$z_t$ 被称为更新门，他像条件渗漏积累器一样可以线性门控任意维度，从而选择将它复制（在sigmoid的一个极端，也就是0）或完全由新的“目标状态值”替换（在sigmoid的另一个极端，也就是1）

pack_padded_sequence

在自然语言处理中经常会碰上序列长短不一的情况，而我们的网络要求的输入又是一个矩阵，因此在词嵌入以前会对原始序列进行填充处理（padding）
在这里插入图片描述虽然解决了长短不一的问题但这里又有一个新的问题，上面这个矩阵为0的部分在词嵌入后也会有一个数值，并在后续的网络中参与计算。这些无中生有的部分我们自然不会希望它去参加运算，这些计算没有意义而且还会侵占计算资源，因此在正式送入网络学习以前还需要对它进行紧压。
那么在PyTorch中就是使用pack_padded_sequence函数完成这一步操作，它所作的操作如下：
在这里插入图片描述上图的batch_sizes是错的（注意这里的batch_sizes是PackedSequence类中的变量，不是我们设定的网络的batch大小），应该是[10,10,10,10,10,9,7,2,1,1]，也就是每一行有效信息的数量。pack_padded_sequence会要求我们输入的序列按长度由大到小排列并给出各序列长度（0也可能是某种信息）。最终它会返回给我们一个PackedSequence的类，它主要有两个变量：data（以上图为例就是剔除掉所有值为0的紧压后的数据）和batch_sizes（这个很好理解由于被压成一列了，又不能每次取相同量的数据，需要一个数组告诉我们的网络一次该取多少数据）

名字分类

在这里插入图片描述这就是这次的任务：通过名字拼写去推测这个名字属于哪一个国家，几个我认为重要的部分都在上面说过了，直接给代码：

import torch
import time
import math
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from torch.nn.utils.rnn import pack_padded_sequence
# 绘图
import matplotlib.pyplot as plt
import numpy as np
# 读取数据
import gzip
import csv


N_CHARS=128 #ASCII
BATCH_SIZE=32
HIDDEN_SIZE=100
N_LAYER=2
N_EPOCHS=100
USE_GPU=torch.cuda.is_available()

class RNNClassifier(torch.nn.Module):
    def __init__(self,input_size,hidden_size,output_size,n_layers=1,bidirectional=True):
        super().__init__()
        self.hidden_size=hidden_size
        #self.input_size=input_size
        self.n_layers=n_layers
        self.n_directions=2 if bidirectional else 1

        self.embedding=torch.nn.Embedding(input_size,hidden_size)
        self.gru=torch.nn.GRU(hidden_size,hidden_size,n_layers,bidirectional=bidirectional)
        self.fc=torch.nn.Linear(hidden_size*self.n_directions,output_size)

    def _init_hidden(self,batch_size):
        h0=torch.zeros(self.n_layers*self.n_directions,batch_size,self.hidden_size)
        return create_tensor(h0)

    def forward(self,input,seq_length):
        #input是每行是每个名字的字母序列
        input=input.t()#转置
        print(input)
        batch_size=input.size(1)
        hidden=self._init_hidden(batch_size)
        embedding=self.embedding(input)

        gru_input=torch.nn.utils.rnn.pack_padded_sequence(embedding,seq_length.cpu())#length是tensor类型的时候必须在cpu上
        print(gru_input)
        output,hidden=self.gru(gru_input,hidden)
        if self.n_directions==2:
            hidden_cat=torch.cat([hidden[-1],hidden[-2]],dim=1)#按照batch_size的维度拼接
        else:
            hidden_cat=hidden[-1]

        fc_output=self.fc(hidden_cat)#输出为BatchSize*Num_countries
        return fc_output


class NameDataset(Dataset):
    def __init__(self,is_train_set=True):
        #super().__init__()
        filename='names_train.csv.gz' if is_train_set else 'names_test.csv.gz'
        with gzip.open(filename,'rt') as f:
            reader=csv.reader(f)
            rows=list(reader)
        self.names=[row[0] for row in rows]
        self.len=len(self.names)
        self.countries=[row[1] for row in rows]
        self.country_list=list(sorted(set(self.countries)))#生成不重复集合并排序
        self.country_dict=self.getCountryDict()
        self.country_num=len(self.country_list)

    def __getitem__(self,index):
        return self.names[index],self.country_dict[self.countries[index]]

    def __len__(self):
        return self.len

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

    def idx2country(self,index):
        return self.country_list[index]
    
    def getCountriesNum(self):
        return self.country_num

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

def make_tensor(names,countries):
    sequences_and_lengths=[name2list(name) for name in names]
    name_sequences=[sl[0] for sl in sequences_and_lengths]
    seq_lengths=torch.LongTensor([sl[1] for sl in sequences_and_lengths])
    countries=countries.long() # countries：国家索引

    #创建name的张量，batchsize x seqlen
    seq_tensor=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]=torch.LongTensor(seq)
    
    seq_lengths,perm_idx=seq_lengths.sort(dim=0,descending=True)#sort会返回值和索引
    seq_tensor=seq_tensor[perm_idx]
    countries=countries[perm_idx]

    return create_tensor(seq_tensor),\
           create_tensor(seq_lengths),\
           create_tensor(countries)#'\'表示换行



def name2list(name):
    arr=[ord(c) for c in name]
    return arr,len(arr)

def create_tensor(tensor):
    if USE_GPU:
        device=torch.device("cuda")
        tensor=tensor.to(device)
    return tensor

def trainModel():
    total_loss=0
    for i,(names,countries) in enumerate(trainloader,1):
        inputs,seq_lengths,target=make_tensor(names,countries)
        output=classifer(inputs,seq_lengths)
        loss=criterion(output,target)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss+=loss.item()
        if i % 10 == 0:
            print(f'[{time_since(start)}] Epoch{epoch}',end='')
            print(f'[{i*len(inputs)}/{len(trainset)}]',end='')
            print(f'loss={total_loss/(i * len(inputs))}')
    return total_loss

def testModel():
    correct=0
    total=len(testset)
    print("evaluating trained...")
    with torch.no_grad():#不计算梯度
        for i,(names,countries) in enumerate(testloader,1):
            inputs,seqlengths,target=make_tensor(names,countries)
            output=classifer(inputs,seqlengths)
            #print(output)
            pred=output.max(dim=1,keepdim=True)[1]#pred的shape为(BatchSize,1)
            correct+=pred.eq(target.view_as(pred)).sum().item()

        percent='%.2f'%(100*correct/total)
        print(f'Test set:Accuracy{correct}/{total} {percent}%')

    return correct/total

trainset=NameDataset(is_train_set=True)
trainloader=DataLoader(trainset,batch_size=BATCH_SIZE,shuffle=True)
testset=NameDataset(is_train_set=False)
testloader=DataLoader(testset,batch_size=BATCH_SIZE,shuffle=False)

N_COUNTRY=trainset.getCountriesNum()


if __name__ =='__main__':
    classifer=RNNClassifier(N_CHARS,HIDDEN_SIZE,N_COUNTRY,N_LAYER)
    if USE_GPU:
        device=torch.device("cuda")
        classifer.to(device)

    criterion=torch.nn.CrossEntropyLoss()
    optimizer=torch.optim.Adam(classifer.parameters(),lr=0.001)

    start=time.time()
    print("训练%d轮"%N_EPOCHS)
    
    acc_list=[]
    epochs=[]
    for epoch in range(1,N_EPOCHS+1):
        trainModel()
        acc = testModel()
        acc_list.append(acc)
        epochs.append(epoch)
    plt.plot(epochs,acc_list)
    plt.ylabel('Acc')
    plt.xlabel('epoch')
    plt.show()