Dominar os princípios de evolução e adaptação é fundamental ao projetar algoritmos bioinspirados. Em sistemas naturais e computacionais, esses princípios explicam como grupos de indivíduos mudam e melhoram ao longo do tempo. Os conceitos fundamentais incluem:

• População: Conjunto de todas as soluções candidatas ou indivíduos considerados em um determinado momento;
• Aptidão: Medida de quão bem cada indivíduo desempenha em relação ao objetivo do problema;
• Seleção: Processo de escolha dos indivíduos para produzir a próxima geração, geralmente favorecendo aqueles com maior aptidão;
• Mutação: Introdução de alterações aleatórias nos indivíduos, mantendo a diversidade e possibilitando a exploração de novas soluções;
• Cruzamento: Combinação de partes de dois ou mais indivíduos para criar novos descendentes;
• Adaptação: Melhoria contínua da população em resposta à seleção, mutação e cruzamento.

Cada conceito contribui para o desenvolvimento de soluções robustas ao imitar processos que impulsionam a adaptação e o sucesso na natureza.

População

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)

A função create_population gera um grupo de indivíduos, onde cada indivíduo é representado por uma lista de números inteiros aleatórios. Cada inteiro pode ser considerado um gene. Você especifica o tamanho da população, o comprimento de cada indivíduo e o intervalo dos valores dos genes.

Manter a diversidade na população é essencial. Uma população diversa explora mais o espaço do problema, reduzindo o risco de ficar preso em soluções ruins e aumentando a chance de encontrar respostas de alta qualidade.

Aptidão: Medindo a Qualidade da Solução

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

A fitness_function mede a qualidade de uma solução comparando-a com um valor alvo. Quanto menor a diferença, maior a pontuação de aptidão. Por exemplo, se a solução for 97 e o alvo for 100, a pontuação de aptidão será maior do que se a solução for 80.

Seleção: Escolha dos Candidatos Mais Aptos

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)

A seleção por roleta escolhe indivíduos com probabilidade proporcional às suas pontuações de aptidão. Isso significa que candidatos com maior aptidão têm mais chances de serem selecionados, mas indivíduos com menor aptidão ainda podem ser escolhidos, ajudando a manter a diversidade na população.

Mutação: Introdução de Variação

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)

A mutação introduz alterações aleatórias nos indivíduos da população. Essa aleatoriedade ajuda a manter a diversidade, permitindo que o algoritmo explore novas soluções e reduzindo o risco de ficar preso em soluções ruins.

Crossover: Mistura de Características para Novas Soluções

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

Esta função recebe dois indivíduos pais (listas de inteiros) e produz dois descendentes trocando material genético em um ponto escolhido aleatoriamente. O ponto de crossover é selecionado de modo que cada descendente contenha genes de ambos os pais.

Exemplo de uso:

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)

Adaptação: Como as Populações Melhoram ao Longo do Tempo

Adaptação é o efeito cumulativo de operações evolutivas repetidas — seleção, cruzamento e mutação. À medida que esses processos se repetem, a população gradualmente se torna mais eficiente na resolução do problema, resultando em soluções de maior qualidade ao longo do tempo.