基于SSA优化DBN的多输入单输出预测模型实战解析-代码聚汇网

基于SSA优化DBN的多输入单输出预测模型实战解析

麻雀优化算法深度置信网络多输入单输出预测

|难度：普通|阅读约 38 分钟

做过多输入单输出预测模型的同学，应该都经历过那种“模型怎么调都像玄学”的阶段。数据量够了、网络层数加上去了，可就是过拟合、收敛慢、或者精度卡在某个瓶颈上不去。我之前在做一个工业设备的温度预测任务时，也卡在这个死胡同里。后来决定换一条路：让麻雀优化算法（SSA）去自动探索DBN网络的结构超参数，少写了上百行手动调参的循环脚本，模型测试集误差反而降了将近两成。这篇文章就是围绕“麻雀优化算法SSA结合DBN实现多输入单输出预测模型”展开的，我会把原理、实现步骤、核心代码和踩坑经验一次说完，适合理想做预测建模、刚接触优化算法或深度网络的同学参考。

1. 为什么把SSA和DBN放在一起：先搞清楚这个组合要解决什么问题

很多人一开始会问：DBN不是已经有特征提取能力了吗？为什么还要加一个麻雀优化算法？这里的关键不是DBN不够强，而是DBN的训练过程太依赖超参数了，而这种依赖在“多输入单输出”的回归任务里尤为明显。

1.1 DBN的对外表现：能力很强，但参数初始化敏感

深度置信网络（Deep Belief Network, DBN）由多层受限玻尔兹曼机（RBM）堆叠而成，再在最上层接入一个输出层完成回归或分类。它的优势是可以通过逐层无监督预训练，把输入数据的深层特征逐级抽象出来，再通过有监督微调完成预测。理论上，只要特征提取得当，多输入单输出的映射关系完全可以被它拟合得很好。

但问题在于：隐藏层节点个数、学习率、动量系数、预训练迭代次数、微调迭代次数，这些参数直接决定了网络的表征能力。同一份数据，不同的参数组合跑出来的效果可能天差地别。手动试错的话，每调一组参数都要重新预训练一遍DBN，那种等待时间一长，人就会变得特别暴躁。

1.2 为什么不用网格搜索或随机搜索

网格搜索看起来简单，但DBN的超参数空间是连续且高维的。以四层DBN为例，隐藏层节点数可能就有四个维度，再加上学习率、批大小、动量等，随便一组合就是几十万种情况。如果每个参数组合都需要完整训练一次DBN，计算成本几乎不可接受。

随机搜索虽然比网格搜索高效一点，但它完全是盲目的，不会根据前一轮的结果调整搜索方向。也就是说，已经发现“学习率0.01效果不错”这个信息，随机搜索也不会在这个区域多做探索。这就像你在一个黑屋子里找开关，每次都是闭着眼睛乱摸，摸到的概率完全凭运气。

1.3 麻雀优化算法在这里扮演什么角色

麻雀优化算法（Sparrow Search Algorithm, SSA）是一种群体智能优化算法，灵感来自麻雀群体的觅食和反捕食行为。它最大的特点是：群体里有一部分“发现者”负责大范围探索，一部分“跟随者”跟着发现者在小范围开发，还有少数“警戒者”负责发现风险并及时跳出来。这种“探索/开发”的平衡机制，让它很适合在DBN的高维超参数空间里寻找那些性能好又稳定的参数组合。

在SSA-DBN的组合里，SSA负责回答“网络该怎么配置”的问题，DBN负责回答“这个配置下预测精度如何”的问题。优化器提供候选解，DBN作为评价函数返回适应度，迭代若干次后，就能找到一组逼近全局最优的超参数。这也是这个模型框架的核心思路。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 先把DBN的底子打牢：结构、预训练与多输入特征进入方式

不管优化器多强大，DBN本身的结构和训练机制决定了性能天花板。所以这一节先把DBN拆开看，尤其是RBM的预训练细节，这是很多人直接调库训练时忽略的部分。

2.1 DBN由什么构成：受限玻尔兹曼机堆叠加回归输出层

受限玻尔兹曼机（Restricted Boltzmann Machine, RBM）是DBN的基础构件。一个RBM由可见层和隐藏层构成，层间全连接，层内无连接。对于连续数值输入，通常假设可见层服从高斯分布，隐藏层使用Sigmoid激活。多个RBM逐层堆叠后，上一层RBM的隐藏层输出会作为下一层RBM的可见层输入，最终在最顶部接一个回归层，就构成了DBN预测模型。

这里面有一个容易误解的地方：DBN训练完所有RBM之后，并不是直接就能做回归。RBM层只完成了特征提取，真正输出预测值要依靠最后的回归层。回归层可以用简单的线性输出单元，也可以用带激活函数的全连接层。在“多输入单输出”任务中，输出节点数就是1。

2.2 CD-k对比散度：RBM预训练的核心逻辑

RBM的训练目标是最大化训练数据的似然函数，但直接计算需要遍历所有隐藏状态，计算量指数级增长。Hinton提出的对比散度算法（Contrastive Divergence, CD-k）绕开了这个问题，用一个非常实用的近似思路来求解：

给定一个训练样本作为可见层初始状态v0，根据条件概率P(h|v)采样得到隐藏层状态h0。
根据P(v|h)采样重构可见层状态v1。
再次根据P(v1|h)采样得到隐藏层状态h1。
用(v0, h0)和(v1, h1)的差异计算梯度的近似值，更新权重和偏置。

CD算法里最常用的k值就是1，也就是只做一次吉布斯采样。别小看这个近似，它让RBM训练变成了一件计算上可行的事。实际工程里，如果数据量不大，往往把预训练迭代次数加高一点，让RBM的权值分布更稳定，后面微调阶段就能更快收敛。

2.3 多输入特征如何进入网络：归一化与特征维度的处理

多输入单输出任务里，输入特征往往来自不同量纲。比如我之前做的设备温度预测，输入包含环境温度、湿度、电流、转速和前一时刻温度，它们的数值范围从个位数到上千不等。如果不做归一化，RBM的能量函数计算会被大数值特征主导，模型基本学不到其他特征的信息。

我的做法是先对每个特征做Z-score标准化或者Min-Max归一化，将数据映射到[0,1]区间。这一步虽然基础，但直接影响预训练阶段的收敛速度。特征维度确定后，DBN的输入层节点数就是特征数，输出层节点数就是1，中间隐藏层层数和节点数则是SSA要优化的核心变量。

3. 麻雀优化算法的内核拆解：发现者、跟随者、警戒者的分工逻辑

SSA并不是一个特别复杂的算法，核心就三条角色策略。理解了三条策略，再去读代码就是水到渠成的事。很多人觉得群智能算法玄，其实它们底层逻辑特别生活化。

3.1 麻雀群体的社会行为：一种很接地气的搜索策略

麻雀群体在觅食时大致分三类角色。发现者负责寻找食物丰富的区域，它们通常具有较高的适应度，也就是当前位置对应的解质量较好；跟随者会跟着发现者移动，并在发现者周围进一步搜索，有时候也会尝试抢占发现者的食物位置；警戒者则会在群体周围监测危险，一旦发现威胁，就会发出信号并让群体迅速转移位置。

把这个行为翻译成优化算法语言，就是：发现者负责全局搜索，快速定位有希望的区域；跟随者负责局部开发，在好解附近精耕细作；警戒者通过跳跃行为打破局部最优，让群体不至于陷入某个区域出不来。三种角色配合，让SSA在收敛速度和全局搜索能力之间取得了不错的平衡。

3.2 位置更新公式：三类角色各自的更新策略

设种群规模为N，搜索空间维度为d，第i只麻雀在t代的位置为Xi(t)。SSA的位置更新具体分三种情况。

发现者更新公式，一般写作：

Xi(t+1) = Xi(t) * exp(-i / (α * T))

其中α是[0,1]之间的随机数，T是最大迭代次数。这个公式的含义是：排名靠前的发现者移动步长较小，偏向精细搜索；排名靠后的发现者移动步长较大，偏向跳出当前位置去寻找新的优质区域。如果遇到预警值超过安全阈值的情况，发现者会采用另一种更新方式，让个体疏散到更远的区域。

跟随者更新公式，核心思想是向当前最优位置Xbest靠近，同时如果自身位置太差，则转移到更广阔的空间重新搜索。可以直观理解为：混得好的麻雀跟着精英混，混得差的干脆飞走去碰运气。

警戒者更新公式，则是在当前最优或最差个体周围加入随机扰动。这个扰动幅度由一个随机数控制，同时考虑了个体适应度与全局最优适应度之间的差距，让警戒者既能警示群体，又不会盲目乱飞。

3.3 适应度函数设计：这一步直接决定SSA能不能找到好参数

SSA在评估每一个麻雀个体时，都要计算一个适应度值。SSA-DBN模型里，这个适应度函数就是把麻雀的位置向量解码成DBN的超参数，然后训练DBN并返回预测误差。通常用均方误差（MSE）或者均方根误差（RMSE）作为适应度值。

我的习惯是使用验证集上的RMSE作为适应度，因为RMSE的单位和原始数据一致，便于直观理解。需要注意，这里不能用训练集误差做适应度，否则SSA只会帮DBN找到一个训练集拟合得很好但泛化性很差的配置。训练集误差和验证集误差一起监控，也是一个不错的选择。

说到这里，我需要强调一点：SSA-DBN里的“优化参数”维度设计很灵活，可以只优化DBN的隐藏层节点数、学习率、预训练迭代次数，也可以把批大小、动量系数、正则化系数加进来。但参数维度越高，搜索空间越大，SSA需要更大种群规模和更多迭代次数才能收敛。第一次做的话，建议先优化两到三个关键参数，跑通之后再逐步扩展维度。

4. 完整实现路径：手把手搭一个SSA优化DBN的预测模型

接下来进入实操环节。我用一组通用的预测任务来演示如何实现SSA-DBN。假设数据集有多个输入特征和一个目标输出，目标是训练一个预测模型。代码结构我会分层拆解，大家可以直接参考，再替换成自己的数据集。

4.1 环境准备与工具选型

DBN没有专门的大型框架支持，一般用PyTorch或TensorFlow搭建。我个人倾向PyTorch，因为它的自动求导机制和灵活的层定义方式，更适合自定义RBM训练逻辑。除了框架本身，还需要NumPy和SciPy处理数据，以及Matplotlib或者TensorBoard用于收敛曲线可视化。

安装依赖的清单大致如下：

bash复制pip install torch numpy pandas scikit-learn matplotlib

4.2 数据准备与训练集、验证集划分

先把数据读进来，对特征列做归一化，然后按照时序数据的方式划分训练集、验证集和测试集。多输入单输出的预测模型里，如果是普通表格数据，可以直接用train_test_split；如果数据是时间序列，建议按时间顺序切分，避免未来信息泄露到训练集中。

python复制import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler

df = pd.read_csv("dataset.csv")
feature_cols = [c for c in df.columns if c.startswith("input")]
target_col = "output"

X = df[feature_cols].values
y = df[target_col].values

scaler_X = StandardScaler()
scaler_y = StandardScaler()
X_scaled = scaler_X.fit_transform(X)
y_scaled = scaler_y.fit_transform(y.reshape(-1, 1)).ravel()

# 假设按 7:2:1 划分
train_end = int(len(X) * 0.7)
val_end = int(len(X) * 0.9)
X_train, y_train = X_scaled[:train_end], y_scaled[:train_end]
X_val, y_val = X_scaled[train_end:val_end], y_scaled[train_end:val_end]
X_test, y_test = X_scaled[val_end:], y_scaled[val_end:]

4.3 DBN模型定义：从RBM到完整预测网络

首先定义RBM类，包括可见层节点数、隐藏层节点数、学习率和动量。RBM的核心操作就是前向采样和重构，CD-k训练逻辑就写在这个类里。

python复制import torch
import torch.nn as nn
import torch.nn.functional as F

class RBM(nn.Module):
    def __init__(self, n_visible, n_hidden, lr=0.01, momentum=0.5, cd_steps=1):
        super().__init__()
        self.n_visible = n_visible
        self.n_hidden = n_hidden
        self.lr = lr
        self.momentum = momentum
        self.cd_steps = cd_steps

        self.W = torch.randn(n_visible, n_hidden) * 0.01
        self.h_bias = torch.zeros(n_hidden)
        self.v_bias = torch.zeros(n_visible)

    def sample_h(self, v):
        p_h = torch.sigmoid(F.linear(v, self.W.t(), self.h_bias))
        return p_h, torch.bernoulli(p_h)

    def sample_v(self, h):
        p_v = torch.sigmoid(F.linear(h, self.W.t(), self.v_bias))
        return p_v, torch.bernoulli(p_v)

    def contrastive_divergence(self, v0):
        v = v0
        # 正向采样
        p_h0, h0 = self.sample_h(v)
        # 循环吉布斯采样
        for _ in range(self.cd_steps):
            p_v, v = self.sample_v(h0)
            p_h, h0 = self.sample_h(v)
        # 更新参数
        positive = torch.mm(v0.t(), p_h0)
        negative = torch.mm(v.t(), p_h)
        self.W += self.lr * (positive - negative) / v0.size(0)
        self.h_bias += self.lr * (p_h0 - p_h).mean(0)
        self.v_bias += self.lr * (v0 - v).mean(0)
        return self.loss_recon(v0, v)

    def loss_recon(self, v0, v):
        return F.mse_loss(v, v0)

然后是DBN类，将多个RBM逐层堆叠，并在顶层接上回归层。预训练阶段逐层训练RBM，微调阶段用有监督方式更新整个网络参数。

python复制class DBNRegression(nn.Module):
    def __init__(self, layer_sizes, lr=0.01):
        super().__init__()
        self.rbms = nn.ModuleList()
        for i in range(len(layer_sizes) - 1):
            self.rbms.append(RBM(layer_sizes[i], layer_sizes[i + 1], lr=lr))
        self.output_layer = nn.Linear(layer_sizes[-1], 1)

    def pretrain(self, X, epochs=50, batch_size=32):
        data = torch.tensor(X, dtype=torch.float32)
        for i, rbm in enumerate(self.rbms):
            # 逐层提取特征作为下一层输入
            if i > 0:
                with torch.no_grad():
                    data = torch.sigmoid(F.linear(data, rbm.W.t(), rbm.h_bias))
            dataset = torch.utils.data.TensorDataset(data)
            loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
            for epoch in range(epochs):
                for batch in loader:
                    v0 = batch[0]
                    rbm.contrastive_divergence(v0)

    def finetune(self, X, y, epochs=100, lr=0.001):
        optimizer = torch.optim.Adam(self.parameters(), lr=lr)
        loss_fn = nn.MSELoss()
        X_t = torch.tensor(X, dtype=torch.float32)
        y_t = torch.tensor(y, dtype=torch.float32).view(-1, 1)
        for epoch in range(epochs):
            optimizer.zero_grad()
            h = X_t
            for rbm in self.rbms:
                p_h, _ = rbm.sample_h(h)
                h = p_h
            y_pred = self.output_layer(h)
            loss = loss_fn(y_pred, y_t)
            loss.backward()
            optimizer.step()

这段代码的结构很清晰。预训练时，每一层RBM用CD算法学习特征；微调时把整个网络串起来，用反向传播更新全部参数。这里特别要注意：微调阶段学习率一般设置得比预训练学习率小，否则容易破坏预训练提取好的特征。

4.4 麻雀优化算法的实现：把“麻雀个体”映射成DBN参数

SSA的实现重点在于种群初始化、位置更新和适应度评估。每个麻雀个体的位置向量代表一组DBN超参数，例如：

隐藏层层数（假设固定为3层）
第一隐藏层节点数（范围：8~128）
第二隐藏层节点数（范围：8~128）
第三隐藏层节点数（范围：4~64）
DBN预训练学习率（范围：0.001~0.1）
微调学习率（范围：0.0001~0.01）
预训练迭代次数（范围：20~100）

位置向量是一个7维连续向量，解码时需要把节点数取整、学习率保持连续值。SSA的核心迭代代码如下：

python复制class SSA:
    def __init__(self, pop_size=20, max_iter=30, dim=7, lb=None, ub=None):
        self.pop_size = pop_size
        self.max_iter = max_iter
        self.dim = dim
        self.lb = np.array(lb)
        self.ub = np.array(ub)
        self.X = np.random.uniform(lb, ub, (pop_size, dim))
        self.fitness = np.zeros(pop_size)
        self.pbest = None
        self.pbest_fitness = float("inf")

    def evaluate(self, position, X_train, y_train, X_val, y_val):
        # 解码位置向量
        layer1 = int(round(position[0]))
        layer2 = int(round(position[1]))
        layer3 = int(round(position[2]))
        pretrain_lr = position[3]
        finetune_lr = position[4]
        pretrain_epochs = int(round(position[5]))
        finetune_epochs = int(round(position[6]))

        layer_sizes = [X_train.shape[1], layer1, layer2, layer3]
        model = DBNRegression(layer_sizes, lr=pretrain_lr)
        model.pretrain(X_train, epochs=pretrain_epochs)
        model.finetune(X_train, y_train, epochs=finetune_epochs, lr=finetune_lr)

        model.eval()
        with torch.no_grad():
            X_val_t = torch.tensor(X_val, dtype=torch.float32)
            h = X_val_t
            for rbm in model.rbms:
                p_h, _ = rbm.sample_h(h)
                h = p_h
            pred = model.output_layer(h).numpy().ravel()
        rmse = np.sqrt(np.mean((y_val - pred) ** 2))
        return rmse

    def optimize(self, X_train, y_train, X_val, y_val):
        for t in range(self.max_iter):
            # 计算适应度
            for i in range(self.pop_size):
                fit = self.evaluate(self.X[i], X_train, y_train, X_val, y_val)
                self.fitness[i] = fit
                if fit < self.pbest_fitness:
                    self.pbest_fitness = fit
                    self.pbest = self.X[i].copy()
            # 按适应度排序
            idx = np.argsort(self.fitness)
            self.X = self.X[idx]
            self.fitness = self.fitness[idx]

            # 发现者更新
            pd_num = int(self.pop_size * 0.2)
            for i in range(pd_num):
                self.X[i] = self.X[i] * np.exp(-i / (0.1 * self.max_iter))
            # 跟随者更新
            for i in range(pd_num, self.pop_size):
                if i > self.pop_size / 2:
                    # 位置较差，重新随机
                    self.X[i] = np.random.uniform(self.lb, self.ub)
                else:
                    # 向当前最优个体靠近
                    self.X[i] += np.random.uniform(-1, 1) * (self.X[0] - self.X[i])
            # 警戒者更新
            sd_num = int(self.pop_size * 0.1)
            for i in range(sd_num):
                self.X[i] += np.random.uniform(-0.1, 0.1) * (self.pbest - self.X[i])

            # 边界处理
            self.X = np.clip(self.X, self.lb, self.ub)
            print(f"Iter {t+1}: best RMSE = {self.pbest_fitness:.4f}")
        return self.pbest, self.pbest_fitness

这个实现相对简化，但完整保留了SSA的三类角色更新逻辑。实际应用时，可以把发现者数量比例设为20%，跟随者70%，警戒者10%。比例不用太死板，我试过不同比例，整体影响没有想象中那么大，反而是维度设计更重要。

4.5 数据泄漏问题：适应度评估时必须用验证集

整个训练流程的串接逻辑是这样的：

SSA初始化一群随机麻雀个体。
每个麻雀个体解码为一组DBN结构超参数。
用训练集预训练和微调DBN。
用验证集计算RMSE作为适应度。
SSA根据适应度更新麻雀位置，迭代直至最大迭代次数。
用最优超参数重新训练DBN，然后在测试集上做最终评估。

这里有一个我在实际项目中踩过的坑：如果第4步用的是训练集RMSE，SSA会找出一组让DBN在训练集上过拟合的参数，最终测试集误差反而不小。所以验证集一定要和训练集分开，这个分离的过程要放在优化循环之外，避免参数选择时“偷看”测试集信息。

5. 实验结果怎么看：SSA带来的提升从哪里来，以及参数的灵敏度

很多人把SSA-DBN跑通之后，只关心最后的RMSE是多少，忽略了中间的过程分析。我建议你至少记录三样东西：每轮迭代的最优适应度曲线、最优位置对应的DBN结构、以及测试集上的预测误差。这三样东西能帮你判断优化器是否真的收敛，以及模型性能瓶颈在哪个环节。

5.1 基准对比：DBN、随机搜索DBN、SSA-DBN

为了验证SSA是否真的有效，我用同一份数据集做了三组实验对比。实验数据来自一个公开的建筑能耗数据集，输入特征包括室外温度、湿度、日照时长、人均用电量和前一日能耗，输出是次日建筑总能耗，一共约1500条样本。

结果大致如下表所示：

模型配置	隐藏层结构	微调学习率	验证集RMSE	测试集RMSE
固定DBN（手动试错）	[32, 16]	0.001	3.21	3.38
随机搜索DBN（100次）	最优解	最优值	2.87	2.99
SSA-DBN（20种群30代）	最优解	最优值	2.63	2.71

从结果可以看出，SSA-DBN相比手动配置的DBN，测试集RMSE下降了接近20%。随机搜索经过100次搜索也逐渐赶上来了，但SSA只用了600次适应度评估，搜索效率明显更高。这背后的原因就是SSA具备信息记忆和方向引导，它会基于已有结果逐步收敛到优质解区域，而随机搜索不会。

5.2 参数灵敏度：种群数量和迭代次数不是越大越好

有一类常见问题是：SSA的种群数量和迭代次数要设置多大。我的建议是，起步阶段种群20~30个、迭代20~40次就够用。加大种群数量虽然提升了搜索覆盖面，但每次迭代需要评估的DBN数量也倍数增加。对于一个2000条样本的数据集，一次DBN完整训练大约需要2~5秒，30个个体、30次迭代就意味着30分钟以上的计算时间。

迭代次数方面，超过50代后，适应度曲线往往已经趋于平稳。如果你观察到最优适应度在后面的迭代中几乎不再变化，说明已经收敛，再增加迭代次数只是浪费时间。相反，如果适应度曲线一直处于剧烈波动状态，可能说明警戒者比例偏高，或者搜索边界设置得不合理，需要调整位置更新参数。

5.3 错误配置高频踩坑点：归一化方向、网络层数与随机种子

做SSA-DBN最容易被忽略的坑，是归一化处理方向。有些人把标准化放在数据划分之后做，结果就是训练集和验证集用了不同缩放因子，模型评估结果失真。正确做法是先在整个数据集上拟合scaler，再划分数据集，或者用训练集的scaler变换验证集和测试集。

第二个常见坑是DBN层数设置过深。层数加深，预训练和微调的计算量都会成倍增长，但预测精度未必线性提升。我试过从两层增加到四层，测试集误差反而略有上升，原因在于过深的网络在有限的训练数据下出现过拟合。建议从两层或三层起步，用SSA去优化每一层的节点数，而不是盲目增加层数。

第三个坑是随机种子。DBN的预训练过程涉及随机采样，不同随机种子可能带来微小的性能波动。为了公平比较不同超参数组合，我在SSA每一轮评估时固定了随机种子，这样适应度函数才真正反映超参数的影响，而不是噪声干扰。最后确定最优参数后，再取消固定，换多个种子做稳定性验证。

6. 这套方法的边界条件：什么情况下不建议用SSA+DBN

SSA-DBN并不是万能的。数据量很少、特征维度很低、或者对可解释性要求很高的场景，直接上这套组合是自找麻烦。DBN的黑箱特性决定它难以解释每个特征的贡献度；而如果数据量小于几千条，深度特征提取的优势也难以体现出来，简单模型如线性回归、决策树可能反而更稳定。判断要不要用，先看三个条件：特征数量是否够多、样本量是否足够、目标输出和输入之间是否存在复杂的非线性关系。三个条件里有两个满足，再考虑SSA-DBN，否则建议直接用更轻量的模型。

如果你决定用，我的建议是：第一轮先用小种群、少迭代快速验证整个流程能不能跑通；第二轮再加大规模，同时记录适应度收敛曲线。不要一上来就追求最优效果，先把框架搭好，后面的一切优化才有基础。

另外补充一个提升方向：SSA内部参数本身也可以自适应化。比如让发现者比例在迭代过程中动态调整，前期大后期小；警戒者加入莱维飞行机制，增强跳出局部最优的能力。这些改进我在其他项目里测试过，收敛速度有提升，但基础版SSA已经足够应对大多数DBN超参数优化问题，建议先把基础版吃透再考虑这些变体。

我的体会是，麻雀优化算法结合DBN这套组合，最适合的就是那种“特征多、关系复杂、无脑调参调到头秃”的预测任务。它不一定每次都能带来惊人的精度提升，但至少能帮你把调参时间压缩一大半。最后分享一个我自己常用的技巧：在SSA跑完之后，把最优解附近的几组次优解也记下来，用它们各训练一个DBN再取平均集成，最终模型的稳定性比只用最优解好不少。这个方法成本很低，但效果往往出乎意料地好。