ఎవల్యూషనరీ సెర్చ్ అల్గోరిథం అనేది సహజ పరిణామం యొక్క మెకానిజం ఆధారంగా ఒక ఆప్టిమైజేషన్ పద్ధతి. ఈ అల్గోరిథం సమస్యకు ఉత్తమమైన పరిష్కారాన్ని కనుగొనడానికి తరతరాలుగా జనాభాలోని వ్యక్తుల పరిణామ ప్రక్రియను అనుకరిస్తుంది.
అది ఎలా పని చేస్తుంది
- పాపులేషన్ ఇనిషియలైజేషన్: యాదృచ్ఛికంగా ఉత్పత్తి చేయబడిన వ్యక్తుల యొక్క ప్రారంభ జనాభాను సృష్టించండి.
- మూల్యాంకనం: ఆబ్జెక్టివ్ ఫంక్షన్ లేదా మూల్యాంకన ప్రమాణాల ఆధారంగా జనాభాలోని ప్రతి వ్యక్తి యొక్క నాణ్యతను అంచనా వేయండి.
- ఎంపిక: సంభావ్యత లేదా ఎంపిక ప్రమాణాల ఆధారంగా ప్రస్తుత జనాభా నుండి ఉత్తమ వ్యక్తుల ఉపసమితిని ఎంచుకోండి.
- పరిణామం: ఎంచుకున్న వ్యక్తులకు క్రాస్‌ఓవర్ మరియు మ్యుటేషన్ ఆపరేషన్‌లను వర్తింపజేయడం ద్వారా కొత్త తరాన్ని సృష్టించండి.
- పునరావృతం: సంతృప్తికరమైన పరిష్కారం సాధించబడే వరకు లేదా ముందుగా నిర్వచించబడిన అనేక పునరావృత్తులు చేరుకునే వరకు బహుళ తరాలకు 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 విలువల జనాభాను రూపొందిస్తాము, ఉత్తమ వ్యక్తులను ఎంచుకోవడం మరియు క్రాస్‌ఓవర్ మరియు మ్యుటేషన్ ఆపరేషన్‌లను వర్తింపజేయడం ద్వారా తరతరాలుగా వాటిని అభివృద్ధి చేస్తాము.