C++ में विकासवादी खोज (Evolutionary Search) एल्गोरिथम- स्पष्टीकरण, उदाहरण और कोड

इवोल्यूशनरी सर्च एल्गोरिदम प्राकृतिक विकास के तंत्र पर आधारित एक अनुकूलन विधि है। यह एल्गोरिदम किसी समस्या का सर्वोत्तम समाधान खोजने के लिए पीढ़ियों के बीच आबादी के भीतर व्यक्तियों की विकास प्रक्रिया का अनुकरण करता है।

यह काम किस प्रकार करता है

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

उदाहरण: Fibonacci विकासवादी खोज का उपयोग करके फ़ंक्शन को अनुकूलित करना

Fibonacci F(0) = 0, F(1) = 1 के साथ फ़ंक्शन F(x) = F(x-1) + F(x-2) की अनुकूलन समस्या पर विचार करें। हम x का मान ज्ञात करना चाहते हैं जिसके लिए F(x) अधिकतम है. विकासवादी खोज विधि यादृच्छिक x मानों की जनसंख्या उत्पन्न कर सकती है, इष्टतम x मान खोजने के लिए उन्हें पीढ़ियों में विकसित कर सकती है।

C++ में कोड उदाहरण

#include <iostream>  
#include <vector>  
#include <cstdlib>  
#include <ctime>  
  
int fibonacci(int n) {  
    if(n <= 0) return 0;  
    if(n == 1) return 1;  
    return fibonacci(n- 1) + fibonacci(n- 2);  
}  
  
int evolutionSearchFibonacci(int populationSize, int numGenerations) {  
    srand(time(0));  
  
    std::vector<int> population(populationSize);  
    for(int i = 0; i < populationSize; ++i) {  
        population[i] = rand() % populationSize;  
    }  
  
    for(int gen = 0; gen < numGenerations; ++gen) {  
        int bestIndex = 0;  
        for(int i = 1; i < populationSize; ++i) {  
            if(fibonacci(population[i]) > fibonacci(population[bestIndex])) {  
                bestIndex = i;  
            }  
        }  
  
        // Crossover and mutation operations can be applied here  
  
        // Example: Replace the worst individual with the best individual  
        population[0] = population[bestIndex];  
    }  
  
    return population[0];  
}  
  
int main() {  
    int populationSize = 50;  
    int numGenerations = 100;  
    int result = evolutionSearchFibonacci(populationSize, numGenerations);  
  
    std::cout << "Optimal x for maximum Fibonacci value: " << result << std::endl;  
  
    return 0;  
}  

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