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 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 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]
def sga_code_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldD, problem, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, distribute, drawing=1): """ sga_code_templet.py - 单目标编程模板(二进制/格雷编码) 语法: 该函数除了参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: sga_code_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 - 罚函数名 FieldD : array - 二进制/格雷码种群区域描述器, 描述种群每个个体的染色体长度和如何解码的矩阵,它有以下结构: [lens; (int) 每个控制变量编码后在染色体中所占的长度 lb; (float) 指明每个变量使用的下界 ub; (float) 指明每个变量使用的上界 codes; (0:binary | 1:gray) 指明子串是怎么编码的, 0为标准二进制编码,1为各类编码 scales; (0: rithmetic | 1:logarithmic) 指明每个子串是否使用对数或算术刻度, 1为使用对数刻度,2为使用算术刻度 lbin; (0:excluded | 1:included) ubin] (0:excluded | 1:included) lbin和ubin指明范围中是否包含每个边界。 选择lbin=0或ubin=0,表示范围中不包含相应边界。 选择lbin=1或ubin=1,表示范围中包含相应边界。 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 = FieldD.shape[1] # 得到控制变量的个数 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN, NVAR)) * np.nan) ax = None # 存储上一帧图形 """=========================开始遗传算法进化=======================""" Lind = np.sum(FieldD[0, :]) # 种群染色体长度 Chrom = ga.crtbp(NIND, Lind) # 生成初始种群 if problem == 'R': variable = ga.bs2rv(Chrom, FieldD) # 解码 elif problem == 'I': if np.any(FieldD >= sys.maxsize): variable = ga.bs2int(Chrom, FieldD).astype('object') # 解码 else: variable = ga.bs2int(Chrom, FieldD).astype('int64') # 解码 LegV = np.ones((NIND, 1)) # 生成可行性列向量,元素为1表示对应个体是可行解,0表示非可行解 [ObjV, LegV] = aimfuc(variable, 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, :] = variable[bestIdx, :] # 记录当代最优的控制变量值 # 绘制动态图 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) # 对所选个体进行重组 SelCh = ga.mutbin(SelCh, pm) # 变异 # 计算种群适应度 if problem == 'R': variable = ga.bs2rv(SelCh, FieldD) # 解码 elif problem == 'I': if np.any(FieldD >= sys.maxsize): variable = ga.bs2int(SelCh, FieldD).astype('object') # 解码 else: variable = ga.bs2int(SelCh, FieldD).astype('int64') LegVSel = np.ones((SelCh.shape[0], 1)) # 初始化育种种群的可行性列向量 [ObjVSel, LegVSel] = aimfuc(variable, 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) # 计算新一代种群的控制变量解码值 if problem == 'R': variable = ga.bs2rv(Chrom, FieldD) # 解码 elif problem == 'I': if np.any(FieldD >= sys.maxsize): variable = ga.bs2int(Chrom, FieldD).astype('object') # 解码 else: variable = ga.bs2int(Chrom, FieldD).astype('int64') 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 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]
Phen = ga.bs2rv(Chrom, FieldD) #对初始种群进行解码 ObjV = aimfuc(Phen) # 计算初始种群个体的目标函数值 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) # 定义种群最优个体记录器,记录每一代最优个体的染色体,初始值为nan ind_trace = (np.zeros((MAXGEN, Lind)) * np.nan) # 开始进化!! start_time = time.time() # 开始计时 for gen in range(MAXGEN): FitnV = ga.ranking(ObjV) # 根据目标函数大小分配适应度值 SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) #交叉 SelCh = ga.mutbin(SelCh, pm) # 二进制种群变异 Phen = ga.bs2rv(SelCh, FieldD) # 对育种种群进行解码(二进制转十进制) ObjVSel = aimfuc(Phen) # 求育种个体的目标函数值 [Chrom, ObjV] = ga.reins(Chrom, SelCh, SUBPOP, 2, 1, ObjV, ObjVSel) # 重插入得到新一代种群 # 记录 best_ind = np.argmin(ObjV) # 计算当代最优个体的序号 pop_trace[gen, 0] = ObjV[best_ind] # 记录当代种群最优个体目标函数值 pop_trace[gen, 1] = np.sum(ObjV) / ObjV.shape[0] # 记录当代种群的目标函数均值 ind_trace[gen, :] = Chrom[best_ind, :] # 记录当代种群最优个体的变量值 # 进化完成 end_time = time.time() # 结束计时 """============================绘图================================""" ga.trcplot(pop_trace, [['最优个体目标函数值', '种群的目标函数均值']], ['demo_result']) """============================输出结果============================""" best_gen = np.argmin(pop_trace[:, 0]) # 计算最优种群是在哪一代 print('最优的目标函数值为:', np.min(pop_trace[:, 0])) print('最优的控制变量值为:') # 最优个体记录器存储的是各代种群最优个体的染色体,此处需要解码得到对应的基因表现型 variables = ga.bs2rv(ind_trace, FieldD) # 解码
# 整理初始数据 food_info_table = get_food_info_table(input_data) # 种群规模, pop_size = 60 # 最大迭代次数 gen_max = 100 # 维度,即商品种类 M = len(food_info_table) # 初始种群 chrom = ga.crtbp(pop_size, M) gen = 0 while gen < gen_max: # FitnV用来存储适应度值 FitnV = [] for individual in chrom: FitnV.append( fitness_cal(food_info_table, get_promotion(input_data), get_balance(input_data), individual)) # temp用来存储参与交叉编译的个体 temp = [] # 选出每代种群中最优秀的五个进行交叉变异 for i in ga.tour(np.array(FitnV).reshape(pop_size, 1), 5): temp.append(chrom[i]) # xovdp 是交叉编译函数,其第二个参数是交叉概率 temp = ga.xovdp(np.array(temp), 1) new_chrom = ga.reins(chrom, temp, 1, 1, 1, np.array(FitnV).reshape(pop_size, 1)) gen += 1 print(max(FitnV))
# 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) # 定义种群最优个体记录器,记录每一代最优个体的染色体,初始值为nan ind_trace = (np.zeros((MAXGEN, Lind)) * np.nan) # 开始进化!! start_time = time.time() # 开始计时 for gen in range(MAXGEN): FitnV = ga.ranking(maxormin * ObjV, LegV) # 根据目标函数大小分配适应度值 SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) #交叉 SelCh = ga.mutbin(SelCh, pm) # 二进制种群变异 Phen = ga.bs2rv(SelCh, FieldD) # 对育种种群进行解码(二进制转十进制) LegVSel = np.ones((SelCh.shape[0], 1)) # 初始化育种种群的可行性列向量 [ObjVSel, LegVSel] = aimfuc(Phen, LegVSel) # 求育种个体的目标函数值 [Chrom, ObjV, LegV] = ga.reins(Chrom, SelCh, SUBPOP, 1, 1, maxormin * ObjV, maxormin * ObjVSel, ObjV, ObjVSel, LegV, LegVSel) # 重插入得到新一代种群 # 记录 pop_trace[gen, 1] = np.sum(ObjV) / ObjV.shape[0] # 记录当代种群的目标函数均值 if maxormin == 1: best_ind = np.argmin(ObjV) # 计算当代最优个体的序号 elif maxormin == -1: best_ind = np.argmax(ObjV) pop_trace[gen, 0] = ObjV[best_ind] # 记录当代种群最优个体目标函数值 ind_trace[gen, :] = Chrom[best_ind, :] # 记录当代种群最优个体的变量值 # 进化完成 end_time = time.time() # 结束计时 """============================绘图================================""" ga.trcplot(pop_trace, [['最优个体目标函数值', '种群的目标函数均值']], ['demo_result']) """============================输出结果============================""" best_gen = np.argmin(pop_trace[:, 0]) # 计算最优种群是在哪一代
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 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 sga_code_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldD, problem, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, drawing = 1): """ sga_code_templet.py - 单目标编程模板(二进制/格雷编码) 语法: 该函数除了参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: sga_code_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 - 罚函数名 FieldD : array - 二进制/格雷码种群区域描述器, 描述种群每个个体的染色体长度和如何解码的矩阵,它有以下结构: [lens; (int) 每个控制变量编码后在染色体中所占的长度 lb; (float) 指明每个变量使用的下界 ub; (float) 指明每个变量使用的上界 codes; (0:binary | 1:gray) 指明子串是怎么编码的, 0为标准二进制编码,1为各类编码 scales; (0: rithmetic | 1:logarithmic) 指明每个子串是否使用对数或算术刻度, 1为使用对数刻度,2为使用算术刻度 lbin; (0:excluded | 1:included) ubin] (0:excluded | 1:included) lbin和ubin指明范围中是否包含每个边界。 选择lbin=0或ubin=0,表示范围中不包含相应边界。 选择lbin=1或ubin=1,表示范围中包含相应边界。 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 - 进化所用时间 """ """==========================初始化配置===========================""" # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 NVAR = FieldD.shape[1] # 得到控制变量的个数 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN ,2)) * np.nan) # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN ,NVAR)) * np.nan) """=========================开始遗传算法进化=======================""" Lind = np.sum(FieldD[0, :]) # 种群染色体长度 Chrom = ga.crtbp(NIND, Lind) # 生成初始种群 if problem == 'R': variable = ga.bs2rv(Chrom, FieldD) # 解码 elif problem == 'I': if np.any(FieldD >= sys.maxsize): variable = ga.bs2int(Chrom, FieldD).astype('object') # 解码 else: variable = ga.bs2int(Chrom, FieldD).astype('int64') # 解码 ObjV = aimfuc(variable) # 求种群的目标函数值 start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): FitnV = ga.ranking(maxormin * ObjV, None, SUBPOP) if PUN_F is not None: FitnV = punishing(Chrom, FitnV) # 调用罚函数 # 进行遗传算子 SelCh=ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh=ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) # 重组 SelCh=ga.mutbin(SelCh,pm) # 变异 # 计算种群适应度 if problem == 'R': variable = ga.bs2rv(SelCh, FieldD) # 解码 elif problem == 'I': if np.any(FieldD >= sys.maxsize): variable = ga.bs2int(SelCh, FieldD).astype('object') # 解码 else: variable = ga.bs2int(SelCh, FieldD).astype('int64') ObjVSel = aimfuc(variable) # 求后代的目标函数值 # 重插入 [Chrom, ObjV]=ga.reins(Chrom, SelCh, SUBPOP, 2, 1, ObjV, ObjVSel) # 计算新一代种群的控制变量解码值 if problem == 'R': variable = ga.bs2rv(Chrom, FieldD) # 解码 elif problem == 'I': if np.any(FieldD >= sys.maxsize): variable = ga.bs2int(Chrom, FieldD).astype('object') # 解码 else: variable = ga.bs2int(SelCh, FieldD).astype('int64') pop_trace[gen,0] = np.sum(ObjV) // ObjV.shape[0] # 记录种群个体平均目标函数值 if maxormin == 1: pop_trace[gen,1] = np.min(ObjV) # 记录当代目标函数的最优值 var_trace[gen,:] = variable[np.argmin(ObjV), :] # 记录当代最优的控制变量值 elif maxormin == -1: pop_trace[gen,1] = np.max(ObjV) var_trace[gen,:] = variable[np.argmax(ObjV), :] # 记录当代最优的控制变量值 end_time = time.time() # 结束计时 # 绘图 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 sga_permut_templet(AIM_M, AIM_F, PUN_M, PUN_F, NVAR, VarLen, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, drawing=1): """ sga_permut_templet.py - 单目标编程模板(排列编码) 排列编码即每条染色体的基因都是无重复正整数的编码方式。 语法: 该函数除了参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: sga_permut_templet(AIM_M, 'aimfuc', None, None, ..., maxormin) 输入参数: AIM_M - 目标函数的地址,传入该函数前通常由AIM_M = __import__('目标函数名')语句得到 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,传入该函数前通常由PUN_M = __import__('罚函数名')语句得到 PUN_F : str - 罚函数名 NVAR : int - 变量个数,排列编码的染色体长度等于变量个数 VarLen : int - 排列集合的大小 例如VarLen = 5表示是从1,2,3,4,5中抽取若干个数排列组成染色体 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 - 进化所用时间 """ """==========================初始化配置===========================""" # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN, NVAR)) * np.nan) """=========================开始遗传算法进化=======================""" #生成初始种群 Chrom = ga.crtpp(NIND, NVAR, VarLen) ObjV = aimfuc(Chrom) # 求种群的目标函数值 start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): FitnV = ga.ranking(maxormin * ObjV, None, SUBPOP) if PUN_F is not None: FitnV = punishing(Chrom, FitnV) # 调用罚函数 # 进行遗传算子 SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) # 重组 SelCh = ga.mutpp(SelCh, VarLen, pm) # 排列编码种群变异 ObjVSel = aimfuc(SelCh) # 求后代的目标函数值 # 重插入 [Chrom, ObjV] = ga.reins(Chrom, SelCh, SUBPOP, 2, 1, ObjV, ObjVSel) pop_trace[gen, 0] = np.sum(ObjV) // ObjV.shape[0] # 记录种群个体平均目标函数值 if maxormin == 1: pop_trace[gen, 1] = np.min(ObjV) # 记录当代目标函数的最优值 var_trace[gen, :] = Chrom[np.argmin(ObjV), :] # 记录当代最优的控制变量值 elif maxormin == -1: pop_trace[gen, 1] = np.max(ObjV) var_trace[gen, :] = Chrom[np.argmax(ObjV), :] # 记录当代最优的控制变量值 end_time = time.time() # 结束计时 # 绘图 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 sga_real_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDR, problem, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, 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__('目标函数名')语句得到 AIM_F : str - 目标函数名 PUN_M - 罚函数的地址,传入该函数前通常由PUN_M = __import__('罚函数名')语句得到 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 - 进化所用时间 """ """==========================初始化配置===========================""" # 获取目标函数和罚函数 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) """=========================开始遗传算法进化=======================""" if problem == 'R': Chrom = ga.crtrp(NIND, FieldDR) # 生成初始种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDR) ObjV = aimfuc(Chrom) # 求种群的目标函数值 start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): FitnV = ga.ranking(maxormin * ObjV, None, SUBPOP) if PUN_F is not None: FitnV = punishing(Chrom, FitnV) # 调用罚函数 # 进行遗传算子 SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) # 重组 if problem == 'R': SelCh = ga.mutbga(SelCh, FieldDR, pm) # 变异 elif problem == 'I': SelCh = ga.mutint(SelCh, FieldDR, pm) ObjVSel = aimfuc(SelCh) # 求后代的目标函数值 # 重插入 [Chrom, ObjV] = ga.reins(Chrom, SelCh, SUBPOP, 2, 1, ObjV, ObjVSel) pop_trace[gen, 0] = np.sum(ObjV) / ObjV.shape[0] # 记录种群个体平均目标函数值 if maxormin == 1: pop_trace[gen, 1] = np.min(ObjV) # 记录当代目标函数的最优值 var_trace[gen, :] = Chrom[np.argmin(ObjV), :] # 记录当代最优的控制变量值 elif maxormin == -1: pop_trace[gen, 1] = np.max(ObjV) var_trace[gen, :] = Chrom[np.argmax(ObjV), :] # 记录当代最优的控制变量值 end_time = time.time() # 结束计时 # 绘图 if drawing == 1: ga.trcplot(pop_trace, [['种群个体平均目标函数值', '种群最优个体目标函数值']]) # 输出结果 if maxormin == 1: best_gen = np.argmin(pop_trace[:, 1]) # 记录最优种群是在哪一代 print('最优的目标函数值为:' + str(np.min(pop_trace[:, 1]))) elif maxormin == -1: best_gen = np.argmax(pop_trace[:, 1]) # 记录最优种群是在哪一代 print('最优的目标函数值为:' + str(np.max(pop_trace[:, 1]))) print('最优的控制变量值为:') for i in range(NVAR): print(var_trace[best_gen, i]) print('最优的一代是第' + str(best_gen + 1) + '代') times = end_time - start_time print('时间已过' + str(times) + '秒') # 返回进化记录器、变量记录器以及执行时间 return [pop_trace, var_trace, times]
def sga_real_templet(AIM_M, AIM_F, PUN_M, PUN_F, FieldDR, problem, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, 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 = 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,否则请修改模板使用 """ """==========================初始化配置===========================""" # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 exIdx = np.array([]) # 存储非可行解的下标 NVAR = FieldDR.shape[1] # 得到控制变量的个数 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN, NVAR)) * np.nan) """=========================开始遗传算法进化=======================""" if problem == 'R': Chrom = ga.crtrp(NIND, FieldDR) # 生成初始种群 elif problem == 'I': Chrom = ga.crtip(NIND, FieldDR) ObjV = aimfuc(Chrom) # 求种群的目标函数值 start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): FitnV = ga.ranking(maxormin * ObjV, None, SUBPOP) if PUN_F is not None: [FitnV, exIdx] = punishing(Chrom, FitnV) # 调用罚函数 # 记录进化过程 bestIdx = np.argmax(FitnV) # 获取最优个体的下标 wrongSign = np.ones((FitnV.shape[0], 1)) wrongSign[list(exIdx)] = 0 # 对非可行解作标记 if wrongSign[bestIdx] != 0: feasible = np.where(wrongSign != 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]) # 计算最优个体重复数 # 进行遗传算子 SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 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 = aimfuc(SelCh) # 求后代的目标函数值 # 重插入 [Chrom, ObjV] = ga.reins(Chrom, SelCh, SUBPOP, 2, 1, ObjV, ObjVSel) 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 sga_permut_templet(AIM_M, AIM_F, PUN_M, PUN_F, NVAR, VarLen, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, drawing = 1): """ sga_permut_templet.py - 单目标编程模板(排列编码) 排列编码即每条染色体的基因都是无重复正整数的编码方式。 语法: 该函数除了参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: sga_permut_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 - 罚函数名 NVAR : int - 变量个数,排列编码的染色体长度等于变量个数 VarLen : int - 排列集合的大小 例如VarLen = 5表示是从1,2,3,4,5中抽取若干个数排列组成染色体 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,否则请修改模板使用 """ """==========================初始化配置===========================""" # 获取目标函数和罚函数 aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数 if PUN_F is not None: punishing = getattr(PUN_M, PUN_F) # 获得罚函数 exIdx = np.array([]) # 存储非可行解的下标 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN ,2)) * np.nan) # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN ,NVAR)) * np.nan) """=========================开始遗传算法进化=======================""" #生成初始种群 Chrom = ga.crtpp(NIND, NVAR, VarLen) ObjV = aimfuc(Chrom) # 求种群的目标函数值 start_time = time.time() # 开始计时 # 开始进化!! for gen in range(MAXGEN): FitnV = ga.ranking(maxormin * ObjV, None, SUBPOP) if PUN_F is not None: [FitnV, exIdx] = punishing(Chrom, FitnV) # 调用罚函数 # 记录进化过程 bestIdx = np.argmax(FitnV) # 获取最优个体的下标 wrongSign = np.ones((FitnV.shape[0], 1)) wrongSign[list(exIdx)] = 0 # 对非可行解作标记 if wrongSign[bestIdx] != 0: feasible = np.where(wrongSign != 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, :] # 记录当代最优的控制变量值 # 进行遗传算子 SelCh=ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh=ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) # 重组 SelCh=ga.mutpp(SelCh, VarLen, pm) # 排列编码种群变异 ObjVSel = aimfuc(SelCh) # 求后代的目标函数值 # 重插入 [Chrom, ObjV]=ga.reins(Chrom, SelCh, SUBPOP, 2, 1, ObjV, ObjVSel) 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 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 sga_permut_templet(AIM_M, AIM_F, PUN_M, PUN_F, NVAR, VarLen, maxormin, MAXGEN, NIND, SUBPOP, GGAP, selectStyle, recombinStyle, recopt, pm, distribute, drawing=1): """ sga_permut_templet.py - 单目标编程模板(排列编码) 排列编码即每条染色体的基因都是无重复正整数的编码方式。 语法: 该函数除了参数drawing外,不设置可缺省参数。当某个参数需要缺省时,在调用函数时传入None即可。 比如当没有罚函数时,则在调用编程模板时将第3、4个参数设置为None即可,如: sga_permut_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 - 罚函数名 NVAR : int - 变量个数,排列编码的染色体长度等于变量个数 VarLen : int - 排列集合的大小 例如VarLen = 5表示是从1,2,3,4,5中抽取若干个数排列组成染色体 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) # 获得罚函数 # 定义进化记录器,初始值为nan pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) # 定义变量记录器,记录控制变量值,初始值为nan var_trace = (np.zeros((MAXGEN, NVAR)) * np.nan) ax = None # 存储上一帧图形 """=========================开始遗传算法进化=======================""" #生成初始种群 Chrom = ga.crtpp(NIND, NVAR, VarLen) 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, :] # 记录当代最优的控制变量值 # 绘制动态图 if drawing == 2: ax = ga.sgaplot(pop_trace[:, [1]], '种群最优个体目标函数值', False, ax, gen) badCounter = 0 # badCounter计数器清零 else: gen -= 1 # 忽略这一代(遗忘策略) badCounter += 1 # 进行遗传算子 SelCh = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择 SelCh = ga.recombin(recombinStyle, SelCh, recopt, SUBPOP) # 对选择的个体进行重组 SelCh = ga.mutpp(SelCh, VarLen, 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('最优的目标函数值为:%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]