Hệ Miễn Dịch Nhân Tạo (AIS): Hướng Dẫn Kèm Ví Dụ Python

Hãy tưởng tượng một hệ thống có thể nhận diện và vô hiệu hóa các mối đe dọa mà nó chưa từng gặp trước đó, đồng thời ghi nhớ những kẻ xâm nhập trong quá khứ để đẩy lùi chúng hiệu quả hơn. Hệ miễn dịch của bạn làm điều này mỗi ngày. 

Giờ hãy tưởng tượng áp dụng mức độ thông minh đó để giải quyết các bài toán tính toán phức tạp. Với hệ miễn dịch nhân tạo (AIS), chúng ta có thể làm được điều đó.

Hệ Miễn Dịch Nhân Tạo Là Gì?

Hệ miễn dịch nhân tạo là các mô hình tính toán mạnh mẽ lấy cảm hứng từ khả năng bảo vệ cơ thể khỏi tổn hại của hệ miễn dịch con người.

Hệ miễn dịch của con người

Hệ miễn dịch là cơ chế phòng vệ của cơ thể, được thiết kế để nhận diện và vô hiệu hóa các mối đe dọa như vi khuẩn, virus và nấm. Nó vận hành nhờ một số thành phần chủ chốt: kháng thể, tế bào B và tế bào T.

Kháng thể đóng vai trò là đơn vị nhận diện của hệ miễn dịch. Những protein chuyên biệt này nhận biết và bám vào các tác nhân lạ cụ thể, gọi là kháng nguyên, gắn nhãn chúng là mối đe dọa. Mỗi kháng thể là duy nhất, được thiết kế để khớp với một kháng nguyên cụ thể, giống như ổ khóa và chìa khóa.

Tế bào B là “nhà máy” sản xuất kháng thể. Chúng cũng tham gia tạo ra các tế bào ghi nhớ, giúp cơ thể phản ứng nhanh hơn với những kháng nguyên đã gặp trước đó bằng cách ghi nhớ các kháng thể hữu ích từ lần trước.

Tế bào T là lực lượng chấp pháp của hệ miễn dịch. Chúng phát hiện và tiêu diệt các tế bào bị kháng thể gắn cờ là nhiễm bệnh hoặc nguy hiểm, đảm bảo mối đe dọa bị vô hiệu nhanh chóng.

Một trong những đặc điểm đáng kinh ngạc của hệ miễn dịch là khả năng tiến hóa và cải thiện các kháng thể mới theo thời gian. Khi đối mặt với một mầm bệnh mới, hệ miễn dịch không chỉ phản ứng một lần. Nó liên tục tinh chỉnh cách tiếp cận, tạo ra các kháng thể mạnh hơn và hiệu quả hơn để xử lý mối đe dọa.

Cách các khái niệm sinh học này chuyển hóa thành AIS

Hệ miễn dịch nhân tạo (AIS) là việc hiện thực hóa các nguyên lý sinh học này thành thuật toán. AIS mô phỏng chức năng của hệ miễn dịch trong giải quyết vấn đề.

Trong AIS, kháng nguyên đại diện cho các bài toán hoặc thách thức cần giải quyết. Chúng có thể là bất cứ thứ gì, từ phát hiện bất thường trong dữ liệu đến tối ưu hóa một lời giải.

Kháng thể trong AIS là các phương án lời giải ứng cử cho những vấn đề đó. Tương tự như kháng thể sinh học nhận diện kháng nguyên cụ thể, AIS tiến hóa các phương án lời giải tiềm năng phù hợp với các thách thức cụ thể.

Quy trình tế bào B trong AIS phản chiếu cách hệ sinh học tạo ra đa dạng và trí nhớ. Thuật toán AIS sử dụng các lời giải đa dạng và tinh chỉnh chúng theo thời gian. Chúng học từ các lần gặp vấn đề trước đó để cải thiện hiệu suất trong tương lai.

AIS không có phép so sánh trực tiếp với tế bào T, nhưng chúng tích hợp các cơ chế đánh giá đóng vai trò tương tự. Những quy trình này loại bỏ các lời giải kém hiệu quả và tinh chỉnh những lời giải hoạt động tốt hơn.

AIS sử dụng các nguyên lý tiến hóa, như đột biến và chọn lọc, để liên tục cải thiện chất lượng lời giải.

Các Khái Niệm Chính Trong Hệ Miễn Dịch Nhân Tạo

Hệ miễn dịch nhân tạo bao gồm các khái niệm chủ chốt như tương tác kháng thể–kháng nguyên, chọn lọc dòng (clonal selection), chọn lọc âm (negative selection) và lý thuyết mạng miễn dịch.

Tương tác kháng thể–kháng nguyên

Trung tâm của hệ miễn dịch nhân tạo là khái niệm tương tác kháng thể–kháng nguyên. Quy trình này được lấy cảm hứng trực tiếp từ cách hệ miễn dịch của chúng ta phản ứng với mối đe dọa. Hãy coi kháng thể là các phương án lời giải tiềm năng cho một vấn đề và kháng nguyên là chính các vấn đề hoặc thách thức đó.

Trong thế giới sinh học, kháng thể là các protein bám vào kháng nguyên và vô hiệu hóa chúng. Trong AIS, một kháng thể đại diện cho một phương án lời giải ứng cử cho một bài toán tính toán, trong khi kháng nguyên đại diện cho vấn đề cần giải quyết.

Thuật toán AIS tiến hóa một quần thể các kháng thể này để nhận diện và vô hiệu hóa hiệu quả các kháng nguyên tương ứng. Theo thời gian, thuật toán tinh chỉnh các kháng thể, tập trung vào những lời giải hiệu quả nhất.

Thuật toán chọn lọc dòng (CSA)

Thuật toán chọn lọc dòng (CSA) lấy cảm hứng từ một quá trình quan trọng khác trong hệ miễn dịch của chúng ta. Khi cơ thể phát hiện kháng nguyên, nó không triển khai ngẫu nhiên các tế bào miễn dịch; nó chọn ra những tế bào có thể nhận diện kẻ xâm nhập một cách đặc hiệu. Những tế bào được chọn sau đó được nhân bản với số lượng lớn để tạo nên phản ứng phòng vệ hiệu quả.

Các bản sao này trải qua đột biến, tạo ra các biến thể nhỏ làm tăng tính đa dạng của phản ứng miễn dịch. Điều này đảm bảo rằng ngay cả khi tác nhân gây bệnh tiến hóa, hệ miễn dịch vẫn có thể thích nghi và phản ứng hiệu quả.

Tương tự, thuật toán chọn lọc dòng lựa chọn các lời giải triển vọng nhất và tạo nhiều bản sao hay "clones" của chúng.

Các bản sao này sau đó được đưa vào đột biến, tạo nên một tập hợp đa dạng các lời giải tiềm năng. Những bản sao hoạt động tốt nhất được giữ lại, và quy trình lặp lại, dần dần cải thiện chất lượng lời giải. Thuật toán này đặc biệt mạnh trong các bài toán tối ưu hóa, nơi mục tiêu là tìm lời giải hiệu quả nhất trong nhiều khả năng.

CSA thường được dùng để giải các bài toán tối ưu. Ví dụ, trong hàng không vũ trụ, nó có thể giúp thiết kế các cấu trúc hiệu quả như cánh máy bay bằng cách cải thiện đặc tính khí động học qua nhiều vòng lặp.

Trong lĩnh vực chẩn đoán hình ảnh y khoa, CSA có thể tăng độ rõ của ảnh hoặc phát hiện các mẫu bất thường trong môi trường nhiễu, hữu ích cho chụp MRI hoặc phát hiện khối u.

Thuật toán chọn lọc âm (NSA)

Hệ miễn dịch con người phải phân biệt giữa các tế bào của cơ thể và kẻ xâm nhập từ bên ngoài. Đây là lúc thuật toán chọn lọc âm (NSA) phát huy tác dụng. Những tế bào miễn dịch phản ứng quá mạnh với chính tế bào cơ thể sẽ bị loại bỏ. Điều này giúp đảm bảo hệ miễn dịch không nhầm lẫn tấn công chính mình (gây bệnh tự miễn).

NSA mô phỏng quá trình này để nhận diện các điểm bất thường hay ngoại lai trong dữ liệu. Thuật toán tạo ra một tập mô hình, gọi là bộ dò (detector), được thiết kế để nhận biết các mẫu bình thường trong dữ liệu. Bất kỳ bộ dò nào khớp chặt với dữ liệu bình thường sẽ bị loại, chỉ giữ lại những bộ dò không khớp với các mẫu điển hình. Các bộ dò còn lại sẽ được dùng để giám sát dữ liệu mới.

Nếu những bộ dò khác thường này gắn cờ một điểm dữ liệu mới, điều đó cho thấy đó là một bất thường. Điều này tương tự cách hệ miễn dịch phát hiện kẻ xâm nhập. Phương pháp này rất hiệu quả trong các lĩnh vực như an ninh mạng, nơi việc phát hiện các mẫu bất thường là chìa khóa để nhận diện các mối đe dọa tiềm ẩn.

NSA rất phù hợp với các hệ thống phát hiện xâm nhập giám sát lưu lượng mạng, xác định hoạt động độc hại bằng cách so sánh các mẫu bình thường với các mẫu của mối đe dọa tiềm ẩn.

NSA cũng có thể được áp dụng để phát hiện lỗi cơ khí hoặc vận hành trong các hệ thống phức tạp như nhà máy điện.

Lý thuyết mạng miễn dịch (INT)

Lý thuyết mạng miễn dịch (INT) mở rộng khái niệm AIS bằng cách mô hình hóa không chỉ tương tác giữa kháng thể và kháng nguyên mà còn cả tương tác giữa các kháng thể với nhau.

Trong hệ miễn dịch sinh học, các kháng thể không hoạt động biệt lập. Chúng giao tiếp và ảnh hưởng lẫn nhau, tạo nên một mạng lưới phản ứng năng động, vững vàng và thích ứng. Sự tương tác theo mạng này giúp hệ miễn dịch duy trì cân bằng, đảm bảo có thể phản ứng hiệu quả với nhiều mối đe dọa mà không phản ứng thái quá với bất kỳ mối đe dọa đơn lẻ nào.

INT được dùng để mô hình hóa các tương tác và phụ thuộc phức tạp giữa các lời giải khác nhau. Điều này cho phép thuật toán xem xét phổ rộng hơn các phản hồi khả dĩ, dẫn đến những chiến lược giải quyết vấn đề tinh vi hơn.

Bằng cách mô phỏng cách các kháng thể ảnh hưởng lẫn nhau, AIS có thể đồng thời khám phá nhiều con đường tới lời giải, nâng cao khả năng tìm ra lời giải tối ưu trong các môi trường phức tạp và năng động. Lý thuyết này là nền tảng cho một số thuật toán AIS tiên tiến nhất, trở thành công cụ mạnh mẽ để xử lý các thách thức tính toán tinh vi.

Lý thuyết mạng miễn dịch có thể được áp dụng để điều khiển bầy robot. Các tương tác giữa robot mô phỏng tương tác giữa các kháng thể, cho phép hành vi phối hợp và giải quyết vấn đề trong các nhiệm vụ như tìm kiếm và cứu nạn.

Trong tài chính, các mô hình mạng miễn dịch có thể được dùng để nghiên cứu tương tác giữa các chỉ báo kinh tế khác nhau, cho phép dự đoán xu hướng thị trường hoặc phát hiện bất thường tài chính.

Triển Khai Hệ Miễn Dịch Nhân Tạo Bằng Python

Python thường là ngôn ngữ được lựa chọn khi xây dựng hệ miễn dịch nhân tạo nhờ thư viện phong phú và dễ sử dụng.

Triển khai thuật toán chọn lọc dòng

Thuật toán chọn lọc dòng được truyền cảm hứng từ quá trình sinh học, trong đó các tế bào miễn dịch nhận diện thành công mối đe dọa sẽ được nhân bản và sau đó đột biến để cải thiện phản ứng miễn dịch. Trong AIS, những “tế bào miễn dịch” này là các lời giải ứng cử cho một vấn đề, và mục tiêu là tiến hóa các lời giải này để tìm ra lời giải tốt nhất.

Dưới đây là cách bạn có thể triển khai phiên bản đơn giản của CSA trong Python:

1. Khởi tạo quần thể: Bắt đầu bằng cách tạo một quần thể lời giải ngẫu nhiên. Nếu bạn đang xử lý bài toán tối ưu, các lời giải này có thể là những điểm ngẫu nhiên trong không gian tìm kiếm. Mỗi lời giải tương tự một kháng thể trong hệ miễn dịch.
2. Đánh giá độ thích nghi: Tiếp theo, đánh giá độ thích nghi của mỗi lời giải. Độ thích nghi đo lường mức độ một lời giải giải quyết vấn đề tốt đến đâu. Theo nghĩa sinh học, điều này tương tự mức độ một kháng thể có thể vô hiệu hóa một kháng nguyên. Hàm đánh giá bạn dùng sẽ phụ thuộc vào vấn đề cụ thể mà bạn đang giải.
3. Chọn các lời giải tốt nhất: Dựa trên độ thích nghi, chọn các lời giải tốt nhất để nhân bản. Quy trình chọn này giống như hệ miễn dịch chọn ra những kháng thể hiệu quả nhất để chống lại mầm bệnh.
4. Nhân bản và đột biến: Tạo nhiều bản sao của các lời giải đã chọn. Sau đó, đưa vào đột biến cho các bản sao này bằng cách thay đổi nhẹ các giá trị của chúng. Bước này quan trọng vì nó đưa sự đa dạng vào quần thể, cho phép thuật toán khám phá các vùng khác nhau của không gian lời giải.
5. Thay thế và lặp lại: Thay thế các lời giải hoạt động kém nhất trong quần thể bằng các bản sao đã đột biến mới. Lặp lại quy trình trong số thế hệ được chỉ định hoặc cho đến khi các lời giải hội tụ đến giá trị tối ưu hoặc gần tối ưu.

Hãy giải một bài toán tối ưu hàm bằng CSA. Chúng ta sẽ tối ưu một hàm chuẩn đánh giá quen thuộc, hàm Rastrigin. Hàm này được dùng để kiểm thử các thuật toán tối ưu do có nhiều cực tiểu cục bộ.

Trong đoạn mã dưới đây, chúng ta dùng CSA để tìm cực tiểu toàn cục của hàm:

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()Được hỗ trợ bởi

Biểu đồ trên cho thấy CSA đã tìm được các lời giải tốt hơn cho hàm Rastrigin qua mỗi thế hệ.

Biểu đồ này thể hiện đồ thị của hàm Rastrigin, cho thấy nhiều cực tiểu cục bộ. Lời giải tốt nhất, chấm đỏ ở giữa, là kết quả cuối cùng do CSA tìm được.

Triển khai thuật toán chọn lọc âm

NSA đặc biệt hữu ích cho các tác vụ phát hiện bất thường. Thuật toán này mô phỏng cách hệ miễn dịch phân biệt giữa tế bào của cơ thể và kẻ xâm nhập. Trong NSA, bạn tạo ra một tập bộ dò không khớp với các mẫu dữ liệu bình thường. Các bộ dò này sau đó được dùng để giám sát dữ liệu mới, gắn cờ bất cứ thứ gì có vẻ bất thường.

Dưới đây là tổng quan cách tạo một NSA:

1. Tạo dữ liệu “tự thân”: Bắt đầu bằng cách xác định thế nào là “tự thân” trong dữ liệu của bạn. Đây có thể là một tập dữ liệu về hành vi hoặc mẫu dự kiến bình thường. Mục tiêu là tạo ra các bộ dò không khớp với dữ liệu tự thân này.
2. Tạo bộ dò: Sinh ngẫu nhiên các bộ dò và so sánh với dữ liệu tự thân. Bất kỳ bộ dò nào khớp với dữ liệu tự thân sẽ bị loại. Các bộ dò còn lại được giữ lại để giám sát bất thường.
3. Giám sát dữ liệu mới: Khi dữ liệu mới đến, so sánh nó với các bộ dò đã giữ lại. Nếu một bộ dò nhận diện dữ liệu mới là không-tự-thân, dữ liệu đó sẽ bị gắn cờ là bất thường.

Hãy xem điều này hoạt động ra sao với một tập giao dịch giả định. Trong ví dụ này, chúng ta tạo các giao dịch bình thường tập trung quanh hai cụm và các giao dịch gian lận rải rác ngẫu nhiên. Chúng ta sẽ sử dụng thuật toán chọn lọc âm, trong đó các bộ dò gian lận được rải khắp không gian đặc trưng để xác định bất thường dựa trên mức độ gần với các bộ dò này.

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()Được hỗ trợ bởi

Tại đây, các bộ dò gian lận được phân bố khắp không gian đặc trưng để bao phủ những khu vực không có giao dịch bình thường. Giao dịch gian lận rơi gần các bộ dò này sẽ được xác định và gắn cờ là bất thường.

Đồ thị này minh họa ranh giới quyết định do các bộ dò gian lận tạo ra. Các vùng được tô bóng biểu thị khu vực được phân loại là bất thường dựa trên độ gần với các bộ dò, làm nổi bật vị trí các giao dịch gian lận được phát hiện so với giao dịch bình thường. Để điều chỉnh ranh giới quyết định và bao phủ nhiều hay ít khu vực hơn, bạn có thể thay đổi ngưỡng khoảng cách dùng để phát hiện bất thường, từ đó mở rộng hoặc thu hẹp các vùng được phân loại là bất thường.

Triển khai lý thuyết mạng miễn dịch

INT được truyền cảm hứng từ ý tưởng rằng phản ứng miễn dịch không chỉ dựa trên từng kháng thể riêng lẻ mà còn trên sự giao tiếp của chúng. Cách tiếp cận này mô hình hóa hệ miễn dịch như một mạng lưới nơi các kháng thể giao tiếp để tăng cường phản ứng chung. Trong ngữ cảnh này, mỗi kháng thể (lời giải) có thể tương tác với những cái khác để ảnh hưởng và tinh chỉnh việc tìm kiếm lời giải tối ưu.

Dưới đây là cách bạn có thể triển khai phiên bản cơ bản của INT trong Python:

1. Khởi tạo quần thể: Tạo quần thể ban đầu gồm các lời giải ngẫu nhiên, tương tự các thuật toán trước. Mỗi lời giải đại diện cho một kháng thể trong mạng.
2. Đánh giá độ thích nghi: Đánh giá độ thích nghi của mỗi lời giải để xác định mức độ giải quyết vấn đề. Bước này tương tự mức độ một kháng thể nhận diện và gắn với kháng nguyên.
3. Thiết lập kết nối: Tạo một mạng trong đó các kháng thể (lời giải) được kết nối dựa trên độ tương đồng hoặc khoảng cách. Các kết nối đại diện cho sự giao tiếp giữa các kháng thể, cho phép chúng ảnh hưởng lẫn nhau.
4. Cập nhật lời giải: Lặp qua mạng và cập nhật các lời giải dựa trên tương tác với các kháng thể được kết nối. Quy trình này mô phỏng cách các kháng thể ảnh hưởng lẫn nhau để tinh chỉnh phản ứng miễn dịch.
5. Thay thế và lặp lại: Thay thế các lời giải hoạt động kém nhất bằng các lời giải đã cập nhật từ mạng. Tiếp tục quy trình trong số vòng lặp được chỉ định hoặc cho đến khi các lời giải hội tụ đến giá trị tối ưu hoặc gần tối ưu.

Hãy dùng INT để dự đoán xu hướng thị trường chứng khoán dựa trên một tập chỉ báo kinh tế. Chúng ta sẽ dùng tập dữ liệu hư cấu, trong đó mỗi lời giải đại diện cho một tổ hợp các chỉ báo để dự báo giá cổ phiếu.

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()Được hỗ trợ bởi

Biểu đồ này cho thấy Sai số Bình phương Trung bình (MSE) giảm theo thời gian, cho thấy dự đoán của mô hình ngày càng chính xác hơn.

Biểu đồ phân tán này so sánh giá cổ phiếu thực tế với dự đoán của mô hình. Các điểm càng gần đường gạch đỏ thể hiện dự đoán càng chính xác.

Hệ Miễn Dịch Nhân Tạo So Với Các Kỹ Thuật AI Khác Như Thế Nào?

AIS là một trong nhiều kỹ thuật học máy lấy cảm hứng từ sinh học.

Mạng nơ-ron

Mạng nơ-ron lấy cảm hứng từ não người và xuất sắc trong việc học từ các tập dữ liệu lớn. Chúng được dùng cho các tác vụ như nhận diện ảnh và xử lý ngôn ngữ tự nhiên. Chúng dựa vào việc huấn luyện chuyên sâu với lượng dữ liệu khổng lồ để điều chỉnh trọng số của các nơ-ron liên kết.

Ngược lại, hệ miễn dịch nhân tạo tập trung vào khả năng thích ứng và giải quyết vấn đề phi tập trung mà không cần các tập dữ liệu lớn. AIS mô phỏng khả năng nhận diện và phản ứng với thách thức mới theo thời gian thực của hệ miễn dịch, khiến chúng phù hợp với môi trường động nơi khả năng thích ứng nhanh là tối quan trọng.

Thuật toán di truyền

Thuật toán di truyền, lấy cảm hứng từ tiến hóa tự nhiên, hiệu quả trong việc tối ưu các bài toán phức tạp bằng cách tiến hóa một quần thể lời giải thông qua chọn lọc, lai ghép và đột biến. Quy trình này tương tự CSA.

Tuy nhiên, trong khi thuật toán di truyền dựa trên các toán tử di truyền để khám phá không gian lời giải, CSA thích nghi các lời giải bằng cách mô phỏng phản ứng miễn dịch, mang lại sự linh hoạt trong việc xử lý những thách thức mới và bất ngờ. AIS, bao gồm CSA, đặc biệt hiệu quả trong các môi trường động nơi thích ứng nhanh và học liên tục là then chốt.

Bạn có thể đọc thêm về thuật toán di truyền trong Hướng Dẫn Hoàn Chỉnh Về Thuật Toán Di Truyền Kèm Triển Khai Python.

Thuật toán trí tuệ bầy đàn

Thuật toán trí tuệ bầy đàn lấy cảm hứng từ hành vi tập thể của các sinh vật xã hội như kiến và ong. Chúng sử dụng hệ thống phi tập trung và tương tác đơn giản giữa các tác tử để đạt được tối ưu hóa toàn cục phức tạp.

Điều này tương đồng, về tinh thần, với INT. Cả hai cách tiếp cận đều tập trung vào việc duy trì tính đa dạng và khả năng thích ứng trong một hệ thống để giải quyết các bài toán tối ưu. Trong khi trí tuệ bầy đàn nhấn mạnh tương tác dựa trên tác tử, INT tận dụng các cơ chế giống phản ứng miễn dịch, mang lại các phương pháp bổ trợ cho giải quyết vấn đề động.

Bạn có thể đọc thêm về thuật toán trí tuệ bầy đàn trong Thuật Toán Trí Tuệ Bầy Đàn: Ba Triển Khai Bằng Python.

Nghiên Cứu Hiện Nay Về Hệ Miễn Dịch Nhân Tạo

Hệ miễn dịch nhân tạo hứa hẹn giải quyết các vấn đề phức tạp trên nhiều lĩnh vực. Các nhà nghiên cứu đang nỗ lực nâng cao các hệ thống này để chúng hữu ích hơn nữa.

Một hướng nghiên cứu là cách tạo ra các mô hình lai kết hợp AIS với các kỹ thuật trí tuệ tính toán khác. Kỳ vọng là các mô hình lai này sẽ vững vàng và linh hoạt hơn.

Những cách tiếp cận lai này nhằm tận dụng điểm mạnh của từng phương pháp, như khả năng thích ứng của AIS và cơ chế học mạnh mẽ của mạng nơ-ron. Để biết thêm, hãy xem Artificial Immune Systems.

Một mảng nghiên cứu sôi động khác là ứng dụng AIS vào các lĩnh vực mới. Trong khi truyền thống được dùng trong an ninh mạng và tối ưu hóa, AIS hiện đang được khám phá trong các lĩnh vực như robotics, tin–sinh học và thậm chí mô hình hóa tài chính. Tính thích ứng và bản chất phi tập trung của AIS khiến nó là ứng viên đầy hứa hẹn để giải các vấn đề trong môi trường động và khó lường. Để biết thêm, tôi khuyến khích bạn đọc Nature-Inspired Computing: Scope and Applications of Artificial Immune Systems Toward Analysis and Diagnosis of Complex Problems.

Các mô hình AIS không chỉ mang lại kỹ thuật tính toán nâng cao mà còn có thể đóng góp vào hiểu biết của chúng ta về hệ miễn dịch thực. Chúng đang thúc đẩy các chiến lược miễn dịch trị liệu cho các bệnh như ung thư và rối loạn tự miễn. Xem hợp tác giữa Cleveland Clinic và IBM để tìm hiểu thêm.

Kết Luận

Hệ miễn dịch nhân tạo mang đến một cách tiếp cận độc đáo để giải quyết các vấn đề phức tạp bằng cách lấy cảm hứng từ hệ miễn dịch của con người. Bằng việc mô phỏng các quá trình sinh học như nhận dạng mẫu, thích ứng và ghi nhớ, AIS cung cấp các lời giải linh hoạt trong nhiều lĩnh vực, từ an ninh mạng đến tối ưu hóa.