RNN和LSTM

已于 2024-11-23 16:44:12 修改
阅读量682 收藏 13
点赞数 25
分类专栏： 深度学习——基础补充 文章标签： 深度学习 rnn 人工智能 lstm
于 2024-11-23 16:43:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62665562/article/details/143994685
版权

RNN

什么是循环神经网路

Recurrent Neural Networ(RNN),是一类具有内部环状连接的人工神经网络。用于处理序列数据。

image-20241122131046851

简单代码示例

# 一个简单的RNN结构示例
class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(SimpleRNN, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        
    def forward(self, x):
        out, _ = self.rnn(x)
        return out

网络结构

基础结构

有点像全连接层，但是在全连接层的基础上，将隐藏层最后的值多考虑了上一次隐藏层的值。也就是得到的最后的输出值，即考虑了现在的输入也考虑了以前的输入。具有记忆功能。

image-20241122225653704

上图假设输入的第一个序列有两个维度分别为x1, x2, 中间有个隐藏层(hiddenl layer)有着记忆功能，最后隐藏层输出预测值。

Example

image-20241122225901105

假设输入一连串序列，所有的权重都为1，没有bias。所有的激活函数都为f(x) = x。隐藏层初始化为[0,0]

  1. 先输入第一个序列[1,1]，
    a1 = a1*1 + a2*1+x1*1+x2*1
    = 0 + 0 + 1 + 1 = 2

    a2 = a1 + a2 + x1 + x2
    = 0 + 0 + 1 + 1 = 2

    y1 = a1 + a2 = 4
    y2 = a1 + a2 = 4

  2. 输入第二个序列 [1, 1]
    a1 = a1 + a2 + x1 + x2
    = 2 + 2 + 1 + 1
    = 6
    a2 = a1 + a2 + x1 + x2
    = 2 + 2 + 1 + 1
    = 6

    y1 = a1 + a2 = 12

    y2 = a1 + a2 = 12

  3. 输入第三个序列 [2, 2]
    a1 = a1 + a2 + x1 + x2
    = 6+ 6 + 2 + 2
    = 16

    a2 = a1 + a2 + x1 + x2
    = 6+ 6 + 2 + 2
    = 16
    y1 = a1 + a2 = 32

    y2 = a1 + a2 = 32

实际例子的直观运算过程，需要注意的是，每一次序列的运算用的都是同一组参数。（下图同种颜色的箭头用的参数代表同一组参数）

image-20241122231103194

当然这个隐藏层可以是多层组成的

image-20241122231438955

不同变形

Elman Network(前面讲的)

image-20241122231541522

上一次hidden layer的输出作为这次hidden layer的输入。

Jordan Network

image-20241122231628313
上一次的ouput的值作为下次hidden layer的输入。

Bidirectional RNN(双向RNN)

image-20241122231833325

就是先运算正向RNN和反向RNN，最后结合正向和反向得到最后的输出值。分别考虑了序列的前面和后面（结合上下文）。

Long Short-term Memory(LSTM)

基本组成

有三个部分(3个阀门)组成：

  1. Input Gate
  2. Output Gate
  3. Forget Gate

image-20241122232433759

一共有4 Inputs, 1 Output

image-20241122232556643

仔细来看，激活函数通常为sigmoid, 范围在0~1之间，代表阀门的打开程度。

image-20241122233022797

整个运算过程，

首先输入z->g(z), zi->f(zi), out1 = g(z)f(zi),

然后 zf->f(zf), c’=c*f(zf) + out1,

最后z0->f(z0), c’=h(c’), out = h(c’)f(z0)

Example

四个Input的来源是序列的输入分别乘以四组不同的权重得来的。这些权重是可训练的。

image-20241122233515093

  1. 第一个序列输入

    image-20241122233856819

    计算得到
    image-20241122233915847

  2. 第二个序列输入
    image-20241122233931413

    计算得到
    image-20241122233952742

  3. 第三个序列输入
    image-20241122234022601

    计算得到

    image-20241122234048705

  4. 依次类推

完成LSTM组成

对比原来的RNN

image-20241122234449870

LSTM

image-20241122234615929

完整的LSTM

image-20241122235318420

image-20241122235347160

完整的LSTM会将上一次的输出作为这次的输入，

image-20241122235500940

同时会将Cell里面的值作为这次的输入。

image-20241122235546847

上图就是完整的LSTM形态。

image-20241122235605140

Pytorch实现RNN

RNN代码讲解

image-20241123000204008

首先数据集x:[seq_len, batch, feature_len], xt:[batch, feature_len]

image-20241123000524513

假设数据集x为10个序列，3个batch, 100维特征

每次的输入xt为3个batch，100维特征。

计算过程：

hidden_len=20

image-20241123000507671

image-20241123000534599

x(t)@w(xh) + h(t)@w(hh)
= [3, 100] @ [20, 100].T + [3, 20] @ [20, 20].T

=[3, 20] + [3,20]

= [3, 20]

Pytorch函数

image-20241123001601407

image-20241123001650265

forward前向传播

image-20241123002430190

forward一步到位。

代码示例

import torch
from torch import nn

rnn = nn.RNN(input_size=100, hidden_size=10, num_layers=1)
print(rnn)

x = torch.randn(10, 3, 100) # 10 seq, 3 batch, 100 dim
out, h = rnn(x)
print(out.shape, h.shape)

运行结果
image-20241123003014913

多层隐藏层代码

import torch
from torch import nn

rnn = nn.RNN(input_size=100, hidden_size=10, num_layers=4)
print(rnn)

x = torch.randn(10, 3, 100) # 10 seq, 3 batch, 100 dim
out, h = rnn(x)
print(out.shape, h.shape)

image-20241123003245987

image-20241123003616288

单次计算每次序列

代码

import torch
from torch import nn

rnn = nn.RNNCell(input_size=100, hidden_size=10)
print(rnn)

x = torch.randn(10, 3, 100) # 10 seq, 3 batch, 100 dim
ht = torch.zeros(3, 10)
for xt in x:
    ht = rnn(xt, ht)
print(ht.shape)

image-20241123004011579

多层cell代码实现

import torch
from torch import nn

rnn1 = nn.RNNCell(input_size=100, hidden_size=10)
print(rnn1)
rnn2 = nn.RNNCell(input_size=10, hidden_size=20)

x = torch.randn(10, 3, 100) # 10 seq, 3 batch, 100 dim
ht1 = torch.zeros(3, 10)
ht2 = torch.zeros(3, 20)

for xt in x:
    ht1 = rnn1(xt, ht1)
    ht2 = rnn2(ht1, ht2)

print(ht1.shape) 
print(ht2.shape)

image-20241123004501084

RNN实战

时间序列预测

预测正弦曲线的下一段波形

image-20241123095549623

数据 [seq, batch, dim], [50, 1, 1]

随机start, random(防止对拟合数据记忆)

假如给出049的数据，需要预测150的数据形成下一段波形数, 或者更难 预测 0+step~49+step的数据。

数据生成代码

start = np.random.randint(3, size=1)[0] # 随机取起始点进行采集数据, 如果有固定点, 会对数据进行记忆
time_steps = np.linspace(start, start+10, num_time_steps) # 生成数据X, 假设数据从0~50
data = np.sin(time_steps) # 生成标签数据Y
data = data.reshape(num_time_steps, 1) # 标签
x = torch.tensor(data[:-1]).float().view(1, num_time_steps - 1, 1) # 生成数据X, 获取数据从0~49 
y = torch.tensor(data[1:]).float().view(1, num_time_steps - 1, 1) # 生成标签Y, 标签数据从1~50

网络模型代码

# net module
class Net(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
        super().__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.num_layers = num_layers
        self.rnn = nn.RNN(
            input_size = input_size, 
            hidden_size = hidden_size,
            num_layers = num_layers,
            batch_first = True, # batch是否在第一个维度, [seq, batch, dim]: False, [batch, seq, dim]: True 
        )
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, x, hidden_prev):
        out, hidden_prev = self.rnn(x, hidden_prev) # out shape: [batch, seq, hidden_size], hidden_prev shape: [batch, num_layers, hidden_size]
        out = out.view(-1, self.hidden_size) # 将Out展平
        out = self.linear(out) # [batch*seq, hidden_size] => [batch*seq, output_size]
        out = out.unsqueeze(dim=0) # 插入一个维度, [1, batch*seq, output_size]
        return out, hidden_prev

全部代码

import numpy as np
import torch
from torch import nn
from torch import optim
from tqdm import tqdm
from matplotlib import pyplot as plt

num_time_steps = 50
input_size = 1
hidden_size = 16
output_size = 1
lr = 0.001
num_layers = 2



# net module
class Net(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
        super().__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.num_layers = num_layers
        self.rnn = nn.RNN(
            input_size = input_size, 
            hidden_size = hidden_size,
            num_layers = num_layers,
            batch_first = True, # batch是否在第一个维度, [seq, batch, dim]: False, [batch, seq, dim]: True 
        )
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, x, hidden_prev):
        out, hidden_prev = self.rnn(x, hidden_prev) # out shape: [batch, seq, hidden_size], hidden_prev shape: [batch, num_layers, hidden_size]
        out = out.view(-1, self.hidden_size) # 将Out展平
        out = self.linear(out) # [batch*seq, hidden_size] => [batch*seq, output_size]
        out = out.unsqueeze(dim=0) # 插入一个维度, [1, batch*seq, output_size]
        return out, hidden_prev

model = Net(input_size, hidden_size, output_size, num_layers)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr)

hidden_prev = torch.zeros(num_layers, 1, hidden_size)

for iter in tqdm(range(6000)):
    start = np.random.randint(3, size=1)[0] # 随机取起始点进行采集数据, 如果有固定点, 会对数据进行记忆
    time_steps = np.linspace(start, start+10, num_time_steps) # 生成数据X, 假设数据从0~50
    data = np.sin(time_steps) # 生成标签数据Y
    data = data.reshape(num_time_steps, 1) # 标签
    x = torch.tensor(data[:-1]).float().view(1, num_time_steps - 1, 1) # 生成数据X, 获取数据从0~49 
    y = torch.tensor(data[1:]).float().view(1, num_time_steps - 1, 1) # 生成标签Y, 标签数据从1~50

    output, hidden_prev = model(x, hidden_prev)
    hidden_prev = hidden_prev.detach()

    loss = criterion(output, y)
    model.zero_grad()
    loss.backward()
    optimizer.step()

    if iter % 100 == 0:
        print('Iteration: {} loss {}'.format(iter, loss.item()))

start = np.random.randint(3, size=1)[0] # 随机取起始点进行采集数据, 如果有固定点, 会对数据进行记忆
time_steps = np.linspace(start, start+10, num_time_steps) # 生成数据X, 假设数据从0~50
data = np.sin(time_steps) # 生成标签数据Y
data = data.reshape(num_time_steps, 1) # 标签
x = torch.tensor(data[:-1]).float().view(1, num_time_steps - 1, 1) # 生成数据X, 获取数据从0~49 
y = torch.tensor(data[1:]).float().view(1, num_time_steps - 1, 1) # 生成标签Y, 标签数据从1~50

predictions = []
input = x[:, 0, :]
for _ in tqdm(range(x.shape[1])):
    input = input.view(1,1,1)
    (pred, hidden_prev) = model(input, hidden_prev)
    input = pred
    predictions.append(pred.detach().numpy().ravel()[0])

x = x.data.numpy().ravel()
y = y.data.numpy()
plt.scatter(time_steps[:-1], x.ravel(), s=90)
plt.plot(time_steps[:-1], x.ravel())

plt.scatter(time_steps[1:], predictions)
plt.show()

结果展示

image-20241123113622060

LSTM代码讲解

简单回顾

image-20241123114013898

源码

image-20241123163850837

参数

image-20241123114129699

LSTM forward

image-20241123114349224

示例代码

import torch
from torch import nn

lstm = nn.LSTM(input_size=100, hidden_size=20, num_layers=4)
print(lstm)

x = torch.randn(10, 3, 100) # 10 seq, 3 batch, 100 dim
out, (h, c) = lstm(x)

print(out.shape, h.shape, c.shape)    

lstm1 = nn.LSTM(input_size=100, hidden_size=20, num_layers=4, batch_first=True)
print(lstm1)

x = torch.randn(3, 10, 100) # 10 seq, 3 batch, 100 dim
out, (h, c) = lstm1(x)

print(out.shape, h.shape, c.shape)

image-20241123124612865

使用例子看懂RNN
weixin_42673117的博客
01-27 564
1、RNN产生原因 一些数据前后有关联，且关联的长度不确定，需要根据数据前后关系进行预测。比如视频每一帧与之前与之后的关联，要分析这些帧连接起来的整个序列。 2、几种神经网络 (1)基本循环神经网络 考虑例子： 我 昨天 上学 迟到 了 ，老师 批评 了 ____。 分为如下几步： 1、通过one-hot编码将数据向量化变为对应的数字序列 2、根据如下神经网络进行预测后面的数据 通过公式： 计算St与Ot (1)首先随机初始化一个W作为向后传递的初始值 (2)然后通过输入的x向量与权重矩阵U做乘积
史上最详细循环神经网络讲解（RNN/LSTM/GRU）
最新发布
cjneo的专栏
04-02 347
原文地址 https://zhuanlan.zhihu.com/p/123211148
RNN的实例代码
07-19
python实现、可用jupyter notebook查看，非常棒的资源啦啦啦
RNN使用示例
薰珞婷紫小亭子的博客
02-25 1319
RNN使用示例 import torch import torch.nn as nn rnn = nn.RNN(5,6,1) input = torch.randn(1,3,5) h0 = torch.randn(1,3,6) print(input) print(h0) output,hn = rnn(input,h0) print(output) print(hn) 结果 tensor([[[ 1.0300, 0.4837, 1.2938, 0.6715, 1.5796],
深入探索循环神经网络（RNN）（附代码示例）
weixin_67656334的博客
03-19 2584
​ 循环神经网络（RNN）是一种能够处理序列数据的神经网络，其主要特点是引入了循环结构，使得网络能够捕捉序列数据中的时间依赖关系。基于这种能力，RNN 在自然语言处理任务中广泛用于语言建模、机器翻译、语音识别和文本生成等任务。根据反向传播算法和链式法则, 梯度的计算可以简化为以下公式：​Dnσ′z1w1⋅σ′z2w2⋅⋯⋅σ′znwnDnσ′z1w1⋅σ′z2w2⋅⋯⋅σ′znwn​Dnσ′z1。
Python 循环神经网络（RNN）算法详解与应用案例
qq_42568323的博客
10-20 3744
本文详细介绍了循环神经网络（RNN）的基本原理，提供了Python中的面向对象实现，并通过序列预测和文本生成的案例展示了RNN的应用。RNN在处理时间序列和自然语言等领域表现出色，但也面临梯度消失等挑战。希望本文能帮助读者理解RNN的基本概念和实现方法，为进一步研究和应用提供基础。
RNN-LSTM卷积神经网络Matlab实现.zip
11-04
在深度学习领域，循环神经网络（Recurrent Neural Networks, RNN）和长短期记忆网络（Long Short-Term Memory, LSTM）是处理序列数据的强大工具，特别是在自然语言处理、语音识别和时间序列预测等方面表现出色。...
用于预测和预报的Python和MATLAB RNN-LSTM模型 RNN和LSTM模型在Python和MATLAB中编程用于温度
06-28
这项工作使用Python和MATLAB实现了RNN和LSTM模型，用于温度预测，包括设置、数据预处理、模型训练和使用MAE和RMSE等指标进行评估。它采用时间序列分析和统计评估技术，提供可视化来展示模型的准确性和实际应用。
基于RNN和LSTM模型，用于温度预测Matlab代码.rar
09-01
基于此背景，本项目“基于RNN和LSTM模型，用于温度预测Matlab代码”应运而生，旨在为相关专业人士和学术研究者提供一套基于递归神经网络（RNN）和长短期记忆网络（LSTM）的温度预测解决方案。 首先，RNN和LSTM是两...
LSTM实例源代码
10-11
详细的LSTM代码， 附带数据。 RNN全称循环神经网络（Recurrent Neural Networks），是用来处理序列数据的。在传统的神经网络模型中，从输入层到隐含层再到输出层，层与层之间是全连接的，每层之间的节点是无连接的。但是这种普通的神经网络对于很多关于时间序列的问题却无能无力。
LSTM实例,可以运行
09-06
可以运行的LSTM实例，python代码实现，如有问题，可以随时联系我，希望可以和人工智能盆友多多交流，，，，，，，，，，，，，，，，，，，，，，，，，，，
lstm神经网络实例1
03-12
做预测的小栗子，简单易懂，明了，适合初学者学习使用
深度学习模型的基本结构——RNN
01-27
本文来自于个人博客，本文为深度学习课程笔记，通过流程图，详细介绍了深度学习模型的基本结构，希望对您的学习有所帮助。深度学习的基本步骤：定义模型-->定义损失函数-->找到优化方法课程大纲1、熟悉定义符号（略过）2、RNN简单地说就是RNN可以看做是一个function反复迭代。为什么不用feedFordnetwork，因为我们输入的sequence可能会比较长，这样的话feedFord network可能就会参数很多，容易导致过拟合。RNN的一个好处是参数少，有可能比较难train，但是你一旦在trainingdata上获得比较好
两个rnn实例，可直接运行
weixin_41529093的博客
03-30 901
仅作为记录，大佬请跳过。 文章目录参考实例一代码实例二代码 参考 感谢大佬博主文章 实例1传送门 实例2传送门 实例一代码 简介：输入了这个正弦曲线，输出一个移位的正弦曲线 代码： import torch from torch import nn import numpy as np import matplotlib.pyplot as plt plt.figure(figsize=(8, 5)) # how many time steps/data pts are in one batch of
循环神经网络（RNN）入门指南及代码示例
m0_54141558的博客
06-16 3473
循环神经网络（Recurrent Neural Network，RNN）是一种擅长处理序列数据的神经网络结构。与传统的前馈神经网络不同，RNN拥有循环连接，可以保留以前的信息，从而在处理时间序列数据、自然语言处理等任务中表现出色。在这篇文章中，我们将详细介绍RNN的基本概念及其变体LSTM和GRU，并通过代码示例展示如何在实践中使用这些模型。
从本质认识RNN到LSTM【附实例】
bigbug_sec的博客
02-06 4304
（一）说明  这里写一下RNN的相关公式推导，以及代码中RNN的理解，简单的说明本质问题，不再详细介绍RNN相关发展以及相关概念。有相关基础肯能会比较好懂。主要介绍RNN、LSTM并简单介绍其他RNN的变种。  （二）本质分析开始--RNN推导与理解  给出最直观理解RNN的图：     参数这里是共享的。  接下来是RNN的前向传播计算公式：     RNN时间序列的反向传播
LSTM简单的例子
GodsLeft的专栏
05-12 6615
LSTM生成评论的例子 使用前10个字推出后面的1个字 import numpy from keras.models import Sequential from keras.layers import Dense, Dropout, LSTM from keras.callbacks import ModelCheckpoint from keras.utils import np_utils ...
rnn和lstm
03-18
### RNN与LSTM的差异 RNN（循环神经网络）是一种用于处理序列数据的神经网络模型，其核心特点是具有内部状态记忆能力，能够捕捉时间序列中的依赖关系[^1]。然而，标准RNN存在梯度爆炸和梯度消失的问题，在长时间序列中难以有效传递信息。 相比之下，LSTM（长短期记忆网络）是对传统RNN的一种改进版本。它通过引入特殊的门控机制来解决长期依赖问题。具体来说，LSTM包含输入门、遗忘门和输出门三个控制单元，以及一个细胞状态（cell state），这使得它可以有选择地记住或忘记信息。 #### 结构对比 在结构上，RNN的基本单元仅由简单的激活函数组成，而LSTM则更加复杂，包含了多个交互式的组件。这种设计让LSTM能够在训练过程中更好地保持历史信息，从而适应更复杂的任务需求[^2]。 --- ### 应用场景分析 对于短序列或者简单的时间序列预测任务，普通的RNN可能已经足够满足需求。但由于其固有的局限性，当面对较长的上下文关联时，性能会显著下降[^3]。 相反，LSTM因其强大的建模能力和对长距离依赖的有效管理，广泛应用于诸如机器翻译、语音识别等领域。特别是在需要理解大量背景信息才能做出决策的情况下，比如生成高质量的文章摘要或是完成多轮对话系统的构建，LSTM往往表现得更为出色。 尽管如此，实际应用中还需考虑计算资源消耗等因素。虽然理论上LSTM优于基础版RNN，但在特定条件下两者差距并不明显；甚至有时经过优化后的常规RNN也能达到接近的效果。 --- ```python import torch.nn as nn # 定义一个基于RNN的模型 class SimpleRNNModel(nn.Module): def __init__(self, input_size, hidden_size, output_size): super(SimpleRNNModel, self).__init__() self.rnn = nn.RNN(input_size, hidden_size, batch_first=True) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): out, _ = self.rnn(x) return self.fc(out[:, -1, :]) # 定义一个基于LSTM的模型 class LSTMModel(nn.Module): def __init__(self, input_size, hidden_size, num_layers, output_size): super(LSTMModel, self).__init__() self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): lstm_out, _ = self.lstm(x) return self.fc(lstm_out[:, -1, :]) ``` 上述代码分别定义了一个简易的RNN模型和LSTM模型，便于观察两者的不同之处。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值