循环神经网络--LSTM模型

已于 2024-09-26 17:08:19 修改
阅读量587 收藏 5
点赞数 12
分类专栏： 自然语言处理 文章标签： rnn lstm 人工智能
于 2024-09-26 17:07:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64592880/article/details/142559957
版权

LSTM模型

1、概述：

LSTM（Long Short-Term Memory）模型是一种特殊的循环神经网络（RNN），它能够学习和记忆长期依赖关系。LSTM通过引入门控机制来解决传统RNN在处理长序列数据时遇到的梯度消失问题。这些门控机制包括遗忘门、输入门和输出门，它们可以控制信息的流动，从而使得网络能够学习到长期依赖关系。

2、门：

门是一种让信息选择式通过的方法，包含一个sigmoid神经网络层和一个pointwise乘法操作。

1、遗忘门（Forget Gate）

遗忘门决定哪些信息应该从细胞状态中被遗忘或保留。它通过以下公式计算： 

其中 σ 是sigmoid激活函数，Wf是遗忘门的权重矩阵，ht−1 是上一时间步的隐藏状态，xt是当前时间步的输入，bf是偏置项。

2、输出门（Input Gate）

输入门由两部分组成：一个sigmoid层决定哪些值将要更新，和一个tanh层创建一个新的候选值向量，该向量将被加入到状态中。输入门的计算如下：

其中 it​ 是输入门的输出，C~t是候选值

3、状态更新（Cell State Update）

细胞状态的更新是LSTM中最关键的部分，它结合了遗忘门和输入门的信息：

其中 Ct是当前时间步的细胞状态，Ct−1 是上一时间步的细胞状态。

4、输出门（Output Gate）

输出门决定隐藏状态的值，隐藏状态包含关于观测序列的信息，输出门的计算如下：

 

其中 ot​ 是输出门的输出，ht​ 是当前时间步的隐藏状态。

3、代码实现

手写的简单LSTM：

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(LSTM, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size

        # 使用 nn.Parameter 来初始化权重和偏置
        self.w_f = np.random.rand(hidden_size, input_size+hidden_size)
        self.b_f = np.random.rand(hidden_size)

        self.w_i = np.random.rand(hidden_size, input_size+hidden_size)
        self.b_i = np.random.rand(hidden_size)

        self.w_c = np.random.rand(hidden_size, input_size+hidden_size)
        self.b_c = np.random.rand(hidden_size)

        self.w_o = np.random.rand(hidden_size, input_size+hidden_size)
        self.b_o = np.random.rand(hidden_size)

        # 输出层
        self.w_y = np.random.rand(output_size, hidden_size)
        self.b_y = np.random.rand(output_size)


    def tanh(self, x):
        return np.tanh(x)

    def sigmoid(self, x):
        return 1/(1+np.exp(-x))

    def forward(self, x):
        # 初始化隐藏状态和细胞状态
        h_t = np.zeros((self.hidden_size,))
        c_t = np.zeros((self.hidden_size,))

        h_states = []
        c_states = []

        for t in range(x.size(0)):
            x_t = x[t]
            x_t = np.concatenate([x_t, h_t])
            # 遗忘门
            f_t = self.sigmoid(np.dot(self.w_f,x_t) + self.b_f)
            # 输入门
            i_t = self.sigmoid(np.dot(self.w_i,x_t) + self.b_i)
            # 候选细胞状态
            c_hat_t = self.tanh(np.dot(self.w_c,x_t) + self.b_c)
            # 更新细胞状态
            c_t = f_t * c_t + i_t * c_hat_t
            # 输出门
            o_t = self.sigmoid(np.dot( self.w_o,x_t) + self.b_o)
            # 更新隐藏状态
            h_t = o_t * self.tanh(c_t)
            # 保存每个时间步的隐藏状态和细胞状态
            h_states.append(h_t)
            c_states.append(c_t)
        y_t = np.dot(self.w_y,h_t) + self.b_y
        output = torch.softmax(torch.tensor(y_t), dim=0)
        return np.array(h_states), np.array(c_states), output

# 将 NumPy 数组转换为 PyTorch 张量
x = torch.tensor(np.random.randn(3, 2), dtype=torch.float32)
hidden_size = 5

lstm = LSTM(input_size=2, hidden_size=hidden_size, output_size=6)
hidden_states, cell_states, output = lstm.forward(x)
print(hidden_states, cell_states, output)

多对一（简单案例）：

import torch
import torch.nn as nn

class ManyToOneLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(ManyToOneLSTM, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # 初始化隐藏状态和细胞状态
        h0 = torch.zeros(1, x.size(0), self.hidden_size)
        c0 = torch.zeros(1, x.size(0), self.hidden_size)
        # 前向传播LSTM
        out, _ = self.lstm(x, (h0, c0))
        # 只取最后一个时间步的输出
        out = out[:, -1, :]
        # 通过全连接层得到最终输出
        output = self.fc(out)
        return output

# 示例使用
input_size = 10
hidden_size = 20
output_size = 2
model = ManyToOneLSTM(input_size, hidden_size, output_size)
x = torch.randn(4, 7, input_size)
output = model(x)
print(output.shape)  # 输出形状：(4, output_size)

多对多（简单案例）：

import torch
import torch.nn as nn
import torch.nn.functional as F

class ManyToManyLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(ManyToManyLSTM, self).__init__()
        self.hidden_size = hidden_size
        self.input_size = input_size
        self.output_size = output_size
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # 初始化隐藏状态和细胞状态
        h0 = torch.zeros(1, x.size(0), self.hidden_size)
        c0 = torch.zeros(1, x.size(0), self.hidden_size)
        # 前向传播LSTM
        out, _ = self.lstm(x, (h0, c0))
        # 应用全连接层到每个时间步的输出
        out = self.fc(out)
        return out

# 超参数设置
input_size = 10  # 输入特征的维度
hidden_size = 20  # LSTM隐藏层的维度
output_size = 5   # 输出的维度

# 创建模型实例
model = ManyToManyLSTM(input_size, hidden_size, output_size)

# 示例输入数据 (batch_size, sequence_length, input_size)
x = torch.randn(4, 7, input_size)  # 假设有4个样本，每个样本是7个时间步的序列

# 前向传播
output = model(x)
print(output.shape)  # 输出形状将是 (batch_size, sequence_length, output_size)

一对多（简单案例）：

import torch
import torch.nn as nn

class OneToManyLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(OneToManyLSTM, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # 初始化隐藏状态和细胞状态
        h0 = torch.zeros(1, x.size(0), self.hidden_size)
        c0 = torch.zeros(1, x.size(0), self.hidden_size)
        # 前向传播LSTM
        out, _ = self.lstm(x, (h0, c0))
        # 应用全连接层到每个时间步的输出
        out = self.fc(out)
        return out

# 示例使用
input_size = 10
hidden_size = 20
output_size = 2
model = OneToManyLSTM(input_size, hidden_size, output_size)
x = torch.randn(4, 1, input_size)  # 假设每个样本是一个时间步
output = model(x)
print(output.shape)  # 输出形状：(4, 1, output_size)

4、序列池化

1、最大池化（MAX Pooling）：

最大池化通过选择序列中的最大值来生成固定长度的输出。在NLP中，这可以用于提取关键词或短语的最重要特征。最大池化对于异常值具有一定的鲁棒性，因为它只关注最大的激活值。

超级简单案例：

import torch
import torch.nn as nn

input_data = torch.randn(100, 1000,32)

max_pool = nn.AdaptiveMaxPool1d(1)

input_data = input_data.permute(0,2,1)

output = max_pool(input_data)
print(output.size())
#torch.Size([100, 32, 1])

2、平均池化（Average Pooling）：

平均池化通过计算序列中所有值的平均值来生成输出。这种方法倾向于平滑特征，减少噪声的影响。然而，它可能会丢失一些重要信息，因为它对所有值给予相同的权重。

又是一个超级简单的案例：

import torch
import torch.nn as nn

input_data = torch.randn(100, 1000,32)

avg_pool = nn.AdaptiveAvgPool1d(1)

input_data = input_data.permute(0,2,1)

output = avg_pool(input_data)

print(output.size())
#torch.Size([100, 32, 1])

3、注意力池化（Attention Pooling）:

加权池化是一种更灵活的方法，它为序列中的每个元素分配一个权重，然后根据这些权重计算加权平均值。权重可以基于不同的标准，如位置信息、时间衰减或其他自定义函数。这种方法可以更好地捕捉序列中的复杂模式。

m0_64592880
关注
专栏目录
【机器学习】一文搞懂算法模型之：LSTM
商务合作 | 面试培训 | 职场规划 ==>主页扫码
03-21 1万+
一文搞懂算法模型之：LSTM
LSTM模型
Ambrosedream的博客
03-08 4233
概念 LSTM：长短期记忆细胞神经网络 长短期记忆网络是一种时间递归神经网络，适合处理和预测时间序列中间隔和延迟相对较长的重要事件。 使用遗忘门的LSTM适用于连续性的预测。 LSTM避免了RNN（循环神经网络）网络的梯度消失和梯度爆炸问题。 LSTM 使用记忆单元代替神经元。 组成 一个LSTM单元由一个记忆细胞 CtC_tCt​ 和三个门结构组成（输入门 iti_tit​ 、遗忘门 ftf_tft​、输出门 oto_tot​）. 在 t 时刻，xtx_txt​代表输入数据，hth_tht​代表隐藏层。X
VMD-TCN-LSTM-MATT变分模态分解卷积长短期记忆神经网络多头注意力多变量时间序列预测
04-19
1.Matlab实现VMD-TCN-LSTM-MATT变分模态分解卷积长短期记忆神经网络多头注意力多变量时间序列预测； 2.运行环境为Matlab2023及以上； 3.输入多个特征，输出单个变量，考虑历史特征的影响，多变量时间序列预测； 4.data为数据集，main1-VMD.m、main2-VMD-TCN-LSTM-MATT.m为主程序，运行即可,所有文件放在一个文件夹； 5.命令窗口输出R2、MSE、MAE、MAPE和RMSE多指标评价； 多头自注意力层 (Multihead-Self-Attention)：Multihead-Self-Attention多头注意力机制是一种用于模型关注输入序列中不同位置相关性的机制。它通过计算每个位置与其他位置之间的注意力权重，进而对输入序列进行加权求和。注意力能够帮助模型在处理序列数据时，对不同位置的信息进行适当的加权，从而更好地捕捉序列中的关键信息。在时序预测任务中，注意力机制可以用于对序列中不同时间步之间的相关性进行建模.
深度学习算法——LSTM（长短期记忆网络）
最新发布
m0_73774842的博客
08-28 1356
长期以来，隐变量模型存在着长期信息保存和短期输入缺失的问题。解决这一问题的最早方法之一是长短期存储器（long short‐term memory，LSTM）(Hochreiter and Schmidhuber, 1997)。它有许多与门控循环单元一样的属性。有趣的是，长短期记忆网络的设计比门控循环单元稍微复杂一些，却比门控循环单元早诞生了近20年。在初始化函数中，长短期记忆网络的隐状态需要返回一个额外的记忆元，单元的值为0，形状为（批量大小， 隐藏单元数）。因此，我们得到以下的状态初始化。
MATLAB神经网络---lstmLayer（LSTM 长短期记忆神经网络）
qq_45452617的博客
06-13 2023
描述LSTM就要先描述一下循环神经网络循环神经网络循环神经网络通过使用带自反馈的神经元，使得网络的输出不仅和当前的输入有关，还和上一时刻的输出相关，于是在处理任意长度的时序数据时，就具有短期记忆能力。如下是一个按时间展开的循环神经网络图：梯度消失和梯度爆炸是困扰RNN模型训练的关键原因之一，产生梯度消失和梯度爆炸是由于RNN的权值矩阵循环相乘导致的，相同函数的多次组合会导致极端的非线性行为。梯度消失和梯度爆炸主要存在RNN中，因为RNN中每个时间片使用相同的权值矩阵。
基于贝叶斯(bayes)优化卷积神经网络-长短期记忆网络(CNN-LSTM)回归预测（Matlab完整源码和数据）
02-21
基于贝叶斯(bayes)优化卷积神经网络-长短期记忆网络(CNN-LSTM)回归预测，bayes-CNN-LSTM多输入单输出模型。 优化参数为：学习率，隐含层节点，正则化参数。 评价指标包括:R2、MAE、MSE、RMSE和MAPE等，代码质量极高...
Stock-Price-Prediction-LSTM-master 2_LSTM_LSTM股票预测_LSTM股票预测_lstm
09-30
LSTM是一种特殊类型的循环神经网络（RNN），在处理序列数据时，它能够有效地捕获长期依赖性，这使得LSTM在时间序列预测任务中表现出色，如股票市场分析。 1. **LSTM简介** - LSTM是RNN的一种变体，解决了传统RNN的...
Python实现GA-TCN-LSTM遗传算法-时间卷积神经网络-长短期记忆网络时间序列预测（完整源码和数据）
04-10
2.使用先进的机器学习技术和优化算法开发石油产量预测模型，包括开发遗传算法-时间卷积神经网络-长短期记忆（GA-TCN-LSTM）集成模型，以及对循环神经网络（RNN）、门控循环单元（ GRU）、长短期记忆LSTM）和时间卷积...
arima的matlab代码-ARIMA-LSTM-hybrid-corrcoef-predict:应用ARIMA-LSTM混合模型来预测两种
06-02
循环神经网络 (RNN) 来预测两只个股的股价相关系数。 RNN 能够理解时间依赖性。 LSTM 单元的使用进一步增强了其长期预测特性。 为了在模型中同时包含线性和非线性，我们也采用了 ARIMA 模型。 ARIMA 模型过滤数据中...
机器学习——人工神经网络模型LSTM
Alphoseven的博客
12-03 8584
#LSTM的学习 ##学习目标：1·理解什么是人工神经网络。 2·深入理解LSTM（长短期记忆网络） 3·Code 代码 ##浅析人工神经网络： 在谈人工神经网络模型之前我们先来了解一下生理上的神经网络。 下面是个对比图： Neural Science Computer Science 人工神经网络实际上就是模仿人类的神经元之间连结，就像图灵模型也是基于人类运算行为而提出的一个模型。 在人体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值