pytorch框架LSTM(RNN)实现预测

已于 2023-06-10 17:06:41 修改
阅读量3.8k 收藏 38
点赞数 3
文章标签： 笔记 python 人工智能 rnn lstm
于 2023-06-10 17:00:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53707852/article/details/130979031
版权

一、环境配置

        1.python 3.8

        2.torch 1.9.1+cu102

        3.visdom (画图工具)

二、数据准备（模拟数据）

        （目标任务：根据现有数据，预测未来数据）

        生成y=i*2+b的数据（i的取值范围0-499，b的取值范围randint（1,10））。

# -*- coding: UTF-8 -*-
# 请看下面代码
# y=x*2+b
import random

with open('data\\data.txt', 'w', encoding='utf-8') as fp:
    for i in range(500):
        b = random.randint(1, 10)
        fp.write(f'{i},{b},{i * 2 + b}\n')

        生成的data.txt：

三、数据加载

        这里将data.txt中的x,b,y值分别存入列表之中。这里虽然继承了Dataset，但是后面训练代码中的数据加载部分我没有使用Dataloader，其中batch_size设为1，所以这里继承Dataset与否都行，我只是打个版。

# -*- coding: UTF-8 -*-
# 请看下面代码
from torch.utils.data import Dataset

class MyDataset(Dataset):
    def __init__(self):
        super(MyDataset, self).__init__()
        self.x = []
        self.b = []
        self.y = []
        with open('data\\data.txt', 'r', encoding='utf-8') as fp:
            for i in fp.readlines():
                temp = i.split(',')  # ['x','b','y\n']
                self.x.append(float(temp[0])/10)
                self.b.append(float(temp[1])/10)
                self.y.append(float(temp[2].rsplit()[0])/10)

    def __getitem__(self, item):
        return [self.x[item], self.b[item]], self.y[item]

    def __len__(self):
        return len(self.x)


# if __name__ == '__main__':
#     a = MyDataset()
#     # 点位分布图
#     from visdom import Visdom
#
#     vis = Visdom()
#     vis.line([0], [0], win='win', opts=dict(title='title'))
#     for i in range(len(a.x)):
#         vis.line([a.x[i] * 2 + a.b[i]], [i], win='win', update='append')

        加载x,b,y除以10主要是缩小数的大小，也类似于归一化了吧（主要这里我偷懒没做归一化了，可以自己实现归一化）。不归一化会减缓模型收敛，也会影响训练速度，所以能归一化还是归一化吧，不要像我一样。

四、模型搭建

        模型采用LSTM网络，它也是属于RNN的一种。

# -*- coding: UTF-8 -*-
# 请看下面代码
import torch
from torch import nn


class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()

        self.lstm = nn.LSTM(2, 5, 2, batch_first=True, bidirectional=True)
        self.linear1 = nn.Linear(5 * 2, 1)
        self.linear2 = nn.Linear(30, 1)

    def forward(self, x):
        # x [b,seq,2]
        output, hidden = self.lstm(x)
        # output [b,seq,5]
        output = self.linear1(output)
        # output [b,seq,1]
        output = output.view(1, -1)
        # output [b,seq*1]
        output = self.linear2(output)
        # output [b,1]
        return output

# if __name__ == '__main__':
#     model = MyModel()
#     x = torch.randn(1, 30, 2)
#     output = model(x)
#     print(output.shape)

        本次任务中设置bidirectional=True定义双向LSTM貌似比单向的时候，收敛更快。

五、训练代码

        这里设置的时间步长为30，根据前三十个数据预测下一个数据，也就是说根据1-30个数据、预测第31个数据，根据2-31个数据预测第32个数据，以此类推。

# -*- coding: UTF-8 -*-
# 请看下面代码
import torch
import visdom
from torch import optim, nn
from model import MyModel
from dataset import MyDataset

device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
lr = 1e-3
seq = 30

mydataset = MyDataset()
x_all = mydataset.x
b_all = mydataset.b
y_all = mydataset.y
max_len = len(y_all)

data_x = [
    [x_all[i], b_all[i]] for i in range(len(x_all))
]
data_y = y_all

model = MyModel().to(device)
opti = optim.AdamW(model.parameters(), lr=lr)
lossfun = nn.MSELoss().to(device)

vis = visdom.Visdom()
vis.line([0], [0], win='loss', opts=dict(title='loss-win'))
global_index = 1

for i in range(70):
    for item in range(max_len - seq):
        x = data_x[item:item + seq]
        y = data_y[item + seq]
        x, y = torch.tensor(x, dtype=torch.float), torch.tensor(y, dtype=torch.float)
        x, y = x.view(1, seq, -1), y.view(1, 1)
        x, y = x.to(device), y.to(device)
        opti.zero_grad()
        pred = model(x)
        loss = lossfun(pred, y)
        loss.backward()
        opti.step()

        if item == max_len - seq - 1:
            print(f'预测值：{pred.item():.6f}，真实值：{y.item():.6f}，差值为：{pred.item() - y.item():.6f}')
            vis.line([loss.item()], [global_index], win='loss', update='append')
            global_index += 1

torch.save(model.state_dict(), 'best.pt')

六、测试代码

# -*- coding: UTF-8 -*-
# 请看下面代码
import random

import torch
from visdom import Visdom
from model import MyModel

if __name__ == '__main__':
    model = MyModel()
    model.load_state_dict(torch.load('best.pt'))
    vis = Visdom()

    # 预测值和真实值分开画图
    # vis.line([0], [0], win='pred', opts=dict(title='预测'))
    # vis.line([0], [0], win='real', opts=dict(title='真实'))
    # for e in range(31, 501):
    #     sss = e / 10
    #     l = [[sss - float(i) / 10, random.randint(1, 10) / 10] for i in range(1, 31)]
    #     l.sort(reverse=False)
    #     print(l)
    #     x = torch.tensor(l, dtype=torch.float)
    #     x = x.view(1, 30, 2)
    #     out = model(x)
    #     print(out.item() * 10)
    #     vis.line([out.item() * 10], [e], win='pred', update='append')
    # with open('data\\data.txt', 'r', encoding='utf-8') as fp:
    #     for i in fp.readlines():
    #         temp = i.split(',')
    #         x = float(temp[0])
    #         y = float(temp[2].strip())
    #         vis.line([y], [x], win='real', update='append')

    # 预测值和真实值画在一个图
    vis.line([[0, 0]], [0], win='pred', opts=dict(title='预测-真实', legend=['pred', 'real']))
    with open('data\\data.txt', 'r', encoding='utf-8') as fp:
        for step, i in enumerate(fp.readlines()):
            temp = i.split(',')
            y = float(temp[2].strip())
            l = [[(step - float(j)) / 10, random.randint(1, 10) / 10] for j in range(1, 31)]
            l.sort(reverse=False)
            print(l)
            x = torch.tensor(l, dtype=torch.float)
            x = x.view(1, 30, 2)
            out = model(x)
            print(out.item() * 10)
            vis.line([[out.item() * 10, y]], [step], win='pred', update='append')

        预测-真实值图示：

        项目文档结构：

 

 七、疑问

        本人新手，在实验的过程中有些许疑问，想和大家一块讨论，也请大佬答疑。

        1、此次任务目标说是预测，但与其说是预测，本人觉得更像是拟合函数，所以这次的任务能叫做是预测吗？使用训练好的模型进行test测试，因为数据只用了x~[0-499]来作为训练集，如果使用x范围之外的数据进行test的输入，那就会表现的很不准确，所以这到底算是有预测功能呢（只是不能预测较远的数据），还是仅仅只是实现拟合函数功能罢了。（如果有预测功能，可以通过加大时间步来提升预测精确度吗？）

        2、把数据输入进网络，通过RNN\LSTM和线性层后得到[bacth,seq,1]格式的数据，之后我应该是取[:,-1,:]，也就是最后一个时间步作为最终预测结果呢，还是将通过RNN\LSTM和线性层后得到[bacth,seq,1]格式的数据变成[batch,seq*1]然后放入线性层将得到的[batch,1]格式的数据作为最后的预测结果呢？

        3、如果此次任务算是实现拟合函数功能，那过程有什么不标准或可改进的吗？如果此次任务不算是预测，那么该如何使用已知数据实现未来数据的预测呢？

        欢迎大家讨论，也希望大佬答疑，谢谢！

啥啥都喜欢
关注
  • 3
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
使用pytorch搭建lstm时间序列预测
weixin_43745234的博客
08-11 6917
前言：网上找的代码是keras以tensorflow为后端的，苦于不知道具体版本号，所以各种报错，所以参考网上的代码将其修改为基于pytorch的。后来想明白了，除了前八个数没有，其他数经过迭代，Y里面都包含了，所以观察上面两个图，会发现第二幅图比第一幅图少了前面一截数据图。我的疑问，time_step = 8，意味着每8个数据预测下一个数据，为什么预测后的图画出来和原始数据的形状一直呢？3，data[:,0] data[1,:]的含义。下图是归一化后的原数据和预测数据。下图是没有归一化过的原数据。....
pytorch利用LSTM实现对股票进行多变量多步预测
09-10
在PyTorch中，利用LSTM（长短时记忆网络）进行多变量多步股票预测是一项常见的任务，它涉及金融市场的数据分析、时间序列预测以及深度学习技术。以下将详细阐述这一主题的相关知识点。 首先，我们需要理解LSTM的...
使用Python实现长短时记忆网络（LSTM）的博客教程
Echo_Wish的博客
05-13 1633
长短时记忆网络是一种循环神经网络的变体，通过引入特殊的记忆单元（记忆细胞）和门控机制，可以有效地处理和记忆长序列中的信息。LSTM的核心是通过门控单元来控制信息的流动，从而保留和遗忘重要的信息，解决了普通RNN中梯度消失或爆炸的问题。我们定义一个简单的LSTM模型，包括一个LSTM层和一个全连接层。out = self.fc(out[:, -1, :]) # 取最后一个时间步的输出return out# 定义模型参数input_size = 1 # 输入特征维度（时间序列数据维度）
基于pytorch的LSTM模型训练与预测（附源码）
qq_65960840的博客
06-14 4200
关于这个模型的基本概念可以查看这篇文章，写得很详细，我觉得能大概看明白反向传递各个部分的推导就行了。
PyTorch搭建LSTM实现时间序列预测（负荷预测）
热门推荐
KI的博客
01-18 9万+
PyTorch搭建LSTM实现时间序列预测（负荷预测）
PyTorch搭建LSTM实现多变量时间序列预测（负荷预测）
KI的博客
03-24 4万+
PyTorch搭建LSTM实现多变量时间序列预测（负荷预测）
pytorch实现LSTM（附code）
ting_qifengl的博客
01-23 6万+
最近搞了一个NASA PCoE的IGBT加速老化数据，想基于pytorch框架写一个LSTM模型进行IGBT退化状态的预测，于是有了这篇文章。 注：LSTM的原理就不多讲了，网上一大堆，不懂的自己去百度，本文主要侧重代码实现。 一、数据集介绍 本数据集是NASA PCoE研究中心公布的IGBT加速老化数据集。数据集含有四种实验条件下的IGBT加速老化数据，以下是实验条件： （1）新设备的源测量单元（SMU data for new devices） 该文件中含有一组原始实验条件下的电气特性数据，分
基于pytorch的LSTM预测实现（入门级别）
m0_68676807的博客
06-04 1991
基于pytorch框架的LSTM时间序列预测，入门级别
PyTorch搭建LSTM实现多变量多步长时间序列预测（一）：直接多输出
KI的博客
04-04 3万+
PyTorch搭建LSTM实现多变量多步长时间序列预测（负荷预测）
PyTorch搭建LSTM实现多变量输入多变量输出时间序列预测（多任务学习）
KI的博客
06-12 2万+
PyTorch搭建LSTM实现多变量输入多变量输出时间序列预测
PyTorch搭建双向LSTM实现时间序列预测（负荷预测）
KI的博客
04-19 1万+
PyTorch搭建双向LSTM实现时间序列预测（负荷预测）
Pytorch使用 LSTM RNN 的词级语言建模代码.zip
08-13
PyTorch作为一个强大的深度学习框架，提供了灵活的接口来实现这种模型，特别是通过长短期记忆网络（LSTM）和循环神经网络（RNN）。本文件“Pytorch使用 LSTM RNN 的词级语言建模代码.zip”应该包含了一个使用PyTorch...
基于pytorch的RNN、LSTM回归预测
04-12
datas/ 三份数据集 error_value/ 每种方法预测结果的评价指标（RMSE，MAE，MAPE） fig_res/ 预测曲线图 ...超参数.docx 三份数据集，RNN，LSTM，AM-LSTM三种方法所用超参数。MLP和SVR没调，可能意义不大
project2_pytorch实现lstm_
09-29
在本文中，我们将深入探讨如何使用PyTorch框架来实现长短期记忆（LSTM）神经网络。长短期记忆网络是一种特殊的循环神经网络（RNN），它解决了标准RNN在处理长期依赖问题时可能出现的梯度消失或梯度爆炸问题。PyTorch...
vite5+vue3开发阅读APP实战笔记20240725
Python私教
07-25 594
修改src/page/home/index.vue，使用组件和API。注意，这里无论是组件还是API，都不需要我们手动引入，我们配置了自动导入以后，vite会帮我们自动导入。创建 src/page/home/index.vue。修改 vite.config.js。修改vite.config.js。修改 src/main.js。修改src/App.vue。
Golang学习笔记20240725，Go语言基础语法
最新发布
Python私教
07-25 659
如果我们在遍历的时候，不想要key或者value，也可以用下划线替代，下划线叫做匿名变量。go语言里面的switch语句每个case天生就是独立的，不需要加break。指针可以直接对内存地址进行操作。使用*表示指针，使用&取地址。切片在go语言里面非常常用，因为其有动态扩展的特性。运行方式3：goland右键运行。使用加号可以对字符串进行拼接。
学习笔记-系统框图传递函数公式推导
weixin_45875994的博客
07-24 978
输出C(s)是前向路径（通过G(s)）的输出与反馈路径（通过H(s)）的输出之差（在负反馈系统中）。因此，我们可以写出以下关系式：这里，G(s)R(s)是前向路径的输出，而G(s)H(s)C(s)是反馈路径的输出（注意，反馈路径的输出先经过H(s)，再与前向路径的输出相减）。
pytorch LstmRNN用法
07-20
在 PyTorch 中使用 LSTM 进行建模的步骤如下： 1. 导入必要的库和模块： ```python import torch import torch.nn as nn ``` 2. 定义 LSTM 模型： ```python class LSTMModel(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim): super(LSTMModel, self).__init__() self.hidden_dim = hidden_dim self.lstm = nn.LSTM(input_dim, hidden_dim) self.fc = nn.Linear(hidden_dim, output_dim) def forward(self, x): lstm_out, _ = self.lstm(x) out = self.fc(lstm_out[:, -1, :]) return out ``` 在这个例子中，我们定义了一个名为 LSTMModel 的类，继承自 nn.Module。在构造函数中，我们定义了 LSTM 层和全连接层。forward 方法用于定义数据在模型中的流动方式。 3. 实例化模型： ```python input_dim = 10 # 输入维度 hidden_dim = 32 # 隐藏层维度 output_dim = 1 # 输出维度 model = LSTMModel(input_dim, hidden_dim, output_dim) ``` 4. 定义损失函数和优化器： ```python criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.01) ``` 5. 准备数据并进行训练： ```python # 假设有训练数据 x 和目标值 y # 转换数据为 PyTorch 张量 x = torch.tensor(x, dtype=torch.float32) y = torch.tensor(y, dtype=torch.float32) # 前向传播和计算损失 outputs = model(x) loss = criterion(outputs, y) # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() ``` 这是一个简单的使用 PyTorch 实现 LSTM 模型的示例。你可以根据自己的数据和任务进行适当的调整和扩展。记得根据具体情况调整模型架构、超参数和训练过程，以获得更好的性能。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值