pytorch框架LSTM(RNN)实现预测

一、环境配置

        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
    点赞
  • 39
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
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、付费专栏及课程。

余额充值