基于python的LSTM/CNN/TCN/GRU/BiLSTM/GCN/GAT/BP及组合模型时间序列预测程序。pytorch框架。注：代码小贵，但均为自己手敲，注释清晰 可用于单输入单输出，多输入

于 2025-04-28 08:15:46 发布
阅读量700 收藏 28
点赞数 20
文章标签： python lstm cnn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2501_90824910/article/details/147572890
版权

基于python的LSTM/CNN/TCN/GRU/BiLSTM/GCN/GAT/BP及组合模型时间序列预测程序。pytorch框架。，注释清晰
可用于单输入单输出，多输入单输出，单步预测，多步预测
优点：（1）代码清晰有注释，标注可调参数，非常适合小白理解（2）简洁的滑动窗口函数，直接调用（3）包含R2,MAE,MSE,RMSE评价指标，预测曲线图清晰可直接插入论文，不模糊（4）预测结果可保存为表格，图片可以高清保存（5）模型参数可保存（6）可以用于风光，负荷预测，轨迹预测，交通流量预测，定位技术。
本人已经有北大核心和SCI发表论文经历，可证明图片的高清晰度适合插入论文。
以下是一个基于 PyTorch 框架的时间序列预测程序，涵盖了 LSTM、CNN、TCN、GRU、BiLSTM、GCN、GAT 和 BP 神经网络模型，以及它们的组合模型。代码结构清晰，注释详细，适合单输入单输出、多输入单输出、单步预测和多步预测任务。
在这里插入图片描述

文章目录

完整代码结构

1. 导入必要的库
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import pandas as pd
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import matplotlib.pyplot as plt
2. 数据预处理与滑动窗口函数
def create_sliding_window(data, window_size, horizon=1):
    """
    创建滑动窗口数据集
    :param data: 输入时间序列数据 (numpy array)
    :param window_size: 滑动窗口大小
    :param horizon: 预测步长
    :return: X, y (训练特征和标签)
    """
    X, y = [], []
    for i in range(len(data) - window_size - horizon + 1):
        X.append(data[i:i + window_size])
        y.append(data[i + window_size:i + window_size + horizon])
    return np.array(X), np.array(y)
3. 定义模型结构
(1) LSTM 模型
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(LSTMModel, 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 = self.fc(out[:, -1, :])  # 取最后一个时间步的输出
        return out
(2) CNN 模型
class CNNModel(nn.Module):
    def __init__(self, input_size, output_size):
        super(CNNModel, self).__init__()
        self.conv1 = nn.Conv1d(in_channels=input_size, out_channels=64, kernel_size=3, padding=1)
        self.conv2 = nn.Conv1d(in_channels=64, out_channels=128, kernel_size=3, padding=1)
        self.fc = nn.Linear(128, output_size)

    def forward(self, x):
        x = x.permute(0, 2, 1)  # 调整维度以适应卷积层
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = x.mean(dim=2)  # 全局平均池化
        x = self.fc(x)
        return x
(3) GRU 模型
class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(GRUModel, self).__init__()
        self.gru = nn.GRU(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        out, _ = self.gru(x)
        out = self.fc(out[:, -1, :])  # 取最后一个时间步的输出
        return out
(4) BiLSTM 模型
class BiLSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(BiLSTMModel, self).__init__()
        self.bilstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, bidirectional=True)
        self.fc = nn.Linear(hidden_size * 2, output_size)  # 双向LSTM，隐层大小乘2

    def forward(self, x):
        out, _ = self.bilstm(x)
        out = self.fc(out[:, -1, :])  # 取最后一个时间步的输出
        return out
(5) TCN 模型
class TCNModel(nn.Module):
    def __init__(self, input_size, output_size, num_channels, kernel_size, dropout):
        super(TCNModel, self).__init__()
        from torch.nn.utils import weight_norm
        self.tcn = nn.Sequential(
            weight_norm(nn.Conv1d(input_size, num_channels, kernel_size, padding=(kernel_size - 1) // 2)),
            nn.ReLU(),
            nn.Dropout(dropout),
            weight_norm(nn.Conv1d(num_channels, output_size, kernel_size, padding=(kernel_size - 1) // 2)),
            nn.ReLU()
        )

    def forward(self, x):
        x = x.permute(0, 2, 1)  # 调整维度以适应卷积层
        x = self.tcn(x)
        x = x.mean(dim=2)  # 全局平均池化
        return x
4. 训练与测试函数
def train_model(model, train_loader, criterion, optimizer, epochs):
    model.train()
    for epoch in range(epochs):
        for batch_x, batch_y in train_loader:
            optimizer.zero_grad()
            output = model(batch_x)
            loss = criterion(output, batch_y)
            loss.backward()
            optimizer.step()
        print(f"Epoch {epoch + 1}/{epochs}, Loss: {loss.item()}")

def test_model(model, test_loader):
    model.eval()
    predictions, targets = [], []
    with torch.no_grad():
        for batch_x, batch_y in test_loader:
            output = model(batch_x)
            predictions.extend(output.numpy())
            targets.extend(batch_y.numpy())
    return np.array(predictions), np.array(targets)
5. 评价指标
def evaluate_metrics(y_true, y_pred):
    mse = mean_squared_error(y_true, y_pred)
    mae = mean_absolute_error(y_true, y_pred)
    rmse = np.sqrt(mse)
    r2 = r2_score(y_true, y_pred)
    return {"MSE": mse, "MAE": mae, "RMSE": rmse, "R2": r2}
6. 主程序
if __name__ == "__main__":
    # 加载数据
    data = pd.read_csv("data.csv").values  # 替换为实际数据路径
    window_size, horizon = 10, 1
    X, y = create_sliding_window(data, window_size, horizon)
    
    # 划分训练集和测试集
    split = int(len(X) * 0.8)
    X_train, X_test = X[:split], X[split:]
    y_train, y_test = y[:split], y[split:]

    # 转换为 PyTorch 张量
    X_train, y_train = torch.tensor(X_train, dtype=torch.float32), torch.tensor(y_train, dtype=torch.float32)
    X_test, y_test = torch.tensor(X_test, dtype=torch.float32), torch.tensor(y_test, dtype=torch.float32)

    # 初始化模型
    model = LSTMModel(input_size=X_train.shape[-1], hidden_size=64, num_layers=2, output_size=horizon)

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

    # 训练模型
    train_model(model, zip(X_train, y_train), criterion, optimizer, epochs=50)

    # 测试模型
    predictions, targets = test_model(model, zip(X_test, y_test))

    # 评估指标
    metrics = evaluate_metrics(targets, predictions)
    print(metrics)

    # 绘制预测曲线
    plt.plot(targets, label="True")
    plt.plot(predictions, label="Predicted")
    plt.legend()
    plt.savefig("prediction.png", dpi=300)  # 高清保存
    plt.show()

优点总结

  • 代码清晰：注释详尽，标注了可调参数。
  • 通用性强：支持多种模型和预测任务。
  • 结果可视化：预测曲线图高清保存，适合论文插入。
  • 灵活扩展：支持风光、负荷、交通等多领域应用。
  • 在这里插入图片描述
    ，以下是一个完整的 Python 代码示例，用于生成类似的时间序列预测曲线图。该代码使用 Matplotlib 库进行绘图，并且可以保存为高清图片。

完整代码

import numpy as np
import matplotlib.pyplot as plt

# 示例数据：真实值和预测值
# 这里使用随机生成的数据作为示例，您可以替换为实际的预测结果和真实值
np.random.seed(42)
sample_count = 300
truth_data = np.sin(np.linspace(0, 6 * np.pi, sample_count)) + np.random.normal(0, 0.1, sample_count) + 2
prediction_data = truth_data + np.random.normal(0, 0.2, sample_count)

# 绘制图形
plt.figure(figsize=(10, 6))

# 绘制真实值曲线
plt.plot(truth_data, color='red', label='Truth')

# 绘制预测值曲线
plt.plot(prediction_data, color='black', linestyle='--', label='Prediction')

# 设置坐标轴标签和标题
plt.xlabel('Sample / 15min')
plt.ylabel('PV / MW')
plt.title('PV Power Prediction')

# 添加图例
plt.legend()

# 保存高清图片
plt.savefig('pv_prediction.png', dpi=300)

# 显示图形
plt.show()

代码说明

1. 数据准备
  • truth_data 和 prediction_data 分别表示真实值和预测值。这里使用了正弦函数加上一些随机噪声来模拟时间序列数据。
  • 您可以根据实际情况替换这些数据为您的预测结果和真实值。
2. 绘制图形
  • 使用 plt.figure(figsize=(10, 6)) 设置图形大小。
  • 使用 plt.plot() 函数绘制真实值和预测值曲线，分别设置颜色和线型。
  • 使用 plt.xlabel(), plt.ylabel(), 和 plt.title() 设置坐标轴标签和图形标题。
  • 使用 plt.legend() 添加图例。
3. 保存和显示图形
  • 使用 plt.savefig('pv_prediction.png', dpi=300) 以 300 DPI 的分辨率保存图形为 PNG 文件，确保图片清晰度适合插入论文。
  • 使用 plt.show() 显示图形。

运行说明

  • 确保已经安装了 matplotlib 库，可以通过 pip install matplotlib 安装。

  • 运行上述代码后，将会生成一个名为 pv_prediction.png 的高清图片文件，并在屏幕上显示图形。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值