遗传算法系列 （3） 交叉算法

遗传算法系列 （3） 交叉算法

基因交叉，或者基因重组，就是把两个父体部分结构加以替换，生成新的个体的操作，习惯上对实数编码的操作叫做重组（Recombination），对二进制编码的操作称为交叉（crossover）。

比较常用的一些算法介绍如下：
1. 重组算法（Recombination）
 实值重组产生子个体一般是用下边这个算法：
 子个体=父个体1 + a × ( 父个体2 - 父个体1 )
这里a是一个比例因子，可以由[ -d, 1+d] 上边服从均匀分布的随机数产生。
不同的重组算法，a的取值是不同的，一般来讲，d=0.25是一个比较好的选择。
下边一段c++代码片断，实现一个中值重组算法，其中d取值为0。

 1  /*
 2  Gene Crossover Algorithm
 3  Linear Recombination Xover Algorithm
 4 
 5  A crossover operator that linearly combines two parent
 6  chromosome vectors to produce two new offspring a
 7  ccording to the following equations:
 8 
 9  Offspring1 = a * Parent1 + (1- a) * Parent2
10  Offspring2 = (1 – a) * Parent1 + a * Parent2
11 
12 
13  where a is a random weighting factor (chosen before each
14  crossover operation).
15 
16  Consider the following 2 parents (each consisting of 4
17  float genes) which have been selected for crossover:
18 
19  Parent 1: (0.3)(1.4)(0.2)(7.4)
20  Parent 2: (0.5)(4.5)(0.1)(5.6)
21 
22  If a = 0.7, the following two offspring would be produced:
23 
24  Offspring1: (0.36)(2.33)(0.17)(6.86)
25  Offspring2: (0.402)(2.981)(0.149)(6.842)
26  */
27  template <   class  GENE  >
28  class  Intermediate_Recombination_Gene_Crossover_Algorithm
29  {
30       public :
31               void   operator ()( GENE &  g1, GENE &  g2 ) const
32              {
33                  assert( g1.Upper  ==  g2.Upper );
34                  assert( g1.Lower  ==  g2.Lower );
35 
36                   const   long   double  Ran  =  ran();
37                   const   long   double  sum  =  g1.Value  +  g2.Value;
38 
39                   if  ( sum  <  g1.Upper )
40                  {
41                      g1.Value  =  Ran  *  sum;
42                      g2.Value  =  sum  -  g1.Value;
43                  }
44                   else
45                  {
46                       const   long   double  sub  =   2 . 0L   *  g1.Upper  -  sum;
47                      g1.Value  =  g1.Upper  -  sub  *  Ran;
48                      g2.Value  =  g1.Upper  -  sub  +  sub  *  Ran;
49                  }
50              }
51  };

2.  交叉算法
如上文遗传算法中的数据结构中所讲，基因的二进制编码有直接编码（Normal）和Gray编码之分，以下所说算法，均适用于这两种算法。

假设基因的二进制编码长度为N，那么这些编码之间有N-1个空隙，可供交叉使用。
二进制交叉算法就是 如何选择空隙，选择多少个空隙。
以下将各走极端的选择一个空隙交叉的单点交叉算法，和选择N-1个空隙进行交叉的洗牌交叉算法大致说一下。

（1） 单点交叉
在二进制编码中，随机选择一个点，以这个点为界限，相互交换变量。
如
父个体1      011111110000000000
父个体2      000000001111111111
如粗体前边位置为所选择的交叉点，那么生成的子个体为：
子个体1      011111111111111111
子个体2      000000000000000000
以下为c++实现，采用Gray编码，直接编码的类似。

 1  /*
 2  Gene crossover algorithm
 3  One Point Crossover using Gray binary encoding
 4 
 5  A crossover operator that randomly selects a crossover point
 6  within a chromosome then interchanges the two parent chromosomes
 7  at this point to produce two new offspring.
 8 
 9  Consider the following 2 parents which have been selected for
10  crossover. The “|” symbol indicates the randomly chosen
11  crossover point.
12 
13  Parent 1: 11001|010
14  Parent 2: 00100|111
15 
16  After interchanging the parent chromosomes at the crossover
17  point, the following offspring are produced:
18 
19  Offspring1: 11001|111
20  Offspring2: 00100|010
21  */
22  template <   class  GENE  >
23  class  Gray_Binary_Single_Point_Xover_Gene_Crossover_Algorithm
24  {
25       public :
26               void   operator ()( GENE &  g1, GENE &  g2 ) const
27              {
28                  encoding( g1 );
29                  encoding( g2 );
30                  assert( g1.Binary_Array.size()  ==  g2.Binary_Array.size() );
31 
32                  normal2gray( g1 );
33                  normal2gray( g2 );
34 
35                   const  unsigned  int  Pos  =  static_cast < unsigned  int >
36                                  ( g1.Binary_Array.size()  *  ran() );
37 
38                   for  ( unsigned  int  i  =   0 ; i  <  Pos;  ++ i )
39                  {
40                       if  ( g1.Binary_Array[i] xor g2.Binary_Array[i] )
41                      {
42                           if  ( g1.Binary_Array[i] )
43                              {
44                                  g1.Binary_Array[i]  =   0 ;
45                                  g2.Binary_Array[i]  =   1 ;
46                              }
47                               else
48                              {
49                                  g1.Binary_Array[i]  =   1 ;
50                                  g2.Binary_Array[i]  =   0 ;
51                              }
52                      }
53                  }
54 
55                  gray2normal( g1 );
56                  gray2normal( g1 );
57                  decoding( g1 );
58                  decoding( g2 );
59              }
60  };
61 
62 
63 

（2）洗牌交叉
洗牌交叉就是，将一个父基因取一半，再上来自另外一个父基因的一半，构成一个新的子基因。
算法代码如下：

 1  template <   class  GENE  >
 2  class  Gray_Binary_Shuffle_Xover_Gene_Crossover_Algorithm
 3  {
 4       public :
 5               void   operator ()( GENE &  g1, GENE &  g2 ) const
 6              {
 7                  encoding( g1 );
 8                  encoding( g2 );
 9                  assert( g1.Binary_Array.size()  ==  g2.Binary_Array.size() );
10 
11                  normal2gray( g1 );
12                  normal2gray( g2 );
13 
14                   const  unsigned  int  Size  =  g1.Binary_Array.size();
15 
16                   for  ( unsigned  int  i  =   0 ; i  <  Size;  ++ i )
17                  {
18                       if  ( ( i  &   1 )  &&
19                           ( g1.Binary_Array[i] xor g2.Binary_Array[i] )
20                          )
21                      {
22                           if  ( g1.Binary_Array[i] )
23                              {
24                                  g1.Binary_Array[i]  =   0 ;
25                                  g2.Binary_Array[i]  =   1 ;
26                              }
27                               else
28                              {
29                                  g1.Binary_Array[i]  =   1 ;
30                                  g2.Binary_Array[i]  =   0 ;
31                              }
32                      }
33                  }
34 
35                  gray2normal( g1 );
36                  gray2normal( g1 );
37                  decoding( g1 );
38                  decoding( g2 );
39              }
40  };
41 
42 

3.  另外的一些代码
（1）群体中的交叉算法
将经过选择考验的个体放入一个群体，当放入的个体数量达到要求后，对里边的个体进行两两交叉。

 1  // Population Crossover Algorithm
 2  // 1. get the number of Chromosomes in the Population
 3  // 2. get the number of Gens in a Chromosome
 4  // 3. generate a random number
 5  // 4. if the random number is bigger than the probability, skip
 6  // 5. if the selected two genes are of the same value, skip
 7  // 6. crossover the two genes using the selected Gene crossover algorithm
 8  template <   class  POPULATION,  class  GENE_CROSSOVER_ALGORITHM  >
 9  class  Population_Crossover_Algorithm
10  {
11       public :
12           void   operator ()( POPULATION &  population )  const
13          {
14               // 1
15               const  unsigned  int  C_Size  =  population.Chromosome_Array.size();
16              assert( C_Size  >   1  );
17 
18               // 2
19               const  unsigned  int  G_Size  =  population.Chromosome_Array[ 0 ].Gene_Array.size();
20 
21               for  ( unsigned  int  i  =   0 ; i  <  C_Size  /   2 ;  ++ i )
22              {
23                   for ( unsigned  int  j  =   0 ; j  <  G_Size;  ++ j )
24                  {
25                       // 3
26                       const   long   double  Ran  =  ran();
27                       // 4
28                       if  ( Ran  >  population.Crossover_Probability )
29                           continue  ;
30                       // 5
31                       if  ( population.Chromosome_Array[i].Gene_Array[j].Value  ==
32                           population.Chromosome_Array[C_Size - i - 1 ].Gene_Array[j].Value
33                          )
34                           continue ;
35                       // 6
36                      crossover(
37                              population.Chromosome_Array[i].Gene_Array[j],
38                              population.Chromosome_Array[C_Size - i - 1 ].Gene_Array[j],
39                              GENE_CROSSOVER_ALGORITHM()
40                                  );
41                  }
42              }
43          }
44  };

（2） 交叉函数定义
种群的交叉只涉及一个交叉主体，而基因/个体的交叉涉及两个交叉主体，定义如下:

 1  // Population crossover only
 2  template < class  POPULATION,  class  ALGORITHM >
 3  void  crossover( POPULATION &  p,           // the Population to perform crossover
 4                   const  ALGORITHM &  a )     // the Algorithm used for the crossover
 5  {
 6      assert( p.Chromosome_Array.size()  >   1  );
 7      a( p );
 8  }
 9 
10 
11  // gene crossover algorithm
12  template < class  GENE,  class  ALGORITHM >
13  static   void  crossover(  GENE  & g1,                // Gene1 to perform crossvoer
14                          GENE  & g2,                // Gene2 to perform crossvoer
15                           const  ALGORITHM &  a )     // the Algorithm employed
16  {
17      a( g1, g2 );
18  }
19