Arı Algoritması, arıların yiyecek arama davranışlarından esinlenerek geliştirilmiş bir optimizasyon algoritmasıdır. Algoritma genelde global optimizasyon problemlerini çözmek için kullanılır. İşlem aşamaları ve kavramları genellikle arıların gerçek hayattaki davranışlarını taklit eder.

Arı algoritmasının çeşitli versiyonları vardır, ama en yaygın olanı üç tür 'arı' kullanır: işçi arılar, izleyici arılar ve keşifçi arılar.

1. İşçi Arılar: İşçi arılar mevcut çözüm bölgelerini araştırırlar, yani bir çözüm üzerindeki yerel aramalarını yaparlar. Bir işçi arının bulduğu çözümün kalitesi, çözüm çevresinde ne kadar çok zaman harcayacağını belirler.

2. İzleyici Arılar: İzleyici arılar, işçi arıların sunduğu çözümleri değerlendirirler. Bu çözümler, işçi arılar tarafından daha önce bulunmuş ve çözüm kalitesine bağlı olarak belirli bir olasılıkla seçilmiştir. İzleyici arılar bu çözümleri değerlendirir ve en iyi çözümleri belirler.

3. Keşifçi Arılar: Keşifçi arılar tamamen yeni çözüm bölgelerini araştırırlar. Bu, genellikle rastgele bir arama işlemi ile gerçekleştirilir.

Arı Algoritması genellikle aşağıdaki adımlarla gerçekleştirilir:

1. İlk çözüm kümesini oluştur. Çözüm kümesi genellikle rastgele seçilir.

2. İşçi arılar, mevcut çözümlerin yerel bölgelerinde arama yaparlar.

3. İzleyici arılar, işçi arıların bulduğu çözümleri değerlendirir ve en iyi çözümleri belirler.

4. Keşifçi arılar, çözüm uzayında yeni bölgeler keşfeder.

5. Adım 2'ye geri dön ve belirli bir durma kriterine kadar süreci tekrarla.

Bu algoritma, doğal davranışın basit modellerini kullanarak karmaşık optimizasyon problemlerini çözebilmektedir. Ancak, bu algoritmanın etkinliği ve verimliliği belirli bir durumda ne kadar iyi çalışacağı, problemin özelliklerine ve parametrelerin doğru şekilde ayarlanmasına bağlıdır.

Bu örnekte, amacımız bir hedef fonksiyonunu eniyilemektir. Fonksiyonumuz f(x) = x^2, x'in -10 ile 10 arasında olduğu bir aralığı kapsayacak şekilde belirlenmiştir. Bu basit örnek, algoritmanın kavramlarını anlamayı kolaylaştırır.

import numpy as np

# Hedef fonksiyon
def f(x):
    return x**2

# İşçi arılar
def worker_bees(n, solutions, fitness):
    for i in range(n):
        # Yeni bir çözüm oluştur
        new_solution = solutions[i] + np.random.uniform(-1, 1)
        new_fitness = f(new_solution)
        # Eğer yeni çözüm daha iyi ise, mevcut çözümü güncelle
        if new_fitness < fitness[i]:
            solutions[i] = new_solution
            fitness[i] = new_fitness

# İzleyici arılar
def onlooker_bees(n, solutions, fitness):
    # Fitness değerlerine göre olasılıkları hesapla
    probabilities = fitness / np.sum(fitness)
    for i in range(n):
        # Olasılıklara göre bir çözüm seç
        j = np.random.choice(range(n), p=probabilities)
        # Yeni bir çözüm oluştur
        new_solution = solutions[j] + np.random.uniform(-1, 1)
        new_fitness = f(new_solution)
        # Eğer yeni çözüm daha iyi ise, mevcut çözümü güncelle
        if new_fitness < fitness[j]:
            solutions[j] = new_solution
            fitness[j] = new_fitness

# Keşifçi arılar
def scout_bees(n, solutions, fitness):
    for i in range(n):
        # Rastgele bir olasılık oluştur
        p = np.random.uniform()
        # Eğer p < 0.1 ise, rastgele bir yeni çözüm oluştur
        if p < 0.1:
            solutions[i] = np.random.uniform(-10, 10)
            fitness[i] = f(solutions[i])

# Arı Algoritması
def bee_algorithm(n, max_iter):
    # Başlangıç çözümlerini oluştur
    solutions = np.random.uniform(-10, 10, size=n)
    fitness = f(solutions)
    # İterasyonları gerçekleştir
    for iter in range(max_iter):
        worker_bees(n, solutions, fitness)
        onlooker_bees(n, solutions, fitness)
        scout_bees(n, solutions, fitness)
    # En iyi çözümü döndür
    best_solution = solutions[np.argmin(fitness)]
    return best_solution

# Test
best_solution = bee_algorithm(100, 1000)
print("En iyi çözüm: ", best_solution)

Bu kodda, her bir işçi arı rastgele bir yönde bir adım atar ve bu adım eğer çözümü iyileştirirse çözüm güncellenir. İzleyici arılar, mevcut çözümleri fitness değerlerine bağlı olarak seçer ve seçtikleri çözümün yakınında yeni bir çözüm oluşturur. Keşifçi arılar belirli bir olasılıkla (bu örnekte %10) tamamen rastgele yeni bir çözüm oluşturur.

Algoritma, belirli bir iterasyon sayısı boyunca çalıştırıldıktan sonra en iyi çözümü döndürür. Bu örnekte, en iyi çözüm f(x) = x^2 fonksiyonunu eniyileyen x = 0 olmalıdır. Bu algoritmanın performansı, işçi arılar, izleyici arılar ve keşifçi arıların sayısı ile iterasyon sayısına bağlıdır. Bu değerlerin ayarlanması, algoritmanın performansını önemli ölçüde etkiler.