(C/C++学习)20.基于C++改进的单目标遗传算法

说明：在学习生活中，经常会遇到各种各样的最优问题，其中最常见的就是求某个多维（多个自变量）函数在各个自变量各取何值时的最大值或最小值；例如求函数 f(x) = (x-5)²+(y-6)²+(z-7)² 的最小值，当然，这个函数很简单，很容易看出来，该函数的最小值为0，分别在三个自变量取5，6，7时取得最小值。但日常学习中的函数都是很复杂的，就算通过大量的计算，也不一定能准确地算出目标值以及在何时取得该目标值，因此，本文介绍一种基于单目标的遗传算法来解决此类问题。

注意：由于封装函数较多，为了清晰，函数名一般为其英文名，因此比较长，强烈建议电脑阅读。

1.遗传算法代码实现

遗传算法的相关概念，这里不多说，网上一大堆，这里只介绍本程序的实现过程，代码如下：

a.第一部分为主函数

 #include <iostream>
 #include <genetic.h>
 using namespace std;

 int main()
 {
     Genetic M;
     int Iteration = 0;
     //种群及重要参数初始化
     M.initiallize(M.Initialpop,Populationsize);
     cout<<"\n\t\t\t\t  The Genetic Algrithm System\n"<<endl;
     cout<<"\n\t\t\t\t\tThe Initial Pop:\n"<<endl;
     cout<<setw(20)<<"x"<<setw(20)<<"y"<<setw(20)<<"z"<<setw(20)<<"Fitness"<<endl<<endl;
     //获取种群适应度
     M.getfitnessofpop(M.Initialpop,Populationsize);
     //根据适应度排序
     M.sortpopbyfitness(M.Initialpop,Populationsize);
     //打印初始种群
     M.printpop(M.Initialpop,Populationsize);
     cout<<"\n\n\t\t\t\t\tThe Iteration Begins:\n"<<endl;
     while(Iteration <= M.Iterationtimes)
     {
         //交叉
         M.crossover(M.Initialpop,M.Offspring,Populationsize);
         //求取种群适应度
         M.getfitnessofpop(M.Offspring,Populationsize);
         //根据适应度排序
         M.sortpopbyfitness(M.Offspring,Populationsize);
         //父子代结合
         M.combinationpop(M.Initialpop,M.Offspring,M.Combinationpop,Populationsize);
         //变异
         M.mutation(M.Combinationpop,Populationsize*2);
         //求取结合种群适应度
         M.getfitnessofpop(M.Combinationpop,Populationsize*2);
         //对结合种群排序
         M.sortpopbyfitness(M.Combinationpop,Populationsize*2);
         //选择较优个体
         M.selectbestpop(M.Combinationpop,M.Initialpop,Populationsize);
         //结果微调，精确算子
         M.getAccurateResult(M.Initialpop,Populationsize);
         //打印迭代过程中出现的最优个体
         M.printbestindivil(M.Initialpop,Populationsize,Iteration);
         Iteration++;
     }
     cout<<"\n\n"<<"The Last Population : \n\n"<<endl;
     //打印最后一代的所有个体成员及其目标值
     M.printpop(M.Initialpop,Populationsize);
     cout<<"\n\n\n";
     return 0;
 }

b.第二部分为基因操作头文件

 #ifndef GENETIC_H
 #define GENETIC_H
 #include <time.h>
 #include <stdlib.h>
 #include <iomanip>
 #include <iostream>
 #include <math.h>
 using namespace std;
 #define Populationsize 16
 #define pi 3.1415926
 #define Accurate 0.001
 #define NumOfParameters 10
 //精度越高要求迭代次数越大

 class Genetic
 {
 public:
     Genetic();
     typedef struct Individual
     {
         double parameter[Populationsize];
         double fitness;
     }Individuals;
     Individuals Initialpop[Populationsize];
     Individuals Offspring[Populationsize];
     Individuals Combinationpop[Populationsize*2];
     Individuals Bestindividual;
     double downlimit[NumOfParameters];
     double uplimit[NumOfParameters];
     double crossoverability;
     double mutationproability;
     int NumOfParameter;
     int Iterationtimes;

     void initiallize(Individuals *Initialpop,int Populationsiz);
     void printpop(Individuals *Initialpop, int Populationsiz);
     double getfitnessofindiv(Individuals Indiv);
     void getfitnessofpop(Individuals *Initialpop,int Populationsiz);
     void sortpopbyfitness(Individuals *Initialpop,int Populationsiz);
     void crossover(Individuals *Initialpop,Individuals *offspring,int Populationsiz);
     void combinationpop(Individuals *Initialpop,Individuals *offspring,Individuals* Combinationpop,int populationsize);
     void mutation(Individuals *Initialpop,int population);
     void selectbestpop(Individuals* Combinationpo,Individuals *Initialpop,int population);
     void printbestindivil(Individuals* Initialpop,int populationsize, int Iteration);
     void getAccurateResult(Individuals* Initialpop,int population);
 };

 #endif // GENETIC_H
 

c.第三部分为基因操作头文件相应的 cpp 文件

 #include "genetic.h"
 Genetic::Genetic()
 {

 }
 void Genetic::initiallize(Genetic::Individuals *Initialpop, int Populationsiz)
 {
     cout<<"Welcome To The Genetic Algrithm System......\n";
     cout<<"\nPls Follow The Steps To Complete Your Compution.....\n\n";
     cout<<"\nStep 0: Pls Make Sure The Marked Function Have Been Modefied.....\n";
     cout<<"\nStep 1: Now Pls Input The Num Of Variations :";
     cin>>NumOfParameter;
     for(int i = 0;i<NumOfParameter;i++)
     {
         cout<<"\nStep "<<2*i+2<<" : Pls Input The Downlimit Of Variation "<<i+1<<" :";
         cin>>downlimit[i];
         cout<<"\nStep "<<2*i+3<<" : Pls Input The Uplimit Of Variation "<<i+1<<" :";
         cin>>uplimit[i];
     }
     cout<<"\nStep "<<2*NumOfParameter+2<<" :Pls Input The Iteration Times:";
     cin>>Iterationtimes;
     srand(time(NULL));
     crossoverability = 0.8;
     mutationproability = 0.01;
     for(int i=0; i<Populationsiz; i++)
     {
         for(int j = 0;j<NumOfParameter;j++)
         {
             Initialpop[i].parameter[j] = downlimit[j] + (rand()%50)/50.0*(uplimit[j]-downlimit[j]);
         }
     }
 }

 void Genetic::printpop(Genetic::Individuals *Initialpop, int Populationsiz)
 {
     for(int i =0;i<Populationsiz;i++)
     {
         for(int j = 0;j<NumOfParameter;j++)
         {
             cout<<setw(20)<<setprecision(5)<<Initialpop[i].parameter[j];
         }
         cout<<setw(20)<<fixed<<setprecision(7)<<Initialpop[i].fitness<<endl;
     }
 }

 // Function 目标函数根据所求实际问题进行修改
 double Genetic::getfitnessofindiv(Individuals Indiv)
 {
     double result;
     result = -(Indiv.parameter[0]+12.5)*(Indiv.parameter[0]+12.5)-(Indiv.parameter[1]+7.6)*(Indiv.parameter[1]+7.6)
             -(Indiv.parameter[2]+10.3)*(Indiv.parameter[2]+10.3);
     return result;
 }
 //修改

 void Genetic::getfitnessofpop(Genetic::Individuals *Initialpop, int Populationsiz)
 {
     for(int i = 0;i<Populationsiz;i++)
     {
         Initialpop[i].fitness = getfitnessofindiv(Initialpop[i]);
     }
 }

 void Genetic::sortpopbyfitness(Genetic::Individuals *Initialpop, int Populationsiz)
 {
     for(int i = 0;i<Populationsiz;i++)
     {
         int idx = i;
         for(int j = i+1;j<Populationsiz;j++)
         {
             if(Initialpop[idx].fitness > Initialpop[j].fitness)
                 idx = j;
         }
         if(idx != i)
         {
             Individual temp = Initialpop[i];
             Initialpop[i] = Initialpop[idx];
             Initialpop[idx] = temp;
         }
     }
     Bestindividual = Initialpop[0];
 }

 void Genetic::crossover(Individuals *Initialpop,Individuals *offspring, int Populationsiz)
 {
     for(int i = 1;i<=Populationsiz;i++)
     {
         //保证适值为正
         Initialpop[Populationsiz-i].fitness += -Initialpop[0].fitness;
     }
     srand(time(NULL));
     Individuals parent[2];
     double temp = 0;
     double totalfitness = 0;
     double gradient[Populationsiz] = {0};
     for(int i = 0;i<Populationsiz;i++)
     {
         totalfitness += Initialpop[i].fitness;
     }
     for(int i = 0;i<Populationsiz;i++)
     {
         temp += Initialpop[i].fitness;
         gradient[i] = temp/totalfitness;
     }
     for(int i = 0;i<Populationsiz/2;i++)
     {
         for(int j = 0;j<2;j++)
         {
             double randgradient = rand()%1000/1000.0;
             for(int k = 0;k<Populationsiz;k++)
             {
                 if(k == 0)
                 {
                     if(randgradient < gradient[0])
                     {
                         parent[j] = Initialpop[k];
                     }
                 }
                 else
                 {
                     if(randgradient >= gradient[k-1] && randgradient < gradient[k])
                     {
                         parent[j] = Initialpop[k];
                     }
                 }
             }
         }
         double Probability = rand()%1000/1000.0;
         if(Probability < crossoverability)
         {
             double b = rand()%100/100.0;
             if(b <= 0.5)
             {
                 double a = pow(2*b,1/21.0);
                 for(int j = 0;j<NumOfParameter;j++)
                 {
                     offspring[2*i].parameter[j] = ((1+a)*parent[0].parameter[j]+(1-a)*parent[1].parameter[j])/2.0;
                     offspring[2*i+1].parameter[j] = ((1-a)*parent[0].parameter[j]+(1+a)*parent[1].parameter[j])/2.0;
                 }
                 for(int j = 0;j<NumOfParameter;j++)
                 {
                     if(offspring[2*i].parameter[j] < downlimit[j] || offspring[2*i].parameter[j] > uplimit[j]
                             || offspring[2*i+1].parameter[j] < downlimit[j] || offspring[2*i+1].parameter[j] >
                             uplimit[j])
                     {
                         i--;
                         break;
                     }
                 }
             }
             else
             {
                 double a = pow(2*(1-b),-1/21.0);
                 for(int j = 0;j<NumOfParameter;j++)
                 {
                     offspring[2*i].parameter[j] = ((1+a)*parent[0].parameter[j]+(1-a)*parent[1].parameter[j])/2.0;
                     offspring[2*i+1].parameter[j] = ((1-a)*parent[0].parameter[j]+(1+a)*parent[1].parameter[j])/2.0;
                 }
                 for(int j = 0;j<NumOfParameter;j++)
                 {
                     if(offspring[2*i].parameter[j] < downlimit[j] || offspring[2*i].parameter[j] > uplimit[j]
                             || offspring[2*i+1].parameter[j] < downlimit[j] || offspring[2*i+1].parameter[j] >
                             uplimit[j])
                     {
                         i--;
                         break;
                     }
                 }
             }
         }
         else
         {
             for(int j = 0;j<NumOfParameter;j++)
             {
                 offspring[2*i].parameter[j] = downlimit[j] + (rand()%50)/50.0*(uplimit[j]-downlimit[j]);
                 offspring[2*i+1].parameter[j] = downlimit[j] + (rand()%50)/50.0*(uplimit[j]-downlimit[j]);
             }
         }
     }
 }

 void Genetic::combinationpop(Individuals *Initialpop,Individuals *offspring,Individuals *Combinationpop,int populationsize)
 {
     for(int i = 0;i<populationsize*2;i++)
     {
         if(i < populationsize)
             Combinationpop[i] = Initialpop[i];
         else
             Combinationpop[i] = offspring[i-populationsize];
     }
 }

 void Genetic::mutation(Genetic::Individuals *Initialpop, int population)
 {
     srand(time(NULL));
     for(int i = 0;i<population;i++)
     {
         double a = rand()%100/100.0;

         if(a <= mutationproability)
         {
             for(int j = 0;j<NumOfParameter;j++)
             {
                 Initialpop[i].parameter[j] = downlimit[j] + (rand()%50)/50.0*(uplimit[j]-downlimit[j]);
             }
         }
     }
 }

 void Genetic::selectbestpop(Individuals *Combinationpo,Individuals *Initialpop, int population)
 {
     for(int i = 0;i<population;i++)
         Initialpop[i] = Combinationpo[population+i];
 }

 void Genetic::printbestindivil(Genetic::Individuals *Initialpop, int populationsize,int Iteration)
 {
     cout<<"\r";
     cout<<""<<Iteration;
     for(int j = 0;j<NumOfParameter;j++)
     {
         cout<<setw(20)<<Initialpop[populationsize-1].parameter[j];
     }
     cout<<setw(20)<<Initialpop[populationsize-1].fitness;
 }

 void Genetic::getAccurateResult(Genetic::Individuals *Initialpop, int population)
 {
     for(int j = 0;j<population;j++)
     {
         for(int i = 0;i<NumOfParameter;i++)
         {
             Individuals temp = Initialpop[j];
             Individuals temp1 = Initialpop[j];
             temp.parameter[i] = temp.parameter[i]*(1+Accurate);
             if(getfitnessofindiv(temp) > getfitnessofindiv(Initialpop[i]) && temp.parameter[i] <= uplimit[i] &&
                     temp.parameter[i] >= downlimit[i])
             {
                 Initialpop[j] = temp;
             }
             temp1.parameter[i] = temp1.parameter[i]*(1-Accurate);
             if(getfitnessofindiv(temp1) > getfitnessofindiv(Initialpop[i]) && temp1.parameter[i] <= uplimit[i] &&
                     temp1.parameter[i] >= downlimit[i])
             {
                 Initialpop[j] = temp1;
             }
         }
     }
 }

使用注意事项：

a.根据具体的目标函数修改评价函数方程，

b.按照程序运行提示傻瓜式的输入相应的参数即可，

c.Accurate 参数用于当目标函数趋于稳定状态时的优化，即探测此时自变量该精度变化范围内的目标函数变化情况，从而获得更为优越的目标值。应注意的是，当要求精度越高时，该参数要求尽量小，同时迭代次数应该尽可能地高。

d.本例中涉及一个任意维的单目标测试函数，使用源代码直接按照提示步骤输入相应的各个变量上下限及迭代次数即可。