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 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() # 初始化算法模板的一些动态参数 #===========================准备进化============================ 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() # 初始化算法模板的一些动态参数 #===========================准备进化============================ 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) # 初始化种群染色体矩阵(内含染色体解码,详见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类的源码) 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 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类的源码) 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 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): #==========================初始化配置=========================== 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 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): #==========================初始化配置=========================== 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): #==========================初始化配置=========================== 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 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 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): #==========================初始化配置=========================== 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 mintemp1(AIM_M, AIM_F, PUN_M, PUN_F, ranges, borders, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, maxormin): """==========================初始化配置===========================""" # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 punishing = getattr(PUN_M, PUN_F) # 获得罚函数 FieldDR = ga.crtfld(ranges, borders) # 初始化区域描述器 NVAR = ranges.shape[1] # 得到控制变量的个数 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 3)) * np.nan).astype('int64') # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN, NVAR)) * np.nan).astype('int64') """=========================开始遗传算法进化=======================""" Chrom = ga.crtip(NIND, FieldDR) # 根据区域描述器FieldDR生成整数型初始种群 LegV = np.ones((NIND, 1)) # 生成可行性列向量,元素为1表示对应个体是可行解,0表示非可行解 [ObjV, LegV] = aimfuc(Chrom, LegV) # 计算种群目标函数值,同时更新LegV start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): FitnV = ga.ranking(maxormin * ObjV, LegV) # 计算种群适应度 FitnV = punishing(LegV, FitnV) # 调用罚函数 # 记录进化过程 bestIdx = np.argmax(FitnV) if LegV[bestIdx] != 0: feasible = np.where(LegV != 0)[0] # 排除非可行解 # 记录当代种群的适应度均值 pop_trace[gen, 1] = np.sum(FitnV[feasible]) / FitnV[feasible].shape[0] # 记录当代种群最优个体的目标函数值 pop_trace[gen, 0] = ObjV[bestIdx] # 记录当代种群的最优个体的适应度值 pop_trace[gen, 2] = FitnV[bestIdx] # 记录当代种群最优个体的变量值 var_trace[gen, :] = Chrom[bestIdx, :] # 进行遗传操作!! SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) #交叉 SelCh = ga.mutint(SelCh, FieldDR, pm) # 实值变异 LegVSel = np.ones((SelCh.shape[0], 1)) # 创建育种个体的可行性列向量 [ObjVSel, LegVSel] = aimfuc(SelCh, LegVSel) # 求育种个体的目标函数值 FitnVSel = punishing(LegVSel, FitnV) # 调用罚函数 [Chrom, ObjV, LegV] = ga.reins(Chrom, SelCh, SUBPOP, 1, 1, FitnV, FitnVSel, ObjV, ObjVSel, LegV, LegVSel) #重插入 end_time = time.time() # 结束计时 # 后处理进化记录器 delIdx = np.where(np.isnan(pop_trace))[0] pop_trace = np.delete(pop_trace, delIdx, 0) var_trace = np.delete(var_trace, delIdx, 0) # 返回进化记录器、变量记录器以及执行时间 return [pop_trace, var_trace, end_time - start_time]
def nsga2(AIM_M, AIM_F, NIND, ranges, borders, precisions, MAXGEN, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, maxormin): """==========================初始化配置===========================""" GGAP = 0.5 * GGAP # 为了避免父子两代合并后种群数量爆炸,要让代沟不超过0.5 # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 FieldDR = ga.crtfld(ranges, borders, precisions) """=========================开始遗传算法进化=======================""" Chrom = ga.crtrp(NIND, FieldDR) # 创建简单离散种群 ObjV = aimfuc(Chrom) # 计算种群目标函数值 NDSet = np.zeros((0, ObjV.shape[1])) # 定义帕累托最优解集合(初始为空集) start_time = time.time() # 开始计时 [FitnV, levels, maxLevel] = ga.ndomindeb(maxormin * ObjV, 1) # deb非支配分级 frontIdx = np.where(levels == 1)[0] # 处在第一级的个体即为种群的非支配个体 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, repnum] = ga.upNDSet(FitnV, maxormin * ObjV, maxormin * NDSet, frontIdx) # 开始进化!! for gen in range(MAXGEN): # if NDSet.shape[0] > 2 * ObjV.shape[0]: # break # 进行遗传操作!! SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) #交叉 SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 if repnum > Chrom.shape[0] * 0.05: # 当最优个体重复率高达5%时,进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 # 父子合并 Chrom = np.vstack([Chrom, SelCh]) ObjV = aimfuc(Chrom) # 求目标函数值 [FitnV, levels, maxLevel] = ga.ndomindeb(maxormin * ObjV, 1) # deb非支配分级 frontIdx = np.where(levels == 1)[0] # 处在第一级的个体即为种群的非支配个体 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, repnum] = ga.upNDSet(FitnV, maxormin * ObjV, maxormin * NDSet, frontIdx) # 计算每个目标下个体的聚集距离(不需要严格计算欧氏距离,计算绝对值即可) for i in range(ObjV.shape[1]): idx = np.argsort(ObjV[:, i], 0) dis = np.abs(np.diff(ObjV[idx, i].T, 1).T) / ( np.max(ObjV[idx, i]) - np.min(ObjV[idx, i]) + 1) # 差分计算距离 dis = np.hstack([dis, dis[-1]]) FitnV[idx, 0] += dis # 根据聚集距离修改适应度,以增加种群的多样性 Chrom = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择出下一代 end_time = time.time() # 结束计时 # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, end_time - start_time]
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 i_awGA(AIM_M, AIM_F, NIND, ranges, borders, precisions, MAXGEN, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, maxormin): """==========================初始化配置===========================""" # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 FieldDR = ga.crtfld(ranges, borders, precisions) """=========================开始遗传算法进化=======================""" Chrom = ga.crtrp(NIND, FieldDR) # 创建简单离散种群 ObjV = aimfuc(Chrom) # 计算种群目标函数值 NDSet = np.zeros((0, ObjV.shape[1])) # 定义帕累托最优解集合(初始为空集) start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): if NDSet.shape[0] > 2 * ObjV.shape[0]: break [CombinObjV, weight] = ga.awGA(ObjV) # 适应性权重法求聚合目标函数值 FitnV = ga.ranking(maxormin * CombinObjV) # 根据加权单目标计算适应度 [FitnV, frontIdx] = ga.ndominfast(maxormin * ObjV, FitnV) # 求种群的非支配个体,并更新适应度 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, repnum] = ga.upNDSet(FitnV, maxormin * ObjV, maxormin * NDSet, frontIdx) # 进行遗传操作!! SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) #交叉 SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 if repnum > Chrom.shape[0] * 0.1: # 进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 ObjVSel = aimfuc(SelCh) # 求育种个体的目标函数值 [CombinObjV, weight] = ga.awGA(maxormin * ObjVSel) # 适应性权重法求聚合目标函数值 FitnVSel = ga.ranking(maxormin * CombinObjV) # 根据聚合目标求育种个体适应度 [Chrom, ObjV] = ga.reins(Chrom, SelCh, SUBPOP, 1, 0.9, FitnV, FitnVSel, ObjV, ObjVSel) #重插入 end_time = time.time() # 结束计时 # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, end_time - start_time]
def q_sorted(AIM_M, AIM_F, NIND, ranges, borders, precisions, MAXGEN, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, maxormin): """==========================初始化配置===========================""" # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 FieldDR = ga.crtfld(ranges, borders, precisions) """=========================开始遗传算法进化=======================""" Chrom = ga.crtrp(NIND, FieldDR) # 创建简单离散种群 ObjV = aimfuc(Chrom) # 计算种群目标函数值 NDSet = np.zeros((0, ObjV.shape[1])) # 定义帕累托最优解集合(初始为空集) start_time = time.time() # 开始计时 ax = None # 开始进化!! for gen in range(MAXGEN): # if NDSet.shape[0] > ObjV.shape[0]: # break # 求种群的非支配个体以及基于被支配数的适应度 [FitnV, frontIdx] = ga.ndominfast(maxormin * ObjV) # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, repnum] = ga.upNDSet(FitnV, maxormin * ObjV, maxormin * NDSet, frontIdx) # 进行遗传操作!! SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) #交叉 SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 if repnum > Chrom.shape[0] * 0.1: # 进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 ObjVSel = aimfuc(SelCh) # 求育种个体的目标函数值 # 求种群的非支配个体以及基于被支配数的适应度 [FitnVSel, frontIdx] = ga.ndominfast(maxormin * ObjVSel) [Chrom, ObjV] = ga.reins(Chrom, SelCh, SUBPOP, 1, 0.9, FitnV, FitnVSel, ObjV, ObjVSel) #重插入 ax = ga.frontplot(NDSet, False, ax, gen + 1) end_time = time.time() # 结束计时 # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, end_time - start_time]
def mintemp1(AIM_M, AIM_F, PUN_M, PUN_F, ranges, borders, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, maxormin): """==========================初始化配置===========================""" # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 punishing = getattr(PUN_M, PUN_F) # 获得罚函数 FieldDR = ga.crtfld(ranges, borders) # 初始化区域描述器 NVAR = ranges.shape[1] # 得到控制变量的个数 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 3)) * np.nan).astype('int64') # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN, NVAR)) * np.nan).astype('int64') """=========================开始遗传算法进化=======================""" Chrom = ga.crtip(NIND, FieldDR) # 根据区域描述器FieldDR生成整数型初始种群 ObjV = aimfuc(Chrom) # 计算种群目标函数值 start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): FitnV = ga.ranking(maxormin * ObjV) # 计算种群适应度 FitnV = punishing(Chrom, FitnV) # 调用罚函数 # 记录当代种群最优个体的目标函数值 pop_trace[gen, 0] = ObjV[np.argmax(FitnV)] # 记录当代种群的适应度均值 pop_trace[gen, 1] = np.sum(FitnV) / FitnV.shape[0] # 记录当代种群的最优个体的适应度值 pop_trace[gen, 2] = np.max(FitnV) # 记录当代种群最优个体的变量值 var_trace[gen, :] = Chrom[np.argmax(FitnV), :] # 进行遗传操作!! SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) #交叉 SelCh = ga.mutint(SelCh, FieldDR, pm) # 实值变异 ObjVSel = aimfuc(SelCh) # 求育种个体的目标函数值 [Chrom,ObjV] = ga.reins(Chrom,SelCh,SUBPOP,2,1,maxormin*ObjV,\ maxormin*ObjVSel) #重插入 end_time = time.time() # 结束计时 # 返回进化记录器、变量记录器以及执行时间 return [pop_trace, var_trace, end_time - start_time]