基于P系统的粒子群优化算法

PSO粒子群算法一般过程PSO（Particle Swarm Optimization）粒子群算法是一种模拟鸟类群体行为的优化算法，常用于求解优化问题。

它基于一组粒子通过相互合作，通过不断更新自身位置和速度来寻找最优解。

下面是PSO算法的一般过程：1.初始化粒子群：a.设定粒子群的规模和每个粒子的初始位置和速度。

b.初始化每个粒子的历史最佳位置和目标函数值。

2.迭代更新：a.对于每个粒子p：-计算适应度函数值，即粒子的目标函数值。

-如果当前适应度值优于历史最佳适应度值，则更新粒子的历史最佳位置和目标函数值。

b.对于每个粒子p：-更新粒子的速度和位置。

-根据适应度函数的值，如果当前位置优于全局最佳位置，则更新全局最佳位置。

3.终止条件：a.当达到预设迭代次数时，或者粒子群的目标函数值收敛到可接受范围内时，停止迭代。

上述过程中涉及到一些关键的参数和操作：-粒子个体最佳位置：代表粒子个体在过程中找到的最优解，该信息被保存在每个粒子中，以便于后续的比较。

-全局最佳位置：代表整个粒子群在过程中找到的最优解，该信息被保存在整个粒子群中，以便于影响粒子的更新。

-适应度函数：用于评价粒子位置的优劣程度，即目标函数值。

根据具体问题的不同，适应度函数也会有所区别。

-速度更新：根据粒子当前位置和历史最佳位置，以及全局最佳位置，利用一定的权重计算粒子的新速度。

新速度的计算可以考虑粒子的动量（上一次速度的影响）和认知因子（个体历史最佳位置的引导）以及社会因子（全局最佳位置的引导）的影响。

-位置更新：根据粒子的新速度，更新粒子的位置。

位置的更新通常是与速度相关的，通过计算当前位置加上速度乘以时间步长得到。

PSO粒子群算法的基本思想是通过模拟群体中个体的协作和学习来找到最优解。

比较之前的遗传算法和蚁群算法，PSO算法更加注重群体的整体性和号召力，通过全局最佳位置的引导来使得个体更好地进行。

通过数值模拟的方式，可以更好地理解和实践PSO算法，应用于各种求解优化问题的场景中。

第6章粒子群优化算法PSO算法的基本原理是通过模拟粒子在空间中的移动，从而找到最优解。

每个粒子代表一个可能的解，并根据自身的经验和群体的经验进行。

粒子的速度和位置的更新使用以下公式：v(t+1) = w * v(t) + c1 * rand( * (pbest - x(t)) + c2 *rand( * (gbest - x(t))x(t+1)=x(t)+v(t+1)其中，v(t)代表粒子的当前速度，x(t)代表粒子的当前位置，w是惯性权重，c1和c2是学习因子，rand(是一个0到1之间的随机数，pbest 是粒子自身的最佳位置，gbest是整个群体的最佳位置。

PSO算法的过程如下：1.初始化粒子的位置和速度。

2.计算每个粒子的适应度值。

3. 更新每个粒子的pbest和gbest。

4.根据公式更新每个粒子的速度和位置。

5.重复步骤2到4，直到达到终止条件。

PSO算法有几个重要的参数需要设置：-群体大小：确定PSO算法中粒子的数量。

较大的群体大小可以增加整个空间的探索能力，但也增加了计算复杂度。

-惯性权重：控制粒子速度变化的因素。

较大的惯性权重可以增加粒子的飞行距离，但可能导致过程陷入局部最优解。

-学习因子：用于调节个体经验和群体经验的权重。

c1用于调节个体经验的权重，c2用于调节群体经验的权重。

较大的学习因子可以增加粒子的探索能力，但也可能增加时间。

PSO算法的优点是简单、易实现，收敛速度较快，对于多维、非线性、离散等问题具有良好的适应性。

然而，PSO算法也存在一些缺点，如易陷入局部最优解、对参数的敏感性等。

总之，粒子群优化算法是一种基于群体智能的优化算法，在求解复杂问题方面具有出色的性能。

它的基本原理是通过模拟粒子的移动来最优解，利用个体经验和群体经验进行自适应。

PSO算法在多个领域都有成功的应用，可以帮助解决实际问题。

基于粒子群优化与高斯过程的协同优化算法1. 引言协同优化算法是一种结合多种优化算法的集成优化方法，通过合理的组合和协同，克服单一算法在优化问题上的局限性，提高优化效果。

本文将介绍一种基于粒子群优化和高斯过程的协同优化算法，通过利用粒子群算法的全局搜索特性和高斯过程的回归能力，实现更精确、高效的优化过程。

2. 粒子群优化算法粒子群优化算法（Particle Swarm Optimization, PSO）是一种模拟鸟群飞行行为的优化算法，通过模拟粒子在解空间的搜索和迭代过程，寻找最优解。

其基本原理是每个粒子通过跟踪自身历史最佳解（pbest）和整个种群的最佳解（gbest），根据经验和全局信息进行位置调整和速度更新，直到达到最优解或迭代次数达到设定值。

3. 高斯过程高斯过程（Gaussian Process）是一种常用的非参数模型，用于回归和分类问题。

它基于贝叶斯思想，通过对样本数据进行分析和建模，得到一个关于未知函数的概率分布。

高斯过程的主要特点是可以根据已有数据进行预测，同时给出了预测结果的不确定性。

4. 算法设计基于粒子群优化和高斯过程的协同优化算法将PSO和高斯过程相结合，通过以下步骤实现优化过程：4.1 初始化设定粒子的位置和速度的初始值，设定高斯过程的初始参数，设定迭代次数和停止条件。

4.2 粒子群优化利用PSO算法进行全局搜索，更新粒子的位置和速度，根据目标函数的值更新粒子的pbest和gbest。

4.3 高斯过程拟合根据粒子的位置和目标函数的值，使用高斯过程拟合出函数的概率分布，并获取每个位置处的函数均值和方差。

4.4 选择下一个位置根据粒子的速度和上一步得到的高斯过程拟合结果，选择下一个位置。

4.5 更新参数根据新的位置和目标函数的值更新高斯过程的参数。

4.6 终止条件判断判断是否达到设定的迭代次数或满足停止条件，若满足则终止优化过程，否则返回步骤4.2。

5. 算法优势基于粒子群优化和高斯过程的协同优化算法具有以下优势：5.1 全局搜索能力强通过引入粒子群优化算法，可以实现全局搜索，寻找到更接近最优解的位置。

粒子群优化算法python粒子群优化算法（Particle Swarm Optimization，简称PSO）是一种基于群体智能的优化算法，它模拟了鸟群觅食行为，通过不断更新粒子的位置和速度，来寻找最优解。

在本文中，我们将介绍粒子群优化算法的原理及其在Python中的实现。

一、粒子群优化算法原理粒子群优化算法的核心思想是通过模拟鸟群觅食行为来进行优化。

算法中的每个粒子都代表了搜索空间中的一个解，而粒子的位置和速度则代表了解的状态和搜索方向。

在算法开始时，每个粒子都会被随机初始化，并赋予一个随机的速度。

接着，粒子会根据自身当前位置和速度，以及全局最优解和个体最优解的信息，来更新自己的速度和位置。

粒子群优化算法中的速度更新公式如下所示：v(t+1) = w * v(t) + c1 * r1 * (pbest - x(t)) + c2 * r2 * (gbest - x(t))其中，v(t+1)表示粒子在下一时刻的速度，w是惯性权重，c1和c2分别是加速因子，r1和r2是[0,1]之间的随机数，pbest表示粒子的个体最优解，gbest表示全局最优解，x(t)表示粒子的当前位置。

粒子的位置更新公式如下所示：x(t+1) = x(t) + v(t+1)其中，x(t+1)表示粒子在下一时刻的位置，x(t)表示粒子的当前位置，v(t+1)表示粒子在下一时刻的速度。

通过不断迭代更新粒子的位置和速度，粒子群优化算法能够逐渐收敛到全局最优解。

二、粒子群优化算法的Python实现在Python中，我们可以使用numpy库来进行粒子群优化算法的实现。

下面是一个简单的示例代码：```pythonimport numpy as npdef objective_function(x):# 定义目标函数，这里以Rosenbrock函数为例return (1 - x[0])**2 + 100 * (x[1] - x[0]**2)**2def PSO(objective_function, num_particles, num_dimensions, max_iter):# 初始化粒子群particles = np.random.uniform(low=-5, high=5, size=(num_particles, num_dimensions))velocities = np.zeros((num_particles, num_dimensions))pbest = particles.copy()gbest = particles[np.argmin([objective_function(p) for p in particles])]# 设置参数w = 0.5c1 = 1c2 = 1# 迭代更新粒子位置和速度for _ in range(max_iter):for i in range(num_particles):r1 = np.random.uniform()r2 = np.random.uniform()velocities[i] = w * velocities[i] + c1 * r1 * (pbest[i] - particles[i]) + c2 * r2 * (gbest - particles[i])particles[i] = particles[i] + velocities[i]if objective_function(particles[i]) < objective_function(pbest[i]):pbest[i] = particles[i]if objective_function(pbest[i]) < objective_function(gbest):gbest = pbest[i]return gbest# 使用粒子群优化算法求解目标函数的最小值gbest = PSO(objective_function, num_particles=30, num_dimensions=2, max_iter=100)print("最优解：", gbest)print("最优解对应的目标函数值：", objective_function(gbest))```在上述代码中，我们首先定义了一个目标函数`objective_function`，这里以Rosenbrock函数为例。

粒子群优化算法基本原理粒子群优化算法（Particle Swarm Optimization，简称PSO）是一种基于仿生学思想的优化算法，最早由美国加州大学洛杉矶分校（University of California, Los Angeles）的Eberhart和Kennedy于1995年提出。

该算法模拟了群体中个体之间的协作行为，通过不断的信息交流与迭代搜索，寻找最优解。

粒子群优化算法的基本思想是通过模拟鸟群或鱼群等生物群体在搜索空间中的行为，通过个体间的合作与信息共享来寻找最优解。

算法的核心是通过不断更新每个粒子的速度和位置，使其朝着全局最优解的方向进行搜索。

在粒子群优化算法中，每个粒子代表一个解决方案，并通过在搜索空间中移动来寻找最优解。

每个粒子都有一个位置向量和一个速度向量，位置向量表示当前粒子所在的位置，速度向量表示粒子在搜索空间中的移动方向和速度。

每个粒子还有两个重要的参数：个体最佳位置（Pbest）和全局最佳位置（Gbest）。

个体最佳位置表示粒子自身经历的最优位置，全局最佳位置表示整个粒子群中最优的位置。

算法的具体过程如下：1. 初始化粒子群的位置和速度，并为每个粒子设置初始的个体最佳位置。

2. 根据当前位置和速度更新粒子的位置和速度，并计算粒子的适应度值。

3. 更新粒子的个体最佳位置和全局最佳位置。

如果当前适应度值优于个体最佳适应度值，则更新个体最佳位置；如果当前适应度值优于全局最佳适应度值，则更新全局最佳位置。

4. 判断终止条件，如果满足停止条件，则输出全局最佳位置作为最优解；否则返回步骤2进行下一轮迭代。

5. 结束。

粒子群优化算法的优点在于简单易实现，不需要求导等额外计算，且具有全局搜索能力。

由于模拟了群体协作的行为，粒子群优化算法可以克服遗传算法等局部搜索算法容易陷入局部最优解的问题。

此外，算法的收敛速度较快，迭代次数相对较少。

然而，粒子群优化算法也存在一些缺点。

首先，算法对于问题的解空间分布较为敏感，如果解空间分布较为复杂或存在多个局部最优解，算法可能无法找到全局最优解。

pso算法matlab代码粒子群优化算法（Particle Swarm Optimization，PSO）是一种基于群体智能的优化算法，其基本思想是通过模拟鸟群觅食行为来寻找最优解。

以下是一个简单的 MATLAB 代码示例，用于实现 PSO 算法：matlab复制代码% 定义问题参数n_particles = 100; % 粒子数量n_iterations = 100; % 迭代次数n_dimensions = 2; % 问题的维度lb = [-10-10]; % 问题的下界ub = [1010]; % 问题的上界c1 = 2; % 个体学习因子c2 = 2; % 社会学习因子% 初始化粒子群particles = lb + (ub-lb).*rand(n_particles,n_dimensions);velocities = zeros(n_particles, n_dimensions);p_best = particles;g_best = particles(1, :);g_best_fitness = inf;% 主循环for i = 1:n_iterations% 计算每个粒子的适应度值fitness = evaluate(particles); % 更新个体最优解for j = 1:n_particlesif fitness(j) < p_best(j, :)p_best(j, :) = particles(j, :); endend% 更新全局最优解for j = 1:n_particlesif fitness(j) < g_best_fitness g_best_fitness = fitness(j);g_best = particles(j, :);endend% 更新粒子速度和位置for j = 1:n_particlesr1 = rand(); % 个体学习因子随机数r2 = rand(); % 社会学习因子随机数velocities(j, :) = velocities(j, :) +c1*r1*(p_best(j, :) - particles(j, :)) + c2*r2*(g_best - particles(j, :));particles(j, :) = particles(j, :) + velocities(j, :);% 边界条件处理particles(j, :) = max(particles(j, :) , lb);particles(j, :) = min(particles(j, :) , ub);endend% 输出结果disp('全局最优解：');disp(g_best);disp('全局最优解的适应度值：');disp(g_best_fitness);其中，evaluate函数用于计算每个粒子的适应度值，需要根据具体问题进行定义。

2021年$月计算机工程与设计Mar.2021第42卷第$期COMPUTER ENGINEERING AND DESIGN Vol.42No.$基于RMSprop的粒子群优化算法张天泽，李元香+,项正龙，李梦莹（武汉大学计算机学院，湖北武汉430072）摘要：粒子群算法对所有粒子采用相同的惯性权重，忽视了单个粒子的特性，导致收敛精度偏低且易陷入局部最优。

结合RMSprop算法中对每一个维度进行自适应设置的策略，提出一种自适应惯性权重粒子群优化算法RMSPSO。

考虑粒子每一个维度的速度变化及动量，进行自适应动态惯性权重设置，使算法在全局寻优和局部寻优之间达到良好平衡。

选取10个典型测试函数，将改进后的粒子群算法（RMSPSO）与4个主流粒子群算法进行实验对比分析，实验结果表明，在单峰、多峰和组合函数上，RMSPSO算法在收敛速度和收敛精度上取得了明显进步&关键词：粒子群算法；RMSprop算法；自适应；梯度下降；惯性权重中图法分类号：TP301文献标识号：A文章编号：1000-7024（2021）03-0642-07doi：10.16208/j.issnl000-7024.2021.0$.007Particle swarm optimization algorithm based on RMSprop method ZHANG Tian-ze,LI Yuan-xiang+&XIANG Zheng-long,LI Meng-ying(School of Computer Science&Wuhan University&Wuhan430072&China)Abstract：For the particle swarm optimization(PSO)algorithm&the same inertia weight is adopted for all particles and the cha-racteristicsofsingleparticleareignored,resultinginlowconvergenceaccuracyandeasinesstofa l intolocaloptimum6Combined with the strategy of setting each dimension adaptively in RMSprop algorithm&an adaptive inertia weight particle swarm optimiza­tion algorithm RMSPSO was proposed6Considering the velocity and momentum of each dimension of particles,the adaptive dynamicinertiaweightwasset,whichmadethealgorithmachieveagoodbalancebetweenglobaloptimizationandlocaloptimiza-tion6Ten typical test functions were selected and the improved particle swarm optimization(RMSPSO)wascomparedwithfour mainstream particle swarm optimization algorithms.The results show that the RMSPSO algorithm makes progress in conver­gence speed and accuracy in unimodal&multimodal and combined functions.Key words：particle swarm optimization；RMSprop algorithm；adaptive#gradient descent；inertia weighto引言粒子群算法（particle swarm optimization,PSO）1*是由Kennedy和Eberhart提出的一种结构简单、收敛速度快的进化算法。

基于粒子群优化的误差校准算法一、粒子群优化算法概述粒子群优化算法（Particle Swarm Optimization，简称PSO）是一种基于群体智能的优化技术，由Kennedy和Eberhart于1995年提出。

它模拟鸟群觅食行为，通过群体中个体之间的信息共享来寻找最优解。

PSO算法因其简单、鲁棒性好、易于实现等优点，在许多领域得到了广泛的应用。

1.1 粒子群优化算法的基本原理PSO算法中，每个个体称为粒子，粒子在解空间中搜索最优解。

每个粒子都有自己的位置和速度，并且会根据个体经验和群体经验来更新自己的位置和速度。

粒子的位置表示问题的潜在解，速度表示粒子移动的方向和距离。

1.2 粒子群优化算法的关键参数PSO算法的关键参数包括粒子速度、粒子位置、个体最优解和全局最优解。

个体最优解是指粒子自身历史上找到的最优解，全局最优解是指整个粒子群中所有粒子找到的最优解。

1.3 粒子群优化算法的更新规则粒子的位置和速度更新规则如下：- 速度更新：\[v_{i}^{t+1} = w \cdot v_{i}^{t} + c_1 \cdot r_1 \cdot (p_{i} - x_{i}^{t}) + c_2 \cdot r_2 \cdot (p_{g} - x_{i}^{t})\]- 位置更新：\[x_{i}^{t+1} = x_{i}^{t} + v_{i}^{t+1}\]其中，\(v_{i}^{t}\)和\(x_{i}^{t}\)分别表示粒子在第\(t\)时刻的速度和位置，\(p_{i}\)和\(p_{g}\)分别表示粒子的个体最优解和全局最优解，\(w\)是惯性权重，\(c_1\)和\(c_2\)是学习因子，\(r_1\)和\(r_2\)是随机数。

二、误差校准算法的应用背景误差校准算法在许多领域都有应用，如机器视觉、导航定位、传感器网络等。

误差校准的目的是减小或消除系统误差，提高系统的性能和精度。

传统的误差校准方法往往需要大量的实验数据和复杂的数学模型，而基于粒子群优化的误差校准算法提供了一种新的解决方案。

粒子群优化算法（PSO）是一种基于群体智能的优化算法，通过模拟鸟群觅食行为中的社会心理学原理来求解优化问题。

下面是一个简单的粒子群优化算法实例：
假设我们要解决一个最小化问题，即找到一个函数f(x)的最小值。

我们可以使用粒子群优化算法来求解这个问题。

初始化粒子群：随机生成一组粒子，每个粒子代表问题的一个解。

粒子的位置表示解的取值，速度表示解的变化方向。

评估粒子适应度：计算每个粒子的适应度值，即函数f(x)的取值。

更新粒子速度和位置：根据粒子当前的位置、速度和全局最优解的信息，更新粒子的速度和位置。

具体更新公式如下：
速度更新公式：v[i] = w * v[i] + c1 * rand() * (pbest[i] - x[i]) + c2 * rand() * (gbest - x[i])
位置更新公式：x[i] = x[i] + v[i]
其中，w是惯性权重，c1和c2是学习因子，rand()是随机数生成函数，pbest[i]是粒子i的历史最优解，gbest是全局最优解。

更新全局最优解：比较每个粒子的适应度值和全局最优解的适应度值，如果某个粒子的适应度值更小，则更新全局最优解。

迭代执行步骤2-4，直到达到预设的迭代次数或满足停止条件。

返回全局最优解作为问题的近似解。

通过上述步骤，我们可以使用粒子群优化算法来求解最小化问题。

需要注意的是，粒子群优化算法是一种启发式算法，不能保证找到全局最优解，但在许多实际问题中，它能够找到较好的近似解。

python实现粒⼦群算法（PSO）优化神经⽹络超参数——以预测英雄联盟⽐赛结果为例⽬录程序简介本实验根据英雄联盟的对局数据，搭建全连接⽹络分类模型，以粒⼦群算法对神经⽹络的节点数和dropout概率进⾏调优，最后对⽐默认模型和优化后的模型对英雄联盟⽐赛结果的预测准确率粒⼦群优化算法(PSO)是⼀种进化计算技术源于对鸟群捕⾷的⾏为研究。

粒⼦群优化算法的基本思想：是通过群体中个体之间的协作和信息共享来寻找最优解。

它的优点是收敛快、实现简单，缺点则是容易陷⼊局部最优程序/数据集下载代码分析导⼊模块from yers import Input,Dense,Dropout,Activationimport matplotlib.pyplot as pltfrom tensorflow.keras.models import load_modelfrom tensorflow.keras.models import Modelfrom tensorflow.keras.optimizers import Adamfrom sklearn.metrics import accuracy_scoreimport pandas as pdimport numpy as npimport jsonfrom copy import deepcopy数据是英雄联盟各对局10分钟的战况，英雄联盟对战⽅分为红蓝双⽅，blueWins就是指是否为蓝⽅获胜，其他列基本就是⼩龙、野怪、经济啥的，原谅我解释不清。

读研的时候升到⽩银，因为出装问题每⼀局都要被骂，顺便说⼀下，我⽼是在⾥⾯装妹⼦，玩辅助，因为这样骂我的⼈就少了很多，好友已经满了┭┮﹏┭┮错的不是我，是这个世界data = pd.read_csv("Static/high_diamond_ranked_10min.csv").iloc[:,1:]print("数据尺⼨:",data.shape)print("展⽰下数据前5⾏和前5列")data.iloc[:,:5].head()数据尺⼨: (9879, 39)展⽰下数据前5⾏和前5列blueWins blueWardsPlaced blueWardsDestroyed blueFirstBlood blueKills00282191012105201500730431044075406切割数据集，分成训练、验证和测试，这⾥只⽤验证集给PSO调优⽤，并没有给神经⽹络训练保存最佳checkpointdata = data.sample(frac=1.0)#打乱数据trainData = data.iloc[:6000]#训练集xTrain = trainData.values[:,1:]yTrain = trainData.values[:,:1]valData = data.iloc[6000:8000]#验证集xVal = valData.values[:,1:]yVal = valData.values[:,:1]testData = data.iloc[8000:]#测试集xTest = testData.values[:,1:]yTest = testData.values[:,:1]1个粒⼦即1个⽅案，在本实验中，1个粒⼦就是1个(节点数、dropout概率)的数组，PSO就是计算每个粒⼦对应⽅案的适应度，找到最合适的⽅案的过程，下⽂的PSO类会根据粒⼦需要优化的特征对粒⼦迭代，⽀持⼩数或整数的特征，若为⾃定的离散区间，可在适应度函数中，将⾮法粒⼦的适应度给予惩罚值，实例化该类后，需要指定适应度函数给iterate函数对粒⼦⽅案进⾏迭代，本实验的粒⼦群算法为最简单的形式，更新公式如下:class PSO():def __init__(self,featureNum,featureArea,featureLimit,featureType,particleNum=5,epochMax=10,c1=2,c2=2): '''粒⼦群算法:param featureNum: 粒⼦特征数:param featureArea: 特征上下限矩阵:param featureLimit: 特征上下阙界，也是区间的开闭 0为不包含 1为包含:param featureType: 特征类型 int float:param particleNum: 粒⼦个数:param epochMax: 最⼤迭代次数:param c1: ⾃⾝认知学习因⼦:param c2: 群体认知学习因⼦'''#如上所⽰self.featureNum = featureNumself.featureArea = np.array(featureArea).reshape(featureNum,2)self.featureLimit = np.array(featureLimit).reshape(featureNum,2)self.featureType = featureTypeself.particleNum = particleNumself.epochMax = epochMaxself.c1 = c1self.c2 = c2self.epoch = 0#已迭代次数#⾃⾝最优适应度记录self.pBest = [-1e+10 for i in range(particleNum)]self.pBestArgs = [None for i in range(particleNum)]#全局最优适应度记录self.gBest = -1e+10self.gBestArgs = None#初始化所有粒⼦self.particles = [self.initParticle() for i in range(particleNum)]#初始化所有粒⼦的学习速度self.vs = [np.random.uniform(0,1,size=featureNum) for i in range(particleNum)]#迭代历史self.gHistory = {"特征%d"%i:[] for i in range(featureNum)}self.gHistory["群内平均"] = []self.gHistory["全局最优"] = []def standardValue(self,value,lowArea,upArea,lowLimit,upLimit,valueType):'''规范⼀个特征值，使其落在区间内:param value: 特征值:param lowArea: 下限:param upArea: 上限:param lowLimit: 下限开闭区间:param upLimit: 上限开闭区间:param valueType: 特征类型:return: 修正后的值'''if value < lowArea:value = lowAreaif value > upArea:value = upAreaif valueType is int:value = np.round(value,0)#下限为闭区间if value <= lowArea and lowLimit==0:value = lowArea + 1#上限为闭区间if value >= upArea and upLimit==0:value = upArea - 1elif valueType is float:#下限为闭区间if value <= lowArea and lowLimit == 0:value = lowArea + 1e-10#上限为闭=间if value >= upArea and upLimit==0:value = upArea - 1e-10return valuedef initParticle(self):'''随机初始化1个粒⼦'''values = []#初始化这么多特征数for i in range(self.featureNum):#该特征的上下限lowArea = self.featureArea[i][0]upArea = self.featureArea[i][1]#该特征的上下阙界lowLimit = self.featureLimit[i][0]upLimit = self.featureLimit[i][1]#随机值value = np.random.uniform(0,1) * (upArea-lowArea) + lowAreavalue = self.standardValue(value,lowArea,upArea,lowLimit,upLimit,self.featureType[i])values.append(value)return valuesdef iterate(self,calFitness):'''开始迭代:param calFitness:适应度函数输⼊为1个粒⼦的所有特征和全局最佳适应度，输出为适应度'''while self.epoch<self.epochMax:self.epoch += 1for i,particle in enumerate(self.particles):#该粒⼦的适应度fitness = calFitness(particle,self.gBest)#更新该粒⼦的⾃⾝认知最佳⽅案if self.pBest[i] < fitness:self.pBest[i] = fitnessself.pBestArgs[i] = deepcopy(particle)#更新全局最佳⽅案if self.gBest < fitness:self.gBest = fitnessself.gBestArgs = deepcopy(particle)#更新粒⼦for i, particle in enumerate(self.particles):#更新速度self.vs[i] = np.array(self.vs[i]) + self.c1*np.random.uniform(0,1,size=self.featureNum)*(np.array(self.pBestArgs[i])-np.array(self.particles[i])) + self.c2*np.random.uniform(0,1,size=self.featureNum)*(np.array(self.gBestArgs)-np.array(self #更新特征值self.particles[i] = np.array(particle) + self.vs[i]#规范特征值values = []for j in range(self.featureNum):#该特征的上下限lowArea = self.featureArea[j][0]upArea = self.featureArea[j][1]#该特征的上下阙界lowLimit = self.featureLimit[j][0]upLimit = self.featureLimit[j][1]#随机值value =self.particles[i][j]value = self.standardValue(value,lowArea,upArea,lowLimit,upLimit,self.featureType[j])values.append(value)self.particles[i] = values#保存历史数据for i in range(self.featureNum):self.gHistory["特征%d"%i].append(self.gBestArgs[i])self.gHistory["群内平均"].append(np.mean(self.pBest))self.gHistory["全局最优"].append(self.gBest)print("PSO epoch:%d/%d 群内平均:%.4f 全局最优:%.4f"%(self.epoch,self.epochMax,np.mean(self.pBest),self.gBest))buildNet函数根据⽹络节点数和dropout概率来构建⼀个简单的全连接分类⽹络，其输⼊特征数为38，输出特征数为1（当然，也可以选择⽹络层数、学习率等超参数来优化，为⽅便学习，这⾥只选择这俩超参数进⾏实验）并对该⽹络进⾏训练def buildNet(nodeNum,p):'''搭建全连接⽹络进⾏训练，返回模型和训练历史、验证集准确率和测试集准确率:param nodeNum: ⽹络节点数:param p: dropout概率'''#输⼊层 38个对局特征inputLayer = Input(shape=(38,))#中间层middle = Dense(nodeNum)(inputLayer)middle = Dropout(p)(middle)#输出层⼆分类outputLayer = Dense(1,activation="sigmoid")(middle)#建模⼆分类损失model = Model(inputs=inputLayer,outputs=outputLayer)optimizer = Adam(lr=1e-3)pile(optimizer=optimizer,loss="binary_crossentropy",metrics=['acc'])#训练history = model.fit(xTrain,yTrain,verbose=0,batch_size=1000,epochs=100,validation_data=(xVal,yVal)).history#验证集准确率valAcc = accuracy_score(yVal,model.predict(xVal).round(0))#测试集准确率testAcc = accuracy_score(yTest,model.predict(xTest).round(0))return model,history,valAcc,testAcc为了跟优化好的模型有所对⽐，这⾥我们训练⼀个默认参数的神经⽹络，它的超参数取值即各超参数区间的平均值，训练并打印⽹络结构和训练指标nodeArea = [10,200]#节点数区间pArea = [0,0.5]#dropout概率区间#按区间平均值训练⼀个神经⽹络nodeNum = int(np.mean(nodeArea))p = np.mean(pArea)defaultNet,defaultHistory,defaultValAcc,defaultTestAcc = buildNet(nodeNum,p)defaultNet.summary()print("\n默认⽹络的节点数:%d dropout概率:%.2f 验证集准确率:%.4f 测试集准确率:%.4f"%(nodeNum,p,defaultValAcc,defaultTestAcc))Model: "model_346"_________________________________________________________________Layer (type) Output Shape Param #=================================================================input_347 (InputLayer) [(None, 38)] 0_________________________________________________________________dense_691 (Dense) (None, 105) 4095_________________________________________________________________dropout_346 (Dropout) (None, 105) 0_________________________________________________________________dense_692 (Dense) (None, 1) 106=================================================================Total params: 4,201Trainable params: 4,201Non-trainable params: 0_________________________________________________________________默认⽹络的节点数:105 dropout概率:0.25 验证集准确率:0.6535 测试集准确率:0.6578实例化PSO模型，将区间信息输⼊，开始迭代，适应度函数就是输⼊1各粒⼦和全局最优适应度，返回该粒⼦对应⽅案的验证集准确率featureNum = 2#2个需要优化的特征featureArea = [nodeArea,pArea]#2个特征取值范围featureLimit = [[1,1],[0,1]]#取值范围的开闭 0为闭区间 1为开区间featureType = [int,float]#2个特征的类型#粒⼦群算法类pso = PSO(featureNum,featureArea,featureLimit,featureType)def calFitness(particle,gBest):'''适应度函数，输⼊1个粒⼦的数组和全局最优适应度，返回该粒⼦对应的适应度'''nodeNum,p = particle#取出粒⼦的特征值net,history,valAcc,testAcc = buildNet(nodeNum,p)#该粒⼦⽅案超过全局最优if valAcc>gBest:#保存模型和对应信息net.save("Static/best.h5")history = pd.DataFrame(history)history.to_excel("Static/best.xlsx",index=None)with open("Static/info.json","w") as f:f.write(json.dumps({"valAcc":valAcc,"testAcc":testAcc}))return valAcc#开始⽤粒⼦群算法迅游pso.iterate(calFitness)#载⼊最佳模型和对应的训练历史bestNet = load_model("Static/best.h5")with open("Static/info.json","r") as f:info = json.loads(f.read())bestValAcc = float(info["valAcc"])bestTestAcc = float(info["testAcc"])bestHistory = pd.read_excel("Static/best.xlsx")print("最优模型的验证集准确率:%.4f 测试集准确率:%.4f"%(bestValAcc,bestTestAcc)) PSO epoch:1/10 群内平均:0.7210 全局最优:0.7280PSO epoch:2/10 群内平均:0.7210 全局最优:0.7280PSO epoch:3/10 群内平均:0.7251 全局最优:0.7280PSO epoch:4/10 群内平均:0.7275 全局最优:0.7350PSO epoch:5/10 群内平均:0.7275 全局最优:0.7350PSO epoch:6/10 群内平均:0.7299 全局最优:0.7350PSO epoch:7/10 群内平均:0.7313 全局最优:0.7350PSO epoch:8/10 群内平均:0.7313 全局最优:0.7350PSO epoch:9/10 群内平均:0.7313 全局最优:0.7350PSO epoch:10/10 群内平均:0.7313 全局最优:0.7350最优模型的验证集准确率:0.7350 测试集准确率:0.7350查看PSO最优解随迭代次数的变换history = pd.DataFrame(pso.gHistory)history["epoch"] = range(1,history.shape[0]+1)history特征0特征1群内平均全局最优epoch050.00.2677060.72100.7281150.00.2677060.72100.7282250.00.2677060.72510.7283357.00.2013360.72750.7354457.00.2013360.72750.7355557.00.2013360.72990.7356657.00.2013360.73130.7357757.00.2013360.73130.7358857.00.2013360.73130.7359957.00.2013360.73130.73510对⽐下默认参数模型和PSO调优模型的准确率，是有点效果，仅供学习... fig, ax = plt.subplots()x = np.arange(2)a = [defaultValAcc,bestValAcc]b = [defaultTestAcc,bestTestAcc]total_width, n = 0.8, 2width = total_width / nx = x - (total_width - width) / 2ax.bar(x, a, width=width, label='val',color="#00BFFF")for x1,y1 in zip(x,a):plt.text(x1,y1+0.01,'%.3f' %y1, ha='center',va='bottom')ax.bar(x + width, b, width=width, label='test',color="#FFA500")for x1,y1 in zip(x,b):plt.text(x1+width,y1+0.01,'%.3f' %y1, ha='center',va='bottom')ax.legend()ax.set_xticks([0, 1])ax.set_ylim([0,1.2])ax.set_ylabel("acc")ax.set_xticklabels(["default net","PSO-net"])fig.savefig("Static/对⽐.png",dpi=250)。

本文选取常见的二阶惯性加纯滞后环节，传递函数为：)1)(1(21++=-s T s T e G ss τ在这里，3.0,2,,121===τT T PID 参数取为2,1,2===i d p K K K本设计中的模糊控制器采用两输入(e, ec)，三输出(P,I,D)的形式来调整PID 参数。

e 的论域为[-3,3]，ec 的论域为[-3,3]。

推理机使用{,,,,,,}NB NM NS O PS PM PB ，表示{负大，负中，负小，零，正小，正中，正大}为了可以调节尽可能多的系统，此控制器选定在负边界处和正边界处分别选用平滑连续的Z 型隶属度函数和S 型隶属度函数，在中间部分采用灵敏度较强的三角形隶属度函数。

规则表如下图所示：（1）主程序： clear clc%% 参数设置w = 0.6; % 惯性因子 c1 = 1.414; % 加速常数 c2 = 1.623; % 加速常数 Dim = 5; % 维数 SwarmSize = 100; % 粒子群规模 ObjFun = @PSO_PID; % 待优化函数句柄MaxIter = 100; % 最大迭代次数MinFit = 0.01; % 最小适应值Vmax = 2;Vmin =-2;Ub = [20 50 1 1 1];Lb = [0 0 0 0 0];%% 粒子群初始化Range = ones(SwarmSize,1)*(Ub-Lb);Swarm = rand(SwarmSize,Dim).*Range + ones(SwarmSize,1)*Lb; % 初始化粒子群VStep = rand(SwarmSize,Dim)*(Vmax-Vmin) + Vmin; % 初始化速度fSwarm = zeros(SwarmSize,1);for i=1:SwarmSizefSwarm(i,:) = feval(ObjFun,Swarm(i,:)); % 粒子群的适应值end%% 个体极值和群体极值[bestf,bestindex]=min(fSwarm);zbest=Swarm(bestindex,:); % 全局最佳gbest=Swarm; % 个体最佳fgbest=fSwarm; % 个体最佳适应值fzbest=bestf; % 全局最佳适应值%% 迭代寻优iter = 0;y_fitness = zeros(1,MaxIter); % 预先产生4个空矩阵K_p = zeros(1,MaxIter);K_i = zeros(1,MaxIter);K_d = zeros(1,MaxIter);e= zeros(1,MaxIter);ec = zeros(1,MaxIter);while( (iter < MaxIter) && (fzbest > MinFit) )for j=1:SwarmSize% 速度更新VStep(j,:) = w*VStep(j,:) + c1*rand*(gbest(j,:) - Swarm(j,:)) + c2*rand*(zbest -Swarm(j,:));if VStep(j,:)>Vmax, VStep(j,:)=Vmax; endif VStep(j,:)<Vmin, VStep(j,:)=Vmin; end% 位置更新Swarm(j,:)=Swarm(j,:)+VStep(j,:);for k=1:Dimif Swarm(j,k)>Ub(k), Swarm(j,k)=Ub(k); endif Swarm(j,k)<Lb(k), Swarm(j,k)=Lb(k); endend% 适应值fSwarm(j,:) = feval(ObjFun,Swarm(j,:));% 个体最优更新if fSwarm(j) < fgbest(j)gbest(j,:) = Swarm(j,:);fgbest(j) = fSwarm(j);end% 群体最优更新if fSwarm(j) < fzbestzbest = Swarm(j,:);fzbest = fSwarm(j);endenditer = iter+1; % 迭代次数更新y_fitness(1,iter) = fzbest; % 为绘图做准备K_p(1,iter) = zbest(1);K_i(1,iter) = zbest(2);K_d(1,iter) = zbest(3);e(1,iter) = zbest(4);ec(1,iter) = zbest(5);end%% 绘图输出figure(1) % 绘制性能指标ITAE的变化曲线plot(y_fitness,'LineWidth',2)title('最优个体适应值', 'fontsize',18);xlabel('迭代次数','fontsize',18);ylabel('适应值','fontsize',18); set(gca,'Fontsize',18);figure(2) % 绘制PID控制器参数变化曲线plot(K_p)hold onplot(K_i,'k','LineWidth',3)title('Kp、Ki优化曲线','fontsize',18);xlabel('迭代次数','fontsize',18);ylabel('参数值','fontsize',18); set(gca,'Fontsize',18);legend('Kp','Ki',1);figure(3) % 绘制PID控制器参数变化曲线plot(e)hold onplot(ec,'k','LineWidth',3)title('e、ec 优化曲线','fontsize',18);xlabel('迭代次数','fontsize',18);ylabel('参数值','fontsize',18); set(gca,'Fontsize',18);legend('e','ec',1);figure(4) % 绘制PID控制器参数变化曲线plot(K_d)hold ontitle('Kd 优化曲线','fontsize',18);xlabel('迭代次数','fontsize',18);ylabel('参数值','fontsize',18);set(gca,'Fontsize',18);legend('Kd',1);clearclc（2）simulnik与算法结合程序function z=PSO_PID(x)assignin('base','Kp',x(1));assignin('base','Ki',x(2));assignin('base','Kd',x(3)); assignin('base','e',x(4));assignin('base','ec',x(5));[t_time,x_state,y_out]=sim('pca',[0,20]);z=y_out(end,1);（3）Simulink 仿真图：实验结果：8446.8,1,20,15====ITAE K K K d i p ，波形如下图所示。