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]
scales = [0] # 采用算术刻度
ranges = np.vstack([x1]).T # 生成自变量的范围矩阵
borders = np.vstack([b1]).T # 生成自变量的边界矩阵
"""=========================遗传算法参数设置========================="""
NIND = 40
# 种群个体数目
MAXGEN = 25
# 最大遗传代数
FieldD = ea.crtfld(Encoding, varTypes, ranges, borders, precisions, codes,
scales) # 调用函数创建区域描述器
Lind = int(np.sum(FieldD[0, :])) # 计算编码后的染色体长度
obj_trace = np.zeros((MAXGEN, 2)) # 定义目标函数值记录器
var_trace = np.zeros((MAXGEN, Lind)) # 定义染色体记录器，记录每一代最优个体的染色体
"""=========================开始遗传算法进化========================"""
start_time = time.time() # 开始计时
Chrom = ea.crtbp(NIND, Lind) # 生成种群染色体矩阵
variable = ea.bs2real(Chrom, FieldD) # 对初始种群进行解码
ObjV = aim(variable) # 计算初始种群个体的目标函数值
best_ind = np.argmax(ObjV) # 计算当代最优个体的序号
# 开始进化
for gen in range(MAXGEN):
FitnV = ea.ranking(-ObjV) # 根据目标函数大小分配适应度值(由于遵循目标最小化约定，因此最大化问题要对目标函数值乘上-1)
SelCh = Chrom[ea.selecting('rws', FitnV, NIND - 1), :] # 选择，采用'rws'轮盘赌选择
SelCh = ea.recombin('xovsp', SelCh, 0.7) # 重组(采用两点交叉方式，交叉概率为0.7)
SelCh = ea.mutbin(Encoding, SelCh) # 二进制种群变异
# 把父代精英个体与子代合并
Chrom = np.vstack([Chrom[best_ind, :], SelCh])
variable = ea.bs2real(Chrom, FieldD) # 对育种种群进行解码(二进制转十进制)
ObjV = aim(variable) # 求育种个体的目标函数值
# 记录
best_ind = np.argmax(ObjV) # 计算当代最优个体的序号
ranges = np.vstack([x1, x2]).T # 生成自变量的范围矩阵
borders = np.vstack([b1, b2]).T # 生成自变量的边界矩阵
"""========================遗传算法参数设置========================="""
NIND = 50 # 种群规模
MAXGEN = 1000 # 最大遗传代数
GGAP = 0.8 # 代沟：子代与父代个体不相同的概率为0.8
selectStyle = 'sus'
# 遗传算法的选择方式设为"sus"——随机抽样选择
recombinStyle = 'xovdp' # 遗传算法的重组方式，设为两点交叉
recopt = 0.9 # 交叉概率
pm = 0.1 # 变异概率
SUBPOP = 1 # 设置种群数为1
"""=========================开始遗传算法进化========================"""
FieldD = ga.crtfld(ranges, borders, precisions, codes, scales) # 调用函数创建区域描述器
Lind = np.sum(FieldD[0, :]) # 计算编码后的染色体长度
Chrom = ga.crtbp(NIND, Lind) # 根据区域描述器生成二进制种群
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) # 求育种个体的目标函数值
def sga_new_code_templet(AIM_M,
AIM_F,
PUN_M,
PUN_F,
FieldD,
problem,
maxormin,
MAXGEN,
NIND,
SUBPOP,
GGAP,
selectStyle,
recombinStyle,
recopt,
pm,
drawing=1):
"""
sga_new_code_templet.py - 改进的单目标编程模板(二进制/格雷编码)
本模板实现改进单目标编程模板(二进制/格雷编码)，将父子两代合并进行选择，增加了精英保留机制
语法：
该函数除了参数drawing外，不设置可缺省参数。当某个参数需要缺省时，在调用函数时传入None即可。
比如当没有罚函数时，则在调用编程模板时将第3、4个参数设置为None即可，如：
sga_new_code_templet(AIM_M, 'aimfuc', None, None, ..., maxormin)
输入参数：
AIM_M - 目标函数的地址，传入该函数前通常由AIM_M = __import__('目标函数名')语句得到
AIM_F : str - 目标函数名
PUN_M - 罚函数的地址，传入该函数前通常由PUN_M = __import__('罚函数名')语句得到
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 - 进化所用时间
"""
"""==========================初始化配置==========================="""
GGAP = 0.5 # 因为父子合并后选择，因此要将代沟设为0.5以维持种群规模
# 获取目标函数和罚函数
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) # 生成初始种
start_time = time.time() # 开始计时
# 开始进化！！
for gen in range(MAXGEN):
# 进行遗传算子产生子代
SelCh = ga.recombin(recombinStyle, Chrom, recopt, SUBPOP) # 重组
SelCh = ga.mutbin(SelCh, pm) # 变异
Chrom = np.vstack([Chrom, SelCh]) # 父子合并
# 计算种群适应度
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) # 求后代的目标函数值
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), :] # 记录当代最优的控制变量值
# 最后对合并的种群进行适应度评价并选出一半个体留到下一代
FitnV = ga.ranking(maxormin * ObjV, None, SUBPOP)
if PUN_F is not None:
FitnV = punishing(Chrom, FitnV) # 调用罚函数
Chrom = ga.selecting(selectStyle, Chrom, FitnV, GGAP, SUBPOP) # 选择
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]
if __name__ == '__main__':
# 获取输入的初始数据
input_data = []
for i in range(3):
line = sys.stdin.readline().strip()
input_data.append(line)
# 整理初始数据
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 是交叉编译函数，其第二个参数是交叉概率
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]
"""========================遗传算法参数设置========================="""
NIND = 50 # 种群规模
MAXGEN = 10 # 最大遗传代数
GGAP = 0.8 # 代沟：子代与父代个体不相同的概率为0.8
selectStyle = 'sus'
# 遗传算法的选择方式设为"sus"——随机抽样选择
recombinStyle = 'xovdp' # 遗传算法的重组方式，设为两点交叉
recopt = 0.9 # 交叉概率
pm = 0.1 # 变异概率
SUBPOP = 1 # 设置种群数为1
maxormin = -1 # 设置最大最小化目标标记为1，表示是最小化目标，-1则表示最大化目标
"""=========================开始遗传算法进化========================"""
FieldD = ga.crtfld(ranges, borders) # 调用函数创建区域描述器
Lind = np.sum(FieldD[0, :]) # 计算编码后的染色体长度
print(FieldD)
Chrom = ga.crtbp(NIND, FieldD) # 根据区域描述器生成二进制种群
Phen = ga.bs2int(Chrom, FieldD) #对初始种群进行解码
LegV = np.ones((NIND, 1)) # 初始化种群的可行性列向量
[ObjV, LegV] = aimfuc(Phen, LegV) # 计算初始种群个体的目标函数值
# 定义进化记录器，初始值为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) # 对育种种群进行解码(二进制转十进制)
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 - 进化所用时间
模板使用注意：
1.本模板调用的目标函数形如：
ObjV = aimfuc(Phen), 其中Phen表示种群的表现型矩阵
2.本模板调用的罚函数形如:
[FitnV, punIdx] = punishing(Phen, FitnV),
其中输入参数的FitnV为惩罚前的适应度,输出参数的FitnV为惩罚后的适应度
punIdx为惩罚的个体所在的下标
在罚函数定义中，必须将不满足约束条件的个体对应的适应度设为0，否则请修改模板使用
"""
#==========================初始化配置==========================="""
# 获取目标函数和罚函数
aimfuc = getattr(AIM_M, AIM_F) # 获得目标函数
if PUN_F is not None:
punishing = getattr(PUN_M, PUN_F) # 获得罚函数
exIdx = np.array([]) # 存储非可行解的下标
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, 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, :] = variable[bestIdx, :] # 记录当代最优的控制变量值
# 进行遗传算子
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')
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]
# GA Variables, please refer to Geatpy package for details
NIND = 2
MAXGEN = 100
GGAP = 0.8
selectStyle = 'sus'
recombinStyle = 'xovdp'
recopt = 0.9
pm = 0.1
SUBPOP = 1
maxormin = 1
# Start of GA, please refer to Geatpy package for details
FieldD = ga.crtfld(ranges, borders, precisions, codes, scales)
Lind = np.sum(FieldD[0, :])
Chrom = ga.crtbp(NIND, Lind)
Phen = ga.bs2rv(Chrom, FieldD)
LegV = np.ones((NIND, 1))
[ObjV, LegV, Run] = aimfuc(Phen, LegV, Run, NIND)
pop_trace = (np.zeros((MAXGEN,2)) * np.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, Run] = aimfuc(Phen, LegVSel, Run, NIND)
[Chrom, ObjV, LegV] = ga.reins(Chrom, SelCh, SUBPOP, 1, 1, maxormin*ObjV, maxormin*ObjVSel, ObjV, ObjVSel, LegV, LegVSel)
def train_process(model, gt):
def aim(Phen):
# ld = Phen[:, [0]] # 取出第1列，得到所有个体的第1个自变量
# gm = Phen[:, [1]] # 取出第2列，得到所有个体的第2个自变量
fits = np.zeros((len(Phen),1)) # 所有个体的健康程度评估
# print(Phen)
for idx in range(len(Phen)):
model.omiga = Phen[idx][1]
model.gamma = Phen[idx][0]
# model.beta = Phen[idx][2]
model.d = Phen[idx][2]
model.deduce()
# print(np.array(model.i * model.N))
exam_day = int(Phen[idx][3])
model_preds_i = model.i[exam_day:exam_day+len(gt)] * model.N
gt_i = np.array(gt['confirmedCount'])
model_preds_r = model.r[exam_day:exam_day+len(gt)] * model.N
gt_r = np.array(gt['deadCount']+gt['curedCount'])
infective_fitness = residual_square(model_preds_i, gt_i)
recov_fitness = residual_square(model_preds_r, gt_r)
fits[idx] = infective_fitness + recov_fitness
# print(model_preds_i, gt_i)
# print(fits)
return fits
# settings
omiga = [0, 1] # 自变量范围
gamma = [0, 1]
# beta = [0, 1]
d = [0, 100]
exam_d = [10, 60]
b1 = [0, 0] # 自变量边界, 1 表示包含边界， 0 表示不包含边界
b2 = [0, 0]
# b3 = [0, 0]
b4 = [0, 0]
b5 = [1, 1]
varTypes = np.array([0, 0, 0, 0]) # 自变量的类型，0表示连续，1表示离散
Encoding = 'BG' # 'BG'表示采用二进制/格雷编码
codes = [1, 1, 1, 1] # 变量的编码方式，2个变量均使用格雷编码
precisions =[6, 6, 6, 6] # 变量的编码精度
scales = [0, 0, 0, 0] # 采用算术刻度
ranges=np.vstack([gamma, omiga, d, exam_d]).T # 生成自变量的范围矩阵
borders=np.vstack([b2, b1, b4, b5]).T # 生成自变量的边界矩阵
# params of GA
NIND = 400 # 种群个体数目
MAXGEN = 100 # 最大遗传代数
maxormins = [1] # 最小化目标函数， 元素为-1表示最大化目标函数
FieldD = ea.crtfld(Encoding,varTypes,
ranges, borders,precisions,codes,scales) # 调用函数创建区域描述器
Lind = int(np.sum(FieldD[0, :])) # 计算编码后的染色体长度
obj_trace = np.zeros((MAXGEN, 2)) # 定义目标函数值记录器
var_trace = np.zeros((MAXGEN, Lind)) # 定义染色体记录器，记录每一代最优个体的染色体
start_time = time.time() # 开始计时
Chrom = ea.crtbp(NIND, Lind) # 生成种群染色体矩阵
variable = ea.bs2real(Chrom, FieldD) # 对初始种群进行解码
ObjV = aim(variable) # 计算初始种群个体的目标函数值
best_ind = np.argmin(ObjV) # 计算当代最优个体的序号
# 开始进化
for gen in range(MAXGEN):
FitnV = ea.ranking(maxormins * ObjV) # 根据目标函数大小分配适应度值(由于遵循目标最小化约定，因此最大化问题要对目标函数值乘上-1)
SelCh=Chrom[ea.selecting('rws', FitnV, NIND-1), :] # 选择，采用'rws'轮盘赌选择
SelCh=ea.recombin('xovsp', SelCh, 0.7) # 重组(采用两点交叉方式，交叉概率为0.7)
SelCh=ea.mutbin(Encoding, SelCh) # 二进制种群变异
# 把父代精英个体与子代合并
Chrom = np.vstack([Chrom[best_ind, :], SelCh])
variables = ea.bs2real(Chrom, FieldD) # 对育种种群进行解码(二进制转十进制)
ObjV = aim(variables) # 求育种个体的目标函数值
# 记录
best_ind = np.argmin(ObjV) # 计算当代最优个体的序号
obj_trace[gen, 0] = np.sum(ObjV) / NIND # 记录当代种群的目标函数均值
obj_trace[gen, 1] = ObjV[best_ind] # 记录当代种群最优个体目标函数值
var_trace[gen, :] = Chrom[best_ind, :] # 记录当代种群最优个体的变量值
# 进化完成
end_time = time.time() # 结束计时
# 绘制图像
ea.trcplot(obj_trace, [['种群个体平均目标函数值', '种群最优个体目标函数值']])
best_gen = np.argmin(obj_trace[:, [1]])
print('最优解的目标函数值: ', obj_trace[best_gen, 1])
opt_variable = ea.bs2real(var_trace[[best_gen], :], FieldD)
print('最优解的决策变量为：')
for i in range(opt_variable.shape[1]):
print(opt_variable[0, i])
print('用时: ', end_time - start_time, '秒')
model.omiga = opt_variable[0, 1]
model.gamma = opt_variable[0, 0]
# model.beta = opt_variable[0, 2]
model.d = opt_variable[0, 2]
model.deduce()
model.draw_curves()
return opt_variable[0]
