遗传算法介绍并附上Matlab代码

1440359316

1、遗传算法介绍

遗传算法，模拟达尔文进化论的自然选择和遗产学机理的生物进化构成的计算模型，一种不断选择优良个体的算法。谈到遗传，想想自然界动物遗传是怎么来的，自然主要过程包括染色体的选择，交叉，变异（不明白这个的可以去看看生物学），这些操作后，保证了以后的个基本上是最优的，那么以后再继续这样下去，就可以一直最优了。

2、解决的问题

先说说自己要解决的问题吧，遗传算法很有名，自然能解决的问题很多了，在原理上不变的情况下，只要改变模型的应用环境和形式，基本上都可以。但是遗传算法主要还是解决优化类问题，尤其是那种不能直接解出来的很复杂的问题，而实际情况通常也是这样的。

本部分主要为了了解遗传算法的应用，选择一个复杂的二维函数来进行遗传算法优化，函数显示为y=10*sin(5*x)+7*abs(x-5)+10,这个函数图像为：

怎么样，还是有一点复杂的吧，当然你还可以任意假设和编写，只要符合就可以。那么现在问你要你一下求出最大值你能求出来吗？（这个貌似可以，很容易写出来----如果再复杂一点估计就不行了）这类问题如果用遗传算法或者其他优化方法九很简单了，为什么呢？说白了，其实就是计算机太笨了同时计算速度又超快，举个例子吧，我把x等分成100万份，再一下子都带值进去算，求出对应的100万个y的值，再比较他们的大小找到最大值不就可以了吗，很笨吧，人算是不可能的，但是计算机可以。而遗传算法也是很笨的一个个搜索，只不过加了一点什么了，就是人为的给它算的方向和策略，让它有目的的算，这也就是算法了。

4 V7 Z7 _) \* a- X2 @+ d; D$ y

3、如何开始？

不明白遗传算法的会问怎么开始呢？恩，其实每个算法都有自己的开始方式，遗传算法也是，首先是选择个体了。我们知道一个种群中可能只有一个个体吗？不可能吧，肯定很多人才对，这样相互结合的机会才多，产生的后代才会多种多样，才会有更好的优良基因，有利于种群的发展。那么算法也是如此，当然个体多少是个问题，一般来说20-100之间我觉得差不多了。那么个体究竟是什么呢？在我们这个问题中自然就是x值了。其他情况下，个体就是所求问题的变量，这里我们假设个体数选100个，也就是开始选100个不同的x值，不明白的话就假设是100个猴子吧。好了，现在有了100个猴子组成的一个种群，那么这个种群应该怎么发展才能越来越好？说到这，我们想想，如何定义这个越来越好呢？这个应该有一个评价指标吧。在我们的这个问题中，好像是对应的y值越大越好是吧。我们甚至可以给他们排个名来决定哪些好哪些不好。我们把这个叫做对于个体的适应度，这应该算是算法的后半部分才对。

4、编码

首先明白什么是编码？为什么要编码？如何编码？

好，什么是编码？其实编码就是把自变量（x）换一下形式而已，在这个形式下，更容易操作其他过程（比如交叉，变异什么的）而已。举个例子吧，加入我们取x=1, 2, 3，我们可以把x 编码成x=a, b, c,我就说123对应就是abc，为什么要这样做呢？比如问题里面你能够获取的都是abc的组合之类的，那么这样编码以后，你就可以再返回去成123来操作了。一般的编码都是些什么呢？二进制编码，自然数编码，矩阵编码。。等等，很多，不详细写了。而用的最多的可以说是二进制编码，感觉这和人体DNA，基因的排列很相似。想想DNA怎么排的？不就是在两条长链上一对一排的吗？那么什么是二进制编码？很简单，就是1,0,1,0对应的来回组合排列而已。比如：1100100010, 0011001001等等，这些都是位数长度为10的二进制编码。再想想1在计算机的二进制形式是什么？如果八位来表示的话，是不是就是0000 0001；8是不是就是0000 1000；以此类推，那么我们这里也是这样，把对应的x值换算成这种编码形式，我们这里可以看到x的范围是0-5吧，如何按照计算机这样的方式是不是到0000 0101这里就完事了？想想这样多短，前面五位都没有用上多浪费呀，那么要想都用上怎么办呢？也很简单，我们把0000 0001不认为是1不就可以了吗？因为1111 1111是255，那么如果说每一份为1/255的话，那么0000 0001不就是1/255了吗？这个时候1怎样表示了？不就是1111 1111吗？好了我们把范围扩大一些吧，每一份不是1/255,而是1/255*5,那么这个时候最大值是多少？是不是5，恩，这样x编码的范围不就在0-5之间了吗？这里就又有问题了，想想这样做的话，x的最小精度是多少？就是1/255*5.虽然很小，但是在0-1/255*5之间的数你能不能取到？无论如何都取不到吧。那么就又来一个问题，怎样去扩大这个精度呢？如果要保持0-5不变的话，只能增加位数了，把9位编码编程10位，20位，100位，哇，够大了吧，变成100个0,1组合，很恐怖吧，事实上，究竟是多少要视情况而定，一般20位左右感觉就可以了，虽然说越大越好，但是太大了消耗内存，速度慢了，不值。本题中，我们设置它为一个变量，先暂时取为10来实验，好了，如果还不明白为什么要编码看下面的吧。知道了交叉与变异，你就知道了。

8 `+ g- S; L" a0 s8 u+ J6 H( f- z

5、关于交叉与变异

先说变异，什么是变异？简单，基因发生突变就叫变异，有了编码的概念，那就在编码基础上来说变异。首先就讲最简单的变异，但个点的变异。现在以10位长的编码来说，比如把x=3编码一下，随便假设为11000 10010吧，好了，在变异操作时，假设第5位变异了（说一下变异就是一位或者多位1或0变成0或1，也只能0,1之间变，没办法啊），那么这个时候变成什么了？是不是11001 10010再反编码回去成x是多少呢？那肯定不是3了，变了呀，是多少是肯定可以反算回去的，这里懒得算了，就假设为3.213吧，发没发现，这样一来，x是不是变了？既然变了就好啊，带到原函数（适应度函数）里面比较这两个x值对应的哪个y值大一写，如果后面变异后的大一些是不是就是说产生了好的变异啊，就可以在下一次个体选择的时候选择它了。那么想想很多x来一起变异会怎么样呢？肯定会生成很多很多的解吧，反复这么做会怎么样呢？只要每次都保留最优解的话，我来个循环100万次，也总能找到解吧，当然这么多次得花多久，也不太合适，这还只是一个点位在进行变异，若果每次我让多个点位变异呢？哇，又不可思议了，变化更大了吧。当然，变异不止如此，更多的去看专业的论文吧。知道了变异是干什么的，剩下的都好说了，好了，这还是变异，想想自然界遗传中除了变异还有什么？交叉吧，那么交叉又是什么？

学过生物的都知道，动物交配时，部分染色体干什么了？是不是交叉了？就是把相应部分的基因交换了，你的给我，我的给你，很有爱吧。再以编码为例，比如现在随便从100个x值中选取两个吧，鸡舍正好选中了x=3和4，对应的编码假设是11001 10101 和00101 01011，那么怎么交叉呢？我们知道每次交叉的染色体通常是一块一块的，恩，这里在算法设计上也来一块一块的吧。比如说就把位置在2,3,4号的编码给整体交叉了，那么x=3对应的位置是100吧，x=4对应的位置是010吧，好，交换以后x=3对应的位置就变成了010，x=4对应的位置就变成100，加回去就变成什么了？x=3是不是就是10101 10101，x=4是不是就是01001 01011了。而现在，把他们再反编码回去还是x=3和x=4吗？显然又不是了吧（当然也有小概率是一样的吧，很小）。那是什么？不想算，还是假设吧，假设为3.234和4.358吧，好了新的个体是不是又来了？恩，同理，带到适应度函数里面去吧，再取优秀个体，完事。同样，有些专门研究这种算法的开发出来各种各样的交叉方式，什么一个个体的钱3个与后一个个体的后三个交叉，中间几位来交叉等等，总之就是生产新个体。而这样做的目的在哪呢？无非是三个字，随机性，充分保证生产新个体具有随机性，你说你的x=3变异后为3.2,3.2什么的距离3那么近，在一些存在局部最优解的问题上就永远跳不出局部最优解，相反，你的x=1一下子变异成了x=5，哇，好大的变化，一下从这头到了那头，这对于算法的广阔搜索能力来说是非常好的。

讲完了这部分，现在知道了为什么要编码了吧？如果你不编码，你说你想要你的x=3怎么去变异？怎么去交叉？当然也不是没有方法，比如你生成一个小的随机数加到x=3上，但是你想想这两种方法哪一个更具有随机性、普遍性？显然的。而更多的时候交叉预编译是在一起操作的，先交叉，再变异是普遍遗传算法的操作步骤。

1 Y1 k) K1 x6 `9 |- i

6、关于选择的问题

说完了上面的部分，再说说选择吧，选择是什么？就是优胜劣汰。好的留下来，差的走人，在自然界中直接gg了是吧。不停地选择是的种群一直吵着较好的方向行走。

对应到本问题来说，遗传算法的选择是什么样子？在前面说到，每次交叉或者变异是不是产生了新的个体？如果这些个体都保留下来的话，种群是要爆炸的，第一次循环可能有100个x，第二次循环就200个个体，再来那么10万次，哇哦，多少了，好多。显然不可能吧。而且在算法里面，我们还规定的是每次循环都必须保证都是100个个体。那么必须在200个个体中剔除100个吧。好了，问题来了，如何剔除呢？有人说很简单，排名吧，取前100号x不就可以了吗？排名这个东西真的好吗？我就不信，凭什么差一点的不能选上，搞不好在下一次变异中一下子冲到了第一呢？这个问题在选择上也有一些对应的规则，最通用的就是轮盘赌法，简单来说就是一种概率选择法（当然还有许多其他的方法，感兴趣的自己搜相关的文献吧，我也没用过）。什么是轮盘赌法呢？就是把对应所有y值（适应度函数值）加起来，在用各自的y值去除以这个sum值，这样是不是谁的概率大谁的概率小就很清楚了？然后再随机生成一个0-1的概率值p，谁在p的范围里面是不是就选择谁，比如说x=3时在100个x中y的值最大，那么选择它的概率是不是就最大，比如说是0.1（0.1小吗？不小了好吧，想想其他的会是什么，都比0.1小，那么从概率上讲，选100次的话，是不是就有10次宣导x=3，其他的都不足10次是吧，那么在下一次100个种群个体中就有10个x=3了，再来一回可能就有20个x=3的个体了。再就是30个，最后就只剩下100个x=3的个体了，它自己在哪里交叉变异已经没有意义了，如果到了这个时候就意味着这个算法可以结束了）。再详细点，如下图所示吧：现在要在下面三个大类中选取100个x个体，轮盘赌转100次以后，是不是个艺术落在s3中的个体多一些，选择的原理就是这样，再不明白直接后面的程序吧。

7、还差点什么呢

至此，感觉也差不多了吧，选择完后在重复上述步骤交叉，变异等等，那么什么时候是个头了？很简单，办法就是迭代次数，迭代10次看一下结果，20次，看一下结果，30次，40次，100次，当次数达到一定程度以后，优秀的个体越来越多，大都集中在最优解附近，即使变异或者交叉了也是在这个最优解附近，没有影响的。在下一次选择就又变回来了，那么至此就真的结束了。比如说先来结果吧，该问题按我的思路做完后，迭代100次变成什么样子了？看图：

+ c4 C" D: s5 \2 }' L5 }% U

下面看代码：

（1）首先看主函数

• 
  ' L! x. Q* {5 H3 l" O
  1 n0 i: s  Q1 C; M% \  i- T1 M" xfunction main()
  
  # }* F/ a8 O! t7 X6 n
• 
  # l6 ]4 W) m8 v; e3 o/ _5 i& ^
  clear;
  
  : f/ G2 W  G% [5 J5 Z% |
• 
  
  clc;
  / S1 T0 x; N# B7 ?$ \; {& h
  ! |1 _' r2 K) U; j( X( _
• 
  
  . `: |' t# W1 t. y%种群大小
  
  
• 
  ) _7 L5 |, Y7 r1 N0 E; I& R
  popsize=100;
  - n% U( B, a2 ], M9 t4 u) q  k
  
• 
  
  8 }0 \3 k2 k' `! s2 ?6 A+ u%二进制编码长度
  
  0 J; V- Y# l/ a# q
• 
  1 g% o* E5 Y3 O3 J
  chromlength=10;
  
  / M( j- c# H5 H% \) S( J) |4 i' C8 _. ~
• 
  
  + V* r8 A% e/ Z$ c9 {8 k%交叉概率
  1 L: A9 e7 a' I3 h( |- {% _. t6 c* q
  ! u, t  s6 l- ~/ U+ u+ @1 y
• 
  ( |, Y6 _6 ]3 `9 G9 @+ J0 |6 D
  # a0 r/ y9 x+ a# `7 mpc = 0.6;
  5 h, `2 D$ x' Z
  , K) j  N. g4 C
• 
  
  %变异概率
  8 t5 y8 ]5 A4 O, _
  
• 
  
  3 a* M* c. B8 |/ T* z8 l3 Npm = 0.001;
  
  2 T' z" Z" F4 x' Y
• 
  " p, e) j& j* @4 C
  0 U! o" s+ y0 ~%初始种群
  
  : G* p6 {9 M$ [) c1 m, G9 B- k
• 
  * \( y# ^) j* D- b* D$ @  P
  4 f) O- G* m  ^2 n9 X3 p. Jpop = initpop(popsize,chromlength);
  
  . |5 p" k. x7 N8 c8 @; I
• 
  . D8 A9 O- V' u- k2 e+ h1 c/ G/ a
  
  ' U& U! D- K* g: ^
  
• 
  7 }; {2 q# I- \- V( E( ]
  for i = 1:100
  ' }" G. M$ Z3 {! S8 Y8 h0 f2 \
  
• 
  
      %计算适应度值（函数值）
  2 A3 x: ~; [; `8 G( a
  3 ~( K% ~# d4 d
• 
  ) @: |1 a6 f& X' g: x+ y, s
  # [" J- e& S: P5 `    objvalue = cal_objvalue(pop);
  ; l: I" D- a4 I, [2 t* ~8 b7 g  z, P
  
• 
  % ^' c+ o* E' I/ [, f
  5 D' _+ g7 {* s0 J- O    fitvalue = objvalue;
  
  ' i5 P! g8 B5 ~8 O6 K0 v; k
• 
  2 U0 P8 e$ ^& }5 O( P! T+ N
  " N; z$ d! q+ s0 Y5 O* q    %选择操作
  
  . X) I6 N; n8 S# }3 m. y  R
• 
  , E$ O/ P: O! K1 d6 D; T5 X
  + j7 V6 L* V! I$ y    newpop = selection(pop,fitvalue);
  
  ( Y9 b/ E" K' Q* x: S
• 
  
  1 `& c6 [) L. e: ], t( O* d    %交叉操作
  3 K, U6 x- F- e+ i' |2 M
  : d& m3 a1 g/ n8 k
• 
  
  1 z! r. z/ u9 K& {# {! m    newpop = crossover(newpop,pc);
  5 ^5 b* s$ ]1 L8 {) |0 t0 M
  
• 
  ( R- i6 e4 t0 m2 x( \8 f* X* ^
  8 p# s3 D( ^' `    %变异操作
  
  3 k/ C% M6 x6 R+ E
• 
  ; h: l' S; |0 d) |5 [
      newpop = mutation(newpop,pm);
    a0 ?- i" D4 n/ u
  
• 
  
  2 z3 O9 g% V; _    %更新种群
  5 a) r; `! o6 |, @5 E8 j( q% }+ q+ Z
  
• 
  
      pop = newpop;
  % w9 f" I1 z0 q) Q
  # H+ T  I8 z: T
• 
  
  5 H3 _$ N" e$ h, q$ m' u% D    %寻找最优解
  5 U+ h' N0 Z5 L5 l: u
  ! V; ^0 t6 D6 X6 k9 M! E) T
• 
  1 ~: k  W/ R5 @" q9 b6 Q9 S5 Y
    `" K6 o" Z, m8 G( o/ z% Q    [bestindividual,bestfit] = best(pop,fitvalue);
  
  
• 
  % E/ _' L- S& A' \0 C
      x2 = binary2decimal(bestindividual);
  . O# Z! f4 q% V% x" l3 z5 m( I
  ' g0 U" y9 g. y) E/ Z
• 
  
  2 x! ^% }3 I& B* i) b% Z    x1 = binary2decimal(newpop);
  
  * l& @( u) s) @" T$ m
• 
  , @+ |- I2 l! {& ^# g, e% d1 l" N
  # [2 m3 y% h. d# {( W& {3 F    y1 = cal_objvalue(newpop);
  
  , u& z! O2 z5 m9 \; _) d+ B  Q
• 
  0 x- @% u) y6 |% b' M- L
      if mod(i,10) == 0
  1 P. A: v2 p" C- b9 `  v: F
  
• 
  8 {4 H+ f2 Y! d, w! V) \
          figure;
  
  
• 
  
          fplot('10*sin(5*x)+7*abs(x-5)+10',[0 10]);
  
  
• 
  & \( U: G8 [6 O' e7 x% U( N
  # K, ^3 I, l( E& R        hold on;
  ( Y* I/ L; N* V" s/ c8 v
  9 K# x, |2 g; t
• 
  % F4 X# i; l; x' o0 w
  & L" A6 T4 \0 @2 W% G- B' ^* N        plot(x1,y1,'*');
  % b, y" r, ^( u1 n# Z. N
  0 X6 J5 R: \; ?0 c& a/ b5 Z1 f
• 
  
          title(['迭代次数为n=' num2str(i)]);
  
  
• 
  
          %plot(x1,y1,'*');
  * ~& U. P2 S: ~# I9 j# f/ r* \
  6 k# T5 H7 ?3 G3 {$ L$ C4 d# d' w/ Z
• 
  
      end
  
  6 O4 `% m" t# t0 q, j
• 
  + `' G+ _6 U* D' a$ s' P$ ]5 v- ^
  end
  
  
• 
  * Y& ^# {  ^# k7 u9 i9 [
  fprintf('The best X is --->>%5.2f\n',x2);
    r6 ~: T7 `* _  p) n
  
• 
  3 O" c+ T: e/ t
  fprintf('The best Y is --->>%5.2f\n',bestfit);
  
  
  

（2）下面看二进制种群生成的方法

• 
  1 m9 E, N7 |! g
  , E# J. p8 B; j%初始化种群大小
  & Y& w! L% s0 L$ m" {- ~1 X& e
  $ e( v/ r; R: Y; I
• 
  
  ! F8 h8 K) Q. y; i, t2 }) M! `%输入变量：
  7 ^- c1 l6 f" h% V: S
  
• 
  9 O7 [" T3 J- Q6 ^
  . `0 s8 Y- ^. V" G" c1 N, G%popsize：种群大小
  
  
• 
  . |$ z. {# L. y7 z3 u
  %chromlength：染色体长度-->>转化的二进制长度
  
  
• 
  9 `( _/ X9 L/ {
  %输出变量：
  0 m1 U9 I" b. v$ C+ m3 G$ b% o' z5 k' J
  * k6 v3 R1 u8 h
• 
  8 u" |5 }% p( \! l
  ; M- y" k$ f* U. P; I) N%pop：种群
  0 a% F6 Y& x/ V- d9 C+ I
  : d: P8 m  t9 n$ \5 q) o
• 
  " N/ T% h! v. h. Z' j5 B
  function pop=initpop(popsize,chromlength)
  
  
• 
  0 G, P4 d7 J, m, F% j1 ?: i$ F4 F
  ' j- n' o4 ]9 m$ @pop = round(rand(popsize,chromlength));
  
    k. a! S% C) c/ j+ S* Q- [
• 
  5 h+ P8 j- v6 N! ~% ~3 N- g
  %rand(3,4)生成3行4列的0-1之间的随机数
  $ {; e0 q  X5 f* h1 _
  
• 
  
  % b) |, v0 ~$ P* K3 P% rand(3,4)
  
  
• 
  3 F. Y2 i. @/ W9 W: u
  %
  # W7 S4 v6 ]6 O. p7 F
  
• 
  
  % ans =
  " u5 r3 _+ I& q& s* Y2 N4 N
  
• 
  
  " p: v3 q8 _# I, r%
  
  
• 
  5 ]% Y! d) `7 A3 _& L0 C
  %     0.8147    0.9134    0.2785    0.9649
  
  
• 
  
  + n6 ~0 {$ u& Z4 s% M6 d%     0.9058    0.6324    0.5469    0.1576
  
  - j3 I9 F! ?* @! D- U
• 
  
  %     0.1270    0.0975    0.9575    0.9706
  
  , m) P% _8 I; h+ R
• 
  
  %round就是四舍五入
  
  
• 
  
  % round(rand(3,4))=
  
  " T( u3 v* w4 X7 V2 O) t: l
• 
  1 P3 F7 |; C# u8 J4 p" A
  % 1 1 0 1
  
  
• 
  % k  O' I9 z! X* w8 g' X
  % t+ H6 K! r9 L# i% 1 1 1 0
  
  
• 
  * k+ ?  X$ d* N: T; H- w* g
  % 0 0 1 1
  # X( F* n3 F5 Q  F
  
• 
  3 B: F" w. c+ E) ^* \2 g+ \- o6 n
  %所以返回的种群就是每行是一个个体，列数是染色体长度
  / p+ B, r! b9 p$ X- o
  
  

（3）下面看如何把二进制返回对应的十进制

• 
  
  ! _' D- r9 b; m# o4 _%二进制转化成十进制函数
  ; j0 n- V; u, H
  
• 
  % ^& F* ~& [: ]5 g4 v: S
  %输入变量：
  ' Z/ ?% R6 Y9 m
  ! ]* z, e* a7 i( \2 c0 F
• 
  
  ( ?- e7 t8 a  q%二进制种群
  0 b" ?, _- C: O3 L' X
  
• 
  
  ! c6 ]& [4 P+ D7 r3 D%输出变量
  
  
• 
  7 V+ G  L; f" M" w2 N
  + o3 q# L9 k4 s/ o; K2 ^5 z/ M9 G8 `%十进制数值
  2 `" S8 N6 }. S, K$ ?
  # K) A+ V( P2 H' Y1 L4 w" C$ a
• 
  
  function pop2 = binary2decimal(pop)
  
  * o* e: m% }0 @" X, u, S
• 
  
  . V- k" x4 @) F% T[px,py]=size(pop);
  ' c7 v3 d, J+ X& ~2 g6 q/ e) ~
  
• 
  ) V9 r7 Q3 h! n) Q4 j: D  u
  $ k4 L7 m: j, Jfor i = 1:py
  
  
• 
  
      pop1(:,i) = 2.^(py-i).*pop(:,i);
  
  
• 
  
  end
  
  % n) ~+ ?8 U3 F
• 
  # H  V* V2 y! f
  %sum(.,2)对行求和，得到列向量
  
  / r7 P8 s; a  R! @
• 
  & I9 ?* V( `+ ^) F
  temp = sum(pop1,2);
  4 M6 P5 ^% Q; M& X
  
• 
  : F7 P3 o; Y/ ~% U3 j
  0 t  V8 A" y9 t$ y* ~pop2 = temp*10/1023;
  / A' }" Y; l3 ?- N1 C
  
  

输入的是100组0,1编码的二进制，输出的是x值，开始取一下种群大小，size（pop）,显然这里py是10了，借着对每一位求和，就是pop1（:,i）=2.^(py-i).*pop(:,i);这里省略用了冒号，，什么依稀呢？就是对所有行都有这个操作，冒号意思就是胸1到100了，那么就其中一个个体来说吧，假设为11001 10010，那么先进性这么一个操作就是什么呢？是不是就是对应的为0或1乘以2的对应次幂，如果1就是管用，是0就不管用。那么这个值就是(2^0)*1+(2^1)*1+0+0+(2^4)*1+....这样就算出了一个值，因为是10位编码，所以这个数是结余0-2^9即0-1023.那么最大为多少？1023吧。temp = sum(pop1,2)是对行求和吧，2表示行，1表示列，最后一行是吧它转化为100组0-10之间的数值了。

（4）下面看计算适应度函数：

• 
  & V; W; N4 t" o2 f
  %计算函数目标值
  
  6 p$ Z! g$ R. B3 p( c
• 
  " S" n" m  \, x% X& ~: i
  # b" C( I8 c; z9 q* X%输入变量：二进制数值
  , Q7 g0 m* u$ z5 C# w2 \0 i
  
• 
  # z! u/ z  n$ b% A
  1 j# S' D, {0 C0 l# m& @%输出变量：目标函数值
  8 {- X5 ~* P* L8 y$ U; j6 m! g/ P
  ' ^1 [7 f. K# u- u& _
• 
  # p% r- @2 ~0 c3 l$ @+ \
  function [objvalue] = cal_objvalue(pop)
  
    I$ u# k9 _- d: m& r1 i' V
• 
  
  5 [; ]9 v$ k& h$ Jx = binary2decimal(pop);
  " D' k, w5 M3 ~( P" S+ `
  
• 
  
  %转化二进制数为x变量的变化域范围的数值
    ~1 Z/ ~" r2 U+ D" V0 g
  $ G5 ~8 g' u* G1 r- |1 Q* A! v
• 
  
  * k+ _) {# a' f) c: u- M. dobjvalue=10*sin(5*x)+7*abs(x-5)+10;
  $ A! c4 S6 U- `  P
  
  

（5）如何选择新的个体

上面所有个体的函数值都计算出来了，存在objvalue中，此时它是不是也是100组y值啊，恩，那么对于现有的随机生成的100组x，怎么来再选择100组新的更好的x呢？这里我们把选择放在了交叉与变异之间了，都可以，如何选择，就要构造概率的那个轮盘了，谁的概率大，是不是选择的个体就会多一些？也就是现在的选择就是100中100个，最后出现的就够就是以前的100个中最优的x有一个的话，选择完后，可能就变成5个这个x了，多余的4个是不是相当于顶替了以前的不好的4个x值，这样才能达到x总数100不变啊。

• 
  + @1 y) _1 i% M% Y' @
  7 a4 Y* J+ X8 ?+ t%如何选择新的个体
  ! P" i6 g7 K9 w# R& c, V7 l
  ( [3 p3 s7 S9 _! A
• 
  / v0 x6 a9 g- W& Q# a7 N6 H. Z
  %输入变量：pop二进制种群，fitvalue：适应度值
  . c$ W" }; [; x' @
  0 q) a; A7 W5 P% K) o
• 
  4 Q; g+ A9 Y2 f# m8 n
  ; m4 k) l4 a, i; n/ Z%输出变量：newpop选择以后的二进制种群
  5 @5 b) o' m! y% r. v' L8 l
  
• 
  
  function [newpop] = selection(pop,fitvalue)
  
  # C" M5 j! y) U5 S2 l
• 
  ! {* i5 a# u6 `5 ~+ S7 @
  %构造轮盘
  5 t6 c$ p5 ~4 ~$ I9 r3 v
  
• 
  $ `/ c4 K8 P4 c8 i7 c
  - z  M% M$ k1 [" o4 t; y; h8 J[px,py] = size(pop);
  $ J; f3 T% X# K* l1 K2 v, x- X
  
• 
  : _$ Z+ J  x$ l0 [* o
  totalfit = sum(fitvalue);
  , V9 D/ B4 A; ~2 Q5 X$ N+ @
  
• 
  
    A* q, n. R3 @. wp_fitvalue = fitvalue/totalfit;
  # C; Z& f5 `& @/ `0 o" L, y0 m+ ]
  , n3 U8 @& t' w! m5 q5 w. [1 `) c3 l
• 
  ! Y/ u8 I4 ~! [1 s" r& Z
  p_fitvalue = cumsum(p_fitvalue);%概率求和排序
  
  
• 
  ' S% U/ ]) c/ R' H5 _
  ms = sort(rand(px,1));%从小到大排列
  : C" {0 H& A# ~
    h/ A- O9 t9 L
• 
  ; @: D/ G9 S! x
  ; |3 X/ |! Z1 H+ U# |fitin = 1;
  
  
• 
  
  , Z6 N& ^8 F7 l8 p- @5 T  Znewin = 1;
  $ V: i; O  g( @. h
  5 o5 C7 t- T  o  o
• 
  
  while newin<=px
  . j# Y' I% X' c/ g" o: `
  
• 
  
      if(ms(newin))<p_fitvalue(fitin)
  ! T1 B- p6 A" d  a
  5 z' P! ?+ C! `+ g
• 
  
  8 u9 P# O, \( f0 |- R) R- R        newpop(newin,=pop(fitin,;
  
  
• 
  " x# z/ Z8 F, G$ E# g! m
          newin = newin+1;
  4 G$ y# g5 k: V) R# ?( G3 C
  
• 
  ) Z3 R9 T/ `. l- @1 i
      else
  6 B% o, e6 b9 u: A/ J
  
• 
  
  ( O% s9 M9 Q& @; M8 _5 g$ a        fitin=fitin+1;
  : V- D' }# y2 f
  " F$ @9 x& V  |% X! B; d
• 
  4 a: E9 U5 i- Z3 f/ S3 G
  7 k: g, K% m5 ~: j) v    end
  
  
• 
  ) M0 ?3 `% W5 O
  end
  9 ?3 V4 L$ N* V* s0 x5 _
  
  

（6）怎么交叉

• 
  
  / ^* _3 r9 x3 p$ b; S& R%交叉变换
  
  
• 
  ! E5 c2 x2 ?8 R1 P
  * c9 X- e* Z) l" d3 s%输入变量：pop：二进制的父代种群数，pc：交叉的概率
  3 }; H1 P8 q9 @( Y
  0 i" a% g% x* D* |
• 
  
  %输出变量：newpop：交叉后的种群数
  
  
• 
  6 ?* G( U5 M) F  ^
  function [newpop] = crossover(pop,pc)
  
  
• 
  & Y/ z- ?; k) D/ P' x2 U2 w
  ! W1 M7 |- f) B7 h  M[px,py] = size(pop);
  
  
• 
  9 T( f4 H* F- b, Z
  newpop = ones(size(pop));
  
  * p9 K1 N4 u7 i: v: x
• 
  9 [3 S# P5 q7 _. S6 v. ?
  ( z. \2 R8 B6 R; `( jfor i = 1:2:px-1
  
  
• 
  * H4 |+ T9 @7 V% _+ P9 l+ B$ |
  * U3 i( J  ^7 D2 n    if(rand<pc)
  8 H/ p; w% ^# o9 |3 J5 ?: |
  0 O/ a5 q) H' k  U1 q- n* l
• 
  " o  c& ]6 f$ U; Z1 @) C
  3 @, _9 L9 v! C2 \1 L) P3 `# e        cpoint = round(rand*py);
  & V" c$ [; ^& Z6 G7 A3 |( _
  : O, D0 M4 ]; a: e& a) u7 U: i
• 
  / k# G8 g8 V4 \  O& V; w
          newpop(i, = [pop(i,1:cpoint),pop(i+1,cpoint+1:py)];
  
  0 H/ e& g4 s4 E. R& v2 E! x
• 
  
          newpop(i+1, = [pop(i+1,1:cpoint),pop(i,cpoint+1:py)];
  % I. W; N1 d8 y2 L
  $ v1 U6 @( c. m* l1 p. n1 E
• 
  / j9 o# h& m9 r% q! ?/ N/ V
  9 `( T# c3 ^- a6 R& R$ s) o, M    else
  
  
• 
  1 @- t0 V- d9 E" x0 d* x
  ! m1 P5 U9 o2 w( m; Z6 X2 q        newpop(i, = pop(i,;
  
  
• 
  , E7 h0 R/ ~9 i5 p" N" h8 @; @
  # `( R+ W# T5 ~9 Z1 f" u        newpop(i+1, = pop(i+1,;
  
  
• 
  # V9 j' `4 @  b* F- o6 ~* v
      end
  
  ( d' e' m% m7 s; t9 S, U/ y8 P. q6 Q
• 
  
  ) c0 A$ T8 ~0 q! l1 w& k9 U8 H1 |end
  ! A, x" ?1 B/ S& F* ^
  . J" V, R  C4 N. ?0 V7 N. N
  

（7）怎么变异

• 
  
  ) ^. N! c0 ?* [5 B5 D* {%关于编译
  3 U8 v- ?6 v. `& O" R. f7 K/ _
  7 S) R6 X- r. {; F$ f" j& `
• 
  . c. D0 M% Z: T; r
  %函数说明
  6 S- ^' m8 Z6 E" d( V1 K0 d
  , N0 c9 C# P  S; D5 o: L
• 
  . L  _& |& q$ _% e
  0 b" c' [& [, @$ y1 q. H%输入变量：pop：二进制种群，pm：变异概率
    e# `/ J2 a$ B3 [* O* V) M
  
• 
  2 b1 W4 _6 }# S. E: c! M
    Y/ a0 v0 _; F$ v" c%输出变量：newpop变异以后的种群
  
  . r. q" v' f7 L: J) e( G
• 
  6 X+ _2 e3 R' b; b; B; o
  function [newpop] = mutation(pop,pm)
  ( U6 V* W7 X9 Y0 w5 x( @
  
• 
  . ^! p: _" F& \1 s2 ^4 K; d
  [px,py] = size(pop);
  
  1 e' ^4 s, u1 N2 F, Z4 Y9 M
• 
  ) |; V/ p$ @# C; c* |  j
  ( N: |$ ^3 [) Q2 H" mnewpop = ones(size(pop));
  
  
• 
  
  9 V7 k* v8 O, Pfor i = 1:px
  5 I0 }' R' @/ o; r/ m
  
• 
  2 a- b" T/ o. g+ d. x5 C- d6 W8 P, O
  ) x+ h4 z6 L2 g. n    if(rand<pm)
  ( S% H' w% ]9 {( O7 \
  
• 
  5 Q6 M9 z4 I7 V) }/ {
          mpoint = round(rand*py);
  
  ! p% h6 K9 h# ^# g" m/ T5 \8 _
• 
  0 T/ Q5 |) V( K
          if mpoint <= 0;
  
  
• 
  
              mpoint = 1;
  
  * }$ P+ X  v; y. x9 o7 q
• 
  
          end
  
  & w: ^+ w8 r. c; S4 K- {- M
• 
  
          newpop(i, = pop(i,;
  " w9 b+ F5 y* }9 g- D5 B
  6 C5 u- k; h$ W0 C3 L# R* a
• 
  ; s- z! y$ o' B; l3 h
          if newpop(i,mpoint) == 0
  
  ) A2 S6 V# k6 P- q0 j
• 
  
  ; w; S: N: u$ i( z6 K8 o* l            newpop(i,mpoint) = 1;
  : `8 t" n4 F6 f
  
• 
  
  9 X# X! Q2 s4 x# _        else newpop(i,mpoint) == 1
  
  
• 
  
              newpop(i,mpoint) = 0;
  
  
• 
    R. q7 I. ]( x1 Z( q0 \
          end
  : ^7 U  h% L9 t) C6 \
  0 m7 R6 B+ n( p; I* J; D8 {
• 
  
  ( n. p  U* b! e1 T* m6 C6 n( ]    else newpop(i, = pop(i,;
  8 R7 Y: ]& a* D6 ]( ^; H4 o5 a
  
• 
  * S0 s" B7 `% @5 Q- [' i- W
      end
  
  
• 
  
  end
  
  ' f8 G3 E# @9 e$ _
  7 K; I! `2 `' h! M1 n! p

（8）选择最优个体

• 
  9 d* z8 M. O' r/ {' n+ K
  : d0 ]! T9 u, Z1 S; w4 d4 u9 D* I%求最优适应度函数
  & V  U9 g: d9 S
  0 }* v' j7 R) n& n% a: ]9 |: O
• 
  ; D0 v+ I' r% Q5 m( R6 K
  %输入变量：pop:种群，fitvalue:种群适应度
  5 E) G1 X. u5 p6 |
  ! d' l( I5 ?3 ]" x# X4 C
• 
  
  6 @4 ^. j0 c9 L& W/ q4 t( B: R( V% d%输出变量：bestindividual:最佳个体，bestfit:最佳适应度值
  
  1 t/ u6 r0 A. F
• 
  % k& d# x( r2 {
  * N9 C( a0 k8 F3 _. Z* _! Ifunction [bestindividual bestfit] = best(pop,fitvalue)
  
  9 e- J. k8 {/ G8 M
• 
  , k: d9 }& ~3 d+ o8 S+ G
  [px,py] = size(pop);
  2 W" _4 K& ~) q! ^2 |3 l5 B
  
• 
  
  bestindividual = pop(1,;
  # S* r: w/ ?+ {# K4 z: K. p& |
    |! ^7 Q1 A& i2 y: B  w# `
• 
  * I# J" b0 O* D( p) }5 X! `
  bestfit = fitvalue(1);
  
  : p, j9 t: b: n. ?% T: G
• 
  ' H6 o5 H0 z9 I. s$ ?& P" a
  for i = 2:px
  
    U3 k5 r7 l8 J% ?
• 
  
  3 q! e  K8 ?1 q8 D    if fitvalue(i)>bestfit
  6 n9 t. p) w3 a3 M! [
  
• 
  4 a$ ^* Q* {9 H+ U. [2 m1 ^
          bestindividual = pop(i,;
  
  / A8 g1 B! M" o" v
• 
  6 w( l8 [. n8 E
  & z# A& q' i/ @+ D* Q- V% z( E- F9 y        bestfit = fitvalue(i);
  : b, D% Q# J( w* x+ b' }/ J
  
• 
  4 _+ S( o# f/ t" F6 G) }
  # U) q8 S$ Q' s! k    end
  6 a& c# {  [  ^
  0 U8 O% M7 n9 J% H, V3 S
• 
  
  5 `* B2 g$ A1 i' l6 T9 j# O# I. ^2 Jend
  
  & J  ^* {9 F( _. N7 w! c# @8 A5 X$ H
  3 V$ Q/ P% \) q" f; H' L! J1 e

到这里遗传算法程序就算是结束了。

看部分图片结果：

! {" g, _% x' ^' S: ?# i0 k
. J8 p4 B6 e: B" n! z

随便去一个

66666666666666666666
  O  z1 ^) b& N" B4 B, u& G9 Q

canglan

写的真好，多谢分享知识

AllChen

好细致，只可惜没有代码块支持

樊

写的非常好，太棒了。