Genetic Algorithms: Selection Techniques

Note: this page has been created with the use of AI. Please take caution, and note that the content of this page does not necessarily reflect the opinion of Cratecode.

Genetic algorithms are fascinating creatures! They incorporate the principles of evolution and natural selection into the world of computation, allowing us to solve complex problems in novel ways. One of the central parts of any genetic algorithm is the selection process, where we choose which individuals get to pass on their genes to the next generation.

The Importance of Selection

Think of the selection process in genetic algorithms like a high-stakes game show. In each round, some of the contestants (or in our case, solutions) will be selected to go on to the next round, while the others will be eliminated. But instead of a cheesy game show host, the selection process is guided by a complex set of rules, or selection techniques, which decide who gets to stay and who has to leave.

Roulette Wheel Selection

The first selection technique we're going to talk about is the Roulette Wheel Selection. Imagine a roulette wheel where each solution has a spot on the wheel. The size of the spot is determined by the fitness of the solution – the fitter the solution, the bigger the spot. The wheel is spun and whichever solution the ball lands on is selected to pass on its genes.

Here's a simple example:

def roulette_wheel_selection(population):
    max_fitness = sum(individual.fitness for individual in population)
    pick = random.uniform(0, max_fitness)
    current = 0
    for individual in population:
        current += individual.fitness
        if current > pick:
            return individual

This code calculates the total fitness of the population, picks a random number between 0 and the total fitness, then goes through the population and adds up the fitness until it reaches the picked number. The individual whose fitness pushed the total over the pick is selected.

Tournament Selection

Another technique is Tournament Selection. It's like a mini-game within our game show, where a few solutions are randomly selected to compete against each other in a tournament. The winner of the tournament (the solution with the highest fitness) is then selected to pass on its genes.

def tournament_selection(population, tournament_size):
    tournament = random.sample(population, tournament_size)
    return max(tournament, key=lambda x: x.fitness)

In this example, a subset of the population is chosen randomly for the tournament. The fittest individual in this subset is selected.

Rank Selection

Lastly, let's talk about Rank Selection. In this technique, solutions are ranked based on their fitness, and the chance of being selected is proportional to their rank, not their absolute fitness value. This can be useful when the fitness values vary widely.

def rank_selection(population):
    population.sort(key=lambda x: x.fitness)
    rank_sum = sum(range(len(population)))
    pick = random.uniform(0, rank_sum)
    current = 0
    for i, individual in enumerate(population):
        current += i
        if current > pick:
            return individual

In this code, the population is sorted by fitness, a random number between 0 and the sum of all ranks is picked, and individuals are selected proportionally to their rank.

FAQ