[原]遗传算法Java实现源代码

【Title】[原]遗传算法Java实现源代码
【Date】2013-04-07
【Abstract】以前学习遗传算法时，用Java实现的遗传算法程序，现整理分享出来。
【Keywords】wintys、遗传、算法、algorithm、种群、基因、个体、进化、染色体、适应度、Rosenbrock
【Environment】Windows 7、PowerDesigner16
【Author】wintys (wintys@gmail.com) http://wintys.cnblogs.com
【URL】http://www.cnblogs.com/wintys/archive/2013/04/07/genetic_algorithms.html

【Content】:

1、简介

    此程序是对照《遗传算法原理及应用》（周明、孙树栋编著），附录所列C程序改编而来，用Java实现的遗传算法程序。相关理论请参考《遗传算法原理及应用》。

2、类图

    类图由源代码经PowerDesigner反向生成。

 

   （类图）

3、代码

3.1、染色体

    //染色体:Chromesone.java
    class Chromosome implements Cloneable{
        private StringBuffer chromosome;
        private int chromosomeLength;//染色体长度
        private char defaultChar; //默认基因填充字符
        
        public Chromosome(int chromosomeLength){
            chromosome = new StringBuffer(chromosomeLength);
            chromosome.setLength(chromosomeLength);
            defaultChar = '0';
            this.chromosomeLength = chromosomeLength;
        }
        
        //设置基因
        public boolean setGene(int begin , int end , String gene){
            int len = gene.length();
            
            if(len > end - begin + 1)
                return false;
                
            //index => chromosome , idx => gene
            for (int index = begin , idx = 0; index <= end; index++ , idx++) {
                if(idx < len)
                    chromosome.setCharAt(index , gene.charAt(idx));
                else
                    chromosome.setCharAt(index , defaultChar);
            }
            
            return true;    
        }
        
        //获取基因
        public String getGene(int begin , int end){
            char[] dest = new char[end - begin + 1];
            chromosome.getChars(begin , end + 1 , dest , 0);

            return new String(dest);        
        }
        
        public int getLength(){
            return chromosomeLength;
        }
        
        public String toString(){
            return chromosome.toString();
        }
        
        @Override
        public     Object clone()throws CloneNotSupportedException{
            Chromosome c = null;
            try{
                c = (Chromosome)super.clone();
                c.chromosome = new StringBuffer(chromosome);
            }catch(CloneNotSupportedException e ){
                System.out.println(e.getMessage());
            }

            return c;    
        }
    }

3.2、个体

3.2.1、抽象个体

    //Individual.java
    abstract class Individual implements Cloneable{
        protected Chromosome chrom;//个体基因型:一个基因型染色体由多个基因组成
        protected int genelen;//基因长度
        protected double fitness;//适应度
        protected double targetValue;//目标函数值
        
        public abstract void coding();//编码
        public abstract void decode();//解码
        public abstract void calFitness();//计算个体适应度
        public abstract void generateIndividual();//随机产生个体
        public abstract void calTargetValue();//获取目标函数值
        
        public double getFitness(){
            return fitness;
        }
        
        public double getTargetValue(){
            return targetValue;
        }
        
        public int getChromlen(){
            return chrom.getLength();
        }
        
        public boolean setChrom(int begin , int end , String gene){
            return chrom.setGene(begin,end,gene);
        }
        
        public String getChrom(int begin , int end){
            return chrom.getGene(begin,end);
        }
        
        public void mutateSingleBit(int index){
            String gene , gn;
            gene = chrom.getGene(index , index);
            gn = gene.equals("0") ? "1":"0";
            chrom.setGene(index , index , gn);
        }
        
        @Override
        public Object clone(){
            Individual indv = null;
            
            try{
                indv = (Individual)super.clone();
                indv.chrom = (Chromosome)chrom.clone();
            }catch(CloneNotSupportedException e ){
                System.out.println(e.getMessage());
            }
            
            return indv;
        }
    }

3.2.2、Rosenbrock个体实现

    //RosenbrockIndividual.java
    class RosenbrockIndividual extends Individual {
        private double x1 , x2; // 个体表现型
        //基因型chromosome由 (x1 , x2)编码而成
        
        RosenbrockIndividual(int chromlen){
            genelen = 10;
            chrom = new Chromosome(chromlen);
        }
        
        //编码
        public void coding(){
            String code1,code2;
            code1 = codingVariable(x1);
            code2 = codingVariable(x2);
            
            chrom.setGene(0 , 9 , code1);
            chrom.setGene(10, 19 , code2);
        }
        
        //解码
        public void decode(){
            String gene1,gene2;
            
            gene1 = chrom.getGene(0 , 9);
            gene2 = chrom.getGene(10 , 19);
            
            x1 = decodeGene(gene1);
            x2 = decodeGene(gene2);
        }
        
        //计算目标函数值
        public  void calTargetValue(){
            decode();
            targetValue = rosenbrock(x1 , x2);
        }
        
        //计算个体适应度
        public void calFitness(){
            fitness = getTargetValue();
        }
        
        private String codingVariable(double x){
            double y = (((x + 2.048) * 1023) / 4.096);
            String code = Integer.toBinaryString((int) y);
            
            StringBuffer codeBuf = new StringBuffer(code);
            for(int i = code.length(); i<genelen; i++)
                codeBuf.insert(0,'0');
                
            return codeBuf.toString();
        }
        
        private double decodeGene(String gene){
            int value ;
            double decode;
            value = Integer.parseInt(gene, 2);
            decode = value/1023.0*4.096 - 2.048;
            
            return decode;
        }
            
        public String toString(){
            String str = "";
            ///str = "基因型:" + chrom + "  ";
            ///str+= "表现型:" + "[x1,x2]=" + "[" + x1 + "," + x2 + "]" + "\t";
            str+="函数值:" + rosenbrock(x1 , x2) + "\n";
            
            return     str;    
        }
        
        /**
         *Rosenbrock函数:
         *f(x1,x2) = 100*(x1**2 - x2)**2 + (1 - x1)**2
         *在当x在[-2.048 , 2.048]内时，
         *函数有两个极大点:
         *f(2.048 , -2.048) = 3897.7342
         *f(-2.048,-2.048) = 3905.926227
         *其中后者为全局最大点。
         */
        public static double rosenbrock(double x1 , double x2){
            double fun;
            fun = 100*Math.pow((x1*x1 - x2) , 2) + Math.pow((1 - x1) , 2);
            
            return fun;
        }
        
        //随机产生个体
        public void generateIndividual(){
            x1 = Math.random() * 4.096 - 2.048;
            x2 = Math.random() * 4.096 - 2.048;
            
            //同步编码和适应度
            coding();
            calTargetValue();
            calFitness();
        }
    }

3.3、种群

    //Population.java
    class Population{
        private int generation; //种群的代数
        private int size;            //群体大小
        private Individual[] pop;   //种群
        private double averageFitness;    //平均适应度
        private double[] relativeFitness;    //相对适应度
        private int chromlen;//基因长度
        Individual bestIndividual;//当前代适应度最好的个体
        Individual worstIndividual;//当前代适应度最差的个体
        Individual currentBest;//到目前代为止最好的个体
        private int worstIndex;//bestIndividual对应的数组下标

        
        public Population(int size){
            this.generation = 0;
            this.size = size;
            
            this.pop = new Individual[size];
            this.averageFitness = 0;
            this.relativeFitness = new double[size];
            this.chromlen = 20;
            
            for(int i = 0; i < size; i++){
                pop[i] = new RosenbrockIndividual(chromlen);
            }
        }
        
        
        //初始化种群
        public void initPopulation(){
            for(int i = 0;i < size;i++){
                pop[i].generateIndividual();
            }
            
            findBestAndWorstIndividual();                
        }

        //----------------------------------------------------
        //比例选择
        public void  select(){
            double[] rouletteWheel; //赌盘
            Individual[] childPop = new Individual[size];
            
            calRelativeFitness();
            
            //产生赌盘
            rouletteWheel  = new double[size];
            rouletteWheel[0] = relativeFitness[0];
            for(int i=1;i<size -1;i++){
                rouletteWheel[i] = relativeFitness[i] + rouletteWheel[i - 1];
            }
            rouletteWheel[size - 1] = 1;
            
            //进行赌盘选择,产生新种群
            for(int i = 0;i < size ; i++){
                double rnd = rand();
                for(int j = 0; j < size; j++){
                    if(rnd < rouletteWheel[j]){
                        childPop[i] = pop[j];
                        break;
                    }    
                }        
            }
            
            for(int i = 0;i < size; i++){
                pop[i] = childPop[i];
            }
            
            //return     childPop;
        }
        
        //求总适应度
        private double calTotalFitness(){
            double total = 0;
            for(int i = 0 ; i < size ;i++)
                total += pop[i].getFitness();
            return total;
        }
            
        //计算相对适应度
        public double[] calRelativeFitness(){
            double totalFitness = calTotalFitness();
            for(int i = 0 ;i < size ; i++){
                relativeFitness[i] = pop[i].getFitness() / totalFitness;    
            }
            
            return relativeFitness;
        }
        
        //================================
        
        //------------------------------------------------------
        //单点交叉
        public void crossover(){
            for(int i = 0 ; i < size/2*2; i+=2){
                int rnd;
                //随机两两配对
                rnd = rand(i , size);

                if(rnd != i)
                    exchange(pop , i , rnd);
                    
                rnd = rand(i , size);
                if(rnd != i+1)
                    exchange(pop , i + 1 , rnd);    
                        
                //交叉
                double random = rand();

                if(random < GeneticAlgorithms.crossoverRate){
                    cross(i);
                }            
            }
        }
        
        //执行交叉操作
        private void cross(int i){
            String chromFragment1,chromFragment2;//基因片段
            
            int rnd = rand(0 , getChromlen() - 1);//交叉点为rnd之后,可能的位置有chromlen - 1个.
            chromFragment1 = pop[i].getChrom(rnd + 1 , getChromlen() - 1);
            chromFragment2 = pop[i+1].getChrom(rnd + 1 , getChromlen() - 1);
                
            pop[i].setChrom(rnd + 1 , getChromlen() - 1 , chromFragment2);
            pop[i+1].setChrom(rnd + 1 , getChromlen() - 1 , chromFragment1);            
        }
        
        //产生随机数
        private int rand(int start , int end){//产生区间为[start , end)的随机整数
            return (int)(rand()*(end - start) + start);
        }
        
        //交换
        private void exchange(Individual[] p ,int src , int dest){
            Individual temp;
            temp = p[src];
            p[src] = p[dest];
            p[dest] = temp;    
        }
        //==============================

        //-----------------------------------------------------
        //变异
        public void mutate(){
            for(int i = 0 ; i < size;i++){
                for(int j = 0 ;j < getChromlen(); j++){
                    if(rand() < GeneticAlgorithms.mutateRate){
                        pop[i].mutateSingleBit(j);
                        ///System.out.print("变异"+ i +" - "+ j + "  ");///
                    }    
                }
            }
        }
        //==============================
        
        //-----------------------------------------------------
        //进化
        public void evolve(){
            select();
            crossover();
            mutate();
            evaluate();    
        }
        
        
        //==============================
        //计算目标函数值、适应度、找出最优个体。
        public void evaluate(){
            //同步目标函数值和适应度
            for(int i = 0; i < size; i++){
                pop[i].calTargetValue();
                pop[i].calFitness();
            }
            
            //使用最优保存策略(Elitist Model)保存最优个体
            findBestAndWorstIndividual();
            pop[worstIndex] = (Individual)currentBest.clone();
            
            generation++;    
        }    
        //找出适应度最大的个体
        public void findBestAndWorstIndividual(){
            bestIndividual = worstIndividual = pop[0];
            for(int i = 1; i <size;i++){
                if(pop[i].fitness > bestIndividual.fitness){
                    bestIndividual = pop[i];
                }
                if(pop[i].fitness < worstIndividual.fitness){
                    worstIndividual = pop[i];
                    worstIndex = i;
                }
            }
        
            if( generation == 0 ){//初始种群
                currentBest = (Individual)bestIndividual.clone();
            }else{
                if(bestIndividual.fitness > currentBest.fitness)
                    currentBest = (Individual)bestIndividual.clone();
            }
        }
        
        //判断进化是否完成
        public boolean isEvolutionDone(){
            if(generation < GeneticAlgorithms.maxGeneration)
                return false;
            return true;    
        }
            
        //计算平均适应度
        public double calAverageFitness(){
            for(int i = 0 ; i < size; i++){
                averageFitness += pop[i].getFitness();
            }
            averageFitness/=size;
                
            return averageFitness;
        }
                    
        //产生随机数
        private double rand(){
            return Math.random();
        }
        
        public int getChromlen(){
            return chromlen;
        }
        
        public void setGeneration(int generation){
            this.generation = generation;
        }
        
        public int getGeneration(){
            return generation;
        }
        /*
        public String printPop(Individual[] pop){
            String str="";
            for(int i = 0 ; i < size ; i++)
                str += pop[i];
            return str;
        }*/
        
        public String toString(){
            String str="";
            for(int i = 0 ; i < size ; i++)
                str += pop[i];
            return str;
        }    
    }

3.4 测试

    //GeneticAlgorithms.java 给定参数，测试遗传算法
    import java.io.*;
    //2008-11-21
    class GeneticAlgorithms{
        public static double crossoverRate;//交叉概率
        public static double mutateRate;//变异概率
        public static int maxGeneration;//进化代数
        public static int populationSize;//群体大小
        
        static {
            //crossoverRate = 0.6;
            //mutateRate = 0.001;
            //maxGeneration  = 100;
            //populationSize = 500;
            maxGeneration  = 100;
            populationSize = 500;
            crossoverRate = 0.6;
            mutateRate = 0.001;
        }
        
        public static void main(String[] args)throws IOException{

            FileWriter fw = new FileWriter("result.txt");
            BufferedWriter bw = new BufferedWriter(fw);
            PrintWriter pw = new PrintWriter(bw);
            
            Population pop = new Population(populationSize);
            pop.initPopulation();

            pw.println("初始种群:\n" + pop);
            while(!pop.isEvolutionDone()){
                pop.evolve();
                pw.print("第" + pop.getGeneration() + "代Best:" + pop.bestIndividual );
                pw.print("第" + pop.getGeneration()  + "代current:" + pop.currentBest );
                pw.println("");        
            }
            pw.println();
            pw.println("第"+ pop.getGeneration()  + "代群体:\n" + pop);

            pw.close();
        }
        
        public void print(){

        }
    }

【Reference】
[1]《遗传算法原理及应用》（周明、孙树栋编著）

【Attachment】

[1] 《遗传算法原理及应用》（周明、孙树栋编著）
[2]遗传算法Java源代码