PSO优化GRU多输入分类预测：从超参数搜索到工程落地

简介：PSO-GRU（粒子群优化-门控循环单元）多输入分类预测的完整项目实例，以docx文档形式打包发布。内容面向具备一定编程基础和机器学习经验的研发人员，聚焦利用粒子群算法自动优化GRU超参数，解决多维输入场景下分类准确率不高、模型过拟合与计算复杂等问题，可应用于金融预测、医疗诊断、工业设备监控、交通流量预测和智能家居等领域。包体为1个docx文件，压缩包约73KB，文档系统梳理了项目背景、目标与意义、挑战及解决方案、特点与创新、应用领域、模型架构、核心代码解析和GUI设计说明，并针对超参数选择、多输入数据处理、训练复杂度控制、过拟合规避与结果评估给出可落地的注意事项。此外，文档还展望了多任务学习、强化学习结合、深度迁移学习、自动特征工程与联邦学习等改进方向，为后续研究和工程实践提供思路。资源目前已有66人学习浏览，适合希望将智能优化与深度学习结合起来、快速复现分类预测项目的算法工程师与科研人员。

1. PSO-GRU 多输入分类预测：这个项目到底在解决什么问题

很多从业者手里都有一张多列特征的表，要做的是分类而不是回归。比如，根据设备振动和温度特征判断故障类型，根据多传感器数据识别人体动作，或者根据行情指标判断涨跌方向。直接上一个门控循环单元（GRU）分类网络，效果往往还行，但瓶颈卡在超参数上——隐层神经元数、学习率、批大小、时间步长，每个参数试几档就是几十次完整训练，费时费力，结果还像在黑匣子里抽卡。粒子群算法（PSO）正好能把这件事自动化：把一组超参数编码成一个粒子，让一群粒子在参数空间里飞行，用验证集准确率当得分，十几代就能收敛到一组可用的参数。本项目就是用 PSO 优化 GRU 做多输入分类预测的完整落地流程，覆盖数据预处理、模型构建、粒子群优化和 GUI 操作界面。适合做故障诊断、行为识别、金融分类这类「多特征输入 + 分类输出」任务的人，也适合想把超参数搜索过程讲清楚的算法工程师。

2. 从原理侧定方案：为什么用粒子群算法去调 GRU，而不是网格搜索或贝叶斯

2.1 PSO 调的是哪几个超参数：粒子编码与搜索空间

GRU 分类网络的实际效果，受四个参数影响最大：GRU 层的隐含神经元数（hidden_size）、学习率（lr）、批大小（batch_size）、输入滑窗长度（window）。如果网络不止一层，还有 num_layers；为了防止过拟合，还要考虑 dropout。这五个参数在优化任务里就构成 PSO 的一个粒子。

粒子群算法的核心思想很朴素：把每一组候选超参数当作参数空间中的一个点（粒子），每个粒子记住自己历史最好的位置 pbest，也共享整个群体目前最好的位置 gbest。每一轮迭代，粒子朝这两个方向同时移动，速度和位置更新公式是：

v = w * v + c1 * r1 * (pbest - x) + c2 * r2 * (gbest - x) x = x + v

w 是惯性权重，控制保持原来飞行方向的能力；c1、c2 是学习因子，控制朝个人最优和群体最优飞的程度；r1、r2 是 [0,1] 之间的随机数。这套公式没有高深数学，写成代码不到十行。跟网格搜索那种按指数级组合穷举的方式相比，PSO 的搜索代价通常低一个数量级；跟贝叶斯优化相比，PSO 不需要额外维护代理模型，对连续参数和整数参数混合的场景处理更直接，也更容易向组内同事解释清楚。

参数范围我按从业经验给一组起点：hidden_size 取 [16, 128] 的整数，lr 取 [0.0001, 0.01] 的对数均匀值，batch_size 取 [8, 64] 且是 2 的幂，window 取 [4, 20] 的整数。特别注意 lr 不要用线性均匀采样——学习率在低数量级区间差一点就天差地别，用对数区间更合理。PSO 自身的参数通常固定 c1 = c2 = 1.5、粒子数 20、迭代 15 代，具体权衡放到第四章展开。

2.2 多输入到底指什么：把表格数据变成三维张量

标题里的「数据多输入」，在从业项目中绝大多数情况下指的是多特征输入（multivariate input），而不是图像那种多个输入分支的结构。也就是说，你有一张多列特征的表，每一行是一个时刻的观测，要根据过去一段时间的多列特征判断当前时刻属于哪个类别。

GRU 吃进去的数据不能是二维表，必须是三维张量，形状为 (样本数, 时间步, 特征数)。构造方式是滑窗（sliding window）：

import numpy as np def make_sequences(features, labels, window=8): X, y = [], [] for i in range(len(features) - window): X.append(features[i:i + window]) # 每个样本切出 window 行 y.append(labels[i + window]) # 标签取窗口之后的那一时刻 return np.array(X), np.array(y)

逻辑说明：features 是已经归一化后的二维数组，每一行是一个时刻的全部特征；labels 是对应时刻的类别编号。循环从 0 走到 len(features) - window，把连续 window 行作为样本，形状是 (window, 特征数)；类别标签取窗口结束后的那一时刻。滑窗之后，问题就变成了「用过去 window 个时刻的多维特征预测当前类别」的序列分类任务。GRU 的时间步数就是 window，每个时间步喂进去的特征数是 features.shape[1]。

参数说明：window 越大，单个样本包含的历史信息越多，但样本总数会减少，训练耗时也会上升。window 本身就是 PSO 要优化的参数之一，所以代码里先用默认值 8，后面第四章会把它写进粒子编码。

2.3 分类任务的损失与评价指标：不能只看准确率

GRU 分类网络的输出端要接一个全连接层，把 hidden_size 维映射到类别数，正常用交叉熵损失。PyTorch 里直接用 nn.CrossEntropyLoss()，内部包含 softmax，不需要在模型输出层额外手动做 softmax。

评价指标才是容易翻车的地方。如果类别均衡，看验证集准确率就够了；如果某一类样本很少，比如故障样本只有正常样本的十分之一，准确率会被多数类带偏。此时适应度函数应该改成 macro-F1，也就是先按每个类别算 F1 再取平均，少数类的表现才能被公平计入。这直接影响第四章 PSO 适应度函数的设计。

另外，GRU 对特征尺度非常敏感。门控结构内部是 sigmoid 和 tanh，如果某一列特征数值特别大，梯度在门里会被压缩得厉害，模型很难收敛。所以归一化不是可选项，而是前置条件。这也是整个项目最基础的一步，下一章按「先划分、再归一化、最后滑窗」的顺序演示。

3. 上手复现：从多输入数据到能跑的分类模型

3.1 数据预处理：先划分、再归一化、最后滑窗

常见错误是先把整个数据集归一化，再划分训练集和测试集。我一般按这个顺序：先按时间顺序切出训练集和测试集，再用训练集的均值和标准差去归一化训练集和测试集，最后分别做滑窗。时序数据不要随机打乱切分，否则未来信息会泄漏到训练集里，验证结果虚高，上线就露馅。

from sklearn.preprocessing import StandardScaler # 假设 raw_data 形状为 (总时刻数, 特征数)，labels 为类别编号 # 1) 按 8:2 切分，时序数据不做随机打乱 split = int(len(raw_data) * 0.8) train_data, test_data = raw_data[:split], raw_data[split:] train_labels, test_labels = labels[:split], labels[split:] # 2) 只用训练集统计量做归一化 scaler = StandardScaler().fit(train_data) train_data = scaler.transform(train_data) test_data = scaler.transform(test_data) # 3) 滑窗构造样本 X_train, y_train = make_sequences(train_data, train_labels, window=8) X_test, y_test = make_sequences(test_data, test_labels, window=8)

逻辑说明：先切分是防止测试集的信息通过归一化统计量流入训练过程；scaler 只 fit 训练集，保证测试集是「没见过」的数据。滑窗必须在归一化之后进行，这样每个窗口内部的特征数值尺度一致。滑窗函数直接复用 2.2 里的 make_sequences，不用另外写。最终的 X_train 形状是 (样本数, 8, 特征数)，y_train 形状是 (样本数,)。

参数说明：8:2 是我常用的基准划分，样本量很小时可以改成 7:3，但验证指标方差会变大。window 取 8 只是起点，后续 PSO 会把它当作一个优化维度。切分后样本总数会减少 window 个，样本量只有几百条时要特别注意这个损耗。

3.2 PyTorch 写一个轻量 GRU 分类网络

GRU 分类器的结构不复杂：GRU 层、一个全连接输出层、可选的 Dropout。中小规模数据建议只上一层 GRU，两层只在序列规律复杂且样本量足够大的时候才有收益。为了让后面 PSO 能把 num_layers 也纳入搜索，这里做成可配置：

import torch import torch.nn as nn class GRUClassifier(nn.Module): def __init__(self, n_features, hidden_size, n_classes, num_layers=1, dropout=0.0): super().__init__() self.gru = nn.GRU(n_features, hidden_size, num_layers, batch_first=True, dropout=dropout) self.fc = nn.Linear(hidden_size, n_classes) def forward(self, x): # x: (batch, window, n_features) out, _ = self.gru(x) # out: (batch, window, hidden_size) out = out[:, -1, :] # 只取最后一个时间步的隐藏状态 return self.fc(out)

逻辑说明：batch_first=True 让输入形状直观，形态是 (batch, window, n_features)。GRU 会输出每个时间步的隐藏状态，分类时只取最后一个时间步，也就是 out[:, -1, :]，它聚合了整个窗口的信息。如果序列特别长，也可以把最后几个时间步平均后再接全连接，但对大多数分类任务，取最后一步已经足够，代码也更简单。

参数说明：hidden_size 是 GRU 的核心容量参数，太小欠拟合、太大容易过拟合且训练显存涨得快，这就是 PSO 需要搜索的第一维。dropout 参数在 num_layers=1 时会被 PyTorch 忽略，只有层数大于 1 才生效，所以后续粒子编码里 dropout 要么固定为 0，要么和层数联动。

3.3 训练循环：一个 epoch 里要同时带验证

训练函数不要写得花哨，但两个细节要提前定死：优化器用 Adam，学习率由 PSO 解码后传入；每个 epoch 结束在验证集上算一次准确率，因为后续适应度函数要反复调用它。

def train_epoch(model, train_loader, optimizer, criterion): model.train() total_loss, correct, total = 0.0, 0, 0 for xb, yb in train_loader: optimizer.zero_grad() logits = model(xb) loss = criterion(logits, yb) loss.backward() optimizer.step() total_loss += loss.item() correct += (logits.argmax(dim=1) == yb).sum().item() total += len(yb) return total_loss / len(train_loader), correct / total def evaluate(model, val_loader, criterion): model.eval() correct, total, loss_sum = 0, 0, 0.0 with torch.no_grad(): for xb, yb in val_loader: logits = model(xb) loss_sum += criterion(logits, yb).item() correct += (logits.argmax(dim=1) == yb).sum().item() total += len(yb) return loss_sum / len(val_loader), correct / total

逻辑说明：train_epoch 先 zero_grad，再 forward、backward、step，是 PyTorch 的标准节奏。argmax(dim=1) 拿到每个样本得分最高的类别。evaluate 用 no_grad 包住推理，省显存，也不会把梯度误算进验证过程。

参数说明：batch_size 在构造 DataLoader 时传入，由 PSO 解码后给出。criterion 统一用 nn.CrossEntropyLoss()，它内部做了 softmax，所以模型 forward 末尾不需要再手动加 softmax，否则损失计算会出错。这两个函数会被第四章的适应度函数反复调用，建议放到公共工具文件里。

4. PSO 优化 GRU 的核心实现：完整代码与参数设计

4.1 粒子编码与解码：整数、对数连续、类别三态混在一起

一个粒子就是一维数组，我把它定义为 [hidden_size, lr_log, batch_size_power, window, dropout]。注意编码和解码分开写：粒子内部全部用连续浮点数，解码时再转成实际超参数。这样 PSO 的速度更新公式就不需要区分整数还是浮点，省去很多边界判断。

import numpy as np # 粒子内部用连续向量表示: [h, lr_log, bs_pow, win, drop] # 实际范围: h∈[16,128]; lr∈[1e-4,1e-2]; bs∈[2^3,2^6]; win∈[4,20]; drop∈[0,0.5] def decode(p): h = int(round(p[0])) lr = 10 ** p[1] bs = int(2 ** round(p[2])) win = int(round(p[3])) drop = float(np.clip(p[4], 0, 0.5)) return dict(hidden_size=h, lr=lr, batch_size=bs, window=win, dropout=drop) def bounds(): return (np.array([16, -4.0, 4, 4, 0.0]), np.array([128, -2.0, 6, 20, 0.5]))

逻辑说明：hidden_size 和 window 这类整数参数，粒子内部仍用浮点，解码时 round 取整。lr 用 10 的指数表示，覆盖 1e-4 到 1e-2 的对数区间，避免线性采样把大量粒子堆在小数值区域。batch_size 用 2 的指数编码，解码后永远是 8、16、32、64，不需要额外校验。dropout 用 clip 限制在 [0, 0.5]，防止粒子飞出边界后生成负 dropout 这种非法配置。

边界说明：PSO 位置更新偶尔会让某个维度越界，最简单的处理是 np.clip 裁剪到边界。裁剪会损失一点点粒子多样性，但对中小规模项目影响很小，代码最直观。想要更精细的反弹式边界处理，可以后续再扩展。

4.2 适应度函数：用验证集准确率当 PSO 的得分

适应度函数是 PSO 与 GRU 之间唯一的接口。每个粒子解码出一组超参数，用这组参数建一个 GRU、训练少量 epoch、在验证集上测准确率，这个值就是粒子的得分。关键权衡在于：训练轮数越多，评估越准，但 PSO 总耗时也随之拉长。经验做法是固定 6 到 10 个 epoch，能让不同超参数之间的差距拉开即可。

def fitness(p, X_train, y_train, X_val, y_val, n_epochs=8): cfg = decode(p) torch.manual_seed(0) model = GRUClassifier( n_features=X_train.shape[2], hidden_size=cfg["hidden_size"], n_classes=len(np.unique(y_train)), num_layers=1, dropout=cfg["dropout"]) optimizer = torch.optim.Adam(model.parameters(), lr=cfg["lr"]) criterion = nn.CrossEntropyLoss() loader = make_loader(X_train, y_train, cfg["batch_size"]) val_loader = make_loader(X_val, y_val, cfg["batch_size"]) for _ in range(n_epochs): train_epoch(model, loader, optimizer, criterion) _, acc = evaluate(model, val_loader, criterion) return acc

逻辑说明：n_epochs 设 8，是让 PSO 能跑进十几代而不至于太慢的折中。如果发现评估噪声太大，先加 n_epochs，比加粒子数更有效。torch.manual_seed(0) 让每个粒子评估时使用相同的初始化，粒子之间得分可比性更高。这里只是临时固定，完整的多重随机种子策略见第五章。

参数说明：make_loader 是 PyTorch DataLoader 的薄封装，按 batch_size 组装训练和验证集。n_epochs、粒子数、迭代代数三者相乘就是总耗时。假设 20 个粒子、15 代、每代 8 epoch，意味着累计 2400 次训练 epoch。数据量大时，先在一个采样子集上做 PSO 搜索，找到参数后全量重训，是这个项目缩短时间最有效的做法。

4.3 PSO 主循环：速度更新、位置更新、收敛判据

粒子群主循环代码很短，核心是速度和位置两条更新公式，外加每代维护全局最优。

def pso_optimize(eval_func, n_particles=20, n_iters=15, c1=1.5, c2=1.5): lb, ub = bounds() dim = len(lb) x = np.random.uniform(lb, ub, (n_particles, dim)) v = np.random.uniform(-(ub - lb) * 0.1, (ub - lb) * 0.1, (n_particles, dim)) pbest = x.copy() pbest_score = np.array([eval_func(p) for p in x]) gbest = pbest[pbest_score.argmax()] gbest_score = pbest_score.max() for it in range(n_iters): w_it = 0.9 - 0.5 * it / n_iters # 惯性权重线性递减 0.9 -> 0.4 for i in range(n_particles): r1, r2 = np.random.rand(dim), np.random.rand(dim) v[i] = w_it * v[i] + c1 * r1 * (pbest[i] - x[i]) + c2 * r2 * (gbest - x[i]) v[i] = np.clip(v[i], -(ub - lb) * 0.2, (ub - lb) * 0.2) x[i] = np.clip(x[i] + v[i], lb, ub) s = eval_func(x[i]) if s > pbest_score[i]: pbest_score[i], pbest[i] = s, x[i].copy() if s > gbest_score: gbest_score, gbest = s, x[i].copy() print(f"iter {it+1}/{n_iters}, best acc={gbest_score:.4f}") return decode(gbest), gbest_score

逻辑说明：w_it 从 0.9 线性递减到 0.4，这是粒子群优化算法最常见的收敛策略——前期惯性大，粒子在全局范围探索；后期惯性小，集中在最优附近精细搜索。速度上限设为边界宽度的 20%，防止粒子一步飞出太远，导致后续只能反复在边界处往返。每个粒子评估完就更新 pbest 和 gbest，不需要等整代粒子全部评估完再一起更新，收敛速度会更快。

参数说明：c1=c2=1.5 是经典取值，一般不需要改动。粒子数 20、迭代 15 代对应约 2400 次 epoch 的成本预算。如果 gbest 一直不动，优先检查是否是 w 衰减太快或粒子数太少，而不是盲目增加迭代代数。

4.4 用最优参数重训最终模型并保存

PSO 找到的是「最优配置」，最终模型还要用这份配置在完整训练集上重新训练更多轮次，才能真正投入使用。常见做法是：把 PSO 评估时的训练集和验证集合并，用最优超参数训练 50 到 100 个 epoch，最后在测试集上出完整报告。

best_cfg, best_acc = pso_optimize(fitness) final_cfg = best_cfg.copy() final_model = GRUClassifier(n_features=X_train.shape[2], hidden_size=final_cfg["hidden_size"], n_classes=n_classes, num_layers=1, dropout=final_cfg["dropout"]) optimizer = torch.optim.Adam(final_model.parameters(), lr=final_cfg["lr"]) criterion = nn.CrossEntropyLoss() full_loader = make_loader(np.concatenate([X_train, X_val]), np.concatenate([y_train, y_val]), final_cfg["batch_size"]) for epoch in range(80): train_epoch(final_model, full_loader, optimizer, criterion) torch.save(final_model.state_dict(), "pso_gru_best.pt")

逻辑说明：重训阶段把训练集和验证集合到一起，样本量变大，模型能学到更多模式。训练轮数从 PSO 评估时的 8 放宽到 80，此时没有搜索成本的压力。保存的 state_dict 只包含模型权重，加载时需要用同一个模型结构才能恢复，这个细节在 GUI 里加载模型时经常被踩到。

参数说明：如果训练到 80 轮已经明显过拟合，可以考虑把 dropout 调大，或者保存验证集准确率最高的 checkpoint 而不是最后一个 epoch。实践中我会先看训练曲线再决定是否加早停，这个习惯来源于真实项目里遇到过不少次 60 轮附近开始过拟合的情况。

5. 避坑与排查：PSO-GRU 落地中翻车最多的五个细节

5.1 适应度评估太慢：一个 PSO 实验跑通宵

现象：粒子数 30、代数 20、每代 20 个 epoch，累计训练 12000 次，实验挂机一晚上还没跑完。

原因：没有意识到适应度评估成本是粒子数、代数、epoch 数三者相乘。很多人只盯着粒子数和代数，忽略了每代内部还要训练多个 epoch。

解决：把粒子数降到 15、迭代降到 10、n_epochs 降到 6 到 8；数据量大时先在一个随机子集上做搜索，拿到超参数后再用全量数据重训。我一般会在代码里打印每代耗时，超过 5 分钟一代就先砍评估轮数，而不是直接加机器。

5.2 粒子群早早撞向同一个点，gbest 再也没动过

现象：跑到第三第四代，所有粒子几乎重叠在同一个位置，搜索停在明显不是最优的区域。

原因：惯性权重 w 太小，或者速度上限卡得太紧，粒子失去了探索能力；粒子数太少也会加剧这种早熟收敛。

解决：w 用 0.9 到 0.4 的线性递减策略，速度上限放宽到边界宽度的 20%，粒子数至少 15。如果仍然早期收敛，可以把 c1 提高到 1.8，让粒子更相信自己历史找到的最优位置，个体多样性保留得更久。

5.3 同样参数两次结果差两三个点，调参像抽卡

现象：同一个 hidden_size、同一个 lr，在同样数据上跑两次，验证集准确率差 2 到 3 个百分点，PSO 搜索方向完全不可信。

原因：numpy 和 PyTorch 的随机初始化都没有固定，DataLoader 的随机打乱顺序也变了，粒子得分里混了大量噪声。

解决：在项目入口一次性固定三处随机源：random.seed、np.random.seed、torch.manual_seed，并且给 DataLoader 固定 shuffle 时的随机种子。这样才能保证粒子之间的得分可比较，搜索方向才不会被噪声带偏。

5.4 验证准确率虚高，换一批数据就崩

现象：测试集指标很漂亮，模型部署到新环境后准确率掉一大截。

原因：归一化时用了全量数据做 scaler.fit，或者 PSO 搜索过程中动过数据划分的边界，导致未来信息泄漏进训练过程。

解决：严格按第三章顺序执行，先切分、再 fit 归一化、最后滑窗。测试集从头到尾不参与任何统计量计算，PSO 评估用的验证集也不能参与最终模型的重训。工程上这一步是项目可信度的底线，省掉它等于给自己埋雷。

5.5 GUI 里点「开始」按钮，窗口直接假死

现象：在 tkinter 或 PyQt 窗口里启动 PSO 后，窗口转圈、按钮失效，只能强杀进程。

原因：把训练循环直接跑在 GUI 主线程里，窗口事件循环被长任务阻塞了。

解决：把 PSO 和训练代码放到 threading.Thread 里运行，线程内通过队列把日志和进度回传，tkinter 用 after 定时轮询队列更新界面。这是第六章 GUI 设计里必须先搭好的地基，否则界面做得再好看，一跑训练就卡死，等于白做。

6. 把 PSO-GRU 收进 GUI：一个能调参、能出图的最终演示

6.1 tkinter 界面骨架：参数面板、日志区、启动按钮

GUI 不追求复杂功能，能完成「选参数区间、启动搜索、看收敛过程、保存模型」这条链路即可。tkinter 是 Python 标准库，不需要额外装界面框架，配合 threading 和 queue 就能解决界面卡死的问题。

import threading, queue import tkinter as tk from tkinter import ttk class PSOApp: def __init__(self, root): self.q = queue.Queue() self.hidden_var = tk.StringVar(value="16-128") self.lr_var = tk.StringVar(value="1e-4-1e-2") self.btn = ttk.Button(root, text="启动 PSO", command=self.start) self.log = tk.Text(root, height=15) self.btn.pack() self.log.pack() root.after(100, self.after_loop) def start(self): threading.Thread(target=self.run_task, daemon=True).start() def run_task(self): def log_cb(msg): self.q.put(msg) log_cb("PSO start...") best, acc = pso_optimize(fitness, log_cb=log_cb) log_cb(f"done, best acc={acc:.4f}") def after_loop(self): try: while True: msg = self.q.get_nowait() self.log.insert(tk.END, msg + "\n") except queue.Empty: pass root.after(100, self.after_loop)

逻辑说明：耗时任务放进 threading.Thread 里，界面通过 after(100) 每 100 毫秒轮询一次队列，把线程里发来的日志逐条写进文本框。daemon=True 保证窗口关闭时线程不会阻止进程退出。PSO 主循环里每迭代一代往队列写入一条收敛信息，用户就能在界面上实时看到 gbest 的变化。

界面再补三个按钮就完整了：加载数据选择 CSV、保存模型把 best.pt 落盘、退出程序。参数面板用 StringVar 绑定输入框，用户改完粒子边界，代码里重新生成 bounds 即可，不需要改任何核心逻辑。

6.2 嵌一张收敛曲线和混淆矩阵，验证才算闭环

GUI 里除了文本日志，我还会放两个 matplotlib 图：左边是 PSO 每代 gbest 的折线，右边是最终模型在测试集上的混淆矩阵。收敛曲线能一眼看出搜索是否早停，混淆矩阵能看出哪些类别被系统性混掉。嵌入 tkinter 用 FigureCanvasTkAgg 把图挂到窗口上，不需要额外引入其他界面库。

出图之外，还有一个最容易忽略的验证习惯：把最优超参数、训练集划分方式、随机种子、数据归一化统计量一起写进 JSON 配置文件。这样隔几天回来，或者换人复现，都能完全还原当时的实验条件。数据目录一变，之前的 PSO 结果就不好比对了。我做这类项目已经养成固定习惯：先落数据和配置，再跑实验，最后才出图和模型。这条顺序帮我避开了很多白费功夫的返工。希望这个 PSO-GRU 项目方案能帮到你，至少让你在超参数搜索这条路上少一点玄学、多一点可复现。

本文还有配套的精品资源，点击获取