recStyle = 'xovdp' # 采用两点交叉
mutStyle = 'mutbin' # 采用二进制染色体的变异算子
Lind = 64 # 计算染色体长度
pc = 0.9 # 交叉概率
pm = 1 / Lind # 变异概率
obj_trace = np.zeros((MAXGEN, 2)) # 定义目标函数值记录器
var_trace = np.zeros((MAXGEN, Lind)) # 染色体记录器，记录历代最优个体的染色体
"""=========================开始遗传算法进化========================"""
start_time = time.time() # 开始计时
Chrom = ea.crtpc(Encoding, NIND, FieldD) # 生成种群染色体矩阵
help(ea.ranking)
for gen in range(MAXGEN):
Phen = ea.bs2real(Chrom, FieldD) # 对种群进行解码(二进制转十进制)
ObjV, CV = aim(Phen) # 求种群个体的目标函数值
FitnV = ea.ranking(maxormins * ObjV, CV) # 根据目标函数大小分配适应度值
# 记录
best_ind = np.argmax(FitnV) # 计算当代最优个体的序号
obj_trace[gen, 0] = np.sum(ObjV) / ObjV.shape[0] # 记录当代种群的目标函数均值
obj_trace[gen, 1] = ObjV[best_ind] # 记录当代种群最优个体目标函数值
var_trace[gen, :] = Chrom[best_ind, :] # 记录当代种群最优个体的染色体
SelCh = Chrom[ea.selecting(selectStyle, FitnV, NIND - 1), :] # 选择
SelCh = ea.recombin(recStyle, SelCh, pc) # 重组
SelCh = ea.mutate(mutStyle, Encoding, SelCh, pm) # 变异
# 把父代精英个体与子代的染色体进行合并，得到新一代种群
Chrom = np.vstack([var_trace[gen, :], SelCh])
print('第', gen, '代', '用时：', time.time() - start_time, '秒')
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) # 计算当代最优个体的序号
obj_trace[gen, 0] = np.sum(ObjV) / NIND # 记录当代种群的目标函数均值
# 种群个体数目
MAXGEN = 70
# 最大遗传代数
GGAP = 0.9
# 代沟：说明子代与父代的重复率为0.1
PM = 1
#整条染色体的变异概率(每一位的变异概率=pm/染色体长度)
selectStyle = 'sus' #采用随机抽样选择
recStyle = 'xovdp' #采用两点交叉
mutStyle = 'mutbin' #采用二进制染色体的变异算子
"""=========================开始遗传算法进化========================"""
FieldD = ga.crtfld(encoding, varTypes, ranges, borders, precisions, codes,
scales) # 调用函数创建区域描述器
Lind = int(np.sum(FieldD[0, :])) # 计算编码后的染色体长度
Chrom = ga.crtpc(encoding, NIND, FieldD) # 根据区域描述器生成二进制种群
variable = ga.bs2real(Chrom, FieldD) #对初始种群进行解码
ObjV = aim(variable) # 计算初始种群个体的目标函数值
pop_trace = (np.zeros((MAXGEN, 2)) * np.nan) # 定义进化记录器，初始值为nan
ind_trace = (np.zeros(
(MAXGEN, Lind)) * np.nan) # 定义种群最优个体记录器，记录每一代最优个体的染色体，初始值为nan
# 开始进化！！
for gen in range(MAXGEN):
FitnV = ga.ranking(-ObjV) # 根据目标函数大小分配适应度值(由于遵循目标最小化约定，因此最大化问题要对目标函数值乘上-1)
SelCh = Chrom[ga.selecting(selectStyle, FitnV,
NIND - 1)] # 选择，采用'sus'随机抽样选择
SelCh = ga.recombin(recStyle, SelCh, GGAP) # 重组(采用单点交叉方式，交叉概率为0.7)
SelCh = ga.mutate(mutStyle, encoding, SelCh, PM) # 二进制种群变异
variable = ga.bs2real(Chrom, FieldD) # 对育种种群进行解码(二进制转十进制)
ObjVSel = aim(variable) # 求育种个体的目标函数值
# 记录
best_ind = np.argmax(ObjV) # 计算当代最优个体的序号
def main():
"""============================变量设置============================"""
x1 = [50, 100] # 第一个决策变量范围
x2 = [50, 100] # 第二个决策变量范围
x3 = [50, 100]
x4 = [50, 100]
x5 = [50, 100]
x6 = [50, 100]
x7 = [50, 100]
x8 = [50, 100]
x9 = [50, 100]
x10 = [50, 100]
b1 = [1, 1] # 第一个决策变量边界，1表示包含范围的边界，0表示不包含
b2 = [1, 1] # 第二个决策变量边界，1表示包含范围的边界，0表示不包含
b3 = [1, 1]
b4 = [1, 1]
b5 = [1, 1]
b6 = [1, 1]
b7 = [1, 1]
b8 = [1, 1]
b9 = [1, 1]
b10 = [1, 1]
ranges = np.vstack([x1, x2, x3, x4, x5, x6, x7, x8, x9,
x10]).T # 生成自变量的范围矩阵，使得第一行为所有决策变量的下界，第二行为上界
borders = np.vstack([b1, b2, b3, b4, b5, b6, b7, b8, b9,
b10]).T # 生成自变量的边界矩阵
varTypes = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) # 决策变量的类型，0表示连续，1表示离散
"""==========================染色体编码设置========================="""
Encoding = 'BG' # 'BG'表示采用二进制/格雷编码
codes = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # 决策变量的编码方式，设置两个0表示两个决策变量均使用二进制编码
precisions = [4, 4, 4, 4, 4, 4, 4, 4, 4,
4] # 决策变量的编码精度，表示二进制编码串解码后能表示的决策变量的精度可达到小数点后6位
scales = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # 0表示采用算术刻度，1表示采用对数刻度
FieldD = ea.crtfld(Encoding, varTypes, ranges, borders, precisions, codes,
scales) # 调用函数创建译码矩阵
"""=========================遗传算法参数设置========================"""
NIND = 30 # 种群个体数目
MAXGEN = 30 # 最大遗传代数
maxormins = [1] # 列表元素为1则表示对应的目标函数是最小化，元素为-1则表示对应的目标函数是最大化
selectStyle = 'rws' # 采用轮盘赌选择
recStyle = 'xovdp' # 采用两点交叉
mutStyle = 'mutbin' # 采用二进制染色体的变异算子
pc = 0.7 # 交叉概率
pm = 1 # 整条染色体的变异概率（每一位的变异概率=pm/染色体长度）
Lind = int(np.sum(FieldD[0, :])) # 计算染色体长度
obj_trace = np.zeros((MAXGEN, 2)) # 定义目标函数值记录器
var_trace = np.zeros((MAXGEN, Lind)) # 染色体记录器，记录历代最优个体的染色体
"""=========================开始遗传算法进化========================"""
start_time = time.time() # 开始计时
Chrom = ea.crtpc(Encoding, NIND, FieldD) # 生成种群染色体矩阵
variable = ea.bs2real(Chrom, FieldD) # 对初始种群进行解码
ObjV = minfun(variable) # 计算初始种群个体的目标函数值
FitnV = ea.ranking(maxormins * ObjV) # 根据目标函数大小分配适应度值
best_ind = np.argmax(FitnV) # 计算当代最优个体的序号
# 开始进化
for gen in range(MAXGEN):
print(gen)
SelCh = Chrom[ea.selecting(selectStyle, FitnV, NIND - 1), :] # 选择
SelCh = ea.recombin(recStyle, SelCh, pc) # 重组
SelCh = ea.mutate(mutStyle, Encoding, SelCh, pm) # 变异
# 把父代精英个体与子代的染色体进行合并，得到新一代种群
Chrom = np.vstack([Chrom[best_ind, :], SelCh])
Phen = ea.bs2real(Chrom, FieldD) # 对种群进行解码(二进制转十进制)
print(Phen)
ObjV = minfun(Phen) # 求种群个体的目标函数值
FitnV = ea.ranking(maxormins * ObjV) # 根据目标函数大小分配适应度值
# 记录
best_ind = np.argmax(FitnV) # 计算当代最优个体的序号
obj_trace[gen, 0] = np.sum(ObjV) / ObjV.shape[0] # 记录当代种群的目标函数均值
obj_trace[gen, 1] = ObjV[best_ind] # 记录当代种群最优个体目标函数值
var_trace[gen, :] = Chrom[best_ind, :] # 记录当代种群最优个体的染色体
print(best_ind)
# 进化完成
end_time = time.time() # 结束计时
ea.trcplot(obj_trace, [['种群个体平均目标函数值', '种群最优个体目标函数值']]) # 绘制图像
"""============================输出结果============================"""
best_gen = np.argmin(obj_trace[:, [1]])
print('最优解的目标函数值：', obj_trace[best_gen, 1])
variable = ea.bs2real(var_trace[[best_gen], :],
FieldD) # 解码得到表现型（即对应的决策变量值）
print('最优解的决策变量值为：')
print(variable)
print('用时：', end_time - start_time, '秒')
scales)
NIND = 20
MAXGEN = 100
maxorins = np.array([1])
selectStyle = 'sus'
recStyle = 'xovdp'
mutStyle = 'mutbin'
Lind = int(np.sum(FieldD[0, :]))
pc = 0.9
pm = 1 / Lind
obj_trace = np.zeros((MAXGEN, 2))
var_trace = np.zeros((MAXGEN, Lind))
start_time = time.time()
Chrom = ea.crtpc(Encoding, NIND, FieldD)
variable = ea.bs2real(Chrom, FieldD)
ObjV = aim(variable)
best_ind = np.argmin(ObjV)
for gen in range(MAXGEN):
FitnV = ea.ranking(maxorins * ObjV)
SelCh = Chrom[ea.selecting(selectStyle, FitnV, NIND - 1), :]
SelCh = ea.recombin(recStyle, SelCh, pc)
SelCh = ea.mutate(mutStyle, Encoding, SelCh, pm)
Chrom = np.vstack([Chrom[best_ind, :], SelCh])
Phen = ea.bs2real(Chrom, FieldD)
ObjV = aim(Phen)
best_ind = np.argmin(ObjV)
obj_trace[gen, 0] = np.sum(ObjV) / ObjV.shape[0]
obj_trace[gen, 1] = ObjV[best_ind]
var_trace[gen, :] = Chrom[best_ind, :]
precisions = [4] # 变量的编码精度
scales = [0] # 采用算法刻度
ranges = np.vstack([x1]).T # 自变量范围矩阵
borders = np.vstack([b1]).T # 自变量边界矩阵
"""遗传算法参数设置"""
NIND = 40 # 种群个体数目
MAXGN = 25 # 最大遗传代数
FieldD = ea.crtfld(Encoding, varTypes, ranges, borders, precisions, codes,
scales) # 调用函数创建区域描述器
Lind = int(np.sum(FieldD[0, :])) # 计算编码后染色体长度
obj_trace = np.zeros((MAXGN, 2)) # 定于目标函数值记录器
var_trace = np.zeros((MAXGN, 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(MAXGN):
FitnV = ea.ranking(-ObjV) # 根据目标函数大小分配适应度
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) # 育种群体编码（2进制转10进制）
ObjV = aim(variable)
# 记录
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]