时间序列预测实战(十七)PyTorch实现LSTM-GRU模型长期预测并可视化结果（附代码+数据集+详细讲解）

已于 2023-11-27 21:31:13 修改
阅读量1w 收藏 186
点赞数 63
分类专栏： 时间序列预测专栏 文章标签： pytorch lstm gru 人工智能 深度学习 python
于 2023-11-20 23:49:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java1314777/article/details/134397113
版权

一、本文介绍

本文给大家带来的实战内容是利用PyTorch实现LSTM-GRU模型，LSTM和GRU都分别是RNN中最常用Cell之一，也都是时间序列预测中最常见的结构单元之一，本文的内容将会从实战的角度带你分析LSTM和GRU的机制和效果，同时如果你是时间序列中的新手，这篇文章会带你了解整个时间序列的建模过程，同时本文的实战代码支持多元预测单元、单元预测单元、多元预测多元，本文的实战内容通过时间序列领域最经典的数据集——电力负荷数据集为例进行预测。

内容回顾->时间序列预测专栏——包含上百种时间序列模型带你从入门到精通时间序列预测

预测类型->单元预测、多元预测、长期预测

下面是预测效果图-> 

目录

一、本文介绍

二、LSTM和GRU的机制原理

2.1LSTM的机制原理

2.2.1忘记门

2.2.2输入门

2.2.3输出门

2.2GRU的机制原理 

2.2.1GRU的基本原理

2.2.1GRU的基本框架

2.3 融合思想 

三、数据集介绍 

四、参数讲解 

五、模型实战 

5.1 模型完整代码

5.2 模型训练 

5.3 模型预测 

5.4 结果分析

六、全文总结

二、LSTM和GRU的机制原理

2.1LSTM的机制原理

LSTM（长短期记忆，Long Short-Term Memory）是一种用于处理序列数据的深度学习模型，属于循环神经网络（RNN）的一种变体,其使用一种类似于搭桥术结构的RNN单元。相对于普通的RNN，LSTM引入了门控机制，能够更有效地处理长期依赖和短期记忆问题，是RNN网络中最常使用的Cell之一。

LSTM通过刻意的设计来实现学习序列关系的同时，又能够避免长期依赖的问题。它的结构示意图如下所示。

在LSTM的结构示意图中，每一条黑线传输着一整个向量，从一个节点的输出到其他节点的输入。其中“+”号代表着运算操作(如矢量的和)，而矩形代表着学习到的神经网络层。汇合在一起的线表示向量的连接，分叉的线表示内容被复制，然后分发到不同的位置。

如果上面的LSTM结构图你看着很难理解,但是其实LSTM的本质就是一个带有tanh激活函数的简单RNN，如下图所示。

LSTM这种结构的原理是引入一个称为细胞状态的连接。这个状态细胞用来存放想要的记忆的东西(对应简单LSTM结构中的h，只不过这里面不再只保存上一次状态了，而是通过网络学习存放那些有用的状态)，同时在加入三个门,分别是。

        忘记门:决定什么时候将以前的状态忘记。

        输入门：决定什么时候将新的状态加进来。

        输出门：决定什么时候需要把状态和输入放在一起输出。

从字面上可以看出，由于三个门的操作，LSTM在状态的更新和状态是否要作为输入，全部交给了神经网络的训练机制来选择。

下面分别来介绍一下三个门的结构和作用。

2.2.1忘记门

下图所示为忘记门的操作，忘记门决定模型会从细胞状态中丢弃什么信息。

忘记门会读取前一序列模型的输出h_{t-1}和当前模型的输入X_{t}来控制细胞状态中的每个数是否保留。

例如:在一个语言模型的例子中，假设细胞状态会包含当前主语的性别，于是根据这个状态便可以选择正确的代词。当我们看到新的主语时，应该把新的主语在记忆中更新。忘记们的功能就是先去记忆中找到一千那个旧的主语(并没有真正执行忘记的操作，只是找到而已。

在上图的LSTM的忘记门中，f_{t}代表忘记门的输出， α代表激活函数，W_{f}代表忘记门的权重，x_{t}代表当前模型的输入，h_{t-1}代表前一个序列模型的输出，b_{f}代表忘记门的偏置。

2.2.2输入门

输入门可以分为两部分功能，一部分是找到那些需要更新的细胞状态。另一部分是把需要更新的信息更新到细胞状态里

在上面输入门的结构中，I_{t}代表要更新的细胞状态，α代表激活函数，x_{t}代表当前模型的输入，h_{t-1}代表前一个序列模型的输出，W_{t}代表计算I_{t}的权重，b_{t}代表计算I_{t}的偏置，_{}C_{t}代表使用tanh所创建的新细胞状态，W_{c}代表计算C_{t}的权重，b_{c}代表计算C_{t}的偏置。

忘记门找到了需要忘掉的信息f_{t}后，在将它与旧状态相乘，丢弃确定需要丢弃的信息。(如果需要丢弃对应位置权重设置为0)，然后，将结果加上I_{t} * C_{t}使细胞状态获得新的信息。这样就完成了细胞状态的更新，如下图输入门的更新图所示。

再上图LSTM输入门的更新图中，B_{t}代表忘记门的输出结果， f_{t}代表忘记门的输出结果，B_{t-1}代表前一个序列模型的细胞状态，I_{t}代表要更新的细胞状态，\widetilde{C_{t}}代表使用tanh所创建的新细胞状态。

2.2.3输出门

如下图LSTM的输出门结构图所示，在输出门中，通过一个激活函数层(实际使用的是Sigmoid激活函数)来确定哪个部分的信息将输出，接着把细胞状态通过tanh进行处理(得到一个在-1~1的值)，并将它和Sigmoid门的输出相乘，得出最终想要输出的那个部分，例如，在语言模型中，假设已经输入了一个代词，便会计算出需要输出一个与该代词相关的信息(词向量)

在LSTM的输出门结构图中，O_{t}代表要输出的信息，α代表激活函数，W_{o}代表计算 O_{t}的权重，b_{o}代表计算O_{t}的偏置，B_{t}代表更新后的细胞状态，h_{t}代表当前序列模型的输出结果。

2.2GRU的机制原理 

2.2.1GRU的基本原理

GRU（门控循环单元）是一种循环神经网络（RNN）的变体，主要用于处理序列数据，它的基本原理可以概括如下：

  1. 门控机制：GRU的核心是门控机制，包括更新门（update gate）和重置门（reset gate）。这些门控制着信息的流动，即决定哪些信息应该被保留，哪些应该被遗忘。

  2. 更新门：更新门帮助模型决定过去的信息有多少需要保留到当前状态。它是通过当前输入和前一个隐状态计算得出的，用于调节隐状态的更新程度。

  3. 重置门：重置门决定了多少过去的信息需要被忘记。它同样依赖于当前输入和前一个隐状态的信息。当重置门接近0时，模型会“忘记”过去的隐状态，只依赖于当前输入。

  4. 当前隐状态的计算：利用更新门和重置门的输出，结合前一隐状态和当前输入，GRU计算出当前的隐状态。这个隐状态包含了序列到目前为止的重要信息。

  5. 输出：GRU的最终输出通常是在序列的每个时间步上产生的，或者在序列的最后一个时间步产生，取决于具体的应用场景。

总结：GRU相较于传统的RNN，其优势在于能够更有效地处理长序列数据，减轻了梯度消失的问题。同时，它通常比LSTM（长短期记忆网络）更简单，因为它有更少的参数。

2.2.1GRU的基本框架

​

上面的图片为一个GRU的基本结构图，解释如下->

  • 更新门（z） 在决定是否用新的隐藏状态更新当前隐藏状态时扮演重要角色。
  • 重置门（r） 决定是否忽略之前的隐藏状态。

这些部分是GRU的核心组成，它们共同决定了网络如何在序列数据中传递和更新信息，这对于时间序列分析至关重要。

2.3 融合思想 

三、数据集介绍 

我们本文用到的数据集是官方的ETTh1.csv ，该数据集是一个用于时间序列预测的电力负荷数据集，它是 ETTh 数据集系列中的一个。ETTh 数据集系列通常用于测试和评估时间序列预测模型。以下是 ETTh1.csv 数据集的一些内容：

数据内容：该数据集通常包含有关电力系统的多种变量，如电力负荷、价格、天气情况等。这些变量可以用于预测未来的电力需求或价格。

时间范围和分辨率：数据通常按小时或天记录，涵盖了数月或数年的时间跨度。具体的时间范围和分辨率可能会根据数据集的版本而异。 

以下是该数据集的部分截图->

​

四、参数讲解 

下面的代码是我定义的所有参数，目前只有这些，这个框架我会进行补充，后期也会在这里进行更新。 

 parser = argparse.ArgumentParser(description='Time Series forecast')
    parser.add_argument('-model', type=str, default='LSTM-Attention', help="模型持续更新")
    parser.add_argument('-window_size', type=int, default=128, help="时间窗口大小, window_size > pre_len")
    parser.add_argument('-pre_len', type=int, default=24, help="预测未来数据长度")
    # data
    parser.add_argument('-shuffle', action='store_true', default=True, help="是否打乱数据加载器中的数据顺序")
    parser.add_argument('-data_path', type=str, default='ETTh1Test.csv', help="你的数据数据地址")
    parser.add_argument('-target', type=str, default='OT', help='你需要预测的特征列，这个值会最后保存在csv文件里')
    parser.add_argument('-input_size', type=int, default=7, help='你的特征个数不算时间那一列')
    parser.add_argument('-output_size', type=int, default=7, help='输出特征个数只有两种选择和你的输入特征一样即输入多少输出多少，另一种就是多元预测单元')
    parser.add_argument('-feature', type=str, default='M', help='[M, S, MS],多元预测多元,单元预测单元,多元预测单元')
    # learning
    parser.add_argument('-lr', type=float, default=0.001, help="学习率")
    parser.add_argument('-drop_out', type=float, default=0.05, help="随机丢弃概率,防止过拟合")
    parser.add_argument('-epochs', type=int, default=20, help="训练轮次")
    parser.add_argument('-batch_size', type=int, default=16, help="批次大小")
    parser.add_argument('-save_path', type=str, default='models')

    # model
    parser.add_argument('-hidden-size', type=int, default=128, help="隐藏层单元数")
    parser.add_argument('-kernel-sizes', type=str, default='3')
    parser.add_argument('-laryer_num', type=int, default=1)
    # device
    parser.add_argument('-use_gpu', type=bool, default=False)
    parser.add_argument('-device', type=int, default=0, help="只设置最多支持单个gpu训练")

    # option
    parser.add_argument('-train', type=bool, default=True)
    parser.add_argument('-predict', type=bool, default=True)
    parser.add_argument('-inspect_fit', type=bool, default=True)
    parser.add_argument('-lr-scheduler', type=bool, default=True)

参数的详细讲解->

参数名称参数类型参数讲解
1modelstr模型名称
2window_sizeint时间窗口大小，用多少条数据去预测未来的数据

3

pre_lenint预测多少条未来的数据
4shufflestore_true是否打乱输入dataloader中的数据，不是数据的顺序

5

data_pathstr你输入数据的地址
6targetstr你想要预测的特征列

7

input_sizeint输入的特征数不包含时间那一列！！！
8output_sizeint输出的特征数只可以是1或者是等于你输入的特征数

9

featurestr[M, S, MS],多元预测多元,单元预测单元,多元预测单元
10lrfloat学习率大小

11

drop_out

float丢弃概率
12epochsint训练轮次

13

batch_sizeint批次大小
14svae_pathstr模型的保存路径

15

hidden_sizeint隐藏层大小
16kernel_sizeint卷积核大小

17

layer_numintlstm层数
18use_gpubool是否使用GPU

19

deviceintGPU编号
20trainbool是否进行训练

21

predictbool是否进行预测

22

inspect_fitbool是否进行检验模型
23lr_schdulerbool是否使用学习率计划

五、模型实战 

5.1 模型完整代码

下面是模型的暂时代码，后期会持续更新内容，以后的实战也会基于这个版本的框架下进行。 

我们将下面的代码创建一个py文件复制进去即可运行。 

import argparse
import numpy as np
import pandas as pd
import torch.nn as nn
from matplotlib import pyplot as plt
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from torch.utils.data import DataLoader
import torch
from torch.utils.data import Dataset
from tqdm import tqdm
import time
# 随机数种子
np.random.seed(1)

def plot_loss_data(data):
    # 使用Matplotlib绘制线图
    plt.figure()

    plt.plot(data)

    # 添加标题
    plt.title("loss results Plot")

    # 显示图例
    plt.legend(["Loss"])



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

    def __len__(self):
        return len(self.sequences)

    def __getitem__(self, index):
        sequence, label = self.sequences[index]
        return torch.Tensor(sequence), torch.Tensor(label)


def create_inout_sequences(input_data, tw, pre_len, config):
    # 创建时间序列数据专用的数据分割器
    inout_seq = []
    L = len(input_data)
    for i in range(L - tw):
        train_seq = input_data[i:i + tw]
        if (i + tw + pre_len) > len(input_data):
            break
        if config.feature == 'MS' or config.feature == 'S':
            train_label = input_data[:,-1:][i + tw:i + tw + pre_len]
        else:
            train_label = input_data[i + tw:i + tw + pre_len]
        inout_seq.append((train_seq, train_label))
    return inout_seq


def calculate_mae(y_true, y_pred):
    # 平均绝对误差
    mae = np.mean(np.abs(y_true - y_pred))
    return mae


def create_dataloader(config, device):
    print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>创建数据加载器<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
    df = pd.read_csv(config.data_path)  # 填你自己的数据地址,自动选取你最后一列数据为特征列 # 添加你想要预测的特征列
    pre_len = config.pre_len  # 预测未来数据的长度
    train_window = config.window_size  # 观测窗口

    # 将特征列移到末尾
    target_data = df[[config.target]]
    df = df.drop(config.target, axis=1)
    df = pd.concat((df, target_data), axis=1)

    cols_data = df.columns[1:]
    df_data = df[cols_data]

    # 这里加一些数据的预处理, 最后需要的格式是pd.series
    true_data = df_data.values

    # 定义标准化优化器
    scaler_train = StandardScaler()
    scaler_valid = StandardScaler()
    scaler_test = StandardScaler()

    train_data = true_data[int(0.3 * len(true_data)):]
    valid_data = true_data[int(0.15 * len(true_data)):int(0.30 * len(true_data))]
    test_data = true_data[:int(0.15 * len(true_data))]
    print("训练集尺寸:", len(train_data), "测试集尺寸:", len(test_data), "验证集尺寸:", len(valid_data))

    # 进行标准化处理
    train_data_normalized = scaler_train.fit_transform(train_data)
    test_data_normalized = scaler_test.fit_transform(test_data)
    valid_data_normalized = scaler_valid.fit_transform(valid_data)

    # 转化为深度学习模型需要的类型Tensor
    train_data_normalized = torch.FloatTensor(train_data_normalized).to(device)
    test_data_normalized = torch.FloatTensor(test_data_normalized).to(device)
    valid_data_normalized = torch.FloatTensor(valid_data_normalized).to(device)

    # 定义训练器的的输入
    train_inout_seq = create_inout_sequences(train_data_normalized, train_window, pre_len, config)
    test_inout_seq = create_inout_sequences(test_data_normalized, train_window, pre_len, config)
    valid_inout_seq = create_inout_sequences(valid_data_normalized, train_window, pre_len, config)

    # 创建数据集
    train_dataset = TimeSeriesDataset(train_inout_seq)
    test_dataset = TimeSeriesDataset(test_inout_seq)
    valid_dataset = TimeSeriesDataset(valid_inout_seq)

    # 创建 DataLoader
    train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, drop_last=True)
    test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False, drop_last=True)
    valid_loader = DataLoader(valid_dataset, batch_size=args.batch_size, shuffle=False, drop_last=True)

    print("通过滑动窗口共有训练集数据：", len(train_inout_seq), "转化为批次数据:", len(train_loader))
    print("通过滑动窗口共有测试集数据：", len(test_inout_seq), "转化为批次数据:", len(test_loader))
    print("通过滑动窗口共有验证集数据：", len(valid_inout_seq), "转化为批次数据:", len(valid_loader))
    print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>创建数据加载器完成<<<<<<<<<<<<<<<<<<<<<<<<<<<")
    return train_loader, test_loader, valid_loader, scaler_train, scaler_test, scaler_valid


class LSTM_GRU(nn.Module):
    def __init__(self, args, device):
        super(LSTM_GRU, self).__init__()
        self.args = args
        self.device = device
        self.dropout = nn.Dropout(args.drop_out)

        self.lstm = nn.LSTM(args.input_size, args.hidden_size, batch_first=True)
        self.gru = nn.GRU(input_size=args.hidden_size, hidden_size=args.hidden_size, num_layers=1, batch_first=True)
        self.linearOut = nn.Linear(args.hidden_size, args.input_size)

    def forward(self, x):
        hidden = ((torch.zeros(1, x.size(0), self.args.hidden_size).to(self.device)),
                  (torch.zeros(1, x.size(0), self.args.hidden_size).to(self.device)))
        x, lstm_h = self.lstm(x, hidden)
        x = self.dropout(x)
        x = torch.tanh(torch.transpose(x, 1, 2))
        x = x.permute(0, 2, 1)
        x, gru_ = self.gru(x)
        x = self.dropout(x)
        x = torch.tanh(torch.transpose(x, 1, 2))
        x = x.permute(0, 2, 1)
        x = self.linearOut(x)
        x = x[:, -args.pre_len:, :]

        return x


def train(model, args, device):
    start_time = time.time()  # 计算起始时间
    lstm_model = model
    loss_function = nn.MSELoss()
    optimizer = torch.optim.Adam(lstm_model.parameters(), lr=0.005)
    epochs = args.epochs
    lstm_model.train()  # 训练模式
    results_loss = []
    for i in tqdm(range(epochs)):
        losss = []
        for seq, labels in train_loader:
            optimizer.zero_grad()
            lstm_model.train()

            optimizer.zero_grad()

            y_pred = lstm_model(seq)

            single_loss = loss_function(y_pred, labels)

            single_loss.backward()

            optimizer.step()
            losss.append(single_loss.detach().cpu().numpy())
        tqdm.write(f"\t Epoch {i + 1} / {epochs}, Loss: {sum(losss) / len(losss)}")
        results_loss.append(sum(losss) / len(losss))
        save_loss = []
        if save_loss:
            valid_loss = valid(model, args, scaler_valid, valid_loader)
            # 尚未引入学习率计划后期补上
        torch.save(lstm_model.state_dict(), 'save_model.pth')
        time.sleep(0.1)

    # 保存模型

    print(f">>>>>>>>>>>>>>>>>>>>>>模型已保存,用时:{(time.time() - start_time) / 60:.4f} min<<<<<<<<<<<<<<<<<<")
    # plot_loss_data(results_loss)
    test(model, args, scaler_test, test_loader)

    return scaler_train


def valid(model, args, scaler, valid_loader):
    lstm_model = model
    # 加载模型进行预测
    lstm_model.load_state_dict(torch.load('save_model.pth'))
    lstm_model.eval()  # 评估模式
    losss = []

    for seq, labels in valid_loader:
        pred = lstm_model(seq)
        mae = calculate_mae(pred.detach().cpu().numpy(), np.array(labels.detach().cpu()))  # MAE误差计算绝对值(预测值  - 真实值)
        losss.append(mae)

    # print("验证集误差MAE:", losss)
    return sum(losss)/len(losss)

def test(model, args, scaler, test_loader):
    lstm_model = model
    # 加载模型进行预测
    lstm_model.load_state_dict(torch.load('save_model.pth'))
    lstm_model.eval()  # 评估模式
    losss = []

    for seq, labels in test_loader:
        pred = lstm_model(seq)
        mae = calculate_mae(pred.detach().cpu().numpy(), np.array(labels.detach().cpu()))  # MAE误差计算绝对值(预测值  - 真实值)
        losss.append(mae)
    # 此处缺少一个绘图功能后期补上，检验测试集情况
    print("测试集误差MAE:", losss)


# 检验模型拟合情况
def inspect_model_fit(model, args, train_loader, scaler_train):
    # 后期完善
    print("模型拟合检验情况暂未完善，如有需要请催更博主")
    pass


def predict(model, args, device, scaler):
    # 预测未知数据的功能
    # 重新读取数据
    df = pd.read_csv(args.data_path)
    train_data = df[[args.target]][int(0.3 * len(df)):]
    df = df.iloc[:, 1:][-args.window_size:].values  # 转换为nadarry
    scaler_tr = StandardScaler()
    scaler_tr.fit_transform(train_data.values)
    pre_data = scaler.transform(df)
    tensor_pred = torch.FloatTensor(pre_data).to(device)
    tensor_pred = tensor_pred.unsqueeze(0)   # 单次预测 , 滚动预测功能暂未开发后期补上
    model = model
    model.load_state_dict(torch.load('save_model.pth'))
    model.eval()  # 评估模式

    pred = model(tensor_pred)[0]

    if args.feature == 'M' or args.feature == 'S':
        pred = scaler.inverse_transform(pred.detach().cpu().numpy())
    else:
        pred = scaler_tr.inverse_transform(pred.detach().cpu().numpy())


    # 计算历史数据的长度
    history_length = len(df[:, -1])

    # 为历史数据生成x轴坐标
    history_x = range(history_length)

    # 为预测数据生成x轴坐标
    # 开始于历史数据的最后一个点的x坐标
    prediction_x = range(history_length - 1, history_length + len(pred[:, -1]) - 1)

    # 绘制历史数据
    plt.plot(history_x, df[:, -1], label='History')

    # 绘制预测数据
    # 注意这里预测数据的起始x坐标是历史数据的最后一个点的x坐标
    plt.plot(prediction_x, pred[:, -1], marker='o', label='Prediction')
    plt.axvline(history_length - 1, color='red')  # 在图像的x位置处画一条红色竖线
    # 添加标题和图例
    plt.title("History and Prediction")
    plt.legend()





if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Time Series forecast')
    parser.add_argument('-model', type=str, default='LSTM-Attention', help="模型持续更新")
    parser.add_argument('-window_size', type=int, default=128, help="时间窗口大小, window_size > pre_len")
    parser.add_argument('-pre_len', type=int, default=24, help="预测未来数据长度")
    # data
    parser.add_argument('-shuffle', action='store_true', default=True, help="是否打乱数据加载器中的数据顺序")
    parser.add_argument('-data_path', type=str, default='ETTh1Test.csv', help="你的数据数据地址")
    parser.add_argument('-target', type=str, default='OT', help='你需要预测的特征列，这个值会最后保存在csv文件里')
    parser.add_argument('-input_size', type=int, default=7, help='你的特征个数不算时间那一列')
    parser.add_argument('-output_size', type=int, default=7, help='输出特征个数只有两种选择和你的输入特征一样即输入多少输出多少，另一种就是多元预测单元')
    parser.add_argument('-feature', type=str, default='M', help='[M, S, MS],多元预测多元,单元预测单元,多元预测单元')
    # learning
    parser.add_argument('-lr', type=float, default=0.001, help="学习率")
    parser.add_argument('-drop_out', type=float, default=0.05, help="随机丢弃概率,防止过拟合")
    parser.add_argument('-epochs', type=int, default=20, help="训练轮次")
    parser.add_argument('-batch_size', type=int, default=16, help="批次大小")
    parser.add_argument('-save_path', type=str, default='models')

    # model
    parser.add_argument('-hidden-size', type=int, default=128, help="隐藏层单元数")
    parser.add_argument('-kernel-sizes', type=str, default='3')
    parser.add_argument('-laryer_num', type=int, default=1)
    # device
    parser.add_argument('-use_gpu', type=bool, default=False)
    parser.add_argument('-device', type=int, default=0, help="只设置最多支持单个gpu训练")

    # option
    parser.add_argument('-train', type=bool, default=True)
    parser.add_argument('-predict', type=bool, default=True)
    parser.add_argument('-inspect_fit', type=bool, default=True)
    parser.add_argument('-lr-scheduler', type=bool, default=True)
    args = parser.parse_args()

    if isinstance(args.device, int) and args.use_gpu:
        device = torch.device("cuda:" + f'{args.device}')
    else:
        device = torch.device("cpu")
    print(device)
    train_loader, test_loader, valid_loader, scaler_train, scaler_test, scaler_valid = create_dataloader(args, device)

    # 实例化模型
    try:
        print(f">>>>>>>>>>>>>>>>>>>>>>>>>开始初始化{args.model}模型<<<<<<<<<<<<<<<<<<<<<<<<<<<")
        model = LSTM_GRU(args, device).to(device)
        print(f">>>>>>>>>>>>>>>>>>>>>>>>>开始初始化{args.model}模型成功<<<<<<<<<<<<<<<<<<<<<<<<<<<")
    except:
        print(f">>>>>>>>>>>>>>>>>>>>>>>>>开始初始化{args.model}模型失败<<<<<<<<<<<<<<<<<<<<<<<<<<<")


    # 训练模型
    if args.train:
        print(f">>>>>>>>>>>>>>>>>>>>>>>>>开始{args.model}模型训练<<<<<<<<<<<<<<<<<<<<<<<<<<<")
        train(model, args, device)
    if args.inspect_fit:
        print(f">>>>>>>>>>>>>>>>>>>>>>>>>开始检验{args.model}模型拟合情况<<<<<<<<<<<<<<<<<<<<<<<<<<<")
        inspect_model_fit(model, args, train_loader, scaler_train)
    if args.predict:
        print(f">>>>>>>>>>>>>>>>>>>>>>>>>预测未来{args.pre_len}条数据<<<<<<<<<<<<<<<<<<<<<<<<<<<")
        predict(model, args, device, scaler_train)
    plt.show()

 

5.2 模型训练 

当我们通过章节四配置好所有的参数之后，我们就可以运行我们创建的py文件了，控制台就会进行训练，输出如下内容->

5.3 模型预测 

下面的图片是模型在测试集上的表现， 可以看到效果还可以吧只能说一般，毕竟这两个结构单元只是最普通的，也没有在其中加入任何的其它高等级机制。

5.4 结果分析

当我们预测完成之后，会进行测试集验证同时会输出测试集的表现情况，后期我会添加个绘图功能在这里。 

六、全文总结

到此本文已经全部讲解完成了，希望能够帮助到大家，在这里也给大家推荐一些我其它的博客的时间序列实战案例讲解，其中有数据分析的讲解就是我前面提到的如何设置参数的分析博客，最后希望大家订阅我的专栏，本专栏均分文章均分98，并且免费阅读。

基于BiLSTM 实现股价多变量时间序列预测(PyTorch版)
时序笔记
07-17 2015
在本文中，我们将探讨如何使用PyTorch框架实现基于双向长短期记忆网络（BiLSTM）的多变量时间序列预测模型。多变量时间序列预测涉及多个输入变量和一个或多个输出变量，这些变量随时间变化并可能相互影响。通过利用BiLSTM的双向特性，我们的模型将能够同时考虑历史数据和未来趋势，从而更准确地预测时间序列的未来值。
GRU实现时间序列预测(PyTorch版)
CSDN 精品推荐
01-08 5万+
本篇文章我们采用了经典的循环神经网络GRU来对我们的时序数据建模处理，作为该专栏的第一篇文章，本篇将详细介绍项目的每个实现部分以及细节处理，帮助新手小白快速建立起如何处理时序数据的框架。
pytorch-forecasting:使用PyTorch进行时间序列预测
03-18
我们关于“ 文章介绍了该软件包，并提供了背景信息。 Pytorch Forecasting旨在通过神经网络简化实际案例和研究的最新时间序列预测。目标是为高级专业人员提供最大程度的灵活性，并为初学者提供合理的默认值的高级API。具体来说，该软件包提供了 一个时间序列数据集类，它抽象化处理变量转换，缺失值，随机子采样，多个历史记录长度等。 基本模型类，提供时间序列模型的基本训练，以及在张量板中的记录和通用可视化，例如实际与预测以及依存关系图 用于时间序列预测的多种神经网络体系结构已针对实际部署进行了增强，并具有内置的解释功能 多地平线时间序列指标 Ranger优化器，用于更快的模型训练 使用调整 该程序包基于构建，可以直接使用CPU，单个和多个GPU进行培训。 安装 如果您在Windows上工作，则需要先使用以下命令安装PyTorch： pip install torch -f https
Python----机器学习（PyTorch模型的保存与加载+预测）
最新发布
weixin_64110589的博客
03-31 1051
在 PyTorch 中，模型的保存与加载以及预测的过程相对简单。首先，可以通过 `torch.save()` 方法将模型的状态字典（`state_dict`）保存到指定的文件中，以便于后续使用。加载模型时，使用 `torch.load()` 方法读取保存的文件，并通过 `model.load_state_dict()` 将参数加载到模型中。为了进行预测，需要将模型设置为评估模式（`model.eval()`），然后使用输入数据进行前向传播，得到预测结果。这一流程确保了模型在训练和推断阶段的一致性与可复用性。
Pytorch实现LSTM和GRU
winycg的博客
03-31 4万+
为了解决传统RNN无法长时依赖问题，RNN的两个变体LSTM和GRU被引入。 LSTM Long Short Term Memory，称为长短期记忆网络，意思就是长的短时记忆，其解决的仍然是短时记忆问题，这种短时记忆比较长，能一定程度上解决长时依赖。 ...
pytorch模型预测
qq_41166909的博客
03-30 5611
1.数据集 pytorch有个快速构造数据集的方法 但是你的目录结构必须是 image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),data_transforms[x])for x in ['train', 'val']} 首先for循环将['train',val]分别赋给x, x =train/val。 os.path.join(data_dir,x)将文件dataset和train和val拼接起来。.
PyTorch--用循环神经网络LSTM预测时间序列
胖虎卖汤圆的博客
03-02 1万+
LSTM使解决序列问题用处最广的算法之一，在这篇文章中，我们可以知道怎么使用LSTM来预测时间序列。当然，这个算法还有很多提升空间，由于循环神经网络容易出现梯度爆炸的情况，我们可以加入梯度裁剪；为了减少泛化误差，我们可以使用k折交叉验证等等方法来优化模型。
PyTorch序列预测实战：RNN、LSTM、GRU模型构建
weixin_33816734的博客
10-21 2247
本文还有配套的精品资源，点击获取 简介：自然语言处理中的序列预测是关键任务，需要对数据序列建模预测未来元素。本项目通过PyTorch框架，实现三种递归神经网络变体：RNN、LSTM、GRU。这些模型在文本和时间序列数据上表现优异。项目涵盖数据预处理、模型定义、训练过程、评估与验证、测试与应用等关键环节。源代码文件包含了实现这些步骤的详细代码，有助于提升PyTorch技能并深...
CNN+LSTM+Attention实现时间序列预测(PyTorch版)
CSDN 精品推荐
01-19 1万+
本专栏整理了《深度学习时间序列预测案例》，内包含了各种不同的基于深度学习模型的时间序列预测方法，例如LSTM、GRU、CNN（一维卷积、二维卷积）、LSTM-CNN、BiLSTM、Self-Attention、LSTM-Attention、Transformer等经典模型，包含项目原理以及源码，每一个项目实例都附带有完整的代码+数据集。
LSTM+CNN实现时间序列预测(PyTorch版)
CSDN 精品推荐
01-16 6395
本专栏整理了《深度学习时间序列预测案例》，内包含了各种不同的基于深度学习模型的时间序列预测方法，例如LSTM、GRU、CNN（一维卷积、二维卷积）、LSTM-CNN、BiLSTM、Self-Attention、LSTM-Attention、Transformer等经典模型，包含项目原理以及源码，每一个项目实例都附带有完整的代码+数据集。
时间序列预测 — CNN-LSTM-Attention实现多变量负荷预测(Tensorflow)：多变量滚动
几度春风里的博客
01-22 1699
​ 所有文章提供源代码、数据集、效果可视化​ 文章多次上领域内容榜、每日必看榜单、全站综合热榜​​​​​​​​现有的大量方法没有真正的预测未来值，只是用历史数据做验证。
Pytorch预测-使用PyTorch进行时间序列预测-Python开发
05-25
Pytorch Forecasting旨在通过神经网络简化实际案例和研究中的时间序列预测。 具体来说，该软件包提供了有关“迈向数据科学”的文章，介绍了该软件包并提供了背景信息。 Pytorch Forecasting旨在通过神经网络简化实际案例和研究中的时间序列预测。 具体来说，该软件包提供了一个时间序列数据集类，该类抽象了处理变量转换，缺失值，随机子采样，多个历史记录长度等的基础模型。基本模型类提供了时间序列模型的基本训练以及登录tensorboa
Python-在PyTorch中使用LSTM进行风速预测
08-11
在PyTorch中使用LSTM进行风速预测
TensorFlow搭建CNN实现时间序列预测（风速预测）
KI的博客
08-29 6728
TensorFlow搭建CNN实现时间序列预测（风速预测）
深入理解PyTorch中LSTM的输入和输出（从input输入到Linear输出）
KI的博客
01-18 9万+
深入理解PyTorch中LSTM的输入和输出（从input输入到Linear输出）
PyTorch搭建Informer实现长序列时间序列预测
KI的博客
04-05 4476
PyTorch搭建Informer实现长序列时间序列预测
PyTorch搭建LSTM实现时间序列预测（负荷预测）
热门推荐
KI的博客
01-18 10万+
PyTorch搭建LSTM实现时间序列预测（负荷预测）
在Python中使用LSTM和PyTorch进行时间序列预测
大数据部落
10-29 1万+
原文链接：http://tecdat.cn/?p=8145 顾名思义，时间序列数据是一种随时间变化的数据类型。例如，24小时内的温度，一个月内各种产品的价格，一年中特定公司的股票价格。诸如长期短期记忆网络（LSTM）之类的高级深度学习模型能够捕获时间序列数据中的模式，因此可用于对数据的未来趋势进行预测。在本文中，您将看到如何使用LSTM算法使用时间序列数据进行将来的预测。 数据集......
【机器学习项目】使用 PyTorch 预测汽车价格（详细报告+代码详解）
m0_51118916的博客
06-16 5414
本实验旨在使用PyTorch构建一个预测汽车价格的模型。通过训练一个深度神经网络模型，我们可以利用汽车的各种特征（如品牌、型号、年份、里程数等）来预测汽车的价格。这将为汽车制造商和消费者提供一个有价值的工具，帮助他们做出更准确的定价和购买决策。
python LSTM可视化模型大袋
01-04
### Python 中 LSTM 模型可视化方法 #### 使用 TensorFlow 和 Keras 进行 LSTM 模型训练与可视化 为了更好地理解和解释 LSTM 模型的行为，可以采用多种方式对其进行可视化。一种常见的做法是在 Jupyter Notebook 或 Google Colab 环境下操作，这允许动态地观察模型的学习过程及其性能。 对于基于 TensorFlow 的 LSTM 实现而言，可以通过 TensorBoard 工具来进行详细的日志记录和图表绘制[^1]： ```python from tensorflow.keras.callbacks import TensorBoard import datetime # 设置 TensorBoard 日志目录 log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") tensorboard_callback = TensorBoard(log_dir=log_dir, histogram_freq=1) model.fit(x_train, y_train, epochs=50, validation_data=(x_test, y_test), callbacks=[tensorboard_callback]) ``` 上述代码片段展示了如何配置 `TensorBoard` 来监控训练进度，并保存每次迭代的结果到指定的日志文件夹中。之后可以在命令行启动 TensorBoard 并访问本地服务器查看这些信息。 另一种有效的方法是利用专门设计用于探索神经网络内部运作机制的应用程序如 LSTMVis[^3]。该应用程序不仅支持标准的损失函数图和其他统计指标显示，还特别针对循环神经元提供了独特的视角，使得用户能更深入地了解隐藏状态随时间变化的情况以及各个单元之间的交互作用。 此外，在纯编程环境下也可以借助 Matplotlib 或 Seaborn 库创建自定义绘图来呈现预测结果对比真实值的趋势线或其他形式的时间序列分析图像[^4]: ```python import matplotlib.pyplot as plt plt.figure(figsize=(12, 6)) plt.plot(y_true, label='True Values') plt.plot(predictions, label='Predictions', linestyle="--") plt.legend() plt.show() ``` 这段简单的脚本会生成一张折线图用来比较原始数据集中的目标变量（即真值）同由经过训练后的 LSTM 所产生的估计值之间差异。
评论 52
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Snu77

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值