`
cuiyadll
  • 浏览: 203161 次
文章分类
社区版块
存档分类
最新评论

遗传算法使用Java实现

 
阅读更多

本文引自:http://luchi007.iteye.com/blog/2263061

最近需要学习神经网络,对于神经网络问题的求解其中需要用到遗传算法,所以今天学习了一下遗传算法,主要参看了 http://blog.csdn.net/emiyasstar__/article/details/6938608这篇博客的文章,同时将其使用C++实现的程序用Java再次实现了一遍,不足之处还请指出多包涵

 

遗传算法:也称进化算法 。 遗传算法是受达尔文的进化论的启发,借鉴生物进化过程而提出的一种启发式搜索算法。因此在介绍遗传算法前有必要简单的介绍生物进化知识

 

遗传算法教科书上的步骤:
      1.评估每条染色体所对应个体的适应度。
      2.遵照适应度越高,选择概率越大的原则,从种群中选择两个个体作为父方和母方。
      3.抽取父母双方的染色体,进行交叉,产生子代。
      4.对子代的染色体进行变异。
      5.重复2,3,4步骤,直到新种群的产生。

 

 

我下面说下我所理解的遗传算法,我所理解的遗传算法其实就是“广撒网多捞鱼”,怎么讲?遗传算法一般是先确定初始的群体,群体的每个个体都有两部分组成:1,染色体,也就是基因序列,2,适应性函数 也就是进化能力 ,其中基因序列指的是在实际问题中的一些起主要决定作用的一些特征的编码,主要分为两种:二进制编码和浮点数编码,这种所谓的编码其实就是对应着该“个体”的特征值,而确定了特征编码之后,因为遗传算法还需要进行进化,那么就需要对个体的“适应环[size=medium]境的能力”进行考量,在实际问题中其实也就是距离真正最优解的度量。我理解这个部分的内容为“广撒网阶段”
      在确定初始群体之后,就需要进行选择和进化,其实是选择其中的优胜者得到下一代,选择是依据进化论的“物竞天择”理论,也就是适应度越好的个体越容易被选出来,在算法的实现过程中这一部分一般使用“转盘赌”算法实现,所谓“转盘赌”算法,比如现在有四个个体,适应度分别是3,6,9,12 ,那么选择下一代就相当于在一个四个区域的转盘上转指针,其中3的区域占3/(3+6+9+12)=10%,以此类推,当指针停在哪个区域上表示选中哪个个体,显然,适应度越高的个体越容易被选中,在编程中,一般使用这样的算法:
    第一步:选择一个介于0(本文讨论的内容适应度大多为正,因为为负的话这种转盘赌方法不适用)和总适应度的适应度,也就是可以描述为:rand(0,1)乘以总的适应度,
   第二步骤:将种群的所有个体的适应度进行累加,如果当加到某个个体的时候累加的适应度大于了第一步所得到的适应度,那么就将这个个体取出来
    其实有人会质疑,这种算法实现的转盘赌是不是真的是有效的,我不太清除如何使用使用数学概率推导说明,但是这种方法实现的转盘赌还是有一定道理的,直观的理解就是,假设在前N-1步到了比步骤一的数字小的累加和,那么第N步能够超越步骤一的累加和的数字肯定是偏向适应度大的 那个个体(没有数学上的证明,只是直观想像)
    好了,选择出杂交的后代接下来就是进行产生后代了,产生后代的过程过程其实是染色体交换和基因变异的过程对于二进制编码而言,染色体交换是交换父母的一部分序列,基因变异是其中几个序列由1变成0或者0变为1的过程;对于浮点数编码的话,那么染色体交换是一样的(在下文的例子中间因为基因只有一个浮点数的编码,所以没有用到染色体交换),基因突变是指在原有的浮点数基础上加一点随机噪音(加一点变化步长)

交叉重组的过程可以用下图表示

 
                                       
 
   这样再循环就算是遗传算法了。

 

结合一个例子:求解 f=x*sin(10PI*x)+2在[0,4]之间的最大值


 
这个例子来源于这个博客:http://blog.csdn.net/emiyasstar__/article/details/6938608,题目的背景和步骤都在原博客里面交代的很清楚,这里我主要给出一个Java版本的实现过程:(本人对C++面向对象部分的编程不是很熟悉,所以使用Java实现)

 

阶梯思路是先随机在0-4之间选择一个种群,以横坐标作为其基因序列,以函数值作为其适应度,然后不断的选择-交叉重组-变异,去除适应度(函数值)低的留下适应度高的,然后不断迭代找到最优解


个体类:

Java代码  收藏代码
  1. package com.luchi.genetic;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. /* 
  7.  * 基因载体类 
  8.  * */  
  9. public class Genome {  
  10.       
  11.       
  12.     private List<Double> genomeList=new ArrayList<Double>();  //存放基因序列  
  13.     private double fitness;  //适应度函数值  
  14.     public List<Double> getGenomeList() {  
  15.         return genomeList;  
  16.     }  
  17.     public void setGenomeList(List<Double> genomeList) {  
  18.         this.genomeList = genomeList;  
  19.     }  
  20.     public double getFitness() {  
  21.         return fitness;  
  22.     }  
  23.     public void setFitness(double fitness) {  
  24.         this.fitness = fitness;  
  25.     }  
  26.     public Genome(){  
  27.         super();  
  28.     }  
  29.     public Genome(List<Double> genomeList, double fitness) {  
  30.         super();  
  31.         this.genomeList = genomeList;  
  32.         this.fitness = fitness;  
  33.     }  
  34.       
  35. }  

 主要算法类:

Java代码  收藏代码
  1. package com.luchi.genetic;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Arrays;  
  5. import java.util.List;  
  6. import java.util.Random;  
  7.   
  8. import javax.swing.plaf.synth.SynthSeparatorUI;  
  9.   
  10. /* 
  11.  * 遗传算法 
  12.  * @author:luchi 
  13.  * @date:2015/12/9 
  14.  * @description:使用遗传算法求解最值问题 
  15.  * */  
  16. public class GeneticAlgorithm {  
  17.       
  18.     //放置所有的种群基因信息  
  19.     private List<Genome> population=new ArrayList<Genome>();  
  20.     //种群数量信息  
  21.     private int popSize;  
  22.     //每条染色体总数目  
  23.     private int chromoLength;  
  24.     //种群总的适应度数值  
  25.     private double totalFitness;  
  26.     //种群最好的适应度  
  27.     private double bestFitness;  
  28.     //种群最坏的适应度  
  29.     private double worstFitness;  
  30.     //种群平均的适应度  
  31.     private double averageFitness;  
  32.     //最好的适应度的对应的染色体  
  33.     private Genome bestGenome;  
  34.     //基因突变概率  
  35.     private double mutationRate;  
  36.     //基因交叉概率  
  37.     private double crossoverRate;  
  38.     //遗传的代数(第几代)  
  39.     private int generation;  
  40.     //最大变异步长  
  41.     private double maxPerturbation;  
  42.     //种群适应度的范围,left为左,right为右边    
  43.     private double leftPoint;  
  44.     private double rightPoint;  
  45.     //遗传最大的迭代次数  
  46.     private int iterNum;  
  47.       
  48.     public int getIterNum() {  
  49.         return iterNum;  
  50.     }  
  51.     public void setIterNum(int iterNum) {  
  52.         this.iterNum = iterNum;  
  53.     }  
  54.   
  55.     private Random random=new Random();  
  56.     private MathCalc mathCalc=new MathCalc();  
  57.     public List<Genome> getPopulation() {  
  58.         return population;  
  59.     }  
  60.     public void setPopulation(List<Genome> population) {  
  61.         this.population = population;  
  62.     }  
  63.     public int getPopSize() {  
  64.         return popSize;  
  65.     }  
  66.     public void setPopSize(int popSize) {  
  67.         this.popSize = popSize;  
  68.     }  
  69.     public int getChromoLength() {  
  70.         return chromoLength;  
  71.     }  
  72.     public void setChromoLength(int chromoLength) {  
  73.         this.chromoLength = chromoLength;  
  74.     }  
  75.     public double getTotalFitness() {  
  76.         return totalFitness;  
  77.     }  
  78.     public void setTotalFitness(double totalFitness) {  
  79.         this.totalFitness = totalFitness;  
  80.     }  
  81.     public double getBestFitness() {  
  82.         return bestFitness;  
  83.     }  
  84.     public void setBestFitness(double bestFitness) {  
  85.         this.bestFitness = bestFitness;  
  86.     }  
  87.     public double getWorstFitness() {  
  88.         return worstFitness;  
  89.     }  
  90.     public void setWorstFitness(double worstFitness) {  
  91.         this.worstFitness = worstFitness;  
  92.     }  
  93.     public double getAverageFitness() {  
  94.         return averageFitness;  
  95.     }  
  96.     public void setAverageFitness(double averageFitness) {  
  97.         this.averageFitness = averageFitness;  
  98.     }  
  99.     public Genome getBestGenome() {  
  100.         return bestGenome;  
  101.     }  
  102.     public void setBestGenome(Genome bestGenome) {  
  103.         this.bestGenome = bestGenome;  
  104.     }  
  105.     public double getMutationRate() {  
  106.         return mutationRate;  
  107.     }  
  108.     public void setMutationRate(double mutationRate) {  
  109.         this.mutationRate = mutationRate;  
  110.     }  
  111.     public double getCrossoverRate() {  
  112.         return crossoverRate;  
  113.     }  
  114.     public void setCrossoverRate(double crossoverRate) {  
  115.         this.crossoverRate = crossoverRate;  
  116.     }  
  117.     public int getGeneration() {  
  118.         return generation;  
  119.     }  
  120.     public void setGeneration(int generation) {  
  121.         this.generation = generation;  
  122.     }  
  123.     public double getMaxPerturbation() {  
  124.         return maxPerturbation;  
  125.     }  
  126.     public void setMaxPerturbation(double maxPerturbation) {  
  127.         this.maxPerturbation = maxPerturbation;  
  128.     }  
  129.     public double getLeftPoint() {  
  130.         return leftPoint;  
  131.     }  
  132.     public void setLeftPoint(double leftPoint) {  
  133.         this.leftPoint = leftPoint;  
  134.     }  
  135.     public double getRightPoint() {  
  136.         return rightPoint;  
  137.     }  
  138.     public void setRightPoint(double rightPoint) {  
  139.   
  140.         this.rightPoint = rightPoint;  
  141.     }  
  142.       
  143.     //构造函数初始化参数值  
  144.     public GeneticAlgorithm(int popSize, int chromoLength, double totalFitness, double bestFitness, double worstFitness,  
  145.             double averageFitness, double mutationRate, double crossoverRate, int generation, double maxPerturbation,  
  146.             double leftPoint, double rightPoint,int iterNum) {  
  147.         super();  
  148.         this.popSize = popSize;  
  149.         this.chromoLength = chromoLength;  
  150.         this.totalFitness = totalFitness;  
  151.         this.bestFitness = bestFitness;  
  152.         this.worstFitness = worstFitness;  
  153.         this.averageFitness = averageFitness;  
  154.         this.mutationRate = mutationRate;  
  155.         this.crossoverRate = crossoverRate;  
  156.         this.generation = generation;  
  157.         this.maxPerturbation = maxPerturbation;  
  158.         this.leftPoint = leftPoint;  
  159.         this.rightPoint = rightPoint;  
  160.         this.iterNum=iterNum;  
  161.     }  
  162.       
  163.     /*转盘赌函数 
  164.      *注意:这里的转盘赌方法仅适用于适应度的值大于0的染色体序列 
  165.      *  
  166.      *  
  167.      * */  
  168.       
  169.     //初始化种群信息  
  170.     public void init(){  
  171.         //清空  
  172.         population.clear();  
  173.         List list;  
  174.         double sum=0.0;  
  175.         //赋予种群最初的信息  
  176.         for(int i=0;i<popSize;i++){  
  177.             double gene=random.nextDouble()*(rightPoint-leftPoint)+leftPoint;  
  178.             list=new ArrayList<Double>();  
  179.             list.add(gene);  
  180.             double fitness=mathCalc.calcFunction(list);  
  181.             sum+=fitness;  
  182.             Genome genome=new Genome(list, fitness);  
  183.             population.add(genome);  
  184.         }  
  185.         setGenInfo();  
  186.         printGenInfo();  
  187.     }  
  188.       
  189.     //转盘赌算法  
  190.     public Genome getChromoRoulette(){  
  191.           
  192.           
  193.         double slice=random.nextDouble()*totalFitness;  
  194.         Genome choseGenome=null;  
  195.         double sum=0.0;  
  196.         for(int i=0;i<population.size();i++){  
  197.             choseGenome=population.get(i);  
  198.             sum+=choseGenome.getFitness();  
  199.             if(sum>=slice && choseGenome.getFitness()>this.averageFitness){  
  200.                 break;  
  201.             }  
  202.         }  
  203.         return choseGenome;  
  204.           
  205.     }  
  206.       
  207.     //基因突变  
  208.     public void Mutate(List<Double> genomList){  
  209.           
  210.         for(int i=0;i<genomList.size();i++){  
  211.               
  212.             //根据指定的突变率选择突变与否  
  213.             double randomRate=random.nextDouble();  
  214.             if(randomRate<this.getMutationRate()){  
  215.                 double raw=(double) genomList.get(i);  
  216.                 raw+=(random.nextDouble()-0.5)*this.getMaxPerturbation();  
  217.                 if(raw<leftPoint){  
  218.                     raw=leftPoint;  
  219.                 }else if(raw>rightPoint){  
  220.                     raw=rightPoint;  
  221.                 }  
  222.                 genomList.set(i, raw);  
  223.             }  
  224.               
  225.         }  
  226.     }  
  227.       
  228.     //进化核心方法,每个双亲生成两个子女  
  229.     public void Epoch(final List<Genome> popList){  
  230.           
  231.         //选择父母,产生后代,注意这里需要size是双数,其实在选择父母的过程中就已经包含了淘汰的过程  
  232.         List <Genome>newPopList=new ArrayList<Genome>();  
  233.         while(newPopList.size()<this.getPopSize()){  
  234.               
  235.             Genome mum=this.getChromoRoulette();  
  236.             Genome dad=this.getChromoRoulette();  
  237.             //生成新的基因序列  
  238.             List<Double> baby1=mum.getGenomeList();  
  239.             List<Double> baby2=dad.getGenomeList();  
  240.             this.Mutate(baby1);  
  241.             this.Mutate(baby2);  
  242.             Genome newBabyGenome1=new Genome(baby1,mathCalc.calcFunction(baby1));  
  243.             Genome newBabyGenome2=new Genome(baby2,mathCalc.calcFunction(baby1));  
  244.             newPopList.add(newBabyGenome1);  
  245.             newPopList.add(newBabyGenome2);  
  246.               
  247.         }  
  248.         popList.clear();  
  249.         //产生新的一代  
  250.         for(int i=0;i<newPopList.size();i++){  
  251.             popList.add(newPopList.get(i));  
  252.         }  
  253.         newPopList=null;  
  254.           
  255.     }  
  256.     public void setGenInfo(){  
  257.           
  258.         Genome bestGenome=population.get(0);  
  259.         Genome worstGenome=population.get(0);  
  260.         double totalFit=0.0;  
  261.         for(int i=0;i<population.size();i++){  
  262.             Genome genom=population.get(i);  
  263.             totalFit+=genom.getFitness();  
  264.             if(genom.getFitness()>bestGenome.getFitness()){  
  265.                 bestGenome=genom;  
  266.             }  
  267.             if(genom.getFitness()<worstGenome.getFitness()){  
  268.                 worstGenome=genom;  
  269.             }  
  270.               
  271.               
  272.         }  
  273.           
  274.         double averageFit=totalFit/population.size();  
  275.         this.setTotalFitness(totalFit);  
  276.         this.setBestFitness(bestGenome.getFitness());  
  277.         this.setWorstFitness(worstGenome.getFitness());  
  278.         this.setAverageFitness(averageFit);  
  279.         this.setGeneration(this.getGeneration()+1);  
  280.           
  281.     }  
  282.     public void printGenInfo(){  
  283.         System.out.print("the generation is:\t");  
  284.         System.out.println(this.generation);  
  285.         System.out.print("the best fitness is:\t");  
  286.         System.out.println(this.getBestFitness());  
  287.         System.out.print("the worst fitness is:\t");  
  288.         System.out.println(this.getWorstFitness());  
  289.         System.out.print("the average fitness is:\t");  
  290.         System.out.println(this.getAverageFitness());  
  291.         System.out.print("the total fitness is:\t");  
  292.         System.out.println(this.getTotalFitness());  
  293.     }  
  294.     //遗传算法具体操作步骤  
  295.     public void geneticAlgorithmPorcess(){  
  296.           
  297.         int iterNum=this.iterNum;  
  298.         this.init();  
  299.         for (int gen=0;gen<this.iterNum;gen++){  
  300.             this.Epoch(this.population);  
  301.             setGenInfo();  
  302.             printGenInfo();  
  303.         }  
  304.   
  305.           
  306.     }  
  307.       
  308.       
  309.       
  310.       
  311.       
  312.   
  313. }  

 测试类:

Java代码  收藏代码
  1. package com.luchi.genetic;  
  2.   
  3. public class MainTestClass {  
  4.       
  5.     public static void main(String[]args){  
  6.           
  7.         GeneticAlgorithm genAL=new GeneticAlgorithm(5010.0,  
  8.                 0.0999999990.00.8,  
  9.                 0.800.00404100);  
  10.       
  11.         genAL.geneticAlgorithmPorcess();  
  12.     }  
  13. }  

 结果如下:

Java代码  收藏代码
  1. the generation is:  101  
  2. the best fitness is:    5.648238442785841  
  3. the worst fitness is:   5.277698361050879  
  4. the average fitness is: 5.460200891763737  
  5. the total fitness is:   273.0100445881869  

 迭代次数为101次(多了一次是因为迭代从0开始的)

 

      需要说明的是:遗传算法对初始群体的选取还有遗传父母的个体还是很敏感的,每次运行会有不同的结         果,这里使用(0,4)区间并不是最好的选择,因为其适应值函数包含了负数,这会影响到转盘赌方法的       准确性,因此如果需要遗传算法得到一个很好的效果,还是需要对初始群体和遗传交叉过程进行优化

      今天就写到这儿,有问题再议,源代码见附件

 

 

       参考文献

       1,http://blog.csdn.net/emiyasstar__/article/details/6938608

        2, http://blog.csdn.net/b2b160/article/details/4680853/ 

  • 大小: 187.3 KB
  • 大小: 182.2 KB
分享到:
评论

相关推荐

    1204 Java 遗传算法排课java sqlserver.rar_java排课算法_排课_排课系统java_遗传算法Java

    Java遗传算法排课系统是一种利用遗传算法解决复杂优化问题的软件应用。在教育领域,排课是一个典型的组合优化问题,需要考虑多方面的约束条件,如教师时间冲突、教室容量限制、课程时间安排等。遗传算法作为一种启发...

    遗传算法经典Java实现

    在这个“遗传算法经典Java实现”的压缩包中,我们可以期待找到一个用Java编程语言实现的遗传算法框架,它可能包含了一系列核心的类和方法,用于表示、操作和演化种群。 遗传算法的基本步骤包括初始化种群、选择、...

    遗传算法Java实现

    在Java中实现遗传算法,通常涉及以下几个关键步骤和概念: 1. **编码**: 在遗传算法中,个体通常被编码为一串数字或字符串,代表可能的解决方案。在Java中,我们可以使用数组、列表或者自定义类来表示这些编码。...

    遗传算法java实现代码

    一个二元最优化问题的遗传算法用java实现的代码

    遗传算法java实现

    遗传算法java实现 遗传算法是一种搜索启发式算法,它模拟自然选择和遗传过程,通过选择、交叉、变异等操作来搜索最优解。在交通路线和方式规划问题中,遗传算法可以用来解决 Vehicle Routing Problem(VRP),即...

    经典遗传算法的Java实现以及遗传算法实现自动组卷+源码(毕业设计&课程设计&项目开发)

    经典遗传算法的Java实现以及遗传算法实现自动组卷+源码,适合毕业设计、课程设计、项目开发。项目源码已经过严格测试,可以放心参考并在此基础上延申使用~ 经典遗传算法的Java实现以及遗传算法实现自动组卷+源码,...

    经典遗传算法的Java实现以及遗传算法实现自动组卷(源码+项目说明).zip

    【资源说明】 1、该资源包括项目的全部源码,下载可以直接使用! 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和...经典遗传算法的Java实现以及遗传算法实现自动组卷(源码+项目说明).zip

    java遗传算法寻找最优路径

    ### Java遗传算法寻找最优路径 #### 一、遗传算法概览 ...综上所述,这段Java代码通过遗传算法成功地实现了寻找最优路径的目标,通过对代码的具体分析我们可以更加深入地理解遗传算法的基本思想及其实现细节。

    java:实现遗传算法

    遗传算法的步骤: (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)个体适应...

    遗传算法-java

    通过分析和理解这个Java实现的遗传算法,开发者可以学习如何在实际项目中应用遗传算法解决优化问题。同时,也可以在此基础上扩展和改进算法,如引入精英保留策略、自适应调整参数等,以适应不同场景的需求。

    遗传算法 tsp java

    《遗传算法在旅行商问题(TSP)中的应用——基于Java实现》 旅行商问题(Traveling Salesman Problem,简称TSP)是一个经典的组合优化问题,它询问的是:给定一个城市列表,一个旅行商如何规划一条路线,使得他能...

    JAVA语言实现的遗传算法

    在Java实现中,可以创建一个表示二进制串的类,包含生成、交叉、变异的方法,并在主循环中不断更新种群,直到找到满足条件的解或者达到预设的迭代次数。 **总结** 遗传算法结合Java语言,可以构建出高效且易于维护...

    基于java的遗传算法设计与实现

    二、Java实现遗传算法的关键点 1. 类的设计:创建代表个体的类,包含其基因(解决方案的表示)和适应度值。可以使用数组、列表或其他数据结构来存储基因。 2. 编写适应度函数:根据问题定义,计算个体的适应度值。...

    经典遗传算法的Java实现以及遗传算法实现自动组卷.zip

    Java是一种高性能、跨平台的面向...自动内存管理(垃圾回收): Java具有自动内存管理机制,通过垃圾回收器自动回收不再使用的对象,使得开发者不需要手动管理内存,减轻了程序员的负担,同时也减少了内存泄漏的风险。

    遗传算法java语言实现

    ### 遗传算法在Java中的实现 #### 知识点概述 本文将详细解析一个用Java语言编写的遗传算法程序。遗传算法(Genetic Algorithm, GA)是一种模拟自然界生物进化过程的搜索算法,用于解决优化问题。它通过选择、交叉...

    旅行商问题-遗传算法--java

    在给定的文件名列表中,"TSP.java"可能是实现旅行商问题的类,包含了遗传算法的主要逻辑,而"Main.java"则是程序的入口,负责调用"TSP"类,初始化参数,运行算法,并可能包含结果的打印和分析。 总的来说,通过遗传...

    Java基于遗传算法的自动排课系统源码.zip

    Java基于遗传算法的自动排课系统源码.zipJava基于遗传算法的自动排课系统源码.zipJava基于遗传算法的自动排课系统源码.zipJava基于遗传算法的自动排课系统源码.zipJava基于遗传算法的自动排课系统源码.zipJava基于...

    经典遗传算法的Java实现以及遗传算法实现自动组卷_GADemo.zip

    经典遗传算法的Java实现以及遗传算法实现自动组卷_GADemo

    遗传算法的java程序实现

    用java语言实现遗传算法,并对一个算例进行运算

Global site tag (gtag.js) - Google Analytics