pytorch入门10--循环神经网络（RNN）

灰太狼 2024-03-25 15:32 51阅读 0赞

补充：torch.randn()函数返回一个张量，包含了从正态分布（均值为0，方差为1）中抽取的一组随机数。张量的形状由参数决定，参数个数任意。  
例如：torch.randn(3,4,5)返回一个shape为\[3,4,5\]即的张量，张量的元素满足标准正态分布。  
![在这里插入图片描述][a29f2b026d7a466cacc2d397a605d959.png]

一、简要介绍  
RNN适用了处理序列性的数据，并利用权重共享机制（即一个RNN网络使用多次）。序列性数据用一个例子来理解，比如我们想要预知某一天是否会下雨，我们采集了大量天数的气象信息，气象信息包括温度、气压和降雨，我们分四天为一组，前三天（用x1,x2,x3表示)就是一个序列，第四天作为已知结果，通过第四天的已知结果与模型的估计值进行比较求损失、求梯度来优化模型参数。使用序列模型的意义在于数据前后之间有一定的联系或影响，即x2的数据依赖于x1,x3的数据依赖于x2，x4的数据依赖于x3，即前三天气象信息与是否降雨对第四天有一定的影响（天气的变化是比较缓和的，很少出现断崖式的变化，所以可以根据前些天的天气预知后一天的天气）。注意，这里的x1,x2,x3是一个序列，而x1,x2,x3三个张量又各自包含三个特征值，分别表示温度、气压和天气。  
除了天气、股市等信息外，自然语言也是具有序列关系的信息。

二、RNN神经网络  
RNN cell本质上是一个也是线性层(Linear Layer，进行w*x+b的线性变换)。区别在于RNN cell的网络是共享的，即使用多次。  
![在这里插入图片描述][29e98c4503514489a59b0a596bc28ebf.png]  
上图中的左边部分是RNN模型的一般书写模式，右边部分是其展开模式。，这里的X1,X2,X3,X4就是之前提到过的序列。h0可以是初始化全为0的张量。先将X1和h0（h表示hidden,即隐层）输入RNN cell（RNN 神经网络），输出结果为h1,再将x2和h1（即RNN cell的两个输出是一样的，都是hi）输入**相同**的RNN cell输出结果h2，依次类推，最终输出结果h4。可以看出h2的结果融合了x1与x2的信息，h3的结果融合了x1、x2与x3的信息，h4的结果融合了x1、x2、x3与x4的信息。  
RNN网络的每一个隐藏层的具体过程：  
![在这里插入图片描述][776d8bac25864eff88b0cd9cd26dc10f.png]  
input\_size表示输入的维度，输入Xt先做一个线性变换，h(t-1)是上一层隐层的输出，也对其做一个线性变换，再将 两个线性变换的结果相加，上图中的Wih为的shape为\[hidden\_size, input\_size\]，使得Wih*Xt+bih的结果为\[hidden\_size,1\]；Whh为的shape为\[hidden\_size, hidden\_size\]。最后使用激活函数tanh()使结果位于（-1，1）的区间内，ht为该隐层的输出。  
实际上，两个线性运算可以写成一个线性运算：  
![在这里插入图片描述][4983dc38679d4e4796e2a143b50f8b65.png]  
RNN cell的公式：  
![在这里插入图片描述][f46a82446a0141488b17c1e920501b83.png]  
三、代码实现  
自定义一个RNN cell,只需输入参数input\_size（即输入值的维度，即Xi有几个分量）和hidden\_size（隐藏层的维度，即hi有几个分量）。

# 声明一个RNN cell
    cell = torch.nn.RNNCell(input_size = input_size, hidden_size = hidden_size)
    # 调用RNN cell，并把下列语句写下一个for循环里（实现序列多次调用RNN cell）
    hidden = cell(input, hidden)

注意：input.shape为\[batch, input\_size\],batch为批量的大小，即数据集的大小，即input.shape=batch.size\*input\_size的二维张量，hidden.shape为\[batch, hidden\_size\]。输出的hidden.shape为\[batch, hidden\_size\]。  
实例：  
（1)使用RNN cell  
RNN的输入张量的shape为\[batchSize, inputSize\],输出张量（隐层）的维度为\[batchSize, hiddenSize\]。数据集（dataset）的shape定义为\[seqLen,batchSize,inputSize\]，这里的seqLen即为序列长度。

import torch
    
    batch_size = 1 # 批量大小
    seq_len = 3
    input_size = 4
    hidden_size = 2
    
    cell = torch.nn.RNNCell(input_size = input_size, hidden_size = hidden_size)
    
    dataset = torch.randn(seq_len,batch_size,input_size)
    hidden = torch.zeros(batch_size,hidden_size) # h0
    
    # 对dataset进行遍历，每次取出序列中的一个元素，即先取x1,再去x2,最后取x3
    for idx,input in enumerate(dataset):
        print('=' * 20,idx,'='*20)
        print('Input size:',input.shape)
        
        hidden = cell(input, hidden) # cell中的hidden为上一次输出的隐层，等号左边的hidden为这一次的隐层。
        
        print('outputs size',hidden.shape)
        print(hidden)

（2）使用RNN  
![在这里插入图片描述][517c88cca3d0462e9c270c191981a889.png]

# num_layers表示隐层的层数（后面图解）
    cell = torch.nn.RNN(input_size = input_size, hidden_size = hidden_size, num_layers= num_layers)
    # 调用
    out, hidden = cell(inputs,hidden) #input为输入的序列[x1,x2,x3,..,xN]，input.shape为[seqLen, batch, input_size]
    # cell中的hidden表示h0,out表示[h1,h1,...,hN)，等号左边的hidden为hN。hidden.shape为[numLayers, batch, hidden_size]
    # output.shape为[seqLen, batch, hiddden_size]

![在这里插入图片描述][8c565dae18f944659c7c780b9bc40746.png]  
上图的numLayers即为3，表示三层隐藏层，同一种颜色的RNN cell为同一层（其实同一种颜色是同一个RNN cell）。

import torch
    
    batch_size = 1 # 批量大小
    seq_len = 3
    input_size = 4
    hidden_size = 2
    num_layers = 1
    
    cell = torch.nn.RNN(input_size = input_size, hidden_size = hidden_size,num_layers=num_layers)
    
    inputs = torch.zeros(seq_len,batch_size,input_size)
    hidden = torch.zeros(num_layers,batch_size,hidden_size)
    
    out, hidden = cell(inputs,hidden)
    
    print('Output size:', output.size)
    print('Output:', output)
    print('Hidden size:', hidden.size)
    print('Hidden:', hidden)

四、实例  
![在这里插入图片描述][25e9c1e5a2464a08a46c9635adde47ac.png]  
训练目标，将输入的“hello"经过RNN网络根据每一个隐藏层的结果输出为“ohlol”。  
1.将单词转化为张量  
使用独热（one-hot)编码：  
![在这里插入图片描述][c801c0c6a113445595a8123975772563.png]  
对于hello的每一个字符都对应一个索引值，将hello转化为索引值得数组，再根据独热编码得方法转化为等长得向量，可以用一个一维含四个特征值得张量表示。注意每一次RNNcell输出的hi是一个含有四个元素的张量，通过softmax函数决定是输出结果是e,h,l,o中的哪一类：  
![在这里插入图片描述][0f5597eaeee441a093280f482347a659.png]

import torch
    
    input_size = 4
    hidden_size = 4
    batch_size = 1
    
    #准备数据
    idx2char = ['e','h','l','o']
    x_data = [1,0,2,2,3]
    y_data = [3,1,2,3,2]
    
    # 便于查询
    one_hot_lookup = [[1,0,0,0],
                     [0,1,0,0],
                     [0,0,1,0],
                     [0,0,0,1]]
    x_one_hot = [one_hot_lookup[x] for x in x_data] # 根据x_data的索引序列生成每一位字符的独热编码（后面详解）
    
    inputs = torch.Tensor(x_one_hot).view(-1,batch_size,input_size)
    labels = torch.LongTensor(y_data).view(-1,1) # torch.LongTensor()用于创建长整型的张量，参数是多维数组。
    # torch.view()和torch.reshape()都是用来重塑tensor的shape的，view()只适用于满足连续性条件的tensor进行操作，而reshape同时还可以对不满足连续性条件的tensor进行操作。
    
    # 定义模型
    class Model(torch.nn.Module):
        def __init__(self,input_size,hidden_size,batch_size):
            super(Model,self).__init__()
            self.batch_size = batch_size
            self.input_size = input_size
            self.hidden_size = hidden_size
            self.rnncell = torch.nn.RNNCell(input_size = self.input_size,
                                           hidden_size=self.hidden_size)
            
        def forward(self,input,hidden):
            hidden = self.rnncell(input,hidden)
            return hidden
        
        # 生成初始的h0
        def init_hidden(self):
            return torch.zeros(self.batch_size,self.hidden_size)
        
        
    net = Model(input_size,hidden_size,batch_size)
    
    # 损失函数
    criterion = torch.nn.CrossEntryLoss()
    # 优化器
    optimizer = torch.optim.Adam(net.parameters(),lr=0.1)
    
    # 训练模型
    for epoch in range(15):
        loss = 0
        optimizer.zero_grad()
        hidden = net.init_hidden()
        print("Predicted stringL:",end='')
        for input,label in zip(inputs,labels):
            hidden = net(input,hidden)
            loss += criterion(hidden,label)
            _,idx = hiddden.max(dim=1)
            print(idx2char[idx.item()],end='')
        loss.backward()
        optimizer.step()
        print(',Epoch[%d/15] loss=%.4f' % (epoch+1,loss.item()))

补充：(1)torch.Tensor()与torch.tensor()的区别  
![在这里插入图片描述][409d30ddabfb4a4db79f0d3474a19cac.png]  
（2）使用for循环来生成多维数组  
下图中x\_data中的每一个x作为下标值找到对应one\_hot\_lookup中的元素，最后生成一个多维数组。  
![在这里插入图片描述][26369ff52d5842eb8c98bdafc9c5ab03.png]

使用RNN的书写形式：

# 定义模型
    class Model(torch.nn.Module):
        def __init__(self,input_size,hidden_size,batch_size，numlayers=1):
            super(Model,self).__init__()
            self.numlayers = num_layers
            self.batch_size = batch_size
            self.input_size = input_size
            self.hidden_size = hidden_size
            self.rnn = torch.nn.RNN(input_size = self.input_size,
                                           hidden_size=self.hidden_size,
                                           num_layers = num_layers)
            
        def forward(self,input):
            hidden = torch.zeros(self.num_layers,self.batch_size,slef.hidden_size)
            out,_=self.rnn(input,hidden)
            return out.view(-1,self.hidden_size) # out.shape为[seqLen*batchSize,hiddenSize]
        
        # 生成初始的h0
        def init_hidden(self):
            return torch.zeros(self.batch_size,self.hidden_size)
        
    net = Model(input_size,hidden_size,batch_size)
    # 损失函数
    criterion = torch.nn.CrossEntryLoss()
    # 优化器
    optimizer = torch.optim.Adam(net.parameters(),lr=0.1)
    
    # 训练模型
    for epoch in range(15):
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs,labels)
        loss.backwrd()
        optimizer.step()
        _,idx= outputs.max(dim=1)
        idx = idx.data.numpy()

2.使用嵌入层代替独热编码（embedding)  
独热编码有许多缺点，维度大、张量稀疏、是硬编码（不是通过提取特征得到的）。因此想到使用低维的（lower-dimension），稠密的（dense），学习到的张量(learn from data）。  
embedding即把一个高位的、稀疏的样本映射到一个低维的、稠密的空间（即数据降维）：  
![在这里插入图片描述][6168bfe4e53946e9965bee66eb84d223.png]  
加入嵌入层后：  
![在这里插入图片描述][681cfcc10a4645f1b2765db1ed229939.png]

加入嵌入层的网络结构：

# 参数
    num_class = 4
    input_size = 4
    hidden_size = 8
    embedding_size = 10
    num_layers = 2
    batch_size = 1
    seq_len = 5
    
    #准备数据
    idx2char = ['e','h','l','o']
    x_data = [1,0,2,2,3]
    y_data = [3,1,2,3,2]
    
    inputs = torch.LongTensor(x_data)
    labels = torch.LongTensor(y_data).view(-1,1)
    
    class Model(torch.nn.Module):
        def __init__(self):
            super(Model,self).__init__()
            self.emb = torch.nn.Embedding(input_size,embedding_size) # 加入嵌入层
            self.rnn = torch.nn.RNN(input_size =embedding_size,
                                           hidden_size=self.hidden_size,
                                           num_layers = num_layers,
                                   batch_first=True)# batch_first=True设为true时后面输入的数据的张量的input.shape为[batchSize,seqLen,input_size],即把训练维度与样本序列进行交换,这里的input_size转变为embedding_size。
                                                   # output.shape为[batchSize,seqLen,hiddenSize] 
            self.fc = torch.nn.Linear(hidden_size,num_class) # 完成输出类别的变换
            
        def forward(self,x):
            hidden = torch.zeros(num_layers,x.size(0),slef.hidden_size)
            x = self.emb(x)
            x,_=self.rnn(x,hidden)
            x =self.fc(x)
            return x.view(-1,num_class) # out.shape为[seqLen*batchSize,hiddenSize]
        
        # 生成初始的h0
        def init_hidden(self):
            return torch.zeros(self.batch_size,self.hidden_size)
    net = Model()
    
    criterion = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(net.parameters(),lr=0.05)
    
    for epoch in range(15):
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs,labels)
        loss.backward()
        optimizer.step()
        _,idx = outputs.max(dim=1)
        idx = idx.data.numpy()
        print('Predicted:',''.join([idx2char[x] for x in idx]},end='')
        print(',Epoch[%d/15] loss=%.3f' % (epoch +1,loss.item())

对于嵌入层可以通过下面的例子来理解：  
![在这里插入图片描述][9327c4d97b36448cb65d0c83f1a65581.png]

嵌入层可以增大张量的维度，是通过查询的方式。比如上图中的x\_data是一个shape为\[5\]的张量，通过对每一个元素（1，0，2，2，3）来找到一个对应的张量（张量的元素个数由embedding\_size决定，为10），这样x\_data就转化为了inputs，其shape为\[5,10\]。  
注意：同一个嵌入层对象多次输入一个张量对应唯一的一个输出结果，同一个张量输入不同的嵌入层对象结果不同。  
![在这里插入图片描述][224abef772bb4c1ebad5333d88a37358.png]  
![在这里插入图片描述][2f9cc888b744412b8b2d2d022fb993f8.png]

[a29f2b026d7a466cacc2d397a605d959.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d99b35665bc74ab0917dc9099ff58791.png
[29e98c4503514489a59b0a596bc28ebf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c30bb868330a4685acf1a58e02179a3f.png
[776d8bac25864eff88b0cd9cd26dc10f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a520f16da19a4b698e6435e810fadca3.png
[4983dc38679d4e4796e2a143b50f8b65.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3a6b3a18911a4f56974aa2faadb1ce00.png
[f46a82446a0141488b17c1e920501b83.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d5b0e4a1de3e43ddae01d9f61460a245.png
[517c88cca3d0462e9c270c191981a889.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/37227445f39e41bda87d2b7393c0f63b.png
[8c565dae18f944659c7c780b9bc40746.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1285a67430cf41ecbdc4208759256c6f.png
[25e9c1e5a2464a08a46c9635adde47ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/188ddcb23b0b4e9692dcf41ac2fd83ff.png
[c801c0c6a113445595a8123975772563.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b7852713c2b7482d8cbff6946f865c29.png
[0f5597eaeee441a093280f482347a659.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/308a5360ba614ec3b7ca3c6339f09031.png
[409d30ddabfb4a4db79f0d3474a19cac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/af9f214ab6964031a661ec6ab263dcf4.png
[26369ff52d5842eb8c98bdafc9c5ab03.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/cbb6532aa19d459699cc0c923fa0b8e2.png
[6168bfe4e53946e9965bee66eb84d223.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ed829ad91dc041829885c15c46306220.png
[681cfcc10a4645f1b2765db1ed229939.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a6d5f6a825fb4109bde9d972be19bc4e.png
[9327c4d97b36448cb65d0c83f1a65581.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/525c5f293af846fb9141171d318f7fa6.png
[224abef772bb4c1ebad5333d88a37358.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b49e403ab5e64f1d9db5f634a59fca7f.png
[2f9cc888b744412b8b2d2d022fb993f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f30df4fce59b45368e4d086b5f27a932.png