遗传算法-变异算法

遗传算法系列 （4） 变异算法

在基因交叉之后产生的子代个体，其变量可能以很小的概率或者步长发生转变，这个过程称为变异(Mutation)。
如果进化的目标函数极值是单峰值的，那么，将变异概率p设置为种群数量n的倒数是一个比较好的选择。
如果变异概率很大，那么整个搜索过程就退化为一个随机搜索过程。所以，比较稳妥的做法是，进化过程刚刚开始的时候，取p为一个比较大的概率，随着搜索过程的进行，p逐渐缩小到0附近。
与交叉过程一样，变异的算法也可以大致分为实数编码和二进制编码两种。
（1） 实数变异
 <1>步长变异
即给数值加上或者减去一个值，这个数值称为步长。大致如下：
X' = X + 0.5 Ld 或者
X' = X - 0.5 Ld
这里
L为变量的取值范围 L = Upper - Lower
d= a(0)/2^0 + a(1)/2^1 + ... + a(m)/s^m
其中a(i)以1/m的概率取1,以 1-1/m的概率取0，一般m=20

C++ 代码

 1  template <   class  GENE  >
 2  class  Real_Gene_Mutate_Algorithm
 3  {
 4       public :
 5           void   operator ()( GENE &  gene )  const
 6          {
 7               const  unsigned  int  M  =   20 ;
 8 
 9               // claculate Delta
10               long   double  Delta  =   0 . 0L ;
11               for  ( unsigned  int  i  =   0 ; i  <  M;  ++ i )
12              {
13                   const   long   double  Boundary  =
14                           1 . 0L   /  static_cast < long   double > (M);
15                   const   long   double  Ran  =  ran();
16                   if  ( Ran  <  Boundary )
17                  {
18                       const  unsigned  int  Base  =   1   <<  i;
19                      Delta  +=   1 . 0L   /  static_cast < long   double > ( Base );
20                  }
21              }
22 
23               // claculate Sig and L
24               const   long   double  Ran  =  ran();
25               long   double  Sig  =   0 ;
26               long   double  L  =   0 ;
27               if  ( Ran  >   0 . 5L  )
28              {
29                  Sig  =   1 . 0L ;
30                  L  =  gene.Upper  -  gene.Value;
31              }
32               else
33              {
34                  Sig  =   - 1 . 0L ;
35                  L  =  gene.Value  -  gene.Lower;
36              }
37 
38              gene.Value  +=  Sig  *  L  *  Delta  *   0 . 5L ;
39          }
40 
41  };
42 

<2>高斯变异
这种变异的方法就是，产生一个服从高斯分布的随机数，取代原先基因中的实数数值。这个算法产生的随机数，数学期望当为当前基因的实数数值。
一个模拟产生的算法是，产生6个服从U(0,1)的随机数，以他们的数学期望作为高斯分布随机数的近似。

 1  template < class  GENE >
 2  class  Gauss_Mutate_Algorithm
 3  {
 4           public :
 5               void   operator ()( GENE &  gene ) const
 6              {
 7                   long   double  gauss  =   0 . 0L ;
 8                   for  ( unsigned  int  i  =   0 ; i  <   6 ;  ++ i )
 9                      gauss  +=  ran();
10                  gauss  /=   6 . 0L ;
11 
12                   long   double  upper;
13                   long   double  lower;
14                   const   long   double  Upper  =  gene.Upper;
15                   const   long   double  Lower  =  gene.Lower;
16                   const   long   double  Value  =  gene.Value;
17 
18                  ( ( Value  -  Lower )  >  ( Upper  -  Value ) )  ?
19                  ( upper  =  Upper, lower  =  Value  *   2 . 0L   -  Upper ) :
20                  ( lower  =  Lower, upper  =  Value  *   2 . 0L   -  Lower );
21 
22                  gauss  *=  ( upper  -  lower );
23                 guass += lower;
24 
25                  gene.Value  =  gauss;
26              }
27  };
28

（2）二进制变异
对二进制编码来讲，变异就是变量的翻转，如
100001 1 1100001
100001 0 1100001

c++代码

 1  template <   class  GENE  >
 2  class  Binary_Gene_Mutate_Algorithm
 3  {
 4       public :
 5           void   operator ()( GENE &  gene ) const
 6          {
 7              encoding( gene );
 8 
 9               const  unsigned  int  Size  =  gene.Binary_Array.size();
10               const   long   double  Ran  =  ran();
11               const  unsigned  int  Pos  =  static_cast < unsigned  int >
12                      ( static_cast < long   double > ( Size )  *  Ran );
13 
14               if  ( gene.Binary_Array[Pos] )
15                  gene.Binary_Array[Pos]  =   0 ;
16               else
17                  gene.Binary_Array[Pos]  =   1 ;
18 
19              decoding( gene );
20          }
21  };

（3）一些相关算法或者函数

 1  template <   class  DATA,  class  ALGORITHM >
 2  void  mutate( DATA &  d,  const  ALGORITHM &  a )
 3  {
 4      a( d );
 5  }
 6 
 7  template <   class  POPULATION,  class  GENE_MUTATE_ALGORITHM  >
 8  class  Population_Mutate_Algorithm
 9  {
10       public :
11           void   operator ()( POPULATION &  p ) const
12          {
13               // chromosome numbers in the population
14               const  unsigned  int  C_Size  =  p.Chromosome_Array.size();
15               // gene numbers in a chromosome
16               const  unsigned  int  G_Size  =  p.Chromosome_Array[ 0 ].Gene_Array.size();
17 
18               for ( unsigned  int  i  =   0 ; i  <  C_Size;  ++ i )
19              {
20                   for  ( unsigned  int  j  =   0 ; j  <  G_Size;  ++ j )
21                  {
22                       const   long   double  Ran  =  ran();
23 
24                       if  ( Ran  >  p.Mutation_Probability )
25                       return  ;
26 
27                      mutate( p.Chromosome_Array[i].Gene_Array[j],
28                              GENE_MUTATE_ALGORITHM() );
29                  }
30              }
31          }
32  };
33