Yapay Bağışıklık Sistemi (AIS): Python Örnekleriyle Rehber

Daha önce hiç karşılaşmadığı tehditleri tanıyıp etkisiz hâle getirirken, geçmiş istilacıları hatırlayıp onlara karşı daha verimli savunma yapabilen bir sistem hayal edin. Bağışıklık sisteminiz bunu her gün yapıyor. 

Şimdi de aynı zekâ düzeyini karmaşık bilişim problemlerini çözmeye uyguladığınızı düşünün. Yapay bağışıklık sistemleri (AIS) ile tam da bunu yapabiliriz.

Yapay Bağışıklık Sistemleri Nedir?

Yapay bağışıklık sistemleri, insan bağışıklık sisteminin vücudu zarardan koruma yeteneğinden esinlenen güçlü hesaplamalı modellerdir.

İnsan bağışıklık sistemi

Bağışıklık sistemi, bakteri, virüs ve mantar gibi tehditleri tanıyıp etkisizleştirmek üzere tasarlanmış savunma mekanizmamızdır. Bunu antikorlar, b-hücreleri ve t-hücreleri gibi birkaç kilit oyuncu aracılığıyla yapar.

Antikorlar bağışıklık sisteminin tanımlama birimleri gibi hareket eder. Bu özel proteinler, antijen adı verilen belirli yabancı maddeleri tanır ve onlara bağlanarak onları tehdit olarak işaretler. Her antikor özeldir; kilit ve anahtar gibi belirli bir antijene uyacak şekilde tasarlanmıştır.

B-hücreleri antikor üreten fabrikalardır. Ayrıca bellek hücrelerinin oluşturulmasında da rol alırlar. Bunlar, daha önce karşılaşılan antijenlere karşı vücudun daha hızlı yanıt vermesine, hangi antikorların işe yaradığını hatırlayarak yardımcı olur.

T-hücreleri bağışıklık sisteminin icracılarıdır. Antikorlar tarafından enfekte veya tehlikeli olarak işaretlenen hücreleri tespit eder ve yok eder, tehdidin hızla etkisizleştirilmesini sağlar.

Bağışıklık sisteminin en dikkat çekici özelliklerinden biri, zaman içinde yeni antikorlar geliştirme ve iyileştirme yeteneğidir. Yeni bir patojenle karşılaşıldığında, bağışıklık sistemi yalnızca bir kez yanıt vermez. Yaklaşımını sürekli olarak rafine eder ve tehditle başa çıkmak için daha güçlü ve daha etkili antikorlar üretir.

Bu biyolojik kavramlar AIS’e nasıl çevrilir

Yapay bağışıklık sistemleri (AIS), bu biyolojik ilkelerin algoritmalara uygulanmış hâlidir. AIS, problem çözmede bağışıklık sisteminin işlevlerini taklit eder.

AIS’te antijenler, ele alınması gereken sorunları veya zorlukları temsil eder. Bunlar, verilerde anomalileri tespit etmekten bir çözümü optimize etmeye kadar her şey olabilir.

AIS’teki antikorlar, bu sorunlara yönelik aday çözümlerdir. Nasıl ki biyolojik antikorlar belirli antijenleri tanıyorsa, AIS de belirli zorluklara uyarlanmış potansiyel çözümler geliştirir.

AIS’te B-hücresi süreci, biyolojik sistemlerin çeşitlilik ve bellek üretme biçimini yansıtır. AIS algoritmaları çeşitli aday çözümler kullanır ve bunları zamanla rafine eder. Geçmiş problem karşılaşmalarından öğrenerek gelecekteki performansı artırırlar.

Yapay bağışıklık sistemlerinin T-hücrelerine doğrudan bir karşılığı yoktur; ancak benzer bir rol üstlenen değerlendirme mekanizmalarını içerirler. Bu süreçler, etkisiz çözümleri eler ve daha iyi performans gösterenleri ince ayarlarla geliştirir.

AIS, çözümlerin kalitesini sürekli iyileştirmek için mutasyon ve seçilim gibi evrimsel ilkeleri kullanır.

Yapay Bağışıklık Sistemlerinde Temel Kavramlar

Yapay bağışıklık sistemleri, antikor-antijen etkileşimi, klonal seçim, negatif seçim ve bağışıklık ağ teorisi gibi temel kavramları içerir. 

Antikor-antijen etkileşimi

Yapay bağışıklık sistemlerinin ayrılmaz bir parçası, antikor-antijen etkileşimi kavramıdır. Bu süreç, bağışıklık sistemimizin tehditlere nasıl yanıt verdiğinden doğrudan esinlenir. Antikorları bir probleme yönelik potansiyel çözümler, antijenleri ise bizzat problemler veya zorluklar olarak düşünün.

Biyolojik dünyada antikorlar, antijenlere tutunup onları etkisiz hâle getiren proteinlerdir. AIS’te bir antikor, hesaplamalı bir probleme aday çözümü temsil ederken antijen, çözülmesi gereken problemi temsil eder.

AIS algoritması, ilgili antijenleri etkili biçimde tanıyıp etkisizleştirmek için bu antikorlardan oluşan bir popülasyonu evrimleştirir. Zamanla algoritma bu antikorları incelikle ayarlar ve en etkili çözümlere odaklanır.

Klonal seçim algoritması (CSA)

Klonal seçim algoritması (CSA), bağışıklık sistemimizdeki bir başka kritik süreçten ilham alır. Vücut bir antijeni tespit ettiğinde rastgele bağışıklık hücrelerini devreye sokmaz; istilacıyı özel olarak tanıyabilenleri seçer. Seçilen bu hücreler, etkili bir savunma oluşturmak için büyük sayılarda klonlanır.

Bu klonlar mutasyonlara uğrayarak bağışıklık yanıtının çeşitliliğini artıran küçük varyasyonlar kazanır. Bu, patojen evrim geçirse bile bağışıklık sisteminin uyum sağlayıp etkili şekilde yanıt vermesini sağlar.

Benzer şekilde, klonal seçim algoritması da en umut verici çözümleri seçer ve bunların birden çok kopyasını veya "klonlarını" oluşturur.

Bu klonlar daha sonra mutasyona tabi tutulur ve çeşitli potansiyel çözümler havuzu oluşturulur. En iyi performans gösteren klonlar tutulur ve süreç tekrarlanarak çözümlerin kalitesi kademeli olarak iyileştirilir. Bu algoritma, birçok olasılık arasından en verimli çözümü bulmanın amaçlandığı optimizasyon görevlerinde özellikle güçlüdür.

CSA, optimizasyon problemlerini çözmek için sıklıkla kullanılır. Örneğin havacılıkta, aerodinamik özellikleri çoklu iterasyonlarla iyileştirerek uçak kanatları gibi verimli yapılar tasarlamaya yardımcı olabilir.

Tıbbi görüntülemede CSA, görüntü netliğini artırabilir veya gürültülü ortamlarda düzensiz örüntüleri tespit edebilir; bu da onu MRI taramaları veya tümör tespiti için faydalı kılar.

Negatif seçim algoritması (NSA)

İnsan bağışıklık sistemi, vücudun kendi hücreleriyle yabancı istilacıları ayırt etmelidir. Negatif seçim algoritması (NSA) burada devreye girer. Vücudun kendi hücrelerine aşırı güçlü tepki veren bağışıklık hücreleri elenir. Bu, bağışıklık sisteminin yanlışlıkla kendine saldırmasını (otoimmün hastalık) engellemeye yardımcı olur.

NSA, verilerde anormallikleri veya aykırı değerleri tanımlamak için bu süreci taklit eder. Algoritma, verilerdeki normal örüntüleri tanıyacak şekilde tasarlanmış "dedektör" adı verilen bir dizi model üretir. Normal verilerle çok yakından eşleşen dedektörler elenir ve yalnızca tipik örüntülerle eşleşmeyenler kalır. Bu kalan dedektörler yeni verileri izlemek için kullanılır.

Bu atipik dedektörler yeni bir veri noktasını işaretlerse, onu bir anomali olarak belirtir. Bu, bağışıklık sisteminin yabancı istilacıları tespit etmesine benzer. Bu yöntem, siber güvenlik gibi alanlarda, olağandışı örüntülerin tespiti potansiyel tehditleri belirlemenin anahtarı olduğundan son derece etkilidir.

NSA, ağ trafiğini izleyen ve normal örüntüleri olası tehditlerin örüntüleriyle karşılaştırarak kötü niyetli etkinlikleri belirleyen sızma tespit sistemleri için uygundur.

NSA, enerji santralleri gibi karmaşık sistemlerdeki mekanik veya operasyonel arızaları tespit etmek için de uygulanabilir.

Bağışıklık ağ teorisi (INT)

Bağışıklık ağ teorisi (INT), sadece antikorlar ve antijenler arasındaki etkileşimi değil, antikorların kendi aralarındaki etkileşimleri de modelleyerek AIS kavramını genişletir.

Biyolojik bağışıklık sisteminde antikorlar tek başına çalışmaz. Birbirleriyle iletişim kurar ve birbirlerini etkilerler; daha sağlam ve uyarlanabilir dinamik bir yanıt ağı oluştururlar. Bu ağ yapılı etkileşim, bağışıklık sisteminin dengeyi korumasına yardımcı olur; böylece çok çeşitli tehditlere etkili şekilde yanıt verebilir, tek bir tehdide aşırı tepki vermekten kaçınır.

INT, farklı çözümler arasındaki karmaşık etkileşimleri ve bağımlılıkları modellemek için kullanılır. Bu, algoritmanın daha geniş bir olası yanıt yelpazesini dikkate almasını sağlayarak daha sofistike problem çözme stratejilerine yol açar.

Antikorların birbirlerini nasıl etkilediğini simüle ederek AIS, aynı anda bir çözüme giden birden fazla yolu keşfedebilir; bu da karmaşık ve dinamik ortamlarda en iyi çözümleri bulma yeteneğini artırır. Bu teori, en gelişmiş AIS algoritmalarının bir kısmının temelini oluşturur ve karmaşık hesaplamalı zorlukların üstesinden gelmek için güçlü bir araçtır.

Bağışıklık ağ teorisi, robot sürülerinin kontrolüne uygulanabilir. Robotlar arasındaki etkileşimler, antikor etkileşimlerini taklit eder; arama-kurtarma görevleri gibi işlerde koordineli davranış ve problem çözmeyi mümkün kılar.

Finansta, bağışıklık ağı modelleri çeşitli ekonomik göstergeler arasındaki etkileşimleri incelemek için kullanılabilir; bu da piyasa trendlerinin tahmin edilmesini veya finansal anomalilerin tespitini sağlar.

Yapay Bağışıklık Sistemlerinin Python ile Uygulanması

Python, geniş kütüphaneleri ve kullanım kolaylığı nedeniyle yapay bağışıklık sistemleri oluştururken sıklıkla tercih edilen dildir.

Klonal seçim algoritması uygulaması

Klonal seçim algoritması, bir tehdidi başarıyla tanıyan bağışıklık hücrelerinin klonlanıp mutasyona uğratılarak bağışıklık yanıtının iyileştirildiği biyolojik süreçten ilham alır. AIS’te bu “bağışıklık hücreleri” bir probleme yönelik aday çözümlerdir ve amaç, en iyi çözümü bulmak için bu çözümleri evrimleştirmektir.

İşte Python’da CSA’nın basit bir sürümünü nasıl uygulayabileceğiniz:

1. Popülasyonu başlatın: Rastgele çözümlerden oluşan bir popülasyon oluşturarak başlayın. Bir optimizasyon problemi üzerinde çalışıyorsanız, bu çözümler arama uzayı içinde rastgele noktalar olabilir. Her çözüm, bağışıklık sistemindeki bir antikora benzer.
2. Uygunluğu değerlendirin: Daha sonra her çözümün uygunluğunu değerlendirin. Uygunluk, bir çözümün problemi ne kadar iyi çözdüğünün bir ölçüsüdür. Biyolojik terimlerle bu, bir antikorun bir antijeni ne kadar iyi etkisizleştirdiğine benzer. Kullanacağınız uygunluk fonksiyonu, çözdüğünüz spesifik probleme bağlı olacaktır.
3. En iyi çözümleri seçin: Uygunluklarına göre klonlama için en iyi çözümleri seçin. Bu seçim süreci, bağışıklık sisteminin bir patojenle savaşmak için en etkili antikorları seçmesine benzer.
4. Klonlayın ve mutasyona uğratın: Seçilen çözümlerin birden çok kopyasını, yani klonlarını oluşturun. Ardından bu klonların değerlerini biraz değiştirerek mutasyonlar uygulayın. Bu adım, popülasyona çeşitlilik kazandırdığı ve algoritmanın çözüm uzayının farklı bölgelerini keşfetmesini sağladığı için önemlidir.
5. Değiştirin ve yineleyin: Popülasyondaki en kötü performans gösteren çözümleri yeni mutasyona uğramış klonlarla değiştirin. Belirli sayıda nesil boyunca veya çözümler en iyi ya da en iyiye yakın bir değerde yakınsayana kadar süreci tekrarlayın.

CSA kullanarak bir fonksiyon optimizasyon problemi çözelim. İyi bilinen bir karşılaştırma fonksiyonu olan Rastrigin fonksiyonunu optimize edeceğiz. Bu fonksiyon, birçok yerel minimuma sahip olduğu için optimizasyon algoritmalarını test etmekte kullanılabilir.

Aşağıdaki kodda, fonksiyon için küresel minimumu bulmak üzere bir CSA kullanıyoruz:

import numpy as np
import matplotlib.pyplot as plt

# Define the Rastrigin function
def rastrigin(X):
    n = len(X)
    return 10 * n + np.sum(X**2 - 10 * np.cos(2 * np.pi * X))

# Generate the initial population of potential solutions
def generate_initial_population(pop_size, solution_size):
    return np.random.uniform(-5.12, 5.12, size=(pop_size, solution_size))  # Initialize within the search space of Rastrigin

# Evaluate the fitness of each individual in the population (lower is better)
def evaluate_population(population):
    return np.array([rastrigin(individual) for individual in population])

# Select the best candidates from the population based on their fitness
def select_best_candidates(population, fitness, num_candidates):
    indices = np.argsort(fitness)
    return population[indices[:num_candidates]], fitness[indices[:num_candidates]]

# Clone the best candidates multiple times
def clone_candidates(candidates, num_clones):
    return np.repeat(candidates, num_clones, axis=0)

# Introduce random mutations to the cloned candidates to explore new solutions
def mutate_clones(clones, mutation_rate):
    mutations = np.random.rand(*clones.shape) < mutation_rate
    clones[mutations] += np.random.uniform(-1, 1, np.sum(mutations))  # Mutate by adding a random value
    return clones

# Main function implementing the Clonal Selection Algorithm
def clonal_selection_algorithm(solution_size=2, pop_size=100, num_candidates=10, num_clones=10, mutation_rate=0.05, generations=100):
    population = generate_initial_population(pop_size, solution_size)

    best_fitness_per_generation = []  # Track the best fitness in each generation

    for generation in range(generations):
        fitness = evaluate_population(population)
        candidates, candidate_fitness = select_best_candidates(population, fitness, num_candidates)
        clones = clone_candidates(candidates, num_clones)
        mutated_clones = mutate_clones(clones, mutation_rate)
        clone_fitness = evaluate_population(mutated_clones)

        # Replace the worst individuals in the population with the new mutated clones
        population[:len(mutated_clones)] = mutated_clones
        fitness[:len(clone_fitness)] = clone_fitness

        # Track the best fitness of this generation
        best_fitness = np.min(fitness)
        best_fitness_per_generation.append(best_fitness)

        # Stop early if we've found a solution close to the global minimum
        if best_fitness < 1e-6:
            print(f"Optimal solution found in {generation + 1} generations.")
            break

    # Plot the fitness improvement over generations
    plt.figure(figsize=(10, 6))
    plt.plot(best_fitness_per_generation, marker='o', color='blue', label='Best Fitness per Generation')
    plt.xlabel('Generations')
    plt.ylabel('Fitness (Rastrigin Function Value)')
    plt.title('Fitness Improvement Over Generations')
    plt.grid(True)
    plt.show()

    # Return the best solution found (the one with the lowest fitness score)
    best_solution = population[np.argmin(fitness)]
    return best_solution

# Example Usage
best_solution = clonal_selection_algorithm(solution_size=2)  # Using 2D Rastrigin function
print("Best solution found:", best_solution)
print("Rastrigin function value at best solution:", rastrigin(best_solution))

# Plot the surface of the Rastrigin function with the best solution found
x = np.linspace(-5.12, 5.12, 200)
y = np.linspace(-5.12, 5.12, 200)
X, Y = np.meshgrid(x, y)
Z = 10 * 2 + (X**2 - 10 * np.cos(2 * np.pi * X)) + (Y**2 - 10 * np.cos(2 * np.pi * Y))

plt.figure(figsize=(8, 6))
plt.contourf(X, Y, Z, levels=50, cmap='viridis')
plt.colorbar(label='Function Value')
plt.scatter(best_solution[0], best_solution[1], c='red', s=100, label='Best Solution')
plt.title('Rastrigin Function Optimization with CSA')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.grid(True)
plt.show()Altyapı:

Yukarıdaki grafik, CSA’nın her nesilde Rastrigin fonksiyonu için daha iyi çözümler bulduğunu gösteriyor.

Bu grafikte Rastrigin fonksiyonu çizilerek çok sayıda yerel minimumu gösteriliyor. Ortadaki kırmızı nokta, CSA tarafından bulunan nihai en iyi çözümdür.

Negatif seçim algoritması uygulaması

NSA, anomali tespiti görevleri için özellikle kullanışlıdır. Bu algoritma, bağışıklık sisteminin vücudun kendi hücreleri ile yabancı istilacıları nasıl ayırt ettiğini simüle eder. Bir NSA’da, normal veri örüntüleriyle eşleşmeyen bir dedektör kümesi oluşturursunuz. Bu dedektörler daha sonra yeni verileri izlemek için kullanılır ve anormal görünen her şeyi işaretler.

İşte bir NSA’nın nasıl oluşturulacağına dair genel bir bakış:

1. Kendini veri kümesini oluşturun: Verinizde “kendi”yi neyin oluşturduğunu tanımlayarak başlayın. Bu, normal ve beklenen davranışların veya örüntülerin bulunduğu bir veri kümesi olabilir. Amaç, bu kendini verileriyle eşleşmeyen dedektörler oluşturmaktır.
2. Dedektörler oluşturun: Rastgele dedektörler üretin ve bunları kendini verileriyle karşılaştırın. Kendini verileriyle eşleşen her dedektör elenir. Geriye kalan dedektörler anomalileri izlemek üzere tutulur.
3. Yeni verileri izleyin: Yeni veriler geldiğinde bunları elde tutulan dedektörlerle karşılaştırın. Bir dedektör yeni veriyi "kendi-dışı" olarak tanırsa, veri anomali olarak işaretlenir.

Bunun nasıl çalıştığını kurgusal bir işlem setiyle görelim. Bu örnekte, iki küme etrafında yoğunlaşan normal işlemler ve özellik uzayına rastgele dağılmış sahtekâr işlemler üretiyoruz. Özellik uzayına yayılmış dolandırıcılık dedektörlerini kullanarak, bu dedektörlere yakınlıklarına göre anomalileri tanımlayan bir negatif seçim algoritması uygulayacağız.

import numpy as np
import matplotlib.pyplot as plt

# Generate a synthetic dataset
np.random.seed()

# Parameters for bimodal distribution
num_normal_points = 80  # total number of normal transactions
num_points_per_cluster = num_normal_points // 2  # number of points in each cluster

# Generate normal transactions for two clusters
cluster1_center = [2, 2]
cluster2_center = [8, 8]

# Generate points around the first cluster center
normal_cluster1 = np.random.normal(loc=cluster1_center, scale=0.5, size=(num_points_per_cluster, 2))

# Generate points around the second cluster center
normal_cluster2 = np.random.normal(loc=cluster2_center, scale=0.5, size=(num_points_per_cluster, 2))

# Combine clusters into one dataset
normal_transactions = np.vstack([normal_cluster1, normal_cluster2])

# Define random distribution for fraudulent transactions
num_fraud_points = 5  # number of fraudulent transactions
fraudulent_transactions = np.random.uniform(low=0, high=10, size=(num_fraud_points, 2))

# Combine into one dataset
data = np.vstack([normal_transactions, fraudulent_transactions])
labels = np.array([0] * len(normal_transactions) + [1] * len(fraudulent_transactions))

# Function to generate detectors (random points) that don't match any of the normal data
def generate_detectors(normal_data, num_detectors, detector_size):
    detectors = []
    while len(detectors) < num_detectors:
        detector = np.random.rand(detector_size) * 10  # Scale to cover the data range
        if not any(np.allclose(detector, pattern, atol=0.5) for pattern in normal_data):
            detectors.append(detector)
    return np.array(detectors)

# Function to detect anomalies (points in the data that are close to any detector)
def detect_anomalies(detectors, data, threshold=0.5):
    anomalies = []
    for point in data:
        if any(np.linalg.norm(detector - point) < threshold for detector in detectors):
            anomalies.append(point)
    return anomalies

# Generate detectors that do not match the normal data
detectors = generate_detectors(normal_transactions, num_detectors=300, detector_size=2)

# Detect anomalies within the entire dataset using the detectors
anomalies = detect_anomalies(detectors, data)
print("Number of anomalies detected:", len(anomalies))

# Convert anomalies to a numpy array for visualization
anomalies = np.array(anomalies) if anomalies else np.array([])

# Define axis limits
x_min, x_max = 0, 10
y_min, y_max = -1, 11

# Visualize the dataset, detectors, and anomalies
plt.figure(figsize=(14, 6))

# Plot the normal transactions and fraudulent transactions
plt.subplot(1, 2, 1)
plt.scatter(normal_transactions[:, 0], normal_transactions[:, 1], color='red', marker='x', label='Normal Transactions')
plt.scatter(fraudulent_transactions[:, 0], fraudulent_transactions[:, 1], color='green', marker='o', label='Fraudulent Transactions')
plt.scatter(detectors[:, 0], detectors[:, 1], color='blue', marker='o', alpha=0.5, label='Detectors')
if len(anomalies) > 0:
    plt.scatter(anomalies[:, 0], anomalies[:, 1], color='yellow', marker='*', s=100, label='Detected Anomalies')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Fraud Detection Using Negative Selection Algorithm (NSA)')
plt.legend(loc='lower right')
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.grid(False)

# Create a grid of points to classify
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))
grid_points = np.c_[xx.ravel(), yy.ravel()]

# Classify grid points
decision = np.array([any(np.linalg.norm(detector - point) < 0.5 for detector in detectors) for point in grid_points])
decision = decision.reshape(xx.shape)

# Plot the decision boundary
plt.subplot(1, 2, 2)
plt.contourf(xx, yy, decision, cmap='coolwarm', alpha=0.3)
plt.scatter(normal_transactions[:, 0], normal_transactions[:, 1], color='red', marker='x', label='Normal Transactions')
plt.scatter(fraudulent_transactions[:, 0], fraudulent_transactions[:, 1], color='green', marker='o', label='Fraudulent Transactions')
plt.scatter(detectors[:, 0], detectors[:, 1], color='blue', marker='o', alpha=0.5, label='Detectors')
if len(anomalies) > 0:
    plt.scatter(anomalies[:, 0], anomalies[:, 1], color='yellow', marker='*', s=100, label='Detected Anomalies')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Decision Boundary Visualization')
plt.legend(loc='lower right')
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.grid(False)

# Show the plot
plt.show()Altyapı:

Burada, dolandırıcılık dedektörleri, normal işlemlerin görünmediği alanları kapsayacak şekilde özellik uzayına dağıtılmıştır. Bu dedektörlere yakın düşen sahtekâr işlemler tanımlanarak anomali olarak işaretlenir.

Bu grafik, dolandırıcılık dedektörlerinin oluşturduğu karar sınırını göstermektedir. Gölgeli bölgeler, dedektörlere yakınlığa göre anormal olarak sınıflandırılan alanları temsil eder; bu da sahtekâr işlemlerin normal işlemlerle ilişkili olarak nerede tespit edildiğini vurgular. Karar sınırını ayarlamak ve daha fazla ya da daha az alanı kapsamak için, anomali tespitinde kullanılan mesafe eşiğini değiştirerek anormal olarak sınıflandırılan bölgeleri genişletebilir veya daraltabilirsiniz.

Bağışıklık ağ teorisi uygulaması

INT, bağışıklık yanıtlarının yalnızca tekil antikorlara değil, aynı zamanda bunların iletişimine de dayandığı fikrinden esinlenir. Bu yaklaşım, antikorların iletişim kurarak genel bağışıklık yanıtını güçlendirdiği bir ağ olarak bağışıklık sistemini modellemektedir. Bu bağlamda her bir antikor (çözüm), en iyi çözümlerin aranmasını etkilemek ve rafine etmek üzere diğerleriyle etkileşime girebilir.

İşte Python’da INT’nin temel bir sürümünü nasıl uygulayabileceğiniz:

1. Popülasyonu başlatın: Önceki algoritmalara benzer şekilde rastgele çözümlerden oluşan bir başlangıç popülasyonu oluşturun. Her çözüm ağdaki bir antikoru temsil eder.
2. Uygunluğu değerlendirin: Her çözümün problemi ne kadar iyi çözdüğünü belirlemek için uygunluğunu değerlendirin. Bu adım, bir antikorun bir antijeni tanıyıp bağlanmada ne kadar iyi olduğuna benzer.
3. Bağlantılar kurun: Benzerlik veya yakınlığa dayalı olarak antikorların (çözümlerin) birbirine bağlandığı bir ağ oluşturun. Bağlantılar, antikorlar arasındaki iletişimi temsil eder ve birbirlerini etkilemelerine olanak tanır.
4. Çözümleri güncelleyin: Ağda yinelemeler yapın ve bağlı antikorlarla olan etkileşimlere dayanarak çözümleri güncelleyin. Bu süreç, bağışıklık yanıtını rafine etmek için antikorların birbirini nasıl etkilediğini simüle eder.
5. Değiştirin ve yineleyin: En kötü performans gösteren çözümleri ağdan gelen güncellenmiş çözümlerle değiştirin. Belirli sayıda yineleme boyunca veya çözümler en iyi ya da en iyiye yakın bir değerde yakınsayana kadar süreci sürdürün.

INT’yi, bir dizi ekonomik göstergeye dayanarak borsa trendlerini tahmin etmek için kullanalım. Her çözümün hisse senedi fiyatlarını tahmin etmeye yönelik gösterge kombinasyonlarını temsil ettiği kurgusal bir veri kümesi kullanacağız.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Generate synthetic data for illustration
np.random.seed(42)
n_samples = 100
n_features = 5
X = np.random.rand(n_samples, n_features)  # Random economic indicators
true_weights = np.array([0.5, -0.2, 0.3, 0.1, -0.1])
y = X @ true_weights + np.random.normal(0, 0.1, n_samples)  # Stock prices with noise

# Define the fitness function
def fitness_function(solution, X, y):
    model = LinearRegression()
    model.coef_ = solution
    predictions = X @ model.coef_
    return mean_squared_error(y, predictions)

# Generate the initial population of potential solutions
def generate_initial_population(pop_size, solution_size):
    return np.random.uniform(-1, 1, size=(pop_size, solution_size))

# Create the immune network
def create_immune_network(population, fitness, num_neighbors):
    network = []
    for i, individual in enumerate(population):
        distances = np.linalg.norm(population - individual, axis=1)
        neighbors = np.argsort(distances)[1:num_neighbors+1]  # Exclude self
        network.append(neighbors)
    return network

# Update the immune network
def update_network(network, population, fitness, mutation_rate):
    new_population = np.copy(population)
    for i, neighbors in enumerate(network):
        if np.random.rand() < mutation_rate:
            # Apply mutation with a smaller range
            mutation = np.random.uniform(-0.05, 0.05, population.shape[1])
            new_population[i] += mutation
    return new_population

# Main function implementing Immune Network Theory
def immune_network_theory(solution_size=n_features, pop_size=50, num_neighbors=5, mutation_rate=0.1, generations=50):
    population = generate_initial_population(pop_size, solution_size)
    best_fitness_per_generation = []  # Track the best fitness in each generation

    for generation in range(generations):
        fitness = np.array([fitness_function(ind, X, y) for ind in population])
        network = create_immune_network(population, fitness, num_neighbors)
        new_population = update_network(network, population, fitness, mutation_rate)

        # Evaluate the fitness of the new population
        fitness_new = np.array([fitness_function(ind, X, y) for ind in new_population])

        # Combine the old and new populations
        combined_population = np.vstack((population, new_population))
        combined_fitness = np.hstack((fitness, fitness_new))

        # Select the best individuals
        best_indices = np.argsort(combined_fitness)[:pop_size]
        population = combined_population[best_indices]
        fitness = combined_fitness[best_indices]

        # Track the best fitness of this generation
        best_fitness = np.min(fitness)
        best_fitness_per_generation.append(best_fitness)

        # Stop early if the fitness is good enough
        if best_fitness < 0.01:
            print(f"Optimal solution found in {generation + 1} generations.")
            break

    # Plot the fitness improvement over generations
    plt.figure(figsize=(10, 6))
    plt.plot(best_fitness_per_generation, marker='o', color='blue', label='Best Fitness per Generation')
    plt.xlabel('Generations')
    plt.ylabel('Mean Squared Error')
    plt.title('Fitness Improvement Over Generations')
    plt.grid(True)
    plt.show()

    # Return the best solution found
    best_solution = population[np.argmin(fitness)]
    return best_solution

# Example Usage
best_solution = immune_network_theory()
print("Best solution found (economic indicators weights):", best_solution)
print("Mean Squared Error at best solution:", fitness_function(best_solution, X, y))

# Plot the predicted vs. actual values using the best solution
model = LinearRegression()
model.coef_ = best_solution
predictions = X @ model.coef_

plt.figure(figsize=(8, 6))
plt.scatter(y, predictions, c='blue', label='Predicted vs Actual')
plt.plot([min(y), max(y)], [min(y), max(y)], 'r--', label='Ideal Fit')
plt.xlabel('Actual Values')
plt.ylabel('Predicted Values')
plt.title('Stock Price Prediction with INT')
plt.legend()
plt.grid(True)
plt.show()Altyapı:

Bu grafik, Ortalama Kare Hata’nın (MSE) zamanla azaldığını ve modelin tahminlerinin daha isabetli hâle geldiğini gösteriyor.

Bu saçılım grafiği, gerçek hisse fiyatlarını model tahminleriyle karşılaştırır. Kırmızı kesik çizgiye daha yakın noktalar daha isabetli tahminleri gösterir.

Yapay Bağışıklık Sistemleri Diğer Yapay Zekâ Teknikleriyle Nasıl Karşılaştırılır?

AIS, biyolojiden ilham alan pek çok makine öğrenmesi tekniğinden biridir.

Sinir ağları

Sinir ağları insan beyninden esinlenmiştir ve büyük veri kümelerinden öğrenmede üstündür. Görüntü tanıma ve doğal dil işleme gibi görevlerde kullanılırlar. Birbirine bağlı nöronların ağırlıklarını ayarlamak için çok büyük miktarda veriyle kapsamlı eğitime dayanırlar.

Buna karşılık, yapay bağışıklık sistemleri büyük veri kümelerine ihtiyaç duymadan uyarlanabilirlik ve merkeziyetsiz problem çözmeye odaklanır. AIS, bağışıklık sisteminin yeni zorlukları gerçek zamanlı tanıma ve tepki verme yeteneğini taklit eder; bu da hızlı uyumun kritik olduğu dinamik ortamlar için onları uygun kılar.

Genetik algoritmalar

Doğal evrimden esinlenen genetik algoritmalar, seçim, çaprazlama ve mutasyon yoluyla çözümler popülasyonunu evrimleştirerek karmaşık problemleri optimize etmede etkilidir. Bu süreç, CSA’ya benzer.

Ancak genetik algoritmalar, çözüm uzayını keşfetmek için genetik operatörlere dayanırken, CSA çözümleri bağışıklık yanıtlarını taklit ederek uyarlar ve beklenmedik yeni zorluklarla başa çıkmada esneklik sunar. CSA dahil AIS, hızlı uyum ve sürekli öğrenmenin kritik olduğu dinamik ortamlarda özellikle etkilidir.

Genetik algoritmalar hakkında daha fazlasını Genetic Algorithm: Complete Guide With Python Implementation başlıklı yazıda okuyabilirsiniz.

Sürü zekâsı algoritmaları

Sürü zekâsı algoritmaları, karıncalar ve arılar gibi sosyal organizmaların kolektif davranışlarından esinlenir. Merkeziyetsiz sistemleri ve basit ajan etkileşimlerini kullanarak karmaşık küresel optimizasyonu başarırlar.

Bu yaklaşım, ruhen INT’ye benzerdir. Her iki yaklaşım da optimizasyon problemlerini ele almak için sistem içinde çeşitlilik ve uyarlanabilirliği korumaya odaklanır. Sürü zekâsı ajan tabanlı etkileşimleri vurgularken, INT bağışıklık yanıtlarına benzer mekanizmaları kullanır ve dinamik problem çözme için tamamlayıcı yöntemler sunar.

Sürü zekâsı algoritmaları hakkında daha fazlasını Swarm Intelligence Algorithms: Three Python Implementations başlıklı yazıda okuyabilirsiniz.

Yapay Bağışıklık Sistemlerinde Güncel Araştırmalar

Yapay bağışıklık sistemleri, çeşitli alanlarda karmaşık problemleri çözme potansiyeli taşır. Araştırmacılar, bu sistemleri daha da kullanışlı hâle getirmek için geliştirmeye çalışıyor.

Araştırmacıların incelediği alanlardan biri, AIS’i diğer hesaplamalı zekâ teknikleriyle birleştiren hibrit modellerin nasıl oluşturulacağıdır. Umut, bu hibrit modellerin daha sağlam ve çok yönlü olmasıdır.

Bu hibrit yaklaşımlar, AIS’in uyarlanabilir yetenekleri ile sinir ağlarının güçlü öğrenme mekanizmaları gibi her yöntemin güçlü yanlarını kullanmayı amaçlar. Daha fazla bilgi için Artificial Immune Systems kaynağına göz atın.

Bir diğer aktif araştırma alanı, AIS’in yeni alanlara uygulanmasıdır. Geleneksel olarak siber güvenlik ve optimizasyonda kullanılsa da AIS artık robotik, biyoinformatik ve hatta finansal modelleme gibi alanlarda da araştırılmaktadır. AIS’in uyarlanabilir ve merkeziyetsiz doğası, bu dinamik ve çoğu zaman öngörülemeyen ortamlardaki sorunları çözmek için onu umut verici bir aday kılar. Daha fazla bilgi için Nature-Inspired Computing: Scope and Applications of Artificial Immune Systems Toward Analysis and Diagnosis of Complex Problems başlıklı yayını okumanızı öneririm.

AIS modelleri yalnızca gelişmiş hesaplamalı teknikler sunmakla kalmaz, gerçek bağışıklık sistemlerini anlamamıza da katkıda bulunabilir. Kanser ve otoimmün bozukluklar gibi hastalıklar için immünoterapi stratejilerini ilerletmektedirler. Daha fazlası için bu Cleveland Clinic ve IBM arasındaki iş birliğine göz atın.

Sonuç

Yapay bağışıklık sistemleri, insan bağışıklık sisteminden ilham alarak karmaşık problemleri çözmede benzersiz bir yaklaşım sunar. Örüntü tanıma, uyum sağlama ve bellek gibi biyolojik süreçleri taklit ederek, AIS siber güvenlikten optimizasyona kadar uzanan alanlarda esnek çözümler sağlar.