Lineer Genetik Programlama (LGP), genetik programlama tekniğinin bir türüdür. LGP, programları bir dizi talimat olarak temsil eder. Bu, genellikle bir dizi operatör ve sabit veya değişken adreslerine sahiptir.

LGP'nin diğer GP tekniklerinden (örneğin, ağaç tabanlı GP) farkı, programların ağaç yapısı yerine düz, sıralı bir yapının (lineer) oluşturduğu genlerden oluşmasıdır. Bu genler, belli bir problemi çözmek için birbirleriyle etkileşime girebilir.

LGP genellikle büyük ölçekli problemler ve karmaşık problemler için kullanılır, çünkü bu problemlerde ağaç tabanlı genetik programlama genellikle karmaşık ve yönetilemez ağaçları oluşturur.

Python'da Lineer Genetik Programlama Örneği:

Python'da LGP'yi gerçekleştirmek için genellikle bir kütüphane kullanılır. DEAP (Distributed Evolutionary Algorithms in Python) gibi kütüphaneler, bu tür genetik algoritmaları ve genetik programlamayı gerçekleştirmek için çok kullanışlıdır. Aşağıda, LGP'yi gerçekleştiren bir örnek bir kod parçacığıdır:

import random
from deap import creator, base, tools, algorithms

# Fitness ve Individual sınıflarını tanımlayın
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

toolbox = base.Toolbox()

# İndividual ve population fonksiyonlarını tanımlayın
toolbox.register("attr_bool", random.randint, 0, 1)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=100)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

def evalOneMax(individual):
    return sum(individual),

# Crossover, mutation ve selection fonksiyonlarını tanımlayın
toolbox.register("evaluate", evalOneMax)
toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
toolbox.register("select", tools.selTournament, tournsize=3)

def main():
    pop = toolbox.population(n=300)
    hof = tools.HallOfFame(1)
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", numpy.mean)
    stats.register("std", numpy.std)
    stats.register("min", numpy.min)
    stats.register("max", numpy.max)

    pop, logbook = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=40, stats=stats, halloffame=hof, verbose=True)

    return pop, logbook, hof

if __name__ == "__main__":
    main()

Bu örnekte, amaç maksimum fitness değerine sahip olan bireyleri bulmaktır. Bu durumda fitness, bireydeki 1'lerin toplamıdır. Bireyler rastgele bitlerden (0 veya 1) oluşur ve başlangıç popülasyonu 300 bireyden oluşur. Algoritma 40 nesil boyunca çalışır ve her nesilde çaprazlama ve mutasyon uygulanır. Fitness değerlerinin istatistikleri her nesilde kaydedilir.

Lineer Genetik Programlama (LGP) kullanarak bir regresyon problemi çözelim. Bu problemde, bir hedef değişkeni (y) belirli bir girdi seti (X) kullanarak tahmin etmeye çalışacağız. Burada, DEAP kütüphanesi kullanacağız.

import operator
import math
import random

import numpy

from deap import algorithms
from deap import base
from deap import creator
from deap import tools
from deap import gp

# Girdi verisi oluşturuluyor
X = numpy.linspace(-10,10,1000)
Y = X**3 + 2*X**2 + 3*X + 4 + numpy.random.normal(0, 30, len(X))  # y = x^3 + 2x^2 + 3x + 4 + Gaussian noise

pset = gp.PrimitiveSet("MAIN", 1)
pset.addPrimitive(operator.add, 2)
pset.addPrimitive(operator.sub, 2)
pset.addPrimitive(operator.mul, 2)
pset.addPrimitive(operator.neg, 1)
pset.addPrimitive(math.cos, 1)
pset.addPrimitive(math.sin, 1)

creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin)

toolbox = base.Toolbox()
toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2)
toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("compile", gp.compile, pset=pset)

def evalSymbReg(individual):
    func = toolbox.compile(expr=individual)
    return math.sqrt(sum((func(x) - y)**2 for x,y in zip(X,Y)) / len(X)),

toolbox.register("evaluate", evalSymbReg)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("mate", gp.cxOnePoint)
toolbox.register("expr_mut", gp.genFull, min_=0, max_=2)
toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset)

def main():
    random.seed(318)

    pop = toolbox.population(n=300)
    hof = tools.HallOfFame(1)

    stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
    stats_size = tools.Statistics(len)
    mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size)
    mstats.register("avg", numpy.mean)
    mstats.register("std", numpy.std)
    mstats.register("min", numpy.min)
    mstats.register("max", numpy.max)

    pop, log = algorithms.eaSimple(pop, toolbox, 0.5, 0.1, 40, stats=mstats,
                                   halloffame=hof, verbose=True)
    return pop, log, hof

if __name__ == "__main__":
    main()

Bu kod, hedef fonksiyonunun bir kubik polinom olduğu bir sembolik regresyon problemi çözer. Genetik programlama, bu fonksiyonu yakınsamaya çalışır.

İlk olarak, X ve Y girdi ve çıktı veri setlerini oluştururuz. Ardından, genetik programlama için bir dizi operatör ve fonksiyon ekleyerek bir ilkel set oluştururuz. Sonra, genetik programlama bireylerinin fitness'ini ve yapısını tanımlarız.

evalSymbReg fonksiyonu, bir bireyin fitness'ini değerlendirmek için kullanılır. Bu, bireyin temsil ettiği fonksiyonun çıktısını gerçek Y değerleriyle karşılaştırarak gerçekleştirilir.

Son olarak, algoritmayı çalıştırırız ve her nesilin istatistiklerini toplarız. Bu, genetik programlamanın ilerlemesini takip etmek için kullanılır.

Yukarıdaki kod, genetik programlama kullanarak sembolik regresyon problemini çözer ve her iterasyon için belirli istatistikleri sağlar.

Algoritmanın başında, popülasyonu belirttiğimiz sayıda birey (örnekte 1000) ile başlatırız. Her birey, farklı genetik operatörler ve işlevler kullanılarak oluşturulmuş rastgele bir ifade ağacıdır. Bu ifade ağacı, genetik programlama ile yakınsamaya çalıştığımız hedef fonksiyonu temsil eder.

Algoritma her iterasyonda (genetik programlamada genellikle "nesil" olarak adlandırılır), seçilmiş bireylerin çaprazlandığı ve mutasyona uğradığı bir dizi genetik operasyon gerçekleştirir. Bu süreç, genel uygunluk seviyesini artırmak için popülasyonu zaman içinde evrimleştirir.

Her neslin sonunda, algoritma belirli istatistikleri çıktı olarak sağlar:

avg: Popülasyonun ortalama uygunluğu. Bu değerin zaman içinde düşmesi beklenir çünkü bu bir minimize etme problemi ve daha düşük uygunluk, daha iyi performans anlamına gelir.

std: Popülasyondaki uygunluk değerlerinin standart sapması. Bu, popülasyonun ne kadar çeşitli olduğunu gösterir. Çok yüksek bir standart sapma, popülasyondaki bireylerin büyük farklılıklar gösterdiğini gösterir, bu da genellikle daha iyi çözümlere ulaşmak için gereklidir.

min: Popülasyondaki en iyi (en düşük) uygunluk. Bu, şimdiye kadar bulunan en iyi çözümün performansını gösterir.

max: Popülasyondaki en kötü (en yüksek) uygunluk. Bu, popülasyondaki en kötü bireyin performansını gösterir.

Sonuç olarak, bu istatistikler genetik programlamanın performansını ve ilerlemesini değerlendirmek için kullanılır. Algoritmanın doğru çalıştığını ve zaman içinde daha iyi çözümler bulduğunu görmek için, ortalama ve minimum uygunluk değerlerinin düştüğünü görmeyi bekleriz.