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 મૂલ્યોની વસ્તી જનરેટ કરીએ છીએ, શ્રેષ્ઠ વ્યક્તિઓને પસંદ કરીને અને ક્રોસઓવર અને મ્યુટેશન ઑપરેશન્સ લાગુ કરીને તેમને પેઢીઓ સુધી વિકસિત કરીએ છીએ.