def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'Population.Population'>":
raise RuntimeError('传入的种群对象必须为Population类型')
self.name = 'awGA'
self.selFunc = 'tour' # 选择方式，采用锦标赛选择
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR=1) # 生成部均匀交叉算子对象
self.mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.recOper = ea.Xovud(XOVR=1) # 生成部均匀交叉算子对象
self.mutOper = ea.Mutuni(Pm=1 / self.problem.Dim,
Alpha=False,
MutShrink=1,
Middle=False) # 生成均匀变异算子对象
self.extraMutOper = ea.Mutgau(
Pm=1 / self.problem.Dim,
Sigma3=False,
MutShrink=3,
Middle=False) # 额外生成一个高斯变异算子对象，对标准差放大3倍
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.MAXSIZE = population.sizes # 非支配解集大小限制
def __init__(self, problem, population):
ea.SoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'PsyPopulation.PsyPopulation'>":
raise RuntimeError('传入的种群对象必须为PsyPopulation类型')
self.name = 'GGAP-SGA'
self.selFunc = 'rws' # 轮盘赌选择算子
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
else:
recOper = ea.Xovdp(XOVR=1) # 生成两点交叉算子对象
if population.Encodings[i] == 'BG':
mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encodings[i] == 'RI':
mutOper = ea.Mutbga(Pm=1 / self.problem.Dim,
MutShrink=0.5,
Gradient=20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
self.GGAP = 0.9 # 代沟，表示使用多少个子代替换父代来形成新一代种群
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'PsyPopulation.PsyPopulation'>":
raise RuntimeError('传入的种群对象必须为PsyPopulation类型')
self.name = 'psy-awGA'
self.selFunc = 'tour' # 选择方式，采用锦标赛选择
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encodings[i] == 'BG':
recOper = ea.Xovud(XOVR=1) # 生成部均匀交叉算子对象
mutOper = ea.Mutbin(Pm=1) # 生成二进制变异算子对象
elif population.Encodings[i] == 'RI':
recOper = ea.Xovud(XOVR=1) # 生成部均匀交叉算子对象
mutOper = ea.Mutuni(Pm=1,
Alpha=False,
MutShrink=1,
Middle=False) # 生成均匀变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
self.extraMutOper = ea.Mutgau(Pm=1,
Sigma=False,
MutShrink=3,
Middle=False) # 额外生成一个高斯变异算子对象，对标准差放大3倍
self.MAXSIZE = population.sizes # 非支配解集大小限制
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'PsyPopulation.PsyPopulation'>":
raise RuntimeError('传入的种群对象必须为PsyPopulation类型')
self.name = 'psy-RVEA-RES'
self.ndSort = ea.ndsortESS # 设置非支配排序算子
self.selFunc = 'urs' # 选择方式，采用无约束随机选择
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR = 1) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm = 1) # 生成逆转变异算子对象
elif population.Encodings[i] == 'BG':
recOper = ea.Xovud(XOVR = 1) # 生成均匀交叉算子对象
mutOper = ea.Mutbin(Pm = None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encodings[i] == 'RI':
recOper = ea.Recsbx(XOVR = 1, n = 20) # 生成模拟二进制交叉算子对象
mutOper = ea.Mutpolyn(Pm = 1/self.problem.Dim, DisI = 20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
self.a = 2 # RVEA算法中的参数alpha
self.fr = 0.1 # RVEA算法中的参数fr
def __init__(self, problem, population):
ea.SoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'PsyPopulation.PsyPopulation'>":
raise RuntimeError('传入的种群对象必须为PsyPopulation类型')
self.name = 'psy-studGA'
self.problem = problem
self.population = population
self.selFunc = 'tour' # 锦标赛选择算子
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
else:
recOper = ea.Xovdp(XOVR=1) # 生成两点交叉算子对象
if population.Encodings[i] == 'BG':
mutOper = ea.Mutbin(Pm=1) # 生成二进制变异算子对象
elif population.Encodings[i] == 'RI':
mutOper = ea.Mutbga(Pm=1, MutShrink=0.5,
Gradient=20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
def __init__(self,
problem,
population,
MAXGEN=None,
MAXTIME=None,
MAXEVALS=None,
MAXSIZE=None,
logTras=None,
verbose=None,
outFunc=None,
drawing=None,
dirName=None,
**kwargs):
# 先调用父类构造方法
super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS, MAXSIZE, logTras, verbose, outFunc, drawing, dirName)
if population.ChromNum != 1:
raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
self.name = 'NSGA2-archive'
if self.problem.M < 10:
self.ndSort = ea.ndsortESS # 采用ENS_SS进行非支配排序
else:
self.ndSort = ea.ndsortTNS # 高维目标采用T_ENS进行非支配排序，速度一般会比ENS_SS要快
self.selFunc = 'tour' # 选择方式，采用锦标赛选择
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR=1) # 生成均匀交叉算子对象
self.mutOper = ea.Mutbin(Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.recOper = ea.Recsbx(XOVR=1, n=20) # 生成模拟二进制交叉算子对象
self.mutOper = ea.Mutpolyn(Pm=1 / self.problem.Dim, DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
self.MAXSIZE = 10 * population.sizes # 全局非支配解存档的大小限制，默认为10倍的种群个体数
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if population.ChromNum != 1:
raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
self.name = 'MOEA/D'
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR=1, Half_N=True) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR=1, Half_N=True) # 生成均匀交叉算子对象
self.mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.recOper = ea.Recsbx(XOVR=1, n=20,
Half_N=True) # 生成模拟二进制交叉算子对象
self.mutOper = ea.Mutpolyn(Pm=1 / self.problem.Dim,
DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.neighborSize = None # 邻域大小，当设置为None时，将会自动设置为等于种群规模
if self.problem.M <= 2:
self.decomposition = ea.tcheby # 采用切比雪夫权重聚合法
else:
self.decomposition = ea.pbi # 采用pbi权重聚合法
self.Ps = 0.9 # (Probability of Selection)表示进化时有多大的概率只从邻域中选择个体参与进化
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'PsyPopulation.PsyPopulation'>":
raise RuntimeError('传入的种群对象必须为PsyPopulation类型')
self.name = 'psy-RVEA'
self.selFunc = 'urs' # 选择方式，采用无约束随机选择
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encodings[i] == 'BG':
recOper = ea.Xovud(XOVR=1) # 生成均匀交叉算子对象
mutOper = ea.Mutbin(Pm=1) # 生成二进制变异算子对象
elif population.Encodings[i] == 'RI':
recOper = ea.Recsbx(XOVR=1, n=20) # 生成模拟二进制交叉算子对象
mutOper = ea.Mutpolyn(Pm=1, DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
self.a = 2 # RVEA算法中的参数alpha
self.fr = 0.1 # RVEA算法中的参数fr
self.Gamma = None # RVEA算法中的Gamma（详见参考文献的公式10），在每次更新参考点后Gamma要重置为None以便重新计算
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'PsyPopulation.PsyPopulation'>":
raise RuntimeError('传入的种群对象必须为PsyPopulation类型')
self.name = 'psy-NSGA3'
if self.problem.M < 10:
self.ndSort = ea.ndsortESS # 采用ENS_SS进行非支配排序
else:
self.ndSort = ea.ndsortTNS # 高维目标采用T_ENS进行非支配排序，速度一般会比ENS_SS要快
self.selFunc = 'tour' # 选择方式，采用锦标赛选择
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encodings[i] == 'BG':
recOper = ea.Xovud(XOVR=1) # 生成均匀交叉算子对象
mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encodings[i] == 'RI':
recOper = ea.Recsbx(XOVR=1, n=20) # 生成模拟二进制交叉算子对象
mutOper = ea.Mutpolyn(Pm=1 / self.problem.Dim,
DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if population.ChromNum == 1:
raise RuntimeError('传入的种群对象必须是多染色体的种群类型。')
self.name = 'psy-awGA'
self.selFunc = 'tour' # 选择方式，采用锦标赛选择
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encodings[i] == 'BG':
recOper = ea.Xovud(XOVR=1) # 生成部均匀交叉算子对象
mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encodings[i] == 'RI':
recOper = ea.Xovud(XOVR=1) # 生成部均匀交叉算子对象
mutOper = ea.Mutuni(Pm=1 / self.problem.Dim,
Alpha=False,
Middle=False) # 生成均匀变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
self.extraMutOper = ea.Mutgau(Pm=1 / self.problem.Dim,
Sigma3=False,
Middle=False) # 额外生成一个高斯变异算子对象，对标准差放大3倍
self.MAXSIZE = population.sizes # 非支配解集大小限制
def __init__(self, problem, population):
ea.SoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if population.ChromNum == 1:
raise RuntimeError('传入的种群对象必须是多染色体的种群类型。')
self.name = 'psy-EGA'
self.selFunc = 'tour' # 锦标赛选择算子
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=0.7) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=0.5) # 生成逆转变异算子对象
else:
recOper = ea.Xovdp(XOVR=0.7) # 生成两点交叉算子对象
if population.Encodings[i] == 'BG':
mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encodings[i] == 'RI':
mutOper = ea.Mutbga(Pm=1 / self.problem.Dim,
MutShrink=0.5,
Gradient=20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
def __init__(self, problem, population):
ea.SoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if type(population) != list:
raise RuntimeError('传入的种群对象列表必须为list类型')
self.name = 'multi-SEGA'
self.PopNum = len(population) # 种群数目
self.selFunc = 'tour' # 锦标赛选择算子
self.migFr = 5 # 发生种群迁移的间隔代数
self.migOpers = ea.Migrate(MIGR=0.2, Structure=2, Select=1, Replacement=2) # 生成种群迁移算子对象
# 为不同的种群设置不同的重组、变异算子
self.recOpers = []
self.mutOpers = []
Pms = np.linspace(1 / self.problem.Dim, 1, self.PopNum) # 生成变异概率列表，为不同的种群分配不同的变异概率
Pcs = np.linspace(0.7, 1, self.PopNum) # 生成重组概率列表，为不同的种群分配不同的重组概率
for i in range(self.PopNum): # 遍历种群列表
pop = population[i] # 得到当前种群对象
if pop.Encoding == 'P':
recOper = ea.Xovpmx(XOVR=Pcs[i]) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=float(Pms[i])) # 生成逆转变异算子对象
else:
recOper = ea.Xovdp(XOVR=Pcs[i]) # 生成两点交叉算子对象
if pop.Encoding == 'BG':
mutOper = ea.Mutbin(Pm=float(Pms[i])) # 生成二进制变异算子对象
elif pop.Encoding == 'RI':
mutOper = ea.Mutbga(Pm=float(Pms[i]), MutShrink=0.5, Gradient=20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
def __init__(self,
problem,
population,
MAXGEN=None,
MAXTIME=None,
MAXEVALS=None,
MAXSIZE=None,
logTras=None,
verbose=None,
outFunc=None,
drawing=None,
trappedValue=None,
maxTrappedCount=None,
dirName=None,
**kwargs):
# 先调用父类构造方法
super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
MAXSIZE, logTras, verbose, outFunc, drawing,
trappedValue, maxTrappedCount, dirName)
if type(population) != list:
raise RuntimeError('传入的种群对象列表必须为list类型')
self.name = 'multi-SEGA'
self.PopNum = len(population) # 种群数目
self.selFunc = 'tour' # 锦标赛选择算子
self.migFr = 5 # 发生种群迁移的间隔代数
self.migOpers = ea.Migrate(MIGR=0.2,
Structure=2,
Select=1,
Replacement=2) # 生成种群迁移算子对象
# 为不同的种群设置不同的重组、变异算子
self.recOpers = []
self.mutOpers = []
Pms = np.linspace(1 / self.problem.Dim, 1,
self.PopNum) # 生成变异概率列表，为不同的种群分配不同的变异概率
Pcs = np.linspace(0.7, 1, self.PopNum) # 生成重组概率列表，为不同的种群分配不同的重组概率
for i in range(self.PopNum): # 遍历种群列表
pop = population[i] # 得到当前种群对象
if pop.Encoding == 'P':
recOper = ea.Xovpmx(XOVR=Pcs[i]) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=float(Pms[i])) # 生成逆转变异算子对象
else:
recOper = ea.Xovdp(XOVR=Pcs[i]) # 生成两点交叉算子对象
if pop.Encoding == 'BG':
mutOper = ea.Mutbin(Pm=float(Pms[i])) # 生成二进制变异算子对象
elif pop.Encoding == 'RI':
mutOper = ea.Mutbga(Pm=float(Pms[i]),
MutShrink=0.5,
Gradient=20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
def __init__(self, problem, population):
ea.SoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if population.ChromNum != 1:
raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
self.name = 'studGA'
self.selFunc = 'tour' # 锦标赛选择算子
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR = 0.7) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm = 0.5) # 生成逆转变异算子对象
else:
self.recOper = ea.Xovdp(XOVR = 0.7) # 生成两点交叉算子对象
if population.Encoding == 'BG':
self.mutOper = ea.Mutbin(Pm = None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.mutOper = ea.Mutbga(Pm = 1/self.problem.Dim, MutShrink = 0.5, Gradient = 20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
def __init__(self, problem, population):
ea.SoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'Population.Population'>":
raise RuntimeError('传入的种群对象必须为Population类型')
self.name = 'steadyGA'
self.selFunc = 'etour' # 锦标赛选择算子
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR = 1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm = 1) # 生成逆转变异算子对象
else:
self.recOper = ea.Xovdp(XOVR = 1) # 生成两点交叉算子对象
if population.Encoding == 'BG':
self.mutOper = ea.Mutbin(Pm = None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.mutOper = ea.Mutbga(Pm = 1/self.problem.Dim, MutShrink = 0.5, Gradient = 20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
def __init__(self,
problem,
population,
MAXGEN=None,
MAXTIME=None,
MAXEVALS=None,
MAXSIZE=None,
logTras=None,
verbose=None,
outFunc=None,
drawing=None,
trappedValue=None,
maxTrappedCount=None,
dirName=None,
**kwargs):
# 先调用父类构造方法
super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
MAXSIZE, logTras, verbose, outFunc, drawing,
trappedValue, maxTrappedCount, dirName)
if population.ChromNum == 1:
raise RuntimeError('传入的种群对象必须是多染色体的种群类型。')
self.name = 'GGAP-SGA'
self.selFunc = 'rws' # 轮盘赌选择算子
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=0.7) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=0.5) # 生成逆转变异算子对象
else:
recOper = ea.Xovdp(XOVR=0.7) # 生成两点交叉算子对象
if population.Encodings[i] == 'BG':
mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encodings[i] == 'RI':
mutOper = ea.Mutbga(Pm=1 / self.problem.Dim,
MutShrink=0.5,
Gradient=20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
self.GGAP = 0.9 # 代沟，表示使用多少个子代替换父代来形成新一代种群
def __init__(self, problem, population):
ea.SoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'Population.Population'>":
raise RuntimeError('传入的种群对象必须为Population类型')
self.name = 'GGAP-SGA'
self.selFunc = 'rws' # 轮盘赌选择算子
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
else:
self.recOper = ea.Xovdp(XOVR=1) # 生成两点交叉算子对象
if population.Encoding == 'BG':
self.mutOper = ea.Mutbin(Pm=1) # 生成二进制变异算子对象
elif population.Encoding == 'RI':
self.mutOper = ea.Mutbga(Pm=1, MutShrink=0.5,
Gradient=20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.GGAP = 0.9 # 代沟，表示使用多少个子代替换父代来形成新一代种群
def __init__(self,
problem,
population,
MAXGEN=None,
MAXTIME=None,
MAXEVALS=None,
MAXSIZE=None,
logTras=None,
verbose=None,
outFunc=None,
drawing=None,
dirName=None,
**kwargs):
# 先调用父类构造方法
super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
MAXSIZE, logTras, verbose, outFunc, drawing, dirName)
if population.ChromNum == 1:
raise RuntimeError('传入的种群对象必须是多染色体的种群类型。')
self.name = 'psy-NSGA2'
if self.problem.M < 10:
self.ndSort = ea.ndsortESS # 采用ENS_SS进行非支配排序
else:
self.ndSort = ea.ndsortTNS # 高维目标采用T_ENS进行非支配排序，速度一般会比ENS_SS要快
self.selFunc = 'tour' # 选择方式，采用锦标赛选择
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encodings[i] == 'BG':
recOper = ea.Xovud(XOVR=1) # 生成均匀交叉算子对象
mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encodings[i] == 'RI':
recOper = ea.Recsbx(XOVR=1, n=20) # 生成模拟二进制交叉算子对象
mutOper = ea.Mutpolyn(Pm=1 / self.problem.Dim,
DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
def __init__(self,
problem,
population,
MAXGEN=None,
MAXTIME=None,
MAXEVALS=None,
MAXSIZE=None,
logTras=None,
verbose=None,
outFunc=None,
drawing=None,
dirName=None,
**kwargs):
# 先调用父类构造方法
super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
MAXSIZE, logTras, verbose, outFunc, drawing, dirName)
if population.ChromNum == 1:
raise RuntimeError('传入的种群对象必须是多染色体的种群类型。')
self.name = 'psy-RVEA'
self.selFunc = 'urs' # 选择方式，采用无约束随机选择
# 由于有多个染色体，因此需要用多个重组和变异算子
self.recOpers = []
self.mutOpers = []
for i in range(population.ChromNum):
if population.Encodings[i] == 'P':
recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encodings[i] == 'BG':
recOper = ea.Xovud(XOVR=1) # 生成均匀交叉算子对象
mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encodings[i] == 'RI':
recOper = ea.Recsbx(XOVR=1, n=20) # 生成模拟二进制交叉算子对象
mutOper = ea.Mutpolyn(Pm=1 / self.problem.Dim,
DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.recOpers.append(recOper)
self.mutOpers.append(mutOper)
self.a = 2 # RVEA算法中的参数alpha
self.fr = 0.1 # RVEA算法中的参数fr
self.Gamma = None # RVEA算法中的Gamma（详见参考文献的公式10），在每次更新参考点后Gamma要重置为None以便重新计算
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'Population.Population'>":
raise RuntimeError('传入的种群对象必须为Population类型')
self.name = 'RVEA'
self.selFunc = 'urs' # 选择方式，采用无约束随机选择
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR = 1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm = 1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR = 1) # 生成均匀交叉算子对象
self.mutOper = ea.Mutbin(Pm = None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.recOper = ea.Recsbx(XOVR = 1, n = 20) # 生成模拟二进制交叉算子对象
self.mutOper = ea.Mutpolyn(Pm = 1/self.problem.Dim, DisI = 20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
self.a = 2 # RVEA算法中的参数alpha
self.fr = 0.1 # RVEA算法中的参数fr
self.Gamma = None # RVEA算法中的Gamma（详见参考文献的公式10），在每次更新参考点后Gamma要重置为None以便重新计算
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if population.ChromNum != 1:
raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
self.name = 'NSGA2'
if self.problem.M < 10:
self.ndSort = ea.ndsortESS # 采用ENS_SS进行非支配排序
else:
self.ndSort = ea.ndsortTNS # 高维目标采用T_ENS进行非支配排序，速度一般会比ENS_SS要快
self.selFunc = 'tour' # 选择方式，采用锦标赛选择
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR = 1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm = 1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR = 1) # 生成均匀交叉算子对象
self.mutOper = ea.Mutbin(Pm = None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.recOper = ea.Recsbx(XOVR = 1, n = 20) # 生成模拟二进制交叉算子对象
self.mutOper = ea.Mutpolyn(Pm = 1/self.problem.Dim, DisI = 20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'Population.Population'>":
raise RuntimeError('传入的种群对象必须为Population类型')
self.name = 'NSGA2-20p-toZero'
if self.problem.M < 10:
self.ndSort = ea.ndsortESS # 采用ENS_SS进行非支配排序
else:
self.ndSort = ea.ndsortTNS # 高维目标采用T_ENS进行非支配排序，速度一般会比ENS_SS要快
self.selFunc = 'tour' # 选择方式，采用锦标赛选择
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR=1) # 生成均匀交叉算子对象
self.mutOper = ea.Mutbin(Pm=1) # 生成二进制变异算子对象
elif population.Encoding == 'RI':
self.recOper = ea.Recsbx(XOVR=1, n=20) # 生成模拟二进制交叉算子对象
self.mutOper = ea.Mutpolyn(Pm=1, DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
def __init__(self,
problem,
population,
MAXGEN=None,
MAXTIME=None,
MAXEVALS=None,
MAXSIZE=None,
logTras=None,
verbose=None,
outFunc=None,
drawing=None,
dirName=None,
**kwargs):
# 先调用父类构造方法
super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
MAXSIZE, logTras, verbose, outFunc, drawing, dirName)
if population.ChromNum != 1:
raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
self.name = 'MOEA/D-archive'
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR=1, Half_N=True) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR=1, Half_N=True) # 生成均匀交叉算子对象
self.mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.recOper = ea.Recsbx(XOVR=1, n=20,
Half_N=True) # 生成模拟二进制交叉算子对象
self.mutOper = ea.Mutpolyn(Pm=1 / self.problem.Dim,
DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.neighborSize = None # 邻域大小，当设置为None时，将会自动设置为等于种群规模
if self.problem.M <= 2:
self.decomposition = ea.tcheby # 采用切比雪夫权重聚合法
else:
self.decomposition = ea.pbi # 采用pbi权重聚合法
self.Ps = 0.9 # (Probability of Selection)表示进化时有多大的概率只从邻域中选择个体参与进化
self.MAXSIZE = None # 全局非支配解存档的大小限制，这里设为None，表示后面将默认设为10倍的种群个体数
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if str(type(population)) != "<class 'Population.Population'>":
raise RuntimeError('传入的种群对象必须为Population类型')
self.name = 'NSGA2-archive'
if self.problem.M < 10:
self.ndSort = ea.ndsortESS # 采用ENS_SS进行非支配排序
else:
self.ndSort = ea.ndsortTNS # 高维目标采用T_ENS进行非支配排序，速度一般会比ENS_SS要快
self.selFunc = 'tour' # 选择方式，采用锦标赛选择
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR = 1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm = 1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR = 1) # 生成均匀交叉算子对象
self.mutOper = ea.Mutbin(Pm = None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.recOper = ea.Recsbx(XOVR = 1, n = 20) # 生成模拟二进制交叉算子对象
self.mutOper = ea.Mutpolyn(Pm = 1/self.problem.Dim, DisI = 20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为''BG''、''RI''或''P''.')
self.MAXSIZE = 10 * population.sizes # 全局非支配解存档的大小限制，默认为10倍的种群个体数
def __init__(self, problem, population):
ea.MoeaAlgorithm.__init__(self, problem, population) # 先调用父类构造方法
if population.ChromNum != 1:
raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
self.name = 'RVEA-RES'
self.ndSort = ea.ndsortESS # 设置非支配排序算子
self.selFunc = 'urs' # 选择方式，采用无约束随机选择
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR=1) # 生成均匀交叉算子对象
self.mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.recOper = ea.Recsbx(XOVR=1, n=20) # 生成模拟二进制交叉算子对象
self.mutOper = ea.Mutpolyn(Pm=1 / self.problem.Dim,
DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.a = 2 # RVEA算法中的参数alpha
self.fr = 0.1 # RVEA算法中的参数fr
def __init__(self,
problem,
population,
MAXGEN=None,
MAXTIME=None,
MAXEVALS=None,
MAXSIZE=None,
logTras=None,
verbose=None,
outFunc=None,
drawing=None,
trappedValue=None,
maxTrappedCount=None,
dirName=None,
**kwargs):
# 先调用父类构造方法
super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
MAXSIZE, logTras, verbose, outFunc, drawing,
trappedValue, maxTrappedCount, dirName)
if population.ChromNum != 1:
raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
self.name = 'studGA'
self.selFunc = 'tour' # 锦标赛选择算子
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR=0.7) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm=0.5) # 生成逆转变异算子对象
else:
self.recOper = ea.Xovdp(XOVR=0.7) # 生成两点交叉算子对象
if population.Encoding == 'BG':
self.mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.mutOper = ea.Mutbga(Pm=1 / self.problem.Dim,
MutShrink=0.5,
Gradient=20) # 生成breeder GA变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
def __init__(self,
problem,
population,
MAXGEN=None,
MAXTIME=None,
MAXEVALS=None,
MAXSIZE=None,
logTras=None,
verbose=None,
outFunc=None,
drawing=None,
dirName=None,
**kwargs):
# 先调用父类构造方法
super().__init__(problem, population, MAXGEN, MAXTIME, MAXEVALS,
MAXSIZE, logTras, verbose, outFunc, drawing, dirName)
if population.ChromNum != 1:
raise RuntimeError('传入的种群对象必须是单染色体的种群类型。')
self.name = 'RVEA-RES'
self.ndSort = ea.ndsortESS # 设置非支配排序算子
self.selFunc = 'urs' # 选择方式，采用无约束随机选择
if population.Encoding == 'P':
self.recOper = ea.Xovpmx(XOVR=1) # 生成部分匹配交叉算子对象
self.mutOper = ea.Mutinv(Pm=1) # 生成逆转变异算子对象
elif population.Encoding == 'BG':
self.recOper = ea.Xovud(XOVR=1) # 生成均匀交叉算子对象
self.mutOper = ea.Mutbin(
Pm=None) # 生成二进制变异算子对象，Pm设置为None时，具体数值取变异算子中Pm的默认值
elif population.Encoding == 'RI':
self.recOper = ea.Recsbx(XOVR=1, n=20) # 生成模拟二进制交叉算子对象
self.mutOper = ea.Mutpolyn(Pm=1 / self.problem.Dim,
DisI=20) # 生成多项式变异算子对象
else:
raise RuntimeError('编码方式必须为' 'BG' '、' 'RI' '或' 'P' '.')
self.a = 2 # RVEA算法中的参数alpha
self.fr = 0.1 # RVEA算法中的参数fr