AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【智能算法】AFSA人工鱼群算法求解无约束多元函数最值(Java代码实现)

2022-12-07 171
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
应用型负载均衡 ALB，每月750个小时 15LCU
传统型负载均衡 CLB，每月750个小时 15LCU
网络型负载均衡 NLB，每月750个小时 15LCU
简介： 【智能算法】AFSA人工鱼群算法求解无约束多元函数最值(Java代码实现)

@[toc]

前言

本文以求解二元函数最小值为例，如果需要求解多元函数，只需要修改以下变量即可：

  • varNum：变量维度数
  • ub和lb：变量的上下界
  • vMaxArr：每个维度的搜索速度限制

优化目标

目标：在变量区间范围最小化 Z = x^2 + y^2 - xy - 10x - 4y +60

求解结果

变量取值为：[7.996330803705318, 6.022624753356061]
最优解为：8.000608357127064

迭代结果可视化

在这里插入图片描述

算法流程

在这里插入图片描述

Java代码

import java.util.Arrays;
import java.util.Random;

/**
 * @Author：WSKH
 * @ClassName：AFSA_Solve
 * @ClassType：
 * @Description：
 * @Date：2022/6/8/18:26
 * @Email：1187560563@qq.com
 * @Blog：https://blog.csdn.net/weixin_51545953?type=blog
 */
public class AFSA_Solve {

    // 鱼对象
    class Fish {
        // 当前鱼的坐标（自变量数组）
        double[] curVars;
        // 当前自变量对应的目标函数值
        double curObjValue;
        // 适应度（解决最小化问题，所以适应度为目标函数值的倒数）
        double fit;
        // 全参构造
        public Fish(double[] curVars, double curObjValue, double fit) {
            this.curVars = curVars;
            this.curObjValue = curObjValue;
            this.fit = fit;
        }
    }

    // 算法参数
    // 变量个数
    int varNum = 2;
    // 最大迭代次数
    int maxGen = 500;
    // 鱼群中鱼的个数
    int fishNum = 300;
    // 每次的最大觅食次数
    int preyCnt = 20;
    // 鱼的最大感知距离
    double visual = 50;
    // 可接受的拥挤程度
    double crowdedRate = 0.6;
    // 步长数组（各个维度的步长）
    double[] stepArr = new double[]{6, 6};
    // 变量的上下界
    double[] ub = new double[]{1000, 1000};
    double[] lb = new double[]{-1000, -1000};
    // 随机数对象
    Random random = new Random();
    // 鱼群
    Fish[] fishes;
    // 最佳的鱼
    Fish bestFish;
    // 记录迭代过程
    public double[][][] positionArr;
    // 当前记录的行数
    int r;

    // 求解主函数
    public void solve() {
        // 初始化鱼群
        initFishes();
        // 开始迭代
        for (int t = 0; t < maxGen; t++) {
            // 聚群行为
            AFSwarm();
            report();
            // 追尾
            AFFollow();
            report();
            // 觅食
            AFPrey();
            report();
        }
        for (Fish fish : fishes) {
            if (fish.fit > bestFish.fit) {
                bestFish = fish;
            }
        }
        // 输出最好的结果
        System.out.println("变量取值为：" + Arrays.toString(bestFish.curVars));
        System.out.println("最优解为：" + bestFish.curObjValue);
    }

    // 移动行为(在鱼群的移动过程中，当一条鱼或几条鱼找到食物时，附近的伙伴会迅速移动并到达食物)
    void AFFollow() {
        for (int i = 0; i < fishes.length; i++) {
            // 探索视野内的鱼有多少条，并找到最大适应值的鱼
            int friendCount = 0;
            Fish maxFish = copyFish(fishes[i]);
            for (int j = 0; j < fishes.length; j++) {
                if (i != j && getDistance(fishes[i], fishes[j]) <= visual) {
                    friendCount++;
                    if (fishes[j].fit > maxFish.fit) {
                        maxFish = copyFish(fishes[j]);
                    }
                }
            }
            // 如果周围不拥挤，且两个鱼的目标函数不相等
            if ((double) friendCount / fishNum <= crowdedRate && Math.abs(maxFish.curObjValue - fishes[i].curObjValue) > 0.0000001) {
                // 尝试往最大适应值位置游
                Fish tempFish = copyFish(fishes[i]);
                double distance = getDistance(maxFish, tempFish);
                for (int m = 0; m < varNum; m++) {
                    double move = (maxFish.curVars[m] - tempFish.curVars[m]) / (distance) * stepArr[m] * random.nextDouble();
                    moveFish(tempFish, m, move);
                }
                tempFish.curObjValue = getObjValue(tempFish.curVars);
                tempFish.fit = 1 / tempFish.curObjValue;
                if (tempFish.fit > fishes[i].fit) {
                    fishes[i] = tempFish;
                } else {
                    // 否则，进行觅食
                    AFPrey(i);
                }
            } else {
                // 否则，进行觅食
                AFPrey(i);
            }
        }
    }

    // 聚群行为(鱼群在移动的过程中会自然地成群聚集，这是一种生活习惯，可以保证群体的存在，避免危险)
    void AFSwarm() {
        for (int i = 0; i < fishes.length; i++) {
            // 探索视野内的鱼有多少条，并计算周围鱼群的中心
            double[] midPoint = new double[varNum];
            int friendCount = 0;
            for (int j = 0; j < fishes.length; j++) {
                if (i != j && getDistance(fishes[i], fishes[j]) <= visual) {
                    friendCount++;
                    for (int m = 0; m < varNum; m++) {
                        midPoint[m] += fishes[j].curVars[m];
                    }
                }
            }
            // 计算中心
            for (int m = 0; m < midPoint.length; m++) {
                midPoint[m] /= friendCount;
            }
            double objValue = getObjValue(midPoint);
            // 获取中心的鱼
            Fish midFish = new Fish(midPoint, objValue, 1 / objValue);
            // 如果中心不拥挤
            if ((double) friendCount / fishNum <= crowdedRate) {
                // 尝试往中心位置游
                Fish tempFish = copyFish(fishes[i]);
                double distance = getDistance(midFish, tempFish);
                for (int m = 0; m < varNum; m++) {
                    double move = (midPoint[m] - tempFish.curVars[m]) / (distance) * stepArr[m] * random.nextDouble();
                    moveFish(tempFish, m, move);
                }
                tempFish.curObjValue = getObjValue(tempFish.curVars);
                tempFish.fit = 1 / tempFish.curObjValue;
                if (tempFish.fit > fishes[i].fit) {
                    fishes[i] = tempFish;
                } else {
                    // 否则，进行觅食
                    AFPrey(i);
                }
            } else {
                // 否则，进行觅食
                AFPrey(i);
            }
        }
    }

    // 觅食行为(这是鱼类对食物的基本生物学行为。一般来说，鱼通过视觉感知水中食物的浓度来决定向哪移动，然后选择移动的方向)
    void AFPrey(int i) {
        // 尝试觅食preyCnt次
        for (int j = 0; j < preyCnt; j++) {
            Fish tempFish = copyFish(fishes[i]);
            for (int m = 0; m < varNum; m++) {
                moveFish(tempFish, m, visual * (random.nextDouble() - 0.5) * 2);
            }
            tempFish.curObjValue = getObjValue(tempFish.curVars);
            tempFish.fit = 1 / tempFish.curObjValue;
            if (tempFish.fit > fishes[i].fit) {
                double distance = getDistance(tempFish, fishes[i]);
                // 觅食成功，向成功方向移动
                for (int m = 0; m < varNum; m++) {
                    double move = (tempFish.curVars[m] - fishes[i].curVars[m]) / (distance) * stepArr[m] * random.nextDouble();
                    moveFish(fishes[i], m, move);
                }
                fishes[i].curObjValue = getObjValue(fishes[i].curVars);
                fishes[i].fit = 1 / fishes[i].curObjValue;
            } else {
                // 觅食失败，随机移动
                for (int m = 0; m < varNum; m++) {
                    double move = stepArr[m] * (random.nextDouble() - 0.5) * 2;
                    moveFish(tempFish, m, move);
                }
                tempFish.curObjValue = getObjValue(tempFish.curVars);
                tempFish.fit = 1 / tempFish.curObjValue;
                if(tempFish.fit > fishes[i].fit){
                    fishes[i] = tempFish;
                }
            }
        }
    }
    void AFPrey(){
        for (int i = 0; i < fishes.length; i++) {
            AFPrey(i);
        }
    }

    // 记录
    void report(){
        for (int i = 0; i < fishes.length; i++) {
            for (int j = 0; j < varNum; j++) {
                positionArr[r][i][j] = fishes[i].curVars[j];
            }
        }
        r++;
    }

    // 初始化鱼群
    private void initFishes() {
        positionArr = new double[3*maxGen][fishNum][varNum];
        fishes = new Fish[fishNum];
        for (int i = 0; i < fishNum; i++) {
            fishes[i] = getRandomFish();
            if (i == 0 || bestFish.fit < fishes[i].fit) {
                bestFish = copyFish(fishes[i]);
            }
        }
    }

    // 控制鱼在第m个维度上移动n个距离
    public void moveFish(Fish fish, int m, double n) {
        // 移动
        fish.curVars[m] += n;
        // 超出定义域的判断
        if (fish.curVars[m] < lb[m]) {
            fish.curVars[m] = lb[m];
        }
        if (fish.curVars[m] > ub[m]) {
            fish.curVars[m] = ub[m];
        }
    }

    // 求两条鱼之间的距离
    double getDistance(Fish f1, Fish f2) {
        double dis = 0d;
        for (int i = 0; i < varNum; i++) {
            dis += Math.pow(f1.curVars[i] - f2.curVars[i], 2);
        }
        return Math.sqrt(dis);
    }

    // 求两点之间的距离
    double getDistance(double p1, double p2) {
        return Math.sqrt(Math.pow(p1 - p2, 2));
    }

    // 获取一个随机生成的鱼
    Fish getRandomFish() {
        double[] vars = new double[varNum];
        for (int j = 0; j < vars.length; j++) {
            vars[j] = lb[j] + random.nextDouble() * (ub[j] - lb[j]);
        }
        double objValue = getObjValue(vars);
        return new Fish(vars.clone(), objValue, 1 / objValue);
    }

    /**
     * @param vars 自变量数组
     * @return 返回目标函数值
     */
    public double getObjValue(double[] vars) {
        //目标：在变量区间范围最小化 Z = x^2 + y^2 - xy - 10x - 4y +60
        return Math.pow(vars[0], 2) + Math.pow(vars[1], 2) - vars[0] * vars[1] - 10 * vars[0] - 4 * vars[1] + 60;
    }

    // 复制鱼
    Fish copyFish(Fish old) {
        return new Fish(old.curVars.clone(), old.curObjValue, old.fit);
    }

}

可视化代码

import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.control.Button;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.paint.Color;
import javafx.stage.Stage;
import javafx.util.Duration;

/**
 * @Author：WSKH
 * @ClassName：PlotUtil
 * @ClassType：
 * @Description：
 * @Date：2022/6/6/18:31
 * @Email：1187560563@qq.com
 * @Blog：https://blog.csdn.net/weixin_51545953?type=blog
 */
public class PlotUtil extends Application {

    //当前的时间轴
    private Timeline nowTimeline;
    //绘图位置坐标
    private double[][][] positionArr;

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) throws Exception {

        // 调用算法获取绘图数据
        AFSA_Solve solver = new AFSA_Solve();
        solver.solve();
        positionArr = solver.positionArr;

        // 画图
        try {
            BorderPane root = new BorderPane();
            root.setStyle("-fx-padding: 20;");
            Scene scene = new Scene(root, 1600, 900);
            double canvasWid = 800;
            double canvasHei = 800;
            //根据画布大小缩放坐标值
            this.fixPosition(canvasWid - 100, canvasHei - 100);

            //画布和画笔
            HBox canvasHbox = new HBox();
            Canvas canvas = new Canvas();
            canvas.setWidth(canvasWid);
            canvas.setHeight(canvasHei);
            canvasHbox.setPrefWidth(canvasWid);
            canvasHbox.getChildren().add(canvas);
            canvasHbox.setAlignment(Pos.CENTER);
            canvasHbox.setStyle("-fx-spacing: 20;" +
                    "-fx-background-color: #87e775;");
            root.setTop(canvasHbox);
            GraphicsContext paintBrush = canvas.getGraphicsContext2D();

            //启动
            HBox hBox2 = new HBox();
            Button beginButton = new Button("播放迭代过程");
            hBox2.getChildren().add(beginButton);
            root.setBottom(hBox2);
            hBox2.setAlignment(Pos.CENTER);
            //启动仿真以及暂停仿真
            beginButton.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
                nowTimeline.play();
            });

            //创建扫描线连接动画
            nowTimeline = new Timeline();
            createAnimation(paintBrush);

            primaryStage.setScene(scene);
            primaryStage.show();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 修正cityPositionArr的坐标，让画出来的点在画布内
     *
     * @param width
     * @param height
     */
    private void fixPosition(double width, double height) {
        double minX = Double.MAX_VALUE;
        double maxX = -Double.MAX_VALUE;
        double minY = Double.MAX_VALUE;
        double maxY = -Double.MAX_VALUE;

        for (int i = 0; i < this.positionArr.length; i++) {
            for (int j = 0; j < this.positionArr[0].length; j++) {
                minX = Math.min(minX, this.positionArr[i][j][0]);
                maxX = Math.max(maxX, this.positionArr[i][j][0]);
                minY = Math.min(minY, this.positionArr[i][j][1]);
                maxY = Math.max(maxY, this.positionArr[i][j][1]);
            }
        }

        double multiple = Math.max((maxX - minX) / width, (maxY - minY) / height);

        //转化为正数数
        for (int i = 0; i < this.positionArr.length; i++) {
            for (int j = 0; j < this.positionArr[0].length; j++) {
                if (minX < 0) {
                    this.positionArr[i][j][0] = this.positionArr[i][j][0] - minX;
                }
                if (minY < 0) {
                    this.positionArr[i][j][1] = this.positionArr[i][j][1] - minY;
                }
            }
        }

        for (int i = 0; i < this.positionArr.length; i++) {
            for (int j = 0; j < this.positionArr[0].length; j++) {
                this.positionArr[i][j][0] = this.positionArr[i][j][0] / multiple;
                this.positionArr[i][j][1] = this.positionArr[i][j][1] / multiple;
            }
        }

    }

    /**
     * 用画笔在画布上画出所有的孔
     * 画第i代的所有粒子
     */
    private void drawAllCircle(GraphicsContext paintBrush, int i) {
        paintBrush.clearRect(0, 0, 2000, 2000);
        paintBrush.setFill(Color.RED);
        for (int j = 0; j < this.positionArr[i].length; j++) {
            drawCircle(paintBrush, i, j);
        }
    }

    /**
     * 用画笔在画布上画出一个孔
     * 画第i代的第j个粒子
     */
    private void drawCircle(GraphicsContext paintBrush, int i, int j) {
        double x = this.positionArr[i][j][0];
        double y = this.positionArr[i][j][1];
        double radius = 2;
        // 圆的直径
        double diameter = radius * 2;
        paintBrush.fillOval(x, y, diameter, diameter);
    }

    /**
     * 创建动画
     */
    private void createAnimation(GraphicsContext paintBrush) {
        for (int i = 0; i < this.positionArr[0].length; i++) {
            int finalI = i;
            KeyFrame keyFrame = new KeyFrame(Duration.seconds(i * 0.05), event -> drawAllCircle(paintBrush, finalI));
            nowTimeline.getKeyFrames().add(keyFrame);
        }
    }

}
文章标签：
负载均衡
Java
数据可视化
算法
关键词：
算法代码
Java代码
Java算法
算法java
智能算法
相关实践学习
每个IT人都想学的“Web应用上云经典架构”实战
本实验从Web应用上云这个最基本的、最普遍的需求出发，帮助IT从业者们通过“阿里云Web应用上云解决方案”，了解一个企业级Web应用上云的常见架构，了解如何构建一个高可用、可扩展的企业级应用架构。
WSKH0929
目录
相关文章
游客3g2isv2zt6tuw
|
2月前
|
Java 数据安全/隐私保护
快手小红书抖音留痕工具，自动留痕插件工具，java代码开源
这个框架包含三个核心模块：主操作类处理点赞评论、配置管理类和代理管理类。使用时需要配合
游客3g2isv2zt6tuw
105 39
啦啦啦191
|
1月前
|
算法 IDE Java
Java 项目实战之实际代码实现与测试调试全过程详解
本文详细讲解了Java项目的实战开发流程，涵盖项目创建、代码实现（如计算器与汉诺塔问题）、单元测试（使用JUnit）及调试技巧（如断点调试与异常排查），帮助开发者掌握从编码到测试调试的完整技能，提升Java开发实战能力。
啦啦啦191
223 0
游客3g2isv2zt6tuw
|
2月前
|
Java 机器人 API
tiktok群控脚本，养号关注私信点赞脚本插件，java代码分享
这个代码模拟了一个社交机器人的基本行为模式，包括登录、关注、点赞、私信等操作。请注意
游客3g2isv2zt6tuw
103 4
欲揽西江月
|
2月前
|
Java 编译器 数据库连接
Java异常处理：写出更健壮的代码
Java异常处理：写出更健壮的代码
欲揽西江月
149 0
青云交（Java大数据AI云原生Python）
|
4月前
|
负载均衡 算法 关系型数据库
大数据大厂之MySQL数据库课程设计：揭秘MySQL集群架构负载均衡核心算法：从理论到Java代码实战，让你的数据库性能飙升！
本文聚焦 MySQL 集群架构中的负载均衡算法，阐述其重要性。详细介绍轮询、加权轮询、最少连接、加权最少连接、随机、源地址哈希等常用算法，分析各自优缺点及适用场景。并提供 Java 语言代码实现示例，助力直观理解。文章结构清晰，语言通俗易懂，对理解和应用负载均衡算法具有实用价值和参考价值。
青云交（Java大数据AI云原生Python）
307 14
大数据大厂之MySQL数据库课程设计：揭秘MySQL集群架构负载均衡核心算法：从理论到Java代码实战，让你的数据库性能飙升！
2G冲浪词条
|
4月前
|
人工智能 算法 NoSQL
LRU算法的Java实现
LRU（Least Recently Used）算法用于淘汰最近最少使用的数据，常应用于内存管理策略中。在Redis中，通过`maxmemory-policy`配置实现不同淘汰策略，如`allkeys-lru`和`volatile-lru`等，采用采样方式近似LRU以优化性能。Java中可通过`LinkedHashMap`轻松实现LRUCache，利用其`accessOrder`特性和`removeEldestEntry`方法完成缓存淘汰逻辑，代码简洁高效。
2G冲浪词条
175 0
啦啦啦191
|
2月前
|
安全 Java 测试技术
Java 项目实战中现代技术栈下代码实现与测试调试的完整流程
本文介绍基于Java 17和Spring技术栈的现代化项目开发实践。项目采用Gradle构建工具，实现模块化DDD分层架构，结合Spring WebFlux开发响应式API，并应用Record、Sealed Class等新特性。测试策略涵盖JUnit单元测试和Testcontainers集成测试，通过JFR和OpenTelemetry实现性能监控。部署阶段采用Docker容器化和Kubernetes编排，同时展示异步处理和反应式编程的性能优化。整套方案体现了现代Java开发的最佳实践，包括代码实现、测试调试
啦啦啦191
120 0
啦啦啦191
|
3月前
|
人工智能 前端开发 Java
Java 面试资料中相关代码使用方法与组件封装方法解析
这是一份详尽的Java面试资料代码指南，涵盖使用方法与组件封装技巧。内容包括环境准备（JDK 8+、Maven/Gradle）、核心类示例（问题管理、学习进度跟踪）、Web应用部署（Spring Boot、前端框架）、单元测试及API封装。通过问题库管理、数据访问组件、学习进度服务和REST接口等模块化设计，帮助开发者高效组织与复用功能，同时支持扩展如用户认证、AI推荐等功能。适用于Java核心技术学习与面试备考，提升编程与设计能力。资源链接：[点此下载](https://pan.quark.cn/s/14fcf913bae6)。
啦啦啦191
95 6
Java 面试资料中相关代码使用方法与组件封装方法解析
啦啦啦191
|
2月前
|
SQL Java 数据库连接
Java 期末考试救急必备涵盖绝大多数核心考点及五大类经典代码助你过关
本文为Java期末考试复习指南，涵盖基础语法、面向对象编程、异常处理、文件操作、数据库连接五大核心考点，提供详细解析与实用代码示例，助力快速掌握重点，高效备考，轻松应对考试。
啦啦啦191
70 0

热门文章

最新文章

  • 1
    近端策略优化算法PPO的核心概念和PyTorch实现详解
  • 2
    MARS算法理论和Python代码实现：用分段回归解决非线性时间序列预测问题
  • 3
    【无人机】基于灰狼优化算法的无人机路径规划问题研究（Matlab代码实现）
  • 4
    使用变动和观察（Perturb and Observe）最大功率点跟踪（MPPT）算法控制升压变换器的MOSFET/IGBT（开关），以从光伏阵列中提取最大功率（Simulink仿真实现）
  • 5
    【车间调度】基于GA、PSO、SA、ACO、TS优化算法的车间调度比较研究（Matlab代码实现）
  • 6
    【无人机编队】基于非支配排序遗传算法II NSGA-II高效可行的无人机离线集群仿真研究（Matlab代码实现）
  • 7
    【23年新算法】基于鱼鹰算法OOA-Transformer-BiLSTM多特征分类预测附Matlab代码 （多输入单输出）（Matlab代码实现）
  • 8
    【优化调度】基于matlab粒子群算法求解水火电经济调度优化问题研究（Matlab代码实现）
  • 9
    基于PSO粒子群优化的XGBoost时间序列预测算法matlab仿真
  • 10
    离散粒子群算法（DPSO）的原理与MATLAB实现
  • 1
    综合案例【商品管理系统-Java基础版】（附完整源码）
    460
  • 2
    Java常见异常及对应解决办法
    168
  • 3
    19 Java8概述（Java8概述+lambda表达式+函数式接口+方法引用+Stream+新时间API）
    126
  • 4
    18 Java反射reflect（类加载+获取类对象+通用操作+设计模式+枚举+注解）
    275
  • 5
    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（下）
    164
  • 6
    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（中）
    169
  • 7
    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（上）
    154
  • 8
    16 Java网络编程（计算机网络+网络模型OSI/TCP/IP+通信协议等）
    189
  • 9
    15 Java IO流（File类+IO流+字节流+字符流+字节编码）
    120
  • 10
    13 Java异常（异常过程解析、throw、throws、try-catch关键字）
    276

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • 数据+算法定义新世界
  • 袋鼠云基于实时计算的反黄牛算法
  • Alink：基于Apache Flink的算法平台
    • 下一篇
    蛋白质语言模型 ProGen：在实验室合成由 AI 预测的蛋白质