粒子群优化算法 (PSO):数学原理、Python 实现与变种解析

PSO算法介绍 结合网上的文章对PSO进行一些介绍,并附上自己复现的算法。 阅读详情

目录

1. 引言:从鸟群说起

2. 数学原理

2.1 核心定义

2.2 速度与位置更新公式

3. Python 实现 (向量化版本)

进阶粒子群优化:从理论到自适应变种

1. 变种原理深度解析

A. 策略一:线性递减权重 (LDIW)

B. 策略二:时变加速因子 (TVAC)

C. 策略三:压缩因子 (Constriction Factor)

2. 完整进阶代码实现 (Modular Advanced PSO)

3. 代码与结果分析

运行结果预期

1. 二进制粒子群优化 (Binary PSO, BPSO)

算法步骤

Python 实现代码

2. 量子行为粒子群 (QPSO)

算法步骤

Python 实现代码


1. 引言:从鸟群说起

粒子群优化算法(Particle Swarm Optimization, PSO)是由 Kennedy 和 Eberhart 于 1995 年提出的一种群智能算法。

它的灵感来源于鸟群捕食的行为:一群鸟在随机搜索食物,它们不知道食物在哪里,但它们知道自己当前的位置距离食物有多远,同时也知道整个鸟群中“目前离食物最近的那只鸟”在哪里。

为了找到食物,每只鸟会根据以下三个因素调整自己的飞行速度和方向:

  1. 惯性:保持之前的飞行状态。

  2. 个体认知:飞向自己曾经过的最好位置。

  3. 社会认知:飞向群体目前找到的最好位置。

这种简单的规则涌现出了复杂的群体智能,使得 PSO 成为一种强大的全局优化算法,广泛应用于函数优化、神经网络训练、路径规划等领域。

2. 数学原理

2.1 核心定义

2.2 速度与位置更新公式

3. Python 实现 (向量化版本)

为了提高计算效率,我们不使用循环遍历每个粒子,而是利用 numpy 进行矩阵运算。

import numpy as np

class PSO:
    def __init__(self, func, dim, pop_size=30, max_iter=100, bounds=(-10, 10)):
        """
        :param func: 目标函数 (我们要最小化的函数)
        :param dim: 变量维度
        :param pop_size: 粒子数量
        :param max_iter: 最大迭代次数
        :param bounds: 搜索边界 (min, max)
        """
        self.func = func
        self.dim = dim
        self.pop_size = pop_size
        self.max_iter = max_iter
        self.bounds = bounds
        
        # PSO 参数 (标准建议值)
        self.w = 0.8      # 惯性权重
        self.c1 = 1.5     # 个体学习因子
        self.c2 = 1.5     # 社会学习因子

        # 初始化粒子位置和速度
        self.X = np.random.uniform(bounds[0], bounds[1], (pop_size, dim))
        self.V = np.random.uniform(-1, 1, (pop_size, dim))
        
        # 初始化个体最佳 (pbest)
        self.pbest_X = self.X.copy()
        self.pbest_y = self.func(self.X)
        
        # 初始化全局最佳 (gbest)
        self.gbest_X = np.zeros(dim)
        self.gbest_y = np.inf
        self.update_gbest()
        
        # 记录历代最优值用于绘图
        self.history = []

    def update_gbest(self):
        """更新全局最优解"""
        min_idx = np.argmin(self.pbest_y)
        if self.pbest_y[min_idx] < self.gbest_y:
            self.gbest_y = self.pbest_y[min_idx]
            self.gbest_X = self.pbest_X[min_idx].copy()

    def run(self):
        for t in range(self.max_iter):
            # 生成随机数矩阵
            r1 = np.random.rand(self.pop_size, self.dim)
            r2 = np.random.rand(self.pop_size, self.dim)
            
            # --- 核心公式更新 ---
            # 更新速度
            self.V = (self.w * self.V + 
                      self.c1 * r1 * (self.pbest_X - self.X) + 
                      self.c2 * r2 * (self.gbest_X - self.X))
            
            # 限制速度 (可选,防止粒子飞太快)
            # self.V = np.clip(self.V, -limit, limit)

            # 更新位置
            self.X = self.X + self.V
            
            # 边界处理:防止粒子跑出定义域
            self.X = np.clip(self.X, self.bounds[0], self.bounds[1])
            
            # --- 评估与更新 ---
            # 计算适应度
            y = self.func(self.X)
            
            # 更新个体最佳 pbest
            # 只有当新位置的适应度比原来的小,才更新
            better_mask = y < self.pbest_y
            self.pbest_X[better_mask] = self.X[better_mask]
            self.pbest_y[better_mask] = y[better_mask]
            
            # 更新全局最佳 gbest
            self.update_gbest()
            
            self.history.append(self.gbest_y)
            
        return self.gbest_X, self.gbest_y, self.history

# --- 测试用例 ---
if __name__ == "__main__":
    # 定义 Sphere 函数: f(x) = x1^2 + x2^2 + ...
    def sphere(x):
        return np.sum(x**2, axis=1)

    pso = PSO(func=sphere, dim=10, pop_size=50, max_iter=100)
    best_x, best_y, history = pso.run()
    
    print(f"最优解: {best_x}")
    print(f"最优适应度: {best_y}")

进阶粒子群优化:从理论到自适应变种

在标准 PSO 中,参数 $w, c_1, c_2$ 是固定的。这导致了一个致命缺陷:算法在初期“飞得不够散”(容易陷入局部最优),在后期“收敛不够稳”(在最优解附近震荡无法精确)。

为了解决这个问题,学术界提出了多种变种。我们将重点实现三种最经典且行之有效的改进策略:

  1. LDIW-PSO (Linear Decreasing Inertia Weight): 线性递减惯性权重。

  2. TVAC-PSO (Time-Varying Acceleration Coefficients): 时变加速因子。

  3. CF-PSO (Constriction Factor): 压缩因子法(基于特征值分析)。

1. 变种原理深度解析

A. 策略一:线性递减权重 (LDIW)

B. 策略二:时变加速因子 (TVAC)

C. 策略三:压缩因子 (Constriction Factor)


2. 完整进阶代码实现 (Modular Advanced PSO)

为了方便实验,我编写了一个模块化的类 AdvancedPSO,你可以在实例化时通过 mode 参数自由切换变种。

此外,为了验证变种的有效性,我们使用 Rastrigin 函数。这是一个高度非凸的函数,充满了成千上万个局部陷阱,标准 PSO 很容易挂在这里,而改进版表现会好很多。

Python

import numpy as np
import matplotlib.pyplot as plt

# ==========================================
# 1. 测试函数:Rastrigin Function
# (非常难的函数,有大量局部最优,全局最优在 0)
# ==========================================
def rastrigin(X):
    # f(x) = 10*d + sum(x_i^2 - 10*cos(2*pi*x_i))
    A = 10
    d = X.shape[1]
    return A * d + np.sum(X**2 - A * np.cos(2 * np.pi * X), axis=1)

# ==========================================
# 2. 进阶 PSO 框架
# ==========================================
class AdvancedPSO:
    def __init__(self, func, dim, pop_size=50, max_iter=200, bounds=(-5.12, 5.12), mode='tvac'):
        """
        :param mode: 算法模式 
                     'standard' - 标准 PSO
                     'ldiw'     - 线性递减权重
                     'tvac'     - 时变加速因子 (推荐)
                     'constriction' - 压缩因子法 (Clerc Type 1)
        """
        self.func = func
        self.dim = dim
        self.pop_size = pop_size
        self.max_iter = max_iter
        self.bounds = bounds
        self.mode = mode
        
        # --- 初始化粒子 ---
        self.X = np.random.uniform(bounds[0], bounds[1], (pop_size, dim))
        # 速度初始化通常为搜索范围的 10%-20%
        v_limit = (bounds[1] - bounds[0]) * 0.2
        self.V = np.random.uniform(-v_limit, v_limit, (pop_size, dim))
        
        # --- 历史最佳 ---
        self.pbest_X = self.X.copy()
        self.pbest_y = self.func(self.X)
        
        self.gbest_X = np.zeros(dim)
        self.gbest_y = np.inf
        self.update_gbest()
        
        self.history = [] # 记录收敛曲线

    def update_gbest(self):
        min_idx = np.argmin(self.pbest_y)
        if self.pbest_y[min_idx] < self.gbest_y:
            self.gbest_y = self.pbest_y[min_idx]
            self.gbest_X = self.pbest_X[min_idx].copy()

    def get_parameters(self, t):
        """
        根据当前迭代次数 t 和选择的 mode,动态计算 w, c1, c2
        """
        # 进度比率 (0 -> 1)
        ratio = t / self.max_iter
        
        if self.mode == 'standard':
            return 0.7, 1.5, 1.5
            
        elif self.mode == 'ldiw':
            # w 线性递减: 0.9 -> 0.4
            w = 0.9 - 0.5 * ratio
            return w, 1.5, 1.5
            
        elif self.mode == 'tvac':
            # w 线性递减
            w = 0.9 - 0.5 * ratio
            # c1 (自我) 递减: 2.5 -> 0.5 (初期多探索自己)
            c1 = 2.5 - 2.0 * ratio
            # c2 (社会) 递增: 0.5 -> 2.5 (后期多跟从群体)
            c2 = 0.5 + 2.0 * ratio
            return w, c1, c2
            
        elif self.mode == 'constriction':
            # 压缩因子模式:w 实际上就是 chi (压缩因子)
            # 理论值: phi = 4.1, chi = 0.729
            phi = 2.05 + 2.05
            chi = 2 / np.abs(2 - phi - np.sqrt(phi**2 - 4*phi))
            return chi, 2.05, 2.05
            
        return 0.7, 1.5, 1.5

    def run(self):
        print(f"Starting PSO [Mode: {self.mode}]")
        
        for t in range(self.max_iter):
            # 1. 获取动态参数
            w, c1, c2 = self.get_parameters(t)
            
            # 2. 生成随机数
            r1 = np.random.rand(self.pop_size, self.dim)
            r2 = np.random.rand(self.pop_size, self.dim)
            
            # 3. 更新速度
            # 如果是压缩因子模式,公式略有不同 (乘在最外面)
            if self.mode == 'constriction':
                self.V = w * (self.V + 
                              c1 * r1 * (self.pbest_X - self.X) + 
                              c2 * r2 * (self.gbest_X - self.X))
            else:
                self.V = (w * self.V + 
                          c1 * r1 * (self.pbest_X - self.X) + 
                          c2 * r2 * (self.gbest_X - self.X))
            
            # 4. 更新位置
            self.X = self.X + self.V
            
            # 边界处理 (Clip)
            self.X = np.clip(self.X, self.bounds[0], self.bounds[1])
            
            # 5. 计算适应度
            y = self.func(self.X)
            
            # 6. 更新 Pbest
            better_mask = y < self.pbest_y
            self.pbest_X[better_mask] = self.X[better_mask]
            self.pbest_y[better_mask] = y[better_mask]
            
            # 7. 更新 Gbest
            self.update_gbest()
            self.history.append(self.gbest_y)
            
        return self.gbest_y, self.history

# ==========================================
# 3. 对比实验与绘图
# ==========================================
if __name__ == "__main__":
    # 实验设置
    DIM = 30           # 30维 Rastrigin 问题 (很难!)
    POP = 50
    ITER = 500
    
    # 运行三种不同模式进行对比
    modes = ['standard', 'ldiw', 'tvac', 'constriction']
    results = {}
    
    plt.figure(figsize=(10, 6))
    
    for mode in modes:
        # 为了公平,每种模式运行 10 次取平均,减少随机性影响
        avg_history = np.zeros(ITER)
        runs = 10
        
        print(f"\nTesting {mode}...")
        for _ in range(runs):
            optimizer = AdvancedPSO(rastrigin, DIM, POP, ITER, bounds=(-5.12, 5.12), mode=mode)
            _, hist = optimizer.run()
            avg_history += np.array(hist)
            
        avg_history /= runs
        results[mode] = avg_history[-1]
        
        # 绘图
        plt.plot(avg_history, label=f"{mode} (Final: {avg_history[-1]:.2e})")

    plt.title(f'Comparison of PSO Variants on {DIM}-D Rastrigin Function')
    plt.xlabel('Iteration')
    plt.ylabel('Fitness (Log Scale)')
    plt.yscale('log')
    plt.legend()
    plt.grid(True, which="both", ls="-", alpha=0.5)
    plt.show()

    # 打印最终对比
    print("\n=== Final Results (Lower is Better) ===")
    for m, res in results.items():
        print(f"{m.ljust(15)}: {res:.10f}")

3. 代码与结果分析

运行结果预期

当你运行这段代码时,你会清楚地看到不同变种的性能差异(特别是在 30 维 Rastrigin 这种复杂函数上):

  1. Standard (标准版):

    • 通常表现最差。曲线下降一段后会变成一条水平线。这说明粒子群**“早熟”**了,它们过早地聚集在了一个局部坑里,再也跳不出来了。

  2. LDIW (线性递减权重):

    • 表现优于标准版。曲线下降得更深,说明它在后期进行了更精细的搜索,但可能仍然无法跳出深层的局部最优。

  3. TVAC (时变加速因子):

  4. Constriction (压缩因子):

    • 表现非常稳定,收敛速度通常很快,属于“性价比”极高的选择,不需要复杂的参数调整。

二进制粒子群优化 (Binary PSO, BPSO)

应用场景:用于离散问题,如特征选择、背包问题、任务分配(解只能是 0 或 1)。

算法步骤

Python 实现代码
import numpy as np

class BinaryPSO:
    def __init__(self, func, dim, pop_size=30, max_iter=100):
        self.func = func
        self.dim = dim
        self.pop_size = pop_size
        self.max_iter = max_iter
        
        # 初始化位置 (0 或 1)
        self.X = np.random.randint(2, size=(pop_size, dim))
        # 初始化速度
        self.V = np.random.uniform(-1, 1, (pop_size, dim))
        
        # 初始化极值
        self.pbest_X = self.X.copy()
        self.pbest_score = self.func(self.X)
        
        self.gbest_X = self.pbest_X[np.argmin(self.pbest_score)].copy()
        self.gbest_score = np.min(self.pbest_score)
        
        # Sigmoid 函数
        self.sigmoid = lambda x: 1 / (1 + np.exp(-x))

    def run(self):
        print("Starting BPSO...")
        for t in range(self.max_iter):
            # 1. 计算速度 (标准公式)
            r1, r2 = np.random.rand(2)
            self.V = (self.V + 
                      1.5 * r1 * (self.pbest_X - self.X) + 
                      1.5 * r2 * (self.gbest_X - self.X))
            
            # 2. 速度映射为概率 (Sigmoid)
            prob = self.sigmoid(self.V)
            
            # 3. 位置更新 (根据概率决定是 0 还是 1)
            # 生成随机矩阵,如果 rand < prob,则设为 1,否则 0
            rand_matrix = np.random.rand(self.pop_size, self.dim)
            self.X = (rand_matrix < prob).astype(int)
            
            # 4. 计算适应度
            scores = self.func(self.X)
            
            # 5. 更新 pbest
            better_mask = scores < self.pbest_score
            self.pbest_X[better_mask] = self.X[better_mask]
            self.pbest_score[better_mask] = scores[better_mask]
            
            # 6. 更新 gbest
            current_best_val = np.min(self.pbest_score)
            if current_best_val < self.gbest_score:
                self.gbest_score = current_best_val
                self.gbest_X = self.pbest_X[np.argmin(self.pbest_score)].copy()
                
            print(f"Iter {t}: Best Score = {self.gbest_score}")

# --- 测试用例 (OneMax 问题: 让所有位都变成 1) ---
# 目标函数:返回 0 的个数 (越少越好)
def objective_function(x):
    # x 是 0/1 矩阵,我们希望 1 越多越好,所以最小化 (dim - sum)
    return x.shape[1] - np.sum(x, axis=1)

if __name__ == "__main__":
    bpso = BinaryPSO(objective_function, dim=20, pop_size=30, max_iter=50)
    bpso.run()

量子行为粒子群 (QPSO)

应用场景:这是一种现代变种。它完全抛弃了“速度”向量,认为粒子具有量子行为,出现在某一点是概率性的。它的参数更少,收敛能力通常强于标准 PSO。

算法步骤
  1. 计算平均最优位置 (mbest):计算群体中所有粒子个体历史最优位置 (pbest) 的平均值。

  2. 计算局部吸引点 (attractor):对于每个粒子,在它的 pbest 和群体的 gbest 之间随机找一个点作为吸引点。

  3. 位置更新:根据量子力学的波函数推导,位置由吸引点、平均最优位置和一个收缩扩张系数 (alpha) 决定。粒子直接“瞬移”到新位置。

Python 实现代码
import numpy as np

class QPSO:
    def __init__(self, func, dim, pop_size=30, max_iter=100, bounds=(-10, 10)):
        self.func = func
        self.dim = dim
        self.pop_size = pop_size
        self.max_iter = max_iter
        self.bounds = bounds
        
        self.X = np.random.uniform(bounds[0], bounds[1], (pop_size, dim))
        
        # QPSO 没有速度 V
        
        self.pbest_X = self.X.copy()
        self.pbest_score = self.func(self.X)
        
        self.gbest_X = self.pbest_X[np.argmin(self.pbest_score)].copy()
        self.gbest_score = np.min(self.pbest_score)

    def run(self):
        print("Starting QPSO...")
        for t in range(self.max_iter):
            # Alpha: 收缩扩张系数,通常从 1.0 线性递减到 0.5
            alpha = 1.0 - 0.5 * (t / self.max_iter)
            
            # 1. 计算 mbest (Mean Best Position)
            # 所有 pbest 的中心点
            mbest = np.mean(self.pbest_X, axis=0)
            
            # 2. 更新每个粒子的位置
            # 生成随机数 phi, u
            phi = np.random.rand(self.pop_size, self.dim)
            u = np.random.rand(self.pop_size, self.dim)
            
            # 计算局部吸引点 p
            # p = phi * pbest + (1-phi) * gbest
            p = phi * self.pbest_X + (1 - phi) * self.gbest_X
            
            # 核心更新公式 (根据 u > 0.5 分正负)
            # X = p +/- alpha * |mbest - X| * ln(1/u)
            sign = np.where(np.random.rand(self.pop_size, self.dim) > 0.5, 1, -1)
            
            self.X = p + sign * alpha * np.abs(mbest - self.X) * np.log(1 / u)
            
            # 边界处理
            self.X = np.clip(self.X, self.bounds[0], self.bounds[1])
            
            # 3. 更新极值 (同标准 PSO)
            scores = self.func(self.X)
            better_mask = scores < self.pbest_score
            self.pbest_X[better_mask] = self.X[better_mask]
            self.pbest_score[better_mask] = scores[better_mask]
            
            min_val = np.min(self.pbest_score)
            if min_val < self.gbest_score:
                self.gbest_score = min_val
                self.gbest_X = self.pbest_X[np.argmin(self.pbest_score)].copy()
                
            if t % 10 == 0:
                print(f"Iter {t}: Best Score = {self.gbest_score:.6f}")

# --- 测试用例 (Sphere 函数) ---
def sphere(x):
    return np.sum(x**2, axis=1)

if __name__ == "__main__":
    qpso = QPSO(sphere, dim=10, pop_size=40, max_iter=100)
    qpso.run()
数学建模——粒子群算法(PSO) 数学建模——粒子群算法(POS)一、粒子群优化算法概述PSO算法步骤PSO(粒子群优化算法)与GA(遗传算法)对比粒子群算法优点PSO的MATLAB实现 推荐博客: https://www.cnblogs.com/Qling/p/9343625.html https://blog.youkuaiyun.com/lyxleft/article/details/82978362 一、粒子群优化算法概述 粒子群优化(PSO, particle swarm optimization)算法是计算智能领域,除了蚁群算法,鱼群算法之 阅读详情

相关推荐

Python 实现粒子群算法(PSO)

粒子群算法

Elford的博客 6954

最优化算法之粒子群算法(PSO)

一、粒子群算法的概念   粒子群优化算法(PSO:Particle swarm optimization) 是一种进化计算技术(evolutionary computation)。源于对鸟群捕食的行为研究。粒子群优化算法的基本思想:是通过群体中个体之间的协作和信息共享来寻找最优解.   PSO的优势:在于简单容易实现并且没有许多参数的调节。目前已被广泛应用于函数优化、神经网络训练、模糊系统控制...

青萍之末的博客 45万+

高频电磁场仿真-主题063-粒子群优化与电磁设计

参数选择策略种群规模:通常20-50个粒子惯性权重:0.4-0.9,建议线性递减学习因子:c1 = c2 = 1.5-2.0迭代次数:100-500次,视问题复杂度而定适应度函数设计明确优化目标(增益、带宽、S参数等)合理设置权重系数添加必要的约束条件考虑多目标优化需求边界处理根据物理意义选择合适的边界策略吸收边界适用于大多数电磁设计问题反射边界可保持种群多样性算法改进自适应参数调整提高收敛性能混沌初始化增强全局搜索能力混合策略结合局部搜索精细优化。

kkchenjj的博客 399

PSO算法

粒子群算法(Particle Swarm Optimization,简称PSO)是一种优化算法,模拟了鸟群或鱼群等群体生物行为的优化思想。

Super algorithm 的博客,技术爱好者。 4807

PyTorch实战:用FGSM攻击MNIST分类器(附可视化对比)

本文通过PyTorch实战演示了如何使用FGSM对抗攻击方法攻击MNIST手写数字分类器。文章详细解析了FGSM攻击原理,提供了从环境搭建、模型准备到攻击实施、可视化对比的完整代码实战流程,并探讨了对抗样本的生成与模型鲁棒性评估。

3a9bq4r8t2y的博客 216

python提取图片中的文字写入excel文件,并打包为exe可执行文件

python提取图片中的文字写入excel文件,并打包为exe可执行文件

liqiang12689的博客 989

粒子群优化算法(PSO)从原理到实战:参数整定与工程应用

在工程优化与机器学习调参中,面对非凸、离散甚至无解析表达式的目标函数,传统梯度方法往往束手无策。群体智能作为一种模拟自然生物行为的随机优化技术,为这类黑箱问题提供了高效可靠的求解思路。粒子群优化算法(PSO)通过个体经验与社会信息共享,在搜索空间中实现探索与开发的动态平衡,其核心的速度-位置更新公式和惯性权重策略,既保证了全局搜索能力,又能精细收敛。PSO对目标函数几乎无假设,天然支持并行化,因此被广泛用于PID参数整定、模型超参数搜索、路径规划等复杂场景。本文从算法数学原理出发,给出完整Python实现与

weixin_29224309的博客 281

一个固定翼飞机仿真程序带你系统性上手如何实现配平(工具箱+脚本)

老规矩,该博客所用的模型和脚本已上传至百度网盘,名字为“固定翼配平训练例子”,自己自取。

zouxu634866的博客 2575

群体智能优化:粒子群算法(PSO)详解与实战

粒子群算法以其简洁的数学模型和高效的优化能力,成为解决复杂非线性问题的利器。本文从生物启发的角度剖析了算法本质,提供了可直接复用的Python代码,并探讨了进阶改进策略。在实际应用中,建议结合具体问题特点调整算法参数,必要时可与其他优化算法融合。资源推荐:1. 《Swarm Intelligence》James Kennedy 著2. PSO官方代码库:https://pyswarms.readthedocs.io3. IEEE PSO相关论文合集。

djq_123的博客 2612

OCC入门指南:从零开始掌握Open CASCADE Technology

本文是Open CASCADE Technology(OCC)的入门指南,详细介绍了这款开源C++三维几何建模内核的核心概念与价值。内容涵盖从零开始搭建开发环境、编写第一个显示立方体的程序,到深入理解其几何与拓扑核心、掌握Draw测试工具及Handle内存管理等关键编程范式,旨在帮助开发者快速掌握这一工业级CAD/CAE/CAM应用开发利器。

java5的博客 1276

【MATLAB-app】系列教程(含视频)第4、5、6课:实战_制作简单的图像处理软件

写作时间: 2020-12-27 我的教程目录 第1课:初步了解appdesigner 第2课:学会制作一个计算器 第3课:学习更多的控件(重点!) 第4课:实例1:制作一个图像处理软件 第5课:学习APPdesigner的设计精髓,框架 第6课:结合使用多种控件,函数等,丰富我们的实例1 第7课:app设计打包,完成工程应用导出 标题: 第4课:我的实例_学会制作一个图像处理软件 本文目录: 1.先看看我之前的一个工程 2.常用的基本组件控件 3.最常用且实用的控件的用法 -3.1 editfilel

wind 4055

Python实现粒子群算法:从原理到数学建模实战

优化算法是解决复杂工程与科学问题的核心技术,它通过迭代搜索寻找目标函数的最优解。粒子群优化算法作为一种经典的群体智能算法,其原理模拟了鸟群觅食的社会行为,每个粒子代表一个候选解,通过个体经验与群体信息的结合来更新位置,逐步逼近全局最优。该算法不依赖梯度信息,对函数性质要求宽松,具备良好的并行性和全局搜索能力,在参数调优、路径规划、函数拟合等场景中价值显著。本文以Python实现为核心,深入解析了粒子群算法的数学模型、参数调优策略及在数学建模中的实战应用,并针对Rastrigin函数测试和资源分配优化等案例,

weixin_34248487的博客 444

SAP Gateway 中事务码 /IWFND/MAINT_SERVICE 的用法介绍

本文系统梳理了SAP Gateway中/IWFND/MAINT_SERVICE事务码的核心功能与运维实践。作为OData服务管理中樞,它支持服务注册激活、ICF节点配置、系统别名绑定、批量处理等关键操作。文章详解了服务目录、ICF节点、系统别名的配置要点,提供了批量激活、缓存清理、性能监控等实用技巧,并针对常见陷阱(如传输配置、删除残留)给出解决方案。通过制造业批量激活、零售业OAuth集成等案例,展示了事务码在企业级应用中的实际价值,为SAP Gateway运维提供了一套完整的治理清单。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 314

Shapiro-Wilk检验:原理、应用与实现

函数可以轻松实现Shapiro-Wilk检验,结合Matplotlib等可视化工具,可以全面评估数据的分布特性,为统计分析和方法选择提供科学依据。Shapiro和Wilk在其原始论文中提供了样本量在2-50范围内的系数值表。Shapiro-Wilk检验由Samuel Shapiro和Martin Wilk于1965年在。这些改进使得Shapiro-Wilk检验能够有效地应用于更大样本量的情况,同时保持了检验的功效。随着算法的改进和计算能力的提升,Shapiro-Wilk检验的应用范围已扩展至。

拒绝AI玄学,只聊真技术▲ 4525

使用 Visual Studio Code 搭建 SAP UI5 本地开发环境

工欲善其事,必先利其器。时至今日,SAP 提供了非常多的 SAP UI5 开发工具,既包含本地搭建的,也包含浏览器里远端使用的工具,比如 WebIDE 和 Business Application Studio. 我们访问下面这个链接,就能找到所有这些工具的安装或者配置步骤: https://tools.hana.ondemand.com/#sapui5 如果想选择本地开发,SAP 推荐的工具是 Visual Studio Code,也就是本文要介绍的内容。 也可以下载 WebIDE 的本地安装包,将其安

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1万+

手把手教你学Simulink——无刷直流电机(BLDC)霍尔传感器(Hall Sensor)信号处理电路仿真

在中,转子位置靠​ 给出,换相逻辑(Commutation Table)据此决定。实际霍尔输出是,且常有:比较迟滞(内置或外加分压)RC 低通(防 EMI 尖刺)与 MCU 间想让你霍尔三相 UVW 理想方波(120° each, 换相每 60°elec)经观察:原始 HU/HV/HW、滤波后波形、整形后 TTL 电平验证换相表(001→100→010…)与转子转向匹配是破局关键。

amy_mhd的博客 39

Python实战:用粒子群算法优化函数最小值(附完整代码)

本文详细解析了如何用Python实现粒子群算法(PSO)优化函数最小值。通过模拟鸟群觅食的群体智能行为,PSO算法能有效解决复杂非凸函数优化问题。文章提供了从原理讲解、完整代码实现到参数调优与实战技巧的全流程指南,并对比了遗传算法等其他群智能算法的特点,帮助开发者快速掌握这一强大的优化工具。

weixin_29171087的博客 439

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

t检验(t-test):统计学中的显著性检验方法

由于酿酒原料(大麦)的变异性和小样本数据的限制,他需要一种适用于小样本的统计推断方法。但在小样本情况下,t分布比正态分布有更厚的尾部,这为小样本推断提供了更保守的检验。通过Python中的SciPy库,我们可以方便地进行各种类型的t检验和结果可视化。戈塞特发现,当样本量较小时,样本均值的标准化统计量不再服从标准正态分布,而是服从一种新的分布——是t检验的理论基础,它是一种对称的钟形分布,类似于正态分布但尾部更厚。(标准误)进行比较。配对样本t检验实际上是对差值进行单样本t检验,检验差值的均值是否为零。

拒绝AI玄学,只聊真技术▲ 4960

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

支持向量机与粒子群优化结合的短期电力负荷预测方案

在电力系统运行中,准确预测未来数小时至数日的负荷曲线,是电网调度、现货交易与安全分析的关键基础。机器学习回归方法为解决此类时序预测问题提供了新的技术路径,其中支持向量机(SVR)凭借其小样本学习与非线性拟合优势,在负荷预测中表现出色。然而,SVR的预测精度高度依赖惩罚系数、核带宽和不敏感损失系数等参数的设定,手动调参难以取得全局最优解。粒子群优化算法(PSO)通过对参数空间进行智能化搜索,能够自动获取最优参数组合,显著提升模型精度。该方法在区域电网负荷数据上的实验表明,MAPE可降至3%以内,且对季节变化和

weixin_29055137的博客 298

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

GPT-5 mini赋能MATLAB Copilot:架构设计与高精度代码生成实践

大语言模型(LLM)通过理解自然语言指令生成代码,正深刻改变着编程范式。其核心原理在于基于海量代码和文本数据训练出的强大模式识别与生成能力。这项技术的价值在于能够将开发者的意图快速转化为可执行代码,极大提升开发效率,尤其在算法原型验证、数据分析和自动化脚本编写等场景中优势明显。本文聚焦于如何将GPT-5 mini这一轻量高效的模型,与MATLAB Copilot这一专业科学计算工具深度结合。通过设计智能代理层进行查询路由与上下文增强,并运用提示工程与RAG(检索增强生成)技术,我们旨在解决通用模型在特定垂直

读书、思考、生活 495

粒子群算法(PSO)

PSO

Люй ли的博客 7739

Python之粒子群算法(含代码实例)

Python粒子群算法(含代码实例)

m0_60307882的博客 3万+

粒子群优化算法(PSO)

粒子群优化算法(PSO) 粒子群优化算法(PSO)是一种进化计算技术,源于对鸟群捕食行为的研究。该算法最初是受到飞鸟集群活动的规律性启发,进而利用群体智能建立的一个简化模型。粒子群算法在对动物及群活动行为观察的基础上,利用群体中的个体对信息的共享使整个群体的运动在问题求解空间中产生从无序到有序的演化过程,从而获得最优解。 什么是粒子群算法 官方说法 粒子群算法,也称粒子群优化算法或鸟群觅食算法,缩写为PSO,是一种新的进化算法。PSO算法属于进化算法中的一种,和模拟退火算法相似,它也是从随机解出发,通过迭代

m0_61735754的博客 4万+

智能优化算法之粒子群优化算法(Particle Swarm Optimization, PSO)

粒子群优化算法是一种基于群体智能的优化算法,通过模拟生物群体的行为来实现全局最优解的搜索。其简单易实现、全局搜索能力强等特点使得它在许多领域都得到了广泛的应用。

北_鱼的博客 1947

PSO——粒子群优化算法

粒子群优化(Particle Swarm Optimization, PSO)是一种基于群体智能的优化算法,灵感来自鸟群或鱼群的觅食行为。PSO通过在多维搜索空间中移动一组“粒子”(代表潜在解)来找到最优解。每个粒子都有自己的位置和速度,逐步向最佳解靠近。PSO算法常用于求解复杂的优化问题,具有全局搜索能力和计算效率较高的特点。

qq_56683019的博客 3644

智能优化之粒子群算法(PSO)(Matlab,python,C++实现)

智能优化算法pso

weixin_52732185的博客 5604
上一篇: 用一段 JS 脚本让 ChatGPT 自动帮你写论文
下一篇: 状态空间模型及其在高分辨距离像识别中的应用 绪论部分
VectorShift
博客等级 码龄1年 1844粉丝 1109原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

VectorShift

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值