基于Pytorch框架的LSTM算法(二)——多维度单步预测

已于 2023-11-06 20:24:01 修改
阅读量1k 收藏 12
点赞数 2
分类专栏： 深度学习算法——Pytorch 文章标签： pytorch lstm 算法
于 2023-11-06 20:22:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38633279/article/details/134253836
版权

1.项目说明

**选用Close和Low两个特征，使用窗口time_steps窗口的2个特征，然后预测Close这一个特征数据未来一天的数据

当batch_first=True,则LSTM的inputs=(batch_size,time_steps,input_size)

batch_size = len(data)-time_steps
time_steps = 滑动窗口，本项目中值为lookback
input_size = 2【因为选取了Close和Low两个特征】**

2.数据集

参考：https://blog.csdn.net/qq_38633279/article/details/134245512?spm=1001.2014.3001.5501中的数据集

3.数据预处理

3.1 读取数据

import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import MinMaxScaler
import torch
import torch.nn as nn
import seaborn as sns
import math, time
from sklearn.metrics import mean_squared_error


filepath = './data/rlData.csv'
data = pd.read_csv(filepath)
data = data.sort_values('Date')
data.head()
data.shape

sns.set_style("darkgrid")
plt.figure(figsize = (15,9))
plt.plot(data[['Close']])
plt.xticks(range(0,data.shape[0],20), data['Date'].loc[::20], rotation=45)
plt.title("****** Stock Price",fontsize=18, fontweight='bold')
plt.xlabel('Date',fontsize=18)
plt.ylabel('Close Price (USD)',fontsize=18)
plt.show()

3.2 选取Close和Low两个特征

price = data[['Close', 'Low']]

3.3 数据归一化

scaler = MinMaxScaler(feature_range=(-1, 1))
price['Close'] = scaler.fit_transform(price['Close'].values.reshape(-1,1))
price['Low'] = scaler.fit_transform(price['Low'].values.reshape(-1,1))

3.4 数据集的制造[batch_size,time_steps,input_size]

本次选取2个维度特征作为输出，因此，input_size =2
x_train.shape = [batch_size,time_steps,input_size]
y_train.shape = [batch_size,1]

1. 输入选取的是Close和Low列作为多维度的输入，所以选择的是data数据中的第一列和第二列作为x_train【因此input_size=2】
2. 输出是选取的Close列作为预测，所以选取data数据的第一列作为y_train【即Close列作为y_train】。

#2.数据集的制作
def split_data(stock, lookback):
    data_raw = stock.to_numpy() 
    data = []    
    for index in range(len(data_raw) - lookback): 
        data.append(data_raw[index: index + lookback])
    
    data = np.array(data);
    test_set_size = int(np.round(0.2 * data.shape[0]))
    train_set_size = data.shape[0] - (test_set_size)
    
    x_train = data[:train_set_size,:-1,:]  #x_train.shape =  (198, 4, 2)
    y_train = data[:train_set_size,-1,0:1] #y_train.shape =  (198, 1)
    
    x_test = data[train_set_size:,:-1,:]   #x_test.shape =  (49, 4, 2)
    y_test = data[train_set_size:,-1,0:1]  #y_test.shape =  (49, 1)
    
    return [torch.Tensor(x_train), torch.Tensor(y_train), torch.Tensor(x_test),torch.Tensor(y_test)]
   
lookback = 5
x_train, y_train, x_test, y_test = split_data(price, lookback)
print('x_train.shape = ',x_train.shape)
print('y_train.shape = ',y_train.shape)
print('x_test.shape = ',x_test.shape)
print('y_test.shape = ',y_test.shape)

4.LSTM算法

这里的LSTM算法和单维单步预测中的LSTM预测算法一模一样。只不过我们在制作数据集的时候，对于LSTM模型中输入不一样了。

class LSTM(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers, output_dim):
        super(LSTM, self).__init__()
        self.hidden_dim = hidden_dim
        self.num_layers = num_layers
        
        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_dim).requires_grad_()
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_dim).requires_grad_()
        out, (hn, cn) = self.lstm(x, (h0.detach(), c0.detach()))
        out = self.fc(out[:, -1, :])

5.预训练

input_dim = 2
hidden_dim = 32
num_layers = 2
output_dim = 1
num_epochs = 100

model = LSTM(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim, num_layers=num_layers)
criterion = torch.nn.MSELoss()
optimiser = torch.optim.Adam(model.parameters(), lr=0.01)

hist = np.zeros(num_epochs)
lstm = []

for t in range(num_epochs):
    y_train_pred = model(x_train)

    loss = criterion(y_train_pred, y_train)
    hist[t] = loss.item()
    # print("Epoch ", t, "MSE: ", loss.item())
    optimiser.zero_grad()
    loss.backward()
    optimiser.step()

6.绘制预测值和真实值拟合图形，以及loss图形

predict = pd.DataFrame(scaler.inverse_transform(y_train_pred.detach().numpy()))
original = pd.DataFrame(scaler.inverse_transform(y_train.detach().numpy()))


sns.set_style("darkgrid")    

fig = plt.figure()
fig.subplots_adjust(hspace=0.2, wspace=0.2)

plt.subplot(1, 2, 1)
ax = sns.lineplot(x = original.index, y = original[0], label="Data", color='royalblue')
ax = sns.lineplot(x = predict.index, y = predict[0], label="Training Prediction (LSTM)", color='tomato')
ax.set_title('Stock price', size = 14, fontweight='bold')
ax.set_xlabel("Days", size = 14)
ax.set_ylabel("Cost (USD)", size = 14)
ax.set_xticklabels('', size=10)

plt.subplot(1, 2, 2)
ax = sns.lineplot(data=hist, color='royalblue')
ax.set_xlabel("Epoch", size = 14)
ax.set_ylabel("Loss", size = 14)
ax.set_title("Training Loss", size = 14, fontweight='bold')
fig.set_figheight(6)
fig.set_figwidth(16)


# make predictions
y_test_pred = model(x_test)

# invert predictions
y_train_pred = scaler.inverse_transform(y_train_pred.detach().numpy())
y_train = scaler.inverse_transform(y_train.detach().numpy())
y_test_pred = scaler.inverse_transform(y_test_pred.detach().numpy())
y_test = scaler.inverse_transform(y_test.detach().numpy())

# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(y_train[:,0], y_train_pred[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(y_test[:,0], y_test_pred[:,0]))
print('Test Score: %.2f RMSE' % (testScore))
lstm.append(trainScore)
lstm.append(testScore)
lstm.append(training_time)

完整代码

问题描述：
选用Close和Low两个特征，使用窗口time_steps窗口的2个特征，然后预测Close这一个特征数据未来一天的数据
当batch_first=True,则LSTM的inputs=(batch_size,time_steps,input_size)
batch_size = len(data)-time_steps
time_steps = 滑动窗口，本项目中值为lookback
input_size = 2【因为选取了Close和Low两个特征】
#%%
import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import MinMaxScaler
import torch
import torch.nn as nn
import seaborn as sns
import math, time
from sklearn.metrics import mean_squared_error


filepath = './data/rlData.csv'
data = pd.read_csv(filepath)
data = data.sort_values('Date')
data.head()
data.shape

sns.set_style("darkgrid")
plt.figure(figsize = (15,9))
plt.plot(data[['Close']])
plt.xticks(range(0,data.shape[0],20), data['Date'].loc[::20], rotation=45)
plt.title("****** Stock Price",fontsize=18, fontweight='bold')
plt.xlabel('Date',fontsize=18)
plt.ylabel('Close Price (USD)',fontsize=18)
plt.show()


#1.选取特征工程2个
price = data[['Close', 'Low']]

scaler = MinMaxScaler(feature_range=(-1, 1))
price['Close'] = scaler.fit_transform(price['Close'].values.reshape(-1,1))
price['Low'] = scaler.fit_transform(price['Low'].values.reshape(-1,1))

#2.数据集的制作
def split_data(stock, lookback):
    data_raw = stock.to_numpy() 
    data = []    
    for index in range(len(data_raw) - lookback): 
        data.append(data_raw[index: index + lookback])
    
    data = np.array(data);
    test_set_size = int(np.round(0.2 * data.shape[0]))
    train_set_size = data.shape[0] - (test_set_size)
    
    x_train = data[:train_set_size,:-1,:]  #x_train.shape =  (198, 4, 2)
    y_train = data[:train_set_size,-1,0:1] #y_train.shape =  (198, 1)
    
    x_test = data[train_set_size:,:-1,:]   #x_test.shape =  (49, 4, 2)
    y_test = data[train_set_size:,-1,0:1]  #y_test.shape =  (49, 1)
    
    return [torch.Tensor(x_train), torch.Tensor(y_train), torch.Tensor(x_test),torch.Tensor(y_test)]
   
lookback = 5
x_train, y_train, x_test, y_test = split_data(price, lookback)
print('x_train.shape = ',x_train.shape)
print('y_train.shape = ',y_train.shape)
print('x_test.shape = ',x_test.shape)
print('y_test.shape = ',y_test.shape)



class LSTM(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers, output_dim):
        super(LSTM, self).__init__()
        self.hidden_dim = hidden_dim
        self.num_layers = num_layers
        
        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_dim).requires_grad_()
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_dim).requires_grad_()
        out, (hn, cn) = self.lstm(x, (h0.detach(), c0.detach()))
        out = self.fc(out[:, -1, :]) 
        return out

input_dim = 2
hidden_dim = 32
num_layers = 2
output_dim = 1
num_epochs = 100

model = LSTM(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim, num_layers=num_layers)
criterion = torch.nn.MSELoss()
optimiser = torch.optim.Adam(model.parameters(), lr=0.01)

hist = np.zeros(num_epochs)
lstm = []

for t in range(num_epochs):
    y_train_pred = model(x_train)

    loss = criterion(y_train_pred, y_train)
    hist[t] = loss.item()
    # print("Epoch ", t, "MSE: ", loss.item())
    optimiser.zero_grad()
    loss.backward()
    optimiser.step()
    
predict = pd.DataFrame(scaler.inverse_transform(y_train_pred.detach().numpy()))
original = pd.DataFrame(scaler.inverse_transform(y_train.detach().numpy()))


sns.set_style("darkgrid")    

fig = plt.figure()
fig.subplots_adjust(hspace=0.2, wspace=0.2)

plt.subplot(1, 2, 1)
ax = sns.lineplot(x = original.index, y = original[0], label="Data", color='royalblue')
ax = sns.lineplot(x = predict.index, y = predict[0], label="Training Prediction (LSTM)", color='tomato')
ax.set_title('Stock price', size = 14, fontweight='bold')
ax.set_xlabel("Days", size = 14)
ax.set_ylabel("Cost (USD)", size = 14)
ax.set_xticklabels('', size=10)

plt.subplot(1, 2, 2)
ax = sns.lineplot(data=hist, color='royalblue')
ax.set_xlabel("Epoch", size = 14)
ax.set_ylabel("Loss", size = 14)
ax.set_title("Training Loss", size = 14, fontweight='bold')
fig.set_figheight(6)
fig.set_figwidth(16)


# make predictions
y_test_pred = model(x_test)

# invert predictions
y_train_pred = scaler.inverse_transform(y_train_pred.detach().numpy())
y_train = scaler.inverse_transform(y_train.detach().numpy())
y_test_pred = scaler.inverse_transform(y_test_pred.detach().numpy())
y_test = scaler.inverse_transform(y_test.detach().numpy())

# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(y_train[:,0], y_train_pred[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(y_test[:,0], y_test_pred[:,0]))
print('Test Score: %.2f RMSE' % (testScore))
lstm.append(trainScore)
lstm.append(testScore)
lstm.append(training_time)

参考：https://gitee.com/qiangchen_sh/stock-prediction/blob/master/%E4%BB%A3%E7%A0%81/LSTM%E4%BB%8E%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80%E5%88%B0%E4%BB%A3%E7%A0%81%E5%AE%9E%E6%88%98%204%20%E5%A4%9A%E7%BB%B4%E7%89%B9%E5%BE%81%E8%82%A1%E7%A5%A8%E4%BB%B7%E6%A0%BC%E9%A2%84%E6%B5%8B_Pytorch.ipynb

小维_
关注
专栏目录
LSTM进阶：使用LSTM进行多维多步的时间序列预测
小EZ的博客
05-17 10万+
各位朋友大家好，今天来讲一下LSTM时间序列的预测进阶。 现在我总结一下常用的LSTM时间序列预测： 1.单维单步（使用前两步预测后一步） 可以看到trainX的shape为 (5,2) trainY为(5,1) 在进行训练的过程中要将trainX reshape为 (5,2,1)(LSTM的输入为 [samples, timesteps, features] 这里的timesteps为...
基于pytorch搭建多特征LSTM时间序列预测代码
ducanwang的博客
01-29 1069
print('Epoch: {}/{} - Loss: {:.4f}'.format(epoch+1, 500, loss.item())) # 输出损失。mse = mean_squared_error(y_test, outputs.detach().numpy()) # 使用测试集评估模型。optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 优化器，这里使用Adam优化器。loss.backward() # 反向传播。
LSTM网络多维预测
05-03
利用LSTM循环神经网络对多维数据进行预测，先对数据进行归一化处理，划分为训练集、测试集，用4个参数预测一个参数值
LSTM多维度预测
懒
07-19 1030
# 导入资源 import numpy as np import matplotlib.pyplot as plt import pandas as pd from sklearn.preprocessing import MinMaxScaler from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM # 设置plt中文字体 from HDFS import HDF.
基于Python LSTM的多维数据预测
最新发布
2301_79810943的博客
05-27 1048
一、项目背景与意义在现实世界的数据分析中，我们经常需要处理多维数据（multi-variate data），这些数据往往具有复杂的时空关系和时间依赖性。传统的预测方法在处理这类数据时往往效果不佳，因为它们无法有效捕捉数据中的长期依赖关系。LSTM作为一种特殊的循环神经网络（RNN），通过引入门控机制，能够学习并记忆数据中的长期依赖关系，因此在多维数据预测领域具有广泛的应用前景。
lstm.zip_lstm 预测_lstm 多维_lstm 时序_lstm多维单步_多维参数预测
07-14
实现一多维时序数据的预测，相关参数可自行修改
pytorch框架LSTM(RNN)实现预测
m0_53707852的博客
06-10 4218
pytorch框架LSTM(RNN)实现预测，目标任务：根据现有数据，预测未来数据。
龙格库塔迭代与基于pytorch的RNN循环神经网络在正弦函数拟合效果上的有趣对比
weixin_46047216的博客
05-26 1929
突发奇想，如果将龙格库塔迭代的曲线拟合与深度学习中的RNN循环神经网络的曲线拟合做一个对比，会出现什么意想不到的效果？答案当然是龙格库塔迭代效果更好，杀鸡焉用牛刀？但是，在某些特殊情况下，比如我们很难对微分方程求导的时候，我们该如何对原方程进行拟合呢？这时候，机器学习就派上用场了。 首先介绍一下龙格库塔法（Runge-Kutta method): 一、龙格库塔迭代是数值分析课程中接触过的也是用途十分广泛的高精度单步算法，误差可以小到10^-5以下。我们常用的是四阶龙格库塔法，已知导数和初始值： y′=f(x
RNN 、LSTM、 GRU、Bi-LSTM 等常见循环网络结构以及其Pytorch实现
MirrorN的博客
03-19 8969
这篇文章主要是对之前一段时间里接触到的 循环神经网络 的相关知识进行一些总结，包括个人觉得初学难理解或者需要注意的问题和如何使用Pytorch的相关函数。由于这些经典结构网上资料很多，所以一些通识不再陈述，偏重代码部分。 文章目录1.RNN2.LSTM3. GRU4. Multi-Layers-LSTM4. Bi-LSTM5.参考 1.RNN 很多问题都归结于序列信息的处理，例如 speech r...
滴普技术荟：基于机器视觉的典型多目标追踪算法应用实践
Deepexi_Date的博客
12-01 914
视频目标追踪算法是机器视觉中一项很实用重要的算法，视频目标追踪算法应用场景很广，比如智能监控、机器人视觉系统、虚拟现实（人体跟踪）、医学诊断（细胞状态跟踪）等。本文由滴普科技2048团队AI产品部算法工程师朱晓丽介绍基于机器视觉的典型多目标追踪算法应用实践。 一、追踪算法概述 目标追踪算法分为单目标追踪SOT（single-object track）和多目标追踪MOT(multi-object track)。在单目标跟踪中，使用给定的目标定位，在后续视频帧中对给定的目标定位的物体进行位置预测。而多目标跟踪算
LSTM多变量预测
09-24
LSTM多变量预测，本程序利用TensorFlow构建一个简易LSTM模型，内含对多个变量因子，以及本程序的运行环境。
Python-在PyTorch中使用LSTM进行风速预测
08-11
在PyTorch中使用LSTM进行风速预测
（python源码）（基于torch框架）基于LSTM的时间序列预测算法实现
05-15
基于LSTM（Long Short-Term Memory）的时间序列预测算法是一种在深度学习中广泛应用的算法，特别适用于处理和预测具有长期依赖性的时间序列数据。LSTM是一种特殊的循环神经网络（RNN），通过引入门控机制来解决传统RNN在处理长序列时容易出现的梯度消失和梯度爆炸问题。 算法原理 LSTM的核心在于其独特的网络结构和门控机制。LSTM单元由输入门、遗忘门和输出门组成，这些门控结构允许网络选择性地保留或遗忘之前的信息。具体来说： 输入门：决定当前时刻的输入信息有多少可以保存到细胞状态中。 遗忘门：决定上一时刻的细胞状态有多少可以保留到当前时刻。 输出门：决定当前时刻的细胞状态有多少可以输出到LSTM的当前输出值。 通过这些门控机制，LSTM能够捕捉到时间序列数据中的长期依赖关系，并在预测时考虑到这些依赖关系。
目标检测YOLO实战应用案例100讲-基于激光雷达点云的三维目标检测算法研究(下)
qq_36130719的博客
04-25 315
Pseudo-LiDAR采样可以遵循随机性的方法，对全部点云进行采样，然而该方式很可能会抹去小物体的点云，对相隔较远处的物体检测衰减也能够预期，如图。功能，因此本文将掩码乘到对应的原始点云特征𝑝上，再与原始𝑝以残差连接的方式相加，得到最终的融合特征，最终输出定义如公式4-5所示。主干特征的提取网络选择Densenet161，对深度估计模型进行训练并收敛，以视为后续端到端训练的的预训练模型。根据表5-1可以得知，本文建立的实验神经网络模型数量达到6个，Base表示的是基线，SSIS确定的。
FastAI：基于机器视觉的典型多目标追踪算法应用实践
DEEPEXI_2048Lab的博客
12-22 1025
视频目标追踪算法是机器视觉中一项很实用重要的算法，视频目标追踪算法应用场景很广，比如智能监控、机器人视觉系统、虚拟现实（人体跟踪）、医学诊断（细胞状态跟踪）等。本文由滴普科技2048团队AI产品部算法工程师朱晓丽介绍基于机器视觉的典型多目标追踪算法应用实践。 一、概述 目标追踪算法分为单目标追踪SOT（Single-Object Track）和多目标追踪MOT(Multi-Object Track)[1][2]。在单目标跟踪中，使用给定的初始目标位置，在后续视频帧中对给定的物体进行位置预测。而多目标跟踪算.
Pytorch LSTM 时间序列预测
热门推荐
zchenack个人专栏
12-02 1万+
详情可以参见文章import torch import torch.nn as nn from torch.autograd import * import torch.optim as optim import torch.nn.functional as F import matplotlib.pyplot as plt import numpy as np def SeriesGen(N)...
基于LSTM多维度特征的资金流预测
STAR GAME
05-27 7786
LSTM多维度项目背景观察数据进行处理特征选择合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 项目背景 本篇主要是使用天池比赛中...
Pytorch实现LSTM预测模型并使用C++相应的ONNX模型推理
午夜的行人
09-15 934
【代码】Pytorch实现LSTM预测模型并使用C++相应的ONNX模型推理。
使用PyTorch训练LSTM预测模型
csdn1561168266的博客
07-14 2823
大家好，长短期记忆网络（LSTM）是RNN的一种变体，RNN由于梯度消失的原因只能有短期记忆，LSTM网络通过精妙的门控制将短期记忆与长期记忆结合起来，并且一定程度上解决了梯度消失的问题。在开始新的优化迭代之前重置了模型参数的梯度，因为在PyTorch中默认情况下梯度会累积，如果不将其清零，则会导致在后续迭代中出现不正确的梯度计算。这个函数的目的是为了生成用于训练和测试时间序列预测模型的输入-输出对，输入-输出对是通过在时间序列数据上滑动一个给定长度（：输出的大小（例如，预测值的数量）。
lstm多维单步预测
09-27
多维单步预测是指在多维时间序列数据中，使用LSTM模型对未来一步进行预测。为了进行多维单步预测，您需要将每个时间步的多个维度作为输入，然后预测下一个时间步的多个维度。 在多维单步预测中，可以使用具有多个LSTM层的模型来对每个维度进行建模。每个LSTM层都有自己的记忆和隐藏状态，这样可以捕捉到每个维度的时间依赖关系。除了LSTM层之外，还可以添加全连接层来提高模型的性能和准确性。 在训练模型时，您可以使用历史时间步的数据作为输入，并将下一个时间步的数据作为目标进行训练。通过反复迭代训练，模型可以学习到时间序列中的模式和趋势，并用于未来一步的预测。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值