Å beherske prinsippene for evolusjon og tilpasning er avgjørende ved utforming av bio-inspirerte algoritmer. I både naturlige og beregningsmessige systemer forklarer disse prinsippene hvordan grupper av individer endres og forbedres over tid. De grunnleggende konseptene inkluderer:

• Populasjon: Mengden av alle kandidat-løsninger eller individer som vurderes samtidig;
• Fitness: Et mål på hvor godt hvert individ presterer i forhold til problemets målsetting;
• Seleksjon: Prosessen med å velge individer for å produsere neste generasjon, ofte med fordel for de med høyere fitness;
• Mutasjon: Innføring av tilfeldige endringer hos individer, som opprettholder mangfold og muliggjør utforskning av nye løsninger;
• Kryssing: Kombinasjon av deler fra to eller flere individer for å skape nytt avkom;
• Tilpasning: Den kontinuerlige forbedringen av populasjonen som følge av seleksjon, mutasjon og kryssing.

Hvert konsept støtter utviklingen av robuste løsninger ved å etterligne prosesser som driver tilpasning og suksess i naturen.

Populasjon

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)

Funksjonen create_population genererer en gruppe individer, der hvert individ representeres av en liste med tilfeldige heltall. Hvert heltall kan betraktes som et gen. Du angir populasjonsstørrelse, lengden på hvert individ og området for genverdier.

Å opprettholde mangfold i populasjonen er avgjørende. En mangfoldig populasjon utforsker mer av problemområdet, reduserer risikoen for å bli sittende fast i dårlige løsninger og øker sjansen for å finne løsninger av høy kvalitet.

Fitness: Måling av 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 å sammenligne den med en målverdi. Jo mindre forskjellen er, desto høyere blir fitness-poengsummen. For eksempel, hvis løsningen er 97 og målet er 100, vil fitness-poengsummen være høyere enn om løsningen er 80.

Utvalg: Valg av de mest egnede kandidatene

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)

Roulettehjulsutvalg velger individer med sannsynlighet proporsjonal med deres fitnessverdier. Dette innebærer at kandidater med høyere fitness har større sannsynlighet for å bli valgt, men individer med lavere fitness kan fortsatt bli valgt, noe som bidrar til å opprettholde mangfoldet i populasjonen.

Mutasjon: Innføring av variasjon

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)

Mutasjon introduserer tilfeldige endringer i individer i populasjonen. Denne tilfeldigheten bidrar til å opprettholde mangfold, slik at algoritmen kan utforske nye løsninger og redusere risikoen for å bli fastlåst i dårlige løsninger.

Crossover: Blanding av egenskaper 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 funksjonen tar to foreldreindivider (lister med heltall) og produserer to avkom ved å bytte genetisk materiale på et tilfeldig valgt punkt. Krysningspunktet velges slik at hvert avkom inneholder gener fra begge foreldrene.

Eksempel på bruk:

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 populasjoner forbedres over tid

Tilpasning er den kumulative effekten av gjentatte evolusjonære operasjoner — seleksjon, krysning og mutasjon. Etter hvert som disse prosessene gjentas, blir populasjonen gradvis bedre til å løse problemet, noe som fører til løsninger av høyere kvalitet over tid.