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):
#==========================初始化配置===========================
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):
#==========================初始化配置===========================
population = self.population
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
uniformPoint, NIND = ea.crtup(self.problem.M,
population.sizes) # 生成在单位目标维度上均匀分布的参考点集
population.initChrom(
NIND
) # 初始化种群染色体矩阵（内含解码，详见Population类的源码），此时种群规模将调整为uniformPoint点集的大小，initChrom函数会把种群规模给重置
self.problem.aimFunc(population) # 计算种群的目标函数值
self.evalsNum = population.sizes # 记录评价次数
#===========================开始进化============================
while self.terminated(population) == False:
# 选择个体参与进化
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND)]
# 进行进化操作，分别对各个种群染色体矩阵进行重组和变异
for i in range(population.ChromNum):
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]) # 变异
offspring.Phen = offspring.decoding() # 解码
self.problem.aimFunc(offspring) # 求进化后个体的目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 重插入生成新一代种群
population = self.reinsertion(population, offspring, NIND,
uniformPoint)
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
#==========================初始化配置===========================
population = self.population
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
uniformPoint, NIND = ea.crtup(self.problem.M, population.sizes) # 生成在单位目标维度上均匀分布的参考点集
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:
# 进行差分进化操作
r0 = ea.selecting(self.selFunc, population.FitnV, NIND) # 得到基向量索引
offspring = population.copy() # 存储子代种群
offspring.Chrom = ea.mutate(self.mutFunc, offspring.Encoding, offspring.Chrom, offspring.Field, r0, self.F, 1) # 差分变异
tempPop = population + offspring # 当代种群个体与变异个体进行合并（为的是后面用于重组）
offspring.Chrom = ea.recombin(self.recFunc, tempPop.Chrom, self.pc, True) # 重组
# 求进化后个体的目标函数值
offspring.Phen = offspring.decoding() # 染色体解码
self.problem.aimFunc(offspring) # 计算目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
# 重插入生成新一代种群
population = self.reinsertion(population, offspring, NIND, uniformPoint)
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom() # 初始化种群染色体矩阵（内含解码，详见Population类的源码）
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来计算初代个体的适应度
#===========================开始进化============================
while self.terminated(population) == False:
# 选择个体参与进化
offspring = population[ea.selecting(self.selFunc, population.FitnV,
NIND)]
# 进行进化操作，分别对各个种群染色体矩阵进行重组和变异
for i in range(population.ChromNum):
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]) # 变异
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
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
if population.Chrom is None:
population.initChrom() # 初始化种群染色体矩阵（内含解码，详见Population类的源码）
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来计算初代个体的适应度
#===========================开始进化============================
while self.terminated(population) == False:
# 进行差分进化操作
r0 = ea.selecting(self.selFunc, population.FitnV, NIND) # 得到基向量索引
offspring = population.copy() # 存储子代种群
offspring.Chrom = ea.mutate(self.mutFunc, offspring.Encoding,
offspring.Chrom, offspring.Field, r0,
self.F, 1) # 差分变异
tempPop = population + offspring # 当代种群个体与变异个体进行合并（为的是后面用于重组）
offspring.Chrom = ea.recombin(self.recFunc, tempPop.Chrom, self.pc,
True) # 重组
# 求进化后个体的目标函数值
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
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
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:
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] = 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]) # 变异
# 求进化后个体的目标函数值
offspring.Phen = offspring.decoding() # 染色体解码
self.problem.aimFunc(offspring) # 计算目标函数值
self.evalsNum += offspring.sizes # 更新评价次数
population = bestIndi + offspring # 更新种群
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 = uniformPoint.copy() # 初始化参考点为uniformPoint
if population.Chrom is None or population.sizes != NIND:
population.initChrom(NIND) # 初始化种群染色体矩阵（内含解码，详见Population类的源码），此时种群规模将调整为uniformPoint点集的大小，initChrom函数会把种群规模给重置
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, refPoint)
# 修改refPoint
if (self.currentGen) % np.ceil(self.fr * self.MAXGEN) == 0:
refPoint = uniformPoint * (np.max(population.ObjV, 0) - np.min(population.ObjV, 0))
self.Gamma = None # 重置Gamma为None
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:
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
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):
#==========================初始化配置===========================
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 = 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, 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 Evolution(self):
start_time = time.time()
Objv = self.get_Objv_i(self.chrom)
best_ind = np.argmax(Objv * self.maxormins)
for gen in range(self.MAXGEN):
self.log.logger.info('==> This is No.%d GEN <==' % (gen))
FitnV = ea.ranking(Objv * self.maxormins)
Selch = self.chrom[ea.selecting('rws', FitnV, self.Nind - 1), :]
Selch = ea.recombin('xovsp', Selch, self.xov_rate)
Selch = ea.mutate('mutswap', 'RI', Selch, self.FieldDR)
NewChrom = np.vstack((self.chrom[best_ind, :], Selch))
Objv = self.get_Objv_i(NewChrom)
best_ind = np.argmax(Objv * self.maxormins)
self.obj_trace[gen, 0] = np.sum(Objv) / self.Nind #记录当代种群的目标函数均值
self.obj_trace[gen, 1] = Objv[best_ind] #记录当代种群最有给他目标函数值
self.var_trace[gen, :] = NewChrom[best_ind, :] #记录当代种群最有个体的变量值
self.log.logger.info(
'GEN=%d,best_Objv=%.5f,best_chrom_i=%s\n' %
(gen, Objv[best_ind], str(
NewChrom[best_ind, :]))) #记录每一代的最大适应度值和个体
end_time = time.time()
self.time = end_time - start_time
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
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:
# 选择
population = population[ea.selecting(self.selFunc,
population.FitnV, NIND)]
# 进行进化操作
population.Chrom = ea.recombin(self.recFunc, population.Chrom,
self.pc) # 重组
population.Chrom = ea.mutate(self.mutFunc, population.Encoding,
population.Chrom, population.Field,
self.pm) # 变异
# 求进化后个体的目标函数值
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
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:
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
# 进行进化操作
population.Chrom = ea.recombin(self.recFunc, population.Chrom,
self.pc) # 重组
population.Chrom = ea.mutate(self.mutFunc, population.Encoding,
population.Chrom, population.Field,
self.pm) # 变异
# 求进化后个体的目标函数值
population.Phen = population.decoding() # 染色体解码
population.ObjV, population.CV = self.problem.aimFuc(
population.Phen, population.CV)
self.evalsNum += population.sizes # 更新评价次数
population.FitnV = ea.scaling(self.problem.maxormins *
population.ObjV,
population.CV) # 计算适应度
# 处理进化记录器
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):
#==========================初始化配置===========================
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 # 记录评价次数
Sigma = 0.5 * (population.Field[1,:] - population.Field[0,:]) / 3 # 初始化高斯变异的Sigma
#===========================开始进化============================
while self.terminated(population) == False:
# 进行进化操作
experimentPop = population.copy() # 存储试验种群
experimentPop.Chrom = ea.mutate('mutgau', experimentPop.Encoding, experimentPop.Chrom, experimentPop.Field, experimentPop.Lind, Sigma) # 变异（这里变异概率设为染色体长度）
# 求进化后个体的目标函数值
experimentPop.Phen = experimentPop.decoding() # 染色体解码
self.problem.aimFunc(experimentPop) # 计算目标函数值
self.evalsNum += population.sizes # 更新评价次数
tempPop = population + experimentPop # 临时合并，以调用otos进行一对一生存者选择
tempPop.FitnV = ea.scaling(self.problem.maxormins * tempPop.ObjV, tempPop.CV) # 计算适应度
chooseIdx = ea.selecting('otos', tempPop.FitnV, NIND) # 采用One-to-One Survivor选择
population = tempPop[chooseIdx] # 产生新一代种群
# 利用1/5规则调整变异压缩概率（实质上是通过变异压缩概率来调整高斯变异的标准差，详见mutgau帮助文档）
successfulRate = len(np.where(chooseIdx >= NIND)[0]) / (2 * NIND)
if successfulRate < 1/5:
Sigma *= 0.817
elif successfulRate > 1/5:
Sigma /= 0.817
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def Evolution(self): #
start_time = time.time()
# 初始化种群
self.get_FieldDR()
Init_chrom = self.get_init_chrom()
# 开始进化
self.log.logger.info('==> This is Init GEN <==')
Init_Objv = self.get_Objv_i(Init_chrom)
best_ind = np.argmax(Init_Objv * self.maxormins) #记录最优个体的索引值
self.chrom_all = Init_chrom
self.Objv_all = Init_Objv
for gen in range(self.MAXGEN):
self.log.logger.info('==> This is No.%d GEN <==' % (gen))
if gen == 0: #第一代和后面有所不同
chrom = Init_chrom
Objv = Init_Objv
else:
chrom = NewChrom
Objv = NewObjv
FitnV = ea.ranking(Objv * self.maxormins)
Selch = chrom[ea.selecting('rws', FitnV, self.Nind -
1), :] #轮盘赌选择 Nind-1 代，与上一代的最优个体再进行拼接
Selch = ea.recombin('xovsp', Selch, self.xov_rate) #重组，即交叉
Selch = ea.mutate('mutswap', 'RI', Selch, self.FieldDR) #变异
Objv_Selch = self.get_Objv_i(Selch)
NewChrom = np.vstack(
(chrom[best_ind, :], Selch)) #将上一代的最优个体与现在的种群拼接
NewObjv = np.vstack((Objv[best_ind, :], Objv_Selch))
best_ind = np.argmax(NewObjv * self.maxormins)
self.chrom_all = np.vstack((self.chrom_all, NewChrom))
self.Objv_all = np.vstack((self.Objv_all, NewObjv))
self.obj_trace[gen,
0] = np.sum(NewObjv) / self.Nind # 记录当代种群的目标函数均值
self.obj_trace[gen, 1] = NewObjv[best_ind] # 记录当代种群最有给他目标函数值
self.var_trace[gen, :] = NewChrom[best_ind, :] # 记录当代种群最优个体的变量值
self.log.logger.info(
'GEN=%d,best_Objv=%.5f,best_chrom_i=%s\n' %
(gen, NewObjv[best_ind], str(
NewChrom[best_ind, :]))) # 记录每一代的最大适应度值和个体
self.Save_chroms(self.chrom_all)
self.Save_objvs(self.Objv_all)
end_time = time.time()
self.time = end_time - start_time
self.log.logger.info('The time of Evoluation is %.5f s. ' % self.time)
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:
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 # 更新评价次数
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选择，产生新一代种群
# 处理进化记录器
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):
#==========================初始化配置===========================
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):
#==========================初始化配置===========================
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 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
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] = 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]) # 变异
# 求进化后个体的目标函数值
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):
#==========================初始化配置===========================
population = self.population
NIND = population.sizes
self.initialization() # 初始化算法模板的一些动态参数
#===========================准备进化============================
population.initChrom() # 初始化种群染色体矩阵（内含解码，详见Population类的源码）
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)]
# 进行进化操作，分别对各个种群染色体矩阵进行重组和变异
for i in range(population.ChromNum):
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]) # 变异
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
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] = 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]) # 变异
# 求进化后个体的目标函数值
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() # 初始化算法模板的一些动态参数
#===========================准备进化============================
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:
print('gen', self.currentGen)
bestIndi = population[np.argmax(population.FitnV, 0)] # 得到当代的最优个体
# 选择
offspring = population[ea.selecting(
self.selFunc, population.FitnV,
NIND - 1)] #同样选取与父代数量相等个体-1,因为前面还有一个最佳父代
# 进行进化操作
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 = bestIndi + offspring # 更新种群
population.FitnV = ea.scaling(self.problem.maxormins *
population.ObjV,
population.CV) # 计算适应度
return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self):
# ==========================初始化配置===========================
population = self.population # population是传入的初始化种群
NIND = population.sizes # NIND表示的是种群数目
NVAR = self.problem.Dim # 得到决策变量的个数
self.obj_trace = (np.zeros((self.MAXGEN, 2)) * np.nan) # 定义目标函数值记录器，初始值为nan
# 目标函数记录器(2列)
self.var_trace = (np.zeros((self.MAXGEN, NVAR)) * np.nan) # 定义变量记录器，记录决策变量值，初始值为nan
# id_trace用于记录每一代训练得出的最佳子种群的ARRAY
self.forgetCount = 0 # “遗忘策略”计数器，用于记录连续出现最优个体不是可行个体的代数/"遗忘策略"
id_1 = self.id_1_start()
#id_1 = np.random.randint(0, NVAR, (NIND, NVAR)) # 对index记录的矩阵进行初始化
# ===========================准备进化============================
self.timeSlot = time.time() # 开始计时
if population.Chrom is None:
new_fixed_dict = self.change_bug()
population.Chrom, population.Phen, population.FitnV, population.CV, population.ObjV = self.start_fx()
population.ObjV, population.CV = self.problem.aim_chuli(population.Phen, id_1, new_fixed_dict)
feasible = np.where(np.all(population.CV <= 0, 1))[0]
while True:
if len(feasible) > 0:
break
else:
# population.Chrom, population.Phen, population.FitnV, population.CV, population.ObjV = self.start_fx()
# id_1 = self.id_1_start()
new_fixed_dict = self.change_bug()
population.ObjV, population.CV = self.problem.aim_chuli(population.Phen, id_1, new_fixed_dict)
feasible = np.where(np.all(population.CV <= 0, 1))[0]
# id_1是保留shape的形状
# 计算种群的目标函数，输入的是CV和Phen表现矩阵
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
# 自动计算适应度
#print('种群初始化-2时的适应度:', population.FitnV)
self.evalsNum = population.sizes # 记录评价次数
# 记录评价次数
# ===========================开始进化============================
self.currentGen = 0
# 开始进化，设置currentGen为0
while self.terminated(population, id_1) == False:
# 若需要继续进化，那么有
bestIdx = np.argmax(population.FitnV, axis=0) # 得到当代的最优个体的索引, 设置axis=0可使得返回一个向量
best_id = np.tile(id_1[bestIdx], (NIND // 2, 1))
studPop = population[np.tile(bestIdx, NIND // 2)] # 复制最优个体NIND//2份，组成一个“种马种群”
restPop = population[np.where(np.array(range(NIND)) != bestIdx)[0]]
# 得到除去精英个体外其它个体组成的种群
# 选择个体，以便后面与种马种群进行交配
restid = id_1[np.where(np.array(range(NIND)) != bestIdx)[0]]
id_temp = restid[ea.selecting(self.selFunc, restPop.FitnV, (NIND - studPop.sizes))]
tempPop = restPop[ea.selecting(self.selFunc, restPop.FitnV, (NIND - studPop.sizes))]
# 将种马种群与选择出来的个体进行合并
population = studPop + tempPop
id_1 = np.vstack((best_id, id_temp))
# 进行进化操作
# population.Chrom = ea.recombin(self.recFunc, population.Chrom, self.pc) # 重组
population.Chrom, id_1 = self.problem.intersect(population.Chrom, id_1, self.pc) # 重组
population.Chrom = ea.mutate(self.mutFunc, population.Encoding, population.Chrom, population.Field, self.pm)
# 求进化后个体的目标函数值//变异
# print('进化中的Chorm矩阵：', population.Chrom)
# print('进化中的Phen矩阵：', population.Phen)
population.Phen = population.decoding() # 染色体解码
# population.ObjV, population.CV = self.problem.aimFuc(population.Phen, population.CV)
population.ObjV, population.CV = self.problem.aim_chuli(population.Phen, id_1, new_fixed_dict) # 计算种群的目标函数值
# population.ObjV, population.CV = self.problem.aim_chuli(population.Chrom, id_1)
self.evalsNum += population.sizes
population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度
# 处理进化记录器
# 计算适应度
# 处理进化记录器
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)
# 对id的trace进行记录
self.id_trace = np.delete(self.id_trace, delIdx, 0)
# self.var_trace = np.delete(self.var_trace, delIdx, 0) #记录trace
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, self.id_trace, new_fixed_dict]
help(ea.ranking)
for gen in range(MAXGEN):
Phen = ea.bs2real(Chrom, FieldD) # 对种群进行解码(二进制转十进制)
ObjV, CV = aim(Phen) # 求种群个体的目标函数值
FitnV = ea.ranking(maxormins * ObjV, CV) # 根据目标函数大小分配适应度值
# 记录
best_ind = np.argmax(FitnV) # 计算当代最优个体的序号
obj_trace[gen, 0] = np.sum(ObjV) / ObjV.shape[0] # 记录当代种群的目标函数均值
obj_trace[gen, 1] = ObjV[best_ind] # 记录当代种群最优个体目标函数值
var_trace[gen, :] = Chrom[best_ind, :] # 记录当代种群最优个体的染色体
SelCh = Chrom[ea.selecting(selectStyle, FitnV, NIND - 1), :] # 选择
SelCh = ea.recombin(recStyle, SelCh, pc) # 重组
SelCh = ea.mutate(mutStyle, Encoding, SelCh, pm) # 变异
# 把父代精英个体与子代的染色体进行合并，得到新一代种群
Chrom = np.vstack([var_trace[gen, :], SelCh])
print('第', gen, '代', '用时：', time.time() - start_time, '秒')
# 进化完成
l = [
'头词频', '词频', '词长', 'TFIDF', 'IDF', '出现在标题', '首次出现词位置', '最后出现词位置', '位置跨度',
'词方差', '词平均', '词偏度', '词峰度', '词差方差', '词差平均', '最大词差', '最小词差', '最大句中位置',
'最小句中位置', '平均句中位置', '最长句长', '最短句长', '平均句长', '首次句位置', '最后句位置', '句跨度',
'出现在第一句', '出现在最后一句', '句子出现频率', '句方差', '句平均', '句偏度', '句峰度', '句差方差', '句差平均',
'最大句差', '最小句差', '包含英文', '相似度', '度中心性', '接近中心性', '介数中心性', '特征向量中心性',
'共现矩阵偏度', 'n', 't', 's', 'f', 'v', 'a', 'b', 'z', 'q', 'd', 'h', 'k', 'x',
'g', 'i', 'j', 'l', 'y', 'un', '包含数字'
]
end_time = time.time() # 结束计时
FieldD = ga.crtfld(encoding, varTypes, ranges, borders, precisions, codes,
scales) # 调用函数创建区域描述器
Lind = int(np.sum(FieldD[0, :])) # 计算编码后的染色体长度
Chrom = ga.crtpc(encoding, NIND, FieldD) # 根据区域描述器生成二进制种群
variable = ga.bs2real(Chrom, FieldD) #对初始种群进行解码
ObjV = aim(variable) # 计算初始种群个体的目标函数值
pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) # 定义进化记录器，初始值为nan
ind_trace = (np.zeros(
(MAXGEN, Lind)) * np.nan) # 定义种群最优个体记录器，记录每一代最优个体的染色体，初始值为nan
# 开始进化！！
for gen in range(MAXGEN):
FitnV = ga.ranking(-ObjV) # 根据目标函数大小分配适应度值(由于遵循目标最小化约定，因此最大化问题要对目标函数值乘上-1)
SelCh = Chrom[ga.selecting(selectStyle, FitnV,
NIND - 1)] # 选择，采用'sus'随机抽样选择
SelCh = ga.recombin(recStyle, SelCh, GGAP) # 重组(采用单点交叉方式，交叉概率为0.7)
SelCh = ga.mutate(mutStyle, encoding, SelCh, PM) # 二进制种群变异
variable = ga.bs2real(Chrom, FieldD) # 对育种种群进行解码(二进制转十进制)
ObjVSel = aim(variable) # 求育种个体的目标函数值
# 记录
best_ind = np.argmax(ObjV) # 计算当代最优个体的序号
pop_trace[gen, 0] = ObjV[best_ind] # 记录当代种群最优个体目标函数值
pop_trace[gen, 1] = np.sum(ObjV) / ObjV.shape[0] # 记录当代种群的目标函数均值
ind_trace[gen, :] = Chrom[best_ind, :] # 记录当代种群最优个体的变量值
# 进化完成
end_time = time.time() # 结束计时
"""============================输出结果及绘图================================"""
print('目标函数最大值：', np.max(pop_trace[:, 0])) # 输出目标函数最大值
variable = ga.bs2real(ind_trace, FieldD) # 解码得到表现型
print('最大值点：', variable[0][0])
print('用时：', end_time - start_time)
plt.plot(variable, aim(variable), 'bo')
def main():
"""============================变量设置============================"""
x1 = [50, 100] # 第一个决策变量范围
x2 = [50, 100] # 第二个决策变量范围
x3 = [50, 100]
x4 = [50, 100]
x5 = [50, 100]
x6 = [50, 100]
x7 = [50, 100]
x8 = [50, 100]
x9 = [50, 100]
x10 = [50, 100]
b1 = [1, 1] # 第一个决策变量边界，1表示包含范围的边界，0表示不包含
b2 = [1, 1] # 第二个决策变量边界，1表示包含范围的边界，0表示不包含
b3 = [1, 1]
b4 = [1, 1]
b5 = [1, 1]
b6 = [1, 1]
b7 = [1, 1]
b8 = [1, 1]
b9 = [1, 1]
b10 = [1, 1]
ranges = np.vstack([x1, x2, x3, x4, x5, x6, x7, x8, x9,
x10]).T # 生成自变量的范围矩阵，使得第一行为所有决策变量的下界，第二行为上界
borders = np.vstack([b1, b2, b3, b4, b5, b6, b7, b8, b9,
b10]).T # 生成自变量的边界矩阵
varTypes = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) # 决策变量的类型，0表示连续，1表示离散
"""==========================染色体编码设置========================="""
Encoding = 'BG' # 'BG'表示采用二进制/格雷编码
codes = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # 决策变量的编码方式，设置两个0表示两个决策变量均使用二进制编码
precisions = [4, 4, 4, 4, 4, 4, 4, 4, 4,
4] # 决策变量的编码精度，表示二进制编码串解码后能表示的决策变量的精度可达到小数点后6位
scales = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # 0表示采用算术刻度，1表示采用对数刻度
FieldD = ea.crtfld(Encoding, varTypes, ranges, borders, precisions, codes,
scales) # 调用函数创建译码矩阵
"""=========================遗传算法参数设置========================"""
NIND = 30 # 种群个体数目
MAXGEN = 30 # 最大遗传代数
maxormins = [1] # 列表元素为1则表示对应的目标函数是最小化，元素为-1则表示对应的目标函数是最大化
selectStyle = 'rws' # 采用轮盘赌选择
recStyle = 'xovdp' # 采用两点交叉
mutStyle = 'mutbin' # 采用二进制染色体的变异算子
pc = 0.7 # 交叉概率
pm = 1 # 整条染色体的变异概率（每一位的变异概率=pm/染色体长度）
Lind = int(np.sum(FieldD[0, :])) # 计算染色体长度
obj_trace = np.zeros((MAXGEN, 2)) # 定义目标函数值记录器
var_trace = np.zeros((MAXGEN, Lind)) # 染色体记录器，记录历代最优个体的染色体
"""=========================开始遗传算法进化========================"""
start_time = time.time() # 开始计时
Chrom = ea.crtpc(Encoding, NIND, FieldD) # 生成种群染色体矩阵
variable = ea.bs2real(Chrom, FieldD) # 对初始种群进行解码
ObjV = minfun(variable) # 计算初始种群个体的目标函数值
FitnV = ea.ranking(maxormins * ObjV) # 根据目标函数大小分配适应度值
best_ind = np.argmax(FitnV) # 计算当代最优个体的序号
# 开始进化
for gen in range(MAXGEN):
print(gen)
SelCh = Chrom[ea.selecting(selectStyle, FitnV, NIND - 1), :] # 选择
SelCh = ea.recombin(recStyle, SelCh, pc) # 重组
SelCh = ea.mutate(mutStyle, Encoding, SelCh, pm) # 变异
# 把父代精英个体与子代的染色体进行合并，得到新一代种群
Chrom = np.vstack([Chrom[best_ind, :], SelCh])
Phen = ea.bs2real(Chrom, FieldD) # 对种群进行解码(二进制转十进制)
print(Phen)
ObjV = minfun(Phen) # 求种群个体的目标函数值
FitnV = ea.ranking(maxormins * ObjV) # 根据目标函数大小分配适应度值
# 记录
best_ind = np.argmax(FitnV) # 计算当代最优个体的序号
obj_trace[gen, 0] = np.sum(ObjV) / ObjV.shape[0] # 记录当代种群的目标函数均值
obj_trace[gen, 1] = ObjV[best_ind] # 记录当代种群最优个体目标函数值
var_trace[gen, :] = Chrom[best_ind, :] # 记录当代种群最优个体的染色体
print(best_ind)
# 进化完成
end_time = time.time() # 结束计时
ea.trcplot(obj_trace, [['种群个体平均目标函数值', '种群最优个体目标函数值']]) # 绘制图像
"""============================输出结果============================"""
best_gen = np.argmin(obj_trace[:, [1]])
print('最优解的目标函数值：', obj_trace[best_gen, 1])
variable = ea.bs2real(var_trace[[best_gen], :],
FieldD) # 解码得到表现型（即对应的决策变量值）
print('最优解的决策变量值为：')
print(variable)
print('用时：', end_time - start_time, '秒')
