企业官网建设流程全解析

简介：面向控制系统设计与优化研究者的分数阶粒子群与混合粒子群PID参数优化工具包，适用于需要借助分数阶理论提升控制器性能的MATLAB/Simulink使用场景。压缩包内共9个文件，以5个m脚本和3个mdl模型为主，另有1个slx模型，整体仅26KB，轻量易用。m脚本涵盖分数阶微积分算子实现、分数阶系统频域特性分析以及粒子群优化算法的参数寻优过程；mdl与slx文件则提供分数阶对象模型、混合粒子群PID控制器及闭环系统仿真，可直接修改参数并运行验证。该工具包已有443人学习，适合研究生、工程师在控制器设计、参数整定与系统稳定性分析中参考使用。通过该工具包，读者能快速搭建分数阶仿真环境，利用粒子群算法自动搜索最优PID增益，同时借助波特图等工具观察不同分数阶次下的频率响应，深入理解分数阶微积分对控制品质的影响，有效减少手动调试与反复试错的时间。

1. 从试凑法到自动寻参：分数阶粒子群PID到底解决什么

做控制的同学几乎都有一段试凑PID参数的深夜经历：阶跃响应超调压下去了，调节时间又拉长；Kp加一点，系统开始啸叫。标题这个“代码.zip_分数阶代码_分数阶优化_分数阶粒子群_参数优化_混合粒子群PID”，本质上是一套把调参交给算法的方案：用分数阶粒子群优化算法（FOPSO）去自动搜索PID乃至分数阶PID（PIλDμ）的五个参数，然后把优化器和控制器“混合”成一条可复现的调参流水线。先说结论：这套方向值得动手，尤其是模型能仿真、但手工调参已经拖慢迭代的场合。它能解决的痛点是让PID参数优化自动化，而你不需要信任某个现成工具箱的黑匣子，核心迭代公式自己就能写。

2. 分数阶算子与粒子群打底：先看懂混合调参的两个来源

2.1 分数阶微积分的工程入口：GL离散化与PIλDμ

分数阶微积分不是新概念，它把“求导的阶次”从整数延拓到实数。控制领域常见三种定义：Riemann-Liouville、Caputo和Grünwald-Letnikov（GL）。做工程落地，我一般只看GL，因为它直接给离散化的递推公式，写进仿真循环没有任何障碍。

GL定义的离散形式长这样：

D^α f(t) ≈ h^{-α} Σ_{k=0}^{N} (-1)^k C(α,k) f(t-kh)

其中 C(α,k) 是广义二项式系数，用递推算就可以：

C(α,0)=1 C(α,k)=C(α,k-1)·(α-k+1)/k，k=1,2,...

这套递推在编程时非常好用，不需要事先算一大堆组合数。实际做分数阶PID仿真时，我会把误差信号 e(t) 的过去 N 个采样点存下来，然后对这条历史序列做一次带 GL 系数的卷积，就得到当前时刻的分数阶积分或微分。

把分数阶放回PID，就是PIλDμ控制器的表达式：

u(t) = Kp·e(t) + Ki·D^{-λ}e(t) + Kd·D^{μ}e(t)

比常规PID多了积分阶次 λ 和微分阶次 μ 两个自由度，响应曲线的形状更自由。比如整数阶微分对测量噪声敏感，μ 取0.5到0.8时，高频放大的斜率要缓和很多。代价是参数从3个变成5个，手工整定基本不可能，这就是后面分数阶粒子群要登场的直接原因。

2.2 粒子群算法原理：标准PSO为什么会在PID调参中早熟

粒子群算法原理并不复杂：一群粒子分布在整个搜索空间里，每个粒子携带着速度和位置。位置就是一组待优化的参数，比如Kp、Ki、Kd；速度决定下一次往哪个方向走。每次迭代，粒子根据自身历史最优 pbest 和群体最优 gbest 更新速度，再更新位置。

标准更新式是：

v_i(t+1) = w·v_i(t) + c1·r1·(pbest_i - x_i(t)) + c2·r2·(gbest - x_i(t)) x_i(t+1) = x_i(t) + v_i(t+1)

w 是惯性权重，通常从0.9线性衰减到0.4；c1、c2 是学习因子，一般取1.5左右；r1、r2 是[0,1]均匀随机数。

标准PSO在PID参数优化里的典型问题不是不收敛，而是收敛太快、收错地方。速度更新本质是一阶差分方程，随着 w 被压小，粒子的速度记忆越来越短，群体很快聚集到某个局部最优附近。PID参数空间是非凸、多峰的，而且五个维度的数值尺度差异很大——Kp可能是0.1到10，λ和μ是0.5到1.5——标准PSO对这类尺度不敏感，经常出现“Kp贴边界、Ki偏小、λ接近1”这种看起来能跑但远不是最优的解。

还有一个现实约束：PID仿真目标函数每次都要完整跑一遍闭环，几百步仿真下来计算量不小，迭代次数被限制在100到300次。这要求优化器前期探索尽量充分、后期别早早扎堆。普通PSO很难同时满足这两点。

2.3 把速度更新改成分数阶差分：FOPSO的汇合点

FOPSO的核心动作，是把标准PSO速度更新左边那个一阶差分 v(t+1)-v(t)，换成分数阶差分 D^α v(t+1)。展开后，速度的历史项会留在公式里，粒子的“动量”就带上了记忆。

GL展开到前三项，速度更新变成：

v(t+1) = a(t) - gl_1·v(t) - gl_2·v(t-1) - gl_3·v(t-2)

其中 a(t) 是标准PSO的加速度部分：w·v(t) + c1·r1·(pbest-x) + c2·r2·(gbest-x)。gl_k 是GL系数，由 α 递推得到。

这个式的直观意义是：粒子不再只看上一时刻自己的速度，还能回忆起两步、三步之前是怎么飞的。当 gbest 发生小幅偏移时，粒子不会全体急转弯，轨迹平滑很多。α=1时，gl_2 和 gl_3 正好等于0，公式退化成 v(t+1)=a(t)+v(t)，就是标准PSO；α越接近0，历史记忆越弱，粒子越短视。所以 FOPSO 不是另起炉灶，而是把标准PSO嵌进了更大的参数族里。

对PID这类多峰目标函数，这个“记忆”很值钱：前期它维持探索多样性，后期它不让所有粒子一窝蜂涌向同一个局部解。而实现成本不过多维护三步速度历史，代码量几乎没变。

3. 手写一个分数阶粒子群：从递推公式到可跑代码

3.1 从速度差分到分数阶记忆项：FOPSO的迭代公式

先给出可以直接抄进代码的推导。标准PSO的速度更新，把 v(t+1)-v(t) 看作一阶差分，我现在把它换成 D^α v(t+1)，并令它等于加速度项 a(t)。根据GL定义，保留前三项：

D^α v(t+1) ≈ v(t+1) - α·v(t) + [α(α-1)/2]·v(t-1) - [α(α-1)(α-2)/6]·v(t-2)

令它等于 a(t)，解出：

v(t+1) = a(t) + α·v(t) - [α(α-1)/2]·v(t-1) + [α(α-1)(α-2)/6]·v(t-2)

注意 GL 系数符号：gl_1 = -α，gl_2 = α(α-1)/2，gl_3 = -α(α-1)(α-2)/6。所以通用写法是：

v_new = acc - Σ_{k=1..m} gl_k · v(t+1-k)

gl_k 用递推算：

def gl_coeff(alpha, m): # 返回 gl_1 到 gl_m，GL差分系数 coeff = 1.0 out = [] for k in range(1, m + 1): coeff = coeff * (alpha - k + 1) / k out.append((-1) ** k * coeff) return out

逻辑说明：coeff 是广义二项式系数 C(α,k)，前面乘 (-1)^k 得到 GL 差分系数。α=0.7 时，gl_1=-0.7，gl_2=-0.105，gl_3=-0.0595，高阶项快速衰减，所以我一般把截断项 m 定在3，再往上对结果影响不大，还额外占内存。截断项 m 是“物理可实现”的边界——理论上GL要全历史，工程上只能收前几步。

这个公式在 α=1 时会自动退化为标准 PSO：gl_1=-1、gl_2=0、gl_3=0，v_new = acc + v(t)，完美兼容。反过来，α=0 时 gl_1=0、gl_2=0，v_new=acc，粒子没有动量，相当于只靠随机加速度乱撞，所以 α 不能取0。

3.2 最小可运行的FOPSO实现（Python）

下面这版是我日常改算法时用的骨架，不依赖任何第三方优化库，只有 numpy：

import numpy as np class FractionalPSO: def __init__(self, obj_func, dim, bounds, alpha=0.6, m=3, c1=1.5, c2=1.5, n_p=40, max_iter=100, seed=42, v_scale=0.2): self.obj = obj_func self.dim = dim self.bounds = np.asarray(bounds, dtype=float) self.alpha = alpha self.m = m self.c1, self.c2 = c1, c2 self.n_p = n_p self.max_iter = max_iter rng = np.random.default_rng(seed) lb, ub = self.bounds[:, 0], self.bounds[:, 1] self.lb, self.ub = lb, ub # 种群初始化：均匀撒点 self.x = rng.uniform(lb, ub, (n_p, dim)) self.v = np.zeros((n_p, dim)) # v_hist[0]是t时刻速度，[1]是t-1，[2]是t-2 self.v_hist = np.zeros((3, n_p, dim)) self.pbest = self.x.copy() self.pbest_val = np.array([obj_func(p) for p in self.x]) idx = np.argmin(self.pbest_val) self.gbest = self.pbest[idx].copy() self.gbest_val = self.pbest_val[idx] self.v_max = v_scale * (ub - lb) def _gl(self, k): coeff = 1.0 for i in range(1, k + 1): coeff = coeff * (self.alpha - i + 1) / i return ((-1) ** k) * coeff def run(self): for it in range(self.max_iter): w = 0.9 - 0.5 * it / self.max_iter # 惯性权重线性递减 r1 = np.random.random((self.n_p, self.dim)) r2 = np.random.random((self.n_p, self.dim)) acc = (w * self.v + self.c1 * r1 * (self.pbest - self.x) + self.c2 * r2 * (self.gbest - self.x)) v_new = acc.copy() # 分数阶记忆项：减掉历史速度的GL加权 for k in range(1, self.m + 1): v_new -= self._gl(k) * self.v_hist[k - 1] v_new = np.clip(v_new, -self.v_max, self.v_max) # 滚动历史速度 self.v_hist[2] = self.v_hist[1] self.v_hist[1] = self.v_hist[0] self.v_hist[0] = v_new self.v = v_new self.x = np.clip(self.x + self.v, self.lb, self.ub) # 评估并更新 pbest / gbest vals = np.array([self.obj(p) for p in self.x]) better = vals < self.pbest_val self.pbest[better] = self.x[better] self.pbest_val[better] = vals[better] if vals.min() < self.gbest_val: g_idx = np.argmin(vals) self.gbest = self.x[g_idx].copy() self.gbest_val = vals[g_idx] return self.gbest, self.gbest_val

逻辑说明：速度更新分两步，先算标准PSO的加速度 acc，再减掉历史速度的GL加权和。这里 v_hist 保存最近三步速度，滚动方式是把新速度放进 [0]，原来的依次后移。位置更新后做边界裁剪，避免粒子飞出参数范围。整体复杂度跟标准PSO几乎一样，只是在每轮更新时多算了三个 GL 系数的乘积。

参数说明：alpha 是分数阶阶次，推荐从0.5起步，调到0.8附近看效果；m 是截断项数，3就够用；v_scale 控制最大速度，取0.2表示速度上限为参数范围的20%，防止分数阶记忆项把速度累积过大。obj_func 是外部传入的目标函数，输入一组参数、返回一个标量值，优化目标是让它最小。

3.3 三个必调参数：阶次α、截断项数和惯性权重

FOPSO 真正需要反复试的就三个参数：α、m、以及惯性权重的衰减方式。

调参时有两条经验。第一，先用标准PSO（把α设成1.0）跑一遍，确认目标函数本身能收敛、适应度曲线能降下来，再改α引入分数阶记忆；如果标准PSO都不动，问题在目标函数或边界，不在FOPSO。第二，α和w是联动的。α大意味着历史速度保留多，粒子惯性大，如果w还在0.9那速度会爆掉，粒子全部冲到边界被裁剪回来，表现为“看似在跑、实际所有粒子都贴在边界上”。正确做法是α取0.6、w衰减开始点降到0.8，观察种群分布，再决定加还是减。

我的诊断习惯是每10代打印一次 pbest_val 的最小值、中位数和最大值。如果中位数和最大值很快塌缩到和最小值同一个数量级，说明多样性丢了；如果中位数迟迟不降，说明历史记忆太强、群体更新太保守。两个极端都要靠 α 和 m 往回拉，而不是加迭代次数——迭代次数救不了已经扎堆的粒子群。

4. 混合粒子群PID：把FOPSO接到控制器参数优化上

4.1 “混合”到底混什么：全局搜索加局部精搜的完整链路

标题里的“混合粒子群PID”在落地文件里有两种常见理解。第一种，控制器本身是混合结构：比如分数阶PID（PIλDμ）就是整数阶PID和分数阶算子的混合，用粒子群来整定这五个参数。第二种，优化器是混合的：FOPSO负责全局粗搜，结束之后再用Nelder-Mead这类局部算法把结果精修一轮。实际代码包里往往是两者都有，我一般也按这个链路来组织。

为什么需要混合而不是让FOPSO一把梭？因为粒子群算法在中后期收敛慢，它的优势是跳出多峰、找到好的盆地，但在盆地内部做精细收敛不是强项。PID参数优化里，最后那10%的J值下降往往是局部搜索带来的。做法是先用FOPSO跑100代拿到 gbest，再把 gbest 作为初值给 scipy.optimize.minimize 的 Nelder-Mead 方法，限制迭代200轮以内。这个组合成本低，效果好，也是“混合”最实在的变现方式。

另外一个容易忽略的点：FOPSO和PID仿真的耦合。每次粒子评估都要完整跑一遍闭环，我建议把仿真函数 cache 起来，因为同一个粒子位置在多轮迭代里会被反复评估。粒子群算法原理里最耗时的不是速度更新，而是目标函数调用，这块优化不做，后面跑100代能慢到怀疑人生。

4.2 目标函数与仿真回路：ITAE加权惩罚的Python实现

目标函数选型，我固定用 ITAE 为主、超调和控制量变化为罚项的加权式。ITAE 对误差持续时间的惩罚足够敏感，能筛掉“慢慢蹭到目标”的懒解；超调百分百要罚，不然优化器会Kp拉满制造大超调；控制量变化率罚项是用来贴近工程现实的，没有它，搜索出的PID可能在仿真里漂亮、上真机就抖。被控对象我取一阶惯性加纯滞后，这是温度、压力、流量回路最常见的传递函数形式。

import numpy as np TS = 0.05 PLANT_K = 1.5 PLANT_T = 3.0 TAU_DELAY = 1.0 SIM_STEPS = 600 GL_WINDOW = 300 DELAY_STEPS = int(TAU_DELAY / TS) def gl_coeff(order, window=GL_WINDOW): coeff = np.zeros(window) coeff[0] = 1.0 for k in range(1, window): coeff[k] = coeff[k-1] * (order - k + 1) / k gl = np.zeros(window) for k in range(window): gl[k] = ((-1) ** k) * coeff[k] return gl def frac_diff(err_hist, order): # order>0为微分，order<0为积分；用GL卷积计算 win = min(len(err_hist), GL_WINDOW) gl = gl_coeff(order, win) val = 0.0 for k in range(win): val += gl[k] * err_hist[len(err_hist) - 1 - k] return val * (TS ** (-order)) def simulate_fopid(p): kp, ki, kd, lam, mu = p y = 0.0 u = 0.0 u_prev = 0.0 delay_line = np.zeros(DELAY_STEPS + 1) err_hist = [] itae = 0.0 du_sum = 0.0 y_max = 0.0 r = 1.0 for i in range(SIM_STEPS): y_plant = delay_line[0] # 带纯滞后的被控量 e = r - y_plant err_hist.append(e) u = (kp * e + ki * frac_diff(err_hist, -lam) + kd * frac_diff(err_hist, mu)) u = np.clip(u, -10.0, 10.0) # 控制量限幅，防积分饱和 du_sum += abs(u - u_prev) u_prev = u y = y + (TS / PLANT_T) * (PLANT_K * u - y) delay_line = np.roll(delay_line, -1) delay_line[-1] = y itae += (i * TS) * abs(e) * TS y_max = max(y_max, y_plant) overshoot_pct = max(0.0, (y_max - r) / r * 100.0) return itae + 50.0 * overshoot_pct + 0.1 * du_sum

逻辑说明：simulate_fopid 接收五元组 p，Kp、Ki、Kd 是常规PID增益，lam 是积分阶次，mu 是微分阶次。闭环回路里，误差信号 e 每步追加进 err_hist，frac_diff 对这段历史做GL卷积：阶次为负就是分数阶积分，为正就是分数阶微分。被控对象的一阶惯性用前向欧拉近似，纯滞后用一个长度21的环形队列模拟。控制量限幅放在 u 进入被控对象之前，防止搜索过程中控制量发散把仿真打崩。

参数说明：ITAE 权重为1，超调百分比罚50，控制量变化率罚0.1。这个权重比例对大多数一阶滞后对象都适用。超调罚50意味着一个10%的超调相当于目标函数里加5分，ITAE不过零点几，权重谱系上能有效压制超调。du_sum 罚0.1是轻量约束，主要防止控制量高频抖动。如果搜出的参数控制量乱甩，就把0.1提到1.0。

4.3 参数边界、收敛判定与结果解读

参数边界直接决定搜索空间质量。我通常按下面的范围给：

调用 FOPSO 的精搜链路是这样的：

from scipy.optimize import minimize pso = FractionalPSO( obj_func=simulate_fopid, dim=5, bounds=[[0.1, 10], [0.01, 5], [0.01, 5], [0.5, 1.5], [0.5, 1.2]], alpha=0.6, m=3, n_p=40, max_iter=100, seed=2024 ) best_p, best_j = pso.run() print("FOPSO:", best_p, best_j) # 局部精搜：把FOPSO结果作为初值 res = minimize(simulate_fopid, best_p, method="Nelder-Mead", options={"maxiter": 200, "xatol": 1e-4, "fatol": 1e-4}) print("Refined:", res.x, res.fun)

这段代码把“混合粒子群PID”完整串起来：FOPSO 先全局粗搜，得到一组靠谱的五元参数；Nelder-Mead 再在这个参数附近做多面体收缩，把 J 值压到更低。收敛判定不需要额外写，PSO 迭代完自然停止，Nelder-Mead 用 xatol 和 fatol 判停。

结果解读时，先看 FOPSO 阶段 gbest 曲线的形状：前30代应该快速下降，之后进入平滑下降段；如果曲线在后期还频繁跳变锯齿，说明 α 偏大或者速度裁剪过松。再看精搜后的 J 是否比粗搜有明显下降，一般能降5%到15%左右，这代表“混合”这一步吃到了红利。最后一定要把最优参数放回 simulate_fopid 跑一次阶跃，单独打印超调量和调节时间——优化器在乎 J，你在乎的是现场表现。

5. 分数阶粒子群PID联调的避坑清单：五个翻车现场

5.1 适应度不降反升或直接NaN：分数阶微分被无限放大

现象：前几代适应度正常下降，十几代后突然跳到一个大数，或者直接出现 nan，整个搜索没法继续。如果打印控制量 u，会发现前几步就顶到限幅。

原因：μ 阶微分在误差跳变的瞬间会算出极大的值。GL系数在 order>1 后开始迅速增大，虽然 μ 上界设了1.2，但搜索初期粒子参数是随机撒的，总会有几组参数把 μ 和 Kd 都推到边界附近，阶跃启动瞬间 D^μ e 剧烈放大。

解决：把 μ 上界从1.2再压到1.0；在误差进入分数阶微分之前先做一阶低通，比如 e_filtered = 0.7e_filtered + 0.3e；另外把控制量限幅从±10暂时压到±5，保证即使微分项爆了仿真也不发nan。这个坑是所有分数阶PID联调里出现频率最高的，不是FOPSO的问题，是目标函数本身对参数极端组合缺乏保护。

5.2 30代内所有粒子挤在一起：记忆项过强导致假收敛

现象：每代打印 pbest_val 的中位数，前10代还在下降，20代后就等于最小值了；再检查种群位置，大量粒子堆在某个参数边界上。

原因：α 取得过大（比如0.9），历史速度的GL系数累积，粒子速度持续增长，飞出边界后被裁剪，全体被 gbest 拉到同一点。这本质是“记忆过强+速度裁剪相互作用”造成的假收敛，粒子并没有真正搜索到最优盆地，只是被边界和引力困住了。

解决：α 从0.5起步，别一上来就0.9；把 m 从3减到2，减少历史项；v_scale 从0.2降到0.1。调整后重新观察前20代的中位数曲线，应该和最小值保持一个合理差距。诊断技巧是看每代有多少粒子触发边界裁剪，比例超过30%就说明速度设置离谱。

5.3 仿真里很好，真机或连续模型上发散：采样与时滞错位

现象：离散仿真里 J 值低得漂亮，参数拿到现场却振荡甚至发散。换到更精确的连续仿真器，同样参数表现也明显变差。

原因：前向欧拉离散误差在采样周期偏大时被FOPSO“利用”了——优化器找到一组参数，在粗粒度离散仿真里恰好稳定，在更精确的模型里稳定裕度不足。纯滞后环节的环形队列实现如果采样对齐不对，还会额外引入一个采样周期的相位误差。

解决：把采样周期从0.05改成0.01重跑一遍，比较两次最优参数的 J 差异；差异超过5%说明离散误差不可忽略，应把 TS 缩小或改用双线性变换。纯滞后处理要确认 delay_line 的长度等于 τ/TS 取整，而不是近似相等等效。养成习惯：每次优化结束后，把参数放到两倍采样率下重放一次，这是成本最低的鲁棒性测试。

5.4 每次运行结果差一大截：随机种子与初始化没有固定

现象：同样的代码，连续跑三次，最优 Kp 一次是2.1，一次是4.6，一次是1.8，J 也差出30%。明明代码没动，结果却像抽奖。

原因：PSO 是随机算法，种群初始位置完全由随机数决定；PID参数空间又存在多个深度接近的局部最优，不同的初始分布会落进不同盆地。

解决：在 FractionalPSO 里固定np.random.default_rng(seed)，每个实验记录种子号；报告结果时不要只写“最好的一次”，而是跑3到5次，给出中位数和范围。我自己的习惯是每次优化完把种群初始随机种子、最终参数、适应度曲线一起存成 npz 文件，留作复现依据。如果三次运行的中位数差异还是超过15%，说明目标函数峰值太接近，这时优先优化权重，而不是盲目加迭代次数。

5.5 搜出的参数换到实物就不好用：目标函数缺了现实惩罚

现象：FOPSO 给出的 Kp 只有0.2，Ki 却顶到5，仿真里超调一点没有，但被控对象动作慢得没法用。放到现场，执行机构频繁动作，阀门最后磨坏。

原因：目标函数里 ITAE 权重过大、控制量变化率惩罚只有0.1，优化器发现了“Kp小、Ki大慢慢蹭”的懒解。这个解在仿真里 ITAE 很低，因为它确实在逼近目标，只是调节时间长到不可接受；而超调罚项又不会惩罚它，因为根本没有超调。

解决：在目标函数里加上调节时间或上升时间罚项，最简单的是把控制量变化率权重从0.1提到1.0，再次优化，观察 Kp 和 Ki 是否回到合理区间。工程判断标准：正常对象 Kp 和 Ki 的量级应当相差不多，不会出现一个比另一个大十倍以上的极端组合。如果搜出来的参数让你觉得“这不像人调出来的PID”，目标函数概率没设对。

6. 上线前的验证与两个进阶技巧：让优化结果敢拿去用

6.1 用多次独立运行统计代替“单次跑通”

把FOPSO固定三个不同随机种子各跑一遍，记录每次的最优J和参数，再取中位数。单次跑通只能证明代码没报错，不能证明方案稳定。成功率定义为：J低于某个工程可接受阈值（比如0.5，由你自己定）的次数的占比。我一般跑5次，低于4次成功就要回头调α或目标函数权重。

6.2 参数灵敏度检查：五个参数谁的误差影响最大

把最优参数每个维度单独±10%，其他维度保持不变，重放目标函数，看J的变化量。J变化最大的参数就是最敏感参数，真机迁移时优先保证它的精度。

上表里μ和Kp的扰动影响最大，这两个参数在实物上取整时就要小心。

6.3 模型失配测试：给被控对象参数加扰动再重放

把 PLANT_T 和 TAU_DELAY 各±20%扰动，用同一组PID参数重放闭环，看超调是否仍然低于可接受值。这是最便宜的鲁棒性测试，我每次调完必做。如果扰动后系统不稳定，说明参数过于依赖精确模型，需要缩小 μ 或者降低 Kd。

我自己的教训是：调参之前先固定随机种子和采样周期，让每次实验都可重放；任何优化结论都要有三次运行的中位数支撑，而不是一次最好值。这套FOPSO-PID流水线跑顺之后，调参不再是玄学，而是可以反复复现的标准化流程，希望帮到你。

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