def finishing(self, population):
"""
进化完成后调用的函数
"""
# 得到非支配种群
[levels,
criLevel] = ea.ndsortDED(self.problem.maxormins * population.ObjV,
None, 1, population.CV) # 非支配分层
NDSet = population[np.where(levels == 1)[0]] # 只保留种群中的非支配个体，形成一个非支配种群
if NDSet.CV is not None: # CV不为None说明有设置约束条件
NDSet = NDSet[np.where(np.all(NDSet.CV <= 0, 1))[0]] # 最后要彻底排除非可行解
self.passTime += time.time() - self.timeSlot # 更新用时记录
# 绘图
if self.drawing != 0:
if NDSet.ObjV.shape[1] == 2 or NDSet.ObjV.shape[1] == 3:
ea.moeaplot(NDSet.ObjV,
'Pareto Front',
saveFlag=True,
gridFlag=True)
else:
ea.moeaplot(NDSet.ObjV,
'Value Path',
saveFlag=True,
gridFlag=False)
# 返回帕累托最优集
return NDSet
def run(self, prophetPop = None): # prophetPop为先知种群（即包含先验知识的种群）
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom() # 初始化种群染色体矩阵（内含解码，详见PsyPopulation类的源码）
self.problem.aimFunc(population) # 计算种群的目标函数值
self.evalsNum = population.sizes # 记录评价次数
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
[levels, criLevel] = self.ndSort(self.problem.maxormins * population.ObjV, NIND, None, population.CV) # 对NIND个个体进行非支配分层
population.FitnV[:, 0] = 1 / levels # 直接根据levels来计算初代个体的适应度
globalNDSet = population[np.where(levels == 1)[0]] # 创建全局存档，该全局存档贯穿进化始终，随着进化不断更新
globalNDSet = globalNDSet[np.where(np.all(globalNDSet.CV <= 0, 1))[0]] # 排除非可行解
#===========================开始进化============================
while self.terminated(population) == False:
# 选择个体参与进化
offspring = population[ea.selecting(self.selFunc, population.FitnV, NIND)]
# 进行进化操作，分别对各个种群染色体矩阵进行重组和变异
for i in range(population.ChromNum):
offspring.Chroms[i] = self.recOpers[i].do(offspring.Chroms[i]) # 重组
offspring.Chroms[i] = self.mutOpers[i].do(offspring.Encodings[i], offspring.Chroms[i], offspring.Fields[i]) # 变异
offspring.Phen = offspring.decoding() # 解码
self.problem.aimFunc(offspring) # 求进化后个体的目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 重插入生成新一代种群，同时更新全局存档
population, globalNDSet = self.reinsertion(population, offspring, NIND, globalNDSet)
self.passTime += time.time() - self.timeSlot # 更新用时记录
#=========================绘图及输出结果=========================
if self.drawing != 0:
ea.moeaplot(globalNDSet.ObjV, 'Pareto Front', True)
# 返回帕累托最优集
return globalNDSet
def run(self):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
if population.Chrom is None:
population.initChrom() # 初始化种群染色体矩阵（内含解码，详见Population类的源码）
else:
population.Phen = population.decoding() # 染色体解码
self.problem.aimFunc(population) # 计算种群的目标函数值
self.evalsNum = population.sizes # 记录评价次数
[levels, criLevel] = self.ndSort(self.problem.maxormins * population.ObjV, NIND, None, population.CV) # 对NIND个个体进行非支配分层
population.FitnV[:, 0] = 1 / levels # 直接根据levels来计算初代个体的适应度
globalNDSet = population[np.where(levels == 1)[0]] # 创建全局存档，该全局存档贯穿进化始终，随着进化不断更新
globalNDSet = globalNDSet[np.where(np.all(globalNDSet.CV <= 0, 1))[0]] # 排除非可行解
#===========================开始进化============================
while self.terminated(population) == False:
# 选择个体参与进化
offspring = population[ea.selecting(self.selFunc, population.FitnV, NIND)]
# 对选出的个体进行进化操作
offspring.Chrom = self.recOper.do(offspring.Chrom) # 重组
offspring.Chrom = self.mutOper.do(offspring.Encoding, offspring.Chrom, offspring.Field) # 变异
offspring.Phen = offspring.decoding() # 解码
self.problem.aimFunc(offspring) # 求进化后个体的目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 重插入生成新一代种群，同时更新全局存档
population, globalNDSet = self.reinsertion(population, offspring, NIND, globalNDSet)
self.passTime += time.time() - self.timeSlot # 更新用时记录
#=========================绘图及输出结果=========================
if self.drawing != 0:
ea.moeaplot(globalNDSet.ObjV, 'Pareto Front', True)
# 返回帕累托最优集
return globalNDSet
def run(self, prophetPop = None): # prophetPop为先知种群（即包含先验知识的种群）
#==========================初始化配置===========================
population = self.population
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
uniformPoint, NIND = ea.crtup(self.problem.M, population.sizes) # 生成在单位目标维度上均匀分布的参考点集
population.initChrom(NIND) # 初始化种群染色体矩阵，此时种群规模将调整为uniformPoint点集的大小，initChrom函数会把种群规模给重置
self.call_aimFunc(population) # 计算种群的目标函数值
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
# 确定邻域大小
if self.neighborSize is None:
self.neighborSize = population.sizes
self.neighborSize = max(self.neighborSize, 2) # 确保不小于2
# 生成由所有邻居索引组成的矩阵
neighborIdx = np.argsort(cdist(uniformPoint, uniformPoint), axis=1, kind='mergesort')[:, :self.neighborSize]
# 计算理想点
idealPoint = ea.crtidp(population.ObjV, population.CV, self.problem.maxormins)
# 创建全局存档
if self.MAXSIZE is None:
self.MAXSIZE = 10 * population.sizes # 默认为10倍的种群个体数
[levels, criLevel] = ea.ndsortDED(population.ObjV, NIND, None, population.CV, self.problem.maxormins) # 对NIND个个体进行非支配分层
globalNDSet = population[np.where(levels == 1)[0]] # 创建全局存档，该全局存档贯穿进化始终，随着进化不断更新
if globalNDSet.CV is not None: # CV不为None说明有设置约束条件
globalNDSet = globalNDSet[np.where(np.all(globalNDSet.CV <= 0, 1))[0]] # 排除非可行解
#===========================开始进化============================
while self.terminated(population) == False:
select_rands = np.random.rand(population.sizes) # 生成一组随机数
for i in range(population.sizes):
indices = neighborIdx[i, :] # 得到邻居索引
if select_rands[i] < self.Ps:
chooseIdx = indices[ea.rps(self.neighborSize, 2)] # 只从邻域中选择
else:
chooseIdx = ea.rps(population.sizes, 2)
matting_Chrom = population.Chrom[chooseIdx, :] # 选出2条来自被选个体的染色体
offspring = ea.Population(population.Encoding, population.Field, 1) # 实例化一个种群对象用于存储进化的后代（这里只进化生成一个后代）
# 对选出的个体进行进化操作
offspring.Chrom = self.recOper.do(matting_Chrom) # 重组
offspring.Chrom = self.mutOper.do(offspring.Encoding, offspring.Chrom, offspring.Field) # 变异
self.call_aimFunc(offspring) # 求进化后个体的目标函数值
# 更新理想点
idealPoint = ea.crtidp(offspring.ObjV, offspring.CV, self.problem.maxormins, idealPoint)
# 重插入更新种群个体
self.reinsertion(indices, population, offspring, idealPoint, uniformPoint)
# 完成当代的进化后，更新全局存档
globalNDSet = population + globalNDSet # 将population与全局归档集合并
[levels, criLevel] = ea.ndsortDED(globalNDSet.ObjV, None, None, globalNDSet.CV, self.problem.maxormins) # 非支配排序
globalNDSet = globalNDSet[np.where(levels == 1)[0]]
if globalNDSet.CV is not None: # CV不为None说明有设置约束条件
globalNDSet = globalNDSet[np.where(np.all(globalNDSet.CV <= 0, 1))[0]] # 排除非可行解
if globalNDSet.sizes > self.MAXSIZE:
globalNDSet = globalNDSet[ea.rps(globalNDSet.sizes, self.MAXSIZE)] # 采用rps随机排列选择，控制全局存档的大小
self.passTime += time.time() - self.timeSlot # 更新用时记录
#=========================绘图及输出结果=========================
if self.drawing != 0:
ea.moeaplot(globalNDSet.ObjV, 'Pareto Front', saveFlag = True, gridFlag = True)
# 返回帕累托最优集
return globalNDSet
def run(self):
#==========================初始化配置===========================
problem = self.problem
population = self.population
NIND = population.sizes
MAXSIZE = self.MAXSIZE
if MAXSIZE is None: # 检查MAXSIZE，默认取2倍的种群规模
MAXSIZE = 2 * NIND
aimFuc = problem.aimFuc # 获取目标函数地址
#===========================准备进化============================
self.timeSlot = time.time() # 开始计时
if population.Chrom is None:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含解码，详见Population类的源码）
population.ObjV, population.CV = aimFuc(population.Phen,
population.CV) # 计算种群的目标函数值
population.FitnV, NDSet = updateNDSet(population, problem.maxormins,
MAXSIZE) # 计算适应度和得到全局非支配种群
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
self.currentGen = 0
while self.terminated(NDSet, population) == False:
uniChrom = np.unique(NDSet.Chrom, axis=0)
repRate = 1 - uniChrom.shape[0] / NDSet.sizes # 计算NDSet中的重复率
# 选择基个体去进化形成子代
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND)]
# 对育种种群进行进化操作
offspring.Chrom = ea.recombin(self.recFunc, offspring.Chrom,
self.pc) #重组
offspring.Chrom = ea.mutate(self.mutFunc, offspring.Encoding,
offspring.Chrom, offspring.Field,
self.pm) # 变异
if population.Encoding != 'B' and population.Encoding != 'G' and repRate > 0.1:
offspring.Chrom = ea.mutate('mutgau', offspring.Encoding,
offspring.Chrom, offspring.Field,
self.pm, False,
3) # 高斯变异，对标准差放大3倍。
offspring.Phen = offspring.decoding() # 染色体解码
offspring.ObjV, offspring.CV = aimFuc(offspring.Phen,
offspring.CV) # 求进化后个体的目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 父代种群和育种种群合并
population = population + offspring
population.FitnV, NDSet = updateNDSet(population,
problem.maxormins, MAXSIZE,
NDSet) # 计算合并种群的适应度及更新NDSet
# 保留个体到下一代
population = population[ea.selecting('dup', population.FitnV,
NIND)] # 选择，保留NIND个个体
NDSet = NDSet[np.where(np.all(NDSet.CV <= 0, 1))[0]] # 最后要彻底排除非可行解
self.passTime += time.time() - self.timeSlot # 更新用时记录
#=========================绘图及输出结果=========================
if self.drawing != 0:
ea.moeaplot(NDSet.ObjV, True)
# 返回帕累托最优集以及执行时间
return NDSet
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
#==========================初始化配置===========================
problem = self.problem
population = self.population
NIND = population.sizes
MAXSIZE = self.MAXSIZE
if MAXSIZE is None: # 检查MAXSIZE，默认取2倍的种群规模
MAXSIZE = 2 * NIND
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
if population.Chrom is None:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含解码，详见Population类的源码）
else:
population.Phen = population.decoding() # 染色体解码
self.problem.aimFunc(population) # 计算种群的目标函数值
NDSet = updateNDSet(population, problem.maxormins,
MAXSIZE) # 计算适应度和得到全局非支配种群
self.evalsNum = population.sizes # 记录评价次数
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
#===========================开始进化============================
while self.terminated(population) == False:
uniChrom = np.unique(NDSet.Chrom, axis=0)
repRate = 1 - uniChrom.shape[0] / NDSet.sizes # 计算NDSet中的重复率
# 选择个体去进化形成子代
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND)]
offspring.Chrom = self.recOper.do(offspring.Chrom) # 重组
offspring.Chrom = self.mutOper.do(offspring.Encoding,
offspring.Chrom,
offspring.Field) # 变异
if population.Encoding == 'RI' and repRate > 0.1:
offspring.Chrom = self.extraMutOper.do(
offspring.Encoding, offspring.Chrom,
offspring.Field) # 执行额外的变异
offspring.Phen = offspring.decoding() # 染色体解码
self.problem.aimFunc(offspring) # 求进化后个体的目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 父代种群和育种种群合并
population = population + offspring
NDSet = updateNDSet(population, problem.maxormins, MAXSIZE,
NDSet) # 计算合并种群的适应度及更新NDSet
# 保留个体到下一代
population = population[ea.selecting('dup', population.FitnV,
NIND)] # 选择，保留NIND个个体
NDSet = NDSet[np.where(np.all(NDSet.CV <= 0, 1))[0]] # 最后要彻底排除非可行解
self.passTime += time.time() - self.timeSlot # 更新用时记录
#=========================绘图及输出结果=========================
if self.drawing != 0:
ea.moeaplot(NDSet.ObjV,
Label='Pareto Front',
saveFlag=True,
gridFlag=True)
# 返回帕累托最优集
return NDSet
def run(self):
#==========================初始化配置===========================
problem = self.problem
population = self.population
NIND = population.sizes
MAXSIZE = self.MAXSIZE
if MAXSIZE is None: # 检查MAXSIZE，默认取2倍的种群规模
MAXSIZE = 2 * NIND
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵（内含解码，详见Population类的源码）
self.problem.aimFunc(population) # 计算种群的目标函数值
NDSet = updateNDSet(population, problem.maxormins,
MAXSIZE) # 计算适应度和得到全局非支配种群
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
while self.terminated(population) == False:
# 选择个体去进化形成子代
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND)]
# 进行进化操作，分别对各个种群染色体矩阵进行重组和变异
for i in range(population.ChromNum):
uniChrom = np.unique(NDSet.Chroms[i], axis=0)
repRate = 1 - uniChrom.shape[0] / NDSet.sizes # 计算NDSet中的重复率
offspring.Chroms[i] = ea.recombin(self.recFuncs[i],
offspring.Chroms[i],
self.pcs[i]) #重组
offspring.Chroms[i] = ea.mutate(self.mutFuncs[i],
offspring.Encodings[i],
offspring.Chroms[i],
offspring.Fields[i],
self.pms[i]) # 变异
if population.Encodings[i] == 'RI' and repRate > 0.1:
offspring.Chroms[i] = ea.mutate('mutgau',
offspring.Encodings[i],
offspring.Chroms[i],
offspring.Fields[i],
self.pms[i], False,
3) # 高斯变异，对标准差放大3倍。
offspring.Phen = offspring.decoding() # 染色体解码
self.problem.aimFunc(offspring) # 求进化后个体的目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 父代种群和育种种群合并
population = population + offspring
NDSet = updateNDSet(population, problem.maxormins, MAXSIZE,
NDSet) # 计算合并种群的适应度及更新NDSet
# 保留个体到下一代
population = population[ea.selecting('dup', population.FitnV,
NIND)] # 选择，保留NIND个个体
NDSet = NDSet[np.where(np.all(NDSet.CV <= 0, 1))[0]] # 最后要彻底排除非可行解
self.passTime += time.time() - self.timeSlot # 更新用时记录
#=========================绘图及输出结果=========================
if self.drawing != 0:
ea.moeaplot(NDSet.ObjV, 'Pareto Front', True)
# 返回帕累托最优集
return NDSet
def run(self):
#==========================初始化配置===========================
self.ax = None # 存储上一桢动画
population = self.population
NIND = population.sizes
#===========================准备进化============================
self.timeSlot = time.time() # 开始计时
if population.Chrom is None:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含解码，详见Population类的源码）
population.ObjV, population.CV = self.problem.aimFuc(
population.Phen, population.CV) # 计算种群的目标函数值
#传入的参数是Phen，也就是表现型矩阵值和约束矩阵(可行性矩阵)
self.evalsNum = population.sizes # 记录评价次数
population.FitnV = self.calFitnV(population, NIND) # 计算适应度
#===========================开始进化============================
self.currentGen = 0
while self.terminated(population) == False:
# 选择基个体
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND)]
# 对基个体进行进化操作
offspring.Chrom = ea.recombin(self.recFunc, offspring.Chrom,
self.pc) #重组
offspring.Chrom = ea.mutate(self.mutFunc, offspring.Encoding,
offspring.Chrom, offspring.Field,
self.pm) # 变异
offspring.Phen = offspring.decoding() # 解码
offspring.ObjV, offspring.CV = self.problem.aimFuc(
offspring.Phen, offspring.CV) # 求进化后个体的目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 合并
population = population + offspring
# 计算合并种群的适应度
population.FitnV = self.calFitnV(population, NIND)
# 选择个体保留到下一次进化
population = population[ea.selecting(
'dup', population.FitnV,
NIND)] # 调用低级选择算子dup进行基于适应度排序的选择，保留NIND个个体
# 得到非支配种群，新的父代产生
[levels,
criLevel] = self.ndSort(self.problem.maxormins * population.ObjV,
NIND, 1, population.CV) # 非支配分层
#划分一层，提取出rank0
NDSet = population[np.where(levels == 1)[0]] # 只保留种群中的非支配个体，形成一个非支配种群
NDSet = NDSet[np.where(np.all(NDSet.CV <= 0, 1))[0]] # 最后要彻底排除非可行解
self.passTime += time.time() - self.timeSlot # 更新用时记录
#=========================绘图及输出结果=========================
if self.drawing != 0:
ea.moeaplot(NDSet.ObjV, True)
# 返回帕累托最优集
return NDSet
def run(self):
#==========================初始化配置===========================
population = self.population
self.timeSlot = time.time() # 开始计时
uniformPoint, NIND = ea.crtup(self.problem.M,
population.sizes) # 生成在单位目标维度上均匀分布的参考点集
if population.Chrom is None or population.sizes != NIND:
population.initChrom(
NIND
) # 初始化种群染色体矩阵（内含解码，详见Population类的源码），此时种群规模将调整为uniformPoint点集的大小，initChrom函数会把种群规模给重置
population.ObjV, population.CV = self.problem.aimFuc(
population.Phen, population.CV) # 计算种群的目标函数值
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
self.currentGen = 0
while self.terminated(population) == False:
population.shuffle() # 打乱个体顺序
# 进行差分进化操作
mutPop = population.copy()
mutPop.Chrom = ea.mutate(self.mutFunc, mutPop.Encoding,
mutPop.Chrom, mutPop.Field, self.F,
1) # 差分变异
tempPop = population + mutPop # 当代种群个体与变异个体进行合并（为的是后面用于重组）
experimentPop = population.copy() # 试验种群
experimentPop.Chrom = ea.recombin(self.recFunc, tempPop.Chrom,
self.pc, True) # 重组
# 求进化后个体的目标函数值
experimentPop.Phen = experimentPop.decoding() # 染色体解码
experimentPop.ObjV, experimentPop.CV = self.problem.aimFuc(
experimentPop.Phen, experimentPop.CV)
self.evalsNum += experimentPop.sizes # 更新评价次数
# 合并
population = population + experimentPop
population.FitnV = self.calFitnV(population, NIND,
uniformPoint) # 计算合并种群的适应度
population = population[ea.selecting('dup', population.FitnV,
NIND)] # 选择操作，保留NIND个个体
# 得到非支配种群
[levels,
criLevel] = self.ndSort(self.problem.maxormins * population.ObjV,
NIND, 1, population.CV) # 非支配分层
NDSet = population[np.where(levels == 1)[0]] # 只保留种群中的非支配个体，形成一个非支配种群
NDSet = NDSet[np.where(np.all(NDSet.CV <= 0, 1))[0]] # 最后要彻底排除非可行解
self.passTime += time.time() - self.timeSlot # 更新用时记录
# 绘图
if self.drawing != 0:
ea.moeaplot(NDSet.ObjV, True)
# 返回帕累托最优集
return NDSet
def draw(self, pop, EndFlag=False):
"""
描述:
该函数用于在进化过程中进行绘图。该函数在stat()以及finishing函数里面被调用。
输入参数:
pop : class <Population> - 种群对象。
EndFlag : bool - 表示是否是最后一次调用该函数。
输出参数:
无输出参数。
"""
if not EndFlag:
self.passTime += time.time() - self.timeSlot # 更新用时记录，不计算画图的耗时
# 绘制动画
if self.drawing == 2:
# 绘制目标空间动态图
self.ax = ea.moeaplot(pop.ObjV,
'objective values',
False,
self.ax,
self.currentGen,
gridFlag=True)
elif self.drawing == 3:
# 绘制决策空间动态图
self.ax = ea.varplot(pop.Phen,
'decision variables',
False,
self.ax,
self.currentGen,
gridFlag=False)
self.timeSlot = time.time() # 更新时间戳
else:
# 绘制最终结果图
if self.drawing != 0:
if pop.ObjV.shape[1] == 2 or pop.ObjV.shape[1] == 3:
ea.moeaplot(pop.ObjV,
'Pareto Front',
saveFlag=True,
gridFlag=True)
else:
ea.moeaplot(pop.ObjV,
'Value Path',
saveFlag=True,
gridFlag=False)
def run(self):
#==========================初始化配置===========================
population = self.population
self.timeSlot = time.time() # 开始计时
uniformPoint, NIND = ea.crtup(self.problem.M,
population.sizes) # 生成在单位目标维度上均匀分布的参考点集
if population.Chrom is None or population.sizes != NIND:
population.initChrom(
NIND
) # 初始化种群染色体矩阵（内含解码，详见Population类的源码），此时种群规模将调整为uniformPoint点集的大小，initChrom函数会把种群规模给重置
population.ObjV, population.CV = self.problem.aimFuc(
population.Phen, population.CV) # 计算种群的目标函数值
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
self.currentGen = 0
while self.terminated(population) == False:
# 选择个体参与进化
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND)]
# 对基个体进行进化操作
offspring.Chrom = ea.recombin(self.recFunc, offspring.Chrom,
self.pc) #重组
offspring.Chrom = ea.mutate(self.mutFunc, offspring.Encoding,
offspring.Chrom, offspring.Field,
self.pm) # 变异
offspring.Phen = offspring.decoding() # 解码
offspring.ObjV, offspring.CV = self.problem.aimFuc(
offspring.Phen, offspring.CV) # 求进化后个体的目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 合并
population = population + offspring
population.FitnV = self.calFitnV(population, NIND,
uniformPoint) # 计算合并种群的适应度
population = population[ea.selecting('dup', population.FitnV,
NIND)] # 选择操作，保留NIND个个体
# 得到非支配种群
[levels,
criLevel] = self.ndSort(self.problem.maxormins * population.ObjV,
NIND, 1, population.CV) # 非支配分层
NDSet = population[np.where(levels == 1)[0]] # 只保留种群中的非支配个体，形成一个非支配种群
NDSet = NDSet[np.where(np.all(NDSet.CV <= 0, 1))[0]] # 最后要彻底排除非可行解
self.passTime += time.time() - self.timeSlot # 更新用时记录
# 绘图
if self.drawing != 0:
ea.moeaplot(NDSet.ObjV, True)
# 返回帕累托最优集
return NDSet
def stat(self, population): # 分析记录，更新进化记录器，population为传入的种群对象
feasible = np.where(
np.all(population.CV <= 0,
1))[0] if population.CV is not None else np.array(
range(population.sizes)) # 找到可行解个体的下标
if len(feasible) > 0:
tempPop = population[feasible] # 获取可行解个体
self.pop_trace.append(tempPop) # 添加记录（只添加可行解个体到种群记录器中）
self.forgetCount = 0 # “遗忘策略”计数器清零
self.passTime += time.time() - self.timeSlot # 更新用时记录
if self.drawing == 2:
# 绘制目标空间动态图
self.ax = ea.moeaplot(tempPop.ObjV,
'objective values',
False,
self.ax,
self.currentGen,
gridFlag=True)
elif self.drawing == 3:
# 绘制决策空间动态图
self.ax = ea.varplot(tempPop.Phen,
'decision variables',
False,
self.ax,
self.currentGen,
gridFlag=False)
self.timeSlot = time.time() # 更新时间戳
else:
self.currentGen -= 1 # 忽略这一代
self.forgetCount += 1 # “遗忘策略”计数器加1
def stat(
self,
population): # 分析记录，更新进化记录器，population为传入的种群对象，NDSet为当代的种群中的非支配个体集
feasible = np.where(np.all(population.CV <= 0, 1))[0] # 找到可行解个体的下标
if len(feasible) > 0:
self.pop_trace.append(population) # 添加记录
self.forgetCount = 0 # “遗忘策略”计数器清零
self.passTime += time.time() - self.timeSlot # 更新用时记录
if self.drawing == 2:
# 绘制目标空间动态图
self.ax = ea.moeaplot(population.ObjV,
'objective values',
False,
self.ax,
self.currentGen,
gridFlag=True)
elif self.drawing == 3:
# 绘制决策空间动态图
self.ax = ea.varplot(population.Phen,
'decision variables',
False,
self.ax,
self.currentGen,
gridFlag=False)
self.timeSlot = time.time() # 更新时间戳
else:
self.currentGen -= 1 # 忽略这一代
self.forgetCount += 1 # “遗忘策略”计数器加1
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
if population.Chrom is None:
population.initChrom() # 初始化种群染色体矩阵
self.call_aimFunc(population) # 计算种群的目标函数值
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
[levels,
criLevel] = self.ndSort(self.problem.maxormins * population.ObjV,
NIND, None, population.CV) # 对NIND个个体进行非支配分层
population.FitnV[:, 0] = 1 / levels # 直接根据levels来计算初代个体的适应度
globalNDSet = population[np.where(
levels == 1)[0]] # 创建全局存档，该全局存档贯穿进化始终，随着进化不断更新
if globalNDSet.CV is not None: # CV不为None说明有设置约束条件
globalNDSet = globalNDSet[np.where(np.all(globalNDSet.CV <= 0,
1))[0]] # 排除非可行解
#===========================开始进化============================
while self.terminated(population) == False:
# 选择个体参与进化
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND)]
# 对选出的个体进行进化操作
offspring.Chrom = self.recOper.do(offspring.Chrom) # 重组
offspring.Chrom = self.mutOper.do(offspring.Encoding,
offspring.Chrom,
offspring.Field) # 变异
self.call_aimFunc(offspring) # 求进化后个体的目标函数值
population, globalNDSet = self.reinsertion(
population, offspring, NIND,
globalNDSet) # 重插入生成新一代种群，同时更新全局存档
self.passTime += time.time() - self.timeSlot # 更新用时记录
#=========================绘图及输出结果=========================
if self.drawing != 0:
ea.moeaplot(globalNDSet.ObjV,
'Pareto Front',
saveFlag=True,
gridFlag=True)
# 返回帕累托最优集
return globalNDSet
def terminated(self, NDSet, population): # 判断是终止进化
if self.currentGen < self.MAXGEN or NDSet.sizes > self.MAXSIZE:
self.passTime += time.time() - self.timeSlot # 更新用时记录
if self.drawing == 2:
self.ax = ea.moeaplot(population.ObjV, False, self.ax,
self.currentGen) # 绘制动态图
self.timeSlot = time.time() # 更新时间戳
self.currentGen += 1 # 进化代数+1
return False
else:
return True
def terminated(self, population): # 判断是否终止进化
if self.currentGen < self.MAXGEN:
self.passTime += time.time() - self.timeSlot # 更新用时记录
if self.drawing == 2:
self.ax = ea.moeaplot(
population.ObjV, False, self.ax,
self.currentGen) # 绘制动态图 False表示不保存图片 self.ax不为None是可以实现
#动态绘制
self.timeSlot = time.time() # 更新时间戳
self.currentGen += 1 # 进化代数+1
return False
else:
return True
