Artificial Immune System (AIS): Een gids met Python-voorbeelden

Stel je een systeem voor dat bedreigingen kan herkennen en uitschakelen die het nog nooit eerder heeft gezien, terwijl het eerdere indringers onthoudt om ze de volgende keer sneller af te weren. Je immuunsysteem doet dit elke dag. 

Stel je nu voor dat je ditzelfde intelligentieniveau toepast op het oplossen van complexe rekenproblemen. Met artificial immune systems (AIS) kan dat.

Wat zijn artificial immune systems?

Artificial immune systems zijn krachtige computationele modellen die zijn geïnspireerd op het vermogen van het menselijk immuunsysteem om het lichaam te beschermen tegen schade.

Het menselijke immuunsysteem

Het immuunsysteem is het verdedigingsmechanisme van ons lichaam, ontworpen om bedreigingen zoals bacteriën, virussen en schimmels te herkennen en te neutraliseren. Het doet dit met een paar sleutelspelers: antilichamen, b-cellen en t-cellen.

Antilichamen fungeren als de identificatie-eenheden van het immuunsysteem. Deze gespecialiseerde eiwitten herkennen en hechten zich aan specifieke vreemde stoffen, zogenaamde antigenen, en merken ze aan als bedreiging. Elk antilichaam is uniek en ontworpen om op een specifiek antigeen te passen, als een sleutel in een slot.

B-cellen zijn de fabrieken die antilichamen produceren. Ze zijn ook betrokken bij het creëren van geheugencellen. Deze helpen het lichaam sneller te reageren op eerder tegengekomen antigenen door te onthouden welke antilichamen de vorige keer effectief waren.

T-cellen zijn de ordehandhavers van het immuunsysteem. Ze detecteren en vernietigen cellen die door antilichamen als geïnfecteerd of gevaarlijk zijn gemarkeerd, zodat de dreiging snel wordt uitgeschakeld.

Een van de meest opmerkelijke eigenschappen van het immuunsysteem is het vermogen om in de loop van de tijd nieuwe antilichamen te ontwikkelen en te verbeteren. Bij een nieuwe ziekteverwekker reageert het immuunsysteem niet slechts één keer; het verfijnt zijn aanpak continu en creëert sterkere en effectievere antilichamen om de dreiging aan te pakken.

Hoe deze biologische concepten zich vertalen naar AIS

Artificial immune systems (AIS) zijn de implementatie van deze biologische principes in algoritmen. AIS bootsen de functies van het immuunsysteem na bij het oplossen van problemen.

In AIS staan antigenen voor de problemen of uitdagingen die moeten worden aangepakt. Dat kan variëren van het detecteren van anomalieën in data tot het optimaliseren van een oplossing.

Antilichamen in AIS zijn kandidaatoplossingen voor deze problemen. Net zoals biologische antilichamen specifieke antigenen herkennen, ontwikkelt AIS potentiële oplossingen die zijn toegesneden op specifieke uitdagingen.

Het B-celproces in AIS weerspiegelt hoe biologische systemen diversiteit en geheugen genereren. AIS-algoritmen gebruiken diverse kandidaatoplossingen en verfijnen die in de tijd. Ze leren van eerdere probleemgevallen om toekomstige prestaties te verbeteren.

Artificial immune systems hebben geen directe tegenhanger van T-cellen, maar bevatten beoordelingsmechanismen met een vergelijkbare rol. Deze processen elimineren ineffectieve oplossingen en scherpen beter presterende oplossingen aan.

AIS gebruiken evolutionaire principes, zoals mutatie en selectie, om de kwaliteit van oplossingen continu te verbeteren.

Belangrijke concepten in artificial immune systems

Artificial immune systems omvatten kernconcepten zoals antilichaam–antigeeninteractie, clonale selectie, negatieve selectie en immuunnetwerktheorie. 

Antilichaam–antigeeninteractie

Cruciaal in artificial immune systems is het concept van antilichaam–antigeeninteractie. Dit proces is direct geïnspireerd op hoe ons immuunsysteem op bedreigingen reageert. Zie antilichamen als potentiële oplossingen voor een probleem en antigenen als de problemen of uitdagingen zelf.

In de biologische wereld zijn antilichamen eiwitten die zich vasthechten aan antigenen en ze neutraliseren. In AIS staat een antilichaam voor een kandidaatoplossing voor een computationeel probleem, terwijl het antigeen het probleem vertegenwoordigt dat opgelost moet worden.

Het AIS-algoritme ontwikkelt een populatie van deze antilichamen om de bijbehorende antigenen effectief te herkennen en te neutraliseren. Na verloop van tijd verfijnt het algoritme deze antilichamen en focust het op de meest effectieve oplossingen.

Clonal selection algorithm (CSA)

Het clonal selection algorithm (CSA) is geïnspireerd op een ander cruciaal proces in ons immuunsysteem. Wanneer het lichaam een antigeen detecteert, zet het niet zomaar willekeurige immuuncellen in; het selecteert de cellen die de indringer specifiek kunnen herkennen. Deze geselecteerde cellen worden vervolgens in groten getale gekloond om een effectieve verdediging te vormen.

Deze klonen ondergaan mutaties, waarbij kleine variaties worden geïntroduceerd die de diversiteit van de immuunrespons vergroten. Zo kan het immuunsysteem zich aanpassen en effectief reageren, zelfs als de ziekteverwekker evolueert.

Op soortgelijke wijze selecteert het clonal selection algorithm de meest veelbelovende oplossingen en maakt daar meerdere kopieën of "klonen" van.

Deze klonen worden vervolgens aan mutaties onderworpen, waardoor een diverse pool van potentiële oplossingen ontstaat. De best presterende klonen blijven behouden en het proces herhaalt zich, waardoor de kwaliteit van de oplossingen geleidelijk verbetert. Dit algoritme is bijzonder krachtig bij optimalisatietaken, waar het doel is om de meest efficiënte oplossing uit vele mogelijkheden te vinden.

CSA wordt vaak gebruikt om optimalisatieproblemen op te lossen. In de luchtvaart kan het bijvoorbeeld helpen bij het ontwerpen van efficiënte structuren, zoals vleugels van vliegtuigen, door aerodynamische eigenschappen over meerdere iteraties te verbeteren.

In medische beeldvorming kan CSA de beeldscherpte verbeteren of onregelmatige patronen in ruisachtige omgevingen detecteren, wat nuttig is voor MRI-scans of tumordetectie.

Negative selection algorithm (NSA)

Het menselijk immuunsysteem moet onderscheid maken tussen de eigen cellen van het lichaam en vreemde indringers. Hier komt het negative selection algorithm (NSA) om de hoek kijken. Immuuncellen die te sterk reageren op de eigen cellen van het lichaam worden geëlimineerd. Dit helpt voorkomen dat het immuunsysteem per ongeluk zichzelf aanvalt (auto-immuunziekte).

NSA bootst dit proces na om anomalieën of uitschieters in data te identificeren. Het algoritme genereert een set modellen, detectoren genoemd, die zijn ontworpen om normale patronen in de data te herkennen. Detectoren die sterk overeenkomen met de normale data worden geëlimineerd, zodat alleen die overblijven die niet overeenkomen met typische patronen. Deze overgebleven detectoren worden vervolgens gebruikt om nieuwe data te monitoren.

Als deze atypische detectoren een nieuw datapunt markeren, duiden ze het aan als een anomalie. Dit lijkt op hoe het immuunsysteem vreemde indringers detecteert. Deze methode is zeer effectief in sectoren zoals cybersecurity, waar het detecteren van ongewone patronen cruciaal is om potentiële dreigingen te identificeren.

NSA is bijzonder geschikt voor intrusion detection-systemen die netwerkverkeer monitoren en kwaadaardige activiteiten identificeren door normale patronen te vergelijken met die van potentiële bedreigingen.

NSA kan ook worden toegepast om mechanische of operationele storingen te detecteren in complexe systemen zoals energiecentrales.

Immuunnetwerktheorie (INT)

Immuunnetwerktheorie (INT) breidt het concept van AIS uit door niet alleen de interactie tussen antilichamen en antigenen te modelleren, maar ook de interacties tussen antilichamen onderling.

In het biologische immuunsysteem werken antilichamen niet geïsoleerd. Ze communiceren en beïnvloeden elkaar, waardoor een dynamisch netwerk van reacties ontstaat dat robuuster en adaptiever is. Deze genetworkte interactie helpt het immuunsysteem een balans te bewaren, zodat het effectief kan reageren op een breed scala aan bedreigingen zonder op één enkele bedreiging te overreageren.

INT wordt gebruikt om complexe interacties en afhankelijkheden tussen verschillende oplossingen te modelleren. Dit stelt het algoritme in staat een breder scala aan mogelijke reacties te overwegen, wat leidt tot meer verfijnde probleemoplossingsstrategieën.

Door te simuleren hoe antilichamen elkaar beïnvloeden, kan AIS gelijktijdig meerdere paden naar een oplossing verkennen, waardoor de kans toeneemt om optimale oplossingen te vinden in complexe en dynamische omgevingen. Deze theorie ligt ten grondslag aan enkele van de meest geavanceerde AIS-algoritmen en is daarmee een krachtig hulpmiddel voor het aanpakken van ingewikkelde computationele uitdagingen.

Immuunnetwerktheorie kan worden toegepast op het aansturen van robotswarms. De interacties tussen robots bootsen antilichaaminteracties na, wat gecoördineerd gedrag en probleemoplossing mogelijk maakt bij taken zoals zoek- en reddingsmissies.

In de financiële sector kunnen immuunnetwerkmodellen worden gebruikt om interacties tussen verschillende economische indicatoren te bestuderen, waardoor markttrends kunnen worden voorspeld of financiële anomalieën kunnen worden gedetecteerd.

Python-implementatie van artificial immune systems

Python is vaak de taal bij uitstek voor het bouwen van artificial immune systems vanwege de uitgebreide bibliotheken en het gebruiksgemak.

Implementatie van het clonal selection algorithm

Het clonal selection algorithm is geïnspireerd op het biologische proces waarbij immuuncellen die een bedreiging succesvol herkennen, worden gekloond en vervolgens gemuteerd om de immuunrespons te verbeteren. In AIS zijn deze "immuuncellen" kandidaatoplossingen voor een probleem en is het doel om deze oplossingen te evolueren om de beste te vinden.

Zo implementeer je een eenvoudige versie van CSA in Python:

1. Initialiseer de populatie: Begin met het maken van een populatie van willekeurige oplossingen. Werk je aan een optimalisatieprobleem, dan zijn dit willekeurige punten binnen de zoekruimte. Elke oplossing is analoog aan een antilichaam in het immuunsysteem.
2. Evalueer de fitness: Evalueer vervolgens de fitness van elke oplossing. Fitness meet hoe goed een oplossing het probleem oplost. In biologische termen is dit vergelijkbaar met hoe goed een antilichaam een antigeen kan neutraliseren. De fitnessfunctie hangt af van het specifieke probleem dat je oplost.
3. Selecteer de beste oplossingen: Selecteer op basis van de fitness de beste oplossingen om te klonen. Dit selectieproces lijkt op hoe het immuunsysteem de meest effectieve antilichamen selecteert om een pathogeen te bestrijden.
4. Kloon en muteer: Maak meerdere kopieën, of klonen, van de geselecteerde oplossingen. Introduceer vervolgens mutaties in deze klonen door hun waarden licht te wijzigen. Deze stap is belangrijk omdat het diversiteit in de populatie brengt, waardoor het algoritme verschillende gebieden van de oplossingsruimte kan verkennen.
5. Vervang en herhaal: Vervang de slechtst presterende oplossingen in de populatie door de nieuw gemuteerde klonen. Herhaal het proces voor een vastgesteld aantal generaties of totdat de oplossingen convergeren naar een optimaal of bijna-optimaal resultaat.

Laten we een functie-optimalisatieprobleem oplossen met CSA. We optimaliseren een bekende benchmarkfunctie, de Rastrigin-functie. Deze functie wordt gebruikt om optimalisatie-algoritmen te testen vanwege de vele lokale minima.

In de onderstaande code gebruiken we een CSA om de globale minima voor de functie te vinden:

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()Mogelijk gemaakt door

De bovenstaande grafiek laat zien hoe de CSA bij elke generatie betere oplossingen voor de Rastrigin-functie vond.

Deze grafiek toont de geplotte Rastrigin-functie en illustreert de vele lokale minima. De beste oplossing, de rode stip in het midden, is de uiteindelijke oplossing die door de CSA is gevonden.

Implementatie van het negative selection algorithm

NSA is bijzonder nuttig voor taken rond anomaliedetectie. Dit algoritme simuleert hoe het immuunsysteem onderscheid maakt tussen de eigen cellen van het lichaam en vreemde indringers. In een NSA genereer je een set detectoren die niet overeenkomen met normale datapatronen. Deze detectoren worden vervolgens gebruikt om nieuwe data te monitoren en alles wat afwijkend lijkt te markeren.

Hier volgt een overzicht van hoe je een NSA maakt:

1. Genereer self-data: Begin met het definiëren van wat "self" is in je data. Dit kan een dataset van normale, verwachte gedragingen of patronen zijn. Het doel is detectoren te creëren die niet overeenkomen met deze self-data.
2. Maak detectoren: Genereer willekeurige detectoren en vergelijk ze met de self-data. Elke detector die overeenkomt met de self-data wordt weggegooid. De overgebleven detectoren blijven behouden om te monitoren op anomalieën.
3. Monitor nieuwe data: Vergelijk nieuwe data met de behouden detectoren. Als een detector de nieuwe data als non-self herkent, wordt de data als anomalie gemarkeerd.

Laten we zien hoe dit werkt met een fictieve set transacties. In dit voorbeeld genereren we normale transacties rond twee clusters en frauduleuze transacties die willekeurig verspreid zijn. We gebruiken een negative selection algorithm, waarbij fraudedetectoren over de feature space worden verspreid om anomalieën te identificeren op basis van hun nabijheid tot deze detectoren.

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()Mogelijk gemaakt door

Hier zijn de fraudedetectoren over de feature space verdeeld om gebieden te dekken waar normale transacties niet voorkomen. Frauduleuze transacties die dicht bij deze detectoren vallen, worden geïdentificeerd en als anomalieën gemarkeerd.

Deze plot illustreert de beslissingsgrens die door de fraudedetectoren is gecreëerd. De gearceerde gebieden vertegenwoordigen zones die als afwijkend zijn geclassificeerd op basis van de nabijheid tot de detectoren, en laten zien waar frauduleuze transacties worden gedetecteerd in relatie tot normale transacties. Om de beslissingsgrens aan te passen en meer of minder gebied te dekken, kun je de afstandsdrempel voor het detecteren van anomalieën wijzigen, waardoor de gebieden die als afwijkend zijn geclassificeerd, groter of kleiner worden.

Implementatie van immuunnetwerktheorie

INT is geïnspireerd op het idee dat immuunresponsen niet alleen gebaseerd zijn op individuele antilichamen, maar ook op hun onderlinge communicatie. Deze aanpak modelleert het immuunsysteem als een netwerk waarin antilichamen communiceren om de algehele immuunrespons te versterken. In deze context kan elk antilichaam (oplossing) met andere interacteren om de zoektocht naar optimale oplossingen te beïnvloeden en te verfijnen.

Zo implementeer je een basisversie van INT in Python:

1. Initialiseer de populatie: Maak een initiële populatie van willekeurige oplossingen, vergelijkbaar met de eerdere algoritmen. Elke oplossing vertegenwoordigt een antilichaam in het netwerk.
2. Evalueer de fitness: Beoordeel de fitness van elke oplossing om te bepalen hoe goed die het probleem oplost. Deze stap is analoog aan hoe goed een antilichaam presteert bij het herkennen en binden aan een antigeen.
3. Leg verbindingen: Creëer een netwerk waarin antilichamen (oplossingen) worden verbonden op basis van hun gelijkenis of nabijheid. Verbindingen vertegenwoordigen de communicatie tussen antilichamen en stellen hen in staat elkaar te beïnvloeden.
4. Werk oplossingen bij: Itereer door het netwerk en werk oplossingen bij op basis van de interacties met verbonden antilichamen. Dit proces simuleert hoe antilichamen elkaar beïnvloeden om de immuunrespons te verfijnen.
5. Vervang en herhaal: Vervang de slechtst presterende oplossingen door bijgewerkte oplossingen uit het netwerk. Ga door voor een vastgesteld aantal iteraties of totdat de oplossingen convergeren naar een optimaal of bijna-optimaal resultaat.

Laten we INT gebruiken om beursontwikkelingen te voorspellen op basis van een set economische indicatoren. We gebruiken een fictieve dataset waarbij elke oplossing staat voor een combinatie van indicatoren voor het voorspellen van aandelenkoersen.

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()Mogelijk gemaakt door

Deze grafiek toont dat de Mean Squared Error (MSE) in de tijd afneemt, wat aangeeft dat de voorspellingen van het model nauwkeuriger worden.

Deze spreidingsplot vergelijkt werkelijke aandelenkoersen met modelvoorspellingen. Punten dichter bij de rode stippellijn duiden op nauwkeurigere voorspellingen.

Hoe verhouden artificial immune systems zich tot andere AI-technieken?

AIS is een van de vele machinelearningtechnieken die inspiratie haalt uit de biologie.

Neurale netwerken

Neurale netwerken zijn geïnspireerd op de menselijke hersenen en excelleren in leren van grote datasets. Ze worden gebruikt voor taken zoals beeldherkenning en natural language processing. Ze vertrouwen op uitgebreide training met grote hoeveelheden data om de gewichten van onderling verbonden neuronen aan te passen.

Daarentegen focussen artificial immune systems op adaptiviteit en gedecentraliseerde probleemoplossing zonder grote datasets te vereisen. AIS bootsen het vermogen van het immuunsysteem na om in real time nieuwe uitdagingen te herkennen en erop te reageren, waardoor ze geschikt zijn voor dynamische omgevingen waar snelle aanpassing cruciaal is.

Genetische algoritmen

Genetische algoritmen, geïnspireerd door natuurlijke evolutie, zijn effectief voor het optimaliseren van complexe problemen door een populatie oplossingen te laten evolueren via selectie, kruising en mutatie. Dit proces lijkt op CSA.

Maar waar genetische algoritmen vertrouwen op genetische operatoren om de oplossingsruimte te verkennen, past CSA oplossingen aan door immuunresponsen na te bootsen, wat flexibiliteit biedt bij het omgaan met nieuwe en onverwachte uitdagingen. AIS, inclusief CSA, zijn bijzonder effectief in dynamische omgevingen waar snelle adaptatie en continu leren cruciaal zijn.

Je kunt meer lezen over genetische algoritmen in Genetic Algorithm: Complete Guide With Python Implementation.

Swarm intelligence-algoritmen

Swarm intelligence-algoritmen zijn geïnspireerd op het collectieve gedrag van sociale organismen zoals mieren en bijen. Ze gebruiken gedecentraliseerde systemen en eenvoudige interacties tussen agenten om complexe globale optimalisatie te bereiken.

Dit is qua geest vergelijkbaar met INT. Beide benaderingen richten zich op het behouden van diversiteit en adaptiviteit binnen een systeem om optimalisatieproblemen aan te pakken. Terwijl swarm intelligence de nadruk legt op agentgebaseerde interacties, benut INT mechanismen die lijken op immuunresponsen, en bieden beide complementaire methoden voor dynamische probleemoplossing.

Je kunt meer lezen over swarm intelligence-algoritmen in Swarm Intelligence Algorithms: Three Python Implementations.

Huidig onderzoek naar artificial immune systems

Artificial immune systems bieden perspectief voor het oplossen van complexe problemen in uiteenlopende domeinen. Onderzoekers werken eraan om deze systemen verder te verbeteren en nog bruikbaarder te maken.

Een gebied dat onderzoekers verkennen, is hoe je hybride modellen maakt die AIS combineren met andere technieken uit de computationele intelligentie. De hoop is dat deze hybride modellen robuuster en veelzijdiger zijn.

Deze hybride benaderingen willen de sterke punten van elke methode benutten, zoals de adaptieve mogelijkheden van AIS en de krachtige leermethoden van neurale netwerken. Meer informatie vind je in Artificial Immune Systems.

Een ander actief onderzoeksterrein is de toepassing van AIS in nieuwe domeinen. Waar AIS traditioneel werd gebruikt in cybersecurity en optimalisatie, wordt het nu ook verkend in gebieden zoals robotica, bio-informatica en zelfs financiële modellering. De adaptieve en gedecentraliseerde aard van AIS maakt het een veelbelovende kandidaat voor het oplossen van problemen in deze dynamische en vaak onvoorspelbare omgevingen. Voor meer informatie raad ik je aan om te lezen Nature-Inspired Computing: Scope and Applications of Artificial Immune Systems Toward Analysis and Diagnosis of Complex Problems.

AIS-modellen bieden niet alleen verbeterde computationele technieken, maar kunnen ook bijdragen aan ons begrip van echte immuunsystemen. Ze helpen bij het ontwikkelen van immunotherapiestrategieën voor ziekten zoals kanker en auto-immuunstoornissen. Bekijk deze samenwerking tussen de Cleveland Clinic en IBM voor meer informatie.

Conclusie

Artificial immune systems bieden een unieke aanpak voor het oplossen van complexe problemen door inspiratie te halen uit het menselijke immuunsysteem. Door biologische processen zoals patroonherkenning, aanpassing en geheugen na te bootsen, levert AIS veelzijdige oplossingen in uiteenlopende velden, van cybersecurity tot optimalisatie.