Das Beherrschen der Prinzipien von Evolution und Anpassung ist entscheidend bei der Entwicklung bio-inspirierter Algorithmen. In natürlichen wie auch in rechnergestützten Systemen erklären diese Prinzipien, wie sich Gruppen von Individuen im Laufe der Zeit verändern und verbessern. Zu den grundlegenden Konzepten gehören:

• Population: Die Gesamtheit aller zu einem Zeitpunkt betrachteten Kandidatenlösungen oder Individuen;
• Fitness: Das Maß dafür, wie gut jedes Individuum in Bezug auf das Problemziel abschneidet;
• Selektion: Der Prozess der Auswahl von Individuen zur Erzeugung der nächsten Generation, wobei häufig solche mit höherer Fitness bevorzugt werden;
• Mutation: Die Einführung zufälliger Veränderungen bei Individuen, um die Vielfalt zu erhalten und die Erkundung neuer Lösungen zu ermöglichen;
• Crossover: Die Kombination von Teilen aus zwei oder mehr Individuen zur Erzeugung neuer Nachkommen;
• Anpassung: Die fortlaufende Verbesserung der Population als Reaktion auf Selektion, Mutation und Crossover.

Jedes dieser Konzepte unterstützt die Entwicklung robuster Lösungen, indem es Prozesse nachahmt, die in der Natur Anpassung und Erfolg fördern.

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)

Die Funktion create_population erzeugt eine Gruppe von Individuen, wobei jedes Individuum durch eine Liste zufälliger Ganzzahlen dargestellt wird. Jede Ganzzahl kann als Gen betrachtet werden. Die Populationsgröße, die Länge jedes Individuums und der Wertebereich der Gene werden vorgegeben.

Die Erhaltung der Vielfalt in der Population ist wesentlich. Eine vielfältige Population erkundet mehr vom Lösungsraum, verringert das Risiko, in schlechten Lösungen stecken zu bleiben, und erhöht die Wahrscheinlichkeit, hochwertige Antworten zu finden.

Fitness: Bewertung der Lösungsqualität

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

Die fitness_function misst, wie gut eine Lösung ist, indem sie mit einem Zielwert verglichen wird. Je kleiner der Unterschied, desto höher der Fitnesswert. Wenn zum Beispiel die Lösung 97 und das Ziel 100 ist, ist der Fitnesswert höher als bei einer Lösung von 80.

Selektion: Auswahl der fittesten Kandidaten

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)

Roulette-Rad-Selektion wählt Individuen mit einer Wahrscheinlichkeit aus, die proportional zu ihren Fitnesswerten ist. Das bedeutet, dass Kandidaten mit höherer Fitness mit größerer Wahrscheinlichkeit ausgewählt werden, aber auch Individuen mit niedrigerer Fitness können ausgewählt werden, was zur Erhaltung der Diversität in der Population beiträgt.

Mutation: Einführung von 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 führt zufällige Veränderungen bei Individuen in der Population ein. Diese Zufälligkeit trägt zur Erhaltung der Diversität bei, ermöglicht dem Algorithmus die Erkundung neuer Lösungen und verringert das Risiko, bei schlechten Lösungen steckenzubleiben.

Crossover: Merkmalsmischung für neue Lösungen

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

Diese Funktion nimmt zwei Elternindividuen (Listen von Ganzzahlen) und erzeugt zwei Nachkommen, indem genetisches Material an einem zufällig gewählten Punkt ausgetauscht wird. Der Crossover-Punkt wird so gewählt, dass jeder Nachkomme Gene von beiden Elternteilen enthält.

Beispiel für die Anwendung:

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)

Anpassung: Wie sich Populationen im Laufe der Zeit verbessern

Anpassung ist die kumulative Wirkung wiederholter evolutionärer Operationen — Selektion, Kreuzung und Mutation. Durch die wiederholte Anwendung dieser Prozesse wird die Population allmählich besser darin, das Problem zu lösen, was im Laufe der Zeit zu hochwertigeren Lösungen führt.