def run(self):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
if NIND < 2:
raise RuntimeError('error: Population'' size is too small. (种群规模不能小于2。)')
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵（内含染色体解码，详见PsyPopulation类的源码）
self.problem.aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
while self.terminated(population) == False:
# 选择
chooseIdx = ea.selecting(self.selFunc, population.FitnV, 2)
offspring = population[chooseIdx]
# 进行进化操作，分别对各种编码的染色体进行重组和变异
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 # 更新评价次数
tempPop = population + offspring # 父子合并
tempPop.FitnV = ea.scaling(self.problem.maxormins * tempPop.ObjV, tempPop.CV) # 计算适应度
# 得到新一代种群
tempPop = tempPop[ea.selecting('otos', tempPop.FitnV, 2)] # 采用One-to-One Survivor选择
population[chooseIdx] = tempPop
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
# ==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法类的一些动态参数
# ===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
self.call_aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
# ===========================开始进化============================
while not self.terminated(population):
# 进行差分进化操作
r0 = ea.selecting(self.selFunc, population.FitnV, NIND) # 得到基向量索引
experimentPop = ea.Population(population.Encoding,
population.Field, NIND) # 存储试验个体
experimentPop.Chrom = self.mutOper.do(population.Encoding,
population.Chrom,
population.Field, [r0]) # 变异
experimentPop.Chrom = self.recOper.do(
np.vstack([population.Chrom, experimentPop.Chrom])) # 重组
self.call_aimFunc(experimentPop) # 计算目标函数值
tempPop = population + experimentPop # 临时合并，以调用otos进行一对一生存者选择
tempPop.FitnV = ea.scaling(tempPop.ObjV, tempPop.CV,
self.problem.maxormins) # 计算适应度
population = tempPop[ea.selecting(
'otos', tempPop.FitnV,
NIND)] # 采用One-to-One Survivor选择，产生新一代种群
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
if population.Chrom is None:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含染色体解码，详见Population类的源码）
self.problem.aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
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() # 染色体解码
self.problem.aimFunc(offspring) # 计算目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
population = population + offspring # 父子合并
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
# 得到新一代种群
population = population[ea.selecting(self.selFunc, population.FitnV, NIND)]
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵
self.call_aimFunc(population) # 计算种群的目标函数值
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
#===========================开始进化============================
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 = population + offspring # 父子合并
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
# 得到新一代种群
population = population[ea.selecting(
'dup', population.FitnV, NIND)] # 采用基于适应度排序的直接复制选择生成新一代种群
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop = None): # prophetPop为先知种群（即包含先验知识的种群）
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
if population.Chrom is None:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含染色体解码，详见Population类的源码）
else:
population.Phen = population.decoding() # 染色体解码
self.problem.aimFunc(population) # 计算种群的目标函数值
self.evalsNum = population.sizes # 记录评价次数
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
#===========================开始进化============================
while self.terminated(population) == False:
# 进行差分进化操作
r0 = ea.selecting('ecs', population.FitnV, NIND)
Xr0 = population.Chrom + self.k * (population.Chrom[r0, :] - population.Chrom) # 根据target-to-best的方法得到基向量矩阵
experimentPop = population.copy() # 存储试验个体
experimentPop.Chrom = self.mutOper.do(experimentPop.Encoding, experimentPop.Chrom, experimentPop.Field, [Xr0]) # 变异
tempPop = population + experimentPop # 当代种群个体与变异个体进行合并（为的是后面用于重组）
experimentPop.Chrom = self.recOper.do(tempPop.Chrom) # 重组
# 求进化后个体的目标函数值
experimentPop.Phen = experimentPop.decoding() # 染色体解码
self.problem.aimFunc(experimentPop) # 计算目标函数值
self.evalsNum += experimentPop.sizes # 更新评价次数
tempPop = population + experimentPop # 临时合并，以调用otos进行一对一生存者选择
tempPop.FitnV = ea.scaling(self.problem.maxormins * tempPop.ObjV, tempPop.CV) # 计算适应度
population = tempPop[ea.selecting('otos', tempPop.FitnV, NIND)] # 采用One-to-One Survivor选择，产生新一代种群
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop = None): # prophetPop为先知种群（即包含先验知识的种群）
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
if NIND < 2:
raise RuntimeError('error: Population'' size is too small. (种群规模不能小于2。)')
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵
self.call_aimFunc(population) # 计算种群的目标函数值
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
#===========================开始进化============================
while self.terminated(population) == False:
# 选择
chooseIdx = ea.selecting(self.selFunc, population.FitnV, 2)
offspring = population[chooseIdx]
# 进行进化操作，分别对各种编码的染色体进行重组和变异
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]) # 变异
self.call_aimFunc(offspring) # 计算目标函数值
tempPop = population + offspring # 父子合并
tempPop.FitnV = ea.scaling(self.problem.maxormins * tempPop.ObjV, tempPop.CV) # 计算适应度
# 得到新一代种群
tempPop = tempPop[ea.selecting('otos', tempPop.FitnV, 2)] # 采用One-to-One Survivor选择
population[chooseIdx] = tempPop
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop = None): # prophetPop为先知种群（即包含先验知识的种群）
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
if population.Chrom is None:
population.initChrom(NIND) # 初始化种群染色体矩阵
self.call_aimFunc(population) # 计算种群的目标函数值
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
#===========================开始进化============================
while self.terminated(population) == False:
# 进行差分进化操作
r0 = ea.selecting(self.selFunc, population.FitnV, NIND) # 得到基向量索引
experimentPop = population.copy() # 存储试验个体
experimentPop.Chrom = self.mutOper.do(experimentPop.Encoding, experimentPop.Chrom, experimentPop.Field, [r0]) # 变异
tempPop = population + experimentPop # 当代种群个体与变异个体进行合并（为的是后面用于重组）
experimentPop.Chrom = self.recOper.do(tempPop.Chrom) # 重组
self.call_aimFunc(experimentPop) # 计算目标函数值
tempPop = population + experimentPop # 临时合并，以调用otos进行一对一生存者选择
tempPop.FitnV = ea.scaling(self.problem.maxormins * tempPop.ObjV, tempPop.CV) # 计算适应度
population = tempPop[ea.selecting('otos', tempPop.FitnV, NIND)] # 采用One-to-One Survivor选择，产生新一代种群
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
# ==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法类的一些动态参数
# ===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
self.call_aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
# ===========================开始进化============================
while not self.terminated(population):
# 选择
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]) # 变异
self.call_aimFunc(offspring) # 计算目标函数值
population = population + offspring # 父子合并
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
# 得到新一代种群
population = population[ea.selecting(
'dup', population.FitnV, NIND)] # 采用基于适应度排序的直接复制选择生成新一代种群
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
# ==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法类的一些动态参数
# ===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
self.call_aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(population.ObjV, population.CV, self.problem.maxormins) # 计算适应度
Sigma3 = np.random.rand(population.sizes, population.Lind) * (
population.Field[1, :] - population.Field[0, :]) * 0.5 # 初始化高斯变异算子的Sigma3
# ===========================开始进化============================
while not self.terminated(population):
# 选择
choose_index = ea.selecting(self.selFunc, population.FitnV, self.NSel)
offspring = population[choose_index]
offspring_Sigma3 = Sigma3[choose_index]
# 进行进化操作
offspring.Chrom = self.recOper.do(offspring.Chrom) # 重组
offspring_Sigma3 = self.recOper.do(offspring_Sigma3) # 对offspring_Sigma3进行重组
for i in range(len(choose_index)):
offspring.Chrom[i, :] = ea.mutgau(offspring.Encoding, offspring.Chrom[i, :].reshape(1, -1),
offspring.Field, 1, offspring_Sigma3[i]).reshape(-1) # 高斯变异
self.call_aimFunc(offspring) # 计算目标函数值
population = population + offspring # 父子合并
Sigma3 = np.vstack([Sigma3, offspring_Sigma3])
population.FitnV = ea.scaling(population.ObjV, population.CV, self.problem.maxormins) # 计算适应度
# 得到新一代种群
choose_index = ea.selecting('dup', population.FitnV, NIND) # 采用基于适应度排序的直接复制选择
population = population[choose_index]
Sigma3 = Sigma3[choose_index]
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
if population.Chrom is None:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含染色体解码，详见Population类的源码）
else:
population.Phen = population.decoding() # 染色体解码
self.problem.aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
while self.terminated(population) == False:
# 进行差分进化操作
r0 = ea.selecting('ecs', population.FitnV, NIND) # 得到基向量索引，采用ecs复制精英个体索引
experimentPop = population.copy() # 存储试验个体
experimentPop.Chrom = ea.mutate(self.mutFunc, experimentPop.Encoding, experimentPop.Chrom, experimentPop.Field, r0, self.F, 1) # 差分变异
tempPop = population + experimentPop # 当代种群个体与变异个体进行合并（为的是后面用于重组）
experimentPop.Chrom = ea.recombin(self.recFunc, tempPop.Chrom, self.pc, True) # 重组
# 求进化后个体的目标函数值
experimentPop.Phen = experimentPop.decoding() # 染色体解码
self.problem.aimFunc(experimentPop) # 计算目标函数值
self.evalsNum += experimentPop.sizes # 更新评价次数
tempPop = population + experimentPop # 临时合并，以调用otos进行一对一生存者选择
tempPop.FitnV = ea.scaling(self.problem.maxormins * tempPop.ObjV, tempPop.CV) # 计算适应度
population = tempPop[ea.selecting('otos', tempPop.FitnV, NIND)] # 采用One-to-One Survivor选择，产生新一代种群
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
# ==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
# ===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵
self.call_aimFunc(population) # 计算种群的目标函数值
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
# ===========================开始进化============================
while self.terminated(population) == False:
# 进行差分进化操作
r0 = np.arange(NIND)
r_best = ea.selecting('ecs', population.FitnV,
NIND) # 执行'ecs'精英复制选择
experimentPop = ea.Population(population.Encoding,
population.Field, NIND) # 存储试验个体
experimentPop.Chrom = self.mutOper.do(
population.Encoding, population.Chrom, population.Field,
[r0, None, None, r_best, r0]) # 变异
experimentPop.Chrom = self.recOper.do(
np.vstack([population.Chrom, experimentPop.Chrom])) # 重组
self.call_aimFunc(experimentPop) # 计算目标函数值
tempPop = population + experimentPop # 临时合并，以调用otos进行一对一生存者选择
tempPop.FitnV = ea.scaling(tempPop.ObjV, tempPop.CV,
self.problem.maxormins) # 计算适应度
population = tempPop[ea.selecting(
'otos', tempPop.FitnV,
NIND)] # 采用One-to-One Survivor选择，产生新一代种群
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
# ==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
# ===========================准备进化============================
if population.Chrom is None:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含染色体解码，详见Population类的源码）
else:
population.Phen = population.decoding() # 染色体解码
self.problem.aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV,
population.CV) # 计算适应度
self.evalsNum = population.sizes # 记录评价次数
# ===========================开始进化============================
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 = population + offspring # 父子合并
population.FitnV = ea.scaling(self.problem.maxormins *
population.ObjV,
population.CV) # 计算适应度
# 得到新一代种群
population = population[ea.selecting(
'dup', population.FitnV, NIND)] # 采用基于适应度排序的直接复制选择生成新一代种群
# 获得此代最优秀的个体
best_gen = np.nanargmin(self.obj_trace[:, 1])
shortest_dis = self.obj_trace[best_gen]
shortest_path = np.hstack(
[self.var_trace[best_gen, :], self.var_trace[best_gen, 0]])
shortest_path_point_x = np.array(
self.problem.places[shortest_path.astype(int), 0])
shortest_path_point_y = np.array(
self.problem.places[shortest_path.astype(int), 1])
# shortest_path_point_name = self.problem.places[best_gen, 2]
shortest_path_point = np.vstack(
(shortest_path_point_x, shortest_path_point_y))
print(shortest_path_point)
print(shortest_path_point_x.shape)
# print("点:", shortest_path_point)
print("obj_trace:" + str(best_gen) + " 最短距离:" + str(shortest_dis))
print("最短路径:" + str(shortest_path), end="\n")
return self.finishing(population) # 调用finishing完成后续工作并返回结果
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):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
NVAR = self.problem.Dim # 得到决策变量的个数
self.obj_trace = (np.zeros(
(self.MAXGEN, 2)) * np.nan) # 定义目标函数值记录器，初始值为nan
self.var_trace = (np.zeros(
(self.MAXGEN, NVAR)) * np.nan) # 定义变量记录器，记录决策变量值，初始值为nan
self.forgetCount = 0 # “遗忘策略”计数器，用于记录连续出现最优个体不是可行个体的代数
#===========================准备进化============================
self.timeSlot = time.time() # 开始计时
if population.Chrom is None:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含染色体解码，详见Population类的源码）
population.ObjV, population.CV = self.problem.aimFuc(
population.Phen, population.CV) # 计算种群的目标函数值
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV,
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 = ea.scaling(self.problem.maxormins *
population.ObjV,
population.CV) # 计算适应度
# 得到新一代种群
population = population[ea.selecting(self.selFunc,
population.FitnV, NIND)]
# 处理进化记录器
delIdx = np.where(np.isnan(self.obj_trace))[0]
self.obj_trace = np.delete(self.obj_trace, delIdx, 0)
self.var_trace = np.delete(self.var_trace, delIdx, 0)
if self.obj_trace.shape[0] == 0:
raise RuntimeError(
'error: No feasible solution. (有效进化代数为0，没找到可行解。)')
self.passTime += time.time() - self.timeSlot # 更新用时记录
# 绘图
if self.drawing != 0:
ea.trcplot(self.obj_trace, [['种群个体平均目标函数值', '种群最优个体目标函数值']])
# 返回最后一代种群、进化记录器、变量记录器以及执行时间
return [population, self.obj_trace, self.var_trace]
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:
# 选择个体参与进化
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 run(self):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵（内含染色体解码，详见PsyPopulation类的源码）
self.problem.aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
while self.terminated(population) == False:
bestIdx = np.argmax(population.FitnV, axis = 0) # 得到当代的最优个体的索引, 设置axis=0可使得返回一个向量
studPop = population[np.tile(bestIdx, (NIND//2))] # 复制最优个体NIND//2份，组成一个“种马种群”
restPop = population[np.where(np.array(range(NIND)) != bestIdx)[0]] # 得到除去精英个体外其它个体组成的种群
# 选择个体，以便后面与种马种群进行交配
tempPop = restPop[ea.selecting(self.selFunc, restPop.FitnV, (NIND - studPop.sizes))]
# 将种马种群与选择出来的个体进行合并
population = studPop + tempPop
# 进行进化操作，分别对各种编码的染色体进行重组和变异
for i in range(population.ChromNum):
population.Chroms[i] = ea.recombin(self.recFuncs[i], population.Chroms[i], self.pcs[i]) # 重组
population.Chroms[i] = ea.mutate(self.mutFuncs[i], population.Encodings[i], population.Chroms[i], population.Fields[i], self.pms[i]) # 变异
# 求进化后个体的目标函数值
population.Phen = population.decoding() # 染色体解码
self.problem.aimFunc(population)
self.evalsNum += population.sizes # 更新评价次数
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
#==========================初始化配置===========================
population = self.population
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
uniformPoint, NIND = ea.crtup(self.problem.M, population.sizes) # 生成在单位目标维度上均匀分布的参考点集
refPoint = np.vstack([uniformPoint, np.random.rand(NIND, self.problem.M)]) # 初始化参考点（详见注释中的参考文献）
if population.Chrom is None or population.sizes != NIND:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含解码，详见Population类的源码），此时种群规模将调整为uniformPoint点集的大小，initChrom函数会把种群规模给重置
else:
population.Phen = population.decoding() # 染色体解码
self.problem.aimFunc(population) # 计算种群的目标函数值
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
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 = self.reinsertion(population, offspring, refPoint)
# 修改refPoint
refPoint[NIND:, :] = self.renewRefPoint(population.ObjV, refPoint[NIND:, :])
if (self.currentGen) % np.ceil(self.fr * self.MAXGEN) == 0:
refPoint[:NIND, :] = uniformPoint * (np.max(population.ObjV, 0) - np.min(population.ObjV, 0))
# 后续处理，限制种群规模（因为此时种群规模有可能大于NIND）
[levels, criLevel] = self.ndSort(self.problem.maxormins * population.ObjV, NIND, None, population.CV) # 对NIND个个体进行非支配分层
population = population[ea.refselect(self.problem.maxormins * population.ObjV, levels, criLevel, NIND, uniformPoint)] # 根据参考点选择个体
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
# ==========================初始化配置===========================
population = self.population
NIND = population.sizes
GGAP_NUM = int(np.ceil(NIND * self.GGAP)) # 计算每一代替换个体的个数
self.initialization() # 初始化算法类的一些动态参数
# ===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
self.call_aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
# ===========================开始进化============================
while not self.terminated(population):
# 选择
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) # 计算目标函数值
offspring.FitnV = ea.scaling(offspring.ObjV, offspring.CV,
self.problem.maxormins) # 计算适应度
# 根据代沟把子代重插入到父代生成新一代种群
population = self.reinsertion(population, offspring, GGAP_NUM)
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def multimin(AIM_M, AIM_F, NIND, NVAR, Base, MAXGEN, SUBPOP, GGAP, selectStyle,
recombinStyle, recopt, pm, maxormin):
"""==========================初始化配置==========================="""
# 获取目标函数和罚函数
aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数
BaseV = ga.crtbase(NVAR, Base)
"""=========================开始遗传算法进化======================="""
Chrom = ga.crtbp(NIND, BaseV) # 创建简单离散种群
ObjV = aimfuc(Chrom) # 计算种群目标函数值
NDSet = np.zeros((0, Chrom.shape[1])) # 定义帕累托最优解集合(初始为空集)
NDSetObjV = np.zeros((0, ObjV.shape[1])) # 定义帕累托最优解的目标函数值记录器
start_time = time.time() # 开始计时
# 开始进化！！
for gen in range(MAXGEN):
# 求种群的非支配个体以及基于被支配数的适应度
[FitnV, frontIdx] = ga.ndominfast(maxormin * ObjV)
# 更新帕累托最优集以及种群非支配个体的适应度
[FitnV, NDSet, NDSetObjV,
repnum] = ga.upNDSet(Chrom, maxormin * ObjV, FitnV, NDSet,
maxormin * NDSetObjV, frontIdx)
# 进行遗传操作！！
SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择
SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) #交叉
SelCh = ga.mut(SelCh, BaseV, pm) # 变异
ObjVSel = aimfuc(SelCh) # 求育种个体的目标函数值
# 求种群的非支配个体以及基于被支配数的适应度
[FitnVSel, frontIdx] = ga.ndominfast(maxormin * ObjVSel)
[Chrom, ObjV] = ga.reins(Chrom, SelCh, SUBPOP, 1, 1, FitnV, FitnVSel,
ObjV, ObjVSel) #重插入
end_time = time.time() # 结束计时
# 返回进化记录器、变量记录器以及执行时间
return [ObjV, NDSet, NDSetObjV, end_time - start_time]
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
# ==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法类的一些动态参数
# ===========================准备进化============================
population.initChrom() # 初始化种群染色体矩阵
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
self.call_aimFunc(population) # 计算种群的目标函数值
[levels, criLevel] = self.ndSort(population.ObjV, NIND, None, population.CV,
self.problem.maxormins) # 对NIND个个体进行非支配分层
population.FitnV = (1 / levels).reshape(-1, 1) # 直接根据levels来计算初代个体的适应度
# ===========================开始进化============================
while not self.terminated(population):
# 进行差分进化操作
r0 = ea.selecting(self.selFunc, population.FitnV, NIND) # 得到基向量索引
offspring = population.copy() # 存储子代种群
offspring.Chrom = self.mutOper.do(offspring.Encoding, offspring.Chrom, offspring.Field, [r0]) # 变异
tempPop = population + offspring # 当代种群个体与变异个体进行合并（为的是后面用于重组）
offspring.Chrom = self.recOper.do(tempPop.Chrom) # 重组
self.call_aimFunc(offspring) # 求进化后个体的目标函数值
population = self.reinsertion(population, offspring, NIND) # 重插入生成新一代种群
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
# ==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
# ===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵
self.call_aimFunc(population) # 计算种群的目标函数值
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
# ===========================开始进化============================
while self.terminated(population) == False:
bestIndi = population[np.argmax(population.FitnV, 0)] # 得到当代的最优个体
# 选择
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND - 1)]
# 进行进化操作，分别对各种编码的染色体进行重组和变异
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]) # 变异
self.call_aimFunc(offspring) # 计算目标函数值
population = bestIndi + offspring # 更新种群
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
if population.Chrom is None:
population.initChrom() # 初始化种群染色体矩阵（内含解码，详见Population类的源码）
self.problem.aimFunc(population) # 计算种群的目标函数值
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
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() # 解码
self.problem.aimFunc(offspring) # 求进化后个体的目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 重插入生成新一代种群
population = self.reinsertion(population, offspring, NIND)
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
GGAP_NUM = int(np.ceil(NIND * self.GGAP)) # 计算每一代替换个体的个数
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵（内含染色体解码，详见PsyPopulation类的源码）
self.problem.aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
while self.terminated(population) == False:
# 选择
offspring = population[ea.selecting(self.selFunc, population.FitnV, NIND)]
# 进行进化操作，分别对各种编码的染色体进行重组和变异
for i in range(offspring.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 # 更新评价次数
offspring.FitnV = ea.scaling(self.problem.maxormins * offspring.ObjV, offspring.CV) # 计算适应度
# 根据代沟把子代重插入到父代生成新一代种群
population = self.reinsertion(population, offspring, GGAP_NUM)
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵（内含染色体解码，详见PsyPopulation类的源码）
self.problem.aimFunc(population) # 计算种群的目标函数值
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV,
population.CV) # 计算适应度
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
while self.terminated(population) == False:
# 选择
population = population[ea.selecting(self.selFunc,
population.FitnV, NIND)]
# 进行进化操作，分别对各种编码的染色体进行重组和变异
for i in range(population.ChromNum):
population.Chroms[i] = self.recOpers[i].do(
population.Chroms[i]) # 重组
population.Chroms[i] = self.mutOpers[i].do(
population.Encodings[i], population.Chroms[i],
population.Fields[i]) # 变异
# 求进化后个体的目标函数值
population.Phen = population.decoding() # 染色体解码
self.problem.aimFunc(population) # 计算目标函数值
self.evalsNum += population.sizes # 更新评价次数
population.FitnV = ea.scaling(self.problem.maxormins *
population.ObjV,
population.CV) # 计算适应度
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def reinsertion(self, population, offspring, NUM, globalNDSet):
"""
描述:
重插入个体产生新一代种群（采用父子合并选择的策略）。
NUM为所需要保留到下一代的个体数目，globalNDSet为全局非支配解存档。
"""
# 父子两代合并
population = population + offspring
globalNDSet = population + globalNDSet # 将population与全局存档合并
# 非支配排序分层
[levels,
criLevel] = self.ndSort(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:
dis = ea.crowdis(globalNDSet.ObjV,
np.ones(globalNDSet.sizes)) # 计算拥挤距离
globalNDSet = globalNDSet[np.argsort(
-dis)[:self.MAXSIZE]] # 根据拥挤距离选择符合个数限制的解保留在存档中
# 选择个体保留到下一代
levels = levels[:population.sizes] # 得到与population个体对应的levels
dis = ea.crowdis(population.ObjV, levels) # 计算拥挤距离
population.FitnV[:, 0] = np.argsort(np.lexsort(np.array([dis,
-levels])),
kind='mergesort') # 计算适应度
chooseFlag = ea.selecting('dup', population.FitnV,
NUM) # 调用低级选择算子dup进行基于适应度排序的选择，保留NUM个个体
return population[chooseFlag], globalNDSet
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来计算初代个体的适应度
#===========================开始进化============================
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 = self.reinsertion(population, offspring, NIND) # 重插入生成新一代种群
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop=None): # prophetPop为先知种群（即包含先验知识的种群）
# ==========================初始化配置===========================
population = self.population
NIND = population.sizes
GGAP_NUM = int(np.ceil(NIND * self.GGAP)) # 计算每一代替换个体的个数
self.initialization() # 初始化算法模板的一些动态参数
# ===========================准备进化============================
population.initChrom(NIND) # 初始化种群染色体矩阵
self.call_aimFunc(population) # 计算种群的目标函数值
# 插入先验知识（注意：这里不会对先知种群prophetPop的合法性进行检查，故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性）
if prophetPop is not None:
population = (prophetPop + population)[:NIND] # 插入先知种群
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
# ===========================开始进化============================
while self.terminated(population) == False:
# 选择
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND)]
# 进行进化操作，分别对各种编码的染色体进行重组和变异
for i in range(offspring.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]) # 变异
self.call_aimFunc(offspring) # 计算目标函数值
offspring.FitnV = ea.scaling(offspring.ObjV, offspring.CV,
self.problem.maxormins) # 计算适应度
# 根据代沟把子代重插入到父代生成新一代种群
population = self.reinsertion(population, offspring, GGAP_NUM)
population.FitnV = ea.scaling(population.ObjV, population.CV,
self.problem.maxormins) # 计算适应度
return self.finishing(population) # 调用finishing完成后续工作并返回结果
