AGDO优化CNN-LSTM的多变量时序预测实验指南

多变量时序预测的实际难度，往往不在模型代码本身，而在于超参数选择。CNN-LSTM 是处理负荷、气象、交通等序列数据的常见结构，它先由卷积层提取局部特征，再由 LSTM 捕捉时间依赖，但在不同数据集上，卷积核数、LSTM 单元数、学习率和 dropout 的取值差异会明显影响最终结果。2025 年 Nature 子刊相关论文提出的 AGDO 算法，为该问题提供了超参数优化的新思路。本文将以电力负荷多变量预测为例，设计 LSTM、CNN-LSTM、AGDO-LSTM、AGDO-CNN-LSTM 四模型对比实验，重点说明 AGDO 如何接入 CNN-LSTM 模型、如何构造数据、如何评估，以及哪些坑容易导致指标失真。

这篇文章面向已经能独立训练一个 LSTM 或 CNN 模型、但想做更规范实验的开发者。读完以后，你可以得到一套可直接复用的实验框架：多变量时序数据怎么转成监督学习样本，CNN-LSTM 最小结构怎么搭，AGDO 作为超参数搜索器怎么和目标函数结合，四模型怎么对比才有说服力。

1. 先理解多变量时序预测为什么需要 AGDO 这类超参数优化

1.1 多变量时序预测的核心难点不是写模型，而是找超参数

单变量预测只需要关注目标序列自身的历史值，多变量预测则要同时处理多个特征，例如历史负荷、温度、湿度、风速、星期类型、节假日标记等。每个特征不仅有自己的时间依赖，特征之间还存在交叉影响。模型要学到的不再是“上一小时负荷高，下一小时通常也高”这种简单规律，而是“温度升高、湿度下降、同时处于工作日高峰时段，负荷会上升”这类复杂映射。

CNN-LSTM 正好适合这种场景。CNN 的一维卷积可以提取局部特征，比如最近 6 小时温度变化趋势、当前时刻前后的负荷形态；LSTM 再把这些局部特征按时间顺序组织起来，学习长周期依赖。结构上这个组合是合理的，但问题在于参数非常多：卷积核数量、卷积核大小、LSTM 单元数、层数、dropout 比例、学习率、批大小，每一项都可能让模型指标发生明显变化。手工调参只能覆盖很小一部分组合，网格搜索又面临组合爆炸，随机搜索则不稳定。

1.2 AGDO 在预测项目中的定位：超参数搜索器

AGDO 是 2025 年 Nature 子刊相关论文中出现的一种优化算法简称。因为不同论文或工程实现里对这个缩写的展开方式并不完全一致，本文不假设原始公式细节，只把它当作一种基于差分变异与高斯扰动的群体搜索算法来使用。具体更新公式请以你参考的论文版本为准。

在预测项目里，AGDO 发挥作用的位置很明确：在固定模型结构的前提下，把超参数组合当作待优化的解，把“验证集上的损失”当作适应度函数，通过若干轮迭代找到一组较优超参数。这和使用遗传算法、粒子群算法做超参搜索的思路类似，但 AGDO 的特点是更新算子中同时包含差分进化的变异机制和高斯随机扰动，理论上能兼顾全局探索与局部精细搜索。

为什么需要这种搜索器？因为 CNN-LSTM 的训练不是一次性的。如果每次都用完整数据训练到收敛，单独评估一组超参数就要几十分钟。AGDO 的价值是，在比较小的验证集上先用少量 epoch 快速筛选超参数，等找到有潜力的组合后，再用完整训练集训练最终模型。这是超参数搜索工程落地的一般策略，不是论文理论本身。

2. 四模型对比方案与整体实验设计

2.1 四个模型分别回答什么问题

单跑一个 AGDO-CNN-LSTM 是无法证明优化效果的。把实验拆成四个模型，目的是把“卷积结构带来的提升”和“AGDO 优化带来的提升”分开看。

这个设计比直接拿 AGDO-CNN-LSTM 和 LSTM 对比更严谨。因为如果只对比这两个模型，即使 AGDO-CNN-LSTM 指标好，你无法判断提升来自“CNN 结构”还是“AGDO 优化”。加入 AGDO-LSTM 后，就能看到 AGDO 在纯 LSTM 上是否同样有效；加入固定超参数的 CNN-LSTM 后，也能看到结构本身带来的增益。

2.2 评价指标和实验口径

时序预测最常用的回归指标是 MAE、RMSE、MAPE 和 R2。

MAE 衡量平均绝对误差，单位与原始数据一致，适合日常业务汇报。RMSE 对较大误差更敏感，能暴露个别异常时段的预测偏差。MAPE 是百分比误差，适合不同量纲数据之间的横向比较，但要注意当真实值接近 0 时会异常放大。R2 表达模型相对“直接用均值预测”的解释程度，越接近 1 越好。

实验口径必须提前固定。所有模型使用同一份训练集、验证集和测试集，随机种子统一设置，训练轮数可以不同，但测试集不能参与任何超参数选择。否则实验结果会虚高，这也是这类对比实验最常见的争议点。

2.3 实验环境与依赖

本文示例代码使用 Python 和 PyTorch。如果你已有可用的 Python 3.9 以上环境，安装以下依赖即可。

pip install numpy pandas torch scikit-learn matplotlib

依赖版本不需要追求最新。只要 torch 版本在 1.13 以上，本示例中的模型定义和训练流程都能正常运行。如果使用 GPU，需要额外安装对应 CUDA 版本的 PyTorch；如果只有 CPU，也可以跑通，只是 AGDO 的搜索轮次要适当减少。

实验目录建议保持清晰：

agdo_cnn_lstm/ ├── data/ │ └── load_data.csv ├── src/ │ ├── data_loader.py │ ├── models.py │ ├── agdo.py │ ├── train.py │ └── evaluate.py └── config.py

data_loader.py负责数据读取和样本构建，models.py定义 LSTM 和 CNN-LSTM，agdo.py实现超参数搜索器，train.py组织训练流程，evaluate.py完成最终指标计算。

3. 数据准备：从原始表到监督学习样本

3.1 多变量特征设计

以下示例以电力负荷预测为场景。假设原始 CSV 文件包含以下列：

• time：时间戳，按小时记录
• load：电力负荷，预测目标
• temp：温度
• humidity：湿度
• wind_speed：风速
• weekday：星期几，0 到 6
• holiday：是否节假日，1 或 0

实际项目中，特征还可以加上历史同周期均值、滚动均值、差分序列、节假日前后标记等。原则是：特征必须能反映目标变量的驱动因素，并且在使用时不能引入未来信息。

3.2 归一化、时间窗口和划分方法

归一化是必须的。CNN 的卷积核和 LSTM 的激活函数都对特征尺度敏感，如果温度是 30 度、负荷是 5000 千瓦，数值较大的特征会主导梯度。这里使用MinMaxScaler把特征映射到 0 到 1。

有一点要特别注意：MinMaxScaler只能在训练集上fit，再用相同的缩放参数转换验证集和测试集。直接在全部数据上fit再划分，等于把测试集信息泄漏进了训练过程，验证指标会偏低，但真实场景中没有这么乐观。

时间窗口是构建监督样本的核心参数。本文示例使用lookback=24，表示用最近 24 小时的特征预测下一小时负荷；horizon=1表示预测步长是 1 小时。窗口越大，模型能看到的历史越长，但样本数量会减少，训练成本也会增加。

数据划分必须按时间顺序切分。可以采用训练集 : 验证集 : 测试集 = 7 : 1 : 2的比例，先切出测试集，再从训练集中切出验证集。不能像普通分类任务那样随机打乱数据。

3.3 数据构建代码

import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler from torch.utils.data import TensorDataset, DataLoader import torch def build_dataset(csv_path, lookback=24, horizon=1, target="load"): df = pd.read_csv(csv_path, parse_dates=["time"]) df = df.sort_values("time").reset_index(drop=True) feature_cols = [target, "temp", "humidity", "wind_speed", "weekday", "holiday"] scaler = MinMaxScaler() scaled = scaler.fit_transform(df[feature_cols]) X, y = [], [] for i in range(len(scaled) - lookback - horizon + 1): X.append(scaled[i : i + lookback, :]) y.append(scaled[i + lookback + horizon - 1, 0]) X = np.array(X, dtype=np.float32) y = np.array(y, dtype=np.float32) test_size = int(len(X) * 0.2) val_size = int((len(X) - test_size) * 0.1) X_train, y_train = X[: -(test_size + val_size)], y[: -(test_size + val_size)] X_val, y_val = X[-(test_size + val_size) : -test_size], y[-(test_size + val_size) : -test_size] X_test, y_test = X[-test_size:], y[-test_size:] train_ds = TensorDataset(torch.from_numpy(X_train), torch.from_numpy(y_train).unsqueeze(1)) val_ds = TensorDataset(torch.from_numpy(X_val), torch.from_numpy(y_val).unsqueeze(1)) test_ds = TensorDataset(torch.from_numpy(X_test), torch.from_numpy(y_test).unsqueeze(1)) return train_ds, val_ds, test_ds, scaler, feature_cols

代码里保留scaler是为了最后反归一化目标值。torch.from_numpy(...).unsqueeze(1)把标签从(batch,)调整为(batch, 1)，方便与模型输出计算 MSE 损失。feature_cols返回后可以用于打印特征重要性或后续可视化。

4. 模型实现：LSTM、CNN-LSTM 与 AGDO 优化器

4.1 CNN-LSTM 模型结构

LSTM 基线模型很容易定义。输入形状是(batch, lookback, n_features)，LSTM 输出最后一个时间步，再经过全连接层得到预测值。

import torch import torch.nn as nn class LSTMNet(nn.Module): def __init__(self, n_features, lstm_units=64, n_layers=2, dropout=0.2): super().__init__() self.lstm = nn.LSTM( input_size=n_features, hidden_size=lstm_units, num_layers=n_layers, batch_first=True, dropout=dropout, ) self.fc = nn.Linear(lstm_units, 1) def forward(self, x): out, _ = self.lstm(x) return self.fc(out[:, -1, :])

out[:, -1, :]表示取最后一个时间步的隐层输出。对单步预测来说，这个操作非常常见。如果n_layers大于 1，dropout会在相邻 LSTM 层之间生效；如果只有 1 层，dropout 参数不会生效，这一点容易误以为已经加了正则。

CNN-LSTM 在 LSTM 之前插入一维卷积。输入先由卷积层提取局部特征，再进入 LSTM 建模时间依赖。

class CNNLSTM(nn.Module): def __init__(self, n_features, cnn_filters=64, kernel_size=3, lstm_units=64, n_layers=2, dropout=0.2): super().__init__() self.conv1 = nn.Conv1d( in_channels=n_features, out_channels=cnn_filters, kernel_size=kernel_size, padding=kernel_size // 2, ) self.relu = nn.ReLU() self.lstm = nn.LSTM( input_size=cnn_filters, hidden_size=lstm_units, num_layers=n_layers, batch_first=True, dropout=dropout, ) self.fc = nn.Linear(lstm_units, 1) def forward(self, x): # x: (batch, lookback, n_features) x = x.permute(0, 2, 1) # (batch, n_features, lookback) x = self.relu(self.conv1(x)) # (batch, cnn_filters, lookback) x = x.permute(0, 2, 1) # (batch, lookback, cnn_filters) out, _ = self.lstm(x) return self.fc(out[:, -1, :])

padding=kernel_size // 2可以在kernel_size为奇数时保持序列长度不变，避免维度对不上。如果希望做更细的局部特征提取，可以增加池化层或多层卷积，但本文保留最小结构。

4.2 AGDO 优化器核心逻辑

AGDO 在这里不是替代 Adam 的权重优化器，而是在模型外部搜索超参数。搜索对象包括学习率、卷积核数量、LSTM 单元数、dropout 和批大小。

import numpy as np class AGDO: def __init__(self, objective, bounds, n_pop=8, max_iter=15, seed=42): self.objective = objective self.bounds = np.array(bounds, dtype=np.float64) self.n_pop = n_pop self.max_iter = max_iter self.seed = seed self.best_x = None self.best_score = np.inf self.history = [] def clip(self, x): return np.clip(x, self.bounds[:, 0], self.bounds[:, 1]) def init_population(self): rng = np.random.default_rng(self.seed) low = self.bounds[:, 0] high = self.bounds[:, 1] return self.clip(rng.random((self.n_pop, len(low))) * (high - low) + low) def optimize(self): pop = self.init_population() for it in range(self.max_iter): scores = np.array([self.objective(ind) for ind in pop]) for i in range(self.n_pop): if scores[i] < self.best_score: self.best_score = scores[i] self.best_x = pop[i].copy() for i in range(self.n_pop): candidates = [j for j in range(self.n_pop) if j != i] r1, r2, r3 = np.random.choice(candidates, 3, replace=False) # 自适应缩放因子：迭代后期收缩 F = 0.5 + 0.5 * (1.0 - it / self.max_iter) # 差分变异 + 高斯扰动 mutant = ( pop[r1] + F * (pop[r2] - pop[r3]) + np.random.normal(0, 0.1 * (1.0 - it / self.max_iter), size=len(self.bounds)) ) mutant = self.clip(mutant) if self.objective(mutant) <= scores[i]: pop[i] = mutant self.history.append(self.best_score) return self.best_x, self.best_score

这段代码是工程化的 AGDO 风格实现，不是对某篇论文公式的严格复刻。它保留了群体迭代、差分变异、高斯扰动和自适应缩放这些核心思想。实际项目中，你应该把mutant更新规则替换为你所参考版本论文中的正式公式，再验证收敛效果。

4.3 超参搜索目标函数

AGDO 的objective需要接收一组超参数，返回越小越好的验证集损失。这里有个关键取舍：搜索阶段不能训练太多 epoch，否则一轮迭代就要数小时；但也不能太少，否则模型还没收敛，评估结果不稳定。

import torch import torch.nn as nn def build_and_evaluate(params, train_loader, val_loader, config): lr, cnn_filters, lstm_units, dropout, batch_size = params model = CNNLSTM( n_features=config["n_features"], cnn_filters=int(np.round(cnn_filters)), kernel_size=3, lstm_units=int(np.round(lstm_units)), n_layers=2, dropout=float(np.clip(dropout, 0.0, 0.5)), ) optimizer = torch.optim.Adam(model.parameters(), lr=float(lr)) loss_fn = nn.MSELoss() for _ in range(config["eval_epochs"]): model.train() for xb, yb in train_loader: optimizer.zero_grad() loss = loss_fn(model(xb), yb) loss.backward() optimizer.step() model.eval() losses = [] with torch.no_grad(): for xb, yb in val_loader: losses.append(loss_fn(model(xb), yb).item()) return float(np.mean(losses))

超参数边界设置如下：

4.4 训练主流程

在训练主流程里，先用固定超参数训练基线模型，再用 AGDO 搜索最优超参数。基线模型的固定值可以选一个经验组合，例如学习率 0.001、卷积核 64、LSTM 单元 64、dropout 0.2、批大小 64。

from torch.utils.data import DataLoader def make_loader(dataset, batch_size): return DataLoader(dataset, batch_size=batch_size, shuffle=False) config = { "n_features": 6, "eval_epochs": 10, "final_epochs": 100, "seed": 42, } train_ds, val_ds, test_ds, scaler, feature_cols = build_dataset("data/load_data.csv") train_loader = make_loader(train_ds, batch_size=64) val_loader = make_loader(val_ds, batch_size=64) test_loader = make_loader(test_ds, batch_size=64) bounds = np.array([ [1e-4, 1e-2], # lr [16, 128], # cnn_filters [16, 128], # lstm_units [0.0, 0.5], # dropout [16, 128], # batch_size ]) agdo = AGDO( objective=lambda p: build_and_evaluate(p, train_loader, val_loader, config), bounds=bounds, n_pop=8, max_iter=15, seed=42, ) best_params, best_val_loss = agdo.optimize() print("best_params:", best_params) print("best_val_loss:", best_val_loss)

shuffle=False在时序数据里必须保持。如果打开 shuffle，模型会看到跨时间窗口的随机顺序，时序依赖被破坏，验证指标失去意义。

5. 四模型训练与结果对比

5.1 基线模型怎么训练

LSTM 和固定超参数的 CNN-LSTM 不需要 AGDO 搜索，直接用固定超参数训练final_epochs轮即可。为了防止后期过拟合，可以加上早停，例如连续 10 个 epoch 验证损失没有下降就停止训练。

固定结构训练完成后，用测试集计算 MAE、RMSE、MAPE、R2。Python 中可以写一个统一评估函数：

def regression_metrics(y_true, y_pred): mae = np.mean(np.abs(y_true - y_pred)) rmse = np.sqrt(np.mean((y_true - y_pred) ** 2)) mape = np.mean(np.abs((y_true - y_pred) / (y_true + 1e-8))) * 100 ss_res = np.sum((y_true - y_pred) ** 2) ss_tot = np.sum((y_true - np.mean(y_true)) ** 2) r2 = 1 - ss_res / (ss_tot + 1e-8) return mae, rmse, mape, r2

MAPE 中加1e-8是为了避免真实值为 0 时除以 0。电力负荷一般不会为 0，但数值稳定性仍然值得保留。

5.2 AGDO 搜索到超参数后的训练

AGDO 返回的best_params是一个五维数组，分别是lr, cnn_filters, lstm_units, dropout, batch_size。拿到这组参数后，不能直接用搜索阶段只训练 10 个 epoch 的模型作为最终结果。正确的做法是：用这组超参数重新初始化模型，在完整训练集和验证集上训练更长轮次，然后评估测试集。

lr, cnn_filters, lstm_units, dropout, batch_size = best_params final_model = CNNLSTM( n_features=config["n_features"], cnn_filters=int(np.round(cnn_filters)), kernel_size=3, lstm_units=int(np.round(lstm_units)), n_layers=2, dropout=float(dropout), ) final_loader = make_loader(train_ds, batch_size=int(np.round(batch_size))) optimizer = torch.optim.Adam(final_model.parameters(), lr=float(lr)) loss_fn = nn.MSELoss() for epoch in range(config["final_epochs"]): final_model.train() for xb, yb in final_loader: optimizer.zero_grad() loss = loss_fn(final_model(xb), yb) loss.backward() optimizer.step() # 在测试集上评估 final_model.eval() preds, trues = [], [] with torch.no_grad(): for xb, yb in test_loader: preds.append(final_model(xb).numpy()) trues.append(yb.numpy()) preds = np.concatenate(preds).flatten() trues = np.concatenate(trues).flatten()

AGDO-LSTM 和 AGDO-CNN-LSTM 的唯一区别在于模型类不同。AGDO-LSTM 的目标函数使用LSTMNet，因此边界只有四个参数：学习率、LSTM 单元数、dropout、批大小。

5.3 对比结果表格与解读

下面表格是实验结构的示意结果，数值只用于说明对比方式，不是某一特定数据集的真实复现结果。单位是电力负荷量纲，比如 kWh。

解读结果时，重点不是看单一指标，而是看两个维度：结构维度上，CNN-LSTM 是否稳定优于 LSTM；优化维度上，AGDO-LSTM 是否优于 LSTM，AGDO-CNN-LSTM 是否优于 CNN-LSTM。如果 AGDO 只对某个模型有效，说明该模型超参数空间更敏感，这是有价值的信息。

建议同时画出三种图：训练损失曲线、验证集预测曲线、误差分布直方图。图和表配合，比只贴一张指标表更能说明问题。

6. 常见问题排查：从数据泄漏到优化不收敛

6.1 测试指标异常高，先查数据泄漏

现象是模型训练损失很低，测试集 MAE 却远高于验证集。

可能原因是MinMaxScaler在全部数据上做了fit。正确做法是只对训练集fit，然后用scaler.transform处理验证集和测试集。另一个常见原因是数据划分后使用了DataLoader(shuffle=True)，导致相邻时间窗口被随机打乱，测试集信息混进了训练过程。

检查方式很简单：把数据构建代码中的shuffle改成False，再把scaler.fit_transform(df[feature_cols])改成scaler.fit(X_train_raw)后分别转换。确认后重新训练，指标通常会回到正常水平。

6.2 AGDO 搜索结果不稳定

现象是多次运行 AGDO，得到的最优超参数差异很大，而且验证损失波动明显。

主要原因有三个。第一，随机种子没有固定，每次初始化种群不同。第二，搜索阶段eval_epochs太少，模型还没有收敛，验证损失不能代表超参数真实水平。第三，目标函数存在随机性，不同个体训练时即使超参数相同，验证损失也可能不同。

处理方式：

• 在 AGDO、模型初始化、DataLoader 中都使用固定随机种子。
• 将eval_epochs从 5 提高到 15 或 20，观察搜索曲线是否更平稳。
• 对同一个候选超参数重复训练 2 到 3 次，取平均验证损失作为适应度。

AGDO 搜索不是一次跑完就结束。更稳妥的工程做法是：先跑一轮较粗的搜索，把最优超参附近的区间缩放，再跑一轮更细的搜索。

6.3 CNN-LSTM 训练慢或内存不足

现象是 GPU 显存溢出，或者 CPU 训练速度慢到无法接受。

主要原因包括lookback太大、cnn_filters太大、batch_size太大，或搜索阶段每个个体都重新训练模型，导致重复开销过高。

排查顺序：

1. 先把batch_size降到 32 或 16。
2. 检查输入序列长度，过长的历史窗口可以压缩到 24 或 12。
3. 在 AGDO 搜索阶段使用较小验证集，只保留 500 到 1000 个样本。
4. 如果条件允许，用多进程并行评估不同个体，但要注意每个进程占用显存的问题。

如果使用 GPU，训练脚本里加入：

import torch assert torch.cuda.is_available()

并用.to("cuda")把模型和数据移到 GPU。不过 AGDO 搜索阶段频繁创建模型和数据集，GPU 显存碎片可能严重，必要时在目标函数内部用 CPU 训练小模型。

6.4 指标口径不一致导致四模型无法对比

现象是四个模型分别用不同 epoch、不同损失函数、不同验证集训练，结果没法横向比较。

四个模型只有在“同一份数据、同一组评价指标、同一测试集”的前提下才有可比性。基线模型虽然固定超参数，但训练轮数要和最终模型保持一致，或者都使用早停。如果某个模型额外使用了数据增强、特征工程或后处理，就必须在图表说明中单独标注。

建议做一个实验记录表，至少记录：数据版本、特征列、窗口长度、归一化方式、训练集/验证集/测试集数量、随机种子、每个 epoch 的验证损失。没有记录的结果，后续很难向别人解释。

7. 工程化最佳实践与下一步扩展

7.1 实验追踪：把超参数搜索当成正式项目

AGDO 搜索会运行大量候选超参数。如果只用print输出结果，后面很难复盘。推荐使用 MLflow 或简单 JSON 日志记录每一次搜索的个体、验证损失、最终指标。

一条记录至少包含：

{ "model": "AGDO-CNN-LSTM", "seed": 42, "lr": 0.0008, "cnn_filters": 96, "lstm_units": 80, "dropout": 0.15, "batch_size": 64, "val_loss": 8.32, "test_mae": 2.18, "test_rmse": 3.22 }

保留原始记录后，即使后续更换数据，也可以快速判断超参数的迁移性。

7.2 生产环境与学习环境的差别

学习环境里可以反复训练模型、随时调整超参数，但生产环境要考虑模型更新、监控、回滚和成本。

生产环境的多变量预测模型至少需要额外处理四件事：

• 配置外置化：把lookback、horizon、超参数、数据路径放到配置中心或环境变量，避免改代码重新发布。
• 模型版本管理：每次训练产出的模型文件按时间戳保存，并记录对应的数据版本和特征版本。
• 在线监控：预测误差一旦连续超过阈值，需要告警并触发重新训练。
• 特征对齐：线上推理时，输入特征的列顺序、归一化参数、节假日标记规则必须和训练时完全一致。

另一个容易忽略的点是：AGDO 搜索阶段的成本不会出现在最终模型规模里，但会体现在整体研发开销里。生产环境不宜频繁全量搜索，可以在搜索完成后把最优超参数固化，后续只做小范围微调。

7.3 下一步扩展方向

AGDO 不只可以优化超参数，也可以用于特征选择，判断哪些变量对预测结果更重要。还可以把搜索空间扩大到“是否使用池化层”“卷积层数”“LSTM 层数”等结构参数，让 AGDO 自动选择模型拓扑。

在模型层面，TCN、Transformer、KAN 等结构逐渐被引入时序预测。TCN 使用空洞因果卷积，能扩大感受野；Transformer 擅长捕捉长距离依赖；KAN 把全连接层换成柯尔莫哥洛夫-阿诺德网络，可以增强非线性拟合能力。未来可以在 AGDO 的搜索空间中把“模型结构”作为一个离散参数，与社区中常见的 TCN-Transformer-KAN 混合模型进行横向对比。

不过需要提醒的是，模型越复杂，AGDO 搜索的计算成本就越高。建议先跑通固定结构下的超参数优化，再逐步加入结构搜索，不要一开始就追求大规模复杂模型。

如果你的任务是把多变量时序预测模型从“能跑”提升到“跑得好”，AGDO 优化 CNN-LSTM 是一条值得落地的路径。核心不是照搬某篇论文的公式，而是把超参数搜索当作一个独立的工程模块，用统一实验口径验证结构、优化器和数据变换各自带来的收益。下一步，先用一份小数据集把四模型流程跑通，再扩展到大时间窗口和更复杂的混合模型，这样的实验结论才经得起推敲。