标准遗传算法（实数编码 python实现）模拟二进制交叉SBX 多项式变异

代码地址：

https://github.com/guojun007/real_sga

本部分是采用实数编码的标准遗传算法，整体流程与上一篇二进制编码的基本一致，

主要区别在于本部分的交叉操作为模拟二进制交叉，即SBX ,

变异操作　为　多项式变异。

real_sga/crossover/crossover.py

#实数编码,SBX交叉

def crossover(population, pcross_real, V, minRealVal, maxRealVal, eta_c):

    for i in xrange(0, len(population), 2):

        #如果随机概率大于交叉概率则不进行交叉操作

        if random.random()>pcross_real:

            continue

        #对两个个体执行SBX交叉操作

        for j in xrange(V):

            #对某自变量交叉

            ylow=minRealVal[j]

            yup=maxRealVal[j]

            y1=population[i][j]

            y2=population[i+1][j]

            r=random.random()

            if r<=0.5:

                betaq=(2*r)**(1.0/(eta_c+1.0))

            else:

                betaq=(0.5/(1.0-r))**(1.0/(eta_c+1.0))

            child1=0.5*( (1+betaq)*y1+(1-betaq)*y2 )

            child2=0.5*( (1-betaq)*y1+(1+betaq)*y2 )

            child1=min(max(child1, ylow), yup)

            child2=min(max(child2, ylow), yup)

            population[i][j]=child1

            population[i+1][j]=child2

以上代码是根据相关论文所写，是原始方式的化简版本。

以下给出官方的原始代码的　Ｐython２.7  　重构版。

#实数编码,SBX交叉

def crossover(population, pcross_real, V, minRealVal, maxRealVal, eta_c):

    for i in xrange(0, len(population), 2):

        #如果随机概率大于交叉概率则不进行交叉操作

        if random.random()>pcross_real:

            continue

        #对两个个体执行SBX交叉操作

        for j in xrange(V):

            #判断是否对某自变量交叉

            if random.random()>0.5:

                continue

            #如果两个体某自变量相等则不操作

            if population[i][j]==population[i+1][j]:

                continue

            #对某自变量交叉

            y1=min(population[i][j], population[i+1][j])

            y2=max(population[i][j], population[i+1][j])

            ylow=minRealVal[j]

            yup=maxRealVal[j]

            r=random.random()

            beta=1.0+(2.0*(y1-ylow)/(y2-y1))

            alpha=2.0-beta**( -(eta_c+1.0) )

            if r<=(1.0/alpha):

                betaq=(r*alpha)**(1.0/(eta_c+1.0))

            else:

                betaq=(1.0/(2.0-r*alpha))**(1.0/(eta_c+1.0))

            child1=0.5*( (y1+y2)-betaq*(y2-y1) )

            beta=1.0+(2.0*(yup-y2)/(y2-y1))

            alpha=2.0-beta**( -(eta_c+1.0) )

            if r<=(1.0/alpha):

                betaq=(r*alpha)**(1.0/(eta_c+1.0))

            else:

                betaq=(1.0/(2.0-r*alpha))**(1.0/(eta_c+1.0))

            child2=0.5*( (y1+y2)-betaq*(y2-y1) )

            child1=min(max(child1, ylow), yup)

            child2=min(max(child2, ylow), yup)

            population[i][j]=child1

            population[i+1][j]=child2

多项式变异：

real_sga/mutation/mutation.py

#Routine for real polynomial mutation of an individual

#实数编码的常规多项式变异

def mutation(population, pmut_real, V, minRealVal, maxRealVal, eta_m):

    for i in xrange(len(population)):

        for j in xrange(V):

            r=random.random()

            #对个体某变量进行变异

            if r<=pmut_real:

                y=population[i][j]

                ylow=minRealVal[j]

                yup=maxRealVal[j]

                delta1=1.0*(y-ylow)/(yup-ylow)

                delta2=1.0*(yup-y)/(yup-ylow)

                #delta=min(delta1, delta2)

                r=random.random()

                mut_pow=1.0/(eta_m+1.0)

                if r<=0.5:

                    xy=1.0-delta1

                    val=2.0*r+(1.0-2.0*r)*(xy**(eta_m+1.0))

                    deltaq=val**mut_pow-1.0

                else:

                    xy=1.0-delta2

                    val=2.0*(1.0-r)+2.0*(r-0.5)*(xy**(eta_m+1.0))

                    deltaq=1.0-val**mut_pow

                y=y+deltaq*(yup-ylow)

                y=min(yup, max(y, ylow))

                population[i][j]=y