Evrimsel programlama (Evolutionary Programming, EP), genetik programlama ve genetik algoritmalar gibi evrimsel algoritma sınıfına ait bir optimizasyon yöntemidir. EP, 1960'ların sonlarında Lawrence J. Fogel tarafından geliştirildi ve başlangıçta önceden belirlenmiş bir sıra ve yöntemle gerçekleştirilen görevleri yerine getiren makinelerin (örn. otonom robotlar) davranışlarını evrimleştirmek için tasarlandı.

EP, genellikle sürekli optimizasyon problemlerinde kullanılır. Her birey, bir çözüm (davranış) ve bir veya daha fazla mutasyon parametresi içerir. Bu mutasyon parametreleri genellikle çözümün mutasyon özelliklerini belirler. Evrimsel programlamada genelde eşeysiz üreme kullanılır ve bu yöntem genetik çeşitliliği sürdürmek için mutasyonlara güvenir.

Evrimsel programlama ve genetik programlama arasındaki temel fark, evrimsel programlamanın genellikle ağaç yapıları yerine sabit boyutlu vektörlerle çalışmasıdır. Bu, genetik programlamadan farklı bir çözüm alanı ve farklı operatörler kullanılmasını gerektirir.

Python'da, evrimsel programlama genellikle DEAP (Distributed Evolutionary Algorithms in Python) gibi kütüphaneler kullanılarak uygulanır. Ancak, DEAP gibi kütüphaneler, ağaç tabanlı genetik programlama üzerinde yoğunlaşır ve evrimsel programlama için özelleştirilmiş özelliklere sahip olmayabilir. Bu yüzden, evrimsel programlamayı uygulamak için genellikle daha düşük seviye fonksiyonları kullanarak kendi algoritmanızı yazmanız gerekebilir.

Evrimsel programlamayı daha özel bir şekilde ele almak için, bir dizi gerçek sayı üzerinde çalışacak basit bir evrimsel programlama algoritması oluşturabiliriz. Burada, her birey bir dizi gerçek sayıyı temsil eder ve bu gerçek sayılar bir çözümü (örneğin bir optimizasyon problemi için bir çözüm) temsil eder.

Aşağıdaki kodda, DEAP kütüphanesi ile basit bir Evrimsel Programlama (EP) algoritması oluşturulmuştur. Bu algoritma, önceden belirlenmiş bir hedef vektöre mümkün olduğunca yakın bir vektör bulmayı amaçlar. Her birey bir çözüm vektörüdür ve bu vektörlerin genleri (bireysel bileşenler) normal dağılımlı rastgele sayılar kullanılarak mutate edilir.

import random
from deap import base, creator, tools

# Uygunluk fonksiyonu: hedef vektöre ne kadar yakın olduğumuzu ölçer
def fitness(individual, target):
    return sum((ind - target)**2 for ind, target in zip(individual, target)),

# Evrimsel programlama algoritması
def main():
    # Hedef vektör
    TARGET = [1, 2, 3, 4, 5]

    IND_SIZE = len(TARGET)

    # Uygunluk değeri minimize edilecek
    creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
    creator.create("Individual", list, fitness=creator.FitnessMin)

    toolbox = base.Toolbox()

    # Bireylerin oluşturulması için yardımcı işlevler
    toolbox.register("attr_float", random.random)
    toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, n=IND_SIZE)
    toolbox.register("population", tools.initRepeat, list, toolbox.individual)

    # Değerlendirme ve çaprazlama işlevleri
    toolbox.register("evaluate", fitness, target=TARGET)
    toolbox.register("mate", tools.cxTwoPoint)
    toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=0.2, indpb=0.2)
    toolbox.register("select", tools.selTournament, tournsize=3)

    # Popülasyon oluşturulması
    pop = toolbox.population(n=100)

    # Algoritmanın geri kalanı
    NGEN = 50
    for gen in range(NGEN):
        offspring = toolbox.select(pop, len(pop))
        offspring = list(map(toolbox.clone, offspring))

        for child1, child2 in zip(offspring[::2], offspring[1::2]):
            if random.random() < 0.5:
                toolbox.mate(child1, child2)
                del child1.fitness.values
                del child2.fitness.values

        for mutant in offspring:
            if random.random() < 0.2:
                toolbox.mutate(mutant)
                del mutant.fitness.values

        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        pop[:] = offspring

    return pop

if __name__ == "__main__":
    pop = main()
    print(tools.selBest(pop, 1))

Bu algoritma, hedef vektöre ne kadar yakın olduğuna göre bireylerin fitness'ını değerlendirir ve daha iyi çözümler oluşturmak için genetik çaprazlama ve mutasyon kullanır. Algoritma sonunda, popülasyondaki en iyi bireyi (yani hedefe en yakın vektörü) döndürür.

Bu kodun çıktısı, genetik operatörler ve fitness değerlendirmesi yoluyla bir dizi iterasyon sonucu hedefe en yakın vektör olacaktır. Çıktıyı yorumlamak genellikle çözümün ne kadar iyi olduğunu değerlendirmek ve potansiyel olarak algoritmanın parametrelerini ayarlamak için kullanılır. Evrimsel programlama gibi evrimsel algoritmalar genellikle belirli bir probleme göre ayarlanması gereken bir dizi parametre içerir.

Başka bir örnek ise;

Rastrigin fonksiyonunun minimumunu bulmak için bir Differential Evolution (DE) algoritması kullanılıyor:

from scipy.optimize import differential_evolution
import numpy as np

# Rastrigin fonksiyonu
def rastrigin(x):
    return 10*len(x) + sum([(xi**2 - 10 * np.cos(2 * np.pi * xi)) for xi in x])

bounds = [(0,10)]*10  # 10 boyutlu bir problem

result = differential_evolution(rastrigin, bounds)

print(result.x)
print(result.fun)

Bu kodu çalıştırdığınızda, Differential Evolution algoritması 10 boyutlu bir Rastrigin fonksiyonunun minimumunu bulmaya çalışır. Çıktı olarak, bulunan minimum noktanın koordinatlarını (result.x) ve bu noktadaki fonksiyonun değerini (result.fun) döndürür.

Daha karmaşık ve özelleştirilmiş Evrimsel Programlama uygulamaları için belirli bir uygulama alanına veya probleme sahip olmanız ve bu alandaki genetik operatörleri, çözüm temsili ve uygunluk fonksiyonu gibi öğeleri özelleştirmeniz gerekebilir.