模拟二进制交叉算子(SBX)与多项式变异(PM)

二进制交叉算子(SBX)

多项式变异(PM)

matlab实现

function chromo_offspring = cross_mutation( chromo_parent,f_num,x_num,x_min,x_max,pc,pm,yita1,yita2,fun )
%模拟二进制交叉与多项式变异
[pop,~]=size(chromo_parent);
suoyin=1;
for i=1:pop
   %%%模拟二进制交叉
   %初始化子代种群
   %随机选取两个父代个体
   parent_1=round(pop*rand(1));
   if (parent_1<1)
       parent_1=1;
   end
   parent_2=round(pop*rand(1));
   if (parent_2<1)
       parent_2=1;
   end
   %确定两个父代个体不是同一个
   while isequal(chromo_parent(parent_1,:),chromo_parent(parent_2,:))
       parent_2=round(pop*rand(1));
       if(parent_2<1)
           parent_2=1;
       end
   end
   chromo_parent_1=chromo_parent(parent_1,:);
   chromo_parent_2=chromo_parent(parent_2,:);
   off_1=chromo_parent_1;
   off_2=chromo_parent_1;
   if(rand(1)<pc)
       %进行模拟二进制交叉
       u1=zeros(1,x_num);
       gama=zeros(1,x_num);
       for j=1:x_num
           u1(j)=rand(1);
           if u1(j)<0.5
               gama(j)=(2*u1(j))^(1/(yita1+1));
           else
               gama(j)=(1/(2*(1-u1(j))))^(1/(yita1+1));
           end
           off_1(j)=0.5*((1+gama(j))*chromo_parent_1(j)+(1-gama(j))*chromo_parent_2(j));
           off_2(j)=0.5*((1-gama(j))*chromo_parent_1(j)+(1+gama(j))*chromo_parent_2(j));
           %使子代在定义域内
           if(off_1(j)>x_max(j))
               off_1(j)=x_max(j);
           elseif(off_1(j)<x_min(j))
               off_1(j)=x_min(j);
           end
           if(off_2(j)>x_max(j))
               off_2(j)=x_max(j);
           elseif(off_2(j)<x_min(j))
               off_2(j)=x_min(j);
           end
       end
       %计算子代个体的目标函数值
       off_1(1,(x_num+1):(x_num+f_num))=object_fun(off_1,f_num,x_num,fun);
       off_2(1,(x_num+1):(x_num+f_num))=object_fun(off_2,f_num,x_num,fun);
   end
   %%%多项式变异
   if(rand(1)<pm)
       u2=zeros(1,x_num);
       delta=zeros(1,x_num);
       for j=1:x_num
           u2(j)=rand(1);
           if(u2(j)<0.5)
               delta(j)=(2*u2(j))^(1/(yita2+1))-1;
           else
               delta(j)=1-(2*(1-u2(j)))^(1/(yita2+1));
           end
           off_1(j)=off_1(j)+delta(j);
           %使子代在定义域内
           if(off_1(j)>x_max(j))
               off_1(j)=x_max(j);
           elseif(off_1(j)<x_min(j))
               off_1(j)=x_min(j);
           end
       end
       %计算子代个体的目标函数值
       off_1(1,(x_num+1):(x_num+f_num))=object_fun(off_1,f_num,x_num,fun);
   end
   if(rand(1)<pm)
       u2=zeros(1,x_num);
       delta=zeros(1,x_num);
       for j=1:x_num
           u2(j)=rand(1);
           if(u2(j)<0.5)
               delta(j)=(2*u2(j))^(1/(yita2+1))-1;
           else
               delta(j)=1-(2*(1-u2(j)))^(1/(yita2+1));
           end
           off_2(j)=off_2(j)+delta(j);
           %使子代在定义域内
           if(off_2(j)>x_max(j))
               off_2(j)=x_max(j);
           elseif(off_2(j)<x_min(j))
               off_2(j)=x_min(j);
           end
       end
       %计算子代个体的目标函数值
       off_2(1,(x_num+1):(x_num+f_num))=object_fun(off_2,f_num,x_num,fun);
   end
   off(suoyin,:)=off_1;
   off(suoyin+1,:)=off_2;
   suoyin=suoyin+2;
end
chromo_offspring=off;
end

python实现SBX

import numpy as np
import random

"""
    SBX 模拟二进制交叉
    SBX主要是模拟基于二进制串的单点交叉工作原理,将其作用于以实数表示的染色体。
    两个父代染色体经过交叉操作产生两个子代染色体,使得父代染色体的有关模式信息在子代染色体中得以保留。
    输入：
        population 种群规模
        alfa 交叉概率
        numRangeList 决策变量上限
        mu是一个(0,1)的随机数
"""

def cross(population, alfa, numRangeList, mu=1):
    N = population.shape[0]
    V = population.shape[1]
    populationList = range(N)

    for _ in range(N):
        r = random.random()

        if r < alfa:
            p1, p2 = random.sample(populationList, 2)
            beta = np.array([0] * V)
            randList = np.random.random(V)
            
            for j in range(V):
                if randList.any() <= 0.5:
                    beta[j] = (2.0 * randList[j]) ** (1.0 / (mu + 1))
                else:
                    beta[j] = (1.0 / (2.0 * (1 - randList[j]))) ** (1.0 / (mu + 1))

                # 随机选取两个个体
                old_p1 = population[p1,]
                old_p2 = population[p2,]
                # 交叉
                new_p1 = 0.5 * ((1 + beta) * old_p1 + (1 - beta) * old_p2)
                new_p2 = 0.5 * ((1 - beta) * old_p1 + (1 + beta) * old_p2)

                # 上下界判断
                new_p1 = np.max(np.vstack((new_p1, np.array([0] * V))), 0)
                new_p1 = np.min(np.vstack((new_p1, numRangeList)), 0)

                new_p2 = np.max(np.vstack((new_p2, np.array([0] * V))), 0)
                new_p2 = np.min(np.vstack((new_p2, numRangeList)), 0)

                # 将交叉后的个体返回给种群
                population[p1,] = new_p1
                population[p2,] = new_p2


if __name__ == '__main__':
    random.seed(0)
    np.random.seed(0)
    xN = 10
    yN = 5
    alfa = 0.9
    population = np.random.rand(xN * yN).reshape(xN, yN) * 1.0

    print('交叉前：')
    print(population)
    # 交叉
    cross(population, alfa, np.array([1] * 5))
    print('交叉后：')
    print(population)

运行结果

参考：
多目标优化算法（一）NSGA-Ⅱ（NSGA2）

SBX(Simulated binary crossover)模拟二进制交叉算子和DE(differential evolution)差分进化算子

SBX的python实现