遗传算法（python版）

1440359316

遗传算法（GA）是最早由美国Holland教授提出的一种基于自然界的“适者生存，优胜劣汰”基本法则的智能搜索算法。该法则很好地诠释了生物进化的自然选择过程。遗传算法也是借鉴该基本法则，通过基于种群的思想，将问题的解通过编码的方式转化为种群中的个体，并让这些个体不断地通过选择、交叉和变异算子模拟生物的进化过程，然后利用“优胜劣汰”法则选择种群中适应性较强的个体构成子种群，然后让子种群重复类似的进化过程，直到找到问题的最优解或者到达一定的进化（运算）时间。

9 a, r% W5 A' S4 rGa算法中的几个重要名词概念。
6 r5 v1 x5 }8 r6 v# ?' j
# B, c- K  W! \$ l个体（染色体）：自然界中一个个体（染色体）代表一个生物，在GA算法中，个体（染色体）代表了具体问题的一个解。


基因：在GA算法中，基因代表了具体问题解的一个决策变量，问题解和染色体中基因的对应关系如下所示：
2 a% g6 e* V: |& z

: f( T, x# _; w# g# k种群：多个个体即组成一个种群。GA算法中，一个问题的多组解即构成了问题的解的种群。
8 [# J* @* V" u- ^5 d( F6 E
* m  x* t9 H  \* J0 Y( [2、主要步骤
GA算法的基本步骤如下：

Step 1. 种群初始化。选择一种编码方案然后在解空间内通过随机生成的方式初始化一定数量的个体构成GA的种群。

Step 2. 评估种群。利用启发式算法对种群中的个体（矩形件的排入顺序）生成排样图并依此计算个体的适应函数值（利用率），然后保存当前种群中的最优个体作为搜索到的最优解。

Step 3. 选择操作。根据种群中个体的适应度的大小，通过轮盘赌或者期望值方法，将适应度高的个体从当前种群中选择出来。

5 d; N" O' J) A, M2 c6 [* o2 \Step 4. 交叉操作。将上一步骤选择的个体，用一定的概率阀值Pc控制是否利用单点交叉、多点交叉或者其他交叉方式生成新的交叉个体。
- J) x, ?' e1 I1 t/ r
: \  N6 t& Q; vStep 5. 变异操作。用一定的概率阀值Pm控制是否对个体的部分基因执行单点变异或多点变异。

Step 6. 终止判断。若满足终止条件，则终止算法，否则返回Step 2。
% n1 p& A; \4 [  S1 Q+ L8 s
流程图如下所示：
! j3 w4 e. X3 S" h2 U, P+ |# R

3、主要操作介绍
9 s. {1 }( Y2 u% P  N( P$ k, y3.1 种群初始化
种群的初始化和具体的问题有关。比如一个问题有n个决策变量{x1,x2,…,xn}。每个决策变量有取值范围:下界{L1,L2,…,Ln}和上界{U1,U2,…,Un}，则种群中个体的初始化即随机地在决策变量的取值范围内生成各个决策变量的值：Xj={x1,x2,...,xn}，其中xi属于范围(Li，Ui)内。所有的个体即构成种群。当每个个体都初始化后，即种群完成初始化。

3.2 评价种群
) p0 V; X' ^) f4 ]种群的评价即计算种群中个体的适应度值。假设种群population有popsize个个体。依次计算每个个体的适应度值及评价种群。
- a& H: t7 L! }: @- @( d- _1 e
3.3 选择操作
  @) x: M* n9 O8 {  VGA算法中常见的选择操作有轮盘赌方式：种群中适应度值更优的个体被选择的概率越大。假设popsize=4，按照如下表达式计算各个个体的被选择概率的大小，然后用圆饼图表示如下。
5 T0 c0 M- J# N0 L# {# o) X. q0 R
2 t% O' y; F8 ^0 b1 d' L' p( y" zP(Xj) = fit(Xj)/(fit(X1)+fit(X2)+fit(X3)+fit(X4)),j=1,2,3,4
% U7 u1 y! d5 L/ L# x# A: U1 D3 Y
) t9 P9 A7 ^" G* a  t
当依据轮盘赌方式进行选择时，则概率越大的越容易被选择到。

( u9 p: @0 X4 H+ x) I3.4 交叉操作
" Q/ O: z3 Z# o6 n3 H% l: m交叉操作也有许多种：单点交叉，两点交叉等。此处仅讲解一下两点交叉。首先利用选择操作从种群中选择两个父辈个体parent1和parent2,然后随机产生两个位置pos1和pos2，将这两个位置中间的基因位信息进行交换，便得到下图所示的off1和off2两个个体，但是这两个个体中一般会存在基因位信息冲突的现象（整数编码时），此时需要对off1和off2个体进行调整：off1中的冲突基因根据parent1中的基因调整为parent2中的相同位置处的基因。如off1中的“1”出现了两次，则第二处的“1”需要调整为parent1中“1”对应的parent2中的“4”，依次类推处理off1中的相冲突的基因。需要注意的是，调整off2，则需要参考parent2。


- q" n9 U. }+ n& O5 O1 i% l
6 E! M+ K; _) J# N3.5 变异操作
变异操作的话，根据不同的编码方式有不同的变异操作。
& e- `& ^" ~8 N- X3 g: V1 h& c+ A  V
- |# Y$ l; m; }. g& D如果是浮点数编码，则变异可以就染色体中间的某一个基因位的信息进行变异（重新生成或者其他调整方案）。

9 x. u. [" M9 M. O% S; z
如果是采用整数编码方案，则一般有多种变异方法：位置变异和符号变异。

  [) \" I  z- v0 U) ?  f; l/ ?3 m; p位置变异：

  z- R3 c& K! L2 b
符号变异：
. Z% U$ x# z  V
0 j1 {& I; s. U: `5 w
4、Python代码
#-*- coding:utf-8 -*-
9 ^3 g* v' r4 M# l4 k- \3 \2 `: V
" ?: G. E/ K8 |import random
import math
from operator import itemgetter

( l$ D, E) E) \$ X& {# Mclass Gene:
' x! \/ q- [' |0 W$ P3 c$ E) {    '''
    This is a class to represent individual(Gene) in GA algorithom
- }" y9 A. X' c7 U    each object of this class have two attribute: data, size
+ e' ]1 D1 v6 u+ }  _5 D$ r    '''
    def __init__(self,**data):
        self.__dict__.update(data)      
        self.size = len(data['data'])#length of gene
0 q* \- F- f) _

class GA:
9 J, K1 |9 H4 j: L, V) U6 U4 k8 D    '''
    This is a class of GA algorithm.
    '''
. Q# y' v  v9 ^* i1 d0 d- E    def __init__(self,parameter):
        '''
8 W% j# o. h" X% W- ^8 H% [3 o, q5 y( h        Initialize the pop of GA algorithom and evaluate the pop by computing its' fitness value .
        The data structure of pop is composed of several individuals which has the form like that:
. V- A! R( @! o
( z! D3 j" Q7 r        {'Gene':a object of class Gene, 'fitness': 1.02(for example)}
7 W% D6 t1 z  n# u6 f3 x        Representation of Gene is a list: [b s0 u0 sita0 s1 u1 sita1 s2 u2 sita2]

6 K, N2 h& }" \' q% P& H. P        '''
        #parameter = [CXPB, MUTPB, NGEN, popsize, low, up]
7 I5 `( @+ `! U: g- h  [8 o& v        self.parameter = parameter
) c+ X# w5 _1 `: k* L, ]# t0 L
% @+ b1 e1 \6 m8 `+ ]8 \6 G$ q        low = self.parameter[4]
- v2 }# y+ y( K5 g        up = self.parameter[5]

$ v# K8 z/ H' `& A- ?        self.bound = []
8 x& j5 }0 g2 Z. [( N        self.bound.append(low)
        self.bound.append(up)

2 z0 W4 l6 O7 e& l) X; a        pop = []
        for i in range(self.parameter[3]):
            geneinfo = []
) k( Z2 @! r; Y+ d            for pos in range(len(low)):
& }1 Q5 P# o) q8 c2 \/ ~) r                geneinfo.append(random.uniform(self.bound[0][pos], self.bound[1][pos]))#initialise popluation
' T6 e9 U3 Z9 S( J
            fitness = evaluate(geneinfo)#evaluate each chromosome
            pop.append({'Gene':Gene(data = geneinfo), 'fitness':fitness})#store the chromosome and its fitness

$ f7 _  u; D+ Y" x# A' A        self.pop = pop
        self.bestindividual = self.selectBest(self.pop)#store the best chromosome in the population

* b) Q& B+ I/ F+ W7 V0 _    def selectBest(self, pop):
/ y- U6 f9 r8 V8 M0 @2 }) d! {        '''
        select the best individual from pop
        '''
( Z. M% X# z4 o! E* \1 H1 U        s_inds = sorted(pop, key = itemgetter("fitness"), reverse = False)
$ T) ^: l- j( F! g- H( p! f        return s_inds[0]

/ Y- Y6 N: Q. Y9 M# ~    def selection(self, individuals, k):
$ I/ E: Q( W1 o7 I: X6 _        '''
        select two individuals from pop
        '''
; E( a9 o1 G3 C; N: d: y6 `6 k5 \3 U7 I        s_inds = sorted(individuals, key = itemgetter("fitness"), reverse=True)#sort the pop by the reference of 1/fitness
        sum_fits = sum(1/ind['fitness'] for ind in individuals) #sum up the 1/fitness of the whole pop

        chosen = []
  J4 r' S( _. I; d, n        for i in xrange(k):
( d8 R  _& Y' B4 n! @( {            u = random.random() * sum_fits#randomly produce a num in the range of [0, sum_fits]
/ l- s; k* d% B            sum_ = 0
            for ind in s_inds:
1 e5 w' Y: Y& |' B% ?0 N                sum_ += 1/ind['fitness']#sum up the 1/fitness
  C7 ~) M9 |! G+ M) _" Z                if sum_ > u:
                    #when the sum of 1/fitness is bigger than u, choose the one, which means u is in the range of [sum(1,2,...,n-1),sum(1,2,...,n)] and is time to choose the one ,namely n-th individual in the pop
                    chosen.append(ind)
                    break
# e6 E/ F4 E6 k  P9 G$ i
        return chosen   


. {& N9 Q+ b9 S) K    def crossoperate(self, offspring):
7 Z$ d) p( f, ~        '''
        cross operation
        '''
; `; W* k$ d# h7 d        dim = len(offspring[0]['Gene'].data)

        geninfo1 = offspring[0]['Gene'].data#Gene's data of first offspring chosen from the selected pop
+ ^* _0 L& Q5 p9 f        geninfo2 = offspring[1]['Gene'].data#Gene's data of second offspring chosen from the selected pop
+ N: C( D- X% V7 w
        pos1 = random.randrange(1,dim)#select a position in the range from 0 to dim-1,
& c2 g5 U- P- ^. q        pos2 = random.randrange(1,dim)
  I4 J3 f" T  ~5 ^
        newoff = Gene(data = [])#offspring produced by cross operation
        temp = []
        for i in range(dim):
% V6 C4 M* t$ u! g) Z9 H$ T- z            if (i >= min(pos1,pos2) and i <= max(pos1,pos2)):
                temp.append(geninfo2)
                #the gene data of offspring produced by cross operation is from the second offspring in the range [min(pos1,pos2),max(pos1,pos2)]
            else:
0 ]* S; v/ L5 a$ ?( j                temp.append(geninfo1)
                #the gene data of offspring produced by cross operation is from the frist offspring in the range [min(pos1,pos2),max(pos1,pos2)]
7 e5 T% ~( e2 _4 H$ `* F. e        newoff.data = temp

        return newoff


    def mutation(self, crossoff, bound):
1 e& j2 \  c$ y$ A3 g        '''
& d# w- n% z( q2 D( n# y# _! J6 B7 u        mutation operation
        '''
9 e3 q( ^9 {7 f0 i, o  q  b2 L" p
% {. C6 T- N( O        dim = len(crossoff.data)

        pos = random.randrange(1,dim)#chose a position in crossoff to perform mutation.
+ h& d: q* a4 d) g5 F
        crossoff.data[pos] = random.uniform(bound[0][pos],bound[1][pos])
5 N  f+ e* J  |: u        return crossoff
& w2 K/ S7 d" j3 f# Y
    def GA_main(self):
0 j0 [6 A) g7 d        '''
        main frame work of GA
4 n7 [* [& j  A5 ~( @. ?5 T        '''
) d/ {( q5 g8 `& v1 K  b* Z
        popsize = self.parameter[3]

) [# x7 [& |3 j1 ^1 \        print("Start of evolution")
; z9 b% K# S- N& B) m
/ c2 l. S1 g# O, W        # Begin the evolution
7 u: t( X7 V7 m$ ?7 T        for g in range(NGEN):

            print("-- Generation %i --" % g)      
+ h2 G8 F" k3 b9 M
6 h' A% r2 T0 s1 Y8 e. z1 S            #Apply selection based on their converted fitness
9 r& t, t7 k$ t! s0 B8 @            selectpop = self.selection(self.pop, popsize)   
& Z! t" F3 t* q7 g/ }% t: X
            nextoff = []   
( `$ S4 f, e% n            while len(nextoff) != popsize:      
                # Apply crossover and mutation on the offspring            

. \$ ]* I; O5 d                # Select two individuals
, i1 c3 T9 @! l* v0 H: @9 B) D: L6 G. Y                offspring = [random.choice(selectpop) for i in xrange(2)]

- w$ x+ }, G6 }- Z; h' p                if random.random() < CXPB: # cross two individuals with probability CXPB
                    crossoff = self.crossoperate(offspring)
                    fit_crossoff = evaluate(self.xydata, crossoff.data)# Evaluate the individuals           

( w! x. X0 c9 m; g+ W7 |: n' Z& f: U                    if random.random() < MUTPB: # mutate an individual with probability MUTPB
                        muteoff = self.mutation(crossoff,self.bound)
& G3 i! Z. O7 j9 p                        fit_muteoff = evaluate(self.xydata, muteoff.data)# Evaluate the individuals
/ \8 v- o3 w9 ~/ g' [                        nextoff.append({'Gene':muteoff,'fitness':fit_muteoff})

' t8 x$ G6 `1 v5 l. f$ D            # The population is entirely replaced by the offspring
            self.pop = nextoff
+ }* l+ j5 G$ R' W& f# u0 s0 v9 U
3 P# c* e, X) r+ Q            # Gather all the fitnesses in one list and print the stats
+ k  @3 v4 Y9 g$ _! G            fits = [ind['fitness'] for ind in self.pop]

: g6 e6 p7 d3 c* y  _            length = len(self.pop)
  n: _; G) k3 y, s3 J            mean = sum(fits) / length
            sum2 = sum(x*x for x in fits)
) z( I8 s0 J7 ~  t6 @- Y            std = abs(sum2 / length - mean**2)**0.5
6 r8 C2 g  j9 i4 A: V2 |" C            best_ind = self.selectBest(self.pop)

+ K. q1 q  e5 c# X            if best_ind['fitness'] < self.bestindividual['fitness']:
7 z2 V5 i: v9 h1 x7 B7 Q                self.bestindividual = best_ind
. J: K) C9 U4 L* ]" I2 w) S
# J$ c3 r. R% P" M/ ^            print("Best individual found is %s, %s" % (self.bestindividual['Gene'].data,self.bestindividual['fitness']))
; g1 P1 p: \: ]2 j$ O  b            print("  Min fitness of current pop: %s" % min(fits))
            print("  Max fitness of current pop: %s" % max(fits))
            print("  Avg fitness of current pop: %s" % mean)
% n# O% D+ @3 M4 }            print("  Std of currrent pop: %s" % std)
7 u7 B2 s6 |' G6 @& |: {# d
1 B: q7 G0 r6 c1 N8 O9 ]        print("-- End of (successful) evolution --")   

8 A& d0 |$ U7 g0 h2 _( dif __name__ == "__main__":

    CXPB, MUTPB, NGEN, popsize = 0.8, 0.3, 50, 100#control parameters
, O6 _7 z/ \- n' G: ~8 Z
  A3 [, V  l4 u% b: \    up = [64, 64, 64, 64, 64, 64, 64, 64, 64, 64]#upper range for variables
    low = [-64, -64, -64, -64, -64, -64, -64, -64, -64, -64]#lower range for variables
' S4 U' Z. f! r' m3 k0 n2 d. v    parameter = [CXPB, MUTPB, NGEN, popsize, low, up]
4 {: r" r+ v4 j! {0 v; g8 v  x; U
6 c, I/ M# i- h9 D% ]0 u) M    run = GA(parameter)
1 X& s- f; E9 |7 b% F$ `    run.GA_main()
————————————————
  z$ ?" D, c; y版权声明：本文为CSDN博主「bible_reader」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/bible_reader/article/details/72782675
; P, u6 p8 c! \9 C8 {
5 G& l8 l" |' A, U- S

2580684929

牛蛙，最近在看这个

2275929388

566666666666666666666
  C3 ^% W2 N; r! d

wwyx。

赞赞赞赞

2275929388

遗传退货怎么都看不懂

852952290

111111111111111111
" E  `9 t7 Y$ j+ Z+ p

738391227

0000000000000000000000000

lifekokool

可能我有点笨吧，看了之后还是不知道该怎么应用某个问题

1034228464

python实现遗传算法易懂
* i6 k) O" q5 e1 t