programa
Sistema imunológico artificial (AIS): Um guia com exemplos em Python
Imagine um sistema que possa identificar e neutralizar ameaças que nunca encontrou antes e, ao mesmo tempo, lembrar-se de invasores anteriores para afastá-los com mais eficiência. Seu sistema imunológico faz isso todos os dias.
Agora, imagine aplicar esse mesmo nível de inteligência para resolver problemas complexos de computação. Com ossistemas imunológicos artificiais (AIS) do , podemos fazer exatamente isso.
O que são sistemas imunológicos artificiais?
Os sistemas imunológicos artificiais são modelos computacionais avançados inspirados na capacidade do sistema imunológico humano de proteger o corpo contra danos.
O sistema imunológico humano
O sistema imunológico é o mecanismo de defesa do nosso corpo, projetado para reconhecer e neutralizar ameaças como bactérias, vírus e fungos. Isso é feito por meio de alguns agentes importantes: anticorpos, células B e células T.
Anticorpos atuam como unidades de identificação do sistema imunológico. Essas proteínas especializadas reconhecem e se ligam a substâncias estranhas específicas, chamadas deantígenos , marcando-as como ameaças. Cada anticorpo é único, projetado para corresponder a um antígeno específico, como uma fechadura e uma chave.
Células B são as fábricas que produzem anticorpos. Eles também estão envolvidos na criação de células de memória. Eles ajudam o corpo a responder mais rapidamente a antígenos encontrados anteriormente, lembrando quais anticorpos foram úteis da última vez.
Células T são os reforçadores do sistema imunológico. Eles detectam e destroem células sinalizadas por anticorpos como infectadas ou perigosas, garantindo que a ameaça seja rapidamente neutralizada.
Uma das características mais notáveis do sistema imunológico é sua capacidade de evoluir e aprimorar novos anticorpos ao longo do tempo. Ao se deparar com um novo patógeno, o sistema imunológico não responde apenas uma vez. Ele refina continuamente sua abordagem, criando anticorpos mais fortes e mais eficazes para lidar com a ameaça.
Como esses conceitos biológicos se traduzem em AIS
Os sistemas imunológicos artificiais (AIS) são a implementação desses princípios biológicos em algoritmos. O AIS imita as funções do sistema imunológico na solução de problemas.
No AIS, os antígenos representam os problemas ou desafios a serem abordados. Isso pode ser qualquer coisa, desde a detecção de anomalias nos dados até a otimização de uma solução.
Os anticorpos em AIS são candidatos a soluções para esses problemas. Da mesma forma que os anticorpos biológicos reconhecem antígenos específicos, o AIS desenvolve soluções potenciais adaptadas a desafios específicos.
O processo das células B na AIS reflete como os sistemas biológicos geram diversidade e memória. Os algoritmos AIS usam diversas soluções candidatas e as refinam com o tempo. Eles aprendem com problemas anteriores para melhorar o desempenho futuro.
Os sistemas imunológicos artificiais não têm um análogo direto às células T, mas incorporam mecanismos de avaliação que desempenham uma função semelhante. Esses processos eliminam soluções ineficazes e ajustam as que têm melhor desempenho.
O AIS usa princípios evolutivos, como mutação e seleção, para melhorar continuamente a qualidade das soluções.
Conceitos-chave em sistemas imunológicos artificiais
Os sistemas imunológicos artificiais incorporam conceitos importantes como interação antígeno-anticorpo, seleção clonal, seleção negativa e teoria da rede imunológica.
Interação anticorpo-antígeno
O conceito de interação anticorpo-antígeno é parte integrante dos sistemas imunológicos artificiais. Esse processo é diretamente inspirado na forma como nosso sistema imunológico responde a ameaças. Pense nos anticorpos como possíveis soluções para um problema e nos antígenos como os próprios problemas ou desafios.
No mundo biológico, os anticorpos são proteínas que se prendem a antígenos e os neutralizam. No AIS, um anticorpo representa uma solução candidata para um problema de computação, enquanto o antígeno representa o problema que precisa ser resolvido.
O algoritmo AIS desenvolve uma população desses anticorpos para reconhecer e neutralizar efetivamente os antígenos correspondentes. Com o tempo, o algoritmo ajusta esses anticorpos, aperfeiçoando as soluções mais eficazes.
Algoritmo de seleção clonal (CSA)
O algoritmo de seleção clonal (CSA) é inspirado em outro processo crítico do nosso sistema imunológico. Quando o corpo detecta um antígeno, ele não utiliza qualquer célula imunológica aleatória; ele seleciona aquelas que podem reconhecer especificamente o invasor. Essas células selecionadas são então clonadas em grande número para montar uma defesa eficaz.
Esses clones sofrem mutações, introduzindo pequenas variações que aumentam a diversidade da resposta imunológica. Isso garante que, mesmo que o patógeno evolua, o sistema imunológico possa se adaptar e responder de forma eficaz.
Da mesma forma, o algoritmo de seleção clonal seleciona as soluções mais promissoras e cria várias cópias ou "clones" delas.
Esses clones são então submetidos a mutações, gerando um conjunto diversificado de possíveis soluções. Os clones com melhor desempenho são mantidos e o processo se repete, melhorando gradualmente a qualidade das soluções. Esse algoritmo é particularmente eficiente em tarefas de otimização, em que o objetivo é encontrar a solução mais eficiente entre várias possibilidades.
O CSA é usado com frequência para resolver problemas de otimização. Por exemplo, no setor aeroespacial, ele pode ajudar a projetar estruturas eficientes, como asas de avião, melhorando as propriedades aerodinâmicas em várias iterações.
Na geração de imagens médicas, a CSA pode melhorar a nitidez da imagem ou detectar padrões irregulares em ambientes ruidosos, o que a torna útil para exames de ressonância magnética ou detecção de tumores.
Algoritmo de seleção negativa (NSA)
O sistema imunológico humano deve distinguir entre as células do corpo e os invasores estranhos. É nesse ponto que o algoritmo de seleção negativa (NSA) entra em ação. As células imunológicas que reagem muito fortemente às células do próprio corpo são eliminadas. Isso ajuda a garantir que o sistema imunológico não ataque a si mesmo por engano (causando uma doença autoimune).
A NSA imita esse processo para identificar anomalias ou discrepâncias nos dados. O algoritmo gera um conjunto de modelos, chamados detectores, projetados para reconhecer padrões normais nos dados. Todos os detectores que se aproximam dos dados normais são eliminados, deixando para trás apenas aqueles que não correspondem aos padrões típicos. Esses detectores restantes são usados para monitorar novos dados.
Se esses detectores atípicos sinalizarem um novo ponto de dados, ele o indicará como uma anomalia. Isso é semelhante à forma como o sistema imunológico detecta invasores estrangeiros. Esse método é altamente eficaz em áreas como segurança cibernéticaem que a detecção de padrões incomuns é fundamental para identificar possíveis ameaças.
A NSA é adequada para sistemas de detecção de intrusão que monitoram o tráfego da rede, identificando atividades mal-intencionadas por meio da comparação de padrões normais com os de possíveis ameaças.
A NSA também pode ser aplicada para detectar falhas mecânicas ou operacionais em sistemas complexos, como usinas de energia.
Teoria da rede imunológica (INT)
A teoria da rede imunológica (INT) amplia o conceito de AIS, modelando não apenas a interação entre anticorpos e antígenos, mas também as interações entre os próprios anticorpos.
No sistema imunológico biológico, os anticorpos não funcionam de forma isolada. Eles se comunicam e influenciam uns aos outros, criando uma rede dinâmica de respostas que é mais robusta e adaptável. Essa interação em rede ajuda o sistema imunológico a manter um equilíbrio, garantindo que ele possa responder de forma eficaz a uma ampla gama de ameaças sem reagir exageradamente a nenhuma delas.
A INT é usada para modelar interações e dependências complexas entre diferentes soluções. Isso permite que o algoritmo considere uma gama mais ampla de respostas possíveis, levando a estratégias mais sofisticadas de solução de problemas.
Ao simular como os anticorpos influenciam uns aos outros, o AIS pode explorar vários caminhos para uma solução simultaneamente, melhorando sua capacidade de encontrar soluções ideais em ambientes complexos e dinâmicos. Essa teoria é a base de alguns dos algoritmos AIS mais avançados, o que a torna uma ferramenta poderosa para enfrentar desafios computacionais complexos.
A teoria da rede imunológica pode ser aplicada ao controle de enxames robóticos. As interações entre robôs imitam as interações entre anticorpos, permitindo um comportamento coordenado e a solução de problemas em tarefas como missões de busca e salvamento.
Em finanças, os modelos de rede imune podem ser usados para estudar as interações entre vários indicadores econômicos, permitindo a previsão de tendências de mercado ou a detecção de anomalias financeiras.
Implementação em Python de sistemas imunológicos artificiais
O Python costuma ser a linguagem escolhida para a criação de sistemas imunológicos artificiais devido às suas bibliotecas abrangentes e à facilidade de uso.
Implementação do algoritmo de seleção clonal
O algoritmo de seleção clonal é inspirado no processo biológico em que as células imunológicas que reconhecem com sucesso uma ameaça são clonadas e, em seguida, sofrem mutação para melhorar a resposta imunológica. Na AIS, essas "células imunológicas" são soluções candidatas para um problema, e o objetivo é evoluir essas soluções para encontrar a melhor.
Veja como você pode implementar uma versão simples do CSA em Python:
- Inicialize a população: Comece criando uma população de soluções aleatórias. Se você estiver trabalhando em um problema de otimização, essas soluções podem ser pontos aleatórios no espaço de pesquisa. Cada solução é análoga a um anticorpo no sistema imunológico.
- Avalie o condicionamento físico: Em seguida, avalie a adequação de cada solução. A adequação é uma medida de quão bem uma solução resolve o problema. Em termos biológicos, isso é semelhante à capacidade de um anticorpo neutralizar um antígeno. A função de adequação usada dependerá do problema específico que você está resolvendo.
- Selecione as melhores soluções: Com base em sua adequação, selecione as melhores soluções para clonagem. Esse processo de seleção é semelhante ao sistema imunológico que seleciona os anticorpos mais eficazes para combater um patógeno.
- Clonagem e mutação: Crie várias cópias, ou clones, das soluções selecionadas. Em seguida, introduza mutações nesses clones, alterando ligeiramente seus valores. Essa etapa é importante porque introduz diversidade na população, permitindo que o algoritmo explore diferentes áreas do espaço de solução.
- Substituir e iterar: Substitua as soluções de pior desempenho na população pelos clones recém-mutados. Repita o processo por um número específico de gerações ou até que as soluções convirjam para um valor ideal ou quase ideal.
Vamos resolver um problema de otimização de função usando o CSA. Otimizaremos uma função de referência bem conhecida, a função Rastrigin. Essa função pode ser usada para testar algoritmos de otimização devido a seus muitos mínimos locais.
No código abaixo, usamos um CSA para encontrar os mínimos globais da função:
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()
O gráfico acima mostra como o CSA encontrou soluções melhores para a função Rastrigin a cada geração.
Este gráfico mostra o gráfico de Rastrigin, demonstrando seus vários mínimos locais. A melhor solução, o ponto vermelho no meio, é a solução final encontrada pela CSA.
Implementação do algoritmo de seleção negativa
A NSA é particularmente útil para tarefas de detecção de anomalias. Esse algoritmo simula como o sistema imunológico distingue entre as células do próprio corpo e os invasores estranhos. Em uma NSA, você gera um conjunto de detectores que não correspondem aos padrões de dados normais. Esses detectores são então usados para monitorar novos dados, sinalizando qualquer coisa que pareça anômala.
Esta é uma visão geral de como você pode criar uma NSA:
- Gerar dados próprios: Comece definindo o que constitui "self" em seus dados. Esse pode ser um conjunto de dados de comportamentos ou padrões normais e esperados. O objetivo é criar detectores que não correspondam a esses dados próprios.
- Crie detectores: Gere detectores aleatórios e compare-os com os dados próprios. Qualquer detector que corresponda aos dados próprios é descartado. Os detectores restantes são mantidos para monitorar anomalias.
- Monitorar novos dados: Quando novos dados chegarem, compare-os com os detectores retidos. Se um detector reconhecer os novos dados como não próprios, os dados serão sinalizados como uma anomalia.
Vamos ver como isso funciona usando um conjunto fictício de transações. Neste exemplo, geramos transações normais centralizadas em dois clusters e transações fraudulentas espalhadas aleatoriamente. Empregaremos um algoritmo de seleção negativa, em que os detectores de fraude estão espalhados pelo espaço de recursos para identificar anomalias com base em sua proximidade com esses detectores.
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()
Aqui, os detectores de fraude são distribuídos pelo espaço de recursos para cobrir áreas em que as transações normais não aparecem. As transações fraudulentas que se aproximam desses detectores são identificadas e sinalizadas como anomalias.
Esse gráfico ilustra o limite de decisão criado pelos detectores de fraude. As regiões sombreadas representam áreas classificadas como anômalas com base na proximidade dos detectores, destacando onde as transações fraudulentas são detectadas em relação às transações normais. Para ajustar o limite de decisão e cobrir mais ou menos área, você pode modificar o limite de distância usado para detectar anomalias, o que expandirá ou contrairá as regiões classificadas como anômalas.
Implementação da teoria da rede imunológica
A INT é inspirada na ideia de que as respostas imunológicas não se baseiam apenas em anticorpos individuais, mas também em sua comunicação. Essa abordagem modela o sistema imunológico como uma rede em que os anticorpos se comunicam para aprimorar a resposta imunológica geral. Nesse contexto, cada anticorpo (solução) pode interagir com outros para influenciar e refinar a busca por soluções ideais.
Veja como você pode implementar uma versão básica do INT em Python:
- Inicialize a população: Crie uma população inicial de soluções aleatórias, semelhante aos algoritmos anteriores. Cada solução representa um anticorpo na rede.
- Avalie o condicionamento físico: Avalie a adequação de cada solução para determinar se ela resolve bem o problema. Essa etapa é análoga ao desempenho de um anticorpo no reconhecimento e na ligação a um antígeno.
- Estabeleça conexões: Crie uma rede em que os anticorpos (soluções) sejam conectados com base em sua similaridade ou proximidade. As conexões representam a comunicação entre os anticorpos, permitindo que eles influenciem uns aos outros.
- Atualizar soluções: Iterar pela rede e atualizar as soluções com base nas interações com os anticorpos conectados. Esse processo simula como os anticorpos influenciam uns aos outros para refinar a resposta imunológica.
- Substituir e iterar: Substitua as soluções de pior desempenho por soluções atualizadas da rede. Continue o processo por um número especificado de iterações ou até que as soluções convirjam para um valor ideal ou quase ideal.
Vamos usar a INT para prever as tendências do mercado de ações com base em um conjunto de indicadores econômicos. Usaremos um conjunto de dados fictício em que cada solução representa uma combinação de indicadores para a previsão de preços de ações.
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()
Esse gráfico mostra o erro quadrático médio (MSE) diminuindo ao longo do tempo, indicando que as previsões do modelo estão ficando mais precisas.
Esse gráfico de dispersão compara os preços reais das ações com as previsões do modelo. Os pontos mais próximos da linha tracejada vermelha mostram previsões mais precisas.
Como os sistemas imunológicos artificiais se comparam a outras técnicas de IA?
O AIS é uma das muitas técnicas de aprendizado de máquina que se inspiram na biologia.
Redes neurais
Redes neurais são inspiradas no cérebro humano e são excelentes para aprender com grandes conjuntos de dados. Eles são usados para tarefas como reconhecimento de imagens e processamento de linguagem natural. Eles dependem de treinamento extensivo com grandes quantidades de dados para ajustar os pesos dos neurônios interconectados.
Por outro lado, os sistemas imunológicos artificiais se concentram na adaptabilidade e na solução descentralizada de problemas sem a necessidade de grandes conjuntos de dados. O AIS imita a capacidade do sistema imunológico de reconhecer e responder a novos desafios em tempo real, o que o torna adequado para ambientes dinâmicos em que a adaptação rápida é crucial.
Algoritmos genéticos
Os algoritmos genéticos, inspirados na evolução natural, são eficazes para otimizar problemas complexos, desenvolvendo uma população de soluções por meio de seleção, cruzamento e mutação. Esse processo é semelhante ao da CSA.
No entanto, enquanto os algoritmos genéticos dependem de operadores genéticos para explorar o espaço da solução, a CSA adapta as soluções imitando as respostas imunológicas, oferecendo flexibilidade para lidar com desafios novos e inesperados. O AIS, incluindo o CSA, é particularmente eficaz em ambientes dinâmicos em que a adaptação rápida e o aprendizado contínuo são cruciais.
Você pode ler mais sobre algoritmos genéticos em Genetic Algorithm: Guia completo com implementação em Python.
Algoritmos de inteligência de enxame
Os algoritmos de inteligência de enxame são inspirados no comportamento coletivo de organismos sociais, como formigas e abelhas. Eles usam sistemas descentralizados e interações simples de agentes para obter uma otimização global complexa.
Isso é semelhante, em espírito, à INT. Ambas as abordagens se concentram em manter a diversidade e a adaptabilidade em um sistema para tratar de problemas de otimização. Enquanto a inteligência de enxame enfatiza as interações baseadas em agentes, a INT utiliza mecanismos semelhantes às respostas imunológicas, oferecendo métodos complementares para a solução dinâmica de problemas.
Você pode ler mais sobre algoritmos de inteligência de enxame em Swarm Intelligence Algorithms: Três implementações do Python.
Pesquisa atual em sistemas imunológicos artificiais
Os sistemas imunológicos artificiais são promissores para resolver problemas complexos em vários domínios. Os pesquisadores estão trabalhando para aprimorar esses sistemas e torná-los ainda mais úteis.
Uma área que os pesquisadores estão explorando é como criar modelos híbridos que combinem o AIS com outras técnicas de inteligência computacional. A expectativa é que esses modelos híbridos sejam mais robustos e versáteis.
Essas abordagens híbridas visam usar os pontos fortes de cada método, como os recursos adaptativos do AIS e os poderosos mecanismos de aprendizado das redes neurais. Para obter mais informações, confira Sistemas imunológicos artificiais.
Outra área de pesquisa ativa envolve a aplicação do AIS a novos domínios. Embora tradicionalmente usado em segurança cibernética e otimização, o AIS agora está sendo explorado em campos como robótica, bioinformática e até mesmo modelagem financeira. A adaptabilidade e a natureza descentralizada do AIS o tornam um candidato promissor para a solução de problemas nesses ambientes dinâmicos e muitas vezes imprevisíveis. Para obter mais informações, recomendo que você leia Computação inspirada na natureza: Escopo e aplicações de sistemas imunológicos artificiais para análise e diagnóstico de problemas complexos.
Os modelos AIS não apenas oferecem técnicas computacionais aprimoradas, mas também podem contribuir para o nosso entendimento dos sistemas imunológicos reais. Eles estão avançando nas estratégias de imunoterapia para doenças como câncer e distúrbios autoimunes. Dê uma olhada nesta colaboração entre a Cleveland Clinic e a IBM para você saber mais.
Conclusão
Os sistemas imunológicos artificiais oferecem uma abordagem exclusiva para solucionar problemas complexos, inspirando-se no sistema imunológico humano. Ao emular processos biológicos como reconhecimento de padrões, adaptação e memória, o AIS oferece soluções versáteis em campos que vão desde a segurança cibernética até a otimização.

Sou PhD e tenho 13 anos de experiência trabalhando com dados em um ambiente de pesquisa biológica. Crio software em várias linguagens de programação, incluindo Python, MATLAB e R. Sou apaixonado por compartilhar meu amor pelo aprendizado com o mundo.
Você quer começar a usar a IA generativa?
Saiba como trabalhar com LLMs em Python diretamente em seu navegador

Aprenda IA com estes cursos!
curso
Large Language Models (LLMs) Concepts
programa
Developing AI Applications
blog
Python no setor de saúde: Aplicativos de IA em hospitais
Armstrong Asenavi
18 min

blog
O que é IA? Um guia rápido para iniciantes
blog
IA na segurança cibernética: Perspectiva de um pesquisador

Natasha Al-Khatib
14 min
blog
IA na área farmacêutica: benefícios, desafios e percepções
tutorial
Criando agentes LangChain para automatizar tarefas em Python
tutorial