遗传算法-交叉算法

遗传算法系列 （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