Arquivo de Python - Página 16 de 31

Automatos Finitos Evolutivos

16/07/202617/06/2026 Por antonino

O que são autômatos finitos evolutivos?

Autômatos finitos evolutivos (AFE) são máquinas de estados que aprendem por evolução artificial. Cada indivíduo é um autômato finito determinístico (AFD) com estados, transições e saídas. A evolução altera o número de estados, as transições ou os símbolos de saída. Diferentemente de redes neurais, eles são discretos, interpretáveis e leves. A aptidão mede o quão bem o autômato resolve uma tarefa sequencial. Por exemplo, ele pode prever o próximo elemento de uma série temporal. Ou pode classificar padrões binários que chegam ao longo do tempo. A programação evolutiva foi originalmente criada para evoluir esses autômatos. Portanto, os AFE são a aplicação clássica da programação evolutiva.

Como funciona a evolução de um autômato?

Inicialmente, uma população de autômatos aleatórios é gerada. Cada um tem um número fixo de estados (ex.: 5) e alfabeto de entrada. As transições são tabelas que mapeiam (estado, símbolo) para próximo estado. Cada estado também possui uma saída (ex.: 0 ou 1 para classificação). A mutação pode alterar uma transição, uma saída ou adicionar/remover estados. O crossover pode trocar sub-tabelas de transição entre dois autômatos. A avaliação percorre o autômato com uma sequência de entrada conhecida. A saída gerada é comparada com a saída desejada (supervisionado). A aptidão é a acurácia ou o erro acumulado ao longo da sequência. Os melhores autômatos são selecionados para a próxima geração.

Aplicações e vantagens práticas

AFE são usados em reconhecimento de padrões temporais e linguagens regulares. Eles também são aplicados em controle de robôs com sensores discretos. Uma grande vantagem é a total interpretabilidade do comportamento aprendido. O engenheiro pode inspecionar estados e transições para entender a decisão. Além disso, eles exigem pouca memória e executam em tempo real. Contudo, eles não lidam bem com entradas contínuas ou ruidosas. Para esses casos, pré-processamento ou fuzzificação é necessário. Ainda assim, os AFE são uma ferramenta didática e poderosa.

Os autômatos finitos evolutivos foram popularizados por Fogel no final dos anos 1960. Ele usou AFE para prever o comportamento de sinais de radar e econômicos. Cada autômato previa o próximo bit de uma sequência binária. A aptidão era a porcentagem de acertos ao longo de todo o histórico. A mutação podia trocar uma transição ou inverter a saída de um estado. Não havia crossover na versão original, apenas mutação pura. Com o tempo, variantes com crossover e auto-adaptação surgiram. Hoje, os AFE são usados em jogos, segurança e bioinformática. Por exemplo, eles podem detectar anomalias em tráfego de rede. Também podem modelar o comportamento de usuários em sistemas interativos. Sua simplicidade os torna ideais para dispositivos embarcados. Eles são frequentemente comparados a redes neurais recorrentes discretizadas. A principal diferença é a ausência de pesos contínuos. Assim, os AFE oferecem um equilíbrio entre expressividade e clareza.

Um exemplo clássico é o problema de previsão do próximo símbolo em uma sequência. Dada uma sequência binária gerada por uma máquina de estados oculta. O AFE deve inferir a regra subjacente sem conhecer a máquina original. Por exemplo, a sequência alterna entre 0 e 1 após cada dois dígitos. O autômato evolui sua tabela de transições até acertar a previsão. Esse problema é simples, mas ilustra perfeitamente o mecanismo de aprendizado.

Enunciado do exemplo clássico

Evolua um autômato finito determinístico com 4 estados para prever o próximo bit da sequência de Fibonacci binária (módulo 2). A sequência é: 0,1,1,0,1,1,0,1,1,… (período 3: 0,1,1 repetido). Use 100 exemplos de treinamento (bits) e 50 de teste (após o treino). População de 50 autômatos, mutação de transição (10%) e saída (5%) por geração. Execute 100 gerações, com seleção por torneio de tamanho 3. Plote a acurácia de treino e teste ao longo das gerações. Plote também um diagrama do melhor autômato encontrado (texto).

import numpy as np  
import matplotlib.pyplot as plt  

# Gera sequência de Fibonacci módulo 2 (período 3: 0,1,1)  
def fibonacci_binaria(n):  
    seq = []  
    a, b = 0, 1  
    for _ in range(n):  
        seq.append(a % 2)  
        a, b = b, (a + b) % 2  
    return seq  

# Parâmetros  
num_estados = 4  
alfabeto = [0, 1]  
pop_size = 50  
geracoes = 100  
taxa_mut_trans = 0.10  
taxa_mut_saida = 0.05  
tamanho_torneio = 3  

# Gerar dados  
treino_len = 100  
teste_len = 50  
treino_seq = fibonacci_binaria(treino_len)  
teste_seq = fibonacci_binaria(treino_len + teste_len)[treino_len:]  

# Representação: cada autômato é (transicoes, saidas)  
# transicoes: dict (estado, simbolo) -> prox_estado  
# saidas: dict estado -> 0 ou 1  

def cria_autômato():  
    trans = {}  
    saidas = {}  
    for e in range(num_estados):  
        saidas[e] = np.random.randint(0, 2)  
        for s in alfabeto:  
            trans[(e, s)] = np.random.randint(0, num_estados)  
    return trans, saidas  

def avaliar(automato, seq, n_predicoes):  
    trans, saidas = automato  
    estado = 0  
    acertos = 0  
    # Usamos os primeiros n_predicoes bits para prever o próximo  
    for i in range(n_predicoes - 1):  
        simbolo = seq[i]  
        estado = trans[(estado, simbolo)]  
        predicao = saidas[estado]  
        if predicao == seq[i+1]:  
            acertos += 1  
    return acertos / (n_predicoes - 1) if n_predicoes > 1 else 0.0  

def mutar(automato):  
    trans, saidas = automato  
    # Mutação de transição  
    for key in list(trans.keys()):  
        if np.random.random() < taxa_mut_trans:  
            trans[key] = np.random.randint(0, num_estados)  
    # Mutação de saída  
    for e in saidas:  
        if np.random.random() < taxa_mut_saida:  
            saidas[e] = 1 - saidas[e]  
    return trans, saidas  

# Inicialização  
populacao = [cria_autômato() for _ in range(pop_size)]  

# Histórico de acurácias  
melhor_treino_hist = []  
melhor_teste_hist = []  
melhor_automato = None  

for gen in range(geracoes):  
    # Avaliar treino  
    fitness_treino = [avaliar(ind, treino_seq, treino_len) for ind in populacao]  
    # Seleção por torneio  
    nova_pop = []  
    for _ in range(pop_size):  
        indices = np.random.choice(pop_size, tamanho_torneio, replace=False)  
        vencedor = indices[np.argmax([fitness_treino[i] for i in indices])]  
        nova_pop.append(populacao[vencedor])  
    # Mutação (exceto o melhor, elitismo)  
    melhor_idx = np.argmax(fitness_treino)  
    melhor_ind = populacao[melhor_idx]  
    nova_pop[0] = melhor_ind  # mantém o melhor  
    for i in range(1, pop_size):  
        nova_pop[i] = mutar(nova_pop[i])  
    populacao = nova_pop  

    # Melhor da geração  
    melhor_treino = np.max(fitness_treino)  
    melhor_teste = avaliar(melhor_ind, teste_seq, teste_len)  
    melhor_treino_hist.append(melhor_treino)  
    melhor_teste_hist.append(melhor_teste)  
    if melhor_treino > max(melhor_treino_hist[:-1], default=-1):  
        melhor_automato = (melhor_ind[0].copy(), melhor_ind[1].copy())  

# Resultado final  
print("Melhor autômato encontrado:")  
trans, saidas = melhor_automato  
print("Transições (estado, símbolo) -> próximo estado:")  
for e in range(num_estados):  
    for s in alfabeto:  
        print(f"  ({e},{s}) -> {trans[(e,s)]}")  
print("Saídas por estado:")  
for e in range(num_estados):  
    print(f"  estado {e} -> {saidas[e]}")  

# Gráfico 1: Acurácias de treino e teste  
plt.figure(figsize=(12, 5))  
plt.subplot(1, 2, 1)  
plt.plot(melhor_treino_hist, 'b-', label='Treino', linewidth=2)  
plt.plot(melhor_teste_hist, 'r--', label='Teste', linewidth=2)  
plt.title('Evolução da Acurácia - AFE')  
plt.xlabel('Geração')  
plt.ylabel('Acurácia')  
plt.ylim(0, 1.05)  
plt.legend()  
plt.grid(True)  

# Gráfico 2: Diagrama textual do melhor autômato  
plt.subplot(1, 2, 2)  
texto = "Melhor AFD encontrado:\n\n"  
texto += "Transições:\n"  
for e in range(num_estados):  
    for s in alfabeto:  
        texto += f"  δ({e},{s}) = {trans[(e,s)]}\n"  
texto += "\nSaídas:\n"  
for e in range(num_estados):  
    texto += f"  λ({e}) = {saidas[e]}\n"  
plt.text(0.1, 0.5, texto, fontsize=10, family='monospace',  
         bbox=dict(facecolor='lightyellow', alpha=0.9))  
plt.axis('off')  
plt.title('Estrutura do Melhor Autômato')  
plt.tight_layout()  
plt.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

import numpy as np

import matplotlib.pyplot as plt

# Gera sequência de Fibonacci módulo 2 (período 3: 0,1,1)

def fibonacci_binaria(n):

seq = []

a, b = 0, 1

for _ in range(n):

seq.append(a % 2)

a, b = b, (a + b) % 2

return seq

# Parâmetros

num_estados = 4

alfabeto = [0, 1]

pop_size = 50

geracoes = 100

taxa_mut_trans = 0.10

taxa_mut_saida = 0.05

tamanho_torneio = 3

# Gerar dados

treino_len = 100

teste_len = 50

treino_seq = fibonacci_binaria(treino_len)

teste_seq = fibonacci_binaria(treino_len + teste_len)[treino_len:]

# Representação: cada autômato é (transicoes, saidas)

# transicoes: dict (estado, simbolo) -> prox_estado

# saidas: dict estado -> 0 ou 1

def cria_autômato():

trans = {}

saidas = {}

for e in range(num_estados):

saidas[e] = np.random.randint(0, 2)

for s in alfabeto:

trans[(e, s)] = np.random.randint(0, num_estados)

return trans, saidas

def avaliar(automato, seq, n_predicoes):

trans, saidas = automato

estado = 0

acertos = 0

# Usamos os primeiros n_predicoes bits para prever o próximo

for i in range(n_predicoes - 1):

simbolo = seq[i]

estado = trans[(estado, simbolo)]

predicao = saidas[estado]

if predicao == seq[i+1]:

acertos += 1

return acertos / (n_predicoes - 1) if n_predicoes > 1 else 0.0

def mutar(automato):

trans, saidas = automato

# Mutação de transição

for key in list(trans.keys()):

if np.random.random() < taxa_mut_trans:

trans[key] = np.random.randint(0, num_estados)

# Mutação de saída

for e in saidas:

if np.random.random() < taxa_mut_saida:

saidas[e] = 1 - saidas[e]

return trans, saidas

# Inicialização

populacao = [cria_autômato() for _ in range(pop_size)]

# Histórico de acurácias

melhor_treino_hist = []

melhor_teste_hist = []

melhor_automato = None

for gen in range(geracoes):

# Avaliar treino

fitness_treino = [avaliar(ind, treino_seq, treino_len) for ind in populacao]

# Seleção por torneio

nova_pop = []

for _ in range(pop_size):

indices = np.random.choice(pop_size, tamanho_torneio, replace=False)

vencedor = indices[np.argmax([fitness_treino[i] for i in indices])]

nova_pop.append(populacao[vencedor])

# Mutação (exceto o melhor, elitismo)

melhor_idx = np.argmax(fitness_treino)

melhor_ind = populacao[melhor_idx]

nova_pop[0] = melhor_ind # mantém o melhor

for i in range(1, pop_size):

nova_pop[i] = mutar(nova_pop[i])

populacao = nova_pop

# Melhor da geração

melhor_treino = np.max(fitness_treino)

melhor_teste = avaliar(melhor_ind, teste_seq, teste_len)

melhor_treino_hist.append(melhor_treino)

melhor_teste_hist.append(melhor_teste)

if melhor_treino > max(melhor_treino_hist[:-1], default=-1):

melhor_automato = (melhor_ind[0].copy(), melhor_ind[1].copy())

# Resultado final

print("Melhor autômato encontrado:")

trans, saidas = melhor_automato

print("Transições (estado, símbolo) -> próximo estado:")

for e in range(num_estados):

for s in alfabeto:

print(f" ({e},{s}) -> {trans[(e,s)]}")

print("Saídas por estado:")

for e in range(num_estados):

print(f" estado {e} -> {saidas[e]}")

# Gráfico 1: Acurácias de treino e teste

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)

plt.plot(melhor_treino_hist, 'b-', label='Treino', linewidth=2)

plt.plot(melhor_teste_hist, 'r--', label='Teste', linewidth=2)

plt.title('Evolução da Acurácia - AFE')

plt.xlabel('Geração')

plt.ylabel('Acurácia')

plt.ylim(0, 1.05)

plt.legend()

plt.grid(True)

# Gráfico 2: Diagrama textual do melhor autômato

plt.subplot(1, 2, 2)

texto = "Melhor AFD encontrado:\n\n"

texto += "Transições:\n"

for e in range(num_estados):

for s in alfabeto:

texto += f" δ({e},{s}) = {trans[(e,s)]}\n"

texto += "\nSaídas:\n"

for e in range(num_estados):

texto += f" λ({e}) = {saidas[e]}\n"

plt.text(0.1, 0.5, texto, fontsize=10, family='monospace',

bbox=dict(facecolor='lightyellow', alpha=0.9))

plt.axis('off')

plt.title('Estrutura do Melhor Autômato')

plt.tight_layout()

plt.show()

Este código evolui um AFD para prever a sequência de Fibonacci binária. A curva de acurácia mostra a melhoria tanto em treino quanto em teste. O diagrama textual exibe as transições e saídas do melhor autômato. Observe que o autômato converge para o período 3 (0,1,1) após algumas gerações. A interpretabilidade é total: cada estado e transição podem ser lidos. Para iniciantes, este exemplo conecta evolução, autômatos e previsão. Os autômatos finitos evolutivos são, portanto, uma ferramenta educativa e prática.

Programação Evolutiva

16/07/202617/06/2026 Por antonino

O que é programação evolutiva?

Programação evolutiva (PE) é uma técnica de computação inspirada na evolução natural. Diferentemente dos algoritmos genéticos, ela enfatiza mutação em vez de crossover. Cada indivíduo é uma estrutura que representa um programa ou uma máquina de estados. Originalmente, ela evoluía autômatos finitos para prever sequências temporais. Hoje, a PE é aplicada a problemas de otimização contínua e discreta. A aptidão é medida pelo desempenho do indivíduo em uma tarefa específica. Os melhores indivíduos são selecionados para produzir filhos por mutação. Não há recombinação genética na forma clássica da PE. Portanto, a diversidade é mantida exclusivamente por variações mutacionais. Ela é considerada uma das abordagens evolutivas mais antigas.

Mecanismos centrais de funcionamento

A PE opera com uma população de tamanho fixo, geralmente entre 50 e 200. Cada indivíduo sofre mutação gaussiana ou cauchy em seus parâmetros. A intensidade da mutação pode ser fixa ou auto-adaptativa, como nas ES. Após a mutação, todos os filhos são avaliados pela função de aptidão. A seleção é feita por torneio estocástico ou por truncamento (μ,λ). Os indivíduos sobreviventes formam a próxima geração. Esse ciclo se repete até que um critério de parada seja satisfeito. A PE é particularmente eficaz para funções com muitas variáveis. Além disso, ela lida bem com ruído e incertezas nos dados.

Diferenças e aplicações práticas

A grande diferença da PE para os algoritmos genéticos é a ausência de crossover. Isso a torna mais simples de implementar e ajustar. Por outro lado, ela pode convergir mais lentamente em paisagens complexas. A PE é amplamente usada em previsão de séries temporais e finanças. Também é aplicada em controle de processos industriais e robótica. Sua capacidade de evoluir estratégias de tomada de decisão é notável. Para iniciantes, a PE oferece um ponto de entrada suave na computação evolutiva.

A programação evolutiva foi proposta por Lawrence Fogel nos anos 1960. Ele utilizou autômatos finitos para prever eventos em ambientes incertos. Cada autômato era uma sequência de estados e transições mutáveis. A aptidão media a precisão da previsão ao longo do tempo. Com o tempo, a PE foi generalizada para vetores numéricos reais. Atualmente, ela é frequentemente confundida com estratégias evolutivas. Contudo, a PE mantém sua identidade pela ênfase na mutação pura. Muitos pesquisadores a usam para problemas onde o crossover é prejudicial. Por exemplo, em otimização de redes neurais recorrentes. A mutação pode alterar pesos, arquitetura ou funções de ativação. A PE também é usada para gerar regras fuzzy automaticamente. Sua flexibilidade permite incorporar conhecimentos específicos do domínio. Ela é uma ferramenta valiosa para problemas mal definidos. Assim, a PE complementa outras técnicas evolutivas no arsenal do cientista.

Um exemplo clássico é evoluir um controlador para o problema do pêndulo invertido. O objetivo é manter a haste na vertical aplicando forças laterais. Cada indivíduo é um vetor de parâmetros de um controlador PID. A aptidão é o tempo que o pêndulo permanece equilibrado. A mutação ajusta os ganhos proporcional, integral e derivativo. Após algumas gerações, a PE encontra um conjunto estável de parâmetros. Esse problema ilustra a capacidade de otimização contínua da PE.

Enunciado do exemplo clássico

Utilize programação evolutiva para minimizar a função de Schwefel em 5 dimensões: f(x) = 418.9829*5 – Σᵢ xᵢ * sin(√|xᵢ|), com xᵢ ∈ [-500, 500]. O mínimo global é em xᵢ = 420.9687 para todo i, com f ≈ 0. Use população de 100 indivíduos, mutação gaussiana com sigma=15, auto-adaptação. Seleção por torneio estocástico de tamanho 2, com 80% de chance de vencer. Execute 300 gerações e armazene o melhor fitness por geração. Plote a curva de convergência e a distribuição final dos parâmetros.

import numpy as np  
import matplotlib.pyplot as plt  

# Função de Schwefel (minimização)  
def schwefel(x):  
    return 418.9829 * len(x) - np.sum(x * np.sin(np.sqrt(np.abs(x))))  

# Parâmetros  
pop_size = 100  
geracoes = 300  
dim = 5  
limites = [-500, 500]  
sigma_inicial = 15.0  
tau = 1.0 / np.sqrt(2 * dim)  

# Inicialização  
populacao = np.random.uniform(limites[0], limites[1], size=(pop_size, dim))  
sigmas = np.full((pop_size, dim), sigma_inicial)  

# Avaliação inicial  
fitness = np.array([schwefel(ind) for ind in populacao])  

# Histórico do melhor  
melhor_fitness_hist = [np.min(fitness)]  
melhor_ind_hist = [populacao[np.argmin(fitness)].copy()]  

for gen in range(geracoes):  
    # Geração de filhos por mutação (cada pai gera um filho)  
    filhos = np.zeros_like(populacao)  
    sigmas_filhos = np.zeros_like(sigmas)  
    for i in range(pop_size):  
        # Auto-adaptação dos sigmas  
        novo_sigma = sigmas[i] * np.exp(tau * np.random.normal(0, 1, size=dim))  
        novo_sigma = np.clip(novo_sigma, 1e-8, 100.0)  
        # Mutação gaussiana  
        filho = populacao[i] + np.random.normal(0, novo_sigma)  
        filho = np.clip(filho, limites[0], limites[1])  
        filhos[i] = filho  
        sigmas_filhos[i] = novo_sigma  

    # Avaliar filhos  
    fitness_filhos = np.array([schwefel(ind) for ind in filhos])  

    # Seleção por torneio estocástico (tamanho 2, probabilidade 0.8)  
    # Juntamos pais e filhos (abordagem (μ+μ) para PE clássica)  
    populacao_total = np.vstack([populacao, filhos])  
    fitness_total = np.concatenate([fitness, fitness_filhos])  
    sigmas_total = np.vstack([sigmas, sigmas_filhos])  

    nova_populacao = []  
    nova_sigmas = []  
    for _ in range(pop_size):  
        # Escolher dois indivíduos aleatórios  
        i1, i2 = np.random.choice(len(populacao_total), 2, replace=False)  
        # Torneio probabilístico  
        if np.random.random() < 0.8:  
            if fitness_total[i1] < fitness_total[i2]:  
                vencedor = i1  
            else:  
                vencedor = i2  
        else:  
            vencedor = i1 if np.random.random() < 0.5 else i2  
        nova_populacao.append(populacao_total[vencedor])  
        nova_sigmas.append(sigmas_total[vencedor])  

    populacao = np.array(nova_populacao)  
    sigmas = np.array(nova_sigmas)  
    fitness = np.array([schwefel(ind) for ind in populacao])  

    # Registrar melhor  
    melhor_fitness_hist.append(np.min(fitness))  
    melhor_ind_hist.append(populacao[np.argmin(fitness)].copy())  

# Resultado final  
melhor_final = min(melhor_fitness_hist)  
idx_final = melhor_fitness_hist.index(melhor_final)  
ponto_final = melhor_ind_hist[idx_final]  
print(f"Melhor fitness encontrado: {melhor_final:.6f}")  
print(f"Melhor ponto: {ponto_final}")  
print(f"Valor teórico global: 0.0 (em x = 420.9687)")  

# Gráfico 1: Curva de convergência  
plt.figure(figsize=(12, 5))  
plt.subplot(1, 2, 1)  
plt.plot(melhor_fitness_hist, 'b-', linewidth=2)  
plt.title('Convergência da Programação Evolutiva')  
plt.xlabel('Geração')  
plt.ylabel('Melhor Fitness (Schwefel)')  
plt.grid(True)  

# Gráfico 2: Distribuição final dos parâmetros (violin plot)  
plt.subplot(1, 2, 2)  
# Mostrar apenas as 5 dimensões  
partes = plt.violinplot(populacao.T, showmeans=True, showmedians=True)  
for pc in partes['bodies']:  
    pc.set_facecolor('skyblue')  
    pc.set_alpha(0.6)  
plt.axhline(y=420.9687, color='red', linestyle='--', label='Ótimo teórico')  
plt.title('Distribuição Final dos Parâmetros')  
plt.xlabel('Dimensão')  
plt.ylabel('Valor de xᵢ')  
plt.xticks(range(1, dim+1))  
plt.legend()  
plt.grid(True)  
plt.tight_layout()  
plt.show()

100

101

102

103

104

105

106

import numpy as np

import matplotlib.pyplot as plt

# Função de Schwefel (minimização)

def schwefel(x):

return 418.9829 * len(x) - np.sum(x * np.sin(np.sqrt(np.abs(x))))

# Parâmetros

pop_size = 100

geracoes = 300

dim = 5

limites = [-500, 500]

sigma_inicial = 15.0

tau = 1.0 / np.sqrt(2 * dim)

# Inicialização

populacao = np.random.uniform(limites[0], limites[1], size=(pop_size, dim))

sigmas = np.full((pop_size, dim), sigma_inicial)

# Avaliação inicial

fitness = np.array([schwefel(ind) for ind in populacao])

# Histórico do melhor

melhor_fitness_hist = [np.min(fitness)]

melhor_ind_hist = [populacao[np.argmin(fitness)].copy()]

for gen in range(geracoes):

# Geração de filhos por mutação (cada pai gera um filho)

filhos = np.zeros_like(populacao)

sigmas_filhos = np.zeros_like(sigmas)

for i in range(pop_size):

# Auto-adaptação dos sigmas

novo_sigma = sigmas[i] * np.exp(tau * np.random.normal(0, 1, size=dim))

novo_sigma = np.clip(novo_sigma, 1e-8, 100.0)

# Mutação gaussiana

filho = populacao[i] + np.random.normal(0, novo_sigma)

filho = np.clip(filho, limites[0], limites[1])

filhos[i] = filho

sigmas_filhos[i] = novo_sigma

# Avaliar filhos

fitness_filhos = np.array([schwefel(ind) for ind in filhos])

# Seleção por torneio estocástico (tamanho 2, probabilidade 0.8)

# Juntamos pais e filhos (abordagem (μ+μ) para PE clássica)

populacao_total = np.vstack([populacao, filhos])

fitness_total = np.concatenate([fitness, fitness_filhos])

sigmas_total = np.vstack([sigmas, sigmas_filhos])

nova_populacao = []

nova_sigmas = []

for _ in range(pop_size):

# Escolher dois indivíduos aleatórios

i1, i2 = np.random.choice(len(populacao_total), 2, replace=False)

# Torneio probabilístico

if np.random.random() < 0.8:

if fitness_total[i1] < fitness_total[i2]:

vencedor = i1

else:

vencedor = i2

else:

vencedor = i1 if np.random.random() < 0.5 else i2

nova_populacao.append(populacao_total[vencedor])

nova_sigmas.append(sigmas_total[vencedor])

populacao = np.array(nova_populacao)

sigmas = np.array(nova_sigmas)

fitness = np.array([schwefel(ind) for ind in populacao])

# Registrar melhor

melhor_fitness_hist.append(np.min(fitness))

melhor_ind_hist.append(populacao[np.argmin(fitness)].copy())

# Resultado final

melhor_final = min(melhor_fitness_hist)

idx_final = melhor_fitness_hist.index(melhor_final)

ponto_final = melhor_ind_hist[idx_final]

print(f"Melhor fitness encontrado: {melhor_final:.6f}")

print(f"Melhor ponto: {ponto_final}")

print(f"Valor teórico global: 0.0 (em x = 420.9687)")

# Gráfico 1: Curva de convergência

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)

plt.plot(melhor_fitness_hist, 'b-', linewidth=2)

plt.title('Convergência da Programação Evolutiva')

plt.xlabel('Geração')

plt.ylabel('Melhor Fitness (Schwefel)')

plt.grid(True)

# Gráfico 2: Distribuição final dos parâmetros (violin plot)

plt.subplot(1, 2, 2)

# Mostrar apenas as 5 dimensões

partes = plt.violinplot(populacao.T, showmeans=True, showmedians=True)

for pc in partes['bodies']:

pc.set_facecolor('skyblue')

pc.set_alpha(0.6)

plt.axhline(y=420.9687, color='red', linestyle='--', label='Ótimo teórico')

plt.title('Distribuição Final dos Parâmetros')

plt.xlabel('Dimensão')

plt.ylabel('Valor de xᵢ')

plt.xticks(range(1, dim+1))

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

Este código implementa a PE clássica com mutação auto-adaptativa. A curva de convergência mostra a redução do erro ao longo do tempo. O gráfico de violino revela a dispersão dos parâmetros na última geração. Observa-se que a maioria dos indivíduos se aproxima do ótimo teórico. A ausência de crossover é compensada pela diversidade da mutação. Para iniciantes, este exemplo demonstra a eficácia da PE pura. A programação evolutiva é, portanto, uma alternativa simples e poderosa.