आर्टिफिशियल इम्यून सिस्टम (AIS): पायथन उदाहरणों के साथ गाइड

कल्पना कीजिए एक ऐसे सिस्टम की जो पहले कभी न देखे गए खतरों की पहचान कर उन्हें निष्क्रिय कर सके और बीते आक्रमणों को याद रखकर अगली बार उनसे और कुशलता से निपट सके। आपका प्रतिरक्षा तंत्र हर दिन यही करता है। 

अब, यही बुद्धिमत्ता जटिल कंप्यूटिंग समस्याओं को हल करने में लगाने की कल्पना कीजिए। आर्टिफिशियल इम्यून सिस्टम (AIS) के साथ, हम यही कर सकते हैं।

आर्टिफिशियल इम्यून सिस्टम क्या हैं?

आर्टिफिशियल इम्यून सिस्टम ऐसे शक्तिशाली संगणकीय मॉडल हैं जो मानव प्रतिरक्षा तंत्र की शरीर की रक्षा करने की क्षमता से प्रेरित हैं।

मानव प्रतिरक्षा तंत्र

प्रतिरक्षा तंत्र हमारे शरीर का रक्षा तंत्र है, जिसे बैक्टीरिया, वायरस और फंगस जैसे खतरों को पहचानकर निष्क्रिय करने के लिए बनाया गया है। यह कुछ प्रमुख घटकों के जरिए ऐसा करता है: एंटीबॉडी, बी-कोशिकाएँ और टी-कोशिकाएँ।

एंटीबॉडी प्रतिरक्षा तंत्र की पहचान इकाइयों की तरह काम करती हैं। ये विशेष प्रोटीन विशिष्ट बाहरी पदार्थों, जिन्हें एंटीजेन कहा जाता है, को पहचानकर उनसे जुड़ जाती हैं और उन्हें खतरे के रूप में चिह्नित करती हैं। हर एंटीबॉडी अद्वितीय होती है, किसी खास एंटीजेन से मेल खाने के लिए बनी, जैसे ताला और चाबी।

बी-कोशिकाएँ एंटीबॉडी बनाने की फैक्ट्रियाँ हैं। ये मेमोरी कोशिकाएँ बनाने में भी शामिल होती हैं। ये कोशिकाएँ पहले मिले एंटीजेन के प्रति शरीर की प्रतिक्रिया तेज करती हैं, क्योंकि इन्हें याद रहता है कि पिछली बार कौन-सी एंटीबॉडी उपयोगी रही थीं।

टी-कोशिकाएँ प्रतिरक्षा तंत्र की प्रवर्तक हैं। वे उन कोशिकाओं का पता लगाकर नष्ट करती हैं जिन्हें एंटीबॉडी ने संक्रमित या खतरनाक के रूप में चिह्नित किया है, ताकि खतरा शीघ्र निष्क्रिय हो जाए।

प्रतिरक्षा तंत्र की अद्भुत विशेषताओं में से एक है समय के साथ नई एंटीबॉडी विकसित और बेहतर करने की क्षमता। किसी नए रोगजनक का सामना होने पर, प्रतिरक्षा तंत्र केवल एक बार प्रतिक्रिया नहीं देता। यह अपने तरीके को लगातार परिष्कृत करता है, खतरे से निपटने के लिए और मजबूत तथा अधिक प्रभावी एंटीबॉडी बनाता है।

ये जैविक अवधारणाएँ AIS में कैसे बदलती हैं

आर्टिफिशियल इम्यून सिस्टम (AIS) इन्हीं जैविक सिद्धांतों का एल्गोरिद्म में निष्पादन हैं। समस्या-समाधान में AIS प्रतिरक्षा तंत्र के कार्यों की नकल करते हैं।

AIS में, एंटीजेन उन समस्याओं या चुनौतियों का प्रतिनिधित्व करते हैं जिन्हें संबोधित करना है। ये डेटा में विसंगतियों का पता लगाने से लेकर किसी समाधान को ऑप्टिमाइज़ करने तक कुछ भी हो सकते हैं।

AIS में एंटीबॉडी इन समस्याओं के संभावित समाधान होते हैं। जैसे जैविक एंटीबॉडी विशिष्ट एंटीजेनों को पहचानती हैं, वैसे ही AIS विशिष्ट चुनौतियों के अनुरूप संभावित समाधानों को विकसित करता है।

AIS में बी-कोशिका प्रक्रिया, जैविक तंत्र में विविधता और मेमोरी उत्पन्न करने की प्रक्रिया का प्रतिबिंब है। AIS एल्गोरिद्म विभिन्न प्रकार के कैंडिडेट समाधानों का उपयोग करते हैं और समय के साथ उन्हें परिष्कृत करते हैं। वे पिछली समस्याओं से सीखते हैं ताकि भविष्य के प्रदर्शन को बेहतर बनाया जा सके।

आर्टिफिशियल इम्यून सिस्टम में टी-कोशिकाओं का सीधा समकक्ष नहीं होता, लेकिन इनमें ऐसे मूल्यांकन तंत्र शामिल होते हैं जो समान भूमिका निभाते हैं। ये प्रक्रियाएँ अकार्यक्षम समाधानों को हटाती हैं और बेहतर प्रदर्शन करने वालों को परिशोधित करती हैं।

AIS म्यूटेशन और चयन जैसी उत्क्रांतिक सिद्धांतों का उपयोग करते हैं ताकि समाधानों की गुणवत्ता को लगातार सुधारा जा सके।

आर्टिफिशियल इम्यून सिस्टम के प्रमुख सिद्धांत

आर्टिफिशियल इम्यून सिस्टम, एंटीबॉडी-एंटीजेन इंटरैक्शन, क्लोनल सेलेक्शन, नेगेटिव सेलेक्शन और इम्यून नेटवर्क थ्योरी जैसे प्रमुख सिद्धांतों को समाहित करते हैं। 

एंटीबॉडी-एंटीजेन इंटरैक्शन

आर्टिफिशियल इम्यून सिस्टम का अभिन्न हिस्सा एंटीबॉडी-एंटीजेन इंटरैक्शन की अवधारणा है। यह प्रक्रिया सीधे इस बात से प्रेरित है कि हमारा प्रतिरक्षा तंत्र खतरों पर कैसे प्रतिक्रिया देता है। एंटीबॉडी को किसी समस्या के संभावित समाधान और एंटीजेन को स्वयं समस्या या चुनौती के रूप में सोचें।

जैविक दुनिया में, एंटीबॉडी प्रोटीन होते हैं जो एंटीजेन से चिपककर उन्हें निष्क्रिय करते हैं। AIS में, एंटीबॉडी किसी संगणकीय समस्या का कैंडिडेट समाधान दर्शाती है, जबकि एंटीजेन उस समस्या का प्रतिनिधित्व करता है जिसे हल करना है।

AIS एल्गोरिद्म ऐसी एंटीबॉडी की आबादी विकसित करता है जो संबंधित एंटीजेन को प्रभावी ढंग से पहचानकर निष्क्रिय कर सके। समय के साथ, एल्गोरिद्म इन एंटीबॉडी को फाइन-ट्यून करता है और सबसे प्रभावी समाधानों पर केंद्रित होता जाता है।

क्लोनल सेलेक्शन एल्गोरिद्म (CSA)

क्लोनल सेलेक्शन एल्गोरिद्म (CSA) हमारे प्रतिरक्षा तंत्र की एक और महत्वपूर्ण प्रक्रिया से प्रेरणा लेता है। जब शरीर किसी एंटीजेन का पता लगाता है, तो वह कोई भी यादृच्छिक प्रतिरक्षा कोशिकाएँ नहीं भेजता; वह उन कोशिकाओं का चयन करता है जो विशेष रूप से आक्रमणकारी को पहचान सकती हैं। चयनित कोशिकाओं को फिर बड़ी संख्या में क्लोन किया जाता है ताकि प्रभावी रक्षा की जा सके।

इन क्लोनों में म्यूटेशन होते हैं, जो हल्के-फुल्के भिन्नता लाते हैं और प्रतिरक्षा प्रतिक्रिया की विविधता बढ़ाते हैं। इससे सुनिश्चित होता है कि यदि रोगजनक विकसित भी हो, तो भी प्रतिरक्षा तंत्र अनुकूल होकर प्रभावी ढंग से प्रतिक्रिया दे सके।

इसी तरह, क्लोनल सेलेक्शन एल्गोरिद्म सबसे आशाजनक समाधानों का चयन करता है और उनके कई प्रतिरूप या "क्लोन" बनाता है।

इसके बाद इन क्लोनों में म्यूटेशन कराए जाते हैं, जिससे संभावित समाधानों का विविध पूल बनता है। सर्वश्रेष्ठ प्रदर्शन करने वाले क्लोन बनाए रखे जाते हैं और प्रक्रिया दोहराई जाती है, जिससे धीरे-धीरे समाधानों की गुणवत्ता में सुधार होता है। यह एल्गोरिद्म विशेष रूप से ऑप्टिमाइज़ेशन कार्यों में शक्तिशाली है, जहाँ लक्ष्य अनेक संभावनाओं में से सबसे कुशल समाधान खोजना होता है।

CSA का अक्सर ऑप्टिमाइज़ेशन समस्याएँ सुलझाने में उपयोग किया जाता है। उदाहरण के लिए, एयरोस्पेस में यह हवाई जहाज़ के पंख जैसी संरचनाओं के वायुगतिकीय गुणों को कई पुनरावृत्तियों में सुधारकर अधिक कुशल डिज़ाइन करने में मदद कर सकता है।

मेडिकल इमेजिंग में, CSA छवि की स्पष्टता बढ़ा सकता है या शोरयुक्त परिवेश में अनियमित पैटर्न का पता लगा सकता है, जिससे यह MRI स्कैन या ट्यूमर डिटेक्शन में उपयोगी बनता है।

नेगेटिव सेलेक्शन एल्गोरिद्म (NSA)

मानव प्रतिरक्षा तंत्र को शरीर की अपनी कोशिकाओं और बाहरी आक्रमणकारियों में अंतर करना होता है। यहीं नेगेटिव सेलेक्शन एल्गोरिद्म (NSA) काम आता है। जो प्रतिरक्षा कोशिकाएँ शरीर की अपनी कोशिकाओं पर अत्यधिक प्रतिक्रिया करती हैं, उन्हें हटा दिया जाता है। इससे सुनिश्चित होता है कि प्रतिरक्षा तंत्र गलती से स्वयं पर हमला न कर दे (ऑटोइम्यून रोग)।

NSA इस प्रक्रिया की नकल कर डेटा में विसंगतियों या आउटलायर्स की पहचान करता है। एल्गोरिद्म मॉडल्स का एक सेट बनाता है, जिन्हें डिटेक्टर कहा जाता है, जो डेटा में सामान्य पैटर्न को पहचानने के लिए बनाए जाते हैं। जो भी डिटेक्टर सामान्य डेटा से बहुत मेल खाते हैं, उन्हें हटा दिया जाता है, और केवल वे बचे रहते हैं जो सामान्य पैटर्न से मेल नहीं खाते। फिर इन्हीं डिटेक्टरों का उपयोग नए डेटा की निगरानी के लिए किया जाता है।

यदि ये असामान्य डिटेक्टर किसी नए डेटा बिंदु को फ़्लैग करते हैं, तो उसे विसंगति (anomaly) के रूप में चिह्नित किया जाता है। यह उसी तरह है जैसे प्रतिरक्षा तंत्र बाहरी आक्रमणकारियों का पता लगाता है। यह तरीका साइबर सुरक्षा जैसे क्षेत्रों में अत्यंत प्रभावी है, जहाँ असामान्य पैटर्न का पता लगाना संभावित खतरों की पहचान की कुंजी है।

NSA नेटवर्क ट्रैफ़िक की निगरानी करने वाले इंट्रूज़न डिटेक्शन सिस्टम के लिए उपयुक्त है, जो सामान्य पैटर्न की तुलना संभावित खतरों के पैटर्न से करके दुर्भावनापूर्ण गतिविधि की पहचान करते हैं।

NSA का उपयोग पावर प्लांट जैसी जटिल प्रणालियों में यांत्रिक या संचालन संबंधी दोषों का पता लगाने के लिए भी किया जा सकता है।

इम्यून नेटवर्क थ्योरी (INT)

इम्यून नेटवर्क थ्योरी (INT) AIS की अवधारणा का विस्तार करती है, जिसमें एंटीबॉडी और एंटीजेन के बीच इंटरैक्शन के साथ-साथ एंटीबॉडी के आपसी इंटरैक्शन का भी मॉडलिंग शामिल है।

जैविक प्रतिरक्षा तंत्र में एंटीबॉडी अकेले काम नहीं करतीं। वे एक-दूसरे से संवाद करती हैं और एक-दूसरे को प्रभावित करती हैं, जिससे प्रतिक्रियाओं का एक गतिशील नेटवर्क बनता है जो अधिक मज़बूत और अनुकूलनीय होता है। यह नेटवर्क-आधारित इंटरैक्शन प्रतिरक्षा तंत्र को संतुलन बनाए रखने में मदद करता है, ताकि वह विभिन्न प्रकार के खतरों का प्रभावी ढंग से सामना कर सके और किसी एक पर अधिक प्रतिक्रिया न दे।

INT का उपयोग विभिन्न समाधानों के बीच जटिल इंटरैक्शन और निर्भरताओं को मॉडल करने के लिए किया जाता है। इससे एल्गोरिद्म अधिक व्यापक संभावित प्रतिक्रियाओं पर विचार कर सकता है, जिसके परिणामस्वरूप अधिक परिष्कृत समस्या-समाधान रणनीतियाँ बनती हैं।

एंटीबॉडी एक-दूसरे को कैसे प्रभावित करती हैं, इसका सिमुलेशन करके, AIS किसी समाधान तक पहुँचने के लिए एक साथ कई रास्तों का अन्वेषण कर सकता है, जिससे जटिल और गतिशील परिवेशों में इष्टतम समाधान खोजने की क्षमता बेहतर होती है। यह सिद्धांत सबसे उन्नत AIS एल्गोरिद्म का आधार है और जटिल संगणकीय चुनौतियों से निपटने के लिए एक शक्तिशाली उपकरण बनाता है।

इम्यून नेटवर्क थ्योरी का उपयोग रोबोटिक स्वॉर्म को नियंत्रित करने में किया जा सकता है। रोबोटों के बीच इंटरैक्शन एंटीबॉडी इंटरैक्शन की नकल करते हैं, जिससे खोज-बचाव जैसे कार्यों में समन्वित व्यवहार और समस्या-समाधान संभव होता है।

वित्त में, इम्यून नेटवर्क मॉडल विभिन्न आर्थिक संकेतकों के बीच इंटरैक्शन का अध्ययन करने के लिए उपयोग किए जा सकते हैं, जिससे बाज़ार प्रवृत्तियों का पूर्वानुमान या वित्तीय विसंगतियों का पता लगाया जा सकता है।

आर्टिफिशियल इम्यून सिस्टम का पायथन निष्पादन

पायथन अक्सर आर्टिफिशियल इम्यून सिस्टम बनाने के लिए पसंदीदा भाषा है, इसकी विस्तृत लाइब्रेरी और उपयोग में सरलता के कारण।

क्लोनल सेलेक्शन एल्गोरिद्म का निष्पादन

क्लोनल सेलेक्शन एल्गोरिद्म उस जैविक प्रक्रिया से प्रेरित है जिसमें जो प्रतिरक्षा कोशिकाएँ किसी खतरे को सफलतापूर्वक पहचान लेती हैं, उन्हें क्लोन किया जाता है और फिर प्रतिरक्षा प्रतिक्रिया को बेहतर करने के लिए उनमें म्यूटेशन कराए जाते हैं। AIS में ये “प्रतिरक्षा कोशिकाएँ” किसी समस्या के कैंडिडेट समाधान होते हैं, और लक्ष्य इन समाधानों को विकसित करना होता है ताकि सर्वश्रेष्ठ समाधान मिल सके।

यहाँ बताया गया है कि आप पायथन में CSA का एक सरल संस्करण कैसे लागू कर सकते हैं:

1. जनसंख्या आरंभ करें: यादृच्छिक समाधानों की एक जनसंख्या बनाकर शुरू करें। यदि आप किसी ऑप्टिमाइज़ेशन समस्या पर काम कर रहे हैं, तो ये समाधान सर्च स्पेस के भीतर यादृच्छिक बिंदु हो सकते हैं। हर समाधान प्रतिरक्षा तंत्र में एक एंटीबॉडी के समान है।
2. फिटनेस का मूल्यांकन करें: इसके बाद, हर समाधान की फिटनेस का आकलन करें। फिटनेस यह माप है कि कोई समाधान समस्या को कितनी अच्छी तरह हल करता है। जैविक रूप से, यह इस बात जैसा है कि कोई एंटीबॉडी एंटीजेन को कितनी कुशलता से निष्क्रिय कर सकती है। आप जो फिटनेस फ़ंक्शन उपयोग करेंगे, वह आपकी विशिष्ट समस्या पर निर्भर करेगा।
3. सर्वश्रेष्ठ समाधान चुनें: उनकी फिटनेस के आधार पर, क्लोनिंग के लिए सर्वश्रेष्ठ समाधानों का चयन करें। यह चयन प्रक्रिया उस तरह है जैसे प्रतिरक्षा तंत्र किसी रोगजनक से लड़ने के लिए सबसे प्रभावी एंटीबॉडी चुनता है।
4. क्लोन करें और म्यूटेट करें: चुने गए समाधानों की कई प्रतियाँ या क्लोन बनाएँ। फिर, उनके मानों में थोड़े परिवर्तन करके इन क्लोनों में म्यूटेशन कराएँ। यह चरण महत्वपूर्ण है क्योंकि यह जनसंख्या में विविधता लाता है, जिससे एल्गोरिद्म समाधान क्षेत्र के अलग-अलग हिस्सों का अन्वेषण कर सके।
5. प्रतिस्थापित करें और दोहराएँ: जनसंख्या में सबसे खराब प्रदर्शन करने वाले समाधानों को नए म्यूटेटेड क्लोनों से बदलें। इस प्रक्रिया को निर्दिष्ट पीढ़ियों तक या तब तक दोहराएँ जब तक समाधान इष्टतम या निकट-इष्टतम मान पर अभिसरित न हो जाएँ।

आइए CSA का उपयोग करके एक फंक्शन ऑप्टिमाइज़ेशन समस्या हल करें। हम एक प्रसिद्ध बेंचमार्क फंक्शन, Rastrigin फंक्शन, को ऑप्टिमाइज़ करेंगे। इस फंक्शन का उपयोग इसके कई लोकल मिनिमा के कारण ऑप्टिमाइज़ेशन एल्गोरिद्म की जाँच के लिए किया जाता है।

नीचे दिए गए कोड में, हम फंक्शन के लिए ग्लोबल मिनिमा ढूँढने हेतु CSA का उपयोग करते हैं:

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()संचालित द्वारा

ऊपर का ग्राफ दिखाता है कि प्रत्येक पीढ़ी के साथ CSA ने Rastrigin फंक्शन के बेहतर समाधान कैसे खोजे।

यह ग्राफ Rastrigin का प्लॉट दिखाता है, जो इसके कई लोकल मिनिमा दर्शाता है। बीच में लाल बिंदु, CSA द्वारा पाया गया अंतिम सर्वश्रेष्ठ समाधान है।

नेगेटिव सेलेक्शन एल्गोरिद्म का निष्पादन

NSA विशेष रूप से विसंगति का पता लगाने वाले कार्यों के लिए उपयोगी है। यह एल्गोरिद्म इस बात का सिमुलेशन करता है कि प्रतिरक्षा तंत्र शरीर की अपनी कोशिकाओं और बाहरी आक्रमणकारियों में कैसे अंतर करता है। NSA में, आप ऐसे डिटेक्टरों का सेट बनाते हैं जो सामान्य डेटा पैटर्न से मेल नहीं खाते। फिर इन डिटेक्टरों का उपयोग नए डेटा की निगरानी करने में किया जाता है, और जो भी चीज़ असामान्य दिखती है उसे फ़्लैग किया जाता है।

यहाँ NSA बनाने का एक अवलोकन दिया गया है:

1. सेल्फ डेटा जनरेट करें: सबसे पहले यह परिभाषित करें कि आपके डेटा में “सेल्फ” क्या है। यह सामान्य, अपेक्षित व्यवहारों या पैटर्न का डेटासेट हो सकता है। लक्ष्य ऐसे डिटेक्टर बनाना है जो इस सेल्फ डेटा से मेल न खाएँ।
2. डिटेक्टर बनाएँ: यादृच्छिक डिटेक्टर बनाएँ और उन्हें सेल्फ डेटा से मिलाएँ। कोई भी डिटेक्टर जो सेल्फ डेटा से मेल खाता है, उसे त्याग दें। बचे हुए डिटेक्टर विसंगतियों की निगरानी के लिए रखे जाते हैं।
3. नए डेटा की निगरानी करें: जब नया डेटा आता है, तो उसे रखे गए डिटेक्टरों से मिलाएँ। यदि कोई डिटेक्टर नए डेटा को नॉन-सेल्फ के रूप में पहचानता है, तो उस डेटा को विसंगति के रूप में फ़्लैग किया जाता है।

आइए इसे काल्पनिक लेन-देन के सेट से समझते हैं। इस उदाहरण में, हम दो क्लस्टरों के आसपास केंद्रित सामान्य लेन-देन बनाते हैं और धोखाधड़ी वाले लेन-देन को यादृच्छिक रूप से बिखेरते हैं। हम नेगेटिव सेलेक्शन एल्गोरिद्म अपनाएँगे, जहाँ फ्रॉड डिटेक्टर फीचर स्पेस में बिखरे होते हैं ताकि इन डिटेक्टरों के निकटता के आधार पर विसंगतियों की पहचान हो सके।

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()संचालित द्वारा

यहाँ, फ्रॉड डिटेक्टर फीचर स्पेस में ऐसे क्षेत्रों को कवर करने के लिए वितरित हैं जहाँ सामान्य लेन-देन दिखाई नहीं देते। जो धोखाधड़ी वाले लेन-देन इन डिटेक्टरों के क़रीब आते हैं, उन्हें पहचानकर विसंगति के रूप में फ़्लैग किया जाता है।

यह प्लॉट फ्रॉड डिटेक्टरों द्वारा बनाई गई निर्णय-सीमा को दर्शाता है। शेडेड क्षेत्र वे हैं जो डिटेक्टरों की निकटता के आधार पर विसंगत के रूप में वर्गीकृत होते हैं, और दिखाते हैं कि सामान्य लेन-देन की तुलना में धोखाधड़ी वाले लेन-देन कहाँ पकड़े जाते हैं। निर्णय-सीमा को अधिक या कम क्षेत्र कवर कराने के लिए आप दूरी-थ्रेशहोल्ड में बदलाव कर सकते हैं, जिससे विसंगत घोषित क्षेत्रों का फैलाव बढ़ेगा या घटेगा।

इम्यून नेटवर्क थ्योरी का निष्पादन

INT इस विचार से प्रेरित है कि प्रतिरक्षा प्रतिक्रियाएँ केवल व्यक्तिगत एंटीबॉडी पर आधारित नहीं होतीं, बल्कि उनके आपसी संचार पर भी निर्भर करती हैं। यह दृष्टिकोण प्रतिरक्षा तंत्र को एक नेटवर्क के रूप में मॉडल करता है, जहाँ एंटीबॉडी एक-दूसरे से संवाद कर समग्र प्रतिरक्षा प्रतिक्रिया को सुदृढ़ करती हैं। इस संदर्भ में, हर एंटीबॉडी (समाधान) अन्य एंटीबॉडी के साथ इंटरैक्ट कर इष्टतम समाधान खोजने की प्रक्रिया को प्रभावित और परिष्कृत कर सकती है।

यहाँ बताया गया है कि आप पायथन में INT का एक बुनियादी संस्करण कैसे लागू कर सकते हैं:

1. जनसंख्या आरंभ करें: पिछले एल्गोरिद्म की तरह, यादृच्छिक समाधानों की एक प्रारंभिक जनसंख्या बनाएँ। हर समाधान नेटवर्क में एक एंटीबॉडी का प्रतिनिधित्व करता है।
2. फिटनेस का मूल्यांकन करें: हर समाधान की फिटनेस का आकलन करें ताकि पता चले कि वह समस्या को कितना अच्छी तरह हल करता है। यह चरण इस बात के अनुरूप है कि कोई एंटीबॉडी एंटीजेन को कितनी अच्छी तरह पहचानती और बाइंड करती है।
3. कनेक्शन स्थापित करें: एक नेटवर्क बनाएँ जहाँ एंटीबॉडी (समाधान) अपनी समानता या निकटता के आधार पर जुड़े हों। कनेक्शन एंटीबॉडी के बीच संचार का प्रतिनिधित्व करते हैं, जिससे वे एक-दूसरे को प्रभावित कर सकें।
4. समाधानों को अपडेट करें: नेटवर्क के माध्यम से इटररेट करें और जुड़े एंटीबॉडी के साथ इंटरैक्शन के आधार पर समाधानों को अपडेट करें। यह प्रक्रिया इस बात का सिमुलेशन करती है कि एंटीबॉडी एक-दूसरे को कैसे प्रभावित कर प्रतिरक्षा प्रतिक्रिया को परिष्कृत करती हैं।
5. प्रतिस्थापित करें और दोहराएँ: सबसे खराब प्रदर्शन करने वाले समाधानों को नेटवर्क से आए अपडेटेड समाधानों से बदलें। इस प्रक्रिया को निर्धारित संख्या तक या तब तक जारी रखें जब तक समाधान इष्टतम या निकट-इष्टतम मान तक अभिसरित न हो जाएँ।

आइए INT का उपयोग आर्थिक संकेतकों के सेट के आधार पर शेयर बाज़ार रुझानों की भविष्यवाणी करने के लिए करें। हम एक काल्पनिक डेटासेट का उपयोग करेंगे, जहाँ हर समाधान शेयर मूल्यों के पूर्वानुमान के लिए संकेतकों के संयोजन का प्रतिनिधित्व करता है।

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()संचालित द्वारा

यह ग्राफ दिखाता है कि समय के साथ मीन स्क्वेयर्ड एरर (MSE) घट रहा है, जो संकेत देता है कि मॉडल की भविष्यवाणियाँ अधिक सटीक होती जा रही हैं।

यह स्कैटर प्लॉट वास्तविक शेयर मूल्यों की तुलना मॉडल की भविष्यवाणियों से करता है। जो बिंदु लाल डैश्ड रेखा के पास हैं, वे अधिक सटीक भविष्यवाणी दर्शाते हैं।

आर्टिफिशियल इम्यून सिस्टम अन्य AI तकनीकों की तुलना में कैसे हैं?

AIS कई मशीन लर्निंग तकनीकों में से एक है जो जीवविज्ञान से प्रेरित हैं।

न्यूरल नेटवर्क

न्यूरल नेटवर्क मानव मस्तिष्क से प्रेरित हैं और बड़े डेटासेट से सीखने में उत्कृष्ट हैं। इन्हें इमेज रिकग्निशन और नैचुरल लैंग्वेज प्रोसेसिंग जैसे कार्यों में उपयोग किया जाता है। ये आपस में जुड़े न्यूरॉनों के वज़नों को समायोजित करने के लिए विशाल मात्रा में डेटा के साथ व्यापक प्रशिक्षण पर निर्भर करते हैं।

इसके विपरीत, आर्टिफिशियल इम्यून सिस्टम बड़े डेटासेट की आवश्यकता के बिना अनुकूलनशीलता और विकेंद्रीकृत समस्या-समाधान पर केंद्रित होते हैं। AIS प्रतिरक्षा तंत्र की वास्तविक समय में नई चुनौतियों को पहचानने और प्रतिक्रिया देने की क्षमता की नकल करते हैं, जिससे वे गतिशील परिवेशों के लिए उपयुक्त बनते हैं जहाँ तेज़ अनुकूलन महत्वपूर्ण होता है।

जेनेटिक एल्गोरिद्म

जेनेटिक एल्गोरिद्म, जो प्राकृतिक उत्क्रांति से प्रेरित हैं, चयन, क्रॉसओवर और म्यूटेशन के माध्यम से समाधानों की आबादी को विकसित करके जटिल समस्याओं का ऑप्टिमाइज़ेशन करने में प्रभावी होते हैं। यह प्रक्रिया CSA के समान है।

हालाँकि, जहाँ जेनेटिक एल्गोरिद्म सर्च स्पेस का अन्वेषण करने के लिए जेनेटिक ऑपरेटरों पर निर्भर करते हैं, वहीं CSA प्रतिरक्षा प्रतिक्रियाओं की नकल कर समाधानों को अनुकूलित करता है, जिससे नए और अप्रत्याशित चुनौतियों से निपटने में लचीलापन मिलता है। AIS, जिनमें CSA भी शामिल है, विशेष रूप से उन गतिशील परिवेशों में प्रभावी हैं जहाँ तेज़ अनुकूलन और सतत् सीखना महत्वपूर्ण है।

आप जेनेटिक एल्गोरिद्म के बारे में और पढ़ सकते हैं Genetic Algorithm: Complete Guide With Python Implementation में।

स्वॉर्म इंटेलिजेंस एल्गोरिद्म

स्वॉर्म इंटेलिजेंस एल्गोरिद्म चींटियों और मधुमक्खियों जैसे सामाजिक जीवों के सामूहिक व्यवहार से प्रेरित हैं। ये विकेंद्रीकृत प्रणालियों और सरल एजेंट इंटरैक्शन का उपयोग करके जटिल वैश्विक ऑप्टिमाइज़ेशन प्राप्त करते हैं।

आत्मा में, यह INT के समान है। दोनों दृष्टिकोण ऑप्टिमाइज़ेशन समस्याओं से निपटने के लिए किसी सिस्टम में विविधता और अनुकूलनशीलता बनाए रखने पर ध्यान केंद्रित करते हैं। जहाँ स्वॉर्म इंटेलिजेंस एजेंट-आधारित इंटरैक्शन पर ज़ोर देता है, वहीं INT प्रतिरक्षा प्रतिक्रियाओं जैसे तंत्रों का लाभ उठाता है, जो गतिशील समस्या-समाधान के लिए पूरक तरीके प्रदान करता है।

आप स्वॉर्म इंटेलिजेंस एल्गोरिद्म के बारे में और पढ़ सकते हैं Swarm Intelligence Algorithms: Three Python Implementations में।

आर्टिफिशियल इम्यून सिस्टम में वर्तमान शोध

आर्टिफिशियल इम्यून सिस्टम विभिन्न क्षेत्रों में जटिल समस्याओं को सुलझाने के लिए आशाजनक हैं। शोधकर्ता इन प्रणालियों को और अधिक उपयोगी बनाने के लिए इन्हें उन्नत करने पर काम कर रहे हैं।

एक क्षेत्र में शोधकर्ता ऐसे हाइब्रिड मॉडल बनाने की खोज कर रहे हैं जो AIS को अन्य कम्प्यूटेशनल इंटेलिजेंस तकनीकों के साथ मिलाएँ। आशा है कि ये हाइब्रिड मॉडल अधिक मज़बूत और बहुमुखी होंगे।

इन हाइब्रिड तरीकों का लक्ष्य प्रत्येक विधि की ताकतों का लाभ उठाना है, जैसे AIS की अनुकूलन क्षमताएँ और न्यूरल नेटवर्क की शक्तिशाली सीखने की प्रणालियाँ। अधिक जानकारी के लिए देखें Artificial Immune Systems।

एक और सक्रिय शोध क्षेत्र AIS को नए डोमेनों में लागू करना है। पारंपरिक रूप से साइबर सुरक्षा और ऑप्टिमाइज़ेशन में उपयोग होने के बावजूद, अब AIS का अन्वेषण रोबोटिक्स, बायोइन्फॉर्मेटिक्स और यहाँ तक कि वित्तीय मॉडलिंग जैसे क्षेत्रों में किया जा रहा है। AIS की अनुकूलनशीलता और विकेंद्रीकृत प्रकृति उन्हें इन गतिशील और अक्सर अप्रत्याशित परिवेशों में समस्याओं को सुलझाने के लिए एक आशाजनक उम्मीदवार बनाती है। अधिक जानकारी के लिए यह पढ़ें Nature-Inspired Computing: Scope and Applications of Artificial Immune Systems Toward Analysis and Diagnosis of Complex Problems।

AIS मॉडल न केवल उन्नत संगणकीय तकनीकें प्रदान करते हैं बल्कि वास्तविक प्रतिरक्षा तंत्र की हमारी समझ में भी योगदान दे सकते हैं। वे कैंसर और ऑटोइम्यून विकारों जैसी बीमारियों के लिए इम्यूनोथेरेपी रणनीतियों को आगे बढ़ा रहे हैं। अधिक जानने के लिए यह Cleveland Clinic और IBM के बीच सहयोग देखें।

निष्कर्ष

आर्टिफिशियल इम्यून सिस्टम मानव प्रतिरक्षा तंत्र से प्रेरणा लेकर जटिल समस्याओं को हल करने का एक अनूठा दृष्टिकोण प्रस्तुत करते हैं। पैटर्न पहचान, अनुकूलन और मेमोरी जैसी जैविक प्रक्रियाओं का अनुकरण करके, AIS साइबर सुरक्षा से लेकर ऑप्टिमाइज़ेशन तक के क्षेत्रों में बहुमुखी समाधान प्रदान करते हैं।