跟着问题学10——RNN详解及代码实战

不如语冰

于 2024-09-16 17:36:34 发布

阅读量816

点赞数 24

分类专栏： AI与大模型笔记文章标签：深度学习人工智能 python ai

本文链接：https://blog.csdn.net/weixin_42251091/article/details/142304926

版权

AI与大模型笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1 循环神经网络 Recurrent Neural Network

什么是序列信息呢？通俗理解就是一段连续的信息，前后信息之间是有关系地，必须将不同时刻的信息放在一起理解。

比如一句话，虽然可以拆分成多个词语，但是需要将这些词语连起来理解才能得到一句话的意思。

RNN就是用来处理这些序列信息的任务，比如NLP中的语句生成问题，一句话中的每个词并不是单独存在地，而是根据上下文信息，与他的前后词有关。

如：我吃XXX，吃是一个动词，按照语法规则，那么它后面接名词的概率就比较大，在预测XXX是什么的时候就要考虑前面的动词吃的信息，如果没考虑上下文信息而预测XXX是一个动词的话，动词+动词，很大概率是不符合语言逻辑地。

为了解决这一问题，循环神经网络 RNN也就应运而生了。

1.1循环神经网络 RNN的结构

从特征角度考虑：输入特征是n*1的单维向量（这也是为什么linear层前要把所有特征层展平的原因），然后根据隐含层神经元的数量m将前层输入的特征用m*1的单维向量进行表示（对特征进行了提取变换），单个隐含层的神经元数量就代表网络参数，可以设置多个隐含层；最终根据输出层的神经元数量y输出y*1的单维向量。

从特征角度考虑：输入特征是width*height*channel的张量，然后根据通道channel的数量c会有c个卷积核将前层输入的特征用k*k*c的张量进行卷积（对特征进行了提取变换，k为卷积核尺寸），卷积核的大小和数量k*k*c就代表网络参数，可以设置多个隐含层；每一个channel都代表提取某方面的一种特征，该特征用width*height的二维张量表示，不同特征层之间是相互独立的（可以进行融合）。最终根据场景的需要设置后面的输出。

从特征角度考虑：输入特征是T_seq*feature_size的张量（T_seq代表序列长度），每个时刻t可以类似于CNN的通道channel，只是时刻t的特征（channel）是和t之前时刻的特征（channel）相关联的，所以H_t是由X_t和H_t-1共同作为输入决定的，每个时刻t的特征表示是用feature_size*1的单维向量表示的，每个隐状态H_t类似于一个channel，特征的表示是用hidden_size*1的单维向量表示的，H_t的channel总数就是输入的序列长度，所以一个隐含层是T_seq*hidden_size的张量,如图中所示，同一个隐含层不同时刻的参数W_ih和W_hh是共享的；隐含层可以有num_layers个（图中只有1个）

以t时刻具体阐述一下：

X_t是t时刻的输入，是一个feature_size*1的向量

W_ih是输入层到隐藏层的权重矩阵

H_t是t时刻的隐藏层的值,是一个hidden_size*1的向量

W_hh是上一时刻的隐藏层的值传入到下一时刻的隐藏层时的权重矩阵

Ot是t时刻RNN网络的输出

从上右图中可以看出这个RNN网络在t时刻接受了输入Xt之后，隐藏层的值是St，输出的值是Ot。但是从结构图中我们可以发现St并不单单只是由Xt决定，还与t-1时刻的隐藏层的值St-1有关。

怎么理解这个参数共享呢？

虽然说X{t-1}，X{t}，X{t+1}是表示不同时刻的输入，但是他们输入到RNN网络中的时候并不是作为单独的向量一个一个输入地，而是组合在一起形成一个矩阵输入，然后这个矩阵再通过权重矩阵U的变化，其实是同一时刻输入地，只是计算的先后顺序不同。因此同一个隐藏层中，不同时刻的输入他们的W，V，U参数是共享地。

2 经典的RNN结构

N vs N

在实际应用中，我们还会遇到很多序列形的数据：

如：自然语言处理问题。x1可以看做是第一个单词，x2可以看做是第二个单词，依次类推。

语音处理。此时，x1、x2、x3……是每帧的声音信号。

时间序列问题。例如每天的股票价格等等

序列形的数据就不太好用原始的神经网络处理了。为了建模序列问题，RNN引入了隐状态h（hidden state）的概念，h可以对序列形的数据提取特征，接着再转换为输出。先从h1的计算开始看：

图示中记号的含义是：

圆圈或方块表示的是向量。
一个箭头就表示对该向量做一次变换。如上图中h0和x1分别有一个箭头连接，就表示对h0和x1各做了一次变换。

在很多论文中也会出现类似的记号，初学的时候很容易搞乱，但只要把握住以上两点，就可以比较轻松地理解图示背后的含义。

h2的计算和h1类似。要注意的是，在计算时，每一步使用的参数U、W、b都是一样的，也就是说每个步骤的参数都是共享的，这是RNN的重要特点，一定要牢记。

依次计算剩下来的（使用相同的参数U、W、b）：

我们这里为了方便起见，只画出序列长度为4的情况，实际上，这个计算过程可以无限地持续下去。

我们目前的RNN还没有输出，得到输出值的方法就是直接通过h进行计算：

正如之前所说，一个箭头就表示对对应的向量做一次类似于f(Wx+b)的变换，这里的这个箭头就表示对h1进行一次变换，得到输出y1。

剩下的输出类似进行（使用和y1同样的参数V和c）：

这就是最经典的RNN结构，我们像搭积木一样把它搭好了。它的输入是x1, x2, .....xn，输出为y1, y2, ...yn，也就是说，输入和输出序列必须要是等长的。

由于这个限制的存在，经典RNN的适用范围比较小，但也有一些问题适合用经典的RNN结构建模，如：

计算视频中每一帧的分类标签。因为要对每一帧进行计算，因此输入和输出序列等长。
输入为字符，输出为下一个字符的概率。这就是著名的Char RNN

（详细介绍请参考：The Unreasonable Effectiveness of Recurrent Neural Networks，Char RNN可以用来生成文章，诗歌，甚至是代码，非常有意思）。

N VS 1

有的时候，我们要处理的问题输入是一个序列，输出是一个单独的值而不是序列，应该怎样建模呢？实际上，我们只在最后一个h上进行输出变换就可以了：

这种结构通常用来处理序列分类问题。如输入一段文字判别它所属的类别，输入一个句子判断其情感倾向，输入一段视频并判断它的类别等等。

1 VS N

输入不是序列而输出为序列的情况怎么处理？我们可以只在序列开始进行输入计算：

还有一种结构是把输入信息X作为每个阶段的输入：

下图省略了一些X的圆圈，是一个等价表示：

这种1 VS N的结构可以处理的问题有：

从图像生成文字（image caption），此时输入的X就是图像的特征，而输出的y序列就是一段句子
从类别生成语音或音乐等

N vs M

下面我们来介绍RNN最重要的一个变种：N vs M。这种结构又叫Encoder-Decoder模型，也可以称之为Seq2Seq模型。

原始的N vs N RNN要求序列等长，然而我们遇到的大部分问题序列都是不等长的，如机器翻译中，源语言和目标语言的句子往往并没有相同的长度。

为此，Encoder-Decoder结构先将输入数据编码成一个上下文向量c：

得到c有多种方式，最简单的方法就是把Encoder的最后一个隐状态赋值给c，还可以对最后的隐状态做一个变换得到c，也可以对所有的隐状态做变换。

拿到c之后，就用另一个RNN网络对其进行解码，这部分RNN网络被称为Decoder。具体做法就是将c当做之前的初始状态h0输入到Decoder中：

还有一种做法是将c当做每一步的输入：

由于这种Encoder-Decoder结构不限制输入和输出的序列长度，因此应用的范围非常广泛，比如：

机器翻译。Encoder-Decoder的最经典应用，事实上这一结构就是在机器翻译领域最先提出的
文本摘要。输入是一段文本序列，输出是这段文本序列的摘要序列。
阅读理解。将输入的文章和问题分别编码，再对其进行解码得到问题的答案。
语音识别。输入是语音信号序列，输出是文字序列。
…………

代码

model.py

import torch
import torch.nn as nn

import random
class RNN(nn.Module):
    def __init__(self,feature_size,hidden_size,num_layers,output_size):
        super(RNN,self).__init__()
        self.rnn=nn.RNN(
            input_size=feature_size,hidden_size=hidden_size,\
            num_layers=num_layers,batch_first=True
        )
        for k in self.rnn.parameters():
            nn.init.normal_(k,mean=0.0,std=0.001)
        self.linear=nn.Linear(hidden_size,output_size)
        self.hidden_size=hidden_size

    def forward(self,x,hidden_prev):
        out,hidden_prev=self.rnn(x,hidden_prev)
        print("out1&hidden_prev.shape",out.shape,hidden_prev.shape)
        #view()相当于reshape、resize，重新调整PyTorch 中的 Tensor 形状，若非 Tensor 类型，可使用 data = torch.tensor(data)来进行转换。
       # out=out.view(-1,self.hidden_size)
        print("out2.shape", out.shape)
        out=self.linear(out)
        print("out3.shape", out.shape)
       # out=out.unsqueeze(0)
        print("out4.shape", out.shape)
        return out,hidden_prev

#自己实现一个RNN函数
def rnn_forward(input,weight_ih,weight_hh,bias_ih,bias_hh,h_prev):
    batch_size,T_seq,feature_size=input.shape
    hidden_size=weight_ih.shape[0]
    h_out=torch.zeros(batch_size,T_seq,hidden_size)
    for t in range(T_seq):
        x=input[:,t,:].unsqueeze(2)
      #  print("xt.shape",x.shape)
            #unsqueeze，在给定维度上（从0开始）扩展1个维度，负数代表从后开始数
        weight_ih_batch=weight_ih.unsqueeze(0).tile(batch_size,1,1)
     #   print("weight_ih_batch.shape", weight_ih_batch.shape)
        weight_hh_batch=weight_hh.unsqueeze(0).tile(batch_size,1,1)
     #   print("weight_hh_batch.shape", weight_hh_batch.shape)

        #计算两个tensor的矩阵乘法，torch.bmm(a,b),tensor a 的size为(b,h,w),tensor b的size为(b,w,m)
        # 也就是说两个tensor的第一维是相等的，然后第一个数组的第三维和第二个数组的第二维度要求一样，
        # 对于剩下的则不做要求，输出维度 （b,h,m）
        # weight_ih_batch=batch_size*hidden_size*feature_size
        #x=batch_size*feature_size*1
        #w_times_x=batch_size*hidden_size*feature_size
        ##squeeze，在给定维度（维度值必须为1）上压缩维度，负数代表从后开始数

        w_times_x=torch.bmm(weight_ih_batch,x).squeeze(-1)#
      #  print("w_times_x.shape", w_times_x.shape)

        w_times_h=torch.bmm(weight_hh_batch,h_prev.unsqueeze(2)).squeeze(-1)
      #  print("w_times_h.shape", w_times_h.shape)

        h_prev=torch.tanh(w_times_x+bias_ih+w_times_h+bias_hh)
        print("h_prev.shape", h_prev.shape)
        h_out[:,t,:]=h_prev
        print("h_out.shape", h_out.shape)

    return h_out,h_prev.unsqueeze(0)

if __name__=="__main__":
    # input=torch.randn(batch_size,T_seq,feature_size)
    # h_prev=torch.zeros(batch_size,hidden_size)

    # rnn=nn.RNN(input_size,hidden_size,batch_first=True)
    # output,state_final=rnn(input,h_prev.unsqueeze(0))

    # print(output)
    # print(state_final)
    batch_size, T_seq =10, 30  # 批大小，输入序列长度
    feature_size, hidden_size = 5, 8  #
    num_layers, output_size=1,3
    input = torch.randn(batch_size, T_seq, feature_size)
    h_prev = torch.zeros(1,batch_size, hidden_size)#.unsqueeze(0)
    #my_rnn=RNN(feature_size,hidden_size,num_layers,output_size)
    rnn=nn.RNN(feature_size,hidden_size,batch_first=True)
   # rnn_output, state_final = rnn(input, h_prev.unsqueeze(0))
    # for k,v in rnn.named_parameters():
    #     print(k,v.shape)
    my_rnn_output,my_state_final=rnn_forward(input,rnn.weight_ih_l0,rnn.weight_hh_l0,\
                                             rnn.bias_ih_l0,rnn.bias_hh_l0,h_prev)
    print(my_rnn_output.shape)
    print(my_state_final.shape)

train.py

import torch
import torch.nn as nn
import numpy as np
from models.nlp import RNN
from models.nlp.RNN import *

import datetime
import torch.optim as optim
from matplotlib import pyplot as plt

batch_size=2#批大小
T_seq=30#输入序列长度(时间步）
feature_size=3#输入特征维度

hidden_size=3#隐含层维度
output_size=2#输出层维度

num_layers=1
lr_rate=0.001
epoch=1000
#input 即RNN网络的输入，维度应该为(T_seq, batch_size, input_size)。如果设置batch_first=True，输入维度则为(batch, seq_len, input_size)
input=torch.randn(batch_size,T_seq,feature_size)

def train(input):
    model=RNN(feature_size,hidden_size,num_layers,output_size)
    print("model:\n",model)
    # 设置损失函数
    loss_fn=nn.MSELoss()
    # 设置优化器
    optimizer=optim.Adam(model.parameters(),lr_rate)
    # 初始化h_prev，它和输入x本质是一样的，hidden_size就是它的特征维度
    #维度应该为(num_layers * num_directions, batch, hidden_size)。num_layers表示堆叠的RNN网络的层数。
    # 对于双向RNNs而言num_directions= 2，对于单向RNNs而言，num_directions= 1
    hidden_prev=torch.zeros(1,batch_size,hidden_size)
    loss_plt=[]
    #开始训练
    for iter in range(epoch):
        x = input
        print("x:", x.shape)

        output,hidden_prev=model(x,hidden_prev)
        print("output_size:",output.shape)
        y = torch.randn(batch_size,T_seq,output_size)
        print("y:", y.shape)
        #返回一个新的tensor，从当前计算图中分离下来的，但是仍指向原变量的存放位置,
        # 不同之处只是requires_grad为false，得到的这个tensor永远不需要计算其梯度，不具有grad。
        hidden_prev=hidden_prev.detach()

        loss=loss_fn(output,y)
        model.zero_grad()
        loss.backward()
        optimizer.step()
        if iter%100==0:
            print("iteration:{} loss {}".format(iter,loss.item()))
            loss_plt.append(loss.item())


    plt.plot(loss_plt, 'r')
    plt.xlabel('epcoh')
    plt.ylabel('loss')
    plt.title('RNN-train-loss')

    return hidden_prev, model


if __name__ == '__main__':
    start_time = datetime.datetime.now()
    hidden_pre, model = train(input)
    end_time = datetime.datetime.now()
    print('The training time: %s' % str(end_time - start_time))
    plt.show()

参考资料

8.4. 循环神经网络 — 动手学深度学习 2.0.0 documentation

https://zhuanlan.zhihu.com/p/28054589

29、PyTorch RNN的原理及其手写复现_哔哩哔哩_bilibili