循环神经网络RNN和长短期记忆网络LSTM学习笔记

最新推荐文章于 2024-04-01 23:05:53 发布
最新推荐文章于 2024-04-01 23:05:53 发布
阅读量1.1k 收藏 9
点赞数 2
分类专栏： 深度学习笔记 文章标签： 神经网络 人工智能 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29380039/article/details/107893075
版权

文章目录

一、RNN

首先思考一个问题，为什么需要RNN？
神经网络只能处理孤立的的输入，每一个输入之间是没有关系的。但是，某些任务需要能够更好的处理序列的信息，即前面的输入和后面的输入是有关系的，例如音频、视频、句子等。
RNN较神经网络的不同是它将上一时刻的输出作为输入一起传入网络中，从而将输入联系起来。
在这里插入图片描述

在这里插入图片描述
序列依次进入网络中，之前进入序列的数据会保存信息而对后面的数据产生影响。图中X0X1…Xn不是同一时刻输入网络的，图中代表的是时间维度，实际上整个网络只有一个A单元，例如t=0时输入X0，t=1时输入X1。

  • 网络的输入：X0,X1,…,Xt
  • 网络的输出：h0,h1,…,ht，RNN的输出比较多样，可只将最后的ht作为输出，也可将h0到ht都作为输出。（Xt，ht都是代表向量Tensor，不是数值）
    网络输出可选ht作为输出后接全连接层和softmax层将维度转化为需要的分类数从而实现序列的分类。

但是这种简易的RNN结构有两个致命缺点。

  • 越前面的数据进入序列的时间越早，所以对后面的数据的影响也就越弱，倘若重点在序列的前边，当最后输出结果时前边重点对结果的影响已经接近于0，无法得到理想的结果。（可通过注意力机制改善）
  • 由于网络只有一个A单元，网络的更新过程不过是不停地更新同一套权重，从结果往前进行反向传播时，梯度会出现两个结果，当梯度小于1时，多个小于1的梯度相乘，传到前边时梯度已经接近于0，发生梯度消失现象，当梯度大于1时，多个大于1的梯度相乘，传到前方时发生梯度爆炸现象。（通过LSTM结构改善）

二、LSTM

2.1 LSTM结构介绍

在这里插入图片描述
LSTM（Long Short-Term Memory）长短期网络模型，它解决了RNN会遗忘序列前段信息的问题。
网络外部结构与RNN相同，同样是只有一个A单元，但A的内部有所不同。

  • LSTM输入为x和上一个时刻的h和c，输出为该时刻的h和c。
  • A单元内包括三条支路，分别为遗忘门，输入门和输出门。可以将输出c和h比作剧情的主线和支线，从图中可以看出c是从头到尾贯穿的，在上一时刻的h和该时刻的x输入之后，先经过遗忘门，比较重要程度来看是否要遗忘c的部分内容，之后经过输入门，根据重要程度看是否要将支线剧情添加至主线，最后经过输出门获得现在的状态。

2.2 LSTM的pytorch代码解析

CLASS torch.nn.LSTM(*args, **kwargs)
参数列表

  • input_size – 输入数据X的向量维度。
  • hidden_size – 隐含数据h的向量维度。
  • num_layers – LSTM 堆叠的层数，默认值是1层，每一层都只有一个A单元。如果设置为2，第二个LSTM接收第一个LSTM的计算结果。也就是第一层输入 [ X0 X1 X2 … Xt]，计算出 [ h0 h1 h2 … ht ]，第二层将 [ h0 h1 h2 … ht ] 作为 [ X0 X1 X2 … Xt] 输入再次计算，输出最后的 [ h0 h1 h2 … ht ]。
  • bias – 若设置为False,网络就不带偏置，只有权重。默认为True。
  • batch_first – 设为True, 则输入和输出格式为(batch, seq, feature)，因为输入输出格式默认为(seq, batch, feature)。
  • dropout – 若不为0，在除了最后一层外的单元添加dropout层，drop概率为传入的不为0的数。
  • bidirectional – 如果为真，则为双向LSTM。

输入格式

  • Inputs: input, (h_0, c_0)
  • input 输入数据 形状（序列长度，batchsize，输入向量维度） (seq_len, batch, input_size)
  • h_0 形状 (num_layers * num_directions, batch, hidden_size)
  • c_0 形状(num_layers * num_directions, batch, hidden_size)
    若h0和c0为提供，则默认为元素为0的向量。若batch_first则batch为首个参数。num_directions默认为1，双向时为2。

输出格式

  • output, (h_n, c_n)
  • output of shape (seq_len, batch, num_directions * hidden_size) 最后一层的hn（多层情况，一层时即为所有hn）
  • h_n of shape (num_layers * num_directions, batch, hidden_size) 包含所有层的hn
  • c_n of shape (num_layers * num_directions, batch, hidden_size) 包含所有层的cn

2.3 LSTM实现MINST手写数字数据集图像分类

引用库文件

import torch
from torch import nn, optim
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision import transforms as T
import matplotlib.pyplot as plt

超参设置

batch_size = 100   # 批量大小
lr = 1e-3          # 学习率
num_epoches = 30   # 训练迭代周期
use_gpu = torch.cuda.is_available()  # 是否使用cpu

MINST数据集导入

train_dataset = datasets.MNIST(root='G:/dl_dataset/',train=True,transform=T.ToTensor())
test_dataset = datasets.MNIST(root='G:/dl_dataset/',train=False,transform=T.ToTensor())
train_loader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
test_loader = DataLoader(test_dataset,batch_size=batch_size,shuffle=False)

定义LSTM结构
要使用的LSTM参数分析。
将图像的每一行作为一个X输入LSTM，所以每张图片都包含一个X0-X27，每个X是28维向量。
定义 input_size=28，hidden_size=128，num_layers = 2，batch_first=True。

class RNN(nn.Module):
    def __init__(self, in_dim, hidden_dim, n_layer, n_class):
        super(RNN, self).__init__()
        self.lstm = nn.LSTM(in_dim, hidden_dim, n_layer, batch_first=True)
        self.classifer = nn.Linear(hidden_dim, n_class)
        
    def forward(self,x):
        out ,_ = self.lstm(x)   # 输出为output(batch,seq_len,  hidden_size * num_directions)
        out = out[:,-1,:]        # seq=-1，即取每张图片数据的最后一个h，即hn
        out = self.classifer(out) # hn后接全连接层，使用softmax损失函数
        return out                # 返回最后的输出
model = RNN(28,128,2,10)   
# in_dim=28（每个X为图片的一行，维度为28）, hidden_dim=128（hn的维度）, n_layer=2（LSTM层数为两层）, n_class（最后的分类数）
if use_gpu:
    model = model.cuda()  # 把模型放到gpu上

定义损失函数和优化器

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(),lr=lr)

训练和测试过程

for epoch in range(num_epoches):
    print('*'*20)
    print("epoch{}".format(epoch+1))
    train_loss = 0.0          # 训练损失函数计算
    train_acc = 0.0           # 训练准确度计算
    
    model.train()  # 置模型于训练模式
    for i, data in enumerate(train_loader):  # 一次循环读入一个batch
        img, label = data           # 读入图像张量和标签张量
        b, c, h, w = img.size()     # MINST为黑白单通道图片
        assert c == 1
        img = img.squeeze(1)  # size b h w  去除通道维度
        if use_gpu:
            img, label = img.cuda(), label.cuda()   # 放入gpu
        out = model(img)  # input(batch,seq_len,in_dim) # 输入图像进行前向传播，输出各分类的得分
        loss = criterion(out,label)   # 计算损失函数
        train_loss += loss.item()     # 记录总的损失函数
        _,pred = torch.max(out,1)     # 返回得分最大值的索引，dim=0为batch，dim=1为每个图片的分类得分
        num_correct = (pred == label).sum()  # 计算得分最大值索引与label相同的个数
        train_acc += num_correct.item()    # 计算正确总个数
        
        optimizer.zero_grad()     # 梯度清零
        loss.backward()           # 梯度反向传播
        optimizer.step()          # 优化器前进step
    # 完成一个epoch的训练，打印训练的loss和acc
    print('Finish {} epoch, Loss: {:.6f}, Acc: {:.6f}'.format(
        epoch + 1, train_loss / (len(train_dataset)), train_acc / (len(
            train_dataset))))    
    
    model.eval()  # 置模型于测试模式，使dropout和bn失去作用
    eval_loss = 0.0  # 测试模式损失记录
    eval_acc = 0.0   # 测试模式准确率记录
    for data in test_loader:  一次循环读入一个batch
        img, label = data
        b, c, h, w = img.size()
        assert c == 1, 'channel must be 1'
        img = img.squeeze(1)
        if use_gpu:
            img, label = img.cuda(), label.cuda()
        with torch.no_grad():        # 测试模式无需梯度
            out = model(img)
            loss = criterion(out, label)
        eval_loss += loss.item()
        _, pred = torch.max(out, 1)
        num_correct = (pred == label).sum()
        eval_acc += num_correct.item()
    print('Test Loss: {:.6f}, Acc: {:.6f}'.format(eval_loss / (len(
        test_dataset)), eval_acc / (len(test_dataset))))

训练30个周期在测试集达到99.08%准确率。

********************
epoch30
Finish 30 epoch, Loss: 0.000106, Acc: 0.996667
Test Loss: 0.000364, Acc: 0.990800

保存模型

torch.save(model.state_dict(),'./RNN.pth')

最终性能测试

model.load_state_dict(torch.load('./RNN.pth'))
print('Final Test')
model.eval()
eval_loss = 0.0
eval_acc = 0.0
for data in test_loader:
    img, label = data
    b, c, h, w = img.size()
    assert c == 1, 'channel must be 1'
    img = img.squeeze(1)
    if use_gpu:
        img, label = img.cuda(), label.cuda()
    with torch.no_grad():
        out = model(img)
        loss = criterion(out, label)
    eval_loss += loss.item()
    _,pred = torch.max(out,1)
    eval_acc += ( pred==label ).float().mean()
print(f'Test Loss: {eval_loss/len(test_loader):.6f}, Acc: {eval_acc/len(test_loader):.6f}')

提取一个实例进行直观认识

imgs,labels = next(iter(test_loader)) # 提取一个batch
img = imgs[0]  # 取一张图片
show = img     
show = show.view(28,28)
# img = img.view(img.size(0),-1)
plt.imshow(show.numpy(), cmap='Greys_r')  # 显示该图片
img = img.cuda()  
label = labels[0].cuda()  # 图片和标签放入gpu
output = model(img)       # 前向传播
print(label,output,sep='\n')  # 打印各分类得分和标签
pred = torch.squeeze(torch.max(output,dim=1)[1],dim=0)  #squeeze降维，max找到得分最大的索引 
print(label,pred,sep='\n') # 对比预测值和真实标签

tensor(7, device='cuda:0')   # label
tensor([[-2.8946, -2.8025,  0.2505, -0.9841,  1.3492, -3.3886, -6.0807, 13.3174,
         -3.3386,  1.1477]], device='cuda:0', grad_fn=<AddmmBackward>)  # output
tensor(7, device='cuda:0')   # label
tensor(7, device='cuda:0')   # 预测标签

在这里插入图片描述

爱吃蛋炒饭的小老鼠
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
循环神经网络(RNN) 和 长短期记忆网络(LSTM)
看正好六个字的博客
12-31 3669
循环神经网络(RNN) 循环神经网络是一种用于处理序列数据的神经网络。 RNN 的输入输出：用「动图」和「举例子」讲讲 RNN 右侧是 RNN 在时间上进行展开的示意图。这个过程由 Encoder完成，目的是从序列输入中依次提取数据并将其编码为向量(表示输入)。 对于第时刻，是当前时刻的输入，用于实时更新状态；是上一隐藏层的状态，用于记忆状态(对于文本而言，就是前文留下的对推断后文有用的信息)。 基于 Encoder-Decoder 的 RNN 模型可应用于机器翻译，输入是英文句...
循环神经网络（RNN）与长短期记忆网络（LSTM）讲解
fxb163的博客
10-01 4585
循环神经网络（RNN） 对于典型的深度神经网络（DNN），就是通过在输入层与输出层之间增加隐藏层来构建网络，如下图所示。 与DNN不同的是，循环神经网络（RNN）赋予了网络对前面的内容的一种“记忆功能”，即一个序列当前的输出与前面的输出也有关。具体的表现形式为网络会对前面的信息进行记忆并应用于当前输出的计算中，即隐藏层之间的节点不再无连接而是有连接的，并且隐藏层的输入不仅包括输入层的输出还包括上...
循环神经网络RNN模型和长短时记忆系统LSTM
weixin_30340775的博客
02-06 560
传统DNN或者CNN无法对时间序列上的变化进行建模，即当前的预测只跟当前的输入样本相关，无法建立在时间或者先后顺序上出现在当前样本之前或者之后的样本之间的联系。实际的很多场景中，样本出现的时间顺序非常重要，例如自然语言处理、语音识别、手写体识别等应用。 循环神经网络RNN包含循环的网络，可以记录信息的持久化信息，特别适合应用在跟时间序列相关的场合。 RN...
神经网络算法：一文搞懂LSTM（长短期记忆网络）
最新发布
2401_84033492的博客
04-01 4030
本文将从LSTM的本质、LSTM的原理、LSTM的应用三个方面，带您一文搞懂长短期记忆网络Long Short Term Memory | LSTM。
RNN循环神经网络 、LSTM长短期记忆网络实现时间序列长期利率预测
拓端研究室TRL
11-22 595
全文链接：http://tecdat.cn/?p=251332017 年年中，R 推出了 Keras 包_，_这是一个在 Tensorflow 之上运行的综合库，具有 CPU 和 GPU 功能（点击文末“阅读原文”获取完整代码数据）。本文将演示如何在 R 中使用 LSTM 实现时间序列预测。相关视频简单的介绍时间序列涉及按时间顺序收集的数据。我用 xt∈R 表示单变量数据，其中 t∈T 是观察数...
RNN循环神经网络以及LSTM长短期记忆模型-简介
热门推荐
yoyofu007的博客
05-18 4万+
 写给自己的备忘内容：RNN的基础1概述Recurrentneural network，循环神经网络，在普通多层BP神经网络基础上，增加了隐藏层各单元间的横向联系，通过一个权重矩阵，可以将上一个时间序列的神经单元的值传递至当前的神经单元，从而使神经网络具备了记忆功能，对于处理有上下文联系的NLP、或者时间序列的机器学习问题，有很好的应用性。 2、特点、优点优点：模型具备记忆性。缺点：不能记忆太前或...
吴恩达视频文档-DeepLearning.ai深度学习课程笔记（V5.71） Coursera 深度学习教程中文笔记
05-13
Deep Learning Specialization 对卷积神经网络 (CNN)、递归神经网络 (RNN)、长短期记忆 (LSTM) 等深度学习常用的网络结构、工具和知识都有涉及。课程中也会有很多实操项目，帮助学生更好地应用自己学到的深度学习...
deeplearning深度学习笔记
12-26
课程涵盖深度学习的基础知识，神经网络构建，卷积神经网络(CNN)、递归神经网络(RNN)、长短期记忆(LSTM)等深度学习常用的网络结构和工具。 通过这五堂课，学生将学习深度学习的基础知识，学会构建神经网络，并在吴...
《机器学习》教学大纲和斯坦福《机器学习》公开课笔记
03-08
《机器学习》教学大纲通常包括以下...循环神经网络（RNN）与长短期记忆网络（LSTM） 深度学习在图像识别、自然语言处理等领域的应用 七、实践项目 基于实际数据集的机器学习项目实践 机器学习竞赛案例分析 八、总结与
Deeplearning 深度学习笔记
05-08
吴恩达Coursera深度学习教程中文笔记，这些课程专为已有一定基础（基本...Deep Learning Specialization对卷积神经网络 (CNN)、递归神经网络 (RNN)、长短期记忆 (LSTM) 等深度学习常用的网络结构、工具和知识都有涉及。
Deeplearning深度学习笔记v5.53
08-31
Deeplearning深度学习笔记v5.53 吴恩达机器学习笔记更新--在这 5 堂...Deep Learning Specialization 对卷积神经网络 (CNN)、递归神经网络 (RNN)、长短期记忆 (LSTM) 等深度学 习常用的网络结构、工具和知识都有涉及。
【深度学习】循环神经网络RNN和长短时记忆网络LSTM(超详细原理推导和解释)
Blog
10-27 1631
主要介绍了循环神经网络RNN和长短时记忆网络LSTM，并对其中的原理和网络结构进行了详细的推导和解释。
小常识10: 循环神经网络（RNN）与长短时记忆网络LSTM简介。
echo_1994的博客
07-11 2720
小常识10:  循环神经网络（RNN）与长短时记忆网络LSTM简介。 本文目的：在计算机视觉(CV)中，CNN 通过局部连接／权值共享／池化操作／多层次结构逐层自动的提取特征，适应于处理如图片类的网格化数据。在自然语言处理(NLP)中，循环神经网络被设计用于处理序列的神经网络，如应用 RNN 在语音识别，语言建模，翻译等。同时，现有的计算机视觉研究开始结合CNN与RNN的使用，应用于视频目标检测，...
循环神经网络（RNN）、长短时记忆网络（LSTM）及（GRU）模型
samuelzhoudev的博客
08-28 1674
循环神经网络（RNN） 循环神经网络区别于其他神经网络在于循环二字，这里的循环是指隐含的输出(v)重新输入隐含权重参与模型训练，不同时刻的输入(X)也要放入隐含层权重中。隐含权重是循环到不同时间段其参数不一样，但隐含权重是共用的，注意在图中unfold下隐含权重矩阵只是一个矩阵（这里稍后解释：隐含的输出(v)和对应的输入(x)怎样共用一个矩阵)，之所以呈现多个是为了对应不同的时刻。 在继续往下叙述之前，有一个优化问题要解决，即共用一个矩阵，这里可以通用一个简单的例子进行说明： 为方便理解，隐含变量为二维，
理论——RNN（循环神经网络）与LSTM（长短期记忆神经网络）
小熊的博客
03-13 5061
CNN与LSTM的理论
RNN（循环神经网络）
鲨鱼儿的博客
05-08 3656
一、循环神经网络 1、x输入序列x=[x1,x2,x3,...,x(t+1),...x(T)] 其中x(i)表示输入的字，每个字有许多分量[x(i1),x(i2),x(i3),...] x(i)下表就是时刻，每一个时刻对应输入序列中一个字 一句话就是一个输入序列，每句话的长度要一样，以最长的话为准，不够的补0；每个字的向量维度长也是一样的s(i)就是递归 ...
NNDL 实验七 循环神经网络（1）RNN记忆能力实验
m0_57250370的博客
12-17 169
无
[机器学习]RNN网络处理长短时记忆问题
小蜗牛之家
11-12 958
RNN网络处理长时间的记忆问题，比如我是男人…省略1000字…我的性别是__，在回答中间很长的时间序列间隔后的预测问题的时候，上面的RNN网络会出现瓶颈，即淡忘了，（很正常，人看一篇很长的文章后最后询问其中的某一个小点的时候，也会常常答不上来。其中一个重要的原因是梯度的消息和弥散作用的这种算法检查不了很长的回合数。这里通过改进RNN，在其基础上引入了LSTM:LongShort Term Memo...
PyTorch 实现 循环神经网络（RNN）、长短期记忆网络（LSTM）、门控循环单元网络（GRU）-谢TS的博客.pdf
07-17
循环神经网络（RNN）、长短期记忆网络（LSTM）和门控循环单元网络（GRU）都是 PyTorch 中重要的深度学习模型，能够学习序列数据的非线性特征，并且可以应用于自然语言处理、语音识别、图像识别等领域。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值