CNN-GRU时序回归预测与SHAP可解释性分析实战指南

很多做时序回归预测的读者，最早都是从 LSTM 入门的。LSTM 确实能捕捉长期依赖，但训练慢、调参麻烦，而且对局部特征不敏感。后来大家开始尝试 CNN-LSTM，把卷积层当作“特征提取器”，再用 LSTM 做时序建模，效果确实比单纯堆 LSTM 好。再往后，GRU 因为参数量更少、训练更快，开始被大量用在 CNN 之后的位置上。于是“CNN-GRU”这个组合逐渐成了一类在工业数据、气象预报、电力负荷、故障诊断等领域非常常见的回归预测架构。

但我发现一个很奇怪的现象：网上关于 CNN-GRU 的代码很多，多数却停留在“能跑”的阶段。数据集怎么构造、窗口怎么滑、卷积核与时间步对齐怎么做、SHAP 怎么不报错，这些真正决定你是否能应用到实际项目里的细节，很少有人讲清楚。

这篇文章准备把“从零实现 CNN-GRU 回归预测 + SHAP 可解释性分析”完整拆开讲一遍。文章会做成可直接复制的代码教程，同时把容易踩的坑提前标出来。如果你正在做时间序列预测，或者需要给领导、客户解释“模型到底学到了什么”，这篇文章应该能帮你省下不少折腾时间。

1. 这篇文章真正要解决的问题

先明确一个判断：CNN-GRU 不是一个“先进到只有论文里才能碰”的模型，它更像一个在工程上比较稳的时序特征提取组合。CNN 负责抓局部模式，GRU 负责抓时间顺序依赖，两个网络串起来，最后用全连接层输出预测值。

这篇文章要解决的是四个层面的问题：

第一，理解。很多人把 CNN-GRU 当成黑盒网络，照抄代码却不知道每一层的输入输出维度是怎么流转的。文章会先带你把模型结构从前往后梳理一遍，保证你看完能自己构建网络。

第二，数据准备。回归预测不是把原始序列直接丢进模型那么简单，它需要构造“滑窗样本”。窗口多大、预测步长是多少、训练集和测试集怎么切分，这些都会影响最终结果。

第三，代码实现。文中会给出一个基于 PyTorch 的完整工程示例，包含数据生成、模型定义、训练验证、指标评估，以及 SHAP 值分析的完整代码。不是只贴模型类，而是从 import 到最终输出都能跑通。

第四，解释性分析。SHAP 不是跑一下就能出图的“魔法”。它需要配合 PyTorch 模型做一些兼容处理，而且输入数据的维度经常被搞错。这篇文章会重点讲清楚 SHAP 的样本背景怎么选、维度怎么校验、结果怎么解释。

所以，这篇文章适合三类读者：

• 需要做回归预测但不想从零搭 Transformer 的开发者。
• 已经尝试过 LSTM 或 CNN-LSTM，想换成 CNN-GRU 或对比效果的研究人员。
• 模型做好了，但需要向业务方解释“哪些特征在影响预测结果”的工程师。

如果你只是需要一个“跑得起来”的模型，那你复制代码可能就够了。但如果你想真的掌握这套模型、能调试、能改结构、能放到新数据集上，那建议把原理部分认真看一遍。

2. CNN-GRU 的核心概念与适用场景

2.1 CNN 在时序预测里到底做了什么事

很多人刚接触时容易困惑：CNN 不是做图像的吗？它为什么可以处理时间序列？

因为时间序列可以看作一个“一维图像”。图像是二维数据，有高度和宽度；时间序列是一维数据，有顺序位置。一维卷积（Conv1d）可以沿着时间方向滑动，把相邻几个时间点的值进行加权组合。

这样做有一个好处：它能提取局部趋势模式。比如某个传感器数值在连续三个周期内持续上升，这种“局部上升模式”会被卷积核捕捉到。原始序列中的短期波动、尖峰、拐点，经过卷积之后会变成更紧凑的特征表示。

从工程经验看，CNN 部分对特征维度和窗口大小比较敏感。如果你的预测目标是气象温度，那窗口大小取 12 小时、24 小时可能效果不同；如果是股票日线数据，窗口太短抓不到周期，窗口太长卷积层参数量会上升。这些需要实验来定，但先要知道“CNN 在帮你抓什么”。

2.2 GRU 在模型里的真实作用

GRU（Gated Recurrent Unit）是 LSTM 的简化变体。它把 LSTM 的遗忘门和输入门合并成一个更新门，同时用重置门控制历史信息的保留程度。效果上，GRU 的长期依赖能力略逊于 LSTM，但参数更少、训练更快，在很多中等规模数据集上表现并不差。

在 CNN-GRU 中，GRU 的输入是 CNN 输出的特征序列。CNN 把每个时间窗口内的局部信息提炼出来，GRU 再沿着时间方向去学习“这些局部特征之间谁先谁后、如何变化”。可以这样理解：CNN 是“看局部亮点的人”，GRU 是“根据看过的片段回忆并推演剧情的人”。

这样说可能更好理解：如果你直接对原始序列做 GRU，GRU 需要自己从原始数值中提取特征，这通常需要更多隐藏单元；如果先用 CNN 压缩特征，GRU 就能更集中地学习时间依赖，训练效率通常更高。

2.3 LSTM vs GRU：为什么项目里更推荐 GRU

这里不是要说 LSTM 不好。如果序列特别长、场景特别复杂，LSTM 的状态记忆能力可能更可靠。但回到回归预测这个目标上，大多数场景数据量有限，GRU 更轻量，和 CNN 组合后整体更可控。

3. 环境准备与前置条件

这次演示使用 PyTorch 作为深度学习框架，原因很简单：SHAP 对 PyTorch 和 TensorFlow 都有支持，但 PyTorch 的模型结构更直观，调试起来方便。

3.1 运行环境

本文示例基于以下环境，版本请以实际项目为准：

• Python 3.9 以上
• PyTorch 2.x 或兼容版本
• NumPy
• Pandas
• scikit-learn
• matplotlib
• shap

如果没有安装，可以直接执行：

pip install torch numpy pandas scikit-learn matplotlib shap

3.2 硬件说明

CNN-GRU 的参数量不算大，CPU 也能跑通小规模训练。但如果数据量达到几万条以上、特征维度较高，建议使用支持 CUDA 的环境。代码中会加入torch.device("cuda" if torch.cuda.is_available() else "cpu")，自动选择设备。

3.3 关于数据集的说明

因为这篇文章重点在“代码流程 + 原理理解”，所以示例使用一段模拟生成的多变量时间序列数据。这样你可以先完整跑通整个流程，再替换成自己的数据集。

模拟数据会让实验完全可复现，也方便理解“特征”和“目标值”之间的关系。

4. 数据准备与滑窗构造

4.1 时间序列回归预测的核心套路

时间序列回归预测的正确做法不是“用前一半预测后一半”，而是“用过去一段时间的数据，预测未来一个或多个时刻的值”。

假设我们有一个长度为 1000 的序列，输入窗口大小为 24，预测未来 1 个值。那么：

• 第 1 到第 24 个数据作为特征，第 25 个数据作为标签。
• 第 2 到第 25 个数据作为特征，第 26 个数据作为标签。
• 以此类推。

这个“滑动窗口”操作是整个回归预测流程的地基。窗口大小选择直接取决于业务需求：你做天气预测，可能用过去 24 小时预测下一个小时；你做工业设备故障预测，可能用过去 100 个时间戳判断未来是否达到阈值。

4.2 标准化里的坑：先切分再 fit

这里真正容易踩坑的地方是标准化。

很多新手会把所有数据合并成一个数组，然后对整个数组做StandardScaler().fit_transform()，再切训练集和测试集。这种做法在信息泄露层面上是有问题的，因为测试集的信息已经被用到了训练过程中。实际上，应该先切分原始序列，再在训练集上fit，之后对训练集、验证集、测试集分别做transform。

示例代码里会演示正确做法。

4.3 滑窗数据生成代码

下面给出一个通用的滑窗函数，输入是二维特征矩阵（样本数，特征数），输出是模型输入形状(样本数，窗口大小，特征数)和标签数组。

import numpy as np def create_sequences(data, target, window_size, forecast_horizon=1): """ 构造滑窗样本。 参数： data: 2D 数组，形状为 (时间步数, 特征数) target: 1D 数组，形状为 (时间步数,) window_size: 输入窗口长度 forecast_horizon: 预测未来多少个时刻 返回： X: 3D 数组，形状为 (样本数, window_size, 特征数) y: 2D 数组，形状为 (样本数, forecast_horizon) """ X, y = [], [] for i in range(len(data) - window_size - forecast_horizon + 1): X.append(data[i : i + window_size]) y.append(target[i + window_size : i + window_size + forecast_horizon]) return np.array(X), np.array(y)

这一步的关键是循环截止条件。如果forecast_horizon大于 1，标签就是一段连续的目标值。

4.4 模拟数据集代码

为了演示，我们构造一个包含周期项、趋势项和噪声的多变量序列。

import numpy as np np.random.seed(42) # 生成长度为 2000 的模拟数据 time_steps = 2000 t = np.arange(time_steps) # 三个特征：正弦波 + 趋势 + 噪声 feature1 = 3 * np.sin(2 * np.pi * t / 50) + 0.5 * t / 100 feature2 = 2 * np.cos(2 * np.pi * t / 30) + np.random.normal(0, 0.3, time_steps) feature3 = np.random.normal(0, 1, time_steps) # 目标值：由特征1和特征2的延迟组合构成，模拟实际场景中的非线性关系 target = 2 * feature1 + 1.5 * feature2 + np.random.normal(0, 0.5, time_steps) # 特征矩阵 data = np.column_stack([feature1, feature2, feature3])

这里的目标值不是凭空生成，而是由特征1和特征2线性组合后加噪声。这样做的好处是，之后用 SHAP 分析时，你心里已经有“哪些特征重要”的预期，可以校验 SHAP 的结果是否合理。

4.5 划分训练集、验证集、测试集

按时间顺序划分，不能随机打乱。

from sklearn.preprocessing import StandardScaler # 先按时间顺序切分原始数据，比例 7:2:1 train_len = int(len(data) * 0.7) val_len = int(len(data) * 0.2) test_len = len(data) - train_len - val_len train_data = data[:train_len] val_data = data[train_len:train_len + val_len] test_data = data[train_len + val_len:] train_target = target[:train_len] val_target = target[train_len:train_len + val_len] test_target = target[train_len + val_len:] # 标准化：只 fit 训练集 scaler = StandardScaler() train_data_scaled = scaler.fit_transform(train_data) val_data_scaled = scaler.transform(val_data) test_data_scaled = scaler.transform(test_data) # 目标值也可以做标准化，但要单独一个 scaler target_scaler = StandardScaler() train_target_scaled = target_scaler.fit_transform(train_target.reshape(-1, 1)).ravel() val_target_scaled = target_scaler.transform(val_target.reshape(-1, 1)).ravel() test_target_scaled = target_scaler.transform(test_target.reshape(-1, 1)).ravel()

这里提醒一下：训练集、验证集、测试集三者的切分比例不是固定不变的，但顺序切分是基本原则。如果数据有明显的时间规律，随机打乱会让模型“偷看未来”，导致验证集指标虚高。

4.6 用滑窗函数生成模型输入

window_size = 24 forecast_horizon = 1 X_train, y_train = create_sequences(train_data_scaled, train_target_scaled, window_size, forecast_horizon) X_val, y_val = create_sequences(val_data_scaled, val_target_scaled, window_size, forecast_horizon) X_test, y_test = create_sequences(test_data_scaled, test_target_scaled, window_size, forecast_horizon) print("X_train shape:", X_train.shape) print("y_train shape:", y_train.shape) print("X_val shape:", X_val.shape) print("X_test shape:", X_test.shape)

预期输出：

X_train shape: (1376, 24, 3) y_train shape: (1376, 1) X_val shape: (376, 24, 3) y_val shape: (376, 1) X_test shape: (176, 24, 3) y_test shape: (176, 1)

到这个阶段，我们已经有了模型可以消费的数据。注意维度关系：(样本数, 24, 3)，24 是窗口大小，3 是特征数量。CNN 卷积时，会把“24”当作序列长度方向，“3”当作通道方向。

5. CNN-GRU 模型完整实现

5.1 网络结构设计

CNN-GRU 的经典结构如下：

输入 (batch_size, window_size, num_features) -> Conv1d (kernel_size=3, padding=1) -> ReLU -> Conv1d (kernel_size=3, padding=1) -> ReLU -> GRU (hidden_size=64, num_layers=2) -> 取 GRU 最后一个时间步的隐藏状态 -> 全连接层 -> 输出 (batch_size, forecast_horizon)

需要注意，PyTorch 的 Conv1d 输入格式是(batch_size, channels, length)，而滑窗函数构造出的形状是(batch_size, length, channels)。因此，在送入卷积层之前要做一个维度置换，把时间序列长度放到最后一位。

5.2 定义 CNN-GRU 模型

import torch import torch.nn as nn class CNNGRU(nn.Module): def __init__(self, num_features, hidden_size=64, num_layers=2, output_size=1, kernel_size=3): super(CNNGRU, self).__init__() # CNN 部分：一维卷积提取局部特征 self.conv1 = nn.Conv1d(in_channels=num_features, out_channels=32, kernel_size=kernel_size, padding=kernel_size // 2) self.conv2 = nn.Conv1d(in_channels=32, out_channels=64, kernel_size=kernel_size, padding=kernel_size // 2) self.relu = nn.ReLU() # GRU 部分：学习时间依赖 self.gru = nn.GRU(input_size=64, hidden_size=hidden_size, num_layers=num_layers, batch_first=True) # 输出层：将 GRU 的最后一个隐藏状态映射到预测值 self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): # x 形状: (batch_size, sequence_length, num_features) # 转换为 Conv1d 需要的形状: (batch_size, num_features, sequence_length) x = x.permute(0, 2, 1) # 卷积提取局部特征 x = self.relu(self.conv1(x)) x = self.relu(self.conv2(x)) # 转换回序列格式，送入 GRU # 卷积输出形状: (batch_size, out_channels, sequence_length) # 转回 (batch_size, sequence_length, out_channels) x = x.permute(0, 2, 1) # GRU 前向传播 gru_out, hidden = self.gru(x) # 取最后一个时间步的输出 out = gru_out[:, -1, :] # 或者用 hidden[-1] 也可以 # out = hidden[-1] out = self.fc(out) return out

这段代码里有几个关键点需要单独说明。

第一，padding=kernel_size // 2的目的是保持卷积前后的序列长度不变。如果窗口大小是 24，kernel_size 是 3，padding 是 1，卷积后长度依然是 24，这样不会因为多次卷积导致时间维度缩短。

第二，batch_first=True让 GRU 的输入输出都保持(batch_size, sequence_length, hidden_size)的格式，方便直接取gru_out[:, -1, :]。

第三，第二个卷积层的输出通道是 64，它正好作为 GRU 每个时间步的输入维度。这里如果修改中间通道数，GRU 的input_size也要跟着改，否则会报维度不匹配。

5.3 训练代码

训练流程包括：定义模型、定义损失函数、定义优化器、训练循环、验证循环、早停与模型保存。

import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset # 转为 PyTorch Tensor X_train_t = torch.tensor(X_train, dtype=torch.float32) y_train_t = torch.tensor(y_train, dtype=torch.float32) X_val_t = torch.tensor(X_val, dtype=torch.float32) y_val_t = torch.tensor(y_val, dtype=torch.float32) X_test_t = torch.tensor(X_test, dtype=torch.float32) y_test_t = torch.tensor(y_test, dtype=torch.float32) # 构建 DataLoader batch_size = 64 train_dataset = TensorDataset(X_train_t, y_train_t) val_dataset = TensorDataset(X_val_t, y_val_t) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False) # 模型与训练配置 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = CNNGRU(num_features=X_train.shape[2], hidden_size=64, num_layers=2, output_size=1) model.to(device) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=0.001) num_epochs = 80 best_val_loss = float("inf") patience = 10 trigger_times = 0 best_model_path = "best_cnn_gru.pth" for epoch in range(num_epochs): model.train() train_loss = 0.0 for batch_X, batch_y in train_loader: batch_X = batch_X.to(device) batch_y = batch_y.to(device) optimizer.zero_grad() outputs = model(batch_X) loss = criterion(outputs, batch_y) loss.backward() optimizer.step() train_loss += loss.item() * batch_X.size(0) train_loss = train_loss / len(train_dataset) # 验证 model.eval() val_loss = 0.0 with torch.no_grad(): for batch_X, batch_y in val_loader: batch_X = batch_X.to(device) batch_y = batch_y.to(device) outputs = model(batch_X) loss = criterion(outputs, batch_y) val_loss += loss.item() * batch_X.size(0) val_loss = val_loss / len(val_dataset) if (epoch + 1) % 10 == 0: print(f"Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.6f}, Val Loss: {val_loss:.6f}") # 早停与模型保存 if val_loss < best_val_loss: best_val_loss = val_loss trigger_times = 0 torch.save(model.state_dict(), best_model_path) else: trigger_times += 1 if trigger_times >= patience: print(f"Early stopping at epoch {epoch + 1}") break print("Training finished.")

训练时需要注意，shuffle=True能让训练集每个 batch 不连续，有助于模型稳定收敛。验证集不需要 shuffle，因为验证只是为了评估当前模型表现。

5.4 加载最优模型并预测

model.load_state_dict(torch.load(best_model_path, map_location=device)) model.eval() with torch.no_grad(): y_pred_test_scaled = model(X_test_t.to(device)).cpu().numpy() # 反标准化，恢复真实量纲 y_pred_test = target_scaler.inverse_transform(y_pred_test_scaled) y_test_original = target_scaler.inverse_transform(y_test) print("Prediction shape:", y_pred_test.shape) print("True shape:", y_test_original.shape)

反标准化是一个经常被遗忘的步骤。如果目标值在训练前做了标准化，模型输出也是标准化后的值，必须用target_scaler.inverse_transform才能还原到原始量纲，否则画图、计算业务指标时都会失真。

6. 模型评估与可视化

6.1 回归指标计算

只看 loss 数值不够直观，建议计算 MAE、RMSE、R2 三个指标。

from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score mae = mean_absolute_error(y_test_original, y_pred_test) rmse = np.sqrt(mean_squared_error(y_test_original, y_pred_test)) r2 = r2_score(y_test_original, y_pred_test) print(f"MAE: {mae:.4f}") print(f"RMSE: {rmse:.4f}") print(f"R2: {r2:.4f}")

R2 越接近 1，说明模型的解释能力越强。如果 R2 为负数，说明模型比直接取平均值还差，一般意味着数据切分、特征构造或模型结构存在问题。

6.2 预测结果可视化

import matplotlib.pyplot as plt plt.figure(figsize=(12, 5)) plt.plot(y_test_original, label="True", color="blue", alpha=0.7) plt.plot(y_pred_test, label="Predicted", color="red", alpha=0.8) plt.legend() plt.title("CNN-GRU Regression Prediction Result") plt.xlabel("Sample Index") plt.ylabel("Target Value") plt.grid(True) plt.show()

6.3 残差分析

一个浅显但实用的判断方式是：如果预测值在真值附近均匀波动，说明模型学到了主要规律；如果残差呈现出某种规律性，比如持续偏高或持续偏低，说明可能存在滞后或特征缺失。

常用的残差分析是看残差分布：

residuals = y_test_original.ravel() - y_pred_test.ravel() plt.figure(figsize=(10, 4)) plt.hist(residuals, bins=50, color="purple", alpha=0.7) plt.title("Residuals Distribution") plt.xlabel("Residual") plt.ylabel("Frequency") plt.grid(True) plt.show()

7. SHAP 值分析：解释模型预测

7.1 为什么需要 SHAP

CNN-GRU 是黑盒模型，它预测得很准，但你很难说清楚“为什么这个样本预测值是 10 而不是 12”。业务方关心这个问题，团队复盘也需要这个问题。

SHAP（SHapley Additive exPlanations）基于博弈论中的 Shapley 值，可以计算每个输入特征对模型输出的贡献值。在时序模型中，每个样本是一个(window_size, num_features)的矩阵，因此 SHAP 可以算出“某个时间步的某个特征”对预测的贡献。

但如果这样输出，维度会非常多，解释起来也很复杂。常见做法是对时间步维度做聚合，得到“每个原始特征总体有多重要”。

7.2 DeepExplainer 的基本用法

PyTorch 模型一般用shap.DeepExplainer。

import shap import numpy as np import torch # 重新加载最优模型 model.load_state_dict(torch.load(best_model_path, map_location=device)) model.eval() # 背景样本：从训练集中抽取一部分代表性样本 background_size = 100 background_indices = np.random.choice(len(X_train), background_size, replace=False) background = torch.tensor(X_train[background_indices], dtype=torch.float32).to(device) # 要解释的测试样本 explain_size = 50 explain_indices = np.random.choice(len(X_test), explain_size, replace=False) explain_data = torch.tensor(X_test[explain_indices], dtype=torch.float32).to(device) # 创建 DeepExplainer explainer = shap.DeepExplainer(model, background) # 计算 SHAP 值 shap_values = explainer.shap_values(explain_data)

这一步最容易出的问题有两个。

第一个问题是DeepExplainer不支持模型输出前有某些不支持梯度传播的层。这里说的“不支持”，包括对模型内部使用了detach()、某些自定义层没有实现梯度、或者模型用了torch.no_grad()包住前向计算。简单来说，DeepExplainer需要模型能够从输入到输出完整走一遍反向传播。

第二个问题是输入数据必须是torch.Tensor且要放到 GPU 或 CPU 的正确设备上。如果模型在 GPU，背景样本也在 GPU；如果模型在 CPU，背景样本也要在 CPU。这个不匹配会让 SHAP 直接报错。

7.3 SHAP 值输出与可视化

大多数情况下，我们更关心“每个特征的平均绝对贡献”。

shap_values_array = np.array(shap_values) # 如果 shap_values 是列表，取第一个 if isinstance(shap_values, list): shap_values = shap_values[0] # shap_values 形状: (样本数, 窗口大小, 特征数) print("SHAP values shape:", shap_values.shape) # 对样本和时间步两个维度取平均绝对值的和，得到每个特征的重要性 mean_abs_shap = np.mean(np.abs(shap_values), axis=(0, 1)) feature_names = ["feature1", "feature2", "feature3"] for name, importance in zip(feature_names, mean_abs_shap): print(f"{name}: {importance:.6f}")

如果要画全局重要性柱状图：

plt.figure(figsize=(8, 5)) plt.barh(feature_names, mean_abs_shap, color="steelblue") plt.xlabel("Mean |SHAP|") plt.title("SHAP Feature Importance (CNN-GRU)") plt.gca().invert_yaxis() plt.show()

如果要画单个样本的特征贡献细节，可以用shap.summary_plot：

shap.summary_plot(shap_values[0], X_test[explain_indices], feature_names=feature_names)

注意，这里传入的X_test[explain_indices]是原始的数值，不是 Tensor。summary_plot主要是人类可读的可视化，不会影响计算本身。

7.4 SHAP 结果怎么解读

在本文构造的数据里，目标值由 feature1 和 feature2 组合生成，feature3 是纯噪声。理论上，SHAP 计算出的 feature1 和 feature2 的重要性应该明显高于 feature3。如果结果显示 feature3 也很重要，那可能存在几种情况：

• 模型过拟合了训练集的噪声。
• CNN-GRU 在特征提取过程中放大了无用特征。
• 数据量太少，模型没有学到正确的因果关系。

这个“预期校验”非常有用。在实际项目中，你可以把 SHAP 结果交给业务专家来判断“模型学到的规律是否符合业务常识”。如果关键特征的重要性排序和业务认知相差太远，宁可回去调特征工程，也不要直接上线。

8. 常见问题与排查思路

从实际跑代码的经验来看，以下问题出现频率比较高。

9. 最佳实践与工程建议

9.1 数据层面

时间序列预测里，“数据切分”是首要原则，一定要按时间顺序划分。某些场景下数据存在多个批次或不同传感器，还需要考虑是否按批次切分，避免同一个批次的数据同时出现在训练集和测试集里。

数据标准化时，只能对训练集 fit。如果你有多组时间序列，尽量每组单独做标准化再合并，或者做 group-based 的切分，不做全局 scale。

9.2 模型结构层面

CNN 部分的卷积核大小不要一开始就设得很大。默认kernel_size=3已经能覆盖常见的局部模式。如果窗口特别长，比如 96 或者 128，可以考虑使用两层卷积，或者增加第一层卷积的输出通道数。

GRU 的隐藏层大小、层数、dropout 都需要实验。num_layers=2通常是一个合适的起点，再深容易过拟合。对于小数据集，GRU 的hidden_size一般不需要超过 128。

9.3 训练策略层面

早停法（early stopping）在回归预测里很实用。保存验证集 loss 最低的模型，而不是训练到最后一步的模型，能降低过拟合风险。

学习率调度也可以加入训练流程，比如在验证 loss 连续几个 epoch 不下降时降低学习率。在 PyTorch 中可以用torch.optim.lr_scheduler.ReduceLROnPlateau。

9.4 SHAP 使用层面

SHAP 分析很适合解释模型，但它在训练数据量大时很耗费资源。工程上可以先抽几百个样本来解释，不需要全量计算。

另外，SHAP 给出的是“这个模型对这个样本为什么给出这个预测”的归因，未必等于因果。也就是说，如果模型本身有问题，SHAP 只是放大了模型的问题。所以 SHAP 一定要结合业务经验来参考。

9.5 生产环境注意事项

如果要上线，建议把模型的输入标准化参数、窗口大小、预测步长都固定下来，最好保存为一个配置文件。否则线上请求的输入格式和训练时不匹配，预测结果会毫无意义。

模型文件也需要配套记录特征列表、标准化器、模型结构超参数。建议保存为一个.pth文件加一个 JSON 配置文件。不要只在代码里写死参数，否则换人维护时会非常痛苦。

10. 总结

这篇文章从回归预测的实际痛点出发，把 CNN-GRU 的数据滑窗构造、模型定义、训练流程、回归评估以及 SHAP 可解释性分析完整串了一遍。核心要点可以概括为几条：

• CNN-GRU 的输入维度流转要理清，重点理解(batch, window, features)与 Conv1d 所需格式的区别。
• 滑窗函数是回归预测的地基，窗口大小、预测步长、数据切分方式都要在动手写模型前定好。
• 标准化必须在训练集上 fit，再 apply 到验证集和测试集。
• 训练完成后要关注 MAE、RMSE、R2，而不是只盯着 loss。
• SHAP 能帮助解释模型预测依据，但要注意背景样本选择、设备一致性和输出维度处理。

如果你刚接触这个领域，建议先运行一遍模拟数据，把每一行代码的注释读一遍，再替换成自己的数据。如果你已经在做其他时序模型，可以把 CNN-GRU 和 LSTM、Transformer 放在同一套数据上对比，用 R2 和训练时间来判断哪个更适合你的业务。

下一步可以往两个方向深入：一是引入注意力机制，让 CNN-GRU 在解码时能自动关注更重要的时间步；二是尝试多步预测，把forecast_horizon调大到 5 或 20，对比不同预测步长下的误差变化规律。希望这篇教程能帮你少走弯路，也欢迎收藏备用。