智能算法-遗传算法

目的:

了解遗传算法,并解决如下问题。已知N个向量,他们属于同一个类,寻找描述此类的"特点向量"P = ( y1,y2,y3,y4,y5 ),使之满足如下目标:累计N个绝对值的cos<Xi,P>最小。(这两天没写题是在搞这个╮(╯▽╰)╭)

遗传算法模拟了自然选择的过程,其一般步骤:

开始循环:

  1.评估每条染色体所对应个体的适应度。

  2.遵照适应度越高,选择概率越大的原则,从种群中选择两个个体作为父方和母方。

  3.抽取父母双方的染色体,进行交叉,产生子代。

  4.对子代的染色体进行变异。

  5.重复2,3,4步骤,直到新种群的产生。

结束循环。

由此构建代码,代码如下:

  1 #include<cstdio>
  2 #include<cmath>
  3 #include<ctime>
  4 #include<algorithm>
  5 #include<cstring>
  6 #define EPS 1e-8
  7 #define MAX_X 200
  8 #define SAVE 0.25                         /*保留比例*/
  9 #define MAX_Y 400                         /*种群数量*/
 10 #define MAX_GENS 50000                    /*最大代数*/
 11 #define PXCOVER 0.8                       /*交叉概率*/
 12 #define PMUTATION 0.05                    /*变异概率*/
 13 #define PA 0.01                           /*交叉因子*/
 14 #define PM 0.8                            /*变异因子*/
 15 #define N 6                               /*向量维度*/
 16 using namespace std;
 17 struct Xvector{                           /*向量x*/
 18     double vec[N];
 19     double mod;
 20 };
 21 struct Yvector{                           /*向量y*/
 22     double vec[N];
 23     double mod;
 24     double fitness;
 25     double fitsum;                        /*存储转盘选择值*/
 26 };
 27 Xvector x[MAX_X];                         /*已知n个向量x*/
 28 Yvector y[MAX_Y];
 29 Yvector newy[MAX_Y];
 30 Yvector fity;                             /*适应度最大的y*/
 31 bool index[MAX_Y];
 32 int n;                                    /*向量x的个数*/
 33 int generation;                           /*代数*/
 34 double lower[N],upper[N];
 35 void inputX();
 36 void inputY();
 37 double randval(double lower,double upper);/*给定上下限给出随机值*/
 38 void evaluate();                          /*评价*/
 39 void select();                            /*选择*/
 40 void xcover();                            /*交叉*/
 41 void mutate();                            /*变异*/
 42 void copyy();                             /*复制*/
 43 void findmaxfit();                        /*寻找适应度最大的y*/
 44 bool compare(Yvector a,Yvector b);
 45 int main(void){
 46     srand(time(NULL));
 47     freopen("input.txt","r",stdin);
 48     freopen("output.txt","w",stdout);
 49     inputX();
 50     inputY();
 51     evaluate();
 52     while(generation<=MAX_GENS){
 53         select();
 54         copyy();
 55         xcover();
 56         mutate();
 57         evaluate();
 58         findmaxfit();
 59     }
 60     printf("种群数量: %d\n",MAX_Y);
 61     printf("经历年代: %d\n",MAX_GENS);
 62     printf("保留比例: %.2lf\n",SAVE);
 63     printf("交叉概率: %.2lf\n",PXCOVER);
 64     printf("变异概率: %.2lf\n",PMUTATION);
 65     printf("交叉因子: %.2lf\n",PA);
 66     printf("变异因子: %.2lf\n",PM);
 67     printf("Y = (%lf,%lf,%lf,%lf,%lf,%lf)\n",fity.vec[0],fity.vec[1],fity.vec[2],fity.vec[3],fity.vec[4],fity.vec[5]);
 68     printf("fitness = %lf\n",fity.fitness);
 69     printf("f(x) = %lf\n",1.0/fity.fitness);
 70     fclose(stdin);
 71     fclose(stdout);
 72     return 0;
 73 }
 74 void inputX(){
 75     scanf("%d",&n);
 76     for(int i=0;i<n;++i){
 77         double mod=0;
 78         for(int j=0;j<N;++j){
 79             scanf("%lf",&x[i].vec[j]);
 80             mod+=x[i].vec[j]*x[i].vec[j];
 81         }
 82         x[i].mod=sqrt(mod);
 83     }
 84 }
 85 void inputY(){
 86     for(int i=0;i<N;++i){
 87         scanf("%lf%lf",&lower[i],&upper[i]);
 88         for(int j=0;j<MAX_Y;++j){
 89             y[j].vec[i]=randval(lower[i],upper[i]);
 90         }
 91     }
 92 }
 93 double randval(double lower,double upper){
 94     return lower+1.0*rand()/RAND_MAX*(upper-lower);
 95 }
 96 void evaluate(){
 97     for(int i=0;i<MAX_Y;++i){
 98         double mod=0;
 99         for(int j=0;j<N;++j){
100             mod+=y[i].vec[j]*y[i].vec[j];
101         }
102         y[i].mod=sqrt(mod);
103     }
104     double fit=0;
105     for(int i=0;i<MAX_Y;++i){
106         double temp=0;
107         for(int j=0;j<n;++j){
108             double xy=0;
109             for(int k=0;k<N;++k){
110                 xy+=y[i].vec[k]*x[j].vec[k];
111             }
112             temp+=fabs((y[i].mod*x[j].mod)/xy);
113         }
114         fit+=temp;
115         y[i].fitness=temp;
116     }
117     sort(y,y+MAX_Y,compare);
118     double temp=0;
119     for(int i=0;i<MAX_Y;++i){
120         temp+=y[i].fitness;
121         y[i].fitsum=temp/fit;
122     }
123 }
124 void select(){
125     for(int i=0;i<MAX_Y*SAVE;++i){
126         newy[i]=y[i];
127     }
128     for(int i=MAX_Y*SAVE;i<MAX_Y;++i){
129         double rand=randval(0,1);
130         for(int j=0;j<MAX_Y;++j){
131             if(y[j].fitsum>rand||fabs(y[j].fitness-rand)<=EPS){
132                 newy[i]=y[j];
133                 break;
134             }
135         }
136     }
137     copyy();
138     generation++;
139 /*
140     printf("******************************************************************\n");
141     printf("\tgeneration: %d\n",generation);
142     for(int i=0;i<MAX_Y;++i){
143         for(int j=0;j<N;++j){
144             printf("%10lf ",y[i].vec[j]);
145         }
146         printf("\n");
147     }
148     printf("******************************************************************\n");
149 */
150 }
151 void copyy(){
152     memset(y,0,sizeof(y));
153     for(int i=0;i<MAX_Y;++i){
154         for(int j=0;j<N;++j){
155             y[i].vec[j]=newy[i].vec[j];
156         }
157     }
158 }
159 void xcover(){
160     memset(index,0,sizeof(index));
161     for(int i=0;i<MAX_Y;++i){
162         int temp;
163         do{
164             temp=rand()%MAX_Y;
165         }while(index[temp]);
166         index[temp]=1;
167         double p=1.0*rand()/RAND_MAX;
168         if(p<PXCOVER||fabs(p-PXCOVER)<=EPS){
169             for(int j=0;j<N;++j){
170                 double t=y[i].vec[j];
171                 y[i].vec[j]=(1-PA)*y[i].vec[j]+PA*y[temp].vec[j];
172                 y[temp].vec[j]=(1-PA)*y[temp].vec[j]+PA*t;
173             }
174         }
175     }
176 }
177 void mutate(){
178     for(int i=0;i<MAX_Y;i++){
179         double p=1.0*rand()/RAND_MAX;
180         if(p<PMUTATION||fabs(p-PMUTATION)<=EPS){
181             int temp=rand()%2;
182             if(temp){
183                 for(int j=0;j<N;++j){
184                     y[i].vec[j]=y[i].vec[j]+PM*(upper[j]-y[i].vec[j])*(1.0*rand()/RAND_MAX);
185                 }
186             }else{
187                 for(int j=0;j<N;++j){
188                     y[i].vec[j]=y[i].vec[j]-PM*(y[i].vec[j]-lower[j])*(1.0*rand()/RAND_MAX);
189                 }
190             }
191         }
192     }
193 }
194 void findmaxfit(){
195     if(y[0].fitness>fity.fitness||fabs(y[0].fitness-fity.fitness)<=EPS)
196         fity=y[0];
197 }
198 bool compare(Yvector a,Yvector b){
199     return a.fitness>b.fitness;
200 }
时间: 2024-12-15 01:37:26

智能算法-遗传算法的相关文章

MATLAB智能算法30个案例分析

<matlab智能算法30个案例分析>采用案例形式,以智能算法为主线,讲解了遗传算法.免疫算法.退火算法.粒子群算法.鱼群算法.蚁群算法和神经网络算法等最常用的智能算法的matlab实现.本书共给出30个案例,每个案例都是一个使用智能算法解决问题的具体实例,所有案例均由理论讲解.案例背景.matlab程序实现和扩展阅读四个部分组成,并配有完整的原创程序,使读者在掌握算法的同时更能快速提高使用算法求解实际问题的能力.本书可作为本科毕业设计.研究生项目设计.博士低年级课题设计参考书籍,同时对广大科

优化算法——遗传算法

与遗传算法的第一次接触 遗传算法的基本概念 基本定义 遗传算法的基本流程 遗传算法过程中的具体操作 参数的编码 二进制编码 Gray编码 实数编码 有序编码 初始群体的设定 适应度函数的计算 遗传操作设计 选择selection 交叉crossover 变异mutation 控制参数的设定 求解优化问题的实例 问题描述 问题分析 算法设计 个体编码 适应值函数 选择策略 杂交算子 变异算子 参数设置 初始化 终止条件 实验代码 最终结果 与遗传算法的第一次接触 遗传算法是我进入研究生阶段接触的第

智能算法|有哪些以动物命名的算法?

黄梅时节家家雨,青草池塘处处蛙. 有约不来过夜半,闲敲棋子落灯花. 鱼群算法?鸟群算法?蝙蝠算法?蚁群算法?病毒算法?...what?这些是什么沙雕算法? 别看这些算法名字挺接地气的,实际上确实很接地气... 以动物命名的算法可远不止这些,俗话说得好,只要脑洞大,就能玩出新花样,这句话在启发式算法界绝对名副其实!然鹅什么是启发式算法呢? 启发式算法:一个基于直观或经验构造的算法,在可接受的花费(指计算时间和空间)下给出待解决组合优化问题每一个实例的一个可行解,该可行解与最优解的偏离程度一般不能被

智能算法---蚁群算法

智能算法---蚁群算法 1 蚁群算法及其基本思想 蚁群算法是一种智能优化算法,通过蚁群优化求解复杂问题,ACO在离散优化问题方面有比较好的优越性. 基本思想(以旅行商问题为例) 设置多只蚂蚁,分头并行搜索. 每只蚂蚁完成一次周游后,在行进的路上释放信息素,信息素量与解的质量成正比. 蚂蚁路径的选择根据信息素强度大小(初始信息素量设为相等),同时考虑两点之间的距离,采用随机的局部搜索策略.这使得距离较       短的边,其上的信息素量较大,后来的蚂蚁选择该边的概率也较大. 每只蚂蚁只能走合法路线

信用评分卡模型入门(智能算法)

信用评分卡模型入门 2016-07-26 智能算法 智能算法 一.背景介绍:   4.数据整理(数据清理过程) 大量取样的数据要真正最后进入模型,必须经过数据整理.在数据处理时应注意检查数据的逻辑性.区分"数据缺失"和"0".根据逻辑推断某些值.寻找反常数据.评估是否真实.可以通过求最小值.最大值和平均值的方法,初步验证抽样数据是否随机.是否具有代表性. 常用清理过程包含:缺失值分析处理.单变量异常分析(LOF分析处理或聚类分析) 5.变量选择 变量选择要同时具有数

智能算法:蚁群算法

作为一种现代智能算法,蚁群算法不需要任何先验知识,最初只是随机地选择搜索路径,随着对解空间的了解,搜索更加具有规律性,并逐渐得到全局最优解.目前,蚁群算法已被成功地应用于求解旅行商问题.车辆调度问题以及指派问题等... 求解TSP: %% 第22章 蚁群算法的优化计算——旅行商问题(TSP)优化 %% 清空环境变量 clear all clc %% 导入数据 load citys_data.mat %% 计算城市间相互距离 n = size(citys,1); D = zeros(n,n); f

智能算法的研究与实现

目前计算机中的搜索算法有哪些? 深度优先,广度优先(源自于数据结构) 穷举法(列出所有可能),回溯法(深度优先思想加上返回式搜索)源自于算法设计与分析 爬山法,模拟退火,遗传算法(智能化算法)都是一些自适应的随机搜索算法,(有点类似于不确定性算法,也是一些启发式算法(另外蚁群算法也是启发式算法) 梯度下降算法(源自于最优化理论) 遗传算法该如何理解 从启发式的角度去理解更容易: 遗传算法参照达尔文的进化论,认为物种都是向好的方向去发展(适者生存),因此可以认为到足够的代数之后,得到的最值可实际的

五种智能算法解决最大割问题分析与比较_爱学术

[摘要]最大割问题(Max-cut Problem)是一个典型的NP难组合优化问题.文章采用遗传算法.分布估计算法.Hopfield网络方法.蚁群算法.粒子群算法等5种算法对最大割问题进行求解,并用标准的多个不同规模最大割测试数据进行测试,研究各参数对算法的影响,并比较各种算法的时间复杂度和空间复杂度.测试结果表明该五种算法虽然在执行效率上有差异,但都能较好的解决最大割问题. [作者] 陈宁  黎子芬  陈金柱 转载至爱学术:https://www.ixueshu.com/document/4c

【智能算法】粒子群算法(Particle Swarm Optimization)超详细解析+入门代码实例讲解

喜欢的话可以扫码关注我们的公众号哦,更多精彩尽在微信公众号[程序猿声] 01 算法起源 粒子群优化算法(PSO)是一种进化计算技术(evolutionary computation),1995 年由Eberhart 博士和kennedy 博士提出,源于对鸟群捕食的行为研究 .该算法最初是受到飞鸟集群活动的规律性启发,进而利用群体智能建立的一个简化模型.粒子群算法在对动物集群活动行为观察基础上,利用群体中的个体对信息的共享使整个群体的运动在问题求解空间中产生从无序到有序的演化过程,从而获得最优解.