【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

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

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

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】