Application de l'AG en java

[memy]

Bonjour,

Voilà que je cherche depuis une bonne heure d'où vient l' erreur dans l'implémentation de l'algo génétique, sans succès.

Pourriez-vous m'aider à corriger ce qui ne va pas, des conseils, critiques... tout ce que vous voulez

Je ne comprends pas d'où cela peut venir en tout cas je vois pas.

Mon code :

public class Individu implements Cloneable, Comparable<Individu>{
     
    // Intervalle de solutions
    private int valMin = -25;
    private int valMax = 25;
    private double fitness = 0;
    private int[] genotype = new int[25];
     
     
    // Constructeur1
    public Individu(){
        for(int i=0; i<25; i++){
            int elt  = (int)(Math.random() * ((valMax - valMin) + 1) + valMin );
            this.genotype[i] = elt;
        } 
    }
 
    // Constructeur Copie
    public Individu clone() throws CloneNotSupportedException{
        Individu copie = (Individu)super.clone();
        copie.genotype = new int[genotype.length];
        System.arraycopy(genotype, 0, copie.genotype, 0 , genotype.length);
        return copie;
    }
     
    // Methodes
    public int compareTo(Individu ind) {
        double fit1 = ((Individu) ind).getFitness(); 
        double fit2 = this.getFitness(); 
        //System.out.println("Fit1 => " + fit1);
        //System.out.println("Fit2 => " + fit2);
        if (fit1 > fit2)  return -1; 
        else if(fit1 == fit2) return 0; 
        else return 1;
    }
     
    public double getFitness(){
        return fitness;
    }
     
    public void setFitness() {
        if(fitness == 0)
            fitness = Competence.fitnessIndividu(this);
    }
     
    public void afficheIndividu(){
        System.out.print("[");
        for(int i=0; i<25; i++){
            System.out.print(this.genotype[i]+", ");
        }
        System.out.print("]\n");
    }
     
    // Getters & Setters
    public int getValMax(){
        return valMax;
    }
     
    public int getValMin(){
        return valMin;
    }
     
    public int getTailleIndividu(){
        return genotype.length;
    }
     
    public int getVal(int index){
        return this.genotype[index];
    }
     
    public void setVal(int index, int valeur){
        this.genotype[index] =  valeur;
    }
}

import java.util.ArrayList;
import java.util.List;
 
 
public class Competence{
     
    private static final double []x = {0, -0.0707106781, -0.1, -0.0707106781, 0, 0.0707106781, 0.1, 0.0707106781, 0, -0.0612372436, -0.0866025404, -0.0612372436, 0, 0.0612372436, 0.0866025404, 0.0612372436, 0, -0.0353553391, -0.05, -0.0353553391, 0, 0.0353553391, 0.05, 0.0353553391, 0};
    private static final double []y = { 0.1, 0.0707106781, 0, -0.0707106781, -0.1, -0.0707106781, 0, 0.0707106781, 0.0866025404, 0.0612372436, 0, -0.0612372436, -0.0866025404, -0.0612372436, 0, 0.0612372436, 0.05, 0.0353553391, 0, -0.0353553391, -0.05, -0.0353553391, 0, 0.0353553391, 0};
    private static final double []z = {0, 0, 0, 0, 0, 0, 0, 0, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.0866025404, 0.0866025404, 0.0866025404, 0.0866025404, 0.0866025404, 0.0866025404, 0.0866025404, 0.0866025404, 0.1};
    static double solution;
 
    // Evaluation de l'individu
    static double fitnessIndividu(Individu individu){
        List<Double> U = new ArrayList<Double>();
        U.add(10.5967659774);
        U.add(2.9653545467);
        U.add(3.361473671);
         
        double res;
        double fitness = 0;
         
        for(int i=0; i<U.size(); i++){
            res = 0;
            for(int j=0; j<individu.getTailleIndividu(); j++){
                if(i == 0){
                    res += individu.getVal(j) * x[j];
                }else if(i == 1){
                    res += individu.getVal(j) * y[j];
                }else{
                    res += individu.getVal(j) * z[j];
                }
            }
            fitness += Math.abs(U.get(i) - res);
        }
        return fitness;
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
 
public class Population {
     
    //private double nbIteration;
    private List<Individu> individus = new ArrayList<Individu>();
     
    // CONSTRUCTOR
    public Population(int taille){
        for(int i=0; i<taille; i++){
            individus.add(new Individu());
        }   
    } // Fin constructor
     
 
    // evalue un individu
    public void evalue(Individu individu){
        individu.setFitness();
    }
     
    // returne un individu
    public Individu getIndividu(int position){
        return individus.get(position);
    }
     
    // retourne les individus entre les positions debut et fin donnée
    public List<Individu> meilleursIndividus(int debut, int fin){
        List<Individu> meilleur = individus.subList(debut, fin);
        return meilleur;
    }
     
    // retourne la meileure solution
    public Individu meilleureSolution(){
        Collections.sort(individus);
        return individus.get(0);
    }
     
    // taille de la population
    public int taillePop(){
        return individus.size();
    }
 
    // GETTERS & SETTERS
    public List<Individu> getIndividus() {
        return individus;
    }
     
    public void setIndividus(int position, Individu ind) {
        individus.set(position, ind);
    }
}

import java.util.Collections;
import java.util.List;
 
 
public class AlgoGenetique {
     
    private static double tauxMute = 0.5;
    //private static double tauxCroiser = 0.00015;
    private static Population p;
         
         
    public static Population faireEvoluer(Population population){
        // on reçoit la population initiale, on la fait évoluer
        p = population;
                 
        int tauxMutation = (int) (tauxMute * p.taillePop());
        int  pourcentage = p.taillePop() - tauxMutation;
         
        // Evaluation
        for(int i=0; i<p.taillePop(); i++)
            p.evalue(p.getIndividu(i));
         
        // trie de la pop
        Collections.sort(p.getIndividus());
         
        // garde les meilleurs
        List<Individu> meilleurs =  p.meilleursIndividus(0, pourcentage);
         
        // mutation
        mutation(meilleurs, tauxMutation);
         
        // retourne novelle pop
        return p;
    }
     
    public static void mutation(List<Individu> tabMeilleurs, int tauxMutation) {
         
        // Taille des meilleurs individus
        int tailleMI = tabMeilleurs.size();
        // Taille d'un individu
        int tailleI = 25;
     
        // Selon taux de mutation
        for(int i=0; i<tauxMutation; i++){
             
            // Choix aléatoire de l'individu à muter dans N meilleurs
            int positionMI = (int)(Math.random() * (tailleMI-0) + 0);
            // Choix au hasard du gène de l'individu à muter
            int positionI = (int)(Math.random() * (tailleI-0) + 0);
            // Tire au hasard un nombre entre -3 et 3
            int val = (int)(Math.random() * ((3 - (-3)) + 1) + (-3) );
         
            System.out.println("Individu Muté ");
            try{
                Individu individu = (tabMeilleurs.get(positionMI)).clone();
                individu.setVal(positionI, val);
                p.setIndividus((tabMeilleurs.size()+i), individu);  // On remplace les mauvais individus par les mutants
                //p.getIndividu((tabMeilleurs.size()+i)).afficheIndividu();
            }catch(CloneNotSupportedException e){
                System.out.println("Clone exception\n");
            }
        }
    }
     
    public static double meilleurFit(){
        return p.getIndividu(0).getFitness();
    }
 
}

public class Main{
     
    public static void main(String args[]) throws CloneNotSupportedException{
         
        Population p = new Population(3);
         
        int i = 0;
        while (p.meilleureSolution().getFitness() >= 0.001){
            i++;
            p = AlgoGenetique.faireEvoluer(p);
            System.out.println("Generation: " + i + " competence: " + AlgoGenetique.meilleurFit() +"\n");
        }
        System.out.println("Meilleur Solution!");
        System.out.println("Generation: " + i);
        System.out.println("Genes:");
        System.out.println(p.meilleureSolution());
    }
}

-----

[memy]

J'ai trouver mon erreur.

C'était la condition dans la fonction setFitness de la classe Individu.

Si vous passez par ce post, pourriez-vous me donnez votre avis sur ce programme afin de l'améliorer peut-être?

Merci.