Kültürel Algoritmalar (Cultural Algorithms), doğadan esinlenmiş bir tür evrimsel algoritmadır. Ancak, geleneksel evrimsel algoritmaların aksine, Kültürel Algoritmalar, popülasyonlar arasında bilgi paylaşımı için bir "kültür" kavramı getirir. Bu, algoritmanın genel performansını ve adaptasyon hızını artırmaya yardımcı olabilir.

Kültürel Algoritmalar, sosyal ve bireysel öğrenme süreçlerini birleştirir. Her birey (veya çözüm), doğal seçilim yoluyla evrimleşirken, aynı zamanda kültürler arası etkileşimlerle de bilgi alır ve paylaşır.

Bir Kültürel Algoritmanın temel adımları şunlardır:

1. Başlangıç Popülasyonunun Oluşturulması: Başlangıçta, genellikle rastgele oluşturulan bir popülasyon oluşturulur.

2. Bireylerin Değerlendirilmesi: Her bireyin (veya çözümün) kalitesi veya uygunluğu, bir uygunluk fonksiyonu kullanılarak değerlendirilir.

3. Belief Space'ın Güncellenmesi: Belief space (inanç alanı), toplumun tüm bilgisini saklar. Bu adımda, bireylerin bilgisi belief space'e eklenir veya güncellenir.

4. Prototip Seçimi: Belief space'deki bilgiye dayanarak, yeni bir birey oluşturmak için bir veya daha fazla prototip seçilir.

5. Yeni Bireyin Oluşturulması: Seçilen prototipler kullanılarak yeni bir birey oluşturulur. Bu genellikle, prototiplerin özelliklerini birleştirerek ve/veya mutasyon uygulayarak gerçekleştirilir.

6. Yeni Bireyin Değerlendirilmesi ve Kabulü: Yeni bireyin uygunluğu değerlendirilir. Eğer yeterince iyiysen, popülasyona eklenir.

Bu adımlar, bir durdurma kriteri (genellikle belirli bir sayıda iterasyon veya belirli bir uygunluk seviyesine ulaşılması) karşılanana kadar tekrarlanır.

Kültürel Algoritmalar, genellikle karmaşık optimizasyon problemlarının çözümünde kullanılır. Ancak, uygun seçim ve mutasyon işlemleri ve uygun belief space stratejilerinin seçimi, bu tür algoritmaların başarısı için kritiktir.

Kod:

import random

def create_individual(length):
    return [random.randint(0, 1) for _ in range(length)]

def fitness(individual):
    return sum(individual)

def selection(population, num):
    return max(random.sample(population, num), key=fitness)

def crossover(parent1, parent2):
    index = random.randint(1, len(parent1) - 2)
    child = parent1[:index] + parent2[index:]
    return child

def mutate(individual, mutation_rate):
    for i in range(len(individual)):
        if random.random() < mutation_rate:
            individual[i] = 1 - individual[i]  # Biti çevir
    return individual

def cultural_algorithm(pop_size, ind_length, max_gen, mutation_rate, tournament_size):
    population = [create_individual(ind_length) for _ in range(pop_size)]
    best = max(population, key=fitness)
    elite_list = [best]
    for _ in range(max_gen):
        new_population = []
        for _ in range(pop_size):
            parent1 = selection(population, tournament_size)
            parent2 = selection([ind for ind in population if ind != parent1], tournament_size)
            child = crossover(parent1, parent2)
            child = mutate(child, mutation_rate)
            new_population.append(child)
        population = new_population
        best = max(population, key=fitness)
        if fitness(best) > fitness(elite_list[-1]):
            elite_list.append(best)
    return elite_list

# Algoritmanın çalıştırılması
elite_list = cultural_algorithm(100, 10, 50, 0.01, 5)
for individual in elite_list:
    print(f"{individual}: {fitness(individual)}")

Bu kod, başlangıçta rastgele oluşturulan bir popülasyon ile başlar ve ardından bir dizi nesil boyunca çalışır. Her nesilde, turnuva seçimini kullanarak ebeveynler seçilir, çocuklar oluşturulur ve daha sonra bu çocuklar belirli bir mutasyon oranıyla çevrilir. Her nesilin sonunda, yeni popülasyonun en iyi bireyi seçilir ve eğer bu birey, önceki nesillerden daha iyi bir uygunluk değerine sahipse, elit listesine eklenir.

Bu kodun çıktısı, her nesil boyunca seçilen elit bireylerin bir listesidir. Bu, genelde çözümün nasıl evrimleştiğini gösterir. Bu örnekte, uygunluk işlevi, bit dizisindeki birlerin sayısı olduğu için, elit listesi genellikle zamanla daha fazla bir içeren bireyleri gösterir.

verilen kodun çıktısı, her nesil boyunca seçilen elit bireylerin bir listesidir. Bunu, bit dizisi şeklinde ve bu dizinin uygunluk skorunun yanında verir.

Örneğin, çıktı şu şekilde olabilir:

[1, 0, 0, 0, 0, 1, 1, 0, 1, 0]: 4
[1, 1, 0, 0, 1, 1, 1, 0, 1, 0]: 6
[1, 1, 1, 0, 1, 1, 1, 0, 1, 1]: 7
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]: 10

Bu çıktıyı yorumlarsak, her satırın, o neslin en elit bireyini ve onun uygunluk skorunu temsil ettiğini görüyoruz. Başlangıçta, en elit bireyin uygunluk skoru 4'tür, yani bit dizisinde dört tane 1 bulunmaktadır. Nesiller boyunca, bu uygunluk skoru artmaktadır. Bu, algoritmanın, bit dizisinde daha fazla 1 bulunan bireyleri favori olarak seçme eğiliminde olduğunu gösterir. Son nesle gelindiğinde, en elit bireyin uygunluk skoru 10 olmuştur. Bu, bit dizisindeki tüm bitlerin 1 olduğunu gösterir.

Bu, kültürel algoritmanın evrimsel sürecini gösteren bir örnektir. Her nesil boyunca, genel popülasyonun uygunluğu genellikle artar. Bu, çözümün zamanla iyileştiğini ve algoritmanın optimizasyon problemini çözme eğiliminde olduğunu gösterir.