CNN、LSTM与CNN-LSTM时间序列预测对比实验

1. 时间序列预测模型对比实验概述

时间序列预测是数据分析领域的经典问题，从股票价格预测到电力负荷分析都离不开它。最近在折腾一个有趣的项目：用三种不同的神经网络模型（CNN、LSTM和它们的混合体CNN-LSTM）对同一组时间序列数据进行预测，并对比它们的表现差异。

这个实验最大的特点是"开箱即用"——你只需要准备一个包含时间序列数据的Excel文件，替换代码中的文件路径，就能直接运行完整的对比实验。所有模型都已经封装好，数据预处理、训练、评估的代码一气呵成，特别适合需要快速验证不同模型效果的场景。

提示：本文使用的环境是Python 3.8 + TensorFlow 2.6，建议使用Jupyter Notebook运行代码，方便分步调试和可视化。

2. 数据准备与预处理

2.1 数据加载与清洗

时间序列预测的第一步永远是数据准备。假设我们有一个Excel文件（data.xlsx），其中第一列是时间戳，第二列是我们需要预测的数值（比如每日销售额、温度值等）。用Pandas加载数据只需要三行代码：

python复制import pandas as pd

# 假设数值在第二列，跳过可能存在的表头
data = pd.read_excel('data.xlsx', usecols=[1], header=0)  
values = data.values.astype('float32')

# 检查是否有缺失值
print(f"原始数据包含 {values.shape[0]} 条记录")
print(f"缺失值数量: {np.isnan(values).sum()}")

这里有几个需要注意的细节：

1. usecols=[1]表示只读取第二列（Python从0开始计数）
2. header=0表示第一行是列名，需要跳过
3. 显式转换为float32类型可以减少内存占用并加速计算
4. 必须检查缺失值，时间序列数据不允许有NaN

2.2 构建时间窗口数据集

时间序列预测的标准做法是使用滑动窗口技术——用过去N天的数据预测下一天的值。这里我们设置窗口大小为30天：

python复制import numpy as np

def create_dataset(dataset, lookback=30):
    X, y = [], []
    for i in range(len(dataset)-lookback):
        X.append(dataset[i:(i+lookback), 0])  # 过去30天的数据
        y.append(dataset[i+lookback, 0])      # 第31天的值
    return np.array(X), np.array(y)

X, y = create_dataset(values)
print(f"X shape: {X.shape}, y shape: {y.shape}")

这个函数会生成一个形状为(样本数, 30)的特征矩阵X和对应的目标值y。例如，如果有1000天的数据，经过转换后会得到970个样本（1000-30）。

2.3 数据归一化与分割

神经网络对输入数据的尺度非常敏感，所以必须进行归一化：

python复制from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X = scaler.fit_transform(X)  # 归一化特征
y = scaler.transform(y.reshape(-1,1)).flatten()  # 归一化目标值

时间序列数据的拆分不能随机打乱，必须保持时间顺序：

python复制train_size = int(len(X)*0.8)
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

print(f"训练集: {X_train.shape[0]} 样本")
print(f"测试集: {X_test.shape[0]} 样本")

3. CNN模型实现与解析

3.1 一维卷积在时间序列中的应用

虽然CNN最常用于图像处理，但其核心思想——局部感受野和权值共享——同样适用于时间序列。一维卷积核沿着时间轴滑动，可以捕捉局部时间模式（如周期性波动）。

首先需要调整数据维度：

python复制X_train_cnn = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
X_test_cnn = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)
print(f"CNN输入维度: {X_train_cnn.shape}")

3.2 模型架构设计

python复制from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense

model_cnn = Sequential([
    Conv1D(64, 3, activation='relu', input_shape=(30, 1)),  # 64个3长度的卷积核
    MaxPooling1D(2),  # 池化窗口为2
    Flatten(),
    Dense(50, activation='relu'),
    Dense(1)  # 输出层
])

model_cnn.compile(optimizer='adam', loss='mae')
model_cnn.summary()

这个架构的设计考虑：

1. 第一层使用64个长度为3的卷积核，可以捕捉3天周期的局部模式
2. MaxPooling缩小特征维度，减少计算量
3. 两个全连接层实现从特征到预测值的非线性映射

3.3 训练与验证

python复制history_cnn = model_cnn.fit(
    X_train_cnn, y_train,
    epochs=50,
    batch_size=32,
    validation_split=0.1,
    shuffle=False  # 重要！时间序列不能打乱顺序
)

训练过程可视化：

python复制import matplotlib.pyplot as plt

plt.plot(history_cnn.history['loss'], label='训练损失')
plt.plot(history_cnn.history['val_loss'], label='验证损失')
plt.title('CNN模型训练过程')
plt.ylabel('MAE损失')
plt.xlabel('Epoch')
plt.legend()
plt.show()

4. LSTM模型实现与解析

4.1 LSTM网络原理

LSTM（长短期记忆网络）是RNN的变体，通过引入门控机制（输入门、遗忘门、输出门）解决传统RNN的梯度消失问题，特别适合处理长序列数据。

数据reshape与CNN类似：

python复制X_train_lstm = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
X_test_lstm = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)

4.2 模型架构设计

python复制from tensorflow.keras.layers import LSTM

model_lstm = Sequential([
    LSTM(64, return_sequences=True, input_shape=(30, 1)),  # 第一层LSTM返回完整序列
    LSTM(32),  # 第二层只返回最后时间步的输出
    Dense(1)
])

model_lstm.compile(optimizer='adam', loss='mae')
model_lstm.summary()

关键设计点：

1. 第一层LSTM设置return_sequences=True，将每个时间步的输出传递给下一层
2. 第二层LSTM自动获取前一层的序列输出
3. 堆叠LSTM层可以学习更复杂的时间模式

4.3 训练与验证

python复制history_lstm = model_lstm.fit(
    X_train_lstm, y_train,
    epochs=50,
    batch_size=32,
    validation_split=0.1,
    shuffle=False
)

训练过程可视化：

python复制plt.plot(history_lstm.history['loss'], label='训练损失')
plt.plot(history_lstm.history['val_loss'], label='验证损失')
plt.title('LSTM模型训练过程')
plt.ylabel('MAE损失')
plt.xlabel('Epoch')
plt.legend()
plt.show()

5. CNN-LSTM混合模型实现

5.1 混合模型设计思路

CNN-LSTM结合了两种网络的优点：

• CNN提取局部时间特征
• LSTM捕捉长期时间依赖

模型架构：

python复制model_mix = Sequential([
    Conv1D(64, 3, activation='relu', input_shape=(30, 1)),
    MaxPooling1D(2),  # 输出形状变为(None, 14, 64)
    LSTM(64, return_sequences=True),
    LSTM(32),
    Dense(1)
])

model_mix.compile(optimizer='adam', loss='mae')
model_mix.summary()

维度变化说明：

1. 输入：(batch, 30, 1)
2. 卷积后：(batch, 28, 64) → 因为卷积核大小为3，两端各损失1
3. 池化后：(batch, 14, 64) → 池化窗口为2，长度减半
4. 第一个LSTM层需要匹配输入维度(14, 64)

5.2 训练技巧

python复制history_mix = model_mix.fit(
    X_train_cnn, y_train,  # 使用与CNN相同的数据格式
    epochs=50,
    batch_size=32,
    validation_split=0.1,
    shuffle=False
)

注意：如果调整卷积参数导致输出长度变化，必须相应调整LSTM输入维度，否则会报错。

6. 模型对比与结果分析

6.1 评估函数实现

python复制def evaluate_model(model, X_test, y_test):
    y_pred = model.predict(X_test)
    y_pred = scaler.inverse_transform(y_pred)  # 反归一化
    y_true = scaler.inverse_transform(y_test.reshape(-1,1))
    
    mae = np.mean(np.abs(y_pred - y_true))
    mse = np.mean((y_pred - y_true)**2)
    
    plt.figure(figsize=(10,5))
    plt.plot(y_true, label='真实值')
    plt.plot(y_pred, label='预测值')
    plt.title(f'{model.name}预测效果')
    plt.legend()
    plt.show()
    
    return mae, mse

6.2 三个模型性能对比

python复制print("CNN模型评估:")
cnn_mae, cnn_mse = evaluate_model(model_cnn, X_test_cnn, y_test)

print("LSTM模型评估:")
lstm_mae, lstm_mse = evaluate_model(model_lstm, X_test_lstm, y_test)

print("CNN-LSTM模型评估:")
mix_mae, mix_mse = evaluate_model(model_mix, X_test_cnn, y_test)

典型结果对比（某股票价格数据集）：

6.3 结果分析与模型选择建议

1. 精度角度：CNN-LSTM > LSTM > CNN

   • 混合模型结合了CNN的局部特征提取和LSTM的时序建模能力
   • 对于复杂时间模式（如同时包含周期性和趋势），混合模型优势明显

2. 效率角度：CNN > LSTM > CNN-LSTM

   • CNN计算量最小，适合实时预测场景
   • LSTM需要更多参数和计算资源

3. 数据量考虑：

   • 小数据集(样本<1000)：优先尝试LSTM
   • 大数据集(样本>10000)：CNN-LSTM效果更好
   • 超长序列(时间步>100)：考虑更复杂的架构如Attention机制

7. 实战技巧与常见问题

7.1 数据准备常见陷阱

1. 时间对齐问题：

   • 确保时间戳等间隔（如每天同一时间）
   • 处理缺失日期：向前填充或插值

2. 数据泄露：

   • 归一化必须在拆分训练测试集之后分别进行
   • 禁止在整个数据集上fit_transform

3. 特征工程：

   • 尝试添加移动平均、差分等衍生特征
   • 对于多变量预测，扩展输入维度

7.2 模型调优技巧

1. 超参数搜索：

   python复制from tensorflow.keras.wrappers.scikit_learn import KerasRegressor
   from sklearn.model_selection import GridSearchCV
   
   def create_model(units=64, learning_rate=0.001):
       model = Sequential()
       model.add(LSTM(units=units, input_shape=(30,1)))
       model.add(Dense(1))
       model.compile(optimizer=Adam(learning_rate), loss='mae')
       return model
   
   param_grid = {
       'units': [32, 64, 128],
       'learning_rate': [0.001, 0.0005]
   }
   
   grid = GridSearchCV(KerasRegressor(create_model), param_grid, cv=3)
   grid.fit(X_train_lstm, y_train)
   

2. 早停与正则化：

   python复制from tensorflow.keras.callbacks import EarlyStopping
   
   early_stop = EarlyStopping(monitor='val_loss', patience=10)
   model.fit(..., callbacks=[early_stop])
   

7.3 部署优化建议

1. 模型量化：

   python复制converter = tf.lite.TFLiteConverter.from_keras_model(model)
   tflite_model = converter.convert()
   open("model.tflite", "wb").write(tflite_model)
   

2. API封装：

   python复制from flask import Flask, request, jsonify
   app = Flask(__name__)
   
   @app.route('/predict', methods=['POST'])
   def predict():
       data = request.json['data']
       # 预处理...
       prediction = model.predict(data)
       return jsonify({'prediction': prediction.tolist()})
   

在实际项目中，我通常会先快速跑通CNN基线模型，然后用LSTM验证时序建模的必要性，最后尝试CNN-LSTM追求最佳性能。记得保存每个模型的训练日志和预测结果，方便后续分析比较。