码迷,mamicode.com
首页 > 编程语言 > 详细

遗传算法入门

时间:2017-09-24 18:16:28      阅读:237      评论:0      收藏:0      [点我收藏+]

标签:有一个   常用   详细   利用   positive   tis   open   rms   one   

 

关于遗传算法

遗传算法的有趣应用很多,诸如寻路问题,8数码问题,囚犯困境,动作控制,找圆心问题(这是一个国外网友的建议:在一个不规则的多边形 中,寻找一个包含在该多边形内的最大圆圈的圆心。),TSP问题(在以后的章节里面将做详细介绍。),生产调度问题,人工生命模拟等。直到最后看到一个非 常有趣的比喻,觉得由此引出的袋鼠跳问题(暂且这么叫它吧),既有趣直观又直达遗传算法的本质,确实非常适合作为初学者入门的例子。

 

 

 问题的提出与解决方案

让我们先来考虑考虑下面这个问题的解决办法。已知一元函数:

技术分享

技术分享

 

 

                                                   

                 

             现在要求在既定的区间内找出函数的最大值  

             

 

 

极大值、最大值、局部最优解、全局最优解

        在解决上面提出的问题之前我们有必要先澄清几个以后将常常会碰到的概念:极 大值、最大值、局部最优解、全局最优解。学过高中数学的人都知道极大值在一个小邻域里面左边的函数值递增,右边的函数值递减,在图2.1里面的表现就是一 个“山峰”。当然,在图上有很多个“山峰”,所以这个函数有很多个极大值。而对于一个函数来说,最大值就是在所有极大值当中,最大的那个。所以极大值具有局部性,而最大值则具有全局性。

        因为遗传算法中每一条染色体,对应着遗传算法的一个 解决方案,一般我们用适应性函数(fitness function)来衡量这个解决方案的优劣。所以从一个基因组到其解的适应度形成一个映射。所以也可以把遗传算法的过程看作是一个在多元函数里面求最优解的过程。在这个多维曲面里面也有数不清的“山峰”,而这些最优解所对应的就是局部最优解。而其中也会有一个“山峰”的海拔最高的,那么这个就是全局最优 解。而遗传算法的任务就是尽量爬到最高峰,而不是陷落在一些小山峰。(另外,值得注意的是遗传算法不一定要找“最高的山峰”,如果问题的适应度评价越小越好的话,那么全局最优解就是函数的最小值,对应的,遗传算法所要找的就是“最深的谷底”)如果至今你还不太理解的话,那么你先往下看。本章的示例程序将会 非常形象的表现出这个情景。

        

 

 

袋鼠跳问题

        既然我们把 函数曲线理解成一个一个山峰和山谷组成的山脉。那么我们可以设想所得到的每一个解就是一只袋鼠,我们希望它们不断的向着更高处跳去,直到跳到最高的山峰(尽管袋鼠本身不见得愿意那么做)。所以求最大值的过程就转化成一个“袋鼠跳”的过程。下面介绍介绍“袋鼠跳”的几种方式。

 

 

爬山法、模拟退火和遗传算法

 

 

解决寻找最大值问题的几种常见的算法:

 

 

        1. 爬山法(最速上升爬山法):

         从搜索空间中随机产生邻近的点,从中选择对应解最优的个体,替换原来的个体,不断 重复上述过程。因为只对“邻近”的点作比较,所以目光比较“短浅”,常常只能收敛到离开初始位置比较近的局部最优解上面。对于存在很多局部最优点的问题,通过一个简单的迭代找出全局最优解的机会非常渺茫。(在爬山法中,袋鼠最有希望到达最靠近它出发点的山顶,但不能保证该山顶是珠穆朗玛峰,或者是一个非常 高的山峰。因为一路上它只顾上坡,没有下坡。)

 

 

       2. 模拟退火:

        这个方法来自金属热加工过程的启发。在金属热加工过程中,当金属的温度超过它的熔点(Melting Point)时,原子就会激烈地随机运动。与所有的其它的物理系统相类似,原子的这种运动趋向于寻找其能量的极小状态。在这个能量的变迁过程中,开始时。温度非常高, 使得原子具有很高的能量。随着温度不断降低,金属逐渐冷却,金属中的原子的能量就越来越小,最后达到所有可能的最低点。利用模拟退火的时候,让算法从较大的跳跃开始,使到它有足够的“能量”逃离可能“路过”的局部最优解而不至于限制在其中,当它停在全局最优解附近的时候,逐渐的减小跳跃量,以便使其“落脚 ”到全局最优解上。(在模拟退火中,袋鼠喝醉了,而且随机地大跳跃了很长时间。运气好的话,它从一个山峰跳过山谷,到了另外一个更高的山峰上。但最后,它渐渐清醒了并朝着它所在的峰顶跳去。)

 

 

       3. 遗传算法:

       遗传算法 ( GA , Genetic Algorithm ) ,也称进化算法 。 遗传算法是受达尔文的进化论的启发,借鉴生物进化过程而提出的一种启发式搜索算法。因此在介绍遗传算法前有必要简单的介绍生物进化知识。

        模拟物竞天择的生物进化过程,通过维护一个潜在解的群体执行了多方向的搜索,并支持这些方向上的信息构成和交换。以面为单位的搜索,比以点为单位的搜索,更能发现全局最优解。(在遗传算法中,有很多袋鼠,它们降落到喜玛拉雅山脉的任意地方。这些袋鼠并不知道它们的任务是寻找珠穆朗玛峰。但每过几年,就在一些海拔高度较低的地方射杀一些袋鼠,并希望存活下来的袋鼠是多产的,在它们所处的地方生儿育女)(后来,一个叫天行健的网游给我想了一个更恰切的故事:从前,有一大群袋鼠,它们被莫名其妙的零散地遗弃于喜马拉雅山脉。于是只好在那里艰苦的生活。海拔 低的地方弥漫着一种无色无味的毒气,海拔越高毒气越稀薄。可是可怜的袋鼠们对此全然不觉,还是习惯于活蹦乱跳。于是,不断有袋鼠死于海拔较低的地方,而越是在海拔高的袋鼠越是能活得更久,也越有机会生儿育女。就这样经过许多年,这些袋鼠们竟然都不自觉地聚拢到了一个个的山峰上,可是在所有的袋鼠中,只有聚 拢到珠穆朗玛峰的袋鼠被带回了美丽的澳洲。)

        

 

 

进化论知识

   作为遗传算法生物背景的介绍,下面内容了解即可:

  种群(Population):生物的进化以群体的形式进行,这样的一个群体称为种群。

  个体:组成种群的单个生物。

  基因 ( Gene ) :一个遗传因子。

  染色体 ( Chromosome ) :包含一组的基因。

  生存竞争,适者生存:对环境适应度高的、牛B的个体参与繁殖的机会比较多,后代就会越来越多。适应度低的个体参与繁殖的机会比较少,后代就会越来越少。

  遗传与变异:新个体会遗传父母双方各一部分的基因,同时有一定的概率发生基因变异。

简单说来就是:繁殖过程,会发生基因交叉( Crossover ) ,基因突变 ( Mutation ) ,适应度( Fitness )低的个体会被逐步淘汰,而适应度高的个体会越来越多。那么经过N代的自然选择后,保存下来的个体都是适应度很高的,其中很可能包含史上产生的适应度最高的那个个体。

下面主要介绍介绍遗传算法实现的过程。

 

 

遗传算法的实现过程

          遗传算法的实现过程实际上就像自然界的进化过程那样。首先寻找一种对问题潜在解进行“数字化”编码的方案。(建立表现型和基因型的映射关系。)然后用随机 数初始化一个种群(那么第一批袋鼠就被随意地分散在山脉上。),种群里面的个体就是这些数字化的编码。接下来,通过适当的解码过程之后,(得到袋鼠的位置 坐标。)用适应性函数对每一个基因个体作一次适应度评估。(袋鼠爬得越高,越是受我们的喜爱,所以适应度相应越高。)用选择函数按照某种规定择优选 择。(我们要每隔一段时间,在山上射杀一些所在海拔较低的袋鼠,以保证袋鼠总体数目持平。)让个体基因交叉变异。(让袋鼠随机地跳一跳)然后产生子 代。(希望存活下来的袋鼠是多产的,并在那里生儿育女。)遗传算法并不保证你能获得问题的最优解,但是使用遗传算法的最大优点在于你不必去了解和操心如何 去“找”最优解。(你不必去指导袋鼠向那边跳,跳多远。)而只要简单的“否定”一些表现不好的个体就行了。(把那些总是爱走下坡路的袋鼠射杀。)以后你会 慢慢理解这句话,这是遗传算法的精粹!

        

        所以我们总结出遗传算法的一般步骤:

        开始循环直至找到满意的解。

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

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

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

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

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

结束循环。

 技术分享

 

接下来,我们将详细地剖析遗传算法过程的每一个细节。

        

 

 

编制袋鼠的染色体----基因的编码方式

          通过前一章的学习,读者已经了解到人类染色体的编码符号集,由4种碱基的两种配合组成。共有4种情况,相当于2 bit的信息量。这是人类基因的编码方式,那么我们使用遗传算法的时候编码又该如何处理呢?

         受到人类染色体结构的启发,我们可以设想一下,假设目前只有“0”,“1”两种碱基,我们也用一条链条把他们有序的串连在一起,因为每一个单位都能表现出 1 bit的信息量,所以一条足够长的染色体就能为我们勾勒出一个个体的所有特征。这就是二进制编码法,染色体大致如下:

010010011011011110111110

        上面的编码方式虽然简单直观,但明显地,当个体特征比较复杂的时候,需要大量的编码才能精确地描述,相应的解码过程(类似于生物学中的DNA翻译过程,就是把基因型映射到表现型的过程。)将过份繁复,为改善遗传算法的计算复杂性、提高运算效率,提出了浮点数编码。染色体大致如下:

1.2 – 3.3 – 2.0 –5.4 – 2.7 – 4.3

        那么我们如何利用这两种编码方式来为袋鼠的染色体编码呢?因为编码的目的是建立表现型到基因型的映射关系,而表现型一般就被理解为个体的特征。比如人的基因型是46条染色体所描述的(总长度 两 米的纸条?),却能解码成一个个眼,耳,口,鼻等特征各不相同的活生生的人。所以我们要想为“袋鼠”的染色体编码,我们必须先来考虑“袋鼠”的“个体特征”是什么。也许有的人会说,袋鼠的特征很多,比如性别,身长,体重,也许它喜欢吃什么也能算作其中一个特征。但具体在解决这个问题的情况下,我们应该进 一步思考:无论这只袋鼠是长短,肥瘦,只要它在低海拔就会被射杀,同时也没有规定身长的袋鼠能跳得远一些,身短的袋鼠跳得近一些。当然它爱吃什么就更不相关了。我们由始至终都只关心一件事情:袋鼠在哪里。因为只要我们知道袋鼠在那里,我们就能做两件必须去做的事情:

(1)通过查阅喜玛拉雅山脉的地图来得知袋鼠所在的海拔高度(通过自变量求函数值。)以判断我们有没必要把它射杀。

(2)知道袋鼠跳一跳后去到哪个新位置。

         如 果我们一时无法准确的判断哪些“个体特征”是必要的,哪些是非必要的,我们常常可以用到这样一种思维方式:比如你认为袋鼠的爱吃什么东西非常必要,那么你就想一想,有两只袋鼠,它们其它的个体特征完全同等的情况下,一只爱吃草,另外一只爱吃果。你会马上发现,这不会对它们的命运有丝毫的影响,它们应该有同 等的概率被射杀!只因它们处于同一个地方。(值得一提的是,如果你的基因编码设计中包含了袋鼠爱吃什么的信息,这其实不会影响到袋鼠的进化的过程,而那只攀到珠穆朗玛峰的袋鼠吃什么也完全是随机的,但是它所在的位置却是非常确定的。)

        以上是对遗传算法编码过程中经常经历的思维过程,必须把具体问题抽象成数学模型,突出主要矛盾,舍弃次要矛盾。只有这样才能简洁而有效的解决问题。希望初学者仔细琢磨。

        既然确定了袋鼠的位置作为个体特征,具体来说位置就 是横坐标。那么接下来,我们就要建立表现型到基因型的映射关系。就是说如何用编码来表现出袋鼠所在的横坐标。由于横坐标是一个实数,所以说透了我们就是要对这个实数编码。回顾我们上面所介绍的两种编码方式,读者最先想到的应该就是,对于二进制编码方式来说,编码会比较复杂,而对于浮点数编码方式来说,则会 比较简洁。恩,正如你所想的,用浮点数编码,仅仅需要一个浮点数而已。而下面则介绍如何建立二进制编码到一个实数的映射。

        明显地,一定长度的二进制编码序列,只能表示一定精度的浮点数。譬如我们要求解精确到六位小数,由于区间长度为2 – (-1) = 3 ,为了保证精度要求,至少把区间[-1,2]分为3 × 106等份。又因为

        技术分享

 

        所以编码的二进制串至少需要22位。

        把一个二进制串(b0,b1,....bn)转化位区间里面对应的实数值通过下面两个步骤。

     (1)将一个二进制串代表的二进制数转化为10进制数:

                技术分享

 

     (2)对应区间内的实数:

                          技术分享

 

      

       例如一个二进制串<1000101110110101000111>表示实数值0.637197。

          技术分享

 

        二进制串<0000000000000000000000>和<1111111111111111111111>则分别表示区间的两个端点值-1和2。

        由于往下章节的示例程序几乎都只用到浮点数编码,所以这个“袋鼠跳”问题的解决方案也是采用浮点数编码的。往下的程序示例(包括装载基因的类,突变函数)都是针对浮点数编码的。(对于二进制编码这里只作简单的介绍,不过这个“袋鼠跳”完全可以用二进制编码来解决的,而且更有效一些。所以读者可以自己尝试用 二进制编码来解决。)

       好了,目前为止我们把袋鼠的染色体给研究透了,让我们继续跟进袋鼠的进化旅程。   

 

 

物竞天择--适应性评分与及选择函数。

 

 

1.物竞――适应度函数(fitness function

        自然界生物竞争过程往往包含两个方面:生物相互间的搏斗与及生物与客观环境的搏斗过程。但在我们这个实例里面,你可以想象到,袋鼠相互之间是非常友好的,它们并不需要互相搏斗以争取生存的权利。它们的生死存亡更多是取决于你的判断。因为你要衡量哪只袋鼠该杀,哪只袋鼠不该杀,所以你必须制定一个衡量的标准。而对于这个问题,这个衡量的标准比较容易制定:袋鼠所在的海拔高度。(因为你单纯地希望袋鼠爬得越高越好。)所以我们直接用袋鼠的海拔高度作为它们的适应性评分。即适应度函数直接返回函数值就行了。

 

 

2.天择――选择函数(selection

        自然界中,越适应的个体就越有可能繁殖后代。但是也不能说适应度越高的就肯定后代越多,只能是从概率上来说更多。(毕竟有些所处海拔高度较低的袋鼠很幸运,逃过了你的眼睛。)那么我们怎么来建立这种概率关系呢?下面我们介绍一种常用的选择方法――轮盘赌(Roulette Wheel Selection)选择法。假设种群数目,某个个体其适应度为,则其被选中的概率为:

                                    技术分享

 

        比如我们有5条染色体,他们所对应的适应度评分分别为:5,7,10,13,15。

        所以累计总适应度为:

                            技术分享

 

     

        所以各个个体被选中的概率分别为:

                   技术分享

 

 

           有人会问为什么我们把它叫成轮盘赌选择法啊?其实你只要看看图2-2的轮盘就会明白了。这个轮盘是按照各个个体的适应度比例进行分块的。你可以想象一下,我们转动轮盘,轮盘停下来的时候,指针会随机地指向某一个个体所代表的区域,那么非常幸运地,这个个体被选中了。(很明显,适应度评分越高的个体被选中的概率越大。)

技术分享

 

               

 

遗传变异――基因重组(交叉)与基因突变。

       应该说这两个步骤就是使到子代不同于父代的根本原因(注意,我没有说是子代优于父代的原因,只有经过自然的选择后,才会出现子代优于父代的倾向。)。对于这两种遗传操作,二进制编码和浮点型编码在处理上有很大的差异,其中二进制编码的遗传操作过程,比较类似于自然界里面的过程,下面将分开讲述。

 

 

1.基因重组/交叉(recombination/crossover)

    (1)二进制编码

      回顾上一章介绍的基因交叉过程:同源染色体联会的过程中,非姐妹染色单体(分别来自父母双方)之间常常发生交叉,并且相互交换一部分染色体,如图2-3。事实上,二进制编码的基因交换过程也非常类似这个过程――随机把其中几个位于同一位置的编码进行交换,产生新的个体,如图所示。

        技术分享

 

    (2)浮点数编码

      如果一条基因中含有 多个浮点数编码,那么也可以用跟上面类似的方法进行基因交叉,不同的是进行交叉的基本单位不是二进制码,而是浮点数。而如果对于单个浮点数的基因交叉,就有其它不同的重组方式了,比如中间重组:

这样只要随机产生就能得到介于父代基因编码值和母代基因编码值之间的值作为子代基因编码的值。

      考 虑到“袋鼠跳”问题的具体情况――袋鼠的个体特征仅仅表现为它所处的位置。可以想象,同一个位置的袋鼠的基因是完全相同的,而两条相同的基因进行交叉后,相当于什么都没有做,所以我们不打算在这个例子里面使用交叉这一个遗传操作步骤。(当然硬要这个操作步骤也不是不行的,你可以把两只异地的袋鼠捉到一起, 让它们交配,然后产生子代,再把它们送到它们应该到的地方。)

       

 

2.基因突变(Mutation)

   (1)二进制编码

      同样回顾一下上一章所介绍的基因突变过程:基因突变是染色体的某一个位点上基因的改变。基因突变使一个基因变成它的等位基因,并且通常会引起一定的表现型变化。恩,正如上面所说,二进制编码的遗传操作过程和生物学中的过程非常相类似,基因串上的“ 0”或“ 1”有一定几率变成与之相反的“ 1”或“ 0”。例如下面这串二进制编码:

101101001011001

经过基因突变后,可能变成以下这串新的编码:

                          001101011011001

(2)浮点型编码

        浮点型编码的基因突变过程一般是对原来的浮点数增加或者减少一个小随机数。比如原来的浮点数串如下:

1.2,3.4, 5.1, 6.0, 4.5

变异后,可能得到如下的浮点数串:

1.3,3.1, 4.9, 6.3, 4.4

        当 然,这个小随机数也有大小之分,我们一般管它叫“步长”。(想想“袋鼠跳”问题,袋鼠跳的长短就是这个步长。)一般来说步长越大,开始时进化的速度会比较快,但是后来比较难收敛到精确的点上。而小步长却能较精确的收敛到一个点上。所以很多时候为了加快遗传算法的进化速度,而又能保证后期能够比较精确地收敛 到最优解上面,会采取动态改变步长的方法。其实这个过程与前面介绍的模拟退火过程比较相类似,读者可以做简单的回顾。

      

值得一提的是遗传算法中基因突变的特点和前面提到的生物学中的基因突变的特点非常相类似,这里回顾一下:

    1.基因突变是随机发生的,且突变频率很低。(不过某些应用中需要高概率的变异)

    2.大多数基因变异对生物本身是有害的。

    3.基因突变是不定向的。

    好了,到此为止,基因编码,基因适应度评估,基因选择,基因变异都一一实现了,剩下来的就是把这些遗传过程的“零件”装配起来了。

 

 

让袋鼠在你的电脑里进化――程序的运行

       我想没有什么别的方法比自己亲手写一个程序然后通过修改相关参数不断调试程序,更能理解并且掌握一种算法了。不知道你还记不记得你初学程序的日子,我想你上机动手写程序比坐在那里看一本厚厚的程序开发指南效率不知高上多少倍,兴趣也特命浓厚,激情也特别高涨。恩,你就是需要那样的感觉,学遗传算法也是一样 的。你需要把自己的代码运行起来,然后看看程序是否按照你所想象的去运行,如果没有,你就要思考原因,按照你的想法去改善代码,试着去弄清其中的内在联系。这是一个思维激活的过程,你大脑中的神经网络正在剧烈抖动(呵呵,或许学到后面你就知道你大脑的神经网络是如何“抖动”的。),试图去接受这新鲜而有 趣的知识。遗传算法(包括以后要学到的人工神经网络)包含大量的可控参数,比如进化代数、人口数目、选择概率、交叉概率、变异概率、变异的步长还有以后学到的很多。这些参数之间的搭配关系,不能指望别人用“灌输”的方式让你被动接受,这需要你自己在不断的尝试,不断的调整中去形成一种“感觉”的。很多时候 一个参数的量变在整个算法中会表现出质的变化。而算法的效果又能从宏观上反映参数的设置。

 

 

抽象过程的演示

        技术分享

 

           刚开始的时候,袋鼠分布得比较分散它们遍布了各个山岭,有的在高峰上,有的在深谷里。(如图2-8)

           技术分享

 

             经过了几代的进化后,一些海拔高度比较低的都被我们射杀了,而海拔较高的袋鼠却不断的生儿育女。(如图2-9)

           技术分享

 

          最后整个袋鼠种群就只出现在最高峰上面(最优解上)。(如图2-10)

            技术分享

 

      

            当然,袋鼠不是每一次都能跳到珠穆朗玛峰的,如图2-11所 示。(就是说不是每次都能收敛到最优解)也许它们跳到了某一个山峰,就自大的认为它们已经“会当凌绝顶”了。(当然,事实上是因为不管它们向前还是向后跳都只能得到更小的适应度,所以不等它们跳过山谷,再跳到旁边更高的山峰,就被我们射杀了。)所以,我们为了使到袋鼠每次都尽可能的攀到珠穆朗玛峰,而不是 留恋在某一个低一些的山峰,我们有两个改进的办法,其一是初始人口数目更多一些,以使最好有一些袋鼠一开始就降落到最高峰的附近,但是这种方法对于搜索空间非常大的问题往往是无能为力的。我们常常采用的方法是使袋鼠有一定的概率跳一个很大的步长,以使袋鼠有可能跳过一个山谷到更高的山峰去。这些改进的方法 留给读者自己去实现。

       技术分享

 

           另外,如果把变异的机率调得比较高,那么就会出现袋鼠跳得比较活跃的局面,但是很可能丢失了最优解;而如果变异的机率比较低的话,袋鼠跳得不太活跃,找到最优解的速度就会慢一些,这也留给读者自己去体验。

          作为一个寻找大值的程序,这个的效率还 很低。我希望留给初学者更多改进的空间,大家不必受限于现有的方法,大可以发挥丰富的想象力,自己想办法去提高程序的效率,然后自己去实现它,让事实去验证你的想法是否真的能提高效率,抑或刚好相反。恩,在这个过程当中,大家不知不觉地走进了遗传算法的圣殿了,胜于一切繁复公式的摆设和教条式的讲解。

 

 

代码实现

    

/**************************************************************************/
/* This is a simple genetic algorithm implementation where the */
/* evaluation function takes positive values only and the      */
/* fitness of an individual is the same as the value of the    */
/* objective function                                          */
/**************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/* Change any of these parameters to match your needs */

#define POPSIZE 50               /* population size */
#define MAXGENS 1000             /* max. number of generations */
#define NVARS 3                  /* no. of problem variables */     //gadata.txt中有3行数据,可以给定3组不同范围的数据
#define PXOVER 0.8               /* probability of crossover */
#define PMUTATION 0.15           /* probability of mutation */
#define TRUE 1
#define FALSE 0

int generation;                  /* current generation no. */
int cur_best;                    /* best individual */
FILE *galog;                     /* an output file */

struct genotype /* genotype (GT), a member of the population */
{
    double gene[NVARS];        /* a string of variables */ 
    double fitness;            /* GT‘s fitness */
    double upper[NVARS];       /* GT‘s variables upper bound */
    double lower[NVARS];       /* GT‘s variables lower bound */
    double rfitness;           /* relative fitness */
    double cfitness;           /* cumulative fitness */
};

struct genotype population[POPSIZE+1];    /* population */
struct genotype newpopulation[POPSIZE+1]; /* new population; */
/* replaces the */
/* old generation */

/* Declaration of procedures used by this genetic algorithm */

void initialize(void);
double randval(double, double);
void evaluate(void);
void keep_the_best(void);
void elitist(void);
void select(void);
void crossover(void);
void Xover(int,int);
void swap(double *, double *);
void mutate(void);
void report(void);

/***************************************************************/
/* Initialization function: Initializes the values of genes    */
/* within the variables bounds. It also initializes (to zero)  */
/* all fitness values for each member of the population. It    */
/* reads upper and lower bounds of each variable from the      */
/* input file `gadata.txt‘. It randomly generates values       */
/* between these bounds for each gene of each genotype in the  */
/* population. The format of the input file `gadata.txt‘ is    */
/* var1_lower_bound var1_upper bound                           */
/* var2_lower_bound var2_upper bound ...                       */
/***************************************************************/

void initialize(void)
{
    FILE *infile;
    int i, j;
    double lbound, ubound;
    
    if ((infile = fopen("gadata.txt","r"))==NULL)
    {
        fprintf(galog,"\nCannot open input file!\n");
        exit(1);
    }
    
    /* initialize variables within the bounds */
    
    for (i = 0; i < NVARS; i++)
    {
        fscanf(infile, "%lf",&lbound);
        fscanf(infile, "%lf",&ubound);
        
        for (j = 0; j < POPSIZE; j++)
        {
            population[j].fitness = 0;
            population[j].rfitness = 0;
            population[j].cfitness = 0;
            population[j].lower[i] = lbound;
            population[j].upper[i]= ubound;
            population[j].gene[i] = randval(population[j].lower[i],population[j].upper[i]);
        }
    }
    
    fclose(infile);
}

/***********************************************************/
/* Random value generator: Generates a value within bounds */
/***********************************************************/

double randval(double low, double high)
{
    double val;
    val = ((double)(rand()%1000)/1000.0)*(high - low) + low;
    return(val);
}

/*************************************************************/
/* Evaluation function: This takes a user defined function.  */
/* Each time this is changed, the code has to be recompiled. */
/* The current function is:  x[1]^2-x[1]*x[2]+x[3]           */
/*************************************************************/

void evaluate(void)
{
    int mem;
    int i;
    double x[NVARS+1];
    
    for (mem = 0; mem < POPSIZE; mem++)
    {
        for (i = 0; i < NVARS; i++)
            x[i+1] = population[mem].gene[i];
        
        population[mem].fitness = (x[1]*x[1]) - (x[1]*x[2]) + x[3];  //利用自定义函数求适应度
    }
}

/***************************************************************/
/* Keep_the_best function: This function keeps track of the    */
/* best member of the population. Note that the last entry in  */
/* the array Population holds a copy of the best individual    */
/***************************************************************/

void keep_the_best()
{
    int mem;
    int i;
    cur_best = 0; /* stores the index of the best individual */
    
    for (mem = 0; mem < POPSIZE; mem++)
    {
        if (population[mem].fitness > population[POPSIZE].fitness)
        {
            cur_best = mem;
            population[POPSIZE].fitness = population[mem].fitness;  //population[50]存放最好的fitness
        }
    }
    /* once the best member in the population is found, copy the genes */
    for (i = 0; i < NVARS; i++)
        population[POPSIZE].gene[i] = population[cur_best].gene[i]; //population[50]存放最好的gene
}

/****************************************************************/
/* Elitist function: The best member of the previous generation */
/* is stored as the last in the array. If the best member of    */
/* the current generation is worse then the best member of the  */
/* previous generation, the latter one would replace the worst  */
/* member of the current population                             */
/****************************************************************/

void elitist()
{
    int i;
    double best, worst;             /* best and worst fitness values */
    int best_mem, worst_mem; /* indexes of the best and worst member */
    
    best = population[0].fitness;
    worst = population[0].fitness;
    for (i = 0; i < POPSIZE - 1; ++i)
    {
        if(population[i].fitness > population[i+1].fitness)
        {     
            if (population[i].fitness >= best)
            {
                best = population[i].fitness;
                best_mem = i;
            }
            if (population[i+1].fitness <= worst)
            {
                worst = population[i+1].fitness;
                worst_mem = i + 1;
            }
        }
        else
        {
            if (population[i].fitness <= worst)
            {
                worst = population[i].fitness;
                worst_mem = i;
            }
            if (population[i+1].fitness >= best)
            {
                best = population[i+1].fitness;
                best_mem = i + 1;
            }
        }
    }
    /* if best individual from the new population is better than */
    /* the best individual from the previous population, then    */
    /* copy the best from the new population; else replace the   */
    /* worst individual from the current population with the     */
    /* best one from the previous generation                     */
    
    if (best >= population[POPSIZE].fitness)
    {
        for (i = 0; i < NVARS; i++)
            population[POPSIZE].gene[i] = population[best_mem].gene[i];
        population[POPSIZE].fitness = population[best_mem].fitness;
    }
    else
    {
        for (i = 0; i < NVARS; i++)
            population[worst_mem].gene[i] = population[POPSIZE].gene[i];
        population[worst_mem].fitness = population[POPSIZE].fitness;
    }
}
/**************************************************************/
/* Selection function: Standard proportional selection for    */
/* maximization problems incorporating elitist model - makes  */
/* sure that the best member survives                         */
/**************************************************************/

void select(void)
{
    int mem, i,j;
    double sum = 0;
    double p;
    
    /* find total fitness of the population */
    for (mem = 0; mem < POPSIZE; mem++)
    {
        sum += population[mem].fitness;
    }
    
    /* calculate relative fitness */
    for (mem = 0; mem < POPSIZE; mem++)
    {
        population[mem].rfitness =  population[mem].fitness/sum;    //计算相对fitness
    }
        
    /* calculate cumulative fitness */
    population[0].cfitness = population[0].rfitness;
    for (mem = 1; mem < POPSIZE; mem++)
    {
        population[mem].cfitness =  population[mem-1].cfitness + population[mem].rfitness;  //计算累计fitness
    }
    
    /* finally select survivors using cumulative fitness. */    
    for (i = 0; i < POPSIZE; i++)
    {
        p = rand()%1000/1000.0;
        if (p < population[0].cfitness)
            newpopulation[i] = population[0];     
        else
        {
            for (j = 0; j < POPSIZE;j++)     
                if (p >= population[j].cfitness && p<population[j+1].cfitness)
                    newpopulation[i] = population[j+1];
        }
    }

    /* once a new population is created, copy it back */    
    for (i = 0; i < POPSIZE; i++)
        population[i] = newpopulation[i];     
}

/***************************************************************/
/* Crossover selection: selects two parents that take part in  */
/* the crossover. Implements a single point crossover          */
/***************************************************************/

void crossover(void)
{
    int mem, one;
    int first  =  0; /* count of the number of members chosen */
    double x;
    
    for (mem = 0; mem < POPSIZE; ++mem)
    {
        x = rand()%1000/1000.0;
        if (x < PXOVER)
        {
            ++first;
            if (first % 2 == 0)
                Xover(one, mem);
            else
                one = mem;
        }
    }
}
/**************************************************************/
/* Crossover: performs crossover of the two selected parents. */
/**************************************************************/

void Xover(int one, int two)
{
    int i;
    int point; /* crossover point */
    
    /* select crossover point */
    if(NVARS > 1)
    {
        if(NVARS == 2)
            point = 1;
        else
            point = (rand() % (NVARS - 1)) + 1;
        
        for (i = 0; i < point; i++)
            swap(&population[one].gene[i], &population[two].gene[i]);
        
    }
}

/*************************************************************/
/* Swap: A swap procedure that helps in swapping 2 variables */
/*************************************************************/

void swap(double *x, double *y)
{
    double temp;
    
    temp = *x;
    *x = *y;
    *y = temp;
    
}

/**************************************************************/
/* Mutation: Random uniform mutation. A variable selected for */
/* mutation is replaced by a random value between lower and   */
/* upper bounds of this variable                              */
/**************************************************************/

void mutate(void)
{
    int i, j;
    double lbound, hbound;
    double x;
    
    for (i = 0; i < POPSIZE; i++)
        for (j = 0; j < NVARS; j++)
        {
            x = rand()%1000/1000.0;
            if (x < PMUTATION)
            {
                /* find the bounds on the variable to be mutated */
                lbound = population[i].lower[j];
                hbound = population[i].upper[j]; 
                population[i].gene[j] = randval(lbound, hbound);
            }
        }
}

/***************************************************************/
/* Report function: Reports progress of the simulation. Data   */
/* dumped into the  output file are separated by commas        */
/***************************************************************/

void report(void)
{
    int i;
    double best_val;            /* best population fitness */
    double avg;                 /* avg population fitness */
    double stddev;              /* std. deviation of population fitness */    //偏离、越轨
    double sum_square;          /* sum of square for std. calc */
    double square_sum;          /* square of sum for std. calc */
    double sum;                 /* total population fitness */
    
    sum = 0.0;
    sum_square = 0.0;
    
    for (i = 0; i < POPSIZE; i++)
    {
        sum += population[i].fitness;       //fitness之和
        sum_square += population[i].fitness * population[i].fitness;   //fitness的平方和
    }
    
    avg = sum/(double)POPSIZE;
    square_sum = avg * avg * POPSIZE;
    stddev = sqrt((sum_square - square_sum)/(POPSIZE - 1));
    best_val = population[POPSIZE].fitness;   //最大的fitness
    
    fprintf(galog, "\n%5d,      %6.3f, %6.3f, %6.3f \n\n", generation,
        best_val, avg, stddev);
}

/**************************************************************/
/* Main function: Each generation involves selecting the best */
/* members, performing crossover & mutation and then          */
/* evaluating the resulting population, until the terminating */
/* condition is satisfied                                     */
/**************************************************************/

void main(void)
{
    int i;
    
    if ((galog = fopen("galog.txt","w"))==NULL)
    {
        exit(1);
    }
    generation = 0;
    
    fprintf(galog, "\n generation  best  average  standard \n");
    fprintf(galog, " number      value fitness  deviation \n");
    
    //前期三步曲
    initialize();
    evaluate();
    keep_the_best();

    //迭代筛选
    while(generation<MAXGENS)
    {
        generation++;
        select();
        crossover();
        mutate();
        report();      //输出
        evaluate();    //更新适应度
        elitist();
    }

    fprintf(galog,"\n\n Simulation completed\n");
    fprintf(galog,"\n Best member: \n");
    
    for (i = 0; i < NVARS; i++)
    {
        fprintf (galog,"\n var(%d) = %3.3f",i,population[POPSIZE].gene[i]);
    }
    fprintf(galog,"\n\n Best fitness = %3.3f",population[POPSIZE].fitness);

    fclose(galog);
    printf("Success\n");
}
/***************************************************************/

 

 

 

前人建树(关于遗传算法的精品文献)

   遗传算法入门到掌握:http://blog.csdn.net/emiyasstar__/article/details/6938608/

   遗传算法入门: http://www.cnblogs.com/heaad/archive/2010/12/23/1914725.html

   知乎(???): https://www.zhihu.com/question/23293449

遗传算法入门

标签:有一个   常用   详细   利用   positive   tis   open   rms   one   

原文地址:http://www.cnblogs.com/muzu/p/7587723.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!