当前位置：首页 > article >正文

时间序列预测（十九）——卷积神经网络（CNN）在时间序列中的应用

article 2025/3/18 1:15:48

有关CNN的介绍可以参考以下博文：

卷积神经网络（CNN）详细介绍及其原理详解-CSDN博客

三万字硬核详解：卷积神经网络CNN（原理详解 + 项目实战 + 经验分享）_cnn卷积神经网络-CSDN博客

CNN笔记：通俗理解卷积神经网络_cnn卷积神经网络-CSDN博客

尽管 CNN 最初是为图像数据设计的，但它的特性（如局部感受野和权重共享）在捕捉时间序列数据中的局部模式和相邻关系时也非常有效。下面是 CNN 在时间序列分析中的应用详细介绍。

一、为什么使用 CNN 处理时间序列？

CNN 的特点适合时间序列分析，主要原因有以下几点：

局部特征提取：卷积核（filter）能够自动学习局部时间模式，如周期性波动或突变点，适合处理短期依赖的特征。
权重共享：在时间序列中，相同的模式可能出现在不同的时间步。权重共享能够帮助 CNN 学习具有一致性的特征，同时减少参数数量。
有效的降维：通过池化（Pooling）操作，CNN 可以减少数据量并提取关键特征，帮助防止过拟合，尤其在数据规模有限时。

二、 CNN 在时间序列中的架构设计

CNN 在时间序列中的架构设计通常包含卷积层、池化层、全连接层，以及可能的输出层。以下是一些关键组件的详细说明：

1 卷积层

在时间序列中，卷积操作将一个一维卷积核与输入序列进行卷积，提取相邻时间点的特征。卷积层的关键设计要素包括：

卷积核大小：卷积核的长度决定了 CNN 感受的时间窗口的长度。较小的卷积核可以捕捉到短期特征，而较大的卷积核可以捕捉到长时依赖的特征。
步长：卷积步长控制每次卷积滑动的时间步大小，较大的步长可以减少计算量，同时加速模型的训练过程。

例如：

输入序列:  [x1, x2, x3, x4, x5, x6, x7, x8]
卷积核:    [w1, w2, w3]
输出:      [y1, y2, y3, y4, y5]  (使用步长=1，卷积核大小=3)

对于每一个输出元素 $y_{i}$ ，卷积核会与输入序列的某一部分（窗口）进行逐元素相乘，并将乘积结果求和 $y_{i} =w_{1}\times x_{i} +w_{2}\times x_{i+1} +w_{3}\times x_{i+2}$

2 池化层

池化层用于在卷积后进一步降维，并保留主要特征，从而防止过拟合。常见的池化方式有最大池化（Max Pooling）和平均池化（Average Pooling）：

最大池化：在一个窗口内提取最大值，保留最显著的特征。
平均池化：在一个窗口内取平均值，更适合平滑的特征提取。

例如：

输入序列:  [x1, x2, x3, x4, x5, x6]
最大池化（步长=2）: [max(x1,x2), max(x3,x4), max(x5,x6)] -> [x2, x4, x6]

3 扩展卷积（Dilated Convolution）

扩展卷积是一种特殊的卷积，允许在卷积操作时加入空洞，从而加大感受野，但不会增加计算量。这对于时间序列数据中的长时依赖（long-term dependencies）建模非常有帮助。扩展卷积的空洞率决定了卷积核的扩展程度，适合于提取多尺度的特征。

例如：

输入序列: [x1, x2, x3, x4, x5, x6]
扩展卷积（空洞率=2）: [x1, 0, x3, 0, x5] (跳过每个中间的元素)

4 全局池化层

在时间序列的最后一层卷积之后，通常会加入全局池化层（如全局最大池化或全局平均池化），用来将所有时间步的特征压缩为一个固定大小的向量。这种方式可以减少特征的维度，增强特征的全局性。

例如：

输入序列: [x1, x2, x3, x4, x5]
全局池化: max([x1, x2, x3, x4, x5]) -> x_max

5 全连接层和输出层

卷积和池化层后接全连接层，通过将提取到的特征进一步整合用于分类或预测。全连接层后可以根据任务需求添加不同的输出层：

对于分类任务，可以使用 Softmax 输出层。
对于回归任务（如时间序列预测），可以使用线性激活函数。

三、CNN 在时间序列中的典型应用场景

CNN 在时间序列中的应用广泛，包括但不限于以下场景：

时间序列分类：如识别行为模式（例如用户行为、心率信号等）。
时间序列预测：如股票价格、气象数据的预测。
异常检测：如检测系统或设备的异常波动。
时间序列分段：如将连续时间序列分割为不同的事件片段，适用于生物医学信号分析和视频分析。

四、 CNN 在时间序列中的常见模型

4.1 一维 CNN (1D-CNN)

一维 CNN 是最基础的时间序列卷积模型，用于处理单变量时间序列，输入的形状会变成 (batch_size, 1, sequence_length)。当1D-CNN处理多变量时，可以被看作是多通道 CNN（Multi-Channel CNN）。

4.2 多通道 CNN（Multi-Channel CNN）

多通道 CNN 用于多变量时间序列预测，是将多个不同类型的输入（通道）结合在一起进行卷积处理。例如预测股票价格时利用多个经济指标。每个变量可以视为一个通道（channel），即每个通道单独进行卷积操作，随后合并各通道的特征用于进一步分析。

import torch
import torch.nn as nn

class MultiChannelCNN(nn.Module):
    def __init__(self, input_channels, output_size, kernel_size=3, stride=1, padding=1):
        """
        :param input_channels: 输入通道数目
        :param output_size: 输出大小
        :param kernel_size: 卷积核的大小
        :param stride: 卷积步长
        :param padding: 卷积的填充
        """
        super(MultiChannelCNN, self).__init__()

        # 定义多个一维卷积层
        self.conv1 = nn.Conv1d(input_channels, 64, kernel_size, stride, padding)  # 第一个卷积层
        self.conv2 = nn.Conv1d(64, 128, kernel_size, stride, padding)  # 第二个卷积层
        self.conv3 = nn.Conv1d(128, 256, kernel_size, stride, padding)  # 第三个卷积层

        # 池化层
        self.pool = nn.MaxPool1d(2)  # 最大池化层，池化窗口大小为2

        # 全连接层，后续用来输出最终结果
        self.fc = nn.Linear(256 * 2, output_size)   #其中 256 来自最后一个卷积层的输出通道数
                                                    # 假设时间序列长度为8，池化后为2的长度

    def forward(self, x):
        """
        :param x: 输入数据，形状为(batch_size, input_channels, sequence_length)
        """
        # 通过第一个卷积层
        x = self.conv1(x)
        x = torch.relu(x)  # 激活函数
        x = self.pool(x)  # 池化层

        # 通过第二个卷积层
        x = self.conv2(x)
        x = torch.relu(x)
        x = self.pool(x)

        # 通过第三个卷积层
        x = self.conv3(x)
        x = torch.relu(x)
        x = self.pool(x)

        # 将输出展平，输入到全连接层
        x = x.view(x.size(0), -1)

        # 通过全连接层
        x = self.fc(x)

        return x

# 示例：假设输入是一个具有3个通道，序列长度为8的时间序列
input_channels = 3
sequence_length = 8
output_size = 1  # 预测一个标量值（例如回归任务）

# 创建模型
model = MultiChannelCNN(input_channels, output_size)

# 输入形状为(batch_size, input_channels, sequence_length)
input_data = torch.randn(batch_size, input_channels, sequence_length)

# 前向传播
output = model(input_data)
print(output)

4.3 混合模型：CNN-LSTM

CNN 和 LSTM 的混合模型利用 CNN 的局部特征提取能力和 LSTM 的长短期记忆能力，适合处理具有长时依赖特征的时间序列。典型架构是先用 CNN 提取局部特征，再将提取的特征输入 LSTM 进行全局特征建模。简化的架构图示例：

输入序列 (batch_size, sequence_length, input_size)
    |
    v
卷积层 (Conv1D) (batch_size, sequence_length, cnn_out_channels)
    |
    v
池化层 (Max Pooling) (batch_size, reduced_sequence_length, cnn_out_channels)
    |
    v
扩展卷积 (Dilated Conv) (batch_size, further_reduced_sequence_length, cnn_out_channels)
    |
    v
LSTM层 (batch_size, sequence_length, hidden_size)
    |
    v
全连接层 (Linear) (batch_size, output_size)
    |
    v
输出 (batch_size, output_size)

import torch
import torch.nn as nn

class CNN_LSTM_Net(nn.Module):
    """
    CNN提取局部特征后，通过LSTM进行时间序列建模。
    """
    def __init__(self, config):
        super(CNN_LSTM_Net, self).__init__()

        # 定义CNN部分
        # 卷积层，输入通道数为7，输出通道数为config.cnn_out_channels，卷积核大小为config.cnn_kernel_size，dilation=1 表示卷积核为常规卷积核，没有扩张效果。dilation > 1：表示扩展卷积（也叫膨胀卷积）
        # padding=1表示边缘填充，保证输出尺寸与输入相同
        self.conv1 = nn.Conv1d(in_channels=7, out_channels=config.cnn_out_channels, kernel_size=config.cnn_kernel_size, padding=1,dilation=1)
        self.conv2 = nn.Conv1d(in_channels=config.cnn_out_channels, out_channels=config.cnn_out_channels * 2, kernel_size=config.cnn_kernel_size, padding=1,dilation=1)

        # 池化层，用于减小特征维度
        self.pool = nn.MaxPool1d(kernel_size=2, stride=2)

        # 定义LSTM部分
        # LSTM层的输入是CNN提取的特征（shape: [batch_size, sequence_length, cnn_out_channels * 2]），
        # 隐藏单元大小为config.hidden_size，层数为config.model_layers，batch_first=True指定输入张量的第一个维度是批次大小
        self.lstm = nn.LSTM(input_size=config.cnn_out_channels * 2,
                            hidden_size=config.hidden_size,
                            num_layers=config.model_layers,
                            batch_first=True,
                            dropout=config.dropout_rate)

        # 定义全连接层
        # 全连接层将LSTM输出映射为目标输出，输出大小为config.output_size
        self.linear = nn.Linear(in_features=config.hidden_size, out_features=config.output_size)

    def forward(self, x, hidden=None):
        """
        前向传播
        :param x: 输入数据，形状为 [batch_size, sequence_length, input_size]
        :param hidden: LSTM的初始隐藏状态和细胞状态
        :return: 模型的输出
        """
        # CNN部分：使用卷积层提取特征
        x = x.permute(0, 2, 1)  # 将输入从 [batch_size, sequence_length, input_size] 转换为 [batch_size, input_size, sequence_length]
        x = self.pool(torch.relu(self.conv1(x)))  # 卷积 + ReLU激活 + 池化
        x = self.pool(torch.relu(self.conv2(x)))  # 卷积 + ReLU激活 + 池化

        # x的形状变为 [batch_size, cnn_out_channels * 2, new_sequence_length]
        # 在送入LSTM之前，需要将其变为 [batch_size, sequence_length, features]
        x = x.permute(0, 2, 1)  # 转换为 [batch_size, new_sequence_length, cnn_out_channels * 2]

        # LSTM部分：处理时间序列的长依赖
        lstm_out, hidden = self.lstm(x, hidden)

        # 提取LSTM的最后时间步的输出，输入到全连接层
        linear_out = self.linear(lstm_out[:, -1, :])

        return linear_out, hidden

对于之前的股票预测，这是CNN-LSTM的预测效果：