Evoluution ja sopeutumisen periaatteiden hallinta on olennaista bioinspiroitujen algoritmien suunnittelussa. Sekä luonnollisissa että laskennallisissa järjestelmissä nämä periaatteet selittävät, miten yksilöiden ryhmät muuttuvat ja parantuvat ajan myötä. Keskeisiä käsitteitä ovat:

• Populaatio: Kaikkien tarkasteltavien ratkaisuehdokkaiden tai yksilöiden joukko yhdellä hetkellä;
• Soveltuvuus: Mittari siitä, kuinka hyvin kukin yksilö suoriutuu suhteessa ongelman tavoitteeseen;
• Valinta: Prosessi, jossa valitaan yksilöitä tuottamaan seuraava sukupolvi, usein suosien korkeamman soveltuvuuden omaavia;
• Mutaatio: Satunnaisten muutosten tuominen yksilöihin, mikä ylläpitää monimuotoisuutta ja mahdollistaa uusien ratkaisujen tutkimisen;
• Risteytys: Osien yhdistäminen kahdesta tai useammasta yksilöstä uusien jälkeläisten luomiseksi;
• Sopeutuminen: Populaation jatkuva parantuminen valinnan, mutaation ja risteytyksen seurauksena.

Jokainen käsite tukee vankkojen ratkaisujen kehittämistä jäljittelemällä luonnossa tapahtuvia sopeutumista ja menestystä ohjaavia prosesseja.

Populaatio

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)

create_population-funktio muodostaa joukon yksilöitä, joista kukin esitetään satunnaisten kokonaislukujen listana. Jokainen kokonaisluku voidaan ajatella geeninä. Määrität populaation koon, yksilön pituuden ja geenien arvojen vaihteluvälin.

Monimuotoisuuden ylläpitäminen populaatiossa on olennaista. Monimuotoinen populaatio tutkii laajemmin ongelma-avaruutta, mikä vähentää huonojen ratkaisujen loukkuun jäämisen riskiä ja lisää korkealaatuisten vastausten löytymisen todennäköisyyttä.

Soveltuvuus: Ratkaisun laadun mittaaminen

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 mittaa ratkaisun laatua vertaamalla sitä tavoitearvoon. Mitä pienempi ero, sitä korkeampi kelpoisuuspisteet. Esimerkiksi, jos ratkaisu on 97 ja tavoite on 100, kelpoisuuspisteet ovat korkeammat kuin jos ratkaisu olisi 80.

Valinta: Parhaiden ehdokkaiden valitseminen

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)

Rulettipyörävalinta valitsee yksilöitä todennäköisyydellä, joka on verrannollinen niiden kelpoisuuspisteisiin. Tämä tarkoittaa, että korkeamman kelpoisuuden omaavat ehdokkaat valitaan todennäköisemmin, mutta myös matalamman kelpoisuuden yksilöt voivat tulla valituiksi, mikä auttaa ylläpitämään populaation monimuotoisuutta.

Mutaatio: Vaihtelun lisääminen

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)

Mutaatio tuo satunnaisia muutoksia populaation yksilöihin. Tämä satunnaisuus auttaa ylläpitämään monimuotoisuutta, mahdollistaen algoritmin tutkia uusia ratkaisuja ja vähentäen riskiä jumittua huonoihin ratkaisuihin.

Risteytys: Ominaisuuksien yhdistäminen uusiksi ratkaisuiksi

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

Tämä funktio ottaa kaksi vanhempaa yksilöä (kokonaislukulistat) ja tuottaa kaksi jälkeläistä vaihtamalla geneettistä materiaalia satunnaisesti valitussa kohdassa. Risteytyspiste valitaan siten, että kumpikin jälkeläinen sisältää geenejä molemmilta vanhemmilta.

Esimerkki käytöstä:

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)

Sopeutuminen: Kuinka populaatiot parantuvat ajan myötä

Sopeutuminen on toistuvien evolutiivisten operaatioiden — valinnan, risteytyksen ja mutaatioiden — yhteisvaikutus. Kun nämä prosessit toistuvat, populaatio kehittyy vähitellen paremmaksi ongelmanratkaisussa, mikä johtaa ajan myötä laadukkaampiin ratkaisuihin.