Artificial Immune System (AIS): Panduan dengan Contoh Python

Bayangkan sebuah sistem yang dapat mengenali dan menetralkan ancaman yang belum pernah ditemuinya, sekaligus mengingat penyerang sebelumnya agar dapat menangkisnya dengan lebih efisien. Sistem kekebalan tubuh Anda melakukan ini setiap hari. 

Sekarang, bayangkan menerapkan tingkat kecerdasan yang sama untuk memecahkan masalah komputasi yang kompleks. Dengan artificial immune systems (AIS), kita bisa melakukan hal itu.

Apa itu Artificial Immune Systems?

Artificial immune systems adalah model komputasi yang kuat yang terinspirasi oleh kemampuan sistem kekebalan manusia untuk melindungi tubuh dari bahaya.

Sistem kekebalan manusia

Sistem kekebalan adalah mekanisme pertahanan tubuh kita, dirancang untuk mengenali dan menetralkan ancaman seperti bakteri, virus, dan jamur. Hal ini dilakukan melalui beberapa pemeran kunci: antibodi, sel B, dan sel T.

Antibodi bertindak sebagai unit identifikasi sistem kekebalan. Protein khusus ini mengenali dan menempel pada zat asing tertentu yang disebut antigen, menandainya sebagai ancaman. Setiap antibodi bersifat unik, dirancang untuk cocok dengan antigen tertentu, seperti kunci dan gembok.

Sel B adalah pabrik yang memproduksi antibodi. Mereka juga terlibat dalam pembentukan sel memori. Ini membantu tubuh merespons lebih cepat terhadap antigen yang pernah ditemui sebelumnya dengan mengingat antibodi mana yang berguna terakhir kali.

Sel T adalah penegak sistem kekebalan. Mereka mendeteksi dan menghancurkan sel yang ditandai oleh antibodi sebagai terinfeksi atau berbahaya, memastikan ancaman segera dinetralkan.

Salah satu fitur paling luar biasa dari sistem kekebalan adalah kemampuannya untuk berevolusi dan meningkatkan antibodi baru seiring waktu. Saat menghadapi patogen baru, sistem kekebalan tidak hanya merespons sekali. Ia terus menyempurnakan pendekatannya, menciptakan antibodi yang lebih kuat dan lebih efektif untuk menghadapi ancaman.

Bagaimana konsep biologis ini diterjemahkan ke AIS

Artificial immune systems (AIS) adalah penerapan prinsip-prinsip biologis ini ke dalam algoritme. AIS meniru fungsi sistem kekebalan dalam pemecahan masalah.

Dalam AIS, antigen merepresentasikan masalah atau tantangan yang harus ditangani. Ini bisa berupa apa saja, mulai dari mendeteksi anomali dalam data hingga mengoptimalkan sebuah solusi.

Antibodi dalam AIS adalah kandidat solusi untuk masalah-masalah ini. Sama seperti antibodi biologis yang mengenali antigen tertentu, AIS mengembangkan solusi potensial yang disesuaikan dengan tantangan spesifik.

Proses sel B dalam AIS mencerminkan bagaimana sistem biologis menghasilkan keragaman dan memori. Algoritme AIS menggunakan beragam kandidat solusi dan menyempurnakannya seiring waktu. Mereka belajar dari pertemuan masalah sebelumnya untuk meningkatkan kinerja di masa depan.

Artificial immune systems tidak memiliki analog langsung dengan sel T, tetapi menggabungkan mekanisme evaluasi yang menjalankan peran serupa. Proses ini menghilangkan solusi yang tidak efektif dan menyetel lebih halus solusi yang berkinerja lebih baik.

AIS menggunakan prinsip-prinsip evolusioner, seperti mutasi dan seleksi, untuk terus meningkatkan kualitas solusi.

Konsep Kunci dalam Artificial Immune Systems

Artificial immune systems menggabungkan konsep kunci seperti interaksi antibodi–antigen, seleksi klonal, seleksi negatif, dan teori jaringan imun. 

Interaksi antibodi–antigen

Konsep yang integral dalam artificial immune systems adalah interaksi antibodi–antigen. Proses ini terinspirasi langsung dari bagaimana sistem kekebalan kita merespons ancaman. Anggap antibodi sebagai solusi potensial untuk suatu masalah dan antigen sebagai masalah atau tantangan itu sendiri.

Di dunia biologis, antibodi adalah protein yang menempel pada antigen dan menetralkannya. Dalam AIS, sebuah antibodi merepresentasikan kandidat solusi untuk masalah komputasi, sementara antigen merepresentasikan masalah yang perlu dipecahkan.

Algoritme AIS mengembangkan populasi antibodi ini agar dapat mengenali dan menetralkan antigen yang sesuai secara efektif. Seiring waktu, algoritme menyetel antibodi ini, mengasah ke arah solusi yang paling efektif.

Clonal selection algorithm (CSA)

Clonal selection algorithm (CSA) mengambil inspirasi dari proses penting lain dalam sistem kekebalan kita. Ketika tubuh mendeteksi antigen, tubuh tidak sekadar mengerahkan sel imun acak; ia memilih yang dapat secara spesifik mengenali penyerang. Sel-sel terpilih ini kemudian dikloning dalam jumlah besar untuk melakukan pertahanan yang efektif.

Klon-klon ini mengalami mutasi, memperkenalkan variasi kecil yang meningkatkan keragaman respons imun. Ini memastikan bahwa bahkan jika patogen berevolusi, sistem kekebalan dapat beradaptasi dan merespons secara efektif.

Serupa, clonal selection algorithm memilih solusi yang paling menjanjikan dan membuat beberapa salinan atau "klon" darinya.

Klon-klon ini kemudian dikenai mutasi, menghasilkan kumpulan solusi potensial yang beragam. Klon dengan kinerja terbaik dipertahankan, dan prosesnya diulang, secara bertahap meningkatkan kualitas solusi. Algoritme ini sangat kuat untuk tugas optimisasi, di mana tujuannya adalah menemukan solusi paling efisien di antara banyak kemungkinan.

CSA sering digunakan untuk menyelesaikan masalah optimisasi. Misalnya, dalam kedirgantaraan, algoritme ini dapat membantu merancang struktur yang efisien seperti sayap pesawat dengan meningkatkan sifat aerodinamis melalui banyak iterasi.

Dalam pencitraan medis, CSA dapat meningkatkan kejernihan gambar atau mendeteksi pola tidak beraturan di lingkungan yang bising, sehingga bermanfaat untuk pemindaian MRI atau deteksi tumor.

Negative selection algorithm (NSA)

Sistem kekebalan manusia harus membedakan antara sel tubuh dan penyerang asing. Di sinilah negative selection algorithm (NSA) berperan. Sel imun yang bereaksi terlalu kuat terhadap sel tubuh sendiri dieliminasi. Ini membantu memastikan sistem kekebalan tidak keliru menyerang dirinya sendiri (menyebabkan penyakit autoimun).

NSA meniru proses ini untuk mengidentifikasi anomali atau outlier dalam data. Algoritme menghasilkan sekumpulan model, disebut detektor, yang dirancang untuk mengenali pola normal dalam data. Detektor yang sangat mirip dengan data normal akan dieliminasi, menyisakan hanya yang tidak cocok dengan pola tipikal. Detektor yang tersisa kemudian digunakan untuk memantau data baru.

Jika detektor atipikal ini menandai titik data baru, hal itu mengindikasikannya sebagai sebuah anomali. Ini mirip dengan cara sistem kekebalan mendeteksi penyerang asing. Metode ini sangat efektif di bidang seperti keamanan siber, di mana mendeteksi pola tidak biasa adalah kunci untuk mengidentifikasi potensi ancaman.

NSA sangat cocok untuk sistem deteksi intrusi yang memantau lalu lintas jaringan, mengidentifikasi aktivitas berbahaya dengan membandingkan pola normal dengan pola potensi ancaman.

NSA juga dapat diterapkan untuk mendeteksi kerusakan mekanis atau operasional pada sistem kompleks seperti pembangkit listrik.

Immune network theory (INT)

Immune network theory (INT) memperluas konsep AIS dengan memodelkan tidak hanya interaksi antara antibodi dan antigen, tetapi juga interaksi antarantibodi itu sendiri.

Dalam sistem kekebalan biologis, antibodi tidak bekerja secara terisolasi. Mereka berkomunikasi dan saling memengaruhi, menciptakan jaringan respons yang dinamis yang lebih tangguh dan adaptif. Interaksi berbasis jaringan ini membantu sistem kekebalan menjaga keseimbangan, memastikan dapat merespons efektif terhadap berbagai ancaman tanpa bereaksi berlebihan pada satu ancaman tertentu.

INT digunakan untuk memodelkan interaksi dan ketergantungan yang kompleks antarberbagai solusi. Ini memungkinkan algoritme mempertimbangkan rentang respons yang lebih luas, menghasilkan strategi pemecahan masalah yang lebih canggih.

Dengan menyimulasikan bagaimana antibodi saling memengaruhi, AIS dapat mengeksplorasi beberapa jalur menuju solusi secara bersamaan, meningkatkan kemampuannya menemukan solusi optimal di lingkungan yang kompleks dan dinamis. Teori ini menopang beberapa algoritme AIS paling canggih, menjadikannya alat yang kuat untuk menangani tantangan komputasi yang rumit.

Immune network theory dapat diterapkan untuk mengontrol kawanan robot. Interaksi antarrobot meniru interaksi antibodi, memungkinkan perilaku terkoordinasi dan pemecahan masalah dalam tugas seperti misi pencarian dan penyelamatan.

Di bidang keuangan, model jaringan imun dapat digunakan untuk mempelajari interaksi antara berbagai indikator ekonomi, memungkinkan prediksi tren pasar atau deteksi anomali finansial.

Implementasi Artificial Immune Systems dengan Python

Python sering menjadi bahasa pilihan saat membuat artificial immune systems karena pustakanya yang luas dan kemudahan penggunaannya.

Implementasi clonal selection algorithm

Clonal selection algorithm terinspirasi oleh proses biologis di mana sel imun yang berhasil mengenali ancaman dikloning lalu dimutasi untuk meningkatkan respons imun. Dalam AIS, “sel imun” ini adalah kandidat solusi untuk suatu masalah, dan tujuannya adalah mengembangkan solusi ini untuk menemukan yang terbaik.

Berikut cara mengimplementasikan versi sederhana CSA di Python:

1. Inisialisasi populasi: Mulailah dengan membuat populasi solusi acak. Jika Anda mengerjakan masalah optimisasi, solusi-solusi ini bisa berupa titik acak di dalam ruang pencarian. Setiap solusi dianalogikan sebagai antibodi dalam sistem kekebalan.
2. Evaluasi kebugaran (fitness): Selanjutnya, evaluasi fitness setiap solusi. Fitness adalah ukuran seberapa baik sebuah solusi memecahkan masalah. Dalam istilah biologis, ini mirip dengan seberapa baik antibodi dapat menetralkan antigen. Fungsi fitness yang Anda gunakan akan bergantung pada masalah spesifik yang Anda selesaikan.
3. Pilih solusi terbaik: Berdasarkan fitness-nya, pilih solusi terbaik untuk dikloning. Proses seleksi ini mirip dengan sistem kekebalan yang memilih antibodi paling efektif untuk melawan patogen.
4. Kloning dan mutasi: Buat beberapa salinan, atau klon, dari solusi yang dipilih. Lalu, perkenalkan mutasi pada klon-klon ini dengan sedikit mengubah nilainya. Langkah ini penting karena memperkenalkan keragaman ke dalam populasi, memungkinkan algoritme menjelajahi area berbeda dari ruang solusi.
5. Ganti dan iterasikan: Ganti solusi dengan kinerja terburuk dalam populasi dengan klon yang baru dimutasi. Ulangi proses untuk sejumlah generasi yang ditentukan atau hingga solusi berkonvergensi ke nilai optimal atau mendekati optimal.

Mari selesaikan masalah optimisasi fungsi menggunakan CSA. Kita akan mengoptimalkan fungsi tolok ukur yang terkenal, fungsi Rastrigin. Fungsi ini dapat digunakan untuk menguji algoritme optimisasi karena memiliki banyak minimum lokal.

Pada kode di bawah, kita menggunakan CSA untuk menemukan titik minimum global dari fungsi tersebut:

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()Didukung oleh

Grafik di atas menunjukkan bagaimana CSA menemukan solusi yang lebih baik untuk fungsi Rastrigin di setiap generasi.

Grafik ini menampilkan plot Rastrigin, memperlihatkan banyaknya minimum lokal. Solusi terbaik, titik merah di tengah, adalah solusi akhir yang ditemukan oleh CSA.

Implementasi negative selection algorithm

NSA sangat berguna untuk tugas deteksi anomali. Algoritme ini mensimulasikan bagaimana sistem kekebalan membedakan antara sel tubuh sendiri dan penyerang asing. Dalam NSA, Anda menghasilkan sekumpulan detektor yang tidak cocok dengan pola data normal. Detektor ini kemudian digunakan untuk memantau data baru, menandai apa pun yang tampak anomalis.

Berikut gambaran cara membuat NSA:

1. Hasilkan data self: Mulailah dengan mendefinisikan apa yang dimaksud dengan “self” dalam data Anda. Ini bisa berupa himpunan data perilaku atau pola yang normal dan diharapkan. Tujuannya adalah membuat detektor yang tidak cocok dengan data self ini.
2. Buat detektor: Hasilkan detektor acak dan bandingkan dengan data self. Detektor yang cocok dengan data self dibuang. Detektor yang tersisa dipertahankan untuk memantau anomali.
3. Pantau data baru: Saat data baru datang, bandingkan dengan detektor yang dipertahankan. Jika suatu detektor mengenali data baru sebagai non-self, data tersebut ditandai sebagai anomali.

Mari lihat cara kerjanya menggunakan kumpulan transaksi fiksi. Dalam contoh ini, kita menghasilkan transaksi normal yang berpusat pada dua klaster dan transaksi curang yang tersebar acak. Kita akan menggunakan negative selection algorithm, di mana detektor penipuan tersebar di seluruh ruang fitur untuk mengidentifikasi anomali berdasarkan kedekatannya dengan detektor tersebut.

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()Didukung oleh

Di sini, detektor penipuan didistribusikan di seluruh ruang fitur untuk mencakup area tempat transaksi normal tidak muncul. Transaksi curang yang berada dekat dengan detektor ini diidentifikasi dan ditandai sebagai anomali.

Plot ini menggambarkan batas keputusan yang dibuat oleh detektor penipuan. Area berarsir mewakili wilayah yang diklasifikasikan sebagai anomalis berdasarkan kedekatan dengan detektor, menyoroti tempat transaksi curang terdeteksi relatif terhadap transaksi normal. Untuk menyesuaikan batas keputusan dan mencakup area yang lebih luas atau lebih sempit, Anda dapat mengubah ambang jarak yang digunakan untuk mendeteksi anomali, yang akan memperluas atau mempersempit wilayah yang diklasifikasikan sebagai anomalis.

Implementasi immune network theory

INT terinspirasi oleh gagasan bahwa respons imun tidak hanya didasarkan pada antibodi individual tetapi juga pada komunikasinya. Pendekatan ini memodelkan sistem kekebalan sebagai sebuah jaringan di mana antibodi berkomunikasi untuk meningkatkan respons imun secara keseluruhan. Dalam konteks ini, setiap antibodi (solusi) dapat berinteraksi dengan yang lain untuk memengaruhi dan menyempurnakan pencarian solusi optimal.

Berikut cara mengimplementasikan versi dasar INT di Python:

1. Inisialisasi populasi: Buat populasi awal solusi acak, serupa dengan algoritme sebelumnya. Setiap solusi merepresentasikan antibodi dalam jaringan.
2. Evaluasi kebugaran: Nilai fitness setiap solusi untuk menentukan seberapa baik ia memecahkan masalah. Langkah ini analog dengan seberapa baik antibodi mengenali dan berikatan dengan antigen.
3. Bangun koneksi: Buat jaringan di mana antibodi (solusi) dihubungkan berdasarkan kemiripan atau kedekatannya. Koneksi merepresentasikan komunikasi antarantibodi, memungkinkan mereka saling memengaruhi.
4. Perbarui solusi: Lakukan iterasi melalui jaringan dan perbarui solusi berdasarkan interaksi dengan antibodi yang terhubung. Proses ini mensimulasikan bagaimana antibodi saling memengaruhi untuk menyempurnakan respons imun.
5. Ganti dan iterasikan: Ganti solusi dengan kinerja terburuk dengan solusi yang diperbarui dari jaringan. Lanjutkan proses untuk jumlah iterasi yang ditentukan atau hingga solusi berkonvergensi ke nilai optimal atau mendekati optimal.

Mari gunakan INT untuk memprediksi tren pasar saham berdasarkan sekumpulan indikator ekonomi. Kita akan menggunakan himpunan data fiksi di mana setiap solusi merepresentasikan kombinasi indikator untuk memprediksi harga saham.

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()Didukung oleh

Grafik ini menunjukkan Mean Squared Error (MSE) yang menurun seiring waktu, menunjukkan bahwa prediksi model menjadi semakin akurat.

Plot sebar ini membandingkan harga saham aktual dengan prediksi model. Titik yang lebih dekat ke garis putus-putus merah menunjukkan prediksi yang lebih akurat.

Bagaimana Perbandingan Artificial Immune Systems dengan Teknik AI Lain?

AIS adalah salah satu dari banyak teknik pembelajaran mesin yang terinspirasi dari biologi.

Jaringan saraf

Jaringan saraf terinspirasi oleh otak manusia dan unggul dalam belajar dari himpunan data besar. Mereka digunakan untuk tugas seperti pengenalan gambar dan pemrosesan bahasa alami. Mereka mengandalkan pelatihan ekstensif dengan data yang sangat banyak untuk menyetel bobot neuron-neuron yang saling terhubung.

Sebaliknya, artificial immune systems berfokus pada kemampuan beradaptasi dan pemecahan masalah yang terdesentralisasi tanpa memerlukan himpunan data besar. AIS meniru kemampuan sistem kekebalan untuk mengenali dan merespons tantangan baru secara real-time, menjadikannya cocok untuk lingkungan dinamis di mana adaptasi cepat sangat krusial.

Algoritme genetika

Algoritme genetika, yang terinspirasi oleh evolusi alam, efektif untuk mengoptimalkan masalah kompleks dengan mengembangkan populasi solusi melalui seleksi, pindah silang (crossover), dan mutasi. Proses ini mirip dengan CSA.

Namun, sementara algoritme genetika bergantung pada operator genetik untuk menjelajahi ruang solusi, CSA menyetel solusi dengan meniru respons imun, menawarkan fleksibilitas dalam menghadapi tantangan baru dan tak terduga. AIS, termasuk CSA, sangat efektif di lingkungan dinamis di mana adaptasi cepat dan pembelajaran berkelanjutan sangat penting.

Anda dapat membaca lebih lanjut tentang algoritme genetika di Genetic Algorithm: Complete Guide With Python Implementation.

Algoritme kecerdasan kawanan

Algoritme kecerdasan kawanan terinspirasi oleh perilaku kolektif organisme sosial seperti semut dan lebah. Mereka menggunakan sistem terdesentralisasi dan interaksi agen sederhana untuk mencapai optimisasi global yang kompleks.

Ini serupa, secara semangat, dengan INT. Kedua pendekatan berfokus pada pemeliharaan keragaman dan kemampuan beradaptasi dalam suatu sistem untuk menangani masalah optimisasi. Sementara kecerdasan kawanan menekankan interaksi berbasis agen, INT memanfaatkan mekanisme yang mirip dengan respons imun, menawarkan metode yang saling melengkapi untuk pemecahan masalah dinamis.

Anda dapat membaca lebih lanjut tentang algoritme kecerdasan kawanan di Swarm Intelligence Algorithms: Three Python Implementations.

Riset Terkini dalam Artificial Immune Systems

Artificial immune systems menjanjikan untuk memecahkan masalah kompleks di berbagai domain. Peneliti bekerja untuk menyempurnakan sistem ini agar menjadi lebih bermanfaat.

Salah satu area yang dieksplorasi peneliti adalah bagaimana membuat model hibrida yang menggabungkan AIS dengan teknik kecerdasan komputasional lainnya. Harapannya, model hibrida ini akan lebih tangguh dan serbaguna.

Pendekatan hibrida ini bertujuan memanfaatkan kekuatan masing-masing metode, seperti kemampuan adaptif AIS dan mekanisme pembelajaran kuat dari jaringan saraf. Untuk informasi lebih lanjut, lihat Artificial Immune Systems.

Area riset aktif lainnya melibatkan penerapan AIS ke domain baru. Meskipun secara tradisional digunakan dalam keamanan siber dan optimisasi, AIS kini dieksplorasi di bidang seperti robotika, bioinformatika, dan bahkan pemodelan finansial. Sifat AIS yang adaptif dan terdesentralisasi menjadikannya kandidat yang menjanjikan untuk memecahkan masalah di lingkungan yang dinamis dan sering kali tidak terduga ini. Untuk informasi lebih lanjut, saya mendorong Anda membaca Nature-Inspired Computing: Scope and Applications of Artificial Immune Systems Toward Analysis and Diagnosis of Complex Problems.

Model AIS bukan hanya menawarkan teknik komputasi yang ditingkatkan tetapi juga dapat berkontribusi pada pemahaman kita tentang sistem kekebalan nyata. Model ini memajukan strategi imunoterapi untuk penyakit seperti kanker dan gangguan autoimun. Lihat kolaborasi antara Cleveland Clinic dan IBM untuk mempelajari lebih lanjut.

Kesimpulan

Artificial immune systems menawarkan pendekatan unik untuk memecahkan masalah kompleks dengan menarik inspirasi dari sistem kekebalan manusia. Dengan meniru proses biologis seperti pengenalan pola, adaptasi, dan memori, AIS menyediakan solusi yang serbaguna di berbagai bidang mulai dari keamanan siber hingga optimisasi.