时间序列预测实战(二十三)进阶版LSTM多元和单元预测（课程设计毕业设计首选）

      

一、本文介绍

本篇文章给大家带来的是利用我个人编写的架构进行LSTM模型进行时间序列建模（专门为了时间序列领域新人编写的架构，简单且不同于市面上大家用GPT写的代码），包括结果可视化、支持单元预测、多元预测、模型拟合效果检测、预测未知数据、以及滚动长期预测功能。该结构是一个通用架构任何模型嵌入其中都可运行。在之前我已经将出过一个LSTM的讲解了，那个比较简单只能进行单元预测，所以在这里进行了一个补充这个模型框架可以满足所有的时间序列功能。

  专栏目录：时间序列预测目录：深度学习、机器学习、融合模型、创新模型实战案例

专栏: 时间序列预测专栏：基础知识+数据分析+机器学习+深度学习+Transformer+创新模型

预测功能效果展示(不是测试集是预测未知数据)->

​

损失截图(后面运行有损失图像运行即可显示)-> 

根据损失来看模型的拟合效果还是很好的，但后面还是做了检验模型拟合效果的功能让大家真正的评估模型的效果。

测试集表现->

这里只展示了部分功能，代码中我还添加了许多可视化功能和结果生成功能。 

目录

一、本文介绍

二、LSTM的框架原理

2.1 LSTM的基础的结构

2.1.1 忘记门

2.1.2 输入门

2.1.3 输出门

三、数据集介绍

四、参数讲解 

五、完整运行代码

六、训练模型 

七、预测结果

7.1 预测未知数据效果图

7.2 测试集效果图 

7.3 CSV文件生成效果图 

7.4 检验模型拟合效果图

八、全文总结

二、LSTM的框架原理

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

2.1 LSTM的基础的结构

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

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

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

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

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

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

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

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

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

2.1.1 忘记门

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

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

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

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

2.1.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.1.3 输出门

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

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

三、数据集介绍

本文是实战讲解文章，上面主要是简单讲解了一下网络结构比较具体的流程还是很复杂的涉及到很多的数学计算，下面我们来讲一讲模型的实战内容，第一部分是我利用的数据集。

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

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

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

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

四、参数讲解 


    parser.add_argument('-model', type=str, default='TCN-LSTM', help="模型持续更新")
    parser.add_argument('-window_size', type=int, default=126, 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='ETTh1-Test.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('-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=64, help="隐藏层单元数")
    parser.add_argument('-kernel_sizes', type=int, default=3)
    parser.add_argument('-laryer_num', type=int, default=2)
    # device
    parser.add_argument('-use_gpu', type=bool, default=True)
    parser.add_argument('-device', type=int, default=0, help="只设置最多支持单个gpu训练")

    # option
    parser.add_argument('-train', type=bool, default=True)
    parser.add_argument('-test', 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输入的特征数不包含时间那一列！！！

8

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

10

drop_out

float丢弃概率
11epochsint训练轮次

12

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

14

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

16

layer_numintlstm层数
17use_gpubool是否使用GPU

18

deviceintGPU编号
19trainbool是否进行训练

20

predictbool是否进行预测

21

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

五、完整运行代码

复制粘贴到一个文件下并且按照上面的从参数讲解配置好参数即可运行~(极其适合新手和刚入门的读者)

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

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

    plt.plot(data, marker='o')

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

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

    plt.show()


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':
            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(1 * len(true_data))]
    valid_data = true_data[int(0.80 * len(true_data)):int(0.85 * len(true_data))]
    test_data = true_data[int(0.85 * 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(nn.Module):
    def __init__(self, input_size, output_size, pre_len, hidden_size, n_layers,  dropout=0.05):
        super(LSTM, self).__init__()
        self.pre_len = pre_len
        self.n_layers = n_layers
        self.hidden_size = hidden_size
        self.hidden = nn.Linear(input_size, self.hidden_size)
        self.relu = nn.ReLU()
        self.lstm = nn.LSTM(self.hidden_size, self.hidden_size, n_layers, bias=True, batch_first=True)  # output (batch_size, obs_len, hidden_size)
        self.linear = nn.Linear(self.hidden_size, output_size)

    def forward(self, x):
        batch_size, obs_len, features_size = x.shape  # (batch_size, obs_len, features_size)
        xconcat = self.hidden(x)  # (batch_size, obs_len, hidden_size)
        H = torch.zeros(batch_size, obs_len - 1, self.hidden_size).to(device)  # (batch_size, obs_len-1, hidden_size)
        ht = torch.zeros(self.n_layers, batch_size, self.hidden_size).to(
            device)  # (num_layers, batch_size, hidden_size)
        ct = ht.clone()
        for t in range(obs_len):
            xt = xconcat[:, t, :].view(batch_size, 1, -1)  # (batch_size, 1, hidden_size)
            out, (ht, ct) = self.lstm(xt, (ht, ct))  # ht size (num_layers, batch_size, hidden_size)
            htt = ht[-1, :, :]  # (batch_size, hidden_size)
            if t != obs_len - 1:
                H[:, t, :] = htt
        H = self.relu(H)  # (batch_size, obs_len-1, hidden_size)

        x = self.linear(H)
        return x[:, -self.pre_len:, :]


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

            y_pred = 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(model.state_dict(), 'save_model.pth')
        time.sleep(0.1)

    # 保存模型

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

    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().numpy().cpu(), np.array(labels.detach().cpu()))  # MAE误差计算绝对值(预测值  - 真实值)
        losss.append(mae)

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


def test(model, args, scaler, test_loader):
    # 加载模型进行预测
    losss = []
    df = pd.read_csv(args.data_path)
    df_inverse = df[int(0.85 * len(df)):][[args.target]].reset_index(drop=True)
    scaler_pre = StandardScaler().fit(df_inverse)
    model = model
    model.load_state_dict(torch.load('save_model.pth'))
    model.eval()  # 评估模式
    results = []
    labels = []

    for seq, label in test_loader:
        pred = model(seq)
        mae = calculate_mae(pred.detach().cpu().numpy(),
                            np.array(label.detach().cpu()))  # MAE误差计算绝对值(预测值  - 真实值)
        losss.append(mae)
        pred = pred[:, 0, :]
        label = label[:, 0, :]
        if args.feature == 'M' or args.feature == 'S':
            pred = scaler_train.inverse_transform(pred.detach().cpu().numpy())
            label = scaler_train.inverse_transform(label.detach().cpu().numpy())
        else:
            pred = scaler_pre.inverse_transform(pred.detach().cpu().numpy())
            label = scaler_pre.inverse_transform(label.detach().cpu().numpy())
        for i in range(len(pred)):
            results.append(pred[i][-1])
            labels.append(label[i][-1])


    print("测试集误差MAE:", losss)
    # 绘制历史数据
    plt.plot(labels, label='TrueValue')

    # 绘制预测数据
    # 注意这里预测数据的起始x坐标是历史数据的最后一个点的x坐标
    plt.plot(results, label='Prediction')

    # 添加标题和图例
    plt.title("test state")
    plt.legend()
    plt.show()


# 检验模型拟合情况
def inspect_model_fit(model, args, train_loader, scaler_train):
    df = pd.read_csv(args.data_path)
    df_inverse = df[:int(0.85 * len(df))][[args.target]].reset_index(drop=True)
    scaler_pre = StandardScaler().fit(df_inverse)
    model = model
    model.load_state_dict(torch.load('save_model.pth'))
    model.eval()  # 评估模式
    results = []
    labels = []

    for seq, label in train_loader:
        pred = model(seq)[:, 0, :]
        label = label[:, 0, :]
        if args.feature == 'M' or args.feature == 'S':
            pred = scaler_train.inverse_transform(pred.detach().cpu().numpy())
            label = scaler_train.inverse_transform(label.detach().cpu().numpy())
        else:
            pred = scaler_pre.inverse_transform(pred.detach().cpu().numpy())
            label = scaler_pre.inverse_transform(label.detach().cpu().numpy())
        for i in range(len(pred)):
            results.append(pred[i][-1])
            labels.append(label[i][-1])

    # 绘制历史数据
    plt.plot(labels, label='History')

    # 绘制预测数据
    # 注意这里预测数据的起始x坐标是历史数据的最后一个点的x坐标
    plt.plot(results, label='Prediction')

    # 添加标题和图例
    plt.title("inspect model fit state")
    plt.legend()
    plt.show()


def predict(model, args, device, scaler):
    # 预测未知数据的功能
    df = pd.read_csv(args.data_path)
    scaler_data = df[[args.target]][int(0.3 * len(df)):]
    scaler_pre = StandardScaler().fit(scaler_data)
    df = df.iloc[:, 1:][-args.window_size:].values  # 转换为nadarry
    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_pre.inverse_transform(pred.detach().cpu().numpy())

    # 假设 df 和 pred 是你的历史和预测数据

    # 计算历史数据的长度
    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], 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='TCN-LSTM', help="模型持续更新")
    parser.add_argument('-window_size', type=int, default=126, 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='ETTh1-Test.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('-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=64, help="隐藏层单元数")
    parser.add_argument('-kernel_sizes', type=int, default=3)
    parser.add_argument('-laryer_num', type=int, default=2)
    # device
    parser.add_argument('-use_gpu', type=bool, default=True)
    parser.add_argument('-device', type=int, default=0, help="只设置最多支持单个gpu训练")

    # option
    parser.add_argument('-train', type=bool, default=True)
    parser.add_argument('-test', 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)

    if args.feature == 'MS' or args.feature == 'S':
        args.output_size = 1
    else:
        args.output_size = args.input_size

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


    # 训练模型
    if args.train:
        print(f">>>>>>>>>>>>>>>>>>>>>>>>>开始{args.model}模型训练<<<<<<<<<<<<<<<<<<<<<<<<<<<")
        train(model, args, device)
    if args.test:
        print(f">>>>>>>>>>>>>>>>>>>>>>>>>开始{args.model}模型测试<<<<<<<<<<<<<<<<<<<<<<<<<<<")
        test(model, args, scaler_test, test_loader)
    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()

六、训练模型 

我们配置好所有参数之后就可以开始训练模型了，根据我前面讲解的参数部分进行配置，不懂得可以评论区留言。

七、预测结果

7.1 预测未知数据效果图

LSTM的预测效果图(这里我只预测了未来24个时间段的值为未来一天的预测值，个人觉得LSTM的极限就在20左右)->

7.2 测试集效果图 

测试集上的表现->

可以看出测试集上的表现还可以，毕竟只有一个LSTM没有加入任何其它的机制，LSTM作为最经典的时间序列预测模型效果还是可圈可点的。

7.3 CSV文件生成效果图 

同时我也可以将输出结果用csv文件保存，但是功能还没有做，我在另一篇informer的文章里实习了这个功能大家如果有需要可以评论区留言，有时间我会移植过来。

另一篇文章链接->时间序列预测实战(十九)魔改Informer模型进行滚动长期预测（科研版本，结果可视化）

将滚动预测结果生成了csv文件方便大家对比和评估，以下是我生成的csv文件可以说是非常的直观。

 我们可以利用其进行画图从而评估结果-> 

7.4 检验模型拟合效果图

检验模型拟合情况->

(从下面的图片可以看出模型拟合的情况很好) 

八、全文总结

 到此本文的正式分享内容就结束了，在这里给大家推荐我的时间序列专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的模型进行补充，目前本专栏免费阅读(暂时，大家尽早关注不迷路~)，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~

 专栏回顾： 时间序列预测专栏——持续复习各种顶会内容——科研必备

如果大家有不懂的也可以评论区留言一些报错什么的大家可以讨论讨论看到我也会给大家解答如何解决！最后希望大家工作顺利学业有成！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/217138.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

(C++)盛水最多的容器--双指针法

(C++)盛水最多的容器--双指针法

个人主页&#xff1a;Lei宝啊 愿所有美好如期而遇 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台备战技术面试&#xff1f;力扣提供海量技术面试资源&#xff0c;帮助你高效提升编程技能&#xff0c;轻松拿下世界 IT 名企 Dream Offer。https://le…
阅读更多...
软著项目推荐 深度学习图像风格迁移

软著项目推荐 深度学习图像风格迁移

文章目录 0 前言1 VGG网络2 风格迁移3 内容损失4 风格损失5 主代码实现6 迁移模型实现7 效果展示8 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 深度学习图像风格迁移 - opencv python 该项目较为新颖&#xff0c;适合作为竞赛课题…
阅读更多...
【ArcGIS Pro微课1000例】0048：深度学习--人群计数

【ArcGIS Pro微课1000例】0048：深度学习--人群计数

文章目录 一、小学回忆录二、深度学习计算人头数三、案例实现一、小学回忆录 加载配套实验数据包中的图片及训练模型。你还记得当年的小学毕业班有多少同学吗？今天我们就用ArcGIS提供的人工智能工具，重温一下童年记忆。 二、深度学习计算人头数 本案例使用到的是深度学习中…
阅读更多...
[树莓派3B+][内核版本6.1]的linux内核编译+替换 （超详细）

[树莓派3B+][内核版本6.1]的linux内核编译+替换 （超详细）

学习Linux的内核编译&#xff0c;我使用的是x86 64位的18.04的ubuntu-linux虚拟机&#xff1a; 目录 树莓派的Linux内核源码安装 操作系统的启动过程 & Bootloader 单片机裸机&#xff1a;C51,STM32 X86&#xff0c;Intel&#xff1a;windows 嵌入式产品&#xff1a;…
阅读更多...
CUDA简介——同步

CUDA简介——同步

1. 引言 前序博客&#xff1a; CUDA简介——基本概念CUDA简介——编程模式CUDA简介——For循环并行化CUDA简介——Grid和Block内Thread索引CUDA简介——CUDA内存模式 本文重点关注Thread同步和Barriers。 Threads并行执行&#xff0c;可能存在如下问题&#xff1a; 1&#…
阅读更多...
芯擎科技与芯华章深度合作，软硬件协同开发加速车规级芯片创新

芯擎科技与芯华章深度合作，软硬件协同开发加速车规级芯片创新

12月4日&#xff0c;系统级验证EDA解决方案提供商芯华章&#xff0c;与国产高端车规芯片设计公司芯擎科技正式建立战略合作。双方强强联手&#xff0c;芯擎科技导入芯华章相关EDA验证工具&#xff0c;赋能车规级芯片和应用软件的协同开发&#xff0c;助力大规模缩短产品上市周期…
阅读更多...
PoE技术详解

PoE技术详解

标准的五类网线有四对双绞线&#xff0c;IEEE 802.3af和IEEE 802.3at允许两种用法&#xff1a;通过空闲线对供电或者数据线对供电。IEEE 802.3bt允许通过空闲线对供电、通过数据线对供电或者空闲线对和数据线对一起供电&#xff0c;如图16.1所示。 图 16.1 PoE供电线对 当在一…
阅读更多...
第一节JavaScript 简介与使用

第一节JavaScript 简介与使用

JavaScript简介 JavaScript是互联网上最流行的脚本语言&#xff0c;这门语言可用于HTML和Web&#xff0c;更广泛用于服务器、PC、电脑、智能手机等设备上。 JavaScript是一种轻量级的编程语言。 JavaScript是可插入HTML页面的编程代码。 JavaScript插入HTML页面后&#xff…
阅读更多...
使用coco数据集进行语义分割：数据预处理与损失函数

使用coco数据集进行语义分割：数据预处理与损失函数

如何coco数据集进行目标检测的介绍已经有很多了&#xff0c;但是关于语义分割几乎没有。本文旨在说明如何处理 stuff_train2017.json stuff_val2017.json panoptic_train2017.json panoptic_val2017.json&#xff0c;将上面那些json中的dict转化为图片的label mask&am…
阅读更多...
【Proteus仿真】【Arduino单片机】蔬菜大棚温湿度控制系统设计

【Proteus仿真】【Arduino单片机】蔬菜大棚温湿度控制系统设计

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用Proteus8仿真Arduino单片机控制器&#xff0c;使用PCF8574、LCD1602液晶、DHT11温湿度传感器、按键、继电器、蜂鸣器、加热、水泵电机等。 主要功能&#xff1a; 系统运行后&#xff0c;LCD160…
阅读更多...
【模电】设置静态工作点的必要性

【模电】设置静态工作点的必要性

设置静态工作点的必要性 静态工作点为什么要设置静态工作点 静态工作点 在放大电路中&#xff0c;当有信号输入时&#xff0c;交流量与直流量共存。将输入信号为零、即直流电源单独作用时晶体管的基极电流 I B I\tiny B IB、集电极电流 I C I\tiny C IC、b - e间电压 U B E U\t…
阅读更多...
玩转大数据5:构建可扩展的大数据架构

玩转大数据5:构建可扩展的大数据架构

1. 引言 随着数字化时代的到来&#xff0c;大数据已经成为企业、组织和个人关注的焦点。大数据架构作为大数据应用的核心组成部分&#xff0c;对于企业的数字化转型和信息化建设至关重要。我们将探讨大数据架构的基本要素和原则&#xff0c;以及Java在大数据架构中的角色&…
阅读更多...
智能指针与动态内存

智能指针与动态内存

动态内存 new placement new 是 C 中的一种内存分配方式&#xff0c;它允许在给定的内存地址上构造对象&#xff0c;而不是在默认的堆上分配新的内存。这对于某些特殊的内存管理场景非常有用&#xff0c;例如在特定的内存池中分配对象。 C11 引入了 "new auto" 语法…
阅读更多...
【C语言】递归详解

【C语言】递归详解

目录 1.前言2. 递归的定义3. 递归的限制条件4. 递归举例4.1 求n的阶乘4.1.1 分析和代码实现4.1.2 画图演示 4.2 顺序打印一个整数的每一位4.2.1 分析和代码实现4.2.2 画图推演 4.3 求第n个斐波那契数 5. 递归与迭代5.1 迭代求第n个斐波那契数 1.前言 这次博客内容是与递归有关&…
阅读更多...
leetcode 876.链表的中间结点

leetcode 876.链表的中间结点

补充上次的环形链表没细讲的快慢指针&#xff08;这三道题现在可以连起来看&#xff09;&#xff0c;希望对你做题思路有帮助 876.链表的中间结点 题目 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结…
阅读更多...
kubernetes监控GPA安装部署

kubernetes监控GPA安装部署

本文在于指导如何对k8s的监控GPA(Grafana&#xff0c;prometheus以及alertmanager)进行安装部署。 1. 介绍 Prometheus 在真正部署Prometheus之前&#xff0c;应了解一下Prometheus的各个组件之间的关系及作用&#xff1a; 1&#xff09;MertricServer&#xff1a;是k8s集群…
阅读更多...
面试官：说说synchronized与ReentrantLock的区别

面试官：说说synchronized与ReentrantLock的区别

程序员的公众号&#xff1a;源1024&#xff0c;获取更多资料&#xff0c;无加密无套路&#xff01; 最近整理了一波电子书籍资料&#xff0c;包含《Effective Java中文版 第2版》《深入JAVA虚拟机》&#xff0c;《重构改善既有代码设计》&#xff0c;《MySQL高性能-第3版》&…
阅读更多...
【NI-RIO入门】Real Time（实时系统解释）

【NI-RIO入门】Real Time（实时系统解释）

1.什么是实时系统&#xff1f; 实时系统可以非常精确可靠的执行需要特定时许要求的系统&#xff0c;对于许多工程项目来说&#xff0c;通用操作系统&#xff0c;例如WINDOWS等标准PC上运行测量和控制程序是无法精确控制计时的&#xff0c;这些系统很容易受用户的其他程序、图像…
阅读更多...
联想LJ2655DN激光打印机清零方法

联想LJ2655DN激光打印机清零方法

随着打印机的使用越来越频繁&#xff0c;需要更换耗材的时候也越来越多&#xff1b;但是更换上新的耗材后&#xff0c;很多用户都会遇到一个问题&#xff0c;就是更换完新的耗材后打印机仍然提示寿命将近&#xff0c;或者无墨粉盒灯情况&#xff0c;这个时候就需要我们对打印机…
阅读更多...
关于使用百度开发者平台处理语音朗读问题排查

关于使用百度开发者平台处理语音朗读问题排查

错误信息&#xff1a;"convert_offline": false, "err_detail": "16: Open api characters limit reach 需要领取完 识别和合成都要有
阅读更多...
最新文章

Copyright @ 2022~2023