Att behärska principerna för evolution och anpassning är avgörande vid utformning av bioinspirerade algoritmer. I både naturliga och beräkningsmässiga system förklarar dessa principer hur grupper av individer förändras och förbättras över tid. De grundläggande begreppen inkluderar:

• Population: Mängden av alla kandidatlösningar eller individer som beaktas vid ett givet tillfälle;
• Fitness: Mått på hur väl varje individ presterar i förhållande till problemets mål;
• Urval: Processen att välja individer för att producera nästa generation, ofta med fördel för dem med högre fitness;
• Mutation: Införandet av slumpmässiga förändringar hos individer, vilket bibehåller mångfald och möjliggör utforskning av nya lösningar;
• Korsning: Kombinationen av delar från två eller flera individer för att skapa nya avkommor;
• Anpassning: Den fortlöpande förbättringen av populationen som svar på urval, mutation och korsning.

Varje begrepp stödjer utvecklingen av robusta lösningar genom att efterlikna processer som driver anpassning och framgång i naturen.

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)

Funktionen create_population genererar en grupp individer, där varje individ representeras av en lista med slumpmässiga heltal. Varje heltal kan betraktas som en gen. Du anger populationsstorlek, längden på varje individ och intervallet för genvärden.

Att upprätthålla mångfald i populationen är avgörande. En mångsidig population utforskar mer av problemrymden, vilket minskar risken för att fastna i dåliga lösningar och ökar chansen att hitta högkvalitativa svar.

Fitness: Mäta lösningens kvalitet

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}")

fitness_function mäter hur bra en lösning är genom att jämföra den med ett mål-värde. Ju mindre skillnaden är, desto högre blir fitness-poängen. Till exempel, om lösningen är 97 och målet är 100, blir fitness-poängen högre än om lösningen är 80.

Urval: Att välja de mest lämpade kandidaterna

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)

Roulettehjulsselektion väljer individer med sannolikhet proportionell mot deras fitnessvärden. Detta innebär att kandidater med högre fitness har större sannolikhet att väljas, men individer med lägre fitness kan fortfarande väljas, vilket bidrar till att bevara mångfalden i populationen.

Mutation: Introduktion av 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)

Mutation introducerar slumpmässiga förändringar hos individer i populationen. Denna slumpmässighet bidrar till att bevara mångfalden, möjliggör utforskning av nya lösningar och minskar risken för att fastna vid dåliga lösningar.

Crossover: Blandning av egenskaper för nya lösningar

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

Denna funktion tar två föräldraindivider (listor av heltal) och producerar två avkommor genom att utbyta genetiskt material vid en slumpmässigt vald punkt. Crossover-punkten väljs så att varje avkomma innehåller gener från båda föräldrarna.

Exempel på användning:

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)

Anpassning: Hur populationer förbättras över tid

Anpassning är den kumulativa effekten av upprepade evolutionära operationer — selektion, korsning och mutation. När dessa processer upprepas blir populationen gradvis bättre på att lösa problemet, vilket leder till lösningar av högre kvalitet över tid.