Genetik programlama (Genetic Programming - GP), yapay zeka alanındaki evrimsel algoritma ailesinin bir parçası olan bir tekniktir. Bu teknik, problemlerin çözümünü otomatik olarak oluşturmayı ve geliştirmeyi amaçlar. Genetik programlamanın temel fikri, doğal evrim sürecini taklit etmektir - yani mutasyon, çaprazlama (rekombinasyon) ve doğal seçilim.

Genetik programlama, bir programın farklı versiyonlarını 'bireyler' olarak görür ve bu bireyler bir 'popülasyon' oluşturur. Her birey, belirli bir problemi çözmek için farklı bir yaklaşımı temsil eder.

Amaç:

Genetik programlama, genetik algoritmaların bir türüdür ve genellikle en iyi veya en uygun çözümü bulmayı amaçlar. Ancak, genetik programlama genetik algoritmalardan biraz farklıdır çünkü genetik programlama, genellikle bir program veya fonksiyon formunda en iyi çözümü bulmayı amaçlar.

Genetik programlamanın temel amacı, bir probleme en iyi çözümü sağlayacak bir bilgisayar programını 'evrimleştirmektir'. Yani, genetik programlama, bir probleme en iyi çözümü sağlayacak bir algoritmayı veya fonksiyonu 'evrimleştirmeyi' amaçlar.

Örneğin, bir hedef fonksiyonu en iyi şekilde tahmin eden bir matematiksel modeli bulmaya çalışabiliriz, veya belki de bir oyunu en iyi şekilde oynayan bir yapay zeka algoritması oluşturmaya çalışıyoruzdur. Bu durumlarda, genetik programlama, hedef fonksiyonunu en iyi şekilde yakalayan veya oyunu en iyi şekilde oynayan bir program oluşturmak için kullanılabilir.

Genetik programlama bu amacı doğrultusunda, doğal evrimin temel süreçlerini (seçilim, çaprazlama ve mutasyon) taklit eder. Başlangıçta, rastgele oluşturulmuş bir dizi program (bir 'popülasyon') oluşturulur. Daha sonra, her bir programın ne kadar iyi performans gösterdiğini belirlemek için bir 'uygunluk fonksiyonu' kullanılır. En uygun programlar, bir sonraki neslin ebeveynleri olarak seçilir ve bu ebeveynlerden yeni programlar (çocuklar) oluşturulur. Bu süreç, belirli bir kriter karşılanana kadar veya belirli bir sayıda nesil geçene kadar tekrarlanır.

Türleri:

Genetik programlamanın farklı tipleri veya çeşitleri vardır. En popüler olanları aşağıdaki gibidir:

1. Lineer Genetik Programlama (LGP): Bu tür genetik programlama, genellikle düzgün bir şekilde yapılandırılmış programları oluşturmak için kullanılır. LGP genellikle bir dizi talimat olarak programları temsil eder ve bu talimatlar bir dizi operatör ve sabit veya değişken adreslerine sahiptir.

2. Ağaç Tabanlı Genetik Programlama:Bu genetik programlamanın en yaygın biçimlerinden biridir. Bu türde, programlar genellikle işlev ağaçları olarak temsil edilir. Bu işlev ağaçları, farklı işlevler ve terminaller (değişkenler ve sabitler) kullanılarak oluşturulur.

3. Kartet Genetik Programlama (CGP): CGP, programları bir yönlü grafik olarak temsil eder. Her düğüm, bir işlevi temsil eder ve düğümler arasındaki bağlantılar veri akışını temsil eder. CGP, birçok uygulamada etkilidir ve özellikle donanım evrimi ve görüntü işleme gibi alanlarda kullanılır.

4. Genetik İşlemci Programlama (GEP): GEP, genetik algoritmalar ve genetik programlama arasında bir tür karışımdır. GEP, her biri genellikle bir ağacı temsil eden birden fazla geni içeren genetik dizileri kullanır. Bu genler daha sonra bir program oluşturmak için birleştirilir.

5. Türler Arası Genetik Programlama (SGP): SGP, farklı türlerin genetik kodlarını birleştirerek yeni bir tür oluşturmayı amaçlar. Bu, yeni ve yaratıcı çözümleri keşfetmek için genetik çeşitliliği teşvik eder.

Her genetik programlama türü, belirli bir problemi çözmek için daha uygun olabilir ve her birinin kendi avantajları ve dezavantajları vardır. Genellikle, hangi türün kullanılacağına karar vermek, çözülmeye çalışılan probleme, mevcut kaynaklara ve kişisel tercihlere bağlıdır.

Adımlar:

Function genetic_programming():
    1. Başlangıç popülasyonunu oluştur
    2. Her birey için uygunluk değerini hesapla
    3. Maksimum iterasyon sayısına veya başka bir durdurma kriterine ulaşana kadar:
        a. Seçim operatörünü kullanarak iki ebeveyni seç
        b. Çaprazlama operatörünü kullanarak ebeveynlerden çocuklar oluştur
        c. Mutasyon olasılığına bağlı olarak mutasyon operatörünü uygula
        d. Yeni çocukların uygunluk değerlerini hesapla
        e. Yeni çocukları popülasyona ekle
        f. Popülasyon boyutunu korumak için en düşük uygunluğa sahip bireyleri çıkar
    4. En iyi uygunluk değerine sahip bireyi döndür
End Function

GP'nin işleyişi büyük ölçüde genetik algoritmalara (GA'ler) benzer, ancak bir anahtar fark vardır:

- Genetik algoritmalar genellikle sabit uzunlukta bit dizilerini kullanırken, genetik programlama genellikle değişken uzunlukta ve değişken şekilli ağaç yapıları kullanır.

Genetik programlama süreci genellikle şu adımları içerir:

1. Başlangıç Popülasyonu: Rastgele oluşturulmuş bir dizi program oluşturulur. Bu popülasyon genellikle problemi çözemeyen programlardan oluşur.

2. Fitness Fonksiyonu: Her programın ne kadar iyi olduğunu belirleyen bir fitness fonksiyonu kullanılır. Bu genellikle, programın çözümünün problemi ne kadar iyi çözdüğünün bir ölçüsüdür.

3. Seçim: Fitness fonksiyonuna dayanarak, bazı programlar yeni bir popülasyon oluşturmak için seçilir. Yüksek fitness değerine sahip programlar genellikle daha fazla çocuğa sahip olur.

4. Çaprazlama ve Mutasyon: Seçilen programlar, çaprazlama (iki programın bir parçasının değiştirildiği) ve mutasyon (programın rastgele bir parçasının değiştirildiği) işlemlerine tabi tutulur.

5. İterasyon: Bu süreç, belirli bir durdurma koşulu karşılanana kadar (örneğin, bir maksimum iterasyon sayısı veya belirli bir fitness seviyesi) tekrarlanır.

Örnek Kod:

Bu örnekte, bir bit listesi oluştururuz ve bu listeyi en iyi hale getirmek (yani tüm bitlerin 1 olmasını sağlamak) için bir genetik algoritma kullanırız.

import random

# Uygunluk Fonksiyonu: Bireyin ne kadar iyi olduğunu belirler. Bu durumda, bireyin tüm bitlerinin toplamını alırız.
def uygunluk(birey):
    return sum(birey)

# Birey Oluşturma: Rastgele bitlerden oluşan bir birey oluştururuz.
def birey_olustur(uzunluk):
    return [random.randint(0, 1) for _ in range(uzunluk)]

# Popülasyon Oluşturma: Rastgele bireylerden oluşan bir popülasyon oluştururuz.
def popülasyon_olustur(boyut, uzunluk):
    return [birey_olustur(uzunluk) for _ in range(boyut)]

# Seçim: Popülasyondan rastgele bir birey seçeriz.
def secim(popülasyon):
    return random.choice(popülasyon)

# Çaprazlama: İki ebeveyn bireyden iki çocuk birey oluşturur.
def caprazlama(ebeveyn1, ebeveyn2):
    caprazlama_noktasi = random.randint(0, len(ebeveyn1))
    cocuk1 = ebeveyn1[:caprazlama_noktasi] + ebeveyn2[caprazlama_noktasi:]
    cocuk2 = ebeveyn2[:caprazlama_noktasi] + ebeveyn1[caprazlama_noktasi:]
    return cocuk1, cocuk2

# Mutasyon: Bir bireyin rastgele bir bitini değiştiririz.
def mutasyon(birey):
    mutasyon_noktasi = random.randint(0, len(birey)-1)
    birey[mutasyon_noktasi] = 1 if birey[mutasyon_noktasi] == 0 else 0

# Örnek bir basit genetik algoritma
def basit_genetik_algoritma(popülasyon_boyutu, birey_uzunlugu, nesil_sayisi):
    popülasyon = popülasyon_olustur(popülasyon_boyutu, birey_uzunlugu)
    
    for _ in range(nesil_sayisi):
        popülasyon = sorted(popülasyon, key=uygunluk)
        yeni_popülasyon = popülasyon[:2]  # Elitizm: En iyi 2 bireyi koru

        while len(yeni_popülasyon) < popülasyon_boyutu:
            ebeveyn1 = secim(popülasyon)
            ebeveyn2 = secim(popülasyon)
            cocuk1, cocuk2 = caprazlama(ebeveyn1, ebeveyn2)
            mutasyon(cocuk1)
            mutasyon(cocuk2)
            yeni_popülasyon.extend([cocuk1, cocuk2])
        
        popülasyon = yeni_popülasyon
    return popülasyon

# Örnek çalıştırma
popülasyon = basit_genetik_algoritma(100, 10, 50)
print("Final popülasyon: ", popülasyon)

Bu kod, genetik algoritmanın basit bir versiyonunu gerçekleştirir. Öncelikle, rastgele bitlerden oluşan bir popülasyon oluşturulur. Daha sonra, belirtilen sayıda nesil için algoritma, seçim, çaprazlama ve mutasyon adımlarını uygular. Elitizm stratejisi ile her nesilde en iyi iki birey korunur. Kod, son nesilin popülasyonunu yazdırır.

kodun çıktısı hakkında daha fazla bilgi verebilirim.

Kavramlar:

Birey: Genetik algoritmalarda bir birey, bir çözümü temsil eder. Bu durumda, bir birey, 0 ve 1'lerden oluşan bir liste veya dizi olarak temsil edilir. Bireyin "uygunluğu", bu çözümün ne kadar iyi olduğunu belirler.

Popülasyon: Popülasyon, bireylerin bir topluluğudur. Her genetik algoritma, bir dizi çözüm olan bir popülasyonla başlar.

Seçim: Seçim süreci, bir sonraki nesilin ebeveynlerini belirler. Bu örnekte, seçim rastgele gerçekleştirilir, yani popülasyondaki her bireyin seçilme şansı eşittir.

Çaprazlama: Çaprazlama, iki ebeveyn bireyin bilgilerini birleştirerek yeni bireyler oluşturur. Bu, genetik çeşitliliği artırır ve algoritmanın yeni çözümler keşfetmesine yardımcı olur.

Mutasyon: Mutasyon, bireylerin rastgele bir kısmını değiştirir. Bu da çeşitliliği artırır ve algoritmanın yerel optimumlarda takılıp kalmamasına yardımcı olur.

Uygunluk Fonksiyonu: Uygunluk fonksiyonu, bir bireyin ne kadar iyi olduğunu belirler. Bu örnekte, uygunluk fonksiyonu bir bireyin tüm bitlerinin toplamını alır. Yani, tüm bitler 1 olduğunda en yüksek uygunluğa ulaşılır.

Elitizm: Bu örnekte elitizm kullanılmıştır, yani her nesilde en iyi iki birey korunur. Bu, algoritmanın en iyi çözümleri kaybetmemesini sağlar.

Çıktı:

Bu kodun çıktısı, genetik algoritmanın son neslinden oluşan bir popülasyondur. Her birey bir dizi bit olarak temsil edilir. Algoritma, her bir biti 1 yapmaya çalışır, bu yüzden ideal çıktı, tüm bitlerin 1 olduğu bireylerin bir listesi olacaktır. Bununla birlikte, algoritmanın tam olarak bu sonucu üretip üretmeyeceği, başlangıç popülasyonunun boyutuna, bireyin uzunluğuna, nesil sayısına ve rastgeleliğe bağlıdır.

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

Final popülasyon:  [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]...

Bu çıktı, genetik algoritmanın çoğu birey için tüm bitleri 1 yapmayı başardığını, ancak bazılarında tamamen başarılı olamadığını gösterir.

GP, karmaşık problemler için otomatik olarak programlar oluşturmayı ve bunları iyileştirmeyi amaçladığı için, simülasyonlarda, otomatik kod oluşturma, makine öğrenmesi ve yapay zeka araştırmalarında kullanılır.