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 读取多标签图像数据方式

    Keras读取多标签图像数据方式 在深度学习中，多标签分类是一种常见的任务。在处理多标签图像数据时，我们一种有效的方式来读取和处理数据。本文将介绍使用Keras读取多标签图像数据的方法。 方法一：使用ImageDataGenerator Keras提供了一个ImageDataGenerator类，可以便地读取和处理图像数据。以下是一个使用ImageDataG…

    python 2023年5月14日
    00

  • Python中矩阵库Numpy基本操作详解

    Python中矩阵库Numpy基本操作详解 NumPy是Python中一个重要的科学计算库，提供了高效的维数组和各种派生对象，以于算的各种函数。在NumPy中，矩阵是重要的数据类型，本文将深入讲解NumPy中矩阵的基本操作，括矩阵的定义、创建、运算和使用等知识。 矩阵的定义 在NumPy中，矩阵是一个二维数组，可以用于存储同类型的数据。下面是示例： impo…

    python 2023年5月13日
    00

  • nditer—numpy.ndarray 多维数组的迭代操作

    以下是关于“nditer—numpy.ndarray多维数组的迭代操作”的完整攻略。 背景 在numpy中，我们可以使用nditer函数来对多维数组进行迭代操作。nditer函数可以帮助我们遍历数组的每个元素，以便进行各种操作。本攻略将介绍nditer函数的用法，并提供两个示例来演示如何使用nditer。 用法 nditer函数用于对多维数组进行迭代操作。以…

    python 2023年5月14日
    00

  • Numpy创建NumPy矩阵的简单实现

    Numpy创建NumPy矩阵的简单实现 在Python中，NumPy是一个非常流行的科学计算库，它提供了许多常用的数学函数和工具。其中，NumPy矩阵是一个非常要的数据结构，它可以用于表示和处理二维数组。本攻略将详细讲解如何使用NumPy创建矩阵，并提供两示例。 安装NumPy 在使用NumPy之前，我们需要先安装它。可以使用以下命令在命令行中安装NumPy…

    python 2023年5月13日
    00

  • Win10下用Anaconda安装TensorFlow(图文教程)

    Win10下用Anaconda安装TensorFlow(图文教程) 在本攻略中，我们将介绍如何在Windows 10操作系统下使用Anaconda安装TensorFlow。我们将提供详细的步骤和示例代码，以帮助读者更好地理解安装过程。 问题描述 TensorFlow是一个非常流行的机器学习框架，它可以用于构建各种深度学习模型。在Windows 10操作系统下…

    python 2023年5月14日
    00

  • Numpy中对向量、矩阵的使用详解

    Numpy中对向量、矩阵的使用详解 NumPy是Python中一个重要的科学计算库，提供了高效的维数组和各种派生对象，以用于计算的各种函数。在NumPy中，向量和矩阵是重要的数据类型，本文将深入讲解NumPy中向量和矩阵的使用，包括向量和矩阵的定义、创建、运算和使用等知识。 向量的定义 在NumPy中，向量是一个一维数组，可以用于存储同类型的数据。下面是一个…

    python 2023年5月13日
    00

  • 纯numpy卷积神经网络实现手写数字识别的实践

    简介 卷积神经网络（Convolutional Neural Network，CNN）是一种深度学习模型，广泛应用于图像识别、语音识别等领域。本文将介绍如何使用纯numpy实现一个简单的卷积神经网络，用于手写数字识别。 数据集 我们将使用MNIST数据集，该数据集包含60,000个训练图像和10,000个测试图像，每个图像都是28×28像素的灰度图像。我们将…

    python 2023年5月14日
    00

  • Numpy中创建数组的9种方式小结

    在NumPy中，有多种方法可以创建数组。以下是Numpy中创建数组的9种方式的详细攻略： 使用numpy.array()函数 numpy.array()函数是创建数组的最基本方法之一。它接受一个序列参数，例如列表或元组，并返回一个NumPy数组。以下是一个使用numpy.array()函数创建数组的示例： import numpy as np # 创建一个一…

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