时间序列预测实战(二十二)TCN-LSTM实现单元和多元长期预测（专为新手编写的自研架构）

news2024/11/18 23:26:00

一、本文介绍

本篇文章给大家带来的是利用我个人编写的架构进行TCN-LSTM时间序列卷积进行时间序列建模（专门为了时间序列领域新人编写的架构，简单不同于市面上用GPT写的代码），包括结果可视化、支持单元预测、多元预测、模型拟合效果检测、预测未知数据、以及滚动长期预测功能。该结构是一个通用架构任何模型嵌入其中都可运行。下面来介绍一下TCN时间序列卷积的基本原理：时间序列卷积（Temporal Convolutional Network, TCN）通过一系列卷积层处理数据，每个层都能捕捉到不同时间范围内的模式。LSTM作为多元预测机制和单元预测机制的优点是可以处理序列数据中的长期依赖关系，从而可以捕捉到数据中的复杂模式和规律。它可以自适应地学习和调整模型参数，从而提高模型的预测性能和泛化能力。

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

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

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

​

损失截图(损失绘图功能已补上运行即可显示)-> 

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

检验模型拟合情况->

(从下面的图片可以看出模型拟合的情况很好，同时比上一篇博客单独用TCN的效果要好) 

目录

一、本文介绍

二、TCN的框架原理

2.1 TCN的主要思想

2.1.1 因果卷积

2.1.2  扩张卷积

2.1.3 无便宜填充

2.2 LSTM的主要思想 

2.2.1 忘记门

2.2.2 输入门

2.2.3 输出门

三、数据集介绍

四、参数讲解 

五、完整代码

六、训练模型 

七、预测结果

7.1 预测未知数据效果图

7.2 测试集效果图 

7.3 CSV文件生成效果图 

7.4 检验模型拟合效果图

八、全文总结

二、TCN的框架原理

2.1 TCN的主要思想

TCN，即Temporal Convolutional Network，是一种专门用于时间序列数据处理的神经网络架构。TCN的关键特点包括：

1. 因果卷积：TCN使用因果卷积来确保在预测未来值时，只会使用当前和过去的信息，而不会出现信息泄露。

2. 扩张卷积：通过扩张卷积，TCN可以在不丢失时间分辨率的情况下增加感受野（即模型可以观察到的历史信息范围）。扩张卷积通过间隔地应用卷积核来实现。

3. 无偏移填充：为了保持输出的时间长度与输入相同，TCN在卷积操作前使用了一种特殊的填充方式。

下图是时间序列卷积的示意图

下面我来分别介绍这几种机制->

2.1.1 因果卷积

什么是因果卷积？首先我们来确定这个问题

  • 因果关系意味着输出序列中的元素只能依赖于输入序列中它前面的元素。
  • 为了确保输出张量与输入张量具有相同的长度，我们需要进行零填充。
  • 如果我们只用零填充输入张量的左侧，那么因果卷积是有保证的。
  • x_{4}^{'}在下图中是通过组合生成的x_{2},x_{3}​,x_{4}确保不会泄露信息。

此操作生成x_{5}^{'}和x_{6}^{'}它们是无关的，应该在将输出传递到下一层之前删除。

TCN有两个基本原则：

  • 序列的输入和输出长度保持不变。
  • 过去不能有任何泄漏。

为了达到第一点，TCN利用了第二点，TCN利用了因果卷积。1D FCN ( Fully Convolutional Network)

2.1.2 扩张卷积

扩张卷积的工作原理

  1. 增加感受野：在标准的卷积中，卷积核覆盖的区域是连续的。扩张卷积通过在卷积核的各个元素之间插入空格（称为“扩张”）来扩大其覆盖区域。例如，一个扩张率为2的3x3卷积核实际上会覆盖一个5x5的区域，但只使用9个权重。

  2. 保持时间分辨率：与池化操作不同，扩张卷积不会减少数据的时间维度。这意味着输出数据在时间上的分辨率保持不变，这对于时间序列分析和音频处理等领域至关重要。

  3. 间隔应用：扩张卷积通过间隔地应用卷积核来实现其效果。这种间隔方式意味着卷积核可以跨越更大的区域，而不是只聚焦于紧邻的输入单元。

扩张卷积在TCN中的应用

在时间卷积网络（TCN）中，扩张卷积允许模型有效地处理长时间序列。通过增大感受野，TCN可以捕捉到更长范围内的依赖关系，这对于许多序列预测任务（如语音识别、自然语言处理等）非常有用。此外，扩张卷积的使用使得TCN在处理长序列时计算效率更高，因为它避免了重复计算和不必要的参数增加。

2.1.3 无便宜填充

无偏移填充在时间卷积网络（TCN）中的使用是为了保持输出序列的时间长度与输入序列相同，从而允许模型在处理序列数据时保持时间对齐。在传统的卷积操作中，通常会因为卷积核覆盖的范围而导致输出序列的长度减少。为了解决这个问题，TCN采用了无偏移填充的策略。

无偏移填充（Zero Padding）的工作原理

  1. 填充操作：无偏移填充是指在输入序列的开始部分添加适量的零值，以使得卷积操作后的输出序列长度不减少。这种填充方式通常用于时间序列的处理中，确保经过卷积后，时间维度上的长度保持不变。

  2. 保持时间对齐：在处理时间序列数据时，保持时间上的对齐非常重要，尤其是在预测未来事件或者在时间序列上做分类任务时。无偏移填充确保了输入和输出在时间维度上保持对齐。

  3. 防止信息丢失：在没有填充的情况下，卷积操作可能会导致序列边缘的信息丢失，因为卷积核无法完全覆盖这些区域。通过使用无偏移填充，可以保证序列的每个部分都被卷积核等同地处理。

在TCN中的应用

在TCN中，无偏移填充通常与扩张卷积结合使用。通过在卷积层之前适当地添加零值，可以保证即使在使用较大扩张率的情况下，输出序列的长度也与输入序列的长度相同。这样不仅保留了时间序列数据的完整性，还允许模型捕捉到长距离的依赖关系，提高模型对时间序列数据的处理能力。

2.2 LSTM的主要思想 

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}代表当前序列模型的输出结果。

三、数据集介绍

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

本文我们用到的数据集是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('-output_size', type=int, default=7, help='输出特征个数只有两种选择和你的输入特征一样即输入多少输出多少，另一种就是多元预测单元')
    parser.add_argument('-feature', type=str, default='M', help='[M, S, MS],多元预测多元,单元预测单元,多元预测单元')
    parser.add_argument('-model_dim', type=list, default=[64, 128, 256], help='这个地方是这个TCN卷积的关键部分,它代表了TCN的层数我这里输'
                                                                              '入list中包含三个元素那么我的TCN就是三层，这个根据你的数据复杂度来设置'
                                                                              '层数越多对应数据越复杂但是不要超过5层')

    # 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=1)
    # 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输入的特征数不包含时间那一列！！！
8output_sizeint输出的特征数只可以是1或者是等于你输入的特征数

9

featurestr[M, S, MS],多元预测多元,单元预测单元,多元预测单元

10

model_dimlist这个地方是这个TCN卷积的关键部分,它代表了TCN的层数我这里输入list中包含三个元素那么我的TCN就是三层，这个根据你的数据复杂度来设置层数越多对应数据越复杂但是不要超过5层!!!!重点部分
11lrfloat学习率大小

12

drop_out

float丢弃概率
13epochsint训练轮次

14

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

16

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

18

layer_numintlstm层数
19use_gpubool是否使用GPU

20

deviceintGPU编号
21trainbool是否进行训练
22testbool是否进行测试

23

predictbool是否进行预测

24

inspect_fitbool是否进行检验模型
25lr_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 Chomp1d(nn.Module):
    def __init__(self, chomp_size):
        super(Chomp1d, self).__init__()
        self.chomp_size = chomp_size

    def forward(self, x):
        return x[:, :, :-self.chomp_size].contiguous()


class TemporalBlock(nn.Module):
    def __init__(self, n_inputs, n_outputs, kernel_size, stride, dilation, padding, dropout=0.2):
        super(TemporalBlock, self).__init__()
        self.conv1 = weight_norm(nn.Conv1d(n_inputs, n_outputs, kernel_size,
                                           stride=stride, padding=padding, dilation=dilation))
        self.chomp1 = Chomp1d(padding)
        self.relu1 = nn.ReLU()
        self.dropout1 = nn.Dropout(dropout)

        self.conv2 = weight_norm(nn.Conv1d(n_outputs, n_outputs, kernel_size,
                                           stride=stride, padding=padding, dilation=dilation))
        self.chomp2 = Chomp1d(padding)
        self.relu2 = nn.ReLU()
        self.dropout2 = nn.Dropout(dropout)

        self.net = nn.Sequential(self.conv1, self.chomp1, self.relu1, self.dropout1,
                                 self.conv2, self.chomp2, self.relu2, self.dropout2)
        self.downsample = nn.Conv1d(n_inputs, n_outputs, 1) if n_inputs != n_outputs else None
        self.relu = nn.ReLU()
        self.init_weights()

    def init_weights(self):
        self.conv1.weight.data.normal_(0, 0.01)
        self.conv2.weight.data.normal_(0, 0.01)
        if self.downsample is not None:
            self.downsample.weight.data.normal_(0, 0.01)

    def forward(self, x):
        out = self.net(x)
        res = x if self.downsample is None else self.downsample(x)
        return self.relu(out + res)


class TemporalConvNet(nn.Module):
    def __init__(self, num_inputs, outputs, pre_len, num_channels, n_layers, kernel_size=2, dropout=0.2):
        super(TemporalConvNet, self).__init__()
        layers = []
        self.pre_len = pre_len
        self.n_layers = n_layers
        self.hidden_size = num_channels[-2]
        self.hidden = nn.Linear(num_channels[-1], num_channels[-2])
        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)
        num_levels = len(num_channels)
        for i in range(num_levels):
            dilation_size = 2 ** i
            in_channels = num_inputs if i == 0 else num_channels[i-1]
            out_channels = num_channels[i]
            layers += [TemporalBlock(in_channels, out_channels, kernel_size, stride=1, dilation=dilation_size,
                                     padding=(kernel_size-1) * dilation_size, dropout=dropout)]

        self.network = nn.Sequential(*layers)
        self.linear = nn.Linear(num_channels[-2], outputs)
    def forward(self, x):
        x = x.permute(0, 2, 1)
        x = self.network(x)
        x = x.permute(0, 2, 1)

        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], 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='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('-output_size', type=int, default=7, help='输出特征个数只有两种选择和你的输入特征一样即输入多少输出多少，另一种就是多元预测单元')
    parser.add_argument('-feature', type=str, default='M', help='[M, S, MS],多元预测多元,单元预测单元,多元预测单元')
    parser.add_argument('-model_dim', type=list, default=[64, 128, 256], help='这个地方是这个TCN卷积的关键部分,它代表了TCN的层数我这里输'
                                                                              '入list中包含三个元素那么我的TCN就是三层，这个根据你的数据复杂度来设置'
                                                                              '层数越多对应数据越复杂但是不要超过5层')

    # 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=1)
    # 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)

    # 实例化模型
    try:
        print(f">>>>>>>>>>>>>>>>>>>>>>>>>开始初始化{args.model}模型<<<<<<<<<<<<<<<<<<<<<<<<<<<")
        model = TemporalConvNet(args.input_size, args.output_size, args.pre_len, args.model_dim, args.laryer_num, args.kernel_sizes).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 预测未知数据效果图

TCN的预测效果图(这里我只预测了未来24个时间段的值为未来一天的预测值)->

7.2 测试集效果图 

测试集上的表现->

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

7.3 CSV文件生成效果图 

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

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

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

7.4 检验模型拟合效果图

检验模型拟合情况->

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

八、全文总结

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

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

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

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Burp Suite序列之目录扫描

Burp Suite序列之目录扫描

如果你是一名渗透测试爱好者或者专业人士&#xff0c;你一定知道目录扫描是渗透测试中非常重要的一步。通过目录扫描&#xff0c;我们可以发现网站的敏感信息&#xff0c;隐藏的功能&#xff0c;甚至是后台入口。目录扫描可以帮助我们更好地了解目标网站的结构和漏洞。 但是&a…
阅读更多...
如何访问电脑的组策略编辑器？

如何访问电脑的组策略编辑器？

如何打开组策略 如果我们使用的是 Win 10 系统&#xff0c;如何打开组策略&#xff1f;下面为大家总结了四种打开组策略编辑器的方法。 从搜索框打开 Win 10 策略组怎么打开&#xff1f;一个简单快速的方法就是使用 Windows 自带的搜索栏。我们可以向搜索框中输入“编辑组策…
阅读更多...
Vue3中的组合式API的详细教程和介绍

Vue3中的组合式API的详细教程和介绍

文章目录 前言介绍组合式 API 基础setup 组件选项 带 ref 的响应式变量生命周期钩子注册内部 setupwatch 响应式更改独立的 computed 属性后言 前言 hello world欢迎来到前端的新世界 &#x1f61c;当前文章系列专栏&#xff1a;vue.js &#x1f431;‍&#x1f453;博主在前端…
阅读更多...
探索创意无限的Photoshop CC 2020Mac/Win版

探索创意无限的Photoshop CC 2020Mac/Win版

作为一款功能强大的图像处理软件&#xff0c;Photoshop CC 2020&#xff08;简称PS 2020&#xff09;在全球范围内备受设计师、摄影师和艺术家的喜爱和推崇。它不仅为用户提供了丰富多样的工具和功能&#xff0c;还不断推出新的创意特效和改进的功能&#xff0c;让用户的创意无…
阅读更多...
链式栈的结构与基本操作的实现（初始化，入栈，出栈，获取元素个数，判空，清空，销毁）

链式栈的结构与基本操作的实现（初始化，入栈，出栈，获取元素个数，判空，清空，销毁）

目录 一.链式栈的栈顶在哪里? 二.链栈的结构: 三.链式栈的实现: 四.链式栈的总结: 一.链式栈的栈顶在哪里? 二.链栈的结构: typedef struct LSNode{int data;struct LSNode* next;}LSNode ,*PLStack; //链栈的节点.由于栈顶在第一个数据节点,所以不需要top指针 三.链式…
阅读更多...
细粒度视觉分类的注意内核编码网络

细粒度视觉分类的注意内核编码网络

Attentional Kernel Encoding Networks for Fine-Grained Visual Categorization 1、介绍2、方法2.1 卷积模块2.2 级联注意力模块2.3 内核编码模块2.4 整体 3、结论 在本文中&#xff0c;我们提出了一种用于细粒度视觉分类的注意核编码网络(AKEN)。具体来说&#xff0c;AKEN聚合…
阅读更多...
【性能测试】性能分析和调优——步骤及案例

【性能测试】性能分析和调优——步骤及案例

文章目录 性能测试瓶颈分析常见的性能瓶颈分析性能调优性能调优步骤 性能调优案例案例一——CPU案例二——网络案例三——SQL查询案例四——JVM内存溢出 阅读前建议先了解前一篇文章&#xff1a;【性能测试】性能测试监控关键指标 性能测试瓶颈分析 常见的性能瓶颈分析 1、服…
阅读更多...
qemu网络通信

qemu网络通信

TAP&#xff08;官网参考地址&#xff09; TAP&#xff0c;即Tunneling traffic access point&#xff0c;是一种在Linux上使用的虚拟网卡技术&#xff0c;它可以为应用程序提供安全的网络连接。可以利用TAP搭建桥接网络&#xff0c;bridge两端分别为host和qemu虚拟机。 安装…
阅读更多...
带删除的并查集

带删除的并查集

Almost Union-Find 支持三种操作 合并 x x x和 y y y所在的集合把 x x x移到 y y y所在的集合求 x x x所在的集合的元素个数和元素之和 操作1和3是基本的并查集的操作. 关键在于操作 2 2 2: 若使用朴素的并查集&#xff0c;把节点 1 1 1合并到 3 3 3所在的集合&#xff0c;会…
阅读更多...
人机协同

人机协同

人机协同是指人和机器之间进行合作和协同工作的方式&#xff0c;人机协同是人工智能技术发展的一个重要方向&#xff0c;通过人机协同的方式&#xff0c;可以充分利用机器的智能和人的智慧&#xff0c;共同实现更高效、更智能的工作和生活方式。人机协同可以应用于各种领域和场…
阅读更多...
CGAL中2D三角剖分的数据结构

CGAL中2D三角剖分的数据结构

1、定义 三角剖分数据结构是一种设计用于处理二维三角剖分表示的数据结构。三角剖分数据结构的概念主要是设计用作CGAL2D三角剖分类的数据结构&#xff0c;这些类是嵌入平面中的三角剖分。然而&#xff0c;这个概念似乎更一般&#xff0c;可以用于任何可定向的无边界三角剖分曲…
阅读更多...
Robotframework自动化常见问题总结

Robotframework自动化常见问题总结

Robotframework自动化新手常见问题总结 1. 经常有人问这个元素找不到&#xff0c;一般先排除这两个地方&#xff0c;再自己找找 A&#xff1a;是否等待了足够的时间让元素加载 (增加sleep xx, wait Until xxx) B: 仔细查查&#xff0c;这个元素是否进入到另一个frame了 (sel…
阅读更多...
从订阅式需求发展，透视凌雄科技DaaS模式增长潜力

从订阅式需求发展，透视凌雄科技DaaS模式增长潜力

订阅制&#xff0c;C端消费者早已耳熟能详&#xff0c;如今也凭借灵活、服务更新稳定的特点&#xff0c;逐渐成为B端企业服务的新热点。 比如对中小企业而言&#xff0c;办公IT设备等配套支出都必不可少&#xff0c;但收入本身并不稳定&#xff0c;购置大堆固定资产&#xff0…
阅读更多...
uniapp实现文件预览过程

uniapp实现文件预览过程

H5实现预览 <template><iframe :src"_url" style"width:100vw; height: 100vh;" frameborder"0"></iframe> </template> <script lang"ts"> export default {data() {return {_url: ,}},onLoad(option…
阅读更多...
激光SLAM：Faster-Lio 算法编译与测试

激光SLAM：Faster-Lio 算法编译与测试

激光SLAM&#xff1a;Faster-Lio 算法编译与测试 前言编译测试离线测试在线测试 前言 Faster-LIO是基于FastLIO2开发的。FastLIO2是开源LIO中比较优秀的一个&#xff0c;前端用了增量的kdtree&#xff08;ikd-tree&#xff09;&#xff0c;后端用了迭代ESKF&#xff08;IEKF&a…
阅读更多...
7、单片机与W25Q128(FLASH)的通讯(SPI)实验(STM32F407)

7、单片机与W25Q128(FLASH)的通讯(SPI)实验(STM32F407)

SPI接口简介 SPI 是英语Serial Peripheral interface的缩写&#xff0c;顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。 SPI&#xff0c;是一种高速的&#xff0c;全双工&#xff0c;同步的通信总线&#xff0c;并且在芯片的管脚上只占用四根…
阅读更多...
【学习记录】从0开始的Linux学习之旅——应用开发（helloworld）

【学习记录】从0开始的Linux学习之旅——应用开发（helloworld）

一、概述 Linux操作系统通常是基于Linux内核&#xff0c;并结合GNU项目中的工具和应用程序而成。Linux操作系统支持多用户、多任务和多线程&#xff0c;具有强大的网络功能和良好的兼容性。本文主要讲述如何在linux系统上进行应用开发。 二、概念及原理 应用程序通过系统调用与…
阅读更多...
理解BatchNormalization层的作用

理解BatchNormalization层的作用

深度学习 文章目录 深度学习前言一、“Internal Covariate Shift”问题二、BatchNorm的本质思想三、训练阶段如何做BatchNorm四、BatchNorm的推理(Inference)过程五、BatchNorm的好处六、机器学习中mini-batch和batch有什么区别 前言 Batch Normalization作为最近一年来DL的重…
阅读更多...
漏洞复现--Tenda路由器DownloadCfg信息泄露

漏洞复现--Tenda路由器DownloadCfg信息泄露

免责声明&#xff1a; 文章中涉及的漏洞均已修复&#xff0c;敏感信息均已做打码处理&#xff0c;文章仅做经验分享用途&#xff0c;切勿当真&#xff0c;未授权的攻击属于非法行为&#xff01;文章中敏感信息均已做多层打马处理。传播、利用本文章所提供的信息而造成的任何直…
阅读更多...
IntelliJ IDEA创建springboot项目时不能选择java8的问题解决方案

IntelliJ IDEA创建springboot项目时不能选择java8的问题解决方案

最近博主也有创建springboot项目&#xff0c;发现了IntelliJ IDEA在通过Spring Initilizer初始化项目的时候已经没有java8版本的选项了。 基于这个问题&#xff0c;有了这篇文章的分享&#xff0c;希望能够帮助大家克服这个困难。 如图&#xff0c;现在创建springboot项目的时…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023