Het beheersen van de principes van evolutie en adaptatie is essentieel bij het ontwerpen van bio-geïnspireerde algoritmen. In zowel natuurlijke als computationele systemen verklaren deze principes hoe groepen individuen in de loop van de tijd veranderen en verbeteren. De fundamentele concepten omvatten:

• Populatie: De verzameling van alle kandidaatoplossingen of individuen die op een bepaald moment worden overwogen;
• Fitness: De maatstaf voor hoe goed elk individu presteert met betrekking tot het doel van het probleem;
• Selectie: Het proces waarbij individuen worden gekozen om de volgende generatie te produceren, vaak met een voorkeur voor degenen met een hogere fitness;
• Mutatie: De introductie van willekeurige veranderingen bij individuen, waardoor diversiteit behouden blijft en het verkennen van nieuwe oplossingen mogelijk wordt gemaakt;
• Crossover: De combinatie van delen van twee of meer individuen om nieuwe nakomelingen te creëren;
• Adaptatie: De voortdurende verbetering van de populatie als reactie op selectie, mutatie en crossover.

Elk concept ondersteunt de ontwikkeling van robuuste oplossingen door processen na te bootsen die aanpassing en succes in de natuur stimuleren.

Populatie

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)

De functie create_population genereert een groep individuen, waarbij elk individu wordt weergegeven door een lijst van willekeurige gehele getallen. Elk geheel getal kan worden beschouwd als een gen. Je specificeert de populatiegrootte, de lengte van elk individu en het bereik van genwaarden.

Het behouden van diversiteit in de populatie is essentieel. Een diverse populatie verkent meer van de oplossingsruimte, waardoor het risico op vastlopen in slechte oplossingen wordt verminderd en de kans op het vinden van hoogwaardige antwoorden toeneemt.

Fitness: Kwaliteitsmeting van oplossingen

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

De fitness_function meet hoe goed een oplossing is door deze te vergelijken met een doelwaarde. Hoe kleiner het verschil, hoe hoger de fitnessscore. Bijvoorbeeld, als de oplossing 97 is en het doel 100, zal de fitnessscore hoger zijn dan wanneer de oplossing 80 is.

Selectie: De fitste kandidaten kiezen

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)

Roulettewielselectie kiest individuen met een kans die evenredig is aan hun fitnessscore. Dit betekent dat kandidaten met een hogere fitness meer kans hebben om geselecteerd te worden, maar individuen met een lagere fitness kunnen nog steeds gekozen worden, wat helpt om diversiteit in de populatie te behouden.

Mutatie: Variatie Introduceren

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)

Mutatie introduceert willekeurige veranderingen bij individuen in de populatie. Deze willekeurigheid helpt om diversiteit te behouden, waardoor het algoritme nieuwe oplossingen kan verkennen en het risico op vastlopen bij suboptimale oplossingen wordt verminderd.

Crossover: Eigenschappen combineren voor nieuwe oplossingen

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

Deze functie neemt twee ouder-individuen (lijsten van gehele getallen) en produceert twee nakomelingen door genetisch materiaal uit te wisselen op een willekeurig gekozen punt. Het crossover-punt wordt geselecteerd zodat elke nakomeling genen van beide ouders bevat.

Voorbeeld van gebruik:

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)

Adaptatie: Hoe populaties zich in de loop van de tijd verbeteren

Adaptatie is het cumulatieve effect van herhaalde evolutionaire operaties — selectie, crossover en mutatie. Naarmate deze processen zich herhalen, wordt de populatie geleidelijk beter in het oplossen van het probleem, wat leidt tot oplossingen van hogere kwaliteit na verloop van tijd.