多层多输入的CNN-LSTM时间序列回归预测（卷积神经网络-长短期记忆网络）——附代码

Posted 2023-04-05 神经网络与数学建模

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了多层多输入的CNN-LSTM时间序列回归预测（卷积神经网络-长短期记忆网络）——附代码相关的知识，希望对你有一定的参考价值。

摘要：

本文使用CNN-LSTM混合神经网络对时间序列数据进行回归预测。本模型的输入数据个数可以自行选择，可以为多输入、也可以为单输入，使用Matlab自带的数据集进行训练，可以轻松的更换数据集以实现自己的功能。首先使用CNN网络对输入数据进行深度特征提取，然后将提取到的抽象特征进行压缩，将压缩后的数据输入后续的LSTM网络进行回归预测。相比一般的单层网络结构，本文所提出的CNN-LSTM包含了三层CNN和三层LSTM网络，因此本文网络预测的准确度有了一定的提升。

本文代码结构清晰，实现效果很好，出图美观，适合初学者进行模仿学习或用于数学建模方面。

有关于CNN-LSTM进行多输入特征分类的代码，可以看我之前发的文章。

卷积神经网络(CNN)的介绍：

卷积神经网络（ConvolutionalNeuralNetworks,CNN）能有效的提取二维图像和高维数据的特征。卷积神经网络具有减少内存占用、减少网络参数、缓解过拟合问题等优势，因此基于卷积神经网络时间序列预测模型。

卷积神经网络由输入层、隐含层和输出层组成，其中隐含层又分为卷积层、池化层和全连接层。结构如图：

（1）输入层：

输入层的作用是预处理输入的图像或数据。预处理方法能够减少数据量纲的差异对模型的影响，可以提高模型的学习效率。

（2）隐含层：

隐含层包括卷积层、池化层、全连接层，作用是完成特征的提取和学习。

（a）卷积层：卷积层中最重要的是卷积核。卷积核的个数、大小和形状，需要根据数据或图像的实际情况确定。一维卷积通常用来处理一维、二维数据或图像，二维卷积常用于二维数据矩阵的卷积操作，三维卷积常用于医学及视频处理领域的三维数据。步长是指进行卷积计算时，每次移动的格数。即步长为几时，卷积核每次向右移动几个格子。在模型训练时，可以根据需要改变步长、卷积核的大小和数量。卷积操作的具体步骤以图举例说明。图中左侧的4×4的矩阵代表输入，中间3×3的矩阵为卷积核，步长设为1，则右侧的矩阵为特征结果图。卷积操作过程为：将卷积核在输入数据或图像上每次先向右平移一个步长，将卷积核矩阵和输入数据对应位置矩阵进行内积计算，输出一个数值，放在特征结果图的对应位置上。水平方向完成卷积计算后再向下移动一个步长，重复卷积计算步骤，最终得到输入数据或图像的特征结果图，

（b）池化层：池化层也称采样层，主要作用是采样降维，即在不改变数据或图像特征的前提下，将数据的维数尽可能地降低。通过池化函数，将特征图某点替换为其相邻输出的全局特征。按照滤波器映射范围内像素点取值的不同，可分为平均池化和最大池化。平均池化：计算所有非零数据的平均值并用作输出。以2×2池化为例，左侧为卷积操作后得到的特征结果图，池化滤波器在特征结果图上每次平移两个步长，得到特征结果图被划分成四部分，分别计算非零像素点的平均值，并作为该位置的输出。

（c）全连接层：全连接层的作用是将特征映射到样本标记空间。通过全连接层将神经元权重连接，并向下一层网络传递数据信息。即通过矩阵乘法对特征向量加权求和计算，并通过激活函数得到全连接层的输出

（3）输出层：

增加一层回归层，并将全连接层的输出值输入到回归层中，得到神经网络的最后输出，即神经网络非线性映射的非线性变换结果。

长短期记忆网络（LSTM）的介绍：

LSTM和循环神经网络都是链式结构，其特殊性在于LSTM加入门结构来存储细胞的状态。因为门结构的存在，随着迭代层数的增加，激活函数的反向误差仍能向下传递，避免长期依赖问题

LSTM是RNN的一种变形，隐含层加入忘记门、输入门和输出门使其不仅能接受上一层神经元的输出，还能通过门结构选择性的保留历史时刻的有用信息。

LSTM是一种含有LSTM区块（blocks）或其他的一种类神经网络，文献或其他资料中LSTM区块可能被描述成智能网络单元，因为它可以记忆不定时间长度的数值，区块中有一个gate能够决定input是否重要到能被记住及能不能被输出output。

最左边函数依情况可能成为区块的input，右边三个会经过gate决定input是否能传入区块，左边第二个为inputgate，如果这里产出近似于零，将把这里的值挡住，不会进到下一层。左边第三个是forgetgate，当这产生值近似于零，将把区块里记住的值忘掉。第四个也就是最右边的input为outputgate，他可以决定在区块记忆中的input是否能输出。

CNN-LSTM：

考虑到CNN和LSTM分别在提取高维数据特征信息和处理时间序列数据方面的优势，设计CNN-LSTM模型来预测实现序列。

卷积神经网络特有的卷积核池化操作能很好的提取数据的特征信息，而长短期记忆神经网络具有很强的记忆性，对序列化数据处理效果较好。基于两种神经网络模型的优势考虑，将两种模型组合。

Matlab代码运行结果：

本文Matlab代码+数据分享：

PyTorch搭建CNN-LSTM混合模型实现多变量多步长时间序列预测（负荷预测）

I. 前言

关于LSTM的具体原理可以参考：人工智能教程。除了LSTM以外，这个网站还囊括了其他大多机器学习以及深度学习模型的具体讲解，配图生动，简单易懂。

前面已经写了很多关于时间序列预测的文章：

上面所有文章一共采用了LSTM、ANN以及CNN三种模型来分别进行时间序列预测。众所周知，CNN提取特征的能力非常强，因此现在不少论文将CNN和LSTM结合起来进行时间序列预测。本文将利用PyTorch来搭建一个简单的CNN-LSTM混合模型实现负荷预测。

II. CNN-LSTM

CNN-LSTM模型搭建如下：

class CNN_LSTM(nn.Module):
    def __init__(self, args):
        super(CNN_LSTM, self).__init__()
        self.args = args
        self.relu = nn.ReLU(inplace=True)
        # (batch_size=30, seq_len=24, input_size=7) ---> permute(0, 2, 1)
        # (30, 7, 24)
        self.conv = nn.Sequential(
            nn.Conv1d(in_channels=args.in_channels, out_channels=args.out_channels, kernel_size=3),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=3, stride=1)
        )
        # (batch_size=30, out_channels=32, seq_len-4=20) ---> permute(0, 2, 1)
        # (30, 20, 32)
        self.lstm = nn.LSTM(input_size=args.out_channels, hidden_size=args.hidden_size,
                            num_layers=args.num_layers, batch_first=True)
        self.fc = nn.Linear(args.hidden_size, args.output_size)

    def forward(self, x):
        x = x.permute(0, 2, 1)
        x = self.conv(x)
        x = x.permute(0, 2, 1)
        x, _ = self.lstm(x)
        x = self.fc(x)
        x = x[:, -1, :]

        return x

可以看到，该CNN-LSTM由一层一维卷积+LSTM组成。

通过PyTorch搭建CNN实现时间序列预测（风速预测）我们知道，一维卷积的原始定义如下：

nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

本文模型的一维卷积定义：

nn.Conv1d(in_channels=args.in_channels, out_channels=args.out_channels, kernel_size=3)

这里in_channels的概念相当于自然语言处理中的embedding，因此输入通道数为7，表示负荷+其他6个环境变量；out_channels的可以随意设置，本文设置为32；kernel_size设置为3。

PyTorch中一维卷积的输入尺寸为：

input(batch_size, input_size, seq_len)=(30, 7, 24)

而经过数据处理后得到的数据维度为：

input(batch_size, seq_len, input_size)=(30, 24, 7)

因此，我们需要进行维度交换：

x = x.permute(0, 2, 1)

交换后的输入数据将符合CNN的输入。

一维卷积中卷积操作是针对seq_len维度进行的，也就是(30, 7, 24)中的最后一个维度。因此，经过：

nn.Conv1d(in_channels=args.in_channels, out_channels=args.out_channels, kernel_size=3)

后，数据维度将变为：

(30, 32, 24-3+1)=(30, 32, 22)

第一维度的batch_size不变，第二维度的input_size将由in_channels=7变成out_channels=32，第三维度进行卷积变成22。

然后经过一个最大池化变成：

(30, 32, 22-3+1)=(30, 32, 20)

此时的(30, 32, 20)将作为LSTM的输入。由于在LSTM中我们设置了batch_first=True，因此LSTM能够接收的输入维度为：

input(batch_size, seq_len, input_size)

而经卷积池化后得到的数据维度为：

input(batch_size=30, input_size=32, seq_len=20)

因此，同样需要进行维度交换：

x = x.permute(0, 2, 1)

然后就是比较常规的LSTM输入输出的，不再细说。

因此，完整的forward函数如下所示：

def forward(self, x):
    x = x.permute(0, 2, 1)
    x = self.conv(x)
    x = x.permute(0, 2, 1)
    x, _ = self.lstm(x)
    x = self.fc(x)
    x = x[:, -1, :]

    return x

III. 代码实现

3.1 数据处理

我们根据前24个时刻的负荷以及该时刻的环境变量来预测接下来4个时刻的负荷，这里采用了直接多输出策略，调整output_size即可调整输出步长。

代码实现：

def nn_seq(args):
    seq_len, B, num = args.seq_len, args.batch_size, args.output_size
    print('data processing...')
    dataset = load_data()
    # split
    train = dataset[:int(len(dataset) * 0.6)]
    val = dataset[int(len(dataset) * 0.6):int(len(dataset) * 0.8)]
    test = dataset[int(len(dataset) * 0.8):len(dataset)]
    m, n = np.max(train[train.columns[1]]), np.min(train[train.columns[1]])

    def process(data, batch_size, step_size):
        load = data[data.columns[1]]
        data = data.values.tolist()
        load = (load - n) / (m - n)
        load = load.tolist()
        seq = []
        for i in range(0, len(data) - seq_len - num, step_size):
            train_seq = []
            train_label = []

            for j in range(i, i + seq_len):
                x = [load[j]]
                for c in range(2, 8):
                    x.append(data[j][c])
                train_seq.append(x)

            for j in range(i + seq_len, i + seq_len + num):
                train_label.append(load[j])

            train_seq = torch.FloatTensor(train_seq)
            train_label = torch.FloatTensor(train_label).view(-1)
            seq.append((train_seq, train_label))

        # print(seq[-1])
        seq = MyDataset(seq)
        seq = DataLoader(dataset=seq, batch_size=batch_size, shuffle=False, num_workers=0, drop_last=False)

        return seq

    Dtr = process(train, B, step_size=1)
    Val = process(val, B, step_size=1)
    Dte = process(test, B, step_size=num)

    return Dtr, Val, Dte, m, n

3.2 模型训练/测试

和前面一致：

def train(args, Dtr, Val, path):
    model = CNN_LSTM(args).to(args.device)
    loss_function = nn.MSELoss().to(args.device)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    print('training...')
    epochs = 50
    min_epochs = 10
    best_model = None
    min_val_loss = 5
    for epoch in range(epochs):
        train_loss = []
        for batch_idx, (seq, target) in enumerate(Dtr, 0):
            seq, target = seq.to(args.device), target.to(args.device)
            optimizer.zero_grad()
            y_pred = model(seq)
            loss = loss_function(y_pred, target)
            train_loss.append(loss.item())
            loss.backward()
            optimizer.step()

        # validation
        val_loss = get_val_loss(args, model, Val)
        if epoch + 1 >= min_epochs and val_loss < min_val_loss:
            min_val_loss = val_loss
            best_model = copy.deepcopy(model)

        print('epoch :03d train_loss :.8f val_loss :.8f'.format(epoch, np.mean(train_loss), val_loss))
        model.train()

    state = 'model': best_model.state_dict(), 'optimizer': optimizer.state_dict()
    torch.save(state, path)


def test(args, Dte, path, m, n):
    print('loading model...')
    model = CNN_LSTM(args).to(args.device)
    model.load_state_dict(torch.load(path)['model'])
    model.eval()
    pred = []
    y = []
    for batch_idx, (seq, target) in enumerate(Dte, 0):
        seq = seq.to(args.device)
        with torch.no_grad():
            target = list(chain.from_iterable(target.tolist()))
            y.extend(target)
            y_pred = model(seq)
            y_pred = list(chain.from_iterable(y_pred.data.tolist()))
            pred.extend(y_pred)

    y, pred = np.array(y), np.array(pred)

    y = (m - n) * y + n
    pred = (m - n) * pred + n
    print('mape:', get_mape(y, pred))
    # plot
    x = [i for i in range(1, 151)]
    x_smooth = np.linspace(np.min(x), np.max(x), 900)
    y_smooth = make_interp_spline(x, y[150:300])(x_smooth)
    plt.plot(x_smooth, y_smooth, c='green', marker='*', ms=1, alpha=0.75, label='true')

    y_smooth = make_interp_spline(x, pred[150:300])(x_smooth)
    plt.plot(x_smooth, y_smooth, c='red', marker='o', ms=1, alpha=0.75, label='pred')
    plt.grid(axis='y')
    plt.legend()
    plt.show()