Java 测试函数在遗传算法中的应用

我已经为种群进化（遗传算法实现）编写了以下代码：

Individual.java

import java.util.Random;

public class Individual {

    public static int SIZE = 500;
    private int[] genes = new int[SIZE];
    private double fitnessValue = 0.0;


    // Getters and Setters
    public void setGene(int index,int gene){
        this.genes[index] = gene;
    }

    public int getGene(int index){
        return this.genes[index];
    }

    public void setFitnessValue(double fitness){
        this.fitnessValue = fitness;
    }

    public double getFitnessValue(){
        return this.fitnessValue;
    }

    //Function to generate a new individual with random set of genes
    public void generateIndividual(){
        Random rand = new Random();
        for(int i=0;i<SIZE;i++){
            this.setGene(i, rand.nextInt(2));
        }
    }

    //Mutation Function
    public void mutate(){
        Random rand = new Random();
        int index = rand.nextInt(SIZE);
        this.setGene(index, 1-this.getGene(index)); // Flipping value of gene 
    }

    //Function to set Fitness value of an individual
    public int evaluate(){

        int fitness = 0;
        for(int i=0; i<SIZE; ++i) {
            fitness += this.getGene(i);
        }
        this.setFitnessValue(fitness);
        return fitness;
    }

}

import java.util.Random;

public class Population {

    final static int ELITISM = 5;
    final static int POP_SIZE = 200+ELITISM; //Population size + Elitism (1)
    final static int MAX_ITER = 10000;
    final static double MUTATION_RATE = 0.05;
    final static double CROSSOVER_RATE = 0.7;
    public static int generation = 2;

    private static Random rand = new Random(); 
    private double totalFitness;
    private  Individual[] pop;

    //Constructor
    public Population(){
        pop = new Individual[POP_SIZE];
        //Initialising population
        for(int i=0;i<POP_SIZE;i++){
            pop[i] = new Individual();
            pop[i].generateIndividual();

        }
        //Evaluating current population
        this.evaluate();
    }

    //Storing new generation in population
    public void setPopulation(Individual[] newPop) {
        System.arraycopy(newPop, 0, this.pop, 0, POP_SIZE);
    }


    //Method to find total fitness of population
    public double evaluate(){
        this.totalFitness = 0.0;
        for (int i = 0; i < POP_SIZE; i++) {
            this.totalFitness +=  pop[i].evaluate();
        }


       return this.totalFitness;
    }


    //Getters
    public Individual getIndividual(int index) {
        return pop[index];
    }


    //Function to find fittest individual for elitism
    public Individual getFittest() {
        Individual fittest = pop[0];
        for (int i = 0; i < POP_SIZE; i++) {
            if (fittest.getFitnessValue() <= getIndividual(i).getFitnessValue()) {
                fittest = getIndividual(i);
            }
        }
        return fittest;
    }

    //CROSSOVER Function : Takes 2 individuals and returns 2 new individuals
    public static Individual[] crossover(Individual indiv1,Individual indiv2) {
        Individual[] newIndiv = new Individual[2];
        newIndiv[0] = new Individual();
        newIndiv[1] = new Individual();
        int randPoint = rand.nextInt(Individual.SIZE);
        int i;
        for (i=0; i<randPoint; ++i) {
            newIndiv[0].setGene(i, indiv1.getGene(i));
            newIndiv[1].setGene(i, indiv2.getGene(i));
        }
        for (; i<Individual.SIZE; ++i) {
            newIndiv[0].setGene(i, indiv2.getGene(i));
            newIndiv[1].setGene(i, indiv1.getGene(i));
        }

        return newIndiv;
    }

    //Roulette Wheel Selection Function
    public Individual rouletteWheelSelection() {

        double randNum = rand.nextDouble() * this.totalFitness;
        int idx;

        for (idx=0; idx<POP_SIZE && randNum>0; idx++) {
            randNum -= pop[idx].getFitnessValue();
        }
        return pop[idx-1];
    }

    //Main method

    public static void main(String[] args) {
        Population pop = new Population();
        Individual[] newPop = new Individual[POP_SIZE];
        Individual[] indiv = new Individual[2];
        //Current Population Stats
        System.out.print("Generation #1");
        System.out.println("Total Fitness = "+pop.totalFitness);
        System.out.println("Best  Fitness = "+pop.getFittest().getFitnessValue());

        int count;
        for(int iter=0;iter<MAX_ITER;iter++){
            count =0;

                //Elitism
                newPop[count] = pop.getFittest();
                count++;

           //Creating new population
            while(count < POP_SIZE){
                //Selecting parents
                indiv[0] = pop.rouletteWheelSelection();
                indiv[1] = pop.rouletteWheelSelection();

                // Crossover
                if (rand.nextDouble() < CROSSOVER_RATE ) {
                    indiv = crossover(indiv[0], indiv[1]);
                }

                // Mutation
                if ( rand.nextDouble() < MUTATION_RATE ) {
                    indiv[0].mutate();
                }
                if ( rand.nextDouble() < MUTATION_RATE ) {
                    indiv[1].mutate();
                }

                // add to new population
                newPop[count] = indiv[0];
                newPop[count+1] = indiv[1];
                count += 2;
            }
            // Saving new population in pop
            pop.setPopulation(newPop);
            //Evaluating new population
            pop.evaluate();
            System.out.println("Generation #"+ generation++);
            System.out.print("Total Fitness = " + pop.totalFitness);
            System.out.println(" ; Best Fitness = " +pop.getFittest().getFitnessValue()); 

            }


        Individual bestIndiv = pop.getFittest();
    }

}

import java.util.Random；
公共阶级个人{
公共静态int SIZE=500；
私有int[]基因=新int[大小]；
私人双重装修价值=0.0；
//接球手和接球手
公共空间集合基因（int索引，int基因）{
这个。基因[指数]=基因；
}
公共整数getGene（整数索引）{
返回这个。基因[索引]；
}
public void setFitnessValue（双适应度）{
this.fitnessValue=适合度；
}
公共双getFitnessValue（）{
返回此.fitnessValue；
}
//功能生成一个具有随机基因集的新个体
公共无效生成个人（）{
Random rand=新的Random（）；
对于（int i=0；i）基因应该代表什么
我假设你的遗传算法的实现是正确的，因为这超出了这个问题的范围

现在，你的适应度函数被定义为所有基因的总和：

double fitness = 0;
for(int i=0; i<SIZE; ++i) {
  fitness += this.getGene(i);
}
this.setFitnessValue(fitness);

当然，适当的导入位于课程的顶部：

import static java.lang.Math.*;

如果你的程序确实针对适合度进行了优化，那么它应该收敛到
x=PI
。我很快编写了自己的程序（承认非常难看），它确实正确收敛

还有一件事：基因应该是一个
double[]
而不是
int[]
，因为当
x
只能是
int
时，增量优化函数并不能真正起作用

为什么是基因阵列？
我认为你的作业要求你使用一个
double
数组作为基因，这样你就得到了一个程序，可以用任意数量的变量优化任何函数。在编程中，编写可用于多种不同用途的代码总是一个好主意

请随时提问！
我试图尽可能清楚地解释所有问题，但如果您不明白，请随意提问！
这与您几小时前发布的问题有何不同？您可以编辑以前的问题并添加此代码，而不是创建新问题。这是Easom函数特有的，但现在我想如果我任何函数的规划我都可以自己做。所以现在的问题不是函数特定的。我不明白这段代码试图实现什么。遗传算法变异个体以尝试提高其适应度。现在你的适应度被定义为基因的总和参见
evaluate（）
（糟糕的命名顺便说一句）。个人的基因不是越来越高吗？你链接的维基百科页面上的函数都是有两个输入的函数，x和y。我建议给你的个人两个基因，我会将适合度定义为你正在测试的函数的结果。你能告诉我我的假设是否正确，这样我就可以写了吗找到答案了吗？我指的那本书把y作为0，把2个变量函数变成了一个更简单的单变量函数。例如，它在Easom fn中取y=0，并使其在x=π时达到全局最大值。我不明白你的意思是取2个基因（你是说2组基因？）但是，是的，适应度值肯定是要检查的测试函数的结果。继续。我在评估中所做的事情，只是通过向每个人分配适应度值来测试代码，以确保程序的所有部分工作正常，我只需将适应度值的分配方法更改为in每个人。你能详细说明两个基因的含义吗？谢谢你的回答。我的问题是，如果我们只使用一个元素的基因阵列，那么交叉就没有意义了（意味着一些基因来自父母一方，其余来自另一方）。新一代个体应该拥有父母的品质（基因），除了那些变异的（非常低的概率0.001-0.05）。如果你检查它是否适用于一个变量，那么你可以尝试使用更多变量，例如，你可以说
y=genes[1]
。是的，这正是我想问的。我是否应该自己做一个函数（例如，将个人的所有基因相加，取mod 5并使其等于x）然后根据它找到个体的适应度，或者我应该把x作为其域中的一个随机数，并用它来计算适应度？恐怕你对遗传算法有误解。它们是解决优化问题的一种方法，看起来像这样：“什么是
x_1
，
x_2
，…，
x_n
的值使得
f（x_1，x_2，…，x_n）
最大？”当我们试图用遗传算法解决这个问题时，我们称之为
x_i
基因，我们称之为
f（…）
适应度。当我们想测试我们的程序时，我们可以选择
easom（x，0）
作为我们优化的功能。然后我们说
x
是我们的单一基因，而
easim（x）
是适合度。你能为Easom函数编写一个伪代码，让个体的基因作为整数数组。我想我会更好地理解代码。我不明白为什么我们只考虑个体的一个或两个基因进行功能评估，而数组中存储了这么多基因我认为f（…）将是个体的适应度，随着进化的发生和世代的变化，我们必须使适应度最大化。但我不明白的是x的值是多少（假设书中给出的Y0）和
import static java.lang.Math.*;