Sistemi Immunitari Artificiali (AIS): guida con esempi in Python

Immagina un sistema in grado di identificare e neutralizzare minacce mai incontrate prima, ricordando al contempo gli invasori passati per respingerli in modo più efficiente. Il tuo sistema immunitario lo fa ogni giorno. 

Ora, immagina di applicare lo stesso livello di intelligenza per risolvere problemi informatici complessi. Con i sistemi immunitari artificiali (AIS), possiamo fare proprio questo.

Cosa sono i Sistemi Immunitari Artificiali?

I sistemi immunitari artificiali sono potenti modelli computazionali ispirati alla capacità del sistema immunitario umano di proteggere il corpo dai danni.

Il sistema immunitario umano

Il sistema immunitario è il meccanismo di difesa del nostro corpo, progettato per riconoscere e neutralizzare minacce come batteri, virus e funghi. Lo fa attraverso alcuni attori chiave: anticorpi, cellule B e cellule T.

Gli anticorpi fungono da unità di identificazione del sistema immunitario. Queste proteine specializzate riconoscono e si legano a sostanze estranee specifiche, chiamate antigeni, etichettandole come minacce. Ogni anticorpo è unico, progettato per corrispondere a un particolare antigene, come una chiave con la sua serratura.

Le cellule B sono le fabbriche che producono anticorpi. Sono coinvolte anche nella creazione delle cellule della memoria, che aiutano il corpo a rispondere più rapidamente ad antigeni già incontrati ricordando quali anticorpi sono stati utili in passato.

Le cellule T sono gli esecutori del sistema immunitario. Rilevano e distruggono le cellule segnalate dagli anticorpi come infette o pericolose, assicurando che la minaccia venga rapidamente neutralizzata.

Una delle caratteristiche più notevoli del sistema immunitario è la sua capacità di evolversi e migliorare nuovi anticorpi nel tempo. Di fronte a un nuovo patogeno, il sistema immunitario non si limita a rispondere una sola volta. Affina continuamente il suo approccio, creando anticorpi via via più forti ed efficaci per affrontare la minaccia.

Come questi concetti biologici si traducono negli AIS

I sistemi immunitari artificiali (AIS) sono l’implementazione di questi principi biologici in algoritmi. Gli AIS imitano le funzioni del sistema immunitario nella risoluzione dei problemi.

Negli AIS, gli antigeni rappresentano i problemi o le sfide da affrontare. Possono essere qualsiasi cosa, dal rilevamento di anomalie nei dati all’ottimizzazione di una soluzione.

Gli anticorpi negli AIS sono soluzioni candidate a questi problemi. Proprio come gli anticorpi biologici riconoscono antigeni specifici, gli AIS evolvono potenziali soluzioni su misura per sfide specifiche.

Il processo delle cellule B negli AIS rispecchia il modo in cui i sistemi biologici generano diversità e memoria. Gli algoritmi AIS usano soluzioni candidate diversificate e le perfezionano nel tempo. Imparano da problemi già incontrati per migliorare le prestazioni future.

I sistemi immunitari artificiali non hanno un analogo diretto delle cellule T, ma incorporano meccanismi di valutazione che svolgono un ruolo simile. Questi processi eliminano le soluzioni inefficaci e affinano quelle che performano meglio.

Gli AIS utilizzano principi evolutivi, come mutazione e selezione, per migliorare continuamente la qualità delle soluzioni.

Concetti chiave nei Sistemi Immunitari Artificiali

I sistemi immunitari artificiali incorporano concetti chiave come l’interazione anticorpo‑antigene, la selezione clonale, la selezione negativa e la teoria delle reti immunitarie. 

Interazione anticorpo‑antigene

Fondamentale per i sistemi immunitari artificiali è il concetto di interazione anticorpo‑antigene. Questo processo è direttamente ispirato a come il nostro sistema immunitario risponde alle minacce. Pensa agli anticorpi come a soluzioni potenziali a un problema e agli antigeni come ai problemi o alle sfide stesse.

Nel mondo biologico, gli anticorpi sono proteine che si attaccano agli antigeni e li neutralizzano. Negli AIS, un anticorpo rappresenta una soluzione candidata a un problema computazionale, mentre l’antigene rappresenta il problema da risolvere.

L’algoritmo AIS evolve una popolazione di questi anticorpi per riconoscere e neutralizzare efficacemente i corrispondenti antigeni. Nel tempo, l’algoritmo affina questi anticorpi, puntando sulle soluzioni più efficaci.

Algoritmo di selezione clonale (CSA)

L’algoritmo di selezione clonale (CSA) trae ispirazione da un altro processo cruciale del nostro sistema immunitario. Quando il corpo rileva un antigene, non schiera cellule immunitarie a caso; seleziona quelle in grado di riconoscere specificamente l’invasore. Queste cellule selezionate vengono poi clonate in gran numero per montare una difesa efficace.

Questi cloni subiscono mutazioni, introducendo lievi variazioni che aumentano la diversità della risposta immunitaria. Questo garantisce che, anche se il patogeno evolve, il sistema immunitario possa adattarsi e rispondere efficacemente.

Allo stesso modo, l’algoritmo di selezione clonale seleziona le soluzioni più promettenti e ne crea più copie, o "cloni".

Questi cloni vengono quindi sottoposti a mutazioni, generando un pool diversificato di potenziali soluzioni. I cloni con le prestazioni migliori vengono mantenuti e il processo si ripete, migliorando progressivamente la qualità delle soluzioni. Questo algoritmo è particolarmente potente nei compiti di ottimizzazione, dove l’obiettivo è trovare la soluzione più efficiente tra molte possibilità.

Il CSA è spesso usato per risolvere problemi di ottimizzazione. Ad esempio, nell’aerospaziale può aiutare a progettare strutture efficienti come le ali degli aerei, migliorando le proprietà aerodinamiche attraverso più iterazioni.

Nell’imaging medico, il CSA può migliorare la nitidezza delle immagini o rilevare schemi irregolari in ambienti rumorosi, risultando utile per risonanze magnetiche o rilevamento di tumori.

Algoritmo di selezione negativa (NSA)

Il sistema immunitario umano deve distinguere tra le cellule del corpo e gli invasori esterni. Qui entra in gioco l’algoritmo di selezione negativa (NSA). Le cellule immunitarie che reagiscono troppo fortemente alle cellule del corpo vengono eliminate. Questo aiuta a garantire che il sistema immunitario non attacchi erroneamente se stesso (causando una malattia autoimmune).

L’NSA imita questo processo per identificare anomalie o outlier nei dati. L’algoritmo genera un insieme di modelli, chiamati rilevatori, progettati per riconoscere i pattern normali nei dati. Qualsiasi rilevatore che corrisponda strettamente ai dati normali viene eliminato, lasciando solo quelli che non corrispondono ai pattern tipici. Questi rilevatori rimanenti vengono poi utilizzati per monitorare i nuovi dati.

Se questi rilevatori atipici segnalano un nuovo punto dati, lo indicano come un’anomalia. È simile a come il sistema immunitario rileva gli invasori esterni. Questo metodo è molto efficace in ambiti come la cybersicurezza, dove rilevare pattern insoliti è la chiave per identificare potenziali minacce.

L’NSA è adatto per i sistemi di rilevamento delle intrusioni che monitorano il traffico di rete, identificando attività malevole confrontando i pattern normali con quelli delle potenziali minacce.

L’NSA può essere applicato anche per rilevare guasti meccanici o operativi in sistemi complessi come le centrali elettriche.

Teoria delle reti immunitarie (INT)

La teoria delle reti immunitarie (INT) estende il concetto di AIS modellando non solo l’interazione tra anticorpi e antigeni, ma anche le interazioni tra gli stessi anticorpi.

Nel sistema immunitario biologico, gli anticorpi non operano in isolamento. Comunicano e si influenzano a vicenda, creando una rete dinamica di risposte più robusta e adattabile. Questa interazione in rete aiuta il sistema immunitario a mantenere un equilibrio, assicurando una risposta efficace a un’ampia gamma di minacce senza reagire eccessivamente a una singola di esse.

L’INT viene utilizzata per modellare interazioni e dipendenze complesse tra diverse soluzioni. Questo consente all’algoritmo di considerare una gamma più ampia di possibili risposte, portando a strategie di problem solving più sofisticate.

Simulando come gli anticorpi si influenzano a vicenda, gli AIS possono esplorare simultaneamente percorsi multipli verso una soluzione, migliorando la capacità di trovare soluzioni ottimali in ambienti complessi e dinamici. Questa teoria è alla base di alcuni degli algoritmi AIS più avanzati, rendendola uno strumento potente per affrontare sfide computazionali intricate.

La teoria delle reti immunitarie può essere applicata al controllo di sciami di robot. Le interazioni tra robot imitano quelle tra anticorpi, abilitando comportamenti coordinati e problem solving in compiti come le missioni di ricerca e soccorso.

In finanza, i modelli di rete immunitaria possono essere utilizzati per studiare le interazioni tra vari indicatori economici, consentendo la previsione dei trend di mercato o il rilevamento di anomalie finanziarie.

Implementazione in Python dei Sistemi Immunitari Artificiali

Python è spesso la lingua preferita per creare sistemi immunitari artificiali grazie alle sue librerie estese e alla facilità d’uso.

Implementazione dell’algoritmo di selezione clonale

L’algoritmo di selezione clonale è ispirato al processo biologico in cui le cellule immunitarie che riconoscono con successo una minaccia vengono clonate e poi mutate per migliorare la risposta immunitaria. Negli AIS, queste “cellule immunitarie” sono soluzioni candidate a un problema, e l’obiettivo è far evolvere queste soluzioni per trovare la migliore.

Ecco come puoi implementare una versione semplice del CSA in Python:

1. Inizializza la popolazione: inizia creando una popolazione di soluzioni casuali. Se stai lavorando su un problema di ottimizzazione, queste soluzioni potrebbero essere punti casuali all’interno dello spazio di ricerca. Ogni soluzione è analoga a un anticorpo nel sistema immunitario.
2. Valuta la fitness: valuta quindi la fitness di ogni soluzione. La fitness misura quanto bene una soluzione risolve il problema. In termini biologici, è simile a quanto bene un anticorpo può neutralizzare un antigene. La funzione di fitness dipende dallo specifico problema che stai risolvendo.
3. Seleziona le soluzioni migliori: in base alla loro fitness, seleziona le soluzioni migliori da clonare. Questo processo di selezione è analogo al sistema immunitario che seleziona gli anticorpi più efficaci per combattere un patogeno.
4. Clona e muta: crea più copie, o cloni, delle soluzioni selezionate. Quindi, introduci mutazioni in questi cloni modificando leggermente i loro valori. Questo passaggio è importante perché introduce diversità nella popolazione, consentendo all’algoritmo di esplorare aree diverse dello spazio delle soluzioni.
5. Sostituisci e ripeti: sostituisci le soluzioni con prestazioni peggiori nella popolazione con i cloni appena mutati. Ripeti il processo per un numero specificato di generazioni o finché le soluzioni non convergono a un valore ottimale o quasi ottimale.

Risolviamo un problema di ottimizzazione di funzione usando il CSA. Ottimizzeremo una funzione di riferimento ben nota, la funzione di Rastrigin. Questa funzione viene usata per testare gli algoritmi di ottimizzazione a causa dei suoi numerosi minimi locali.

Nel codice seguente, usiamo un CSA per trovare il minimo globale della funzione:

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()Offerto da

Il grafico sopra mostra come il CSA abbia trovato soluzioni migliori alla funzione di Rastrigin a ogni generazione.

Questo grafico mostra la funzione di Rastrigin tracciata, evidenziando i suoi numerosi minimi locali. La soluzione migliore, il punto rosso al centro, è la soluzione finale trovata dal CSA.

Implementazione dell’algoritmo di selezione negativa

L’NSA è particolarmente utile per i compiti di rilevamento delle anomalie. Questo algoritmo simula come il sistema immunitario distingue tra le cellule del corpo e gli invasori esterni. In un NSA, si genera un insieme di rilevatori che non corrispondono ai pattern di dati normali. Questi rilevatori vengono poi usati per monitorare i nuovi dati, segnalando tutto ciò che appare anomalo.

Ecco una panoramica di come creare un NSA:

1. Genera i dati self: inizia definendo cosa costituisce il “self” nei tuoi dati. Potrebbe trattarsi di un dataset di comportamenti o pattern normali e attesi. L’obiettivo è creare rilevatori che non corrispondano a questi dati self.
2. Crea i rilevatori: genera rilevatori casuali e confrontali con i dati self. Qualsiasi rilevatore che corrisponda ai dati self viene scartato. I rilevatori rimanenti vengono mantenuti per monitorare le anomalie.
3. Monitora i nuovi dati: quando arrivano nuovi dati, confrontali con i rilevatori mantenuti. Se un rilevatore riconosce i nuovi dati come non‑self, i dati vengono segnalati come anomalia.

Vediamo come funziona usando un insieme fittizio di transazioni. In questo esempio, generiamo transazioni normali centrate attorno a due cluster e transazioni fraudolente sparse casualmente. Useremo un algoritmo di selezione negativa, in cui i rilevatori di frode sono distribuiti nello spazio delle feature per identificare anomalie in base alla loro prossimità a questi rilevatori.

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()Offerto da

Qui, i rilevatori di frode sono distribuiti nello spazio delle feature per coprire le aree in cui non compaiono transazioni normali. Le transazioni fraudolente che cadono vicino a questi rilevatori vengono identificate e segnalate come anomalie.

Questo grafico illustra il confine di decisione creato dai rilevatori di frode. Le aree ombreggiate rappresentano le zone classificate come anomale in base alla prossimità ai rilevatori, evidenziando dove vengono rilevate transazioni fraudolente rispetto a quelle normali. Per regolare il confine di decisione e coprire più o meno area, puoi modificare la soglia di distanza utilizzata per rilevare le anomalie, che espanderà o contrarrà le regioni classificate come anomale.

Implementazione della teoria delle reti immunitarie

L’INT è ispirata all’idea che le risposte immunitarie non si basano solo su singoli anticorpi, ma anche sulla loro comunicazione. Questo approccio modella il sistema immunitario come una rete in cui gli anticorpi comunicano per rafforzare la risposta complessiva. In questo contesto, ogni anticorpo (soluzione) può interagire con gli altri per influenzare e affinare la ricerca delle soluzioni ottimali.

Ecco come puoi implementare una versione di base dell’INT in Python:

1. Inizializza la popolazione: crea una popolazione iniziale di soluzioni casuali, simile agli algoritmi precedenti. Ogni soluzione rappresenta un anticorpo nella rete.
2. Valuta la fitness: valuta la fitness di ogni soluzione per determinare quanto bene risolve il problema. Questo passaggio è analogo a quanto bene un anticorpo riconosce e si lega a un antigene.
3. Stabilisci le connessioni: crea una rete in cui gli anticorpi (soluzioni) sono collegati in base alla loro somiglianza o prossimità. Le connessioni rappresentano la comunicazione tra anticorpi, permettendo loro di influenzarsi a vicenda.
4. Aggiorna le soluzioni: itera sulla rete e aggiorna le soluzioni in base alle interazioni con gli anticorpi connessi. Questo processo simula come gli anticorpi si influenzino a vicenda per affinare la risposta immunitaria.
5. Sostituisci e ripeti: sostituisci le soluzioni con prestazioni peggiori con soluzioni aggiornate dalla rete. Continua il processo per un numero specificato di iterazioni o finché le soluzioni non convergono a un valore ottimale o quasi ottimale.

Usiamo l’INT per prevedere i trend del mercato azionario in base a un insieme di indicatori economici. Useremo un dataset fittizio in cui ogni soluzione rappresenta una combinazione di indicatori per la previsione dei prezzi azionari.

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()Offerto da

Questo grafico mostra il Mean Squared Error (MSE) diminuire nel tempo, indicando che le previsioni del modello stanno diventando più accurate.

Questo scatter plot confronta i prezzi azionari reali con le previsioni del modello. I punti più vicini alla linea tratteggiata rossa indicano previsioni più accurate.

Come si confrontano i Sistemi Immunitari Artificiali con altre tecniche di IA?

Gli AIS sono una delle tante tecniche di machine learning ispirate alla biologia.

Reti neurali

Le reti neurali sono ispirate al cervello umano ed eccellono nell’apprendere da grandi dataset. Vengono utilizzate per compiti come il riconoscimento di immagini e l’elaborazione del linguaggio naturale. Si basano su un addestramento estensivo con grandi quantità di dati per regolare i pesi dei neuroni interconnessi.

Al contrario, i sistemi immunitari artificiali si concentrano sull’adattabilità e sulla risoluzione decentralizzata dei problemi senza richiedere grandi dataset. Gli AIS imitano la capacità del sistema immunitario di riconoscere e rispondere a nuove sfide in tempo reale, rendendoli adatti ad ambienti dinamici dove l’adattamento rapido è cruciale.

Algoritmi genetici

Gli algoritmi genetici, ispirati all’evoluzione naturale, sono efficaci nell’ottimizzare problemi complessi evolvendo una popolazione di soluzioni attraverso selezione, crossover e mutazione. Questo processo è simile al CSA.

Tuttavia, mentre gli algoritmi genetici si affidano a operatori genetici per esplorare lo spazio delle soluzioni, il CSA adatta le soluzioni imitando le risposte immunitarie, offrendo flessibilità nell’affrontare sfide nuove e inaspettate. Gli AIS, incluso il CSA, sono particolarmente efficaci in ambienti dinamici, dove adattamento rapido e apprendimento continuo sono fondamentali.

Puoi leggere di più sugli algoritmi genetici in Genetic Algorithm: Complete Guide With Python Implementation.

Algoritmi di swarm intelligence

Gli algoritmi di swarm intelligence sono ispirati al comportamento collettivo di organismi sociali come formiche e api. Usano sistemi decentralizzati e interazioni semplici tra agenti per ottenere un’ottimizzazione globale complessa.

Questo è simile, nello spirito, all’INT. Entrambi gli approcci si concentrano sul mantenimento di diversità e adattabilità all’interno di un sistema per affrontare problemi di ottimizzazione. Mentre la swarm intelligence enfatizza le interazioni basate sugli agenti, l’INT sfrutta meccanismi simili alle risposte immunitarie, offrendo metodi complementari per il problem solving dinamico.

Puoi leggere di più sugli algoritmi di swarm intelligence in Swarm Intelligence Algorithms: Three Python Implementations.

Ricerca attuale sui Sistemi Immunitari Artificiali

I sistemi immunitari artificiali promettono di risolvere problemi complessi in vari ambiti. I ricercatori stanno lavorando per potenziare questi sistemi e renderli ancora più utili.

Un’area di interesse è come creare modelli ibridi che combinino gli AIS con altre tecniche di intelligenza computazionale. L’auspicio è che questi modelli ibridi siano più robusti e versatili.

Questi approcci ibridi puntano a sfruttare i punti di forza di ciascun metodo, come le capacità adattive degli AIS e i potenti meccanismi di apprendimento delle reti neurali. Per maggiori informazioni, dai un’occhiata a Artificial Immune Systems.

Un’altra area di ricerca attiva riguarda l’applicazione degli AIS a nuovi domini. Sebbene tradizionalmente usati in cybersicurezza e ottimizzazione, gli AIS sono ora esplorati in campi come robotica, bioinformatica e persino modellazione finanziaria. L’adattabilità e la natura decentralizzata degli AIS li rendono candidati promettenti per risolvere problemi in ambienti dinamici e spesso imprevedibili. Per approfondire, ti invito a leggere Nature-Inspired Computing: Scope and Applications of Artificial Immune Systems Toward Analysis and Diagnosis of Complex Problems.

I modelli AIS non solo offrono tecniche computazionali avanzate, ma possono anche contribuire alla nostra comprensione dei sistemi immunitari reali. Stanno facendo progredire le strategie di immunoterapia per malattie come il cancro e i disturbi autoimmuni. Dai un’occhiata a questa collaborazione tra Cleveland Clinic e IBM per saperne di più.

Conclusione

I sistemi immunitari artificiali offrono un approccio unico alla risoluzione di problemi complessi, traendo ispirazione dal sistema immunitario umano. Emulando processi biologici come il riconoscimento di pattern, l’adattamento e la memoria, gli AIS forniscono soluzioni versatili in campi che vanno dalla cybersicurezza all’ottimizzazione.