(Evolutionary Search) C++ ਵਿੱਚ ਵਿਕਾਸਵਾਦੀ ਖੋਜ ਐਲਗੋਰਿਦਮ- ਵਿਆਖਿਆ, ਉਦਾਹਰਨ, ਅਤੇ ਕੋਡ

ਈਵੇਲੂਸ਼ਨਰੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਕੁਦਰਤੀ ਵਿਕਾਸ ਦੀ ਵਿਧੀ 'ਤੇ ਅਧਾਰਤ ਇੱਕ ਅਨੁਕੂਲਨ ਵਿਧੀ ਹੈ। ਇਹ ਐਲਗੋਰਿਦਮ ਇੱਕ ਸਮੱਸਿਆ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲ ਲੱਭਣ ਲਈ ਪੀੜ੍ਹੀਆਂ ਵਿੱਚ ਇੱਕ ਆਬਾਦੀ ਦੇ ਅੰਦਰ ਵਿਅਕਤੀਆਂ ਦੀ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ।

ਕਿਦਾ ਚਲਦਾ

1. ਆਬਾਦੀ ਦੀ ਸ਼ੁਰੂਆਤ: ਬੇਤਰਤੀਬੇ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤੇ ਵਿਅਕਤੀਆਂ ਦੀ ਸ਼ੁਰੂਆਤੀ ਆਬਾਦੀ ਬਣਾਓ।
2. ਮੁਲਾਂਕਣ: ਉਦੇਸ਼ ਫੰਕਸ਼ਨ ਜਾਂ ਮੁਲਾਂਕਣ ਮਾਪਦੰਡ ਦੇ ਅਧਾਰ ਤੇ ਆਬਾਦੀ ਵਿੱਚ ਹਰੇਕ ਵਿਅਕਤੀ ਦੀ ਗੁਣਵੱਤਾ ਦਾ ਮੁਲਾਂਕਣ ਕਰੋ।
3. ਚੋਣ: ਸੰਭਾਵਨਾਵਾਂ ਜਾਂ ਚੋਣ ਮਾਪਦੰਡਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਮੌਜੂਦਾ ਆਬਾਦੀ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵਧੀਆ ਵਿਅਕਤੀਆਂ ਦਾ ਸਬਸੈੱਟ ਚੁਣੋ।
4. ਈਵੇਲੂਸ਼ਨ: ਚੁਣੇ ਗਏ ਵਿਅਕਤੀਆਂ ਲਈ ਕਰਾਸਓਵਰ ਅਤੇ ਪਰਿਵਰਤਨ ਕਾਰਜਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ ਇੱਕ ਨਵੀਂ ਪੀੜ੍ਹੀ ਬਣਾਓ।
5. ਦੁਹਰਾਓ: ਕਈ ਪੀੜ੍ਹੀਆਂ ਵਿੱਚ ਕਦਮ 2 ਤੋਂ 4 ਨੂੰ ਦੁਹਰਾਓ ਜਦੋਂ ਤੱਕ ਕੋਈ ਤਸੱਲੀਬਖਸ਼ ਹੱਲ ਪ੍ਰਾਪਤ ਨਹੀਂ ਹੋ ਜਾਂਦਾ ਜਾਂ ਦੁਹਰਾਓ ਦੀ ਇੱਕ ਪਹਿਲਾਂ ਤੋਂ ਪਰਿਭਾਸ਼ਿਤ ਸੰਖਿਆ ਤੱਕ ਪਹੁੰਚ ਨਹੀਂ ਜਾਂਦੀ।

ਉਦਾਹਰਨ: Fibonacci ਵਿਕਾਸਵਾਦੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫੰਕਸ਼ਨ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਾ

Fibonacci ਫੰਕਸ਼ਨ F(x) = F(x-1) + F(x-2) ਦੇ ਨਾਲ F(0) = 0, F(1) = 1 ਦੀ ਆਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਸਮੱਸਿਆ 'ਤੇ ਗੌਰ ਕਰੋ। ਅਸੀਂ 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 ਮੁੱਲਾਂ ਦੀ ਆਬਾਦੀ ਪੈਦਾ ਕਰਦੇ ਹਾਂ, ਸਭ ਤੋਂ ਵਧੀਆ ਵਿਅਕਤੀਆਂ ਦੀ ਚੋਣ ਕਰਕੇ ਅਤੇ ਕਰਾਸਓਵਰ ਅਤੇ ਪਰਿਵਰਤਨ ਕਾਰਜਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ ਉਹਨਾਂ ਨੂੰ ਪੀੜ੍ਹੀ ਦਰ ਪੀੜ੍ਹੀ ਵਿਕਸਿਤ ਕਰਦੇ ਹਾਂ।