粒子群算法Java实现

于 2024-06-03 08:56:34 发布
阅读量1k 收藏 21
点赞数 29
分类专栏： AI 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42496466/article/details/139402012
版权

        粒子群算法（Particle Swarm Optimization，PSO）是一种受到自然界群体行为启发的优化算法，由James Kennedy和Russell Eberhart于1995年提出。该算法模拟了鸟类或其他动物群体（如鱼群）的社会和集体行为，来寻找复杂问题的最优解。以下是粒子群算法的基本概念和工作原理：

基本概念：

•粒子：算法中的每个解被视为一个“粒子”，它在解空间中有一个位置（代表潜在解决方案）和一个速度（决定其如何移动到新位置）。

•适应度值：每个粒子的位置对应于目标函数的值，用以评估该位置的优劣。

•个体最优解（pBest）：每个粒子记录它经历过的最好位置。

•全局最优解（gBest）：群体中所有粒子经历过的最好位置中的最优者。

工作原理：

1. 初始化：算法开始时，随机生成一组粒子，每个粒子都具有初始位置和速度。

2. 评估：计算每个粒子当前位置的适应度值，确定每个粒子的个体最优解pBest和整个群体的全局最优解gBest。

3. 更新速度和位置：基于粒子的当前速度、个体最优解和全局最优解，按照一定的公式更新每个粒子的速度和位置。更新公式通常包含惯性因子、认知系数（个体学习）和社会系数（社会学习）。

[ v_{i}(t+1) = w \cdot v_{i}(t) + c_1 \cdot r_1 \cdot (pBest_i - x_i(t)) + c_2 \cdot r_2 \cdot (gBest - x_i(t)) ][ x_{i}(t+1) = x_{i}(t) + v_{i}(t+1) ]

其中，(v_i) 是粒子的速度，(x_i) 是粒子的位置，(w) 是惯性权重，(c_1) 和 (c_2) 分别是个体学习和社交学习的加速常数，(r_1) 和 (r_2) 是随机数，用于引入随机性。

4. 重复步骤2和3：直到满足停止条件（如达到预设的最大迭代次数、适应度值的变化小于阈值等）。

特点与优势：

•简单易实现：算法规则直观，实现代码相对简洁。

•并行处理：天然适合并行计算，因为每个粒子的更新是独立的。

•全局优化能力：尽管存在陷入局部最优的风险，但通过适当调整参数，PSO能够有效探索搜索空间，找到全局最优解或接近最优解的解。

•参数少：相比其他进化算法，PSO需要调节的参数较少。

PSO已被广泛应用于各种领域，包括工程优化、机器学习、控制工程、模式识别等，展现了其强大的灵活性和有效性。

算法流程图

函数测试效果



应用（最优值计算）

关键源码实现

package org.xcai.pso;

import org.xcai.i.PsoFunction;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @param
 * @DATA
 * @Author NIRVANA
 * @Description 粒子群
 */
public class PSO {
    private double globalValue = -1;//当前全局最优值
    private int times;//迭代次数
    private List<Particle> allPar = new ArrayList<>();//全部粒子集合
    private PsoFunction psoFunction;//粒子群执行函数
    private double inertialFactor = 0.5;//惯性因子
    private double selfStudyFactor = 2;//个体学习因子
    private double socialStudyFactor = 2;//社会学习因子
    private boolean isMax;//取最大值还是最小值
    private double[] allBest;//全局最佳位置
    private Random random = new Random();
    private int[] minBorder, maxBorder;
    private double maxSpeed;
    private double initSpeed;//初始速度

    public PSO(int dimensionNub, int[] minBorder, int[] maxBorder,
               int times, int particleNub, PsoFunction psoFunction,
               double inertialFactor, double selfStudyFactor, double socialStudyFactor
            , boolean isMax, double maxSpeed, double initSpeed) {
        this.initSpeed = initSpeed;
        this.times = times;
        this.psoFunction = psoFunction;
        this.isMax = isMax;
        allBest = new double[dimensionNub];
        this.minBorder = minBorder;
        this.maxBorder = maxBorder;
        this.maxSpeed = maxSpeed;
        if (inertialFactor > 0) {
            this.inertialFactor = inertialFactor;
        }
        if (selfStudyFactor >= 0 && selfStudyFactor <= 4) {
            this.selfStudyFactor = selfStudyFactor;
        }
        if (socialStudyFactor >= 0 && socialStudyFactor <= 4) {
            this.socialStudyFactor = socialStudyFactor;
        }
        for (int i = 0; i < particleNub; i++) {//初始化生成粒子群
            Particle particle = new Particle(dimensionNub);
            allPar.add(particle);
        }

    }

    public void setAllPar(List<Particle> allPar) {//外置粒子群注入
        this.allPar = allPar;
    }

    public List<double[]> start() throws Exception {//开始进行迭代
        int size = allPar.size();
        for (int i = 0; i < times; i++) {
            for (int j = 0; j < size; j++) {
                move(allPar.get(j), j);
            }
        }
        List<double[]> feature = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            feature.add(allPar.get(i).getParameter());
        }
        return feature;
        //粒子群移动结束
        // draw("/Users/NIRVANA/Desktop/test/testOne/e2.jpg", fatherX, fatherY);
    }

    private void move(Particle particle, int id) throws Exception {//粒子群开始移动
        double[] parameter = particle.getParameter();//当前粒子的位置
        BestData[] bestData = particle.bestDataArray;//该粒子的信息
        double value = psoFunction.getResult(parameter, id);
        double selfValue = particle.selfBestValue;//局部最佳值
        if (isMax) {//取最大值
            if (value > globalValue) {//更新全局最大值
                globalValue = value;
                //更新全局最佳位置
                for (int i = 0; i < allBest.length; i++) {
                    allBest[i] = parameter[i];
                }
            }
            if (value > selfValue) {//更新局部最大值
                particle.selfBestValue = value;
                //更新局部最佳位置
                for (int i = 0; i < bestData.length; i++) {
                    bestData[i].selfBestPosition = parameter[i];
                }
            }
        } else {//取最小值
            if (globalValue < 0 || value < globalValue) {//更新全局最小值
                globalValue = value;
                //更新全局最佳位置
                for (int i = 0; i < allBest.length; i++) {
                    allBest[i] = parameter[i];
                }
            }
            if (selfValue < 0 || value < selfValue) {//更新全局最小值
                particle.selfBestValue = value;
                //更新局部最佳位置
                for (int i = 0; i < bestData.length; i++) {
                    bestData[i].selfBestPosition = parameter[i];
                }
            }
        }
        //先更新粒子每个维度的速度
        for (int i = 0; i < bestData.length; i++) {
            double speed = bestData[i].speed;//当前维度的速度
            double pid = bestData[i].selfBestPosition;//当前自己的最佳位置
            double selfPosition = parameter[i];//当前自己的位置
            double pgd = allBest[i];//当前维度的全局最佳位置
            //当前维度更新后的速度
            speed = inertialFactor * speed + selfStudyFactor * random.nextDouble() * (pid - selfPosition)
                    + socialStudyFactor * random.nextDouble() * (pgd - selfPosition);
            if (Math.abs(speed) > maxSpeed) {
                if (speed > 0) {
                    speed = maxSpeed;
                } else {
                    speed = -maxSpeed;
                }
            }
            bestData[i].speed = speed;
            //更新该粒子该维度新的位置
            double position = selfPosition + speed;
            if (minBorder != null) {
                if (position < minBorder[i]) {
                    position = minBorder[i];
                }
                if (position > maxBorder[i]) {
                    position = maxBorder[i];
                }
            }
            bestData[i].selfPosition = position;
        }
    }

    class Particle {//粒子
        private BestData[] bestDataArray;
        private double selfBestValue = -1;//自身最优的值

        private double[] getParameter() {//获取粒子位置信息
            double[] parameter = new double[bestDataArray.length];
            for (int i = 0; i < parameter.length; i++) {
                parameter[i] = bestDataArray[i].selfPosition;
            }
            return parameter;
        }

        protected Particle(int dimensionNub) {//初始化随机位置
            bestDataArray = new BestData[dimensionNub];
            for (int i = 0; i < dimensionNub; i++) {
                double position;
                if (minBorder != null && maxBorder != null) {
                    int min = minBorder[i];
                    int max = maxBorder[i];
                    int region = max - min + 1;
                    position = random.nextInt(region) + min;//初始化该维度的位置
                } else {
                    position = random.nextDouble();
                }
                bestDataArray[i] = new BestData(position, initSpeed);
            }
        }
    }

    class BestData {//数据保存

        private BestData(double selfPosition, double initSpeed) {
            this.selfBestPosition = selfPosition;
            this.selfPosition = selfPosition;
            speed = initSpeed;
        }

        private double speed;//该粒子当前维度的速度
        private double selfBestPosition;//当前维度自身最优的历史位置/自己最优位置的值
        private double selfPosition;//当前维度自己现在的位置/也就是当前维度自己的值
    }
}

 

如果对您有所帮助，请点赞打赏支持！

技术合作交流qq：2401315930

最后分享一下地图下载器设计及下载地址：

链接：https://pan.baidu.com/s/1RZX7JpTpxES-G7GiaVUxOw 
提取码：61cn

地图下载器代码结构设计及功能实现_地图下载管理器解析-CSDN博客

兴诚
关注
  • 29
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java粒子群算法_Java多线程技术实现的粒子群优化算法
weixin_28882565的博客
02-21 482
概述1 粒子群优化算法，是(Particle Swarm Optimization PSO)一种进化计算技术是基于个体间的协作与竞争来完成复杂,空间中最优解的搜索。中的粒子在解空间追随最优的粒PSO 子进行搜索，而不是像遗传算法那样通过交叉、变异等复杂操作，因此具有参数少、简单易实现等优点。非常适合PSO 于求解连续函数的优化问题，主要应用于神经网络训练，多目标优化等应用领域。的提出至今不到年，但...
粒子群算法Java.rar
07-06
群智能算法入门
粒子群算法的Java实现源码
03-10
附件中是粒子群算法的Java版本的代码实现，可以正常运行；下载者可以根据自己的应用场景来修改。
数学建模常用算法：粒子群算法(PSO)求解二元函数最小值+限定x,y范围测试【java实现--详细注释+Matlab绘制粒子群飞行过程】
记录一名在读研究生的学习笔记、感悟、开发产物
06-05 2818
粒子群算法(PSO)求解二元函数最小值+限定x,y范围测试【java实现--详细注释】
粒子群算法
KHFlash的博客
05-22 1447
一.产生背景     ❃粒子群算法(particleswarm optimization，PSO)由Kennedy和Eberhart在1995年提出，该算法对于Hepper的模拟鸟群(鱼群)的模型进行修正，以使粒子能够飞向解空间，并在最好解处降落，从而得到了粒子群优化算法。 ❃同遗传算法类似，也是一种基于群体叠代的，但并没有遗传算法用的交叉以及变异，而是粒子在解空间追随最优的
粒子群算法(PSO)——Java实现PSO算法(详细注释) 优化算法
cccddduil的博客
03-22 2328
https://blog.csdn.net/daaikuaichuan/article/details/81382794https://blog.csdn.net/daaikuaichuan/article/details/81382794代码||注释||结果 package PSO; /* * Target function : F(x, y) = x^2 + y^2; * Opti Solution is F(0, 0) = 0, Certainly; * * According to
粒子群算法 java
05-20
粒子群算法 java粒子群算法 java粒子群算法 java粒子群算法 java粒子群算法 java粒子群算法 java粒子群算法 java
【运筹优化】PSO粒子群算法求解无约束多元函数最值(Java代码实现)
热门推荐
知不足而奋进，望远山而前行
06-06 2万+
粒子群优化算法(Particle Swarm optimization,PSO)又翻译为粒子群算法、微粒群算法、或微粒群优化算法。是通过模拟鸟群觅食行为而发展起来的一种基于群体协作的随机搜索算法。通常认为它是群集智能 (Swarm intelligence, SI) 的一种。它可以被纳入多主体优化系统(Multiagent Optimization System, MAOS)。粒子群优化算法是由Eberhart博士和kennedy博士发明。PSO模拟鸟群的捕食行为。一群鸟在随机搜索食物，在这个区域里只有一块
基于java的粒子群算法优化神经网络设计与实现
05-01
基于java的粒子群算法优化神经网络设计与实现
基于java的粒子群算法（PSO）简单实例
黄上的博客
12-09 1409
问题：用粒子群算法求函数f(x)=xsinx*cos2x-2*x*sin3x的最大值,同时可以求出当x取多少时原函数有最大值？ 粒子群算法： 1.同遗传算法一样先要随机生成鸟群的位置和速度（相当于遗传算法中随机生成的种群），其实就是在特定的范围内生成随机数 2.需要开始一个大循环，可以理解为各个鸟进行信息交流后又开始去新的位置寻找食物。 3.需要记录下每只“鸟”历史上的最优位置（因为会...
粒子群算法java代码
11-26
粒子群优化代码java粒子群算法简称PSO，它的基本思想是模拟鸟群的捕食行为。设想这样一个场景：一群鸟在随机搜索食物。在这个区域里只有一块食物。所有的鸟都不知道食物在那里。但是他们知道当前的位置离食物还有多远。那么找到食物的最优策略是什么呢。最简单有效的就是搜寻目前离食物最近的鸟的周围区域。 PSO从这种模型中得到启示并用于解决优化问题。PSO中，每个优化问题的解都是搜索空间中的一只鸟。我们称之为“粒子”。所有的粒子都有一个由被优化的函数决定的适应值(fitness value)，每个粒子还有一个速度决定他们飞翔的方向和距离。然后粒子们就追随当前的最优粒子在解空间中搜索。 PSO 初始化为一群随机粒子(随机解)。然后通过迭代找到最优解。在每一次迭代中，粒子通过跟踪两个"极值"来更新自己。第一个就是粒子本身所找到的最优解，这个解叫做个体极值pBest。另一个极值是整个种群目前找到的最优解，这个极值是全局极值gBest。另外也可以不用整个种群而只是用其中一部分作为粒子的邻居，那么在所有邻居中的极值就是局部极值。
粒子群算法 实现 最短路径
04-11
粒子群算法 实现 最短路径，解决TSL多旅行商问题，以此为基础解决VRP问题
粒子群算法Java程序
11-08
很好的粒子群算法Java代码，适合于基于Java平台开发的优化、决策支持系统等高级分析应用
PSO粒子群算法(java)
04-30
资源是java实现的PSO粒子群优化算法,可以正常运行,可以根据自己实际业务更改来满足自己的需求.
【运筹优化】粒子群算法(PSO)实现等误差直线逼近复杂曲线（附PSO Java源码）
最新发布
第三季度的博客
11-30 1177
曲线逼近、粒子群算法源码。
粒子群算法Java代码
m0_62526778的博客
02-28 229
粒子群算法Java代码，PSO算法
用java实现多目标粒子群算法
weixin_35753291的博客
01-05 309
好的，首先多目标粒子群算法是一种基于模拟的优化算法，它的目的是找到一组最优解来解决多目标优化问题。 下面是一个简单的 Java 代码实现： ```java import java.util.Arrays; public class MultiObjectiveParticleSwarmOptimization { // 粒子数量 private static final int N...
Java 实现粒子群算法
shenyeaxu的博客
12-01 2221
/* 粒子群算法JAVA的简单实现 作者：G Greg */ import java.util.Random; import java.io.*; /* 粒子的类 */ class Particle{ public int nVar; // 变量的个数 public double [] position; // 粒子的位置，包含解的信息 publi...
Java实现粒子群算法
11-02
粒子群算法是一种优化算法，可以用于解决许多问题，例如函数优化、组合优化和机器学习等。下面是Java实现粒子群算法的步骤： ```java // 定义粒子类 class Particle { double[] position; // 粒子位置 double[] velocity; // 粒子速度 double[] pBest; // 个体最优位置 double fitness; // 适应度值 public Particle(int dim) { position = new double[dim]; velocity = new double[dim]; pBest = new double[dim]; fitness = Double.MAX_VALUE; } } // 定义粒子群类 class PSO { int swarmSize; // 粒子群大小 int maxIter; // 最大迭代次数 double w; // 惯性权重 double c1, c2; // 学习因子 double[] gBest; // 全局最优位置 double gBestFitness; // 全局最优适应度值 Particle[] swarm; // 粒子群 public PSO(int swarmSize, int maxIter, double w, double c1, double c2) { this.swarmSize = swarmSize; this.maxIter = maxIter; this.w = w; this.c1 = c1; this.c2 = c2; swarm = new Particle[swarmSize]; gBest = new double[swarm[0].position.length]; gBestFitness = Double.MAX_VALUE; for (int i = 0; i < swarmSize; i++) { swarm[i] = new Particle(gBest.length); for (int j = 0; j < gBest.length; j++) { swarm[i].position[j] = Math.random() * 10; // 初始化粒子位置 swarm[i].velocity[j] = Math.random() * 2; // 初始化粒子速度 } } } // 更新粒子位置和速度 public void update() { for (int i = 0; i < swarmSize; i++) { Particle p = swarm[i]; for (int j = 0; j < p.position.length; j++) { // 更新速度 p.velocity[j] = w * p.velocity[j] + c1 * Math.random() * (p.pBest[j] - p.position[j]) + c2 * Math.random() * (gBest[j] - p.position[j]); // 更新位置 p.position[j] += p.velocity[j]; } // 更新个体最优位置 double fitness = evaluate(p.position); if (fitness < p.fitness) { p.fitness = fitness; System.arraycopy(p.position, 0, p.pBest, 0, p.position.length); } // 更新全局最优位置 if (fitness < gBestFitness) { gBestFitness = fitness; System.arraycopy(p.position, 0, gBest, 0, p.position.length); } } } // 计算适应度值 public double evaluate(double[] x) { // TODO: 根据具体问题实现适应度函数 return 0; } // 运行粒子群算法 public void run() { for (int i = 0; i < maxIter; i++) { update(); } } } // 使用粒子群算法解决函数优化问题的例子 public class Main { public static void main(String[] args) { PSO pso = new PSO(30, 100, 0.6, 1.5, 1.5); pso.run(); System.out.println("最优解：" + Arrays.toString(pso.gBest)); System.out.println("最优适应度值：" + pso.gBestFitness); } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

兴诚

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

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

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

打赏作者

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

抵扣说明：

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

余额充值