Parçacık Sürüsü Optimizasyonu (Particle Swarm Optimization - PSO), bir sürü tabanlı, hesaplamalı yöntemdir ve küresel optimizasyon problemlarının çözümünde sıklıkla kullanılır. PSO, ilk olarak 1995 yılında James Kennedy (sosyal psikolog) ve Russel Eberhart (elektrik mühendisi) tarafından kuş sürülerinin ve balık sürülerinin davranışlarını taklit ederek geliştirilmiştir.

PSO, bir çözüm arama alanını keşfeden bir "sürü" veya bir grup "parçacık" ile çalışır. Her parçacık bir çözümü temsil eder ve parçacığın konumu çözümün kalitesini belirler.

Her bir parçacık, çözüm alanında hareket ederken iki ana kavramı dikkate alır:

1. Kişisel En İyi Pozisyon (pbest): Bu, parçacığın bugüne kadar bulduğu en iyi çözümdür.
2. Global En İyi Pozisyon (gbest): Bu, tüm sürü tarafından bugüne kadar bulunan en iyi çözümdür.

Her iterasyonda, parçacıklar kişisel en iyi pozisyonlarına ve global en iyi pozisyonlara doğru hızlarını güncellerler. Bu, parçacıkların kişisel deneyimlerinden ve diğer parçacıklardan öğrenmelerini sağlar, böylece çözüm alanındaki en iyi alanlara doğru hareket ederler.

Matematiksel olarak, PSO'nun güncelleme kuralları genellikle şu şekildedir:

1. `v = w * v + c1 * rand() * (pbest - pos) + c2 * rand() * (gbest - pos)`
2. `pos = pos + v`

Burada `v` parçacığın hızı, `pos` parçacığın pozisyonu, `w` atalet faktörü, `c1` ve `c2` hızlandırma sabitleri (bireysel ve sosyal öğrenme için) ve `rand()` rastgele bir sayıdır.

PSO'nun en büyük avantajlarından biri, algoritmanın karmaşıklığı ve anlaşılırlığı arasındaki dengedir. PSO, çok az parametre gerektirir ve genellikle genetik algoritmalardan daha hızlıdır. Ayrıca, PSO'nun yüksek boyutlu ve karmaşık arama alanlarını keşfetme yeteneği, çok çeşitli optimizasyon problemlarında etkili olmasını sağlar. Bununla birlikte, PSO yerel optimumlara hapsolma eğiliminde olabilir ve bu, bazı durumlarda algoritmanın genel performansını etkileyebilir.

PSO algoritmasının basit bir sürümünü aşağıda görebilirsiniz. Bu örnekte, parçacıkların konumlarını ve hızlarını güncellemek için kullanılan formülleri kullanacağız.

import numpy as np

# Parametreler
n_particles = 100
n_iterations = 1000
dim = 2
bounds = np.array([[-10, 10], [-10, 10]])
w = 0.7
c1 = 1.49
c2 = 1.49

# Başlangıç pozisyonları ve hızları
positions = np.random.uniform(bounds[:, 0], bounds[:, 1], (n_particles, dim))
velocities = np.random.uniform(-1, 1, (n_particles, dim))

# Başlangıç pbest ve gbest
pbest_positions = positions.copy()
pbest_scores = np.full(n_particles, np.inf)
gbest_position = None
gbest_score = np.inf

# Optimizasyon fonksiyonu (örneğin, sphere function)
def function(x):
    return np.sum(x**2)

# Optimizasyon döngüsü
for i in range(n_iterations):
    # Her parçacık için...
    for j in range(n_particles):
        # ...fitness değerlendirme
        score = function(positions[j])
        
        # ...pbest güncelleme
        if score < pbest_scores[j]:
            pbest_scores[j] = score
            pbest_positions[j] = positions[j]
            
        # ...gbest güncelleme
        if score < gbest_score:
            gbest_score = score
            gbest_position = positions[j]

    # Hız ve pozisyon güncellemeleri
    r1, r2 = np.random.rand(dim), np.random.rand(dim)
    cognitive = c1 * r1 * (pbest_positions - positions)
    social = c2 * r2 * (gbest_position - positions)
    velocities = w * velocities + cognitive + social
    positions = positions + velocities

print(f"En iyi pozisyon: {gbest_position}, En iyi skor: {gbest_score}")

Bu kod, bir "sphere" fonksiyonu (fonksiyon(x) = x[0]**2 + x[1]**2 + ... + x[d]**2) üzerinde çalışır ve bu fonksiyonun minimumunu arar, bu da (0, 0, ..., 0) 'da bulunur. Bu bir basit örnektir ve gerçek hayatta karşılaşılan problemlar genellikle daha karmaşık olacaktır.

PSO'nun genellikle pratikte daha iyi sonuçlar vermek için bir dizi parametresinin ayarlanması gerektiğini unutmayın: parçacık sayısı, iterasyon sayısı, atalet faktörü w ve hızlandırma sabitleri c1 ve c2. Bu parametrelerin seçimi, çalışılan probleme bağlıdır.

Bu, algoritmanın çözümünün neredeyse tam olarak (0,0) olduğunu ve bu çözümdeki fonksiyon değerinin çok düşük (neredeyse 0) olduğunu gösterir.

Unutmayın, bu örnekte optimize etmeye çalıştığımız işlev bir "sphere" işlevidir ve en düşük değeri 0'dır. Bu yüzden, algoritmanın neredeyse 0 değeri bulmuş olması, onun doğru bir şekilde çalıştığını ve optimal çözümü bulduğunu gösterir.

Elbette, bu basit bir örnektir ve PSO'yu daha karmaşık fonksiyonlara veya problemlara uyguladığınızda, en iyi pozisyon ve skor farklı olacaktır ve çıktıyı yorumlamak problem bağlamına dayalı olacaktır. Ayrıca, PSO'nun stokastik bir algoritma olduğunu, yani her çalıştırmada farklı sonuçlar verebileceğini unutmayın. Bu yüzden genellikle algoritmayı birkaç kez çalıştırmak ve sonuçların ortalamasını almak iyi bir uygulamadır.