web-dev-qa-db-fra.com

Sélection de la roulette dans les algorithmes génétiques

Quelqu'un peut-il fournir un pseudo-code pour une fonction de sélection de roulette? Comment pourrais-je implémenter ceci:

alt text

Je ne comprends pas vraiment comment lire cette notation mathématique. Je n'ai jamais pris aucune probabilité ou statistique.

genetic-algorithmevolutionary-algorithmroulette-wheel-selection
35
Sam McAfee

Cela fait quelques années que je l'ai fait moi-même, mais le pseudo-code suivant a été trouvé assez facilement sur Google.

 pour tous les membres de la population 
 somme + = aptitude de cette personne 
 fin pour 

 pour tous les membres de la population 
 probabilité = somme des probabilités + (fitness/somme) 
 somme des probabilités + = probabilité 
 fin pour 

 boucle jusqu'à ce que la nouvelle population soit pleine 
 faites-le deux fois 
 nombre = aléatoire entre 0 et 1 
 pour tous les membres de la population 
 si nombre> probabilité mais moins que la probabilité suivante 
 alors vous avez été sélectionné 
 fin pour 
 fin
 créer la progéniture 
 end loop

Le site d'où cela provient peut être trouvé ici si vous avez besoin de plus amples détails.

37
Jarod Elliott

Beaucoup de solutions correctes déjà, mais je pense que ce code est plus clair.

def select(fs):
    p = random.uniform(0, sum(fs))
    for i, f in enumerate(fs):
        if p <= 0:
            break
        p -= f
    return i

De plus, si vous accumulez les fs, vous pouvez produire une solution plus efficace.

cfs = [sum(fs[:i+1]) for i in xrange(len(fs))]

def select(cfs):
    return bisect.bisect_left(cfs, random.uniform(0, cfs[-1]))

C'est à la fois plus rapide et extrêmement concis. STL en C++ dispose d'un algorithme de bissection similaire si c'est le langage que vous utilisez.

15
user97370

Le pseudo-code posté contient des éléments peu clairs et ajoute à la complexité de la génération de offspring au lieu d'effectuer une sélection pure. Voici une implémentation python simple de ce pseudocode:

def roulette_select(population, fitnesses, num):
    """ Roulette selection, implemented according to:
        <http://stackoverflow.com/questions/177271/roulette
        -selection-in-genetic-algorithms/177278#177278>
    """
    total_fitness = float(sum(fitnesses))
    rel_fitness = [f/total_fitness for f in fitnesses]
    # Generate probability intervals for each individual
    probs = [sum(rel_fitness[:i+1]) for i in range(len(rel_fitness))]
    # Draw new population
    new_population = []
    for n in xrange(num):
        r = Rand()
        for (i, individual) in enumerate(population):
            if r <= probs[i]:
                new_population.append(individual)
                break
    return new_population
12
noio

C'est ce qu'on appelle la sélection de la roue de roulette via l'acceptation stochastique:

/// \param[in] f_max maximum fitness of the population
///
/// \return index of the selected individual
///
/// \note Assuming positive fitness. Greater is better.

unsigned rw_selection(double f_max)
{
  for (;;)
  {
    // Select randomly one of the individuals
    unsigned i(random_individual());

    // The selection is accepted with probability fitness(i) / f_max
    if (uniform_random_01() < fitness(i) / f_max)
      return i;
  }   
}

Le nombre moyen de tentatives nécessaires pour une sélection unique est:

τ = fmax / avg (f)

  • fmax est la forme physique maximale de la population
  • avg (f) est l'aptitude moyenne

τ ne dépend pas explicitement du nombre d'individus dans la population (N), mais le rapport peut changer avec N.

Cependant, dans de nombreuses applications (où l’aptitude reste liée et l’aptitude moyenne ne diminue pas à 0 lorsque N augmente), τ n’augmente pas de façon illimitée avec N et donc la complexité typique de cet algorithme est O(1) _ (la sélection de la roue de la roulette à l'aide d'algorithmes de recherche présente une complexité O(N) ou O (journal N)).

La distribution de probabilité de cette procédure est en effet la même que dans la sélection de roue à roulette classique.

Pour plus de détails, voir:

  • Sélection de la roulette via acceptation stochastique (Adam Liposki, Dorota Lipowska - 2011)
8
manlio

Voici du code en C:

// Find the sum of fitnesses. The function fitness(i) should 
//return the fitness value   for member i**

float sumFitness = 0.0f;
for (int i=0; i < nmembers; i++)
    sumFitness += fitness(i);

// Get a floating point number in the interval 0.0 ... sumFitness**
float randomNumber = (float(Rand() % 10000) / 9999.0f) * sumFitness;

// Translate this number to the corresponding member**
int memberID=0;
float partialSum=0.0f;

while (randomNumber > partialSum)
{
   partialSum += fitness(memberID);
   memberID++;
} 

**// We have just found the member of the population using the roulette algorithm**
**// It is stored in the "memberID" variable**
**// Repeat this procedure as many times to find random members of the population**
5
Wartin

Le professeur Thrun du laboratoire d'intelligence artificielle de Stanford a également présenté un code de ré-échantillonnage rapide (er?) En python lors de son CS373 d'Udacity. Le résultat de la recherche Google a conduit au lien suivant: 

http://www.udacity-forums.com/cs373/questions/20194/fast-resampling-algorithm

J'espère que cela t'aides

1
Kangwon Lee

Sélection de roulette dans MatLab: 

TotalFitness=sum(Fitness);
    ProbSelection=zeros(PopLength,1);
    CumProb=zeros(PopLength,1);

    for i=1:PopLength
        ProbSelection(i)=Fitness(i)/TotalFitness;
        if i==1
            CumProb(i)=ProbSelection(i);
        else
            CumProb(i)=CumProb(i-1)+ProbSelection(i);
        end
    end

    SelectInd=Rand(PopLength,1);

    for i=1:PopLength
        flag=0;
        for j=1:PopLength
            if(CumProb(j)<SelectInd(i) && CumProb(j+1)>=SelectInd(i))
                SelectedPop(i,1:IndLength)=CurrentPop(j+1,1:IndLength);
                flag=1;
                break;
            end
        end
        if(flag==0)
            SelectedPop(i,1:IndLength)=CurrentPop(1,1:IndLength);
        end
    end
1
Setu Basak

De la réponse ci-dessus, j'ai obtenu ce qui suit, ce qui était plus clair pour moi que la réponse elle-même.

Pour donner un exemple:

Random (sum) :: Random (12) En parcourant la population, nous vérifions les éléments suivants: random <sum

Laissez-nous choisi 7 comme nombre aléatoire.

Index   |   Fitness |   Sum |   7 < Sum
0       |   2   |   2       |   false
1       |   3   |   5       |   false
2       |   1   |   6       |   false
3       |   4   |   10      |   true
4       |   2   |   12      |   ...

Dans cet exemple, le plus apte (Index 3) a le pourcentage le plus élevé d’être choisi (33%); comme le nombre aléatoire doit seulement atterrir entre 6-> 10, et il sera choisi.

    for (unsigned int i=0;i<sets.size();i++) {
        sum += sets[i].eval();
    }       
    double Rand = (((double)Rand() / (double)Rand_MAX) * sum);
    sum = 0;
    for (unsigned int i=0;i<sets.size();i++) {
        sum += sets[i].eval();
        if (Rand < sum) {
            //breed i
            break;
        }
    }
1
qreba47jhqb4e3lstrujvvdx

Voici une implémentation Java compacte que j’ai récemment écrite pour la sélection de la roulette et que nous espérons utile.

public static gene rouletteSelection()
{
    float totalScore = 0;
    float runningScore = 0;
    for (gene g : genes)
    {
        totalScore += g.score;
    }

    float rnd = (float) (Math.random() * totalScore);

    for (gene g : genes)
    {   
        if (    rnd>=runningScore &&
                rnd<=runningScore+g.score)
        {
            return g;
        }
        runningScore+=g.score;
    }

    return null;
}
1
Nick Donnelly
Based on my research ,Here is another implementation in C# if there is a need for it:


//those with higher fitness get selected wit a large probability 
//return-->individuals with highest fitness
        private int RouletteSelection()
        {
            double randomFitness = m_random.NextDouble() * m_totalFitness;
            int idx = -1;
            int mid;
            int first = 0;
            int last = m_populationSize -1;
            mid = (last - first)/2;

            //  ArrayList's BinarySearch is for exact values only
            //  so do this by hand.
            while (idx == -1 && first <= last)
            {
                if (randomFitness < (double)m_fitnessTable[mid])
                {
                    last = mid;
                }
                else if (randomFitness > (double)m_fitnessTable[mid])
                {
                    first = mid;
                }
                mid = (first + last)/2;
                //  lies between i and i+1
                if ((last - first) == 1)
                    idx = last;
            }
            return idx;
        }
0
kiaGh

Donc, il y a 2 méthodes pour sélection de la roue de la roulette implémentation: Usual _ et Acceptation stochastique _ une.

Algorithme habituel: 

# there will be some amount of repeating organisms here.
mating_pool = []

all_organisms_in_population.each do |organism|
  organism.fitness.times { mating_pool.Push(organism) }
end

# [very_fit_organism, very_fit_organism, very_fit_organism, not_so_fit_organism]
return mating_pool.sample #=> random, likely fit, parent!

Acceptation stochastique} Algorithme:

max_fitness_in_population = all_organisms_in_population.sort_by(:fitness)[0]
loop do
  random_parent = all_organisms_in_population.sample
  probability = random_parent.fitness/max_fitness_in_population * 100
  # if random_parent's fitness is 90%,
  # it's very likely that Rand(100) is smaller than it.
  if Rand(100) < probability
    return random_parent #=> random, likely fit, parent!
  else
    next #=> or let's keep on searching for one.
  end
end

Vous pouvez choisir soit, ils vont retourner des résultats identiques.

Ressources utiles:

http://natureofcode.com/book/chapter-9-the-evolution-of-code - un chapitre clair et convivial pour les débutants sur les algorithmes génétiques. explique sélection de la roue de la roulette comme un seau de lettres en bois (plus vous en mettez, plus vous aurez de chances de choisir un algorithme A, Usual). 

https://en.wikipedia.org/wiki/Fitness_proportionate_selection - décrit acceptation stochastique l'algorithme.

0
lakesare

Cette extension de tableau Swift 4 met en œuvre une sélection aléatoire pondérée, une sélection de roulette à partir de ses éléments:

public extension Array where Element == Double {

    /// Consider the elements as weight values and return a weighted random selection by index.
    /// a.k.a Roulette wheel selection.
    func weightedRandomIndex() -> Int {
        var selected: Int = 0
        var total: Double = self[0]

        for i in 1..<self.count { // start at 1
            total += self[i]
            if( Double.random(in: 0...1) <= (self[i] / total)) { selected = i }
        }

        return selected
    }
}

Par exemple, étant donné le tableau à deux éléments:

[0.9, 0.1]

weightedRandomIndex() retournera zéro 90% du temps et un 10% du temps.

Voici un test plus complet:

let weights = [0.1, 0.7, 0.1, 0.1]
var results = [Int:Int]()
let n = 100000
for _ in 0..<n {
    let index = weights.weightedRandomIndex()
    results[index] = results[index, default:0] + 1
}
for (key,val) in results.sorted(by: { a,b in weights[a.key] < weights[b.key] }) {
    print(weights[key], Double(val)/Double(n))
}

sortie:

0.1 0.09906
0.1 0.10126
0.1 0.09876
0.7 0.70092

Cette réponse est fondamentalement la même que celle d'Andrew Mao ici: https://stackoverflow.com/a/15582983/74975

0
Pat Niemeyer