Beherskelse af principperne for evolution og tilpasning er afgørende ved design af bio-inspirerede algoritmer. I både naturlige og beregningsmæssige systemer forklarer disse principper, hvordan grupper af individer ændrer sig og forbedres over tid. De grundlæggende begreber omfatter:

• Population: Mængden af alle kandidat-løsninger eller individer, der overvejes på ét tidspunkt;
• Fitness: Måling af, hvor godt hver enkelt individ præsterer i forhold til problemets mål;
• Udvælgelse: Processen med at vælge individer til at producere næste generation, ofte med fortrinsret til dem med højere fitness;
• Mutation: Introduktion af tilfældige ændringer til individer, opretholder diversitet og muliggør udforskning af nye løsninger;
• Crossover: Kombination af dele fra to eller flere individer for at skabe nyt afkom;
• Tilpasning: Løbende forbedring af populationen som reaktion på udvælgelse, mutation og crossover.

Hvert begreb understøtter udviklingen af robuste løsninger ved at efterligne processer, der driver tilpasning og succes 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 genererer en gruppe af individer, hvor hvert individ repræsenteres af en liste af tilfældige heltal. Hvert heltal kan betragtes som et gen. Du angiver populationsstørrelse, længden af hvert individ og intervallet for genværdier.

Opretholdelse af diversitet i populationen er væsentlig. En mangfoldig population udforsker mere af problemrummet, hvilket mindsker risikoen for at sidde fast i dårlige løsninger og øger chancen for at finde løsninger af høj kvalitet.

Fitness: Måling af løsningskvalitet

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åler, hvor god en løsning er ved at sammenligne den med en mål-værdi. Jo mindre forskellen er, desto højere bliver fitness-scoren. For eksempel, hvis løsningen er 97 og målet er 100, vil fitness-scoren være højere end hvis løsningen er 80.

Udvælgelse: Valg af de mest egnede kandidater

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)

Roulettehjulsudvælgelse vælger individer med en sandsynlighed, der er proportional med deres fitnessværdier. Dette betyder, at kandidater med højere fitness har større sandsynlighed for at blive valgt, men individer med lavere fitness kan stadig blive udvalgt, hvilket hjælper med at opretholde diversitet i populationen.

Mutation: Introduktion af 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 introducerer tilfældige ændringer i individer i populationen. Denne tilfældighed hjælper med at opretholde diversitet, hvilket gør det muligt for algoritmen at udforske nye løsninger og reducerer risikoen for at sidde fast ved dårlige løsninger.

Crossover: Kombination af egenskaber for nye løsninger

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

Denne funktion tager to forældreindivider (lister af heltal) og producerer to afkom ved at udveksle genetisk materiale på et tilfældigt valgt punkt. Crossover-punktet vælges således, at hvert afkom indeholder gener fra begge forældre.

Eksempel på anvendelse:

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)

Tilpasning: Hvordan populationer forbedres over tid

Tilpasning er den kumulative effekt af gentagne evolutionære operationer — selektion, crossover og mutation. Når disse processer gentages, bliver populationen gradvist bedre til at løse problemet, hvilket fører til løsninger af højere kvalitet over tid.