PyTorch深度学习 学习记录7_2

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}])$$$$h=\tanh (W\cdot [r_t\ast h_{t-1},x_t])$$$$h_t=(1-z_t)\ast h_{t-1}+z_t\ast 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()

至此b站刘二大人的《PyTorch深度学习实践》完结合集就结束了，对于纯小白的我来说帮助很大，接下来就是继续去找其他资料去学习了，说起来之前说的课件忘记放了。
课件下载
密码：cxe4