Maîtriser les principes de l'évolution et de l'adaptation est essentiel lors de la conception d'algorithmes bio-inspirés. Dans les systèmes naturels comme dans les systèmes computationnels, ces principes expliquent comment les groupes d'individus changent et s'améliorent au fil du temps. Les concepts fondamentaux incluent :

• Population : Ensemble de toutes les solutions candidates ou individus considérés à un instant donné ;
• Fitness : Mesure de la performance de chaque individu par rapport à l'objectif du problème ;
• Sélection : Processus de choix des individus pour produire la génération suivante, favorisant souvent ceux ayant une meilleure fitness ;
• Mutation : Introduction de modifications aléatoires chez les individus, maintenant la diversité et permettant l'exploration de nouvelles solutions ;
• Croisement : Combinaison de parties de deux individus ou plus pour créer une nouvelle descendance ;
• Adaptation : Amélioration continue de la population en réponse à la sélection, à la mutation et au croisement.

Chaque concept soutient le développement de solutions robustes en imitant les processus qui favorisent l'adaptation et le succès dans la nature.

Population

import random

def create_population(size, length, value_range=(0, 100)):
    """
    Generates a population of individuals, each as a list of random integers.
    
    Args:
        size (int): Number of individuals in the population.
        length (int): Number of genes in each individual.
        value_range (tuple): Allowed range for gene values (inclusive).
    Returns:
        list: Population represented as a list of individuals.
    """
    return [[random.randint(value_range[0], value_range[1]) for _ in range(length)] for _ in range(size)]

# Example usage:
population = create_population(size=5, length=3, value_range=(0, 50))
print("Generated population:", population)

La fonction create_population génère un groupe d'individus, où chaque individu est représenté par une liste d'entiers aléatoires. Chaque entier peut être considéré comme un gène. Vous spécifiez la taille de la population, la longueur de chaque individu et l'intervalle des valeurs des gènes.

Le maintien de la diversité au sein de la population est essentiel. Une population diversifiée explore davantage l'espace du problème, réduisant le risque de rester bloqué sur de mauvaises solutions et augmentant la probabilité de trouver des réponses de haute qualité.

Fitness : Mesure de la qualité des solutions

def fitness_function(solution, target=100):
    """
    Calculates fitness based on how close the solution is to the target value.
    Higher fitness indicates a solution closer to the target.
    """
    return 1 / (1 + abs(target - solution))

# Example usage:
solution = 97
fitness = fitness_function(solution, target=100)
print(f"Fitness score: {fitness}")

La fonction fitness_function évalue la qualité d'une solution en la comparant à une valeur cible. Plus la différence est faible, plus le score d'adaptation est élevé. Par exemple, si la solution est 97 et la cible est 100, le score d'adaptation sera supérieur à celui obtenu avec une solution de 80.

Sélection : Choix des candidats les plus adaptés

import random

def roulette_wheel_selection(population, fitnesses, num_selected):
    """
    Selects individuals from the population using roulette wheel selection.
    Probability of selection is proportional to fitness.
    Handles the case where all fitness scores are zero by selecting randomly.
    """
    total_fitness = sum(fitnesses)
    if total_fitness == 0:
        # If all fitnesses are zero, select randomly
        return random.choices(population, k=num_selected)
    # Otherwise, select based on fitness weights
    return random.choices(population, weights=fitnesses, k=num_selected)

# Example usage:
population = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [2, 4, 6]]
fitnesses = [10, 0, 30, 5]  # Higher fitness means higher chance of selection
selected = roulette_wheel_selection(population, fitnesses, num_selected=2)
print("Selected individuals:", selected)

La sélection par roulette choisit des individus avec une probabilité proportionnelle à leur score de fitness. Cela signifie que les candidats ayant une meilleure adaptation ont plus de chances d'être sélectionnés, mais les individus avec une adaptation plus faible peuvent également être choisis, ce qui aide à maintenir la diversité dans la population.

Mutation : Introduction de la variation

import random

def mutate_individual(individual, mutation_rate=0.2, value_range=(0, 100)):
    """
    Randomly changes each gene in an individual with a given probability.
    Returns a new individual with possible mutations.
    """
    return [random.randint(*value_range) if random.random() < mutation_rate else gene for gene in individual]

# Example: Mutating a single individual
original = [10, 20, 30, 40, 50]
mutated = mutate_individual(original, mutation_rate=0.4, value_range=(0, 100))
print("Original:", original)
print("Mutated:", mutated)

# Example: Mutating an entire population
population = [[5, 15, 25], [35, 45, 55], [65, 75, 85]]
mutated_population = [mutate_individual(ind, mutation_rate=0.3) for ind in population]
print("Original Population:", population)
print("Mutated Population:", mutated_population)

La mutation introduit des modifications aléatoires chez les individus de la population. Ce caractère aléatoire permet de maintenir la diversité, d'explorer de nouvelles solutions et de réduire le risque de rester bloqué sur des solutions de mauvaise qualité.

Croisement : Mélange des caractéristiques pour de nouvelles solutions

def single_point_crossover(parent1, parent2):
    """
    Performs single-point crossover between two parent individuals.
    Each parent is a list of integers of the same length.
    Returns two offspring as lists.
    """
    import random
    if len(parent1) != len(parent2):
        raise ValueError("Parents must be of the same length.")
    if len(parent1) < 2:
        raise ValueError("Parent length must be at least 2 for crossover.")
    crossover_point = random.randint(1, len(parent1) - 1)
    offspring1 = parent1[:crossover_point] + parent2[crossover_point:]
    offspring2 = parent2[:crossover_point] + parent1[crossover_point:]
    return offspring1, offspring2

Cette fonction prend deux individus parents (listes d'entiers) et produit deux descendants en échangeant du matériel génétique à un point choisi aléatoirement. Le point de croisement est sélectionné de sorte que chaque descendant contienne des gènes provenant des deux parents.

Exemple d'utilisation :

import random
random.seed(42)  # For reproducible results
parent1 = [10, 20, 30, 40, 50]
parent2 = [1, 2, 3, 4, 5]
offspring1, offspring2 = single_point_crossover(parent1, parent2)
print("Offspring 1:", offspring1)
print("Offspring 2:", offspring2)

Adaptation : Comment les populations s'améliorent au fil du temps

L'adaptation est l'effet cumulatif des opérations évolutives répétées — sélection, croisement et mutation. À mesure que ces processus se répètent, la population devient progressivement plus apte à résoudre le problème, ce qui conduit à des solutions de meilleure qualité au fil du temps.