Java实战：遗传算法

最新推荐文章于 2022-08-29 19:50:00 发布
最新推荐文章于 2022-08-29 19:50:00 发布
阅读量1.4k 收藏 16
点赞数 3
分类专栏： Java实战 文章标签： java 计算智能导论 原力计划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41684249/article/details/115144179
版权
本文详细介绍了使用遗传算法解决包含30个自变量的目标函数f(x)最小值问题。从编码、解码、适应度函数、选择、交叉、变异等步骤进行了深入阐述，并提供了相应的Java代码实现。实验结果显示，随着迭代次数增加，目标函数的最小值逼近-3268995.485765472。最后，通过Python对实验结果进行了可视化展示。
摘要由CSDN通过智能技术生成

一、题目

在这里插入图片描述

使用遗传算法求解 f（x）目标函数的最小值。

由题可知，f（x）是一个30元函数，即含有30个自变量。

二、原理

2.1 基础

个体：染色体带有特征的实体，本题中是指 f（x）的潜在解的二进制编码形式。
群体：个体的集合，群体的数量由用户确定。
目标函数：f（x）就是一个目标函数，我们想要得到该目标函数的最小值。
适应度：根据目标函数确定用于区分群体中个体好坏的度量方式。
基因：染色体的内部表现，在这指二进制位（0或者1）。

2.2 编码与解码

编码：

编码就是对问题潜在解进行“数字化”的方式。

在本题中，潜在解由30个自变量组成，我们需要将潜在解进行二进制编码。

如何确定单个自变量的二进制位数？

假设自变量的精度为小数点后2位，那么为了保证精度，需要将[-5, 5]的区间平均分为10×10^2份。

512 = 2^9 < [5-（-5）]×10^2 = 1000 < 2^10 = 1024

所以编码的单个自变量的二进制位数为10。

本题中，一个潜在解由30个自变量组成，因此，该潜在解由30个位数为10的二进制数拼接组成，即是一个位数为300二进制。

解码：

解码就是将编码的数进行实数化。

本题中，由于一个潜在解由30个自变量二进制数拼接而成，因此在解码前，需要对其进行裁剪操作。

在这里插入图片描述

a：自变量范围的下界（最小值）。
b：自变量范围的上界（最大值）。
x：自变量二进制转换为十进制的实数。
y：自变量解码后的真实值。
m：单个自变量二进制位数。

y = -5 +  x × [ 5 - （-5）] / (2^10 - 1)

裁剪后通过上式对各个自变量二进制数进行解码。

2.3 适应度函数

适应度函数也称评价函数，是根据目标函数确定的，用于区分群体中个体好坏的标准。

适应度函数总是非负的，而目标函数可能有正有负，故需要在目标函数与适应度函数之间进行变换。

在这里插入图片描述

上式为本题的适应度函数，该式在区间内都是非负的，并且适应度函数的值越大，其目标函数的值越小，符合题意。

2.4 选择

选择实际上就是一个“优胜劣汰”的过程。适应度越大的个体将被更大概率的选中保留到下一代，适应度较小的个体更容易被淘汰。

在本次实验中，每次将保留适应度排在群体前50%的个体，适应度排在后50%的个体将被新的随机初始化的个体替换。

2.5 交叉

交叉是指有一定概率的对两个相互配对的染色体按某种方式相互交换其部分基因，从而形成两个新的个体。

这个概率是由用户确定的，一般为0.5。

本实验中，交叉的方法是将染色体依次两两配对，随机在一对染色体上选取一点分成两段，然后互换重组为新的两条染色体。

在交叉这一步，有更好的策略是只选取选择得到的适应度高的个体进行交叉，并且可以选择交叉后保留原个体。

2.6 变异

复制时可能（很小的概率）产生某些复制差错，变异产生新的染色体，表现出新的性状。

这个概率是由用户确定的，一般为0.01。

本实验中，在染色体上随机选取一位，翻转其二进制位。

三、程序实现

3.1 编码类

初始化群体中的染色体，实际上就是潜在解。潜在解由30个自变量组成，每个自变量二进制位数为10，所以一个潜在解的二进制位数为300。

/**
 * 编码类：初始化群体，一个群体中有多条染色体。对染色体进行编码。
 * 染色体即是个体。
 */
public class Code {
    /**
     * 随机初始化一条染色体。
     * @param GENE 染色体的位数，位数是根据自变量x范围确定的。
     * @return 返回二进制染色体。例如011000110
     */
    public String codeSingle(int GENE){
        String res = ""; // 定义为字符串型，这样子的话+就是在字符串尾部添加。
        for(int i = 0; i < GENE; i++){
            if(Math.random() < 0.5){ // 随机添加0或者1
                res += 0;
            }else{
                res += 1;
            }
        }
        return res;
    }
    /**
     * 随机初始化一组染色体
     * @param GENE 染色体的位数
     * @param groupsize 种群中存在染色体的个数
     * @return 返回所有二进制染色体
     */
    public String[] codeAll(int GENE,int groupsize){
        String[] iAll = new String[groupsize];
        for(int i = 0; i < groupsize; i++){
            iAll[i] = codeSingle(GENE);
        }
        return iAll;
    }
}

3.2 解码类

将潜在解的二进制数拆分为30个二进制数，然后解码。

/**
 * 解码类：对二进制染色体进行解码操作。
 */
public class Decode {
    /**
     * 单个染色体解码
     * @param single 染色体字符串（二进制）
     * @param GENE 染色体位数
     * @return 自变量x的值
     */
    public double[] decode(String single,int GENE) {
        int[] a = new int[GAmain.NUM];
        // 裁剪分段
        for (int i = 0; i < GAmain.NUM; i++) {
            a[i] =  Integer.parseInt(single.substring(i * (GENE / 30), (i + 1) * (GENE / 30)), 2);
        }
        // 解码
        double[] x = new double[GAmain.NUM];
        for (int i = 0; i < GAmain.NUM; i++) {
            x[i] = a[i] * (5 - (-5)) / (Math.pow(2, GENE / 30) - 1) - 5;
        }
        return x;
    }
}

3.3 适应度类

将解码后的潜在解代入适应度函数中，求出个体的适应度，适应度越大，更有机会进入下一代。

import java.lang.Math;
/**
 * 适应度类：将个体解码然后通过公式进行换算。
 */
public class Fitness {
    /**
     * 计算个体的适应度
     * @param str 染色体二进制数
     * @param GENE 染色体二进制位数
     * @return 适应度的值
     */
    public double fitSingle(String str, int GENE){
        Decode decode = new Decode();
        double[] x = decode.decode(str, GENE);
        //适应度计算公式
        double f1 = 0;
        double f2 = 0;
        double c1 = 20;
        double c2 = 0.2;
        double c3 = 2 * Math.PI;
        for (int i = 0; i < 30; i++) {
            f1 += Math.pow(x[i], 2) / 2;
            f2 += Math.cos(c3 * x[i]) / 2;
        }
        double fitness = c1 * Math.exp(-c2 * Math.pow(f1, 0.5)) + Math.exp(f2);
        return fitness;
    }
    /**
     * 批量计算数组的适应度
     * @param str 染色体数组
     * @param GENE 染色体位数
     * @return 适应度数组
     */
    public double[] fitAll(String str[], int GENE){
        double [] fit = new double[str.length];
        for(int i = 0;i < str.length; i++){
            fit[i] = fitSingle(str[i], GENE);
        }
        return fit;
    }
    /**
     * 适应度最值（返回序号）
     * @param fit 适应度数组
     * @return 适应度最大的序号
     */
    public int mFitNum(double fit[]){
        double m = fit[0];
        int n = 0;
        for(int i = 0;i < fit.length; i++){
            if(fit[i] > m){
                m = fit[i]; // 最大值
                n = i;
            }
        }
        return n;
    }
    /**
     * 适应度最值（返回适应度）
     * @param fit 适应度数组
     * @return 适应度最大的值
     */
    public double mFitVal(double fit[]){
        double m = fit[0];
        for(int i = 0;i < fit.length; i++){
            if(fit[i] > m){
                m = fit[i]; // 最大值
            }
        }
        return m;
    }
}

3.4 选择类

选择进入下一代的染色体，将保留适应度排在群体前50%的个体，适应度排在后50%的个体将被新的随机初始化的个体替换。

/**
 * 选择类
 */
public class Selection {
    Code init = new Code();
    Fitness fitness = new Fitness();
    /**
     * 选择
     * @param group 群体数组
     * @param GENE 染色体二进制数
     * @return 新的二进制染色体数组
     */
    public String[] RWS(String group[], int GENE){
        String[] newgroup = new String[group.length];
        double[] fit = fitness.fitAll(group, GENE);	// 计算适应度数组

        // 冒泡排序算法 fit和group数组进行小到大排序
        for (int i = 0; i < fit.length; i++) {
            for (int j = 0; j < fit.length-1-i; j++){
                if (fit[j] > fit[j+1]){
                    double temp = fit[j];
                    fit[j] = fit[j+1];
                    fit[j+1] = temp;

                    String stringTemp = group[j];
                    group[j] = group[j+1];
                    group[j+1] = stringTemp;
                }
            }
        }

        // 根据适应度大小排序，排在前一半的被选中，后一半的被淘汰
        for (int i = 0; i < fit.length; i++){
            //适应度最大的个体直接继承
            if(i > fit.length/2){
                newgroup[i] = group[i];
            }
            else {
                newgroup[i] = init.codeSingle(GENE);	// 如果没被选中，被外来者取代
            }
        }
        return newgroup;
    }
}

3.5 交叉类

将染色体依次两两配对，随机在一对染色体上选取一点分成两段，然后互换重组为新的两条染色体。

需要设置交叉率，一般设置为0.5。

/**
 * 交叉类：将染色体依次两两配对，随机在一对染色体上选取一点分成两段，然后互换重组为新的两条染色体。
 */
public class Cross {
    Fitness fitness = new Fitness();
    /**
     *
     * @param group 群体数组
     * @param GENE 染色体二进制位数
     * @param crossRate 交叉率
     * @return
     */
    public String[] cross(String[] group,int GENE,double crossRate){
        String temp1, temp2;
        int pos = 0;

        double[] fit = fitness.fitAll(group, GENE);
        int mFitNum = fitness.mFitNum(fit);	// 计算适应度最大的染色体序号
        String max = group[mFitNum];

        for(int i = 0; i < group.length; i++){
            if(Math.random() < crossRate){
                pos = (int)(Math.random()*GENE) + 1;	//交叉点
                temp1 = group[i].substring(0, pos) + group[(i+1) % group.length].substring(pos);	//%用来防止数组越界
                temp2 = group[(i+1) % group.length].substring(0, pos) + group[i].substring(pos);
                group[i] = temp1;
                group[(i+1) % group.length] = temp2;
            }
        }
        group[0] = max;
        return group;
    }
}

3.6 变异类

在染色体上随机选取一位，翻转其二进制位。

需要设置变异概率，这里取0.01，即100个个体会有一个个体发生变异。

/**
 * 变异
 */
public class Mutation {
    //替换String中的指定位
    //str要改动的字符串
    //num要改动的位（从0开始数）
    //pos要把这一位改动成什么
    public String replacePos(String str,int num,String pos){
        String temp;
        if(num == 0){
            temp = pos + str.substring(1);
        }else if(num == str.length()-1){
            temp = str.substring(0, str.length() - 1) + pos;
        }else{
            String temp1 = str.substring(0, num);
            String temp2 = str.substring(num + 1);
            temp = temp1 + pos + temp2;
        }
        return temp;
    }
    
    public String[] mutation(String[] group,int GENE,double MP){
        Fitness fitness = new Fitness();
        double[] fit = fitness.fitAll(group,GENE);
        int mFitNum = fitness.mFitNum(fit);	//计算适应度最大的染色体序号
        String max = group[mFitNum];

        for(int i = 0; i < group.length * MP; i++){
            int n = (int) (Math.random() * GENE * group.length );	//从[0，GENE * group.length)区间取随机数
            int chrNum = (int) (n / GENE);	//取得的染色体数组下标
            int gNum = (int)(n % GENE); 	//取得的基因下标
            String temp = "";

            if(group[chrNum].charAt(gNum) == '0' ){
                temp = replacePos(group[chrNum], gNum, "1");
            }else{
                temp = replacePos(group[chrNum], gNum, "0");
            }
            group[chrNum] = temp;
        }
        group[0] = max;
        return group;
    }
}

3.7 日志类

将结果记录到log.txt文件中。

import java.io.*;
/**
 * 日志类，记录结果。
 */
public class Logger {
    public static void log(String msg) {
        try {
            BufferedWriter out = new BufferedWriter(new FileWriter("log.txt", true));
            out.write(msg);
            out.flush();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

3.8 主程序

public class GAmain {
    public static final int groupsize = 100;	//染色体数（群体中个体数）
    public static final double MP = 0.01;	//变异概率
    public static final double CP = 0.5;	//交叉概率
    public static final int ITERA = 100000;	//迭代次数
    public static final int NUM = 30; // 群体中的个体数量
    public static final int GENE = 10 * NUM;	// 潜在解二进制位数
    /**
     * 输出适应度最大值,以及返回最优的个体,测试用
     * @param str 完成
     * @param group 群体数组
     * @return 返回最大值的染色体序号
     */
    public int outMax(String str,String[] group){
        Fitness fitness = new Fitness();
        double[] fit = fitness.fitAll(group, GENE);
        double max = fitness.mFitVal(fit);
        System.out.println(str+"后适应度最大值为"+max);
        return fitness.mFitNum(fit);
    }
    // 程序入口
    public static void main(String[] args) {
        Code init = new Code();
        Fitness fitness = new Fitness();
        Selection rws = new Selection();
        Cross cross = new Cross();
        Mutation mutation = new Mutation();
        Decode decode = new Decode();
        GAmain ga = new GAmain();

        String group[] = init.codeAll(ga.GENE, groupsize);	//初始化

        for(int i = 0; i < ITERA; i++){
            group = rws.RWS(group, ga.GENE); //选择
            group = cross.cross(group,ga.GENE,CP);	//交叉
            group = mutation.mutation(group, ga.GENE, MP);	//变异

            if (i % 200 == 0) {
                double[] fit = fitness.fitAll(group, GENE);
                int max = fitness.mFitNum(fit);
                double result = -fitness.fitSingle(group[max], ga.GENE) + 20 + 2.71282;
                String msg = i / 200 + " " + result + "\n";
                Logger.log(msg);
                System.out.println("目标函数结果为：" + result);
            }
        }
    }
}

四、实验结果

4.1 Python可视化

读取记录下来的log.txt文件，对数据进行可视化绘图。

import os
import matplotlib.pyplot as plt
# 读取log.txt文件
with open(os.path.join("log.txt"), 'r') as fd:
    dataList = fd.readlines()
dataList = [l[:-1] for l in dataList] # 把/n去掉
# 将数据放入list中
data = []
iters = []
for i in range(len(dataList)):
    sample = dataList[i].split()
    data.append(float(sample[1]))
    iters.append(int(sample[0]))
# 绘图
plt.title("Result GA")
plt.plot(iters, data, color='blue')
plt.xlabel("iters")
plt.ylabel("result")
plt.savefig("Result_GA")
plt.show()

4.2 实验结果

在这里插入图片描述

横坐标是迭代次数，纵坐标是目标函数的结果。

增加迭代次数，求得该目标函数的最小值近似为：-3268995.485765472（不一定是正确答案，但应该是接近了）。

五、总结

在本次实验中，还尝试了赌轮盘+最佳保留的选择方法，将适应度最高的个体保留到下一代，然后其余个体通过概率进行选择。这个概率对应于适应度，适应度越大，概率越高。

但是实验发现，对于本题，赌轮盘+最佳保留的选择方法寻找最优解太慢。所以最终使用了每次将保留适应度排在群体前50%的个体，适应度排在后50%的个体将被新的随机初始化的个体替换的策略。

Ma lidong
关注
  • 3
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA实现遗传算法
小鸡慢慢的专栏
12-12 4万+
转载请注明出处：http://blog.csdn.net/xiaojimanman/article/details/50277547 http://www.llwjy.com/blogdetail/8d8f9fa295e57c774c2b8223166aee1b.html 个人博客站已经上线了，网址 www.llwjy.com ~欢迎各位吐槽~ -----------------------...
遗传算法使用Java实现
luchi007的专栏
12-10 722
最近需要学习神经网络，对于神经网络问题的求解其中需要用到遗传算法，所以今天学习了一下遗传算法，主要参看了 http://blog.csdn.net/emiyasstar__/article/details/6938608这篇博客的文章，同时将其使用C++实现的程序用Java再次实现了一遍，不足之处还请指出多包涵   遗传算法：也称进化算法 。 遗传算法是受达尔文的进化论的启发，借鉴生物进化过...
用Java实现简单的遗传算法
爱上Java8
08-17 1369
遗传算法是解决复杂问题的一种搜索策略，是一种智能计算。他模拟自然界中的种群进化。从这点看，它和神经网络这些算法的起源很像，都是使用计算机去模拟一些自然法则和运作规律。同样，和神经网络一样，遗传算法也是一种基于概率的算法。当然，在现代启发式算法中，很多算法都都是基于概率的，比如神经网络，粒子群算法，模拟退火等。这类方法的要解决的一个问题就是NP问题，要求得结果是满意解，而非最优解。理解这点，我觉得很
一个简单的遗传算法应用（java版）
weixin_30371875的博客
04-04 78
计算智能课的遗传算法上完了，老师布置了一个简单的应用，用java实现了下。 首先是题目要求： A given function is as follows: Use genetic algorithm to find a near-maximal value in f==xsin(10*pi*x)+2 [-1,2]. In addition, the required ...
java：实现遗传算法
04-03
遗传算法的步骤： （1）染色体的编码与解码 对于区间[a,b]上的值x进行解码表示；对于某一个个体的编码为b1,b2,...,bn,解码后对应的参数x值为： x=a+(b-a)/(2^n-1)sum(bk*2^(k-1)).....k=1,2,...n; (2)个体适应度函数 对于目标函数最大化问题，采用Fitness(f(x))=f(x)-Cmin ，f(x)>Cmin ，其中Cmin为目标函数的最小估计； =0, 其他 对于目标函数最小化问题，采用Fitness(f(x))=Cmax-f(x) , f(x)<Cmax，其中Cmin为目标函数的最大估计； =0, 其它 （3）选择算子 选择思想：轮盘赌选择 假设第t代种群P（t）中共有N个染色体xi(1<=i<=N),各染色体的适应值为f(xi),故染色体xi被选中的概率为： P(xi)=f(xi)/sum(f(xj)), j=1,2,...N. (4)交叉算子 Pc:交叉概率；范围在0.4---0.99之间 交叉准则：可以
编程项目实战：基于JAVA技术的遗传算法的中药药对挖掘系统的设计与实现(源代码+论文)
06-23
关联规则是形如A=>B的蕴涵式，挖掘关联规则分为两步：第一步是识别所有的频繁项集，即支持度不小于用户指定的最小支持度的项集；第二步是从频繁项集中构造其置信度不低于用户给定最小置信度的规则，即强规则。...
java-algorithm:Java算法实践资料库
03-14
3. **进阶算法**：如字符串匹配算法（KMP、Boyer-Moore）、贪心算法、回溯法、分支限界法、遗传算法、模拟退火算法等复杂算法的Java实现，这些可以帮助解决更复杂的问题。 4. **面试题目**：资料库可能会包含一些...
JAVA遗传算法编程pdf版本书籍
03-09
《JAVA遗传算法编程》这本书是面向对遗传算法有兴趣并希望通过Java语言进行实现的读者的一本专业指南。遗传算法（Genetic Algorithm，简称GA）是一种基于生物进化论中的自然选择和遗传原理的优化方法，它在解决复杂...
经典遗传算法的Java实现以及遗传算法实现自动组卷（完整源码+说明）.zip
03-28
【资源说明】 1、该资源内项目代码都是经过测试运行成功，功能正常的情况下才上传的，请...3、不仅适合小白学习实战练习，也可作为大作业、课程设计、毕设项目、初期项目立项演示等，欢迎下载，互相学习，共同进步！
JAVA基于遗传算法的中药药对挖掘系统的设计与实现(源代码+论文).rar
最新发布
08-13
【优秀课程设计】主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也可作为课程设计、期末大作业。 包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ ...
遗传算法（GeneticAlgorithm）的Java实现源码工程
11-26
遗传算法（GeneticAlgorithm）的Java实现源码工程，可导入eclipse后可直接运行工程，main方法在类GeneticAlgorithmTest文件中。带有图形界面动态展示遗传算法的收敛过程。你可以在此基础上改动后运用于你的项目中。
遗传算法经典Java实现
04-12
遗传算法是解决最优解的。其代码是java实现，且有main函数可以方便自行调试查看运行结果。
java实现遗传算法的类库
10-08
java实现遗传算法的类库，包括英文的参考文档，提供遗传算法的各种支持。有编码支持，基因染色体扩展，选择算法、交叉算法、变异算法的各种支持。
JGAP--Java编写的遗传算法包
10-05
JGAP 是一款用Java编写的遗传算法包，由sourceforce上开发而来。它提供了基本的遗传算法，你可以使用它来解决一些适合用遗传算法解决的问题。而且它给出了很多例子程序，可用于我们一些遗传算法的测试工作。由于它来自于开源组织sourceforce，所以开源的遗传功能将是研究简单遗传算法很好工具。
遗传算法java实现
08-11
运输路线和方式规划问题研究的遗传算法java实现代码，可以运行~
遗传算法Java实现版
luchi007的专栏
12-10 451
ttp://blog.csdn.net/emiyasstar__/article/details/6938608这篇博客的文章，同时将其使用C++实现的程序用Java再次实现了一遍，不足之处还请指出多包涵遗传算法：也称进化算法 。 遗传算法是受达尔文的进化论的启发，借鉴生物进化过程而提出的一种启发式搜索算法。因此在介绍遗传算法前有必要简单的介绍生物进化知识遗传算法教科书上的步骤：      1.评估每条染色体所对应个体的适应度。      2.遵照适应度越高，选择概率越大的原则，从种群中选择两个个体作为父方
java 遗传算法库,哪些遗传算法的Java库/库？
weixin_39538536的博客
03-02 278
I want to implement some simple genetic algorithms in Java.So far I found only JGAP. Did somebody has some experience with that? And do you know other Java libraries for GA?I do not want to write it m...
Java:实现一种遗传算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-29 619
Java:实现一种遗传算法（附完整源码）
Java遗传算法库Jenetics安装
随笔
02-11 1974
摘 要：Jenetics是一个使用现代的Java面向对象程序设计语言的高级的遗传算法库。本文介绍了Jenetics的安装以及HelloWorld运行。 【Java遗传算法库Jenetics安装】 如果你有什么疑问，可以在下面留言。 ...
Java语言解析遗传算法实战
"本书《Genetic Algorithms in Java Basics》由Lee Jacobson和Burak Kanber合著，深入浅出地介绍了如何使用Java语言实现遗传算法，并通过解决旅行推销员问题等经典问题来阐述其应用。" 遗传算法是一种模拟自然选择...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Ma lidong

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

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

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

打赏作者

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

抵扣说明：

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

余额充值