1. Python技术站首页
  2. Python开发
  3. python

Python中LSTM回归神经网络时间序列预测详情

• python

以下是Python中LSTM回归神经网络时间序列预测的完整攻略，包括两个示例。

LSTM回归神经网络时间序列预测的基本步骤

LSTM回归神经网络时间序预测的基本步骤如下：

  1. 导入必要的库
import numpy as
import pandas as pd
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
  1. 准备数据

准备时间序列数据，将其转换为适合LSTM模的格式。

class TimeSeriesDataset(Dataset):
    def __init__(self, data, seq_len):
        self.data = data
        self.seq_len = seq_len

    def __len__(self):
        return len(self.data) - self.seq_len

    def __getitem__(self, idx):
        x = self.data[idx:idx+self.seq_len]
        y = self.data[idx+self.seq_len]
        return x, y

# 加载数据
data = pd.read_csv('data.csv', header=None)
data = data.values.astype('float32')

# 划分训练集和测试集
train_size int(len(data) * 0.8)
train_data = data[:train_size]
test_data = data[train_size:]

# 标准化数据
mean = train_data.mean(axis=0)
std = train_data.std(axis=0)
train_data = (train_data - mean) / std
test_data = (test_data - mean) / std

# 创建数据集
seq_len = 10
train_dataset = TimeSeriesDataset(train_data, seq_len)
test_dataset = TimeSeriesDataset(test_data, seq_len)

# 创建数据加载器
batch_size = 32
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
  1. 定义模型

定义LSTM模型。

class LSTM(nn.Module):
    def __init__(self, input_size,_size, num_layers, output_size):
        super(LSTM, 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):
        out, _ = self.lstm(x)
        out = out[:, -1, :]
        out = self.fc(out)
        return out
  1. 训练模型

训练LSTM模型。

# 定义模型
input_size = 1
hidden_size = 32
num_layers 2
output_size = 1
model = LSTM(input_size, hidden_size, num_layers, output_size)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 100
for epoch in range(num_epochs):
    for i, (x, y) in enumerate(train_loader):
        # 前向传播
        x = x.unsqueeze(-1)
        y_pred = model(x)

        # 计算损失
        loss = criterion(y_pred, y)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 打印损失
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))
  1. 测试模型

测试LSTM模型。

# 测试模型
model.eval()
with torch.no_grad():
    y_pred = []
    for x, y in test_loader:
        x = x.unsqueeze(-1)
        y_pred.append(model(x).squeeze().numpy())
    y_pred = np.concatenate(y_pred)

# 反标准化数据
y_pred = y_pred * std[-1] + mean[-1]
y_true = test_data[seq_len:, -1] * std[-1] + mean[-1]

# 绘制预测结果
plt.plot(y_true, label='True')
plt.plot(y_pred, label='Predicted')
plt.legend()
plt.show()

以上是Python中LSTM回归神经网络时间序列预测的完整攻略，通过以上步骤和示例，我们可以轻松地使用LSTM模型进行时间序列预测。

示例一：使用LSTM模型预测股票价格

以下是使用LSTM模型预测股票价格的示例代码：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader

# 加载数据
data = pd.read_csv('stock.csv')
data = data['Close'].values.astype('float32')

# 划分训练集和测试集
train_size = int(len(data) * 0.8)
train_data = data[:train_size]
test_data = data[train_size:]

# 标准化数据
mean = train_data.mean()
std = train_data.std()
train_data = (train_data - mean) / std
test_data = (test_data - mean) / std

# 创建数据集
seq_len = 10
train_dataset = TimeSeriesDataset(train_data, seq_len)
test_dataset = TimeSeriesDataset(test_data, seq_len)

# 创建数据加载器
batch_size = 32
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 定义模型
input_size = 1
hidden_size = 32
num_layers = 2
output_size = 1
model = LSTM(input_size, hidden_size, num_layers, output_size)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 100
for epoch in range(num_epochs):
    for i, (x, y) in enumerate(train_loader):
        # 前向传播
        x = x.unsqueeze(-1)
        y_pred = model(x)

        # 计算损失
        loss = criterion(y_pred, y)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 打印损失
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# 测试模型
model.eval()
with torch.no_grad():
    y_pred = []
    for x, y in test_loader:
        x = x.unsqueeze(-1)
        y_pred.append(model(x).squeeze().numpy())
    y_pred = np.concatenate(y_pred)

# 反标准化数据
y_pred = y_pred * std + mean
y_true = test_data[seq_len:] * std + mean

# 绘制预测结果
plt.plot(y, label='True')
plt.plot(y_pred, label='Predicted')
plt.legend()
plt.show()

上面的代码使用LSTM模型预测股票价格。

示例二：使用LSTM模型预测气温

以下使用LSTM模型预测气温的示例代码：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader

# 加载数据
data = pd.read_csv('temperature.csv')
data = data['Temperature'].values.astype('float32')

# 划分训练集和测试集
train_size = int(len(data) * 0.8)
train_data = data[:train_size]
test_data = data[train_size:]

# 标准化数据
mean = train_data.mean()
std = train_data.std()
train_data = (train_data - mean) / std
test_data = (test_data - mean) / std

# 创建数据集
seq_len = 10
train_dataset = TimeSeriesDataset(train_data, seq_len)
test_dataset = TimeSeriesDataset(test_data, seq_len)

# 创建数据加载器
batch_size = 32
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 定义模型
input_size = 1
hidden_size = 32
num_layers = 2
output_size = 1
model LSTM(input_size, hidden_size, num_layers, output_size)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 
for epoch in range(num_epochs):
    for i, (x, y) in enumerate(train_loader):
        # 前向传播
        x = x.unsqueeze(-1)
        y_pred = model(x)

        # 计算损失
        loss = criterion(y_pred, y)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 打印损失
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# 测试模型
model.eval()
with torch.no_grad():
    y_pred = []
    for x, y in test_loader:
        x = x.unsqueeze(-1)
        y_pred.append(model(x).squeeze().numpy())
    y_pred = np.concatenate(y_pred)

# 反标准化数据
y_pred = y_pred * std + mean
y_true = test_data[seq_len:] * std + mean

# 绘制预测结果
plt.plot(y_true, label='True')
plt.plot(y_pred label='Predicted')
plt.legend()
plt.show()

上面的代码使用LSTM模型预测气温。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Python中LSTM回归神经网络时间序列预测详情 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月14日
下一篇 2023年5月14日

相关文章

  • keras 自定义loss损失函数,sample在loss上的加权和metric详解

    Keras自定义Loss损失函数、Sample在Loss上的加权和Metric详解 在本攻略中，我们将介绍如何在Keras中自定义Loss损失函数、Sample在Loss上的加权和Metric。以下是完整的攻略，含两个示例说明。 示例1：自定义Loss损失函数 以下是在Keras中自定义Loss损失函数的步骤： 导入必要的库。可以使用以下命令导入必要的库： …

    python 2023年5月14日
    00

  • 使用numpy.ndarray添加元素

    NumPy是Python中常用的数值计算库，它提供了一些常用的函数和方法，方便地进行数值计算。其中，numpy.ndarray是NumPy的重要类，它表示一个多维数组对象。本文将详细讲解“使用numpy.ndarray添加元素”的完整攻略，包括如何使用numpy.append()函数和numpy.concatenate()函数添加元素的方法。 示例1：使用n…

    python 2023年5月14日
    00

  • Python NumPy教程之数组的创建详解

    Python NumPy教程之数组的创建详解 NumPy是Python中一个重要的科学计算库，提供了高效的多维数组和各种派生对象及算种函数。在NumPy中，可以使用ndarray多维数组来各数据处理操作，包括创建、索引、切片、运算等。本文将详细讲解Numpy数组的创建，包括使用array()函数使用zeros()函数、使用ones()函数、使用empty()…

    python 2023年5月13日
    00

  • Python图像处理库crop()函数 thumbnail方法使用详解

    Python图像处理库crop()函数 thumbnail方法使用详解 简介 Python的图像处理库有很多种，如Pillow（PIL）和OpenCV等。其中Pillow是一个友好易用的Python图像处理库，提供了众多的图像处理功能。crop()函数和thumbnail()方法是其中常用的两个功能之一。crop()函数用于从图像中截取一部分区域，而thum…

    python 2023年5月14日
    00

  • 使用Numpy读取CSV文件,并进行行列删除的操作方法

    下面是关于“使用Numpy读取CSV文件，并进行行列删除的操作方法”的完整攻略，包含了两个示例。 使用Numpy读取CSV文件 使用Numpy可以方便地读取CSV文件。下面是一个示例，演示如何使用Numpy读取文件。 import numpy as np # 读取CSV文件 data = np.genfromtxt(‘data.csv’, delimiter…

    python 2023年5月14日
    00

  • 支持python的分布式计算框架Ray详解

    支持Python的分布式计算框架Ray详解 Ray是一个支持Python的分布式计算框架，它可以帮助用户轻松地编写并行和分布式应用程序。Ray提供了一组API，使得编写行和分布式应用程序变得更加容易。本文将详细介绍Ray的特点、使用方法和示例。 Ray的特点 Ray具有以下特点： 简单易用：Ray提供了一组简单易用的API，使得编写并行和分布式应用程序变得更…

    python 2023年5月14日
    00

  • PyCharm导入numpy库的几种方式

    PyCharm是一款常用的Python集成开发环境，可以方便地导入各种Python库。本文将详细讲解PyCharm导入numpy库的几种方式，包括使用conda、pip和PyCharm自带的包管理器等，并提供两个示例。 使用conda导入numpy库 conda是一个流行的Python包管理器，可以方便地安装和管理Python库。下面是使用conda导入nu…

    python 2023年5月13日
    00

  • numpy增加维度、删除维度的方法

    在Numpy中，可以使用reshape()函数增加或删除数组的维度，也可以使用squeeze()函数删除数组中长度为1的维度。下面是详细的讲解和示例： 增加维度 在Numpy中，可以使用reshape()函数增加数组的维度。reshape()函数的用法如下： import numpy as np # 创建一个形状为(2, 3)的二维数组 a = np.arr…

    python 2023年5月13日
    00
合作推广
合作推广
分享本页
返回顶部