def run(self, prophetPop = None): # prophetPop为先知种群(即包含先验知识的种群) #==========================初始化配置=========================== population = self.population NIND = population.sizes self.initialization() # 初始化算法模板的一些动态参数 #===========================准备进化============================ population.initChrom(NIND) # 初始化种群染色体矩阵 self.call_aimFunc(population) # 计算种群的目标函数值 # 插入先验知识(注意:这里不会对先知种群prophetPop的合法性进行检查,故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性) if prophetPop is not None: population = (prophetPop + population)[:NIND] # 插入先知种群 population.FitnV = ea.scaling(population.ObjV, population.CV, self.problem.maxormins) # 计算适应度 Sigma3 = 0.5 * (population.Field[1,:] - population.Field[0,:]) # 初始化高斯变异算子的Sigma3 #===========================开始进化============================ while self.terminated(population) == False: # 进行进化操作 experimentPop = ea.Population(population.Encoding, population.Field, NIND) # 存储试验种群 experimentPop.Chrom = ea.mutgau(population.Encoding, population.Chrom, population.Field, 1, Sigma3) # 高斯变异 self.call_aimFunc(experimentPop) # 计算目标函数值 tempPop = population + experimentPop # 临时合并,以调用otos进行一对一生存者选择 tempPop.FitnV = ea.scaling(tempPop.ObjV, tempPop.CV, self.problem.maxormins) # 计算适应度 chooseIdx = ea.selecting('otos', tempPop.FitnV, NIND) # 采用One-to-One Survivor选择 population = tempPop[chooseIdx] # 产生新一代种群 # 利用1/5规则调整变异压缩概率 successfulRate = len(np.where(chooseIdx >= NIND)[0]) / (2 * NIND) if successfulRate < 1/5: Sigma3 *= 0.817 elif successfulRate > 1/5: Sigma3 /= 0.817 return self.finishing(population) # 调用finishing完成后续工作并返回结果
def run(self, prophetPop=None): # prophetPop为先知种群(即包含先验知识的种群) # ==========================初始化配置=========================== population = self.population NIND = population.sizes self.initialization() # 初始化算法类的一些动态参数 # ===========================准备进化============================ population.initChrom(NIND) # 初始化种群染色体矩阵 # 插入先验知识(注意:这里不会对先知种群prophetPop的合法性进行检查) if prophetPop is not None: population = (prophetPop + population)[:NIND] # 插入先知种群 self.call_aimFunc(population) # 计算种群的目标函数值 population.FitnV = ea.scaling(population.ObjV, population.CV, self.problem.maxormins) # 计算适应度 Sigma3 = np.random.rand(population.sizes, population.Lind) * ( population.Field[1, :] - population.Field[0, :]) * 0.5 # 初始化高斯变异算子的Sigma3 # ===========================开始进化============================ while not self.terminated(population): # 选择 choose_index = ea.selecting(self.selFunc, population.FitnV, self.NSel) offspring = population[choose_index] offspring_Sigma3 = Sigma3[choose_index] # 进行进化操作 offspring.Chrom = self.recOper.do(offspring.Chrom) # 重组 offspring_Sigma3 = self.recOper.do(offspring_Sigma3) # 对offspring_Sigma3进行重组 for i in range(len(choose_index)): offspring.Chrom[i, :] = ea.mutgau(offspring.Encoding, offspring.Chrom[i, :].reshape(1, -1), offspring.Field, 1, offspring_Sigma3[i]).reshape(-1) # 高斯变异 self.call_aimFunc(offspring) # 计算目标函数值 population = population + offspring # 父子合并 Sigma3 = np.vstack([Sigma3, offspring_Sigma3]) population.FitnV = ea.scaling(population.ObjV, population.CV, self.problem.maxormins) # 计算适应度 # 得到新一代种群 choose_index = ea.selecting('dup', population.FitnV, NIND) # 采用基于适应度排序的直接复制选择 population = population[choose_index] Sigma3 = Sigma3[choose_index] return self.finishing(population) # 调用finishing完成后续工作并返回结果
def 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 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 # 记录评价次数 Sigma = 0.5 * (population.Field[1, :] - population.Field[0, :]) / 3 # 初始化高斯变异的Sigma #===========================开始进化============================ while self.terminated(population) == False: # 进行进化操作 experimentPop = population.copy() # 存储试验种群 experimentPop.Chrom = ea.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 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 run(self, prophetPop = None): # prophetPop为先知种群(即包含先验知识的种群) #==========================初始化配置=========================== population = self.population NIND = population.sizes self.initialization() # 初始化算法模板的一些动态参数 #===========================准备进化============================ if population.Chrom is None: population.initChrom(NIND) # 初始化种群染色体矩阵(内含染色体解码,详见Population类的源码) else: population.Phen = population.decoding() # 染色体解码 self.problem.aimFunc(population) # 计算种群的目标函数值 self.evalsNum = population.sizes # 记录评价次数 # 插入先验知识(注意:这里不会对先知种群prophetPop的合法性进行检查,故应确保prophetPop是一个种群类且拥有合法的Chrom、ObjV、Phen等属性) if prophetPop is not None: population = (prophetPop + population)[:NIND] # 插入先知种群 population.FitnV = ea.scaling(self.problem.maxormins * population.ObjV, population.CV) # 计算适应度 Sigma3 = 0.5 * (population.Field[1,:] - population.Field[0,:]) # 初始化高斯变异算子的Sigma3 #===========================开始进化============================ while self.terminated(population) == False: # 进行进化操作 experimentPop = population.copy() # 存储试验种群 experimentPop.Chrom = ea.mutgau(experimentPop.Encoding, experimentPop.Chrom, experimentPop.Field, 1, Sigma3) # 高斯变异 # 求进化后个体的目标函数值 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: Sigma3 *= 0.817 elif successfulRate > 1/5: Sigma3 /= 0.817 return self.finishing(population) # 调用finishing完成后续工作并返回结果
def awGA_templet(AIM_M, AIM_F, PUN_M, PUN_F, ranges, borders, precisions, maxormin, MAXGEN, MAXSIZE, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, drawing=1): """ awGA_templet.py - 基于awGA的多目标优化编程模板 语法: 该函数除了参数drawing外,不设置可缺省参数。 当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: awGA_templet(AIM_M, 'aimfuc', None, None, ..., maxormin) 输入参数: AIM_M - 目标函数的地址,传入该函数前通常由AIM_M = __import__('目标函数名')语句得到 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,传入该函数前通常由PUN_M = __import__('罚函数名')语句得到 PUN_F : str - 罚函数名 ranges : array - 代表自变量的范围矩阵,要求上界必须大于下界 例如:[[1, 2, 3], [3, 4, 5]] 表示有3个控制变量,其范围分别是1-3, 2-4, 3-5 borders : list -(可选参数)代表是否包含变量范围的边界,为1代表控制变量的范围包含该边界 当为None时,默认设置为全是1的矩阵 例如:[[1, 0, 1], [0, 1, 1]] 表示上面的三个控制变量的范围分别是:[1, 3)、(2, 4]、[3, 5] precisions : list -(可选参数)代表控制变量的精度, 如等于4,表示对应的控制变量的编码可以精确到小数点后4位。 当precisions为None时,默认precision为1*n的0矩阵(此时表示种群是离散编码的) precision的元素必须不小于0 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 MAXSIZE : int - 帕累托最优集最大规模 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,表示子代与父代染色体及性状不相同的概率 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图,2表示绘制进化过程的动画。 默认drawing为1 算法描述: 本模板实现了基于适应性权重聚合法(awGA)的多目标优化搜索, 通过维护一个全局帕累托最优集来实现帕累托前沿的搜索,故并不需要保证种群所有个体都是非支配的 """ #==========================初始化配置=========================== # 获取目标函数和罚函数 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])) ax = None start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): if NDSet.shape[0] > MAXSIZE: break [CombinObjV, weight] = ga.awGA(maxormin * ObjV) # 计算适应性权重以及多目标的加权单目标 FitnV = ga.ranking(maxormin * CombinObjV) # 根据加权单目标计算适应度 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, repnum] = ga.upNDSet(FitnV, maxormin * ObjV, maxormin * NDSet) # 进行遗传操作!! 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) #重插入 if drawing == 2: ax = ga.frontplot(NDSet, False, ax, gen + 1) # 绘制动态图 end_time = time.time() # 结束计时 #=========================绘图及输出结果========================= if drawing != 0: ga.frontplot(NDSet, True) times = end_time - start_time print('用时:' + str(times) + '秒') print('帕累托前沿点个数:' + str(NDSet.shape[0]) + '个') print('单位时间找到帕累托前沿点个数:' + str(NDSet.shape[0] // times) + '个') # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, end_time - start_time]
def moea_q_sorted_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDR, problem, maxormin, MAXGEN, MAXSIZE, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, distribute, drawing = 1): """ moea_q_sorted_templet.py - 基于快速非支配排序法求解多目标优化问题的进化算法模板 语法: 该函数除参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: moea_q_sorted_templet(AIM_M, 'aimfuc', None, None, ..., maxormin,...) 输入参数: AIM_M - 目标函数的地址,由AIM_M = __import__('目标函数所在文件名')语句得到 目标函数规范定义:[f,LegV] = aimfuc(Phen,LegV) 其中Phen是种群的表现型矩阵, LegV为种群的可行性列向量,f为种群的目标函数值矩阵 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,由PUN_M = __import__('罚函数所在文件名')语句得到 罚函数规范定义: newFitnV = punishing(LegV, FitnV) 其中LegV为种群的可行性列向量, FitnV为种群个体适应度列向量 一般在罚函数中对LegV为0的个体进行适应度惩罚,返回修改后的适应度列向量newFitnV PUN_F : str - 罚函数名 FieldDR : array - 实际值种群区域描述器 [lb; (float) 指明每个变量使用的下界 ub] (float) 指明每个变量使用的上界 注:不需要考虑是否包含变量的边界值。在crtfld中已经将是否包含边界值进行了处理 本函数生成的矩阵的元素值在FieldDR的[下界, 上界)之间 problem : str - 表明是整数问题还是实数问题,'I'表示是整数问题,'R'表示是实数问题 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 MAXSIZE : int - 帕累托最优集最大规模,当设为np.inf(无穷)时,模板不对帕累托最优解集规模作限制 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,表示子代与父代染色体及性状不相同的概率 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 distribute : bool - 是否增强帕累托前沿的分布性(可能会造成收敛慢或帕累托前沿数目减少) drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图,2表示绘制进化过程的动画。 默认drawing为1 算法描述: 本模板维护一个全局帕累托最优集来实现帕累托前沿的搜索 利用快速非支配排序寻找每一代种群的非支配个体,并用它来不断更新全局帕累托最优集, 故并不需要保证种群所有个体都是非支配的 模板使用注意: 1.本模板调用的目标函数形如:[ObjV,LegV] = aimfuc(Phen,LegV), 其中Phen表示种群的表现型矩阵, LegV为种群的可行性列向量(详见Geatpy数据结构) 2.本模板调用的罚函数形如: newFitnV = punishing(LegV, FitnV), 其中FitnV为用其他算法求得的适应度 若不符合上述规范,则请修改算法模板或自定义新算法模板 3.关于'maxormin': geatpy的内核函数全是遵循“最小化目标”的约定的,即目标函数值越小越好。 当需要优化最大化的目标时,需要设置'maxormin'为-1。 本算法模板是正确使用'maxormin'的典型范例,其具体用法如下: 当调用的函数传入参数包含与“目标函数值矩阵”有关的参数(如ObjV,ObjVSel,NDSetObjV等)时, 查看该函数的参考资料(可用'help'命令查看,也可到官网上查看相应的教程), 里面若要求传入前对参数乘上'maxormin',则需要乘上。 里面若要求对返回参数乘上'maxormin'进行还原, 则调用函数返回得到的相应参数需要乘上'maxormin'进行还原,否则其正负号就会被改变。 """ #==========================初始化配置=========================== # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 #=========================开始遗传算法进化======================= if problem == 'R': Chrom = ga.crtrp(NIND, FieldDR) # 生成实数值种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDR) # 生成整数值种群 LegV = np.ones((NIND, 1)) # 初始化种群的可行性列向量 [ObjV, LegV] = aimfuc(Chrom, LegV) # 计算种群目标函数值 NDSet = np.zeros((0, Chrom.shape[1])) # 定义帕累托最优解记录器 NDSetObjV = np.zeros((0, ObjV.shape[1])) # 定义帕累托最优解的目标函数值记录器 ax = None # 存储上一帧动画 start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): # 求种群的非支配个体以及基于被支配数的适应度 [FitnV, frontIdx] = ga.ndominfast(maxormin * ObjV, LegV) if PUN_F is not None: FitnV = punishing(LegV, FitnV) # 调用罚函数作进一步的惩罚 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, NDSetObjV, repnum] = ga.upNDSet(Chrom, maxormin * ObjV, FitnV, NDSet, maxormin * NDSetObjV, frontIdx, LegV) NDSetObjV *= maxormin # 还原在传入upNDSet函数前被最小化处理过的NDSetObjV [NDSet, NDSetObjV] = ga.redisNDSet(NDSet, NDSetObjV, NDSetObjV.shape[1] * MAXSIZE) # 利用拥挤距离选择帕累托前沿的子集,在进化过程中最好比上限多筛选出几倍的点集 if distribute == True: # 若要增强种群的分布性(可能会导致帕累托前沿搜索效率降低) # 计算每个目标下相邻个体的距离(不需要严格计算欧氏距离) for i in range(ObjV.shape[1]): idx = np.argsort(ObjV[:, i], 0) dis = np.diff(ObjV[idx, i]) / (np.max(ObjV[idx, i]) - np.min(ObjV[idx, i]) + 1) # 差分计算距离的偏移量占比,即偏移量除以目标函数的极差。加1是为了避免极差为0 dis = np.hstack([dis, dis[-1]]) FitnV[idx, 0] *= np.exp(dis) # 根据相邻距离修改适应度,突出相邻距离大的个体,以增加种群的多样性 # 进行遗传操作!! SelCh=ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh=ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) #交叉 if problem == 'R': SelCh=ga.mutbga(SelCh,FieldDR, pm) # 变异 if repnum > Chrom.shape[0] * 0.01: # 当最优个体重复率高达1%时,进行一次高斯变异 SelCh=ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 elif problem == 'I': SelCh=ga.mutint(SelCh, FieldDR, pm) LegVSel = np.ones((SelCh.shape[0], 1)) # 初始化育种种群的可行性列向量 [ObjVSel, LegVSel] = aimfuc(SelCh, LegVSel) # 求育种个体的目标函数值 # 求种群的非支配个体以及基于被支配数的适应度 [FitnVSel, frontIdx] = ga.ndominfast(maxormin * ObjVSel, LegVSel) if PUN_F is not None: FitnVSel = punishing(LegVSel, FitnVSel) # 调用罚函数作进一步的惩罚 [Chrom,ObjV,LegV] = ga.reins(Chrom,SelCh,SUBPOP,1,0.9,FitnV,FitnVSel,ObjV,ObjVSel,LegV,LegVSel) #重插入 if drawing == 2: ax = ga.frontplot(NDSetObjV, False, ax, gen + 1) # 绘制动态图 end_time = time.time() # 结束计时 [NDSet, NDSetObjV] = ga.redisNDSet(NDSet, NDSetObjV, MAXSIZE) # 最后根据拥挤距离选择均匀分布的点 #=========================绘图及输出结果========================= if drawing != 0: ga.frontplot(NDSetObjV,True) times = end_time - start_time print('用时:%s 秒'%(times)) print('帕累托前沿点个数:%s 个'%(NDSet.shape[0])) print('单位时间找到帕累托前沿点个数:%s 个'%(int(NDSet.shape[0] // times))) # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, NDSetObjV, end_time - start_time]
def nsga2_templet(AIM_M, AIM_F, PUN_M, PUN_F, ranges, borders, precisions, maxormin, MAXGEN, MAXSIZE, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, drawing = 1): """ nsga2_templet.py - 基于改进NSGA-Ⅱ算法求解多目标优化问题编程模板 语法: 该函数除参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: nsga2_templet(AIM_M, 'aimfuc', None, None, ..., maxormin) 输入参数: AIM_M - 目标函数的地址,传入该函数前通常由AIM_M = __import__('目标函数名')语句得到 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,传入该函数前通常由PUN_M = __import__('罚函数名')语句得到 PUN_F : str - 罚函数名 ranges : array - 代表自变量的范围矩阵,要求上界必须大于下界 例如:[[1, 2, 3], [3, 4, 5]] 表示有3个控制变量,其范围分别是1-3, 2-4, 3-5 borders : list -(可选参数)代表是否包含变量范围的边界,为1代表控制变量的范围包含该边界 当为None时,默认设置为全是1的矩阵 例如:[[1, 0, 1], [0, 1, 1]] 表示上面的三个控制变量的范围分别是:[1, 3)、(2, 4]、[3, 5] precisions : list -(可选参数)代表控制变量的精度, 如等于4,表示对应的控制变量的编码可以精确到小数点后4位。 当precisions为None时,默认precision为1*n的0矩阵(此时表示种群是离散编码的) precision的元素必须不小于0 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 MAXSIZE : int - 帕累托最优集最大规模 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,本模板中该参数为无用参数,仅为了兼容同类模板而设 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图,2表示绘制进化过程的动画。 默认drawing为1 算法描述: 传统NSGA-Ⅱ算法的帕累托最优解来只源于当代种群个体,这样难以高效地获取更多的帕累托最优解 同时难以把种群大小控制在合适的范围内, 改进的NSGA2整体上沿用传统的NSGA-Ⅱ算法, 不同的是,该算法通过维护一个全局帕累托最优集来实现帕累托前沿的搜索, 故并不需要保证种群所有个体都是非支配的。 值得注意的是: 尽管当全局帕累托最优集大小比种群规模大时,算法的时间复杂度比原NSGA-Ⅱ算法要高, 但算法整体的时间复杂度要低与原NSGA-Ⅱ算法, 因此单位时间内生成的无重复帕累托最优解个数要多于原NSGA-Ⅱ算法 """ # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 #==========================初始化配置=========================== GGAP = 0.5 # 为了避免父子两代合并后种群数量爆炸,要让代沟为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])) # 定义帕累托最优解集合(初始为空集) ax = None start_time = time.time() # 开始计时 [FitnV, levels] = ga.ndomindeb(maxormin * ObjV, 1) # deb非支配分级 if PUN_F is not None: FitnV = punishing(Chrom, FitnV) # 调用罚函数 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] > MAXSIZE: 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] = ga.ndomindeb(maxormin * ObjV, 1) # deb非支配分级 if PUN_F is not None: FitnV = punishing(Chrom, FitnV) # 调用罚函数 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) # 选择出下一代 if drawing == 2: ax = ga.frontplot(NDSet, False, ax, gen + 1) # 绘制动态图 end_time = time.time() # 结束计时 #=========================绘图及输出结果========================= if drawing != 0: ga.frontplot(NDSet,True) times = end_time - start_time print('用时:' + str(times) + '秒') print('帕累托前沿点个数:' + str(NDSet.shape[0]) + '个') print('单位时间找到帕累托前沿点个数:' + str(NDSet.shape[0] // times) + '个') # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, times]
def sga_mps_real_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDRs, problem, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, drawing=1): """ sga_mps_real_templet.py - 基于多种群独立进化单目标编程模板(实值编码) 基于多种群独立进化单目标编程模板(实值编码),各种群独立将父子两代合并进行选择,采取精英保留机制 语法: 该函数除了drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: sga_mps_real_templet(AIM_M, 'aimfuc', None, None, ..., maxormin) 输入参数: AIM_M - 目标函数的地址,由AIM_M = __import__('目标函数所在文件名')语句得到 目标函数规范定义:f = aimfuc(Phen) 其中Phen是种群的表现型矩阵 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,由PUN_M = __import__('罚函数所在文件名')语句得到 罚函数规范定义: f = punishing(Phen, FitnV) 其中Phen是种群的表现型矩阵, FitnV为种群个体适应度列向量 PUN_F : str - 罚函数名 FieldDR : array - 实际值种群区域描述器 [lb; (float) 指明每个变量使用的下界 ub] (float) 指明每个变量使用的上界 注:不需要考虑是否包含变量的边界值。在crtfld中已经将是否包含边界值进行了处理 本函数生成的矩阵的元素值在FieldDR的[下界, 上界)之间 problem : str - 表明是整数问题还是实数问题,'I'表示是整数问题,'R'表示是实数问题 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,本模板中该参数为无用参数,仅为了兼容同类的其他模板而设 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图。默认drawing为1 输出参数: pop_trace : array - 种群进化记录器(进化追踪器), 第0列记录着各代种群最优个体的目标函数值 第1列记录着各代种群的适应度均值 第2列记录着各代种群最优个体的适应度值 var_trace : array - 变量记录器,记录着各代种群最优个体的变量值,每一列对应一个控制变量 times : float - 进化所用时间 模板使用注意: 1.本模板调用的目标函数形如:aimfuc(Phen), 其中Phen表示种群的表现型矩阵 2.本模板调用的罚函数形如: punishing(Phen, FitnV), 其中FitnV为用其他算法求得的适应度 在罚函数定义中,必须将不满足约束条件的个体对应的适应度设为0,否则请修改模板使用 """ #==========================初始化配置===========================""" GGAP = 0.5 # 因为父子合并后选择,因此要将代沟设为0.5以维持种群规模 # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 exIdx = np.array([]) # 存储非可行解的下标 NVAR = FieldDRs[0].shape[1] # 得到控制变量的个数 # 定义全局进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) pop_trace[:, 0] = 0 # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN, NVAR)) * np.nan) """=========================开始遗传算法进化=======================""" start_time = time.time() # 开始计时 # 对于各个网格分别进行进化,采用全局进化记录器记录最优值 for index in range(len(FieldDRs)): FieldDR = FieldDRs[index] if problem == 'R': Chrom = ga.crtrp(NIND, FieldDR) # 生成初始种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDR) repnum = 0 # 初始化重复个体数为0 # 开始进化!! for gen in range(MAXGEN): # 进行遗传算子,生成子代 SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) # 重组 if problem == 'R': SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 if repnum > Chrom.shape[0] * 0.01: # 当最优个体重复率高达1%时,进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 elif problem == 'I': SelCh = ga.mutint(SelCh, FieldDR, pm) Chrom = np.vstack([Chrom, SelCh]) # 父子合并 ObjV = aimfuc(Chrom) # 求后代的目标函数值 FitnV = ga.ranking(maxormin * ObjV, None, SUBPOP) # 适应度评价 if PUN_F is not None: [FitnV, exIdx] = punishing(Chrom, FitnV) # 调用罚函数 repnum = len( np.where(ObjV[np.argmax(FitnV)] == ObjV)[0]) # 计算最优个体重复数 # 记录进化过程 bestIdx = np.argmax(FitnV) wrongSign = np.ones((FitnV.shape[0], 1)) wrongSign[list(exIdx)] = 0 # 对非可行解作标记 if FitnV[bestIdx] != 0: if (np.isnan(pop_trace[gen, 1])) or ( (maxormin == 1) & (pop_trace[gen, 1] >= ObjV[bestIdx])) or ( (maxormin == -1) & (pop_trace[gen, 1] <= ObjV[bestIdx])): feasible = np.where(wrongSign != 0)[0] # 排除非可行解 pop_trace[gen, 0] += np.sum( ObjV[feasible]) / ObjV[feasible].shape[0] / len( FieldDRs) # 记录种群个体平均目标函数值 pop_trace[gen, 1] = ObjV[bestIdx] # 记录当代目标函数的最优值 var_trace[gen, :] = Chrom[bestIdx, :] # 记录当代最优的控制变量值 Chrom = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 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) # 绘图 if drawing == 1: ga.trcplot(pop_trace, [['种群个体平均目标函数值', '种群最优个体目标函数值']]) # 输出结果 if maxormin == 1: best_gen = np.argmin(pop_trace[:, 1]) # 记录最优种群是在哪一代 print('最优的目标函数值为:', np.min(pop_trace[:, 1])) elif maxormin == -1: best_gen = np.argmax(pop_trace[:, 1]) # 记录最优种群是在哪一代 print('最优的目标函数值为:', np.max(pop_trace[:, 1])) print('最优的控制变量值为:') for i in range(NVAR): print(var_trace[best_gen, i]) print('最优的一代是第', best_gen + 1, '代') times = end_time - start_time print('时间已过', times, '秒') # 返回进化记录器、变量记录器以及执行时间 return [pop_trace, var_trace, times]
def moea_nsga2_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDR, problem, maxormin, MAXGEN, MAXSIZE, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, distribute, drawing=1): """ moea_nsga2_templet.py - 基于改进NSGA-Ⅱ算法求解多目标优化问题的进化算法模板 语法: 该函数除参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: moea_nsga2_templet(AIM_M, 'aimfuc', None, None, ..., maxormin,...) 输入参数: AIM_M - 目标函数的地址,由AIM_M = __import__('目标函数所在文件名')语句得到 目标函数规范定义:[f,LegV] = aimfuc(Phen,LegV) 其中Phen是种群的表现型矩阵, LegV为种群的可行性列向量,f为种群的目标函数值矩阵 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,由PUN_M = __import__('罚函数所在文件名')语句得到 罚函数规范定义: newFitnV = punishing(LegV, FitnV) 其中LegV为种群的可行性列向量, FitnV为种群个体适应度列向量 一般在罚函数中对LegV为0的个体进行适应度惩罚,返回修改后的适应度列向量newFitnV PUN_F : str - 罚函数名 FieldDR : array - 实际值种群区域描述器 [lb; (float) 指明每个变量使用的下界 ub] (float) 指明每个变量使用的上界 注:不需要考虑是否包含变量的边界值。在crtfld中已经将是否包含边界值进行了处理 本函数生成的矩阵的元素值在FieldDR的[下界, 上界)之间 problem : str - 表明是整数问题还是实数问题,'I'表示是整数问题,'R'表示是实数问题 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 MAXSIZE : int - 帕累托最优集最大规模,当设为np.inf(无穷)时,模板不对帕累托最优解集规模作限制 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,本模板中该参数为无用参数,仅为了兼容同类模板而设 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 distribute : bool - 是否增强帕累托前沿的分布性(可能会造成收敛慢或帕累托前沿数目减少) drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图,2表示绘制进化过程的动画。 默认drawing为1 算法描述: 传统NSGA-Ⅱ算法的帕累托最优解来只源于当代种群个体,这样难以高效地获取更多的帕累托最优解 同时难以把种群大小控制在合适的范围内, 改进的NSGA2整体上沿用传统的NSGA-Ⅱ算法, 不同的是,该算法通过维护一个全局帕累托最优集来实现帕累托前沿的搜索, 故并不需要保证种群所有个体都是非支配的。 值得注意的是: 尽管当全局帕累托最优集大小比种群规模大时,算法的时间复杂度比原NSGA-Ⅱ算法要高, 但算法整体的时间复杂度要低与原NSGA-Ⅱ算法, 因此单位时间内生成的无重复帕累托最优解个数要多于原NSGA-Ⅱ算法 模板使用注意: 1.本模板调用的目标函数形如:[ObjV,LegV] = aimfuc(Phen,LegV), 其中Phen表示种群的表现型矩阵, LegV为种群的可行性列向量(详见Geatpy数据结构) 2.本模板调用的罚函数形如: newFitnV = punishing(LegV, FitnV), 其中FitnV为用其他算法求得的适应度 若不符合上述规范,则请修改算法模板或自定义新算法模板 3.关于'maxormin': geatpy的内核函数全是遵循“最小化目标”的约定的,即目标函数值越小越好。 当需要优化最大化的目标时,需要设置'maxormin'为-1。 本算法模板是正确使用'maxormin'的典型范例,其具体用法如下: 当调用的函数传入参数包含与“目标函数值矩阵”有关的参数(如ObjV,ObjVSel,NDSetObjV等)时, 查看该函数的参考资料(可用'help'命令查看,也可到官网上查看相应的教程), 里面若要求传入前对参数乘上'maxormin',则需要乘上。 里面若要求对返回参数乘上'maxormin'进行还原, 则调用函数返回得到的相应参数需要乘上'maxormin'进行还原,否则其正负号就会被改变。 """ # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 #==========================初始化配置=========================== GGAP = 0.5 # 为了避免父子两代合并后种群数量爆炸,要让代沟为0.5 # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 #=========================开始遗传算法进化======================= if problem == 'R': Chrom = ga.crtrp(NIND, FieldDR) # 生成实数值种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDR) # 生成整数值种群 LegV = np.ones((NIND, 1)) # 初始化可行性列向量 [ObjV, LegV] = aimfuc(Chrom, LegV) # 计算种群目标函数值 NDSet = np.zeros((0, Chrom.shape[1])) # 定义帕累托最优解集合(初始为空集) NDSetObjV = np.zeros((0, ObjV.shape[1])) # 定义帕累托最优解对应的目标函数集合(初始为空集) ax = None # 存储上一桢动画 start_time = time.time() # 开始计时 # 计算初代 [FitnV, levels] = ga.ndomindeb(maxormin * ObjV, 1, LegV) # deb非支配分级 frontIdx = np.where(levels == 1)[0] # 处在第一级的个体即为种群的非支配个体 if PUN_F is not None: FitnV = punishing(LegV, FitnV) # 调用罚函数 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, NDSetObjV, repnum] = ga.upNDSet(Chrom, maxormin * ObjV, FitnV, NDSet, maxormin * NDSetObjV, frontIdx, LegV) NDSetObjV *= maxormin # 还原在传入upNDSet函数前被最小化处理过的NDSetObjV [NDSet, NDSetObjV] = ga.redisNDSet( NDSet, NDSetObjV, NDSetObjV.shape[1] * MAXSIZE) # 利用拥挤距离选择帕累托前沿的子集,在进化过程中最好比上限多筛选出几倍的点集 # 开始进化!! for gen in range(MAXGEN): # 进行遗传操作!! SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) #交叉 if problem == 'R': SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 if repnum >= Chrom.shape[0] * 0.01: # 当最优个体重复率高达1%时,进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 elif problem == 'I': SelCh = ga.mutint(SelCh, FieldDR, pm) [ObjVSel, LegVSel] = aimfuc(SelCh, LegV) # 求育种个体的目标函数值 # 父子合并 Chrom = np.vstack([Chrom, SelCh]) ObjV = np.vstack([ObjV, ObjVSel]) LegV = np.vstack([LegV, LegVSel]) [FitnV, levels] = ga.ndomindeb(maxormin * ObjV, 1, LegV) # deb非支配分级 frontIdx = np.where(levels == 1)[0] # 处在第一级的个体即为种群的非支配个体 if PUN_F is not None: FitnV = punishing(LegV, FitnV) # 调用罚函数 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, NDSetObjV, repnum] = ga.upNDSet(Chrom, maxormin * ObjV, FitnV, NDSet, maxormin * NDSetObjV, frontIdx, LegV) NDSetObjV *= maxormin # 还原在传入upNDSet函数前被最小化处理过的NDSetObjV [NDSet, NDSetObjV ] = ga.redisNDSet(NDSet, NDSetObjV, NDSetObjV.shape[1] * MAXSIZE) # 利用拥挤距离选择帕累托前沿的子集,在进化过程中最好比上限多筛选出几倍的点集 if distribute == True: # 若要增强种群的分布性(可能会导致帕累托前沿搜索效率降低) # 计算每个目标下相邻个体的距离(不需要严格计算欧氏距离) for i in range(ObjV.shape[1]): idx = np.argsort(ObjV[:, i], 0) dis = np.diff(ObjV[idx, i]) / ( np.max(ObjV[idx, i]) - np.min(ObjV[idx, i]) + 1 ) # 差分计算距离的偏移量占比,即偏移量除以目标函数的极差。加1是为了避免极差为0 dis = np.hstack([dis, dis[-1]]) FitnV[idx, 0] *= np.exp(dis) # 根据相邻距离修改适应度,突出相邻距离大的个体,以增加种群的多样性 [Chrom, ObjV, LegV] = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP, ObjV, LegV) # 选择出下一代 if drawing == 2: ax = ga.frontplot(NDSetObjV, False, ax, gen + 1) # 绘制动态图 end_time = time.time() # 结束计时 [NDSet, NDSetObjV] = ga.redisNDSet(NDSet, NDSetObjV, MAXSIZE) # 最后根据拥挤距离选择均匀分布的点 #=========================绘图及输出结果========================= if drawing != 0: ga.frontplot(NDSetObjV, True) times = end_time - start_time print('用时:', times, '秒') print('帕累托前沿点个数:', NDSet.shape[0], '个') print('单位时间找到帕累托前沿点个数:', int(NDSet.shape[0] // times), '个') # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, NDSetObjV, times]
def q_sorted_new_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDR, problem, maxormin, MAXGEN, MAXSIZE, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, distribute, drawing=1): """ q_sorted_new_templet.py - 基于改进的快速非支配排序法求解多目标优化问题的进化算法模板 语法: 该函数除参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: q_sorted_new_templet(AIM_M, 'aimfuc', None, None, ..., maxormin,...) 输入参数: AIM_M - 目标函数的地址,由AIM_M = __import__('目标函数所在文件名')语句得到 目标函数规范定义:f = aimfuc(Phen) 其中Phen是种群的表现型矩阵 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,由PUN_M = __import__('罚函数所在文件名')语句得到 罚函数规范定义: f = punishing(Phen, FitnV) 其中Phen是种群的表现型矩阵, FitnV为种群个体适应度列向量 PUN_F : str - 罚函数名 FieldDR : array - 实际值种群区域描述器 [lb; (float) 指明每个变量使用的下界 ub] (float) 指明每个变量使用的上界 注:不需要考虑是否包含变量的边界值。在crtfld中已经将是否包含边界值进行了处理 本函数生成的矩阵的元素值在FieldDR的[下界, 上界)之间 problem : str - 表明是整数问题还是实数问题,'I'表示是整数问题,'R'表示是实数问题 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 MAXSIZE : int - 帕累托最优集最大规模 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,本模板中该参数为无用参数,仅为了兼容同类模板而设 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 distribute : bool - 是否增强帕累托前沿的分布性(可能会造成收敛慢或帕累托前沿数目减少) drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图,2表示绘制进化过程的动画。 默认drawing为1 算法描述: 本模板维护一个全局帕累托最优集来实现帕累托前沿的搜索 利用改进快速非支配排序寻找每一代种群的非支配个体,并用它来不断更新全局帕累托最优集, 改进之处是在进化过程中将父代和子代合并再进行选择,从而实现了经营保留策略 故并不需要保证种群所有个体都是非支配的 模板使用注意: 1.本模板调用的目标函数形如:ObjV = aimfuc(Phen), 其中Phen表示种群的表现型矩阵 2.本模板调用的罚函数形如: [newFitnV, exIdx] = punishing(Phen, FitnV), 其中FitnV为用其他算法求得的适应度, exIdx为罚函数所找到的不符合约束条件的个体下标行向量 若不符合上述规范,则请修改模板或自定义新模板 """ #==========================初始化配置=========================== # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 GGAP = 0.5 # 为了避免父子两代合并后种群数量爆炸,要让代沟为0.5 ax = None # 用于存储图形 exIdx = np.array([]) # 非可行解的下标 #=========================开始遗传算法进化======================= if problem == 'R': Chrom = ga.crtrp(NIND, FieldDR) # 生成实数值种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDR) # 生成整数值种群 ObjV = aimfuc(Chrom) # 计算种群目标函数值 FitnV = np.ones((ObjV.shape[0], 1)) # 初始化适应度(仅是为了使调用罚函数时符合罚函数定义的参数列表) if PUN_F is not None: [FitnV, exIdx] = punishing(Chrom, FitnV) # 调用罚函数,不满足约束条件的个体适应度被设为0 NDSet = np.zeros((0, Chrom.shape[1])) # 定义帕累托最优解集合(初始为空集) NDSetObjV = np.zeros((0, ObjV.shape[1])) # 定义帕累托最优解对应的目标函数集合(初始为空集) start_time = time.time() # 开始计时 [FitnV, frontIdx] = ga.ndominfast(maxormin * ObjV, exIdx) # 快速非支配排序,一定要传入FitnV从而对排除考虑不满足约束条件的解 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, NDSetObjV, repnum] = ga.upNDSet(Chrom, maxormin * ObjV, FitnV, NDSet, maxormin * NDSetObjV, frontIdx, exIdx) # 开始进化!! for gen in range(MAXGEN): if NDSet.shape[0] > MAXSIZE: NDSet = NDSet[0:MAXSIZE, :] NDSetObjV = NDSetObjV[0:MAXSIZE, :] break # 进行遗传操作!! SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) #交叉 if problem == 'R': SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 if repnum >= Chrom.shape[0] * 0.01: # 当最优个体重复率高达1%时,进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 elif problem == 'I': SelCh = ga.mutint(SelCh, FieldDR, pm) # 父子合并 Chrom = np.vstack([Chrom, SelCh]) ObjV = aimfuc(Chrom) # 求目标函数值 FitnV = np.ones( (ObjV.shape[0], 1)) # 初始化FitnV(仅是为了使调用罚函数时符合罚函数定义的参数列表) if PUN_F is not None: [FitnV, exIdx] = punishing(Chrom, FitnV) # 调用罚函数 ga.ndomin(maxormin * ObjV, exIdx) [FitnV, frontIdx] = ga.ndominfast(maxormin * ObjV, exIdx) # 快速非支配排序 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, NDSetObjV, repnum] = ga.upNDSet(Chrom, maxormin * ObjV, FitnV, NDSet, maxormin * NDSetObjV, frontIdx, exIdx) if distribute == True: # 若要增强帕累托解集的分布性 # 计算每个目标下个体的聚集距离(不需要严格计算欧氏距离,计算绝对值即可) 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]]) dis = dis + np.min(dis) FitnV[idx, 0] *= np.exp(dis) # 根据聚集距离修改适应度,以增加种群的多样性 Chrom = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择出下一代 if drawing == 2: ax = ga.frontplot(NDSetObjV, False, ax, gen + 1) # 绘制动态图 end_time = time.time() # 结束计时 #=========================绘图及输出结果========================= if drawing != 0: ga.frontplot(NDSetObjV, True) times = end_time - start_time print('用时:', times, '秒') print('帕累托前沿点个数:', NDSet.shape[0], '个') print('单位时间找到帕累托前沿点个数:', int(NDSet.shape[0] // times), '个') # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, NDSetObjV, times]
def q_sorted_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDR, problem, maxormin, MAXGEN, MAXSIZE, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, distribute, drawing=1): """ q_sorted_templet.py - 基于快速非支配排序法求解多目标优化问题的进化算法模板 语法: 该函数除参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: q_sorted_templet(AIM_M, 'aimfuc', None, None, ..., maxormin,...) 输入参数: AIM_M - 目标函数的地址,由AIM_M = __import__('目标函数所在文件名')语句得到 目标函数规范定义:f = aimfuc(Phen) 其中Phen是种群的表现型矩阵 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,由PUN_M = __import__('罚函数所在文件名')语句得到 罚函数规范定义: f = punishing(Phen, FitnV) 其中Phen是种群的表现型矩阵, FitnV为种群个体适应度列向量 PUN_F : str - 罚函数名 FieldDR : array - 实际值种群区域描述器 [lb; (float) 指明每个变量使用的下界 ub] (float) 指明每个变量使用的上界 注:不需要考虑是否包含变量的边界值。在crtfld中已经将是否包含边界值进行了处理 本函数生成的矩阵的元素值在FieldDR的[下界, 上界)之间 problem : str - 表明是整数问题还是实数问题,'I'表示是整数问题,'R'表示是实数问题 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 MAXSIZE : int - 帕累托最优集最大规模 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,表示子代与父代染色体及性状不相同的概率 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 distribute : bool - 是否增强帕累托前沿的分布性(可能会造成收敛慢或帕累托前沿数目减少) drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图,2表示绘制进化过程的动画。 默认drawing为1 算法描述: 本模板维护一个全局帕累托最优集来实现帕累托前沿的搜索 利用快速非支配排序寻找每一代种群的非支配个体,并用它来不断更新全局帕累托最优集, 故并不需要保证种群所有个体都是非支配的 """ #==========================初始化配置=========================== # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 #=========================开始遗传算法进化======================= if problem == 'R': Chrom = ga.crtrp(NIND, FieldDR) # 生成实数值种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDR) # 生成整数值种群 ObjV = aimfuc(Chrom) # 计算种群目标函数值 NDSet = np.zeros((0, Chrom.shape[1])) # 定义帕累托最优解记录器 NDSetObjV = np.zeros((0, ObjV.shape[1])) # 定义帕累托最优解的目标函数值记录器 ax = None start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): if NDSet.shape[0] > MAXSIZE: break # 求种群的非支配个体以及基于被支配数的适应度 [FitnV, frontIdx] = ga.ndominfast(maxormin * ObjV) if PUN_F is not None: FitnV = punishing(Chrom, FitnV) # 调用罚函数 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, NDSetObjV, repnum] = ga.upNDSet(Chrom, maxormin * ObjV, FitnV, NDSet, maxormin * NDSetObjV, frontIdx) if distribute == True: # 若要增强帕累托解集的分布性 # 计算每个目标下个体的聚集距离(不需要严格计算欧氏距离,计算绝对值即可) 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]]) dis = dis + np.min(dis) FitnV[idx, 0] *= np.exp(dis) # 根据聚集距离修改适应度,以增加种群的多样性 # 进行遗传操作!! SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) #交叉 if problem == 'R': SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 if repnum > Chrom.shape[0] * 0.01: # 当最优个体重复率高达1%时,进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 elif problem == 'I': SelCh = ga.mutint(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) #重插入 if drawing == 2: ax = ga.frontplot(NDSetObjV, False, ax, gen + 1) # 绘制动态图 end_time = time.time() # 结束计时 #=========================绘图及输出结果========================= if drawing != 0: ga.frontplot(NDSetObjV, True) times = end_time - start_time print('用时:', times, '秒') print('帕累托前沿点个数:', NDSet.shape[0], '个') print('单位时间找到帕累托前沿点个数:', int(NDSet.shape[0] // times), '个') # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, NDSetObjV, end_time - start_time]
def sga_real_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDR, problem, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, distribute, drawing=1): """ sga_real_templet.py - 单目标编程模板(实值编码) 语法: 该函数除了参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: sga_real_templet(AIM_M, 'aimfuc', None, None, ..., maxormin) 输入参数: AIM_M - 目标函数的地址,由AIM_M = __import__('目标函数所在文件名')语句得到 目标函数规范定义:[f,LegV] = aimfuc(Phen,LegV) 其中Phen是种群的表现型矩阵, LegV为种群的可行性列向量,f为种群的目标函数值矩阵 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,由PUN_M = __import__('罚函数所在文件名')语句得到 罚函数规范定义: newFitnV = punishing(LegV, FitnV) 其中LegV为种群的可行性列向量, FitnV为种群个体适应度列向量 一般在罚函数中对LegV为0的个体进行适应度惩罚,返回修改后的适应度列向量newFitnV PUN_F : str - 罚函数名 FieldDR : array - 实际值种群区域描述器 [lb; (float) 指明每个变量使用的下界 ub] (float) 指明每个变量使用的上界 注:不需要考虑是否包含变量的边界值。在crtfld中已经将是否包含边界值进行了处理 本函数生成的矩阵的元素值在FieldDR的[下界, 上界)之间 problem : str - 表明是整数问题还是实数问题,'I'表示是整数问题,'R'表示是实数问题 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,表示子代与父代染色体及性状不相同的概率 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 distribute : bool - 是否增强种群的分布性(可能会造成收敛慢) drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图。默认drawing为1 输出参数: pop_trace : array - 种群进化记录器(进化追踪器), 第0列记录着各代种群最优个体的目标函数值 第1列记录着各代种群的适应度均值 第2列记录着各代种群最优个体的适应度值 var_trace : array - 变量记录器,记录着各代种群最优个体的变量值,每一列对应一个控制变量 times : float - 进化所用时间 模板使用注意: 1.本模板调用的目标函数形如:[ObjV,LegV] = aimfuc(Phen,LegV), 其中Phen表示种群的表现型矩阵, LegV为种群的可行性列向量(详见Geatpy数据结构) 2.本模板调用的罚函数形如: newFitnV = punishing(LegV, FitnV), 其中FitnV为用其他算法求得的适应度 若不符合上述规范,则请修改算法模板或自定义新算法模板 3.关于'maxormin': geatpy的内核函数全是遵循“最小化目标”的约定的,即目标函数值越小越好。 当需要优化最大化的目标时,需要设置'maxormin'为-1。 本算法模板是正确使用'maxormin'的典型范例,其具体用法如下: 当调用的函数传入参数包含与“目标函数值矩阵”有关的参数(如ObjV,ObjVSel,NDSetObjV等)时, 查看该函数的参考资料(可用'help'命令查看,也可到官网上查看相应的教程), 里面若要求传入前对参数乘上'maxormin',则需要乘上。 里面若要求对返回参数乘上'maxormin'进行还原, 则调用函数返回得到的相应参数需要乘上'maxormin'进行还原,否则其正负号就会被改变。 """ """==========================初始化配置===========================""" # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 NVAR = FieldDR.shape[1] # 得到控制变量的个数 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN, NVAR)) * np.nan) ax = None # 存储上一帧图形 repnum = 0 # 初始化重复个体数为0 """=========================开始遗传算法进化=======================""" if problem == 'R': Chrom = ga.crtrp(NIND, FieldDR) # 生成初始种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDR) LegV = np.ones((NIND, 1)) # 初始化种群的可行性列向量 [ObjV, LegV] = aimfuc(Chrom, LegV) # 求种群的目标函数值 gen = 0 badCounter = 0 # 用于记录在“遗忘策略下”被忽略的代数 # 开始进化!! start_time = time.time() # 开始计时 while gen < MAXGEN: if badCounter >= 10 * MAXGEN: # 若多花了10倍的迭代次数仍没有可行解出现,则跳出 break FitnV = ga.ranking(maxormin * ObjV, LegV, None, SUBPOP) if PUN_F is not None: FitnV = punishing(LegV, FitnV) # 调用罚函数 # 记录进化过程 bestIdx = np.argmax(FitnV) # 获取最优个体的下标 if LegV[bestIdx] != 0: feasible = np.where(LegV != 0)[0] # 排除非可行解 pop_trace[gen, 0] = np.sum( ObjV[feasible]) / ObjV[feasible].shape[0] # 记录种群个体平均目标函数值 pop_trace[gen, 1] = ObjV[bestIdx] # 记录当代目标函数的最优值 var_trace[gen, :] = Chrom[bestIdx, :] # 记录当代最优的控制变量值 repnum = len( np.where(ObjV[np.argmax(FitnV)] == ObjV)[0]) # 计算最优个体重复数 # 绘制动态图 if drawing == 2: ax = ga.sgaplot(pop_trace[:, [1]], '种群最优个体目标函数值', False, ax, gen) badCounter = 0 # badCounter计数器清零 else: gen -= 1 # 忽略这一代(遗忘策略) badCounter += 1 if distribute == True: # 若要增强种群的分布性(可能会造成收敛慢) idx = np.argsort(ObjV[:, 0], 0) dis = np.diff(ObjV[idx, 0]) / (np.max(ObjV[idx, 0]) - np.min( ObjV[idx, 0]) + 1) # 差分计算距离的修正偏移量 dis = np.hstack([dis, dis[-1]]) dis = dis + np.min(dis) # 修正偏移量+最小量=修正绝对量 FitnV[idx, 0] *= np.exp(dis) # 根据相邻距离修改适应度,突出相邻距离大的个体,以增加种群的多样性 # 进行遗传算子 SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) # 对所选个体进行重组 if problem == 'R': SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 if repnum > Chrom.shape[0] * 0.01: # 当最优个体重复率高达1%时,进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 elif problem == 'I': SelCh = ga.mutint(SelCh, FieldDR, pm) LegVSel = np.ones((SelCh.shape[0], 1)) # 初始化育种种群的可行性列向量 [ObjVSel, LegVSel] = aimfuc(SelCh, LegVSel) # 求育种种群的目标函数值 FitnVSel = ga.ranking(maxormin * ObjVSel, LegVSel, None, SUBPOP) # 计算育种种群的适应度 if PUN_F is not None: FitnVSel = punishing(LegVSel, FitnVSel) # 调用罚函数 # 重插入 [Chrom, ObjV, LegV] = ga.reins(Chrom, SelCh, SUBPOP, 1, 1, FitnV, FitnVSel, ObjV, ObjVSel, LegV, LegVSel) gen += 1 end_time = time.time() # 结束计时 times = end_time - start_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) if pop_trace.shape[0] == 0: raise RuntimeError('error: no feasible solution. (有效进化代数为0,没找到可行解。)') # 绘图 if drawing != 0: ga.trcplot(pop_trace, [['种群个体平均目标函数值', '种群最优个体目标函数值']]) # 输出结果 if maxormin == 1: best_gen = np.argmin(pop_trace[:, 1]) # 记录最优种群是在哪一代 best_ObjV = np.min(pop_trace[:, 1]) elif maxormin == -1: best_gen = np.argmax(pop_trace[:, 1]) # 记录最优种群是在哪一代 best_ObjV = np.max(pop_trace[:, 1]) print('最优的目标函数值为:%s' % (best_ObjV)) print('最优的控制变量值为:') for i in range(NVAR): print(var_trace[best_gen, i]) print('有效进化代数:%s' % (pop_trace.shape[0])) print('最优的一代是第 %s 代' % (best_gen + 1)) print('时间已过 %s 秒' % (times)) # 返回进化记录器、变量记录器以及执行时间 return [pop_trace, var_trace, times]
def nsga2_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDR, problem, maxormin, MAXGEN, MAXSIZE, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, distribute, drawing=1): """ nsga2_templet.py - 基于改进NSGA-Ⅱ算法求解多目标优化问题的进化算法模板 语法: 该函数除参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: nsga2_templet(AIM_M, 'aimfuc', None, None, ..., maxormin,...) 输入参数: AIM_M - 目标函数的地址,由AIM_M = __import__('目标函数所在文件名')语句得到 目标函数规范定义:f = aimfuc(Phen) 其中Phen是种群的表现型矩阵 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,由PUN_M = __import__('罚函数所在文件名')语句得到 罚函数规范定义: f = punishing(Phen, FitnV) 其中Phen是种群的表现型矩阵, FitnV为种群个体适应度列向量 PUN_F : str - 罚函数名 FieldDR : array - 实际值种群区域描述器 [lb; (float) 指明每个变量使用的下界 ub] (float) 指明每个变量使用的上界 注:不需要考虑是否包含变量的边界值。在crtfld中已经将是否包含边界值进行了处理 本函数生成的矩阵的元素值在FieldDR的[下界, 上界)之间 problem : str - 表明是整数问题还是实数问题,'I'表示是整数问题,'R'表示是实数问题 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 MAXSIZE : int - 帕累托最优集最大规模 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,本模板中该参数为无用参数,仅为了兼容同类模板而设 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 distribute : bool - 是否增强帕累托前沿的分布性(可能会造成收敛慢或帕累托前沿数目减少) drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图,2表示绘制进化过程的动画。 默认drawing为1 算法描述: 传统NSGA-Ⅱ算法的帕累托最优解来只源于当代种群个体,这样难以高效地获取更多的帕累托最优解 同时难以把种群大小控制在合适的范围内, 改进的NSGA2整体上沿用传统的NSGA-Ⅱ算法, 不同的是,该算法通过维护一个全局帕累托最优集来实现帕累托前沿的搜索, 故并不需要保证种群所有个体都是非支配的。 值得注意的是: 尽管当全局帕累托最优集大小比种群规模大时,算法的时间复杂度比原NSGA-Ⅱ算法要高, 但算法整体的时间复杂度要低与原NSGA-Ⅱ算法, 因此单位时间内生成的无重复帕累托最优解个数要多于原NSGA-Ⅱ算法 """ # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 #==========================初始化配置=========================== GGAP = 0.5 # 为了避免父子两代合并后种群数量爆炸,要让代沟为0.5 # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 #=========================开始遗传算法进化======================= if problem == 'R': Chrom = ga.crtrp(NIND, FieldDR) # 生成实数值种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDR) # 生成整数值种群 ObjV = aimfuc(Chrom) # 计算种群目标函数值 NDSet = np.zeros((0, Chrom.shape[1])) # 定义帕累托最优解集合(初始为空集) NDSetObjV = np.zeros((0, ObjV.shape[1])) # 定义帕累托最优解对应的目标函数集合(初始为空集) ax = None start_time = time.time() # 开始计时 [FitnV, levels] = ga.ndomindeb(maxormin * ObjV, 1) # deb非支配分级 if PUN_F is not None: FitnV = punishing(Chrom, FitnV) # 调用罚函数 frontIdx = np.where(levels == 1)[0] # 处在第一级的个体即为种群的非支配个体 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, NDSetObjV, repnum] = ga.upNDSet(Chrom, maxormin * ObjV, FitnV, NDSet, maxormin * NDSetObjV, frontIdx) # 开始进化!! for gen in range(MAXGEN): if NDSet.shape[0] > MAXSIZE: break # 进行遗传操作!! SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) #交叉 if problem == 'R': SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 if repnum >= Chrom.shape[0] * 0.01: # 当最优个体重复率高达1%时,进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDR, pm) # 高斯变异 elif problem == 'I': SelCh = ga.mutint(SelCh, FieldDR, pm) # 父子合并 Chrom = np.vstack([Chrom, SelCh]) ObjV = aimfuc(Chrom) # 求目标函数值 [FitnV, levels] = ga.ndomindeb(maxormin * ObjV, 1) # deb非支配分级 if PUN_F is not None: FitnV = punishing(Chrom, FitnV) # 调用罚函数 frontIdx = np.where(levels == 1)[0] # 处在第一级的个体即为种群的非支配个体 # 更新帕累托最优集以及种群非支配个体的适应度 [FitnV, NDSet, NDSetObjV, repnum] = ga.upNDSet(Chrom, maxormin * ObjV, FitnV, NDSet, maxormin * NDSetObjV, frontIdx) if distribute == True: # 若要增强帕累托解集的分布性 # 计算每个目标下个体的聚集距离(不需要严格计算欧氏距离,计算绝对值即可) 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]]) dis = dis + np.min(dis) FitnV[idx, 0] *= np.exp(dis) # 根据聚集距离修改适应度,以增加种群的多样性 Chrom = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择出下一代 if drawing == 2: ax = ga.frontplot(NDSetObjV, False, ax, gen + 1) # 绘制动态图 end_time = time.time() # 结束计时 #=========================绘图及输出结果========================= if drawing != 0: ga.frontplot(NDSetObjV, True) times = end_time - start_time print('用时:', times, '秒') print('帕累托前沿点个数:', NDSet.shape[0], '个') print('单位时间找到帕累托前沿点个数:', int(NDSet.shape[0] // times), '个') # 返回帕累托最优集以及执行时间 return [ObjV, NDSet, NDSetObjV, times]
def sga_mpc_real_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDRs, problem, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, distribute, drawing=1): """ sga_mpc_real_templet.py - 基于多种群竞争进化单目标编程模板(实值编码) 基于多种群竞争进化单目标编程模板(实值编码),多种群之间加入竞争,同时各种群独立进化 语法: 该函数除了drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: sga_mpc_real_templet(AIM_M, 'aimfuc', None, None, ..., maxormin) 输入参数: AIM_M - 目标函数的地址,由AIM_M = __import__('目标函数所在文件名')语句得到 目标函数规范定义:[f,LegV] = aimfuc(Phen,LegV) 其中Phen是种群的表现型矩阵, LegV为种群的可行性列向量,f为种群的目标函数值矩阵 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,由PUN_M = __import__('罚函数所在文件名')语句得到 罚函数规范定义: newFitnV = punishing(LegV, FitnV) 其中LegV为种群的可行性列向量, FitnV为种群个体适应度列向量 一般在罚函数中对LegV为0的个体进行适应度惩罚,返回修改后的适应度列向量newFitnV PUN_F : str - 罚函数名 FieldDR : array - 实际值种群区域描述器 [lb; (float) 指明每个变量使用的下界 ub] (float) 指明每个变量使用的上界 注:不需要考虑是否包含变量的边界值。在crtfld中已经将是否包含边界值进行了处理 本函数生成的矩阵的元素值在FieldDR的[下界, 上界)之间 problem : str - 表明是整数问题还是实数问题,'I'表示是整数问题,'R'表示是实数问题 maxormin int - 最小最大化标记,1表示目标函数最小化;-1表示目标函数最大化 MAXGEN : int - 最大遗传代数 NIND : int - 种群规模,即种群中包含多少个个体 SUBPOP : int - 子种群数量,即对一个种群划分多少个子种群 GGAP : float - 代沟,本模板中该参数为无用参数,仅为了兼容同类的其他模板而设 selectStyle : str - 指代所采用的低级选择算子的名称,如'rws'(轮盘赌选择算子) recombinStyle: str - 指代所采用的低级重组算子的名称,如'xovsp'(单点交叉) recopt : float - 交叉概率 pm : float - 重组概率 distribute : bool - 是否增强种群的分布性(可能会造成收敛慢) drawing : int - (可选参数),0表示不绘图,1表示绘制最终结果图。默认drawing为1 输出参数: pop_trace : array - 种群进化记录器(进化追踪器), 第0列记录着各代种群最优个体的目标函数值 第1列记录着各代种群的适应度均值 第2列记录着各代种群最优个体的适应度值 var_trace : array - 变量记录器,记录着各代种群最优个体的变量值,每一列对应一个控制变量 times : float - 进化所用时间 模板使用注意: 1.本模板调用的目标函数形如:[ObjV,LegV] = aimfuc(Phen,LegV), 其中Phen表示种群的表现型矩阵, LegV为种群的可行性列向量(详见Geatpy数据结构) 2.本模板调用的罚函数形如: newFitnV = punishing(LegV, FitnV), 其中FitnV为用其他算法求得的适应度 若不符合上述规范,则请修改算法模板或自定义新算法模板 3.关于'maxormin': geatpy的内核函数全是遵循“最小化目标”的约定的,即目标函数值越小越好。 当需要优化最大化的目标时,需要设置'maxormin'为-1。 本算法模板是正确使用'maxormin'的典型范例,其具体用法如下: 当调用的函数传入参数包含与“目标函数值矩阵”有关的参数(如ObjV,ObjVSel,NDSetObjV等)时, 查看该函数的参考资料(可用'help'命令查看,也可到官网上查看相应的教程), 里面若要求传入前对参数乘上'maxormin',则需要乘上。 里面若要求对返回参数乘上'maxormin'进行还原, 则调用函数返回得到的相应参数需要乘上'maxormin'进行还原,否则其正负号就会被改变。 """ """==========================初始化配置===========================""" GGAP = 0.5 # 因为父子合并后选择,因此要将代沟设为0.5以维持种群规模 # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 NVAR = FieldDRs[0].shape[1] # 得到控制变量的个数 # 定义全局进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) pop_trace[:, 0] = 0 # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN, NVAR)) * np.nan) ax = None # 存储上一帧图形 """=========================开始遗传算法进化=======================""" Chroms = [] # 存储所有子种群的染色体 LegVs = [] # 存储所有子种群的可行性列向量 ObjVs = [] # 存储所有子种群的目标函数值 repnums = [0] * len(FieldDRs) # 初始化重复个体数为0 for index in range(len(FieldDRs)): if problem == 'R': Chrom = ga.crtrp(NIND, FieldDRs[index]) # 生成初始种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDRs[index]) # 初始化相关变量 Chroms.append(Chrom) LegV = np.ones((NIND, 1)) # 初始化初代种群的可行性列向量 [ObjV, LegV] = aimfuc(Chrom, LegV) # 求初始种群的目标函数值 ObjVs.append(ObjV) LegVs.append(LegV) gen = 0 badCounter = 0 # 用于记录在“遗忘策略下”被忽略的代数 # 开始进化!! start_time = time.time() # 开始计时 while gen < MAXGEN: if badCounter >= 10 * MAXGEN: # 若多花了10倍的迭代次数仍没有可行解出现,则跳出 break allChroms = np.zeros((NVAR, 0)).T # 存储所有子种群父子合并的染色体 allObjVs = np.zeros((1, 0)).T # 存储所有子种群父子合并的目标函数值 allLegVs = np.zeros((1, 0)).T # 存储所有子种群父子合并的可行性列向量 if problem == 'R': for index in range(len(FieldDRs)): # 遍历各个子种群 Chrom = Chroms[index] # 取某个子种群的Chrom ObjV = ObjVs[index] # 取某个子种群的ObjV LegV = LegVs[index] # 取某个子种群的LegV # 进行遗传算子,生成子代 SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) # 重组 SelCh = ga.mutbga(SelCh, FieldDRs[index], pm) # 变异 if repnums[index] > Chrom.shape[ 0] * 0.01: # 当最优个体重复率高达1%时,进行一次高斯变异 SelCh = ga.mutgau(SelCh, FieldDRs[index], pm) # 高斯变异 LegVSel = np.ones((SelCh.shape[0], 1)) # 初始化育种种群的可行性列向量 [ObjVSel, LegVSel] = aimfuc(SelCh, LegVSel) # 父子合并 Chrom = np.vstack([Chrom, SelCh]) ObjV = np.vstack([ObjV, ObjVSel]) LegV = np.vstack([LegV, LegVSel]) allChroms = np.vstack([allChroms, Chrom]) allObjVs = np.vstack([allObjVs, ObjV]) allLegVs = np.vstack([allLegVs, LegV]) elif problem == 'I': for index in range(len(FieldDRs)): Chrom = Chroms[index] # 进行遗传算子,生成子代 SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) # 重组 SelCh = ga.mutint(SelCh, FieldDRs[index], pm) # 变异 LegVSel = np.ones((SelCh.shape[0], 1)) # 初始化育种种群的可行性列向量 [ObjVSel, LegVSel] = aimfuc(SelCh, LegVSel) # 计算育种种群的目标函数值 # 父子合并 Chrom = np.vstack([Chrom, SelCh]) ObjV = np.vstack([ObjV, ObjVSel]) LegV = np.vstack([LegV, LegVSel]) allChroms = np.vstack([allChroms, Chrom]) allObjVs = np.vstack([allObjVs, ObjV]) allLegVs = np.vstack([allLegVs, LegV]) allFitnVs = ga.ranking(maxormin * allObjVs, allLegVs, None, SUBPOP) # 计算所有子种群的适应度 if PUN_F is not None: allFitnVs = punishing(allLegVs, allFitnVs) # 调用罚函数 # 记录进化过程 bestIdx = np.argmax(allFitnVs) if allLegVs[bestIdx] != 0: feasible = np.where(allLegVs != 0)[0] # 排除非可行解 pop_trace[gen, 0] = np.sum( allObjVs[feasible]) / allObjVs[feasible].shape[0] pop_trace[gen, 1] = allObjVs[bestIdx] var_trace[gen, :] = allChroms[bestIdx] # 绘制动态图 if drawing == 2: ax = ga.sgaplot(pop_trace[:, [1]], '种群最优个体目标函数值', False, ax, gen) badCounter = 0 # badCounter计数器清零 else: gen -= 1 # 忽略这一代(遗忘策略) badCounter += 1 # 最后对合并的种群进行适应度评价并选出一半个体留到下一代(加入竞争的适应度评价) for index in range(len(FieldDRs)): Chrom = allChroms[index * NIND:(index + 2) * NIND] FitnV = allFitnVs[index * NIND:(index + 2) * NIND] ObjV = allObjVs[index * NIND:(index + 2) * NIND] LegV = allLegVs[index * NIND:(index + 2) * NIND] repnums[index] = len( np.where(FitnV[np.argmax(FitnV)] == FitnV)[0]) # 计算最优个体重复数 if distribute == True: # 若要增强种群的分布性(可能会造成收敛慢) idx = np.argsort(ObjV[:, 0], 0) dis = np.diff(ObjV[idx, 0]) / (np.max(ObjV[idx, 0]) - np.min( ObjV[idx, 0]) + 1) # 差分计算距离的修正偏移量 dis = np.hstack([dis, dis[-1]]) dis = dis + np.min(dis) # 修正偏移量+最小量=修正绝对量 FitnV[idx, 0] *= np.exp(dis) # 根据相邻距离修改适应度,突出相邻距离大的个体,以增加种群的多样性 [Chroms[index], ObjVs[index], LegVs[index]] = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP, ObjV, LegV) # 选择 gen += 1 end_time = time.time() # 结束计时 times = end_time - start_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) if pop_trace.shape[0] == 0: raise RuntimeError('error: no feasible solution. (有效进化代数为0,没找到可行解。)') # 绘图 if drawing != 0: ga.trcplot(pop_trace, [['种群个体平均目标函数值', '种群最优个体目标函数值']]) # 输出结果 if maxormin == 1: best_gen = np.argmin(pop_trace[:, 1]) # 记录最优种群是在哪一代 best_ObjV = np.min(pop_trace[:, 1]) elif maxormin == -1: best_gen = np.argmax(pop_trace[:, 1]) # 记录最优种群是在哪一代 best_ObjV = np.max(pop_trace[:, 1]) print('最优的目标函数值为:%f' % (best_ObjV)) print('最优的控制变量值为:') for i in range(NVAR): print(var_trace[best_gen, i]) print('有效进化代数:%d' % (pop_trace.shape[0])) print('最优的一代是第 %d 代' % (best_gen + 1)) print('时间已过 %f 秒' % (times)) # 返回进化记录器、变量记录器以及执行时间 return [pop_trace, var_trace, times]