C++ இல் பரிணாம தேடல் (Evolutionary Search) அல்காரிதம்- விளக்கம், எடுத்துக்காட்டு மற்றும் குறியீடு

பரிணாம தேடல் அல்காரிதம் என்பது இயற்கையான பரிணாமத்தின் பொறிமுறையை அடிப்படையாகக் கொண்ட ஒரு தேர்வுமுறை முறையாகும். இந்த வழிமுறையானது, ஒரு பிரச்சனைக்கு சிறந்த தீர்வைக் கண்டறிய தலைமுறை தலைமுறையாக மக்கள்தொகைக்குள் தனிநபர்களின் பரிணாம செயல்முறையை உருவகப்படுத்துகிறது.

எப்படி இது செயல்படுகிறது

1. மக்கள்தொகை துவக்கம்: தோராயமாக உருவாக்கப்பட்ட தனிநபர்களின் ஆரம்ப மக்கள்தொகையை உருவாக்கவும்.
2. மதிப்பீடு: புறநிலை செயல்பாடு அல்லது மதிப்பீட்டு அளவுகோல்களின் அடிப்படையில் மக்கள்தொகையில் உள்ள ஒவ்வொரு நபரின் தரத்தையும் மதிப்பீடு செய்யவும்.
3. தேர்வு: நிகழ்தகவுகள் அல்லது தேர்வு அளவுகோல்களின் அடிப்படையில் தற்போதைய மக்கள்தொகையில் இருந்து சிறந்த நபர்களின் துணைக்குழுவைத் தேர்ந்தெடுக்கவும்.
4. பரிணாமம்: தேர்ந்தெடுக்கப்பட்ட நபர்களுக்கு குறுக்குவழி மற்றும் பிறழ்வு செயல்பாடுகளைப் பயன்படுத்துவதன் மூலம் புதிய தலைமுறையை உருவாக்கவும்.
5. மறு செய்கை: திருப்திகரமான தீர்வை அடையும் வரை அல்லது முன் வரையறுக்கப்பட்ட எண்ணிக்கையிலான மறு செய்கைகளை அடையும் வரை பல தலைமுறைகளுக்கு 2 முதல் 4 படிகளை மீண்டும் செய்யவும்.

எடுத்துக்காட்டு: Fibonacci பரிணாம தேடலைப் பயன்படுத்தி செயல்பாட்டை மேம்படுத்துதல்

F(0) = 0, F(1) = 1 உடன் F(x) = F(x-1) + F(x-2) செயல்பாட்டின் தேர்வுமுறை சிக்கலைக் கவனியுங்கள். Fibonacci எதற்காக 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 மதிப்புகளின் மக்கள்தொகையை உருவாக்குகிறோம், சிறந்த நபர்களைத் தேர்ந்தெடுத்து குறுக்குவழி மற்றும் பிறழ்வு செயல்பாடுகளைப் பயன்படுத்துவதன் மூலம் அவற்றை தலைமுறைகளாக உருவாக்குகிறோம்.