遗传算法程序设计

Begin
      t=0 % 遗传代数
      初始化P(t)
      计算P(t)的适应值
      while(不满足条件时)
          begin
          t=t+1
          从P(t-1)中选择P(t) %选择
          重组P(t)           %交叉和变异
          计算P(t)的适应值
          end

import numpy as np
import random
from math import *

bounds=[-2,2]             #一维变量的取值范围
precision=0.0001          #运算精度
bounds_begin ,bounds_end = bounds[0] ,bounds[1]

#计算满足所需精度需要至少多少染色体
BitLength=ceil(log((bounds_end-bounds_begin)/precision ,2))
popsize=50 #初始种群大小
Generationmax=200 #最大代数
pcrossover=0.9 #交配概率
pmutation=0.09 #变异概率
#产生初始种群
population = np.rint(np.random.rand(popsize,BitLength))

def func(x):
    
    """
        目标函数: y=200exp(-0.05x)*sin(x)  x∈[-2,2]
        参数：x 自变量
        返回值：y 因变量
    """

    y = 200*exp(-0.05*x)*sin(x)
    
    return y


def fitnessfun(population):
    
    """
        计算种群适应度和累计概率函数 fitnessfun()
        参数：population 种群的染色体
        返回值：[Fitvalue，cumsump] 适应度和累计概率
    """
    popsize=population.shape[0]
    Fitvalue=[]
    for i in range(0,popsize):
        x=0
        for j in range(BitLength-1,-1,-1):
            x += population[i,j]*2**j
        xx=bounds_begin + x*(bounds_end-bounds_begin)/(2**BitLength-1)
        y=func(x)+230 #保证适应度为正值
        Fitvalue.append(y)
        
    #计算选择概率
    fsum=sum(Fitvalue)
    Perpopulation=[item/fsum for item in Fitvalue]
        
        
    #计算累计概率
    cumsump=[Perpopulation[0]]
    for i in range(1,popsize):
        cumsump.append(cumsump[i-1]+Perpopulation[i])
        
    return [Fitvalue,cumsump]


def IfCroIfMut(mutorcro):
    """
        根据概率判断是否应该发生交叉或变异
        轮盘赌算法
    """
    test=np.zeros(100)
    l=round(100*mutorcro)
    for i in range(l):test[i]=1
    n=random.randint(0,99)
    
    return test[n]
    
    
    

def mutation(snew,pmutation):
    """
        变异函数，使染色体发生变异
        参数：snew,pmutation 种群染色体,变异概率
        返回值：snnew 变异后的染色体
    """
    BitLength=snew.shape[0]
    snnew=snew
    pmm=IfCroIfMut(pmutation)
    if pmm:
        chb=random.randint(0,BitLength-1)
        snnew[chb]=1-snew[chb]
    
    return snnew

def crossover(population,seln,pc):
    """
        交叉函数，使得两个染色体进行交叉
        参数：population,seln,pc 种群染色体，交叉个体，交叉概率
        返回值：交叉后的染色体
    """
    
    BitLength=population.shape[1]
    pcc=IfCroIfMut(pc)
    if pcc:
        chb=random.randint(0,BitLength-1)
    
        a=np.append(population[seln[0],0:chb],population[seln[1],chb:])
        b=np.append(population[seln[1],0:chb],population[seln[0],chb:])
    else:
        a=population[seln[0],:]
        b=population[seln[1],:]
    a1=a.reshape(1,a.shape[0])
    b1=b.reshape(1,b.shape[0])
    return np.append(a1,b1,axis=0)

def Selection(population,cumsump):
    """
        新种群选择操作
        
    """
    i_,j_=np.random.rand(1,2)[0,0],np.random.rand(1,2)[0,1]
    prand1=[item - i_ for item in cumsump]
    prand2=[item - j_ for item in cumsump]
    i,j = 0,0

    while prand1[i]<0 : i = i+1
    while prand2[j]<0 : j = j+1

    return [i,j]

            
        
    
#计算适应度，返回适应度Fitvalue和累计概率cumsump
[Fitvalue , cumsump] = fitnessfun(population)

Generation=1
ymax=[]
xmax=[]
ymean=[]
scnew=np.empty(shape=[0,16])
while Generation < Generationmax + 1:
    scnew=[]
    flag=1
    for j in range(0,popsize,2):
        #选择操作
        seln=Selection(population,cumsump)
        #交叉操作
        scro=crossover(population,seln,pcrossover)
        
        a=mutation(scro[0,:],pmutation)
        b=mutation(scro[1,:],pmutation)
        
        a1=a.reshape(1,a.shape[0])
        b1=b.reshape(1,b.shape[0])
        
        if flag == 1:
            flag -=1
            scnew=np.append(a1,b1,axis=0)
        else:
            scnew=np.append(scnew,a1,axis=0)
            scnew=np.append(scnew,b1,axis=0)
            
    population=scnew #产生了新的种群
    [Fitvalue,cumsup]=fitnessfun(population)
    fmax,index=np.max(Fitvalue),np.argmax(Fitvalue)
    fmean=np.mean(Fitvalue)
    ymax.append(fmax)
    ymean.append(fmean)
    
    x=0
    for j in range(BitLength-1,-1,-1):
        x += population[index,j]*2**j
    xx=bounds_begin + x*(bounds_end-bounds_begin)/(2**BitLength-1)
    xmax.append(xx)
    Generation += 1

print(func(xx))