def train(dim, maxIter):
problem = MyProblem() # 生成问题对象
NIND = dim # 种群规模
# 创建区域描述器，这里需要创建两个， 前2个变量用RI编码，剩余变量用排列编码
Encodings = ['RI', 'P']
Field1 = ea.crtfld(Encodings[0], problem.varTypes[:2],
problem.ranges[:, :2], problem.borders[:, :2])
Field2 = ea.crtfld(Encodings[1], problem.varTypes[2:],
problem.ranges[:, 2:], problem.borders[:, 2:])
Fields = [Field1, Field2]
population = ea.PsyPopulation(Encodings, Fields,
NIND) # 实例化种群对象（此时种群还没被初始化，仅仅是完成种群对象的实例化）
myAlgorithm = ea.soea_psy_SEGA_templet(problem, population) # 实例化一个算法模板对象
myAlgorithm.MAXGEN = maxIter # 最大进化代数
[population, obj_trace, var_trace] = myAlgorithm.run() # 执行算法模板
population.save() # 把最后一代种群的信息保存到文件中
# 输出结果
best_gen = np.argmin(problem.maxormins * obj_trace[:, 1]) # 记录最优种群个体是在哪一代
best_ObjV = obj_trace[best_gen, 1]
print('最优的目标函数值为：%s' % (best_ObjV))
print('最优的控制变量值为：')
for i in range(var_trace.shape[1]):
print(var_trace[best_gen, i])
print('有效进化代数：%s' % (obj_trace.shape[0]))
print('最优的一代是第 %s 代' % (best_gen + 1))
print('评价次数：%s' % (myAlgorithm.evalsNum))
print('时间已过 %s 秒' % (myAlgorithm.passTime))
def __init__(self,
problem,
population,
MAXGEN=None,
MAXTIME=None,
MAXEVALS=None,
MAXSIZE=None,
logTras=None,
verbose=None,
outFunc=None,
dirName=None,
**kwargs):
"""
描述:
构造函数。
"""
if dirName is None:
dirName = ''
if dirName != '':
dirName += '/'
# 静态属性
self.name = 'Algorithm'
self.problem = problem
self.population = population
self.MAXGEN = MAXGEN
self.MAXTIME = MAXTIME
self.MAXEVALS = MAXEVALS
self.MAXSIZE = MAXSIZE
self.logTras = 1 if logTras is None else logTras
self.verbose = True if verbose is None else verbose
self.outFunc = outFunc
self.dirName = dirName
# 动态属性
self.currentGen = None
self.timeSlot = None
self.passTime = None
self.evalsNum = None
self.log = None
self.stopMsg = ''
# 初始化种群的译码矩阵
if isinstance(population, ea.Population):
if population.ChromNum == 1: # 如果是单染色体种群
if population.Field is None:
self.population = ea.Population(
Encoding=population.Encoding,
Field=(problem.varTypes, problem.ranges,
problem.borders),
NIND=population.sizes)
else: # 如果是多染色体种群
if population.Fields is None:
self.population = ea.PsyPopulation(
Encodings=population.Encodings,
Fields=(problem.varTypes, problem.ranges,
problem.borders),
NIND=population.sizes,
EncoIdxs=population.EncoIdxs)
def solve_one_file(graph, sdn_count, sdn_nodes, bandwidth, filename):
traffic = project_xml_reader.parse_traffics(filename)
# 区域描述
problem = SOHybridNetTEOptimizeProblem(graph, sdn_count, traffic, bandwidth, filename, True)
Encodings = ['P', 'RI']
Field1 = ea.crtfld(Encodings[0], problem.varTypes[:sdn_count],
problem.ranges[:, :sdn_count], problem.borders[:, :sdn_count]) # 创建区域描述器
Field2 = ea.crtfld(Encodings[1], problem.varTypes[sdn_count:],
problem.ranges[:, sdn_count:], problem.borders[:, sdn_count:]) # 创建区域描述器
Fields = [Field1, Field2]
weight_size = int(np.sum(graph == 1) / 2)
# weights = [233, 846, 1, 1176, 1893, 366, 861, 1295, 2095, 902, 639, 587, 548, 700, 260]
weights = [1] * weight_size
pop = ea.PsyPopulation(Encodings, Fields, 1, Phen=np.array([sdn_nodes + weights]))
return problem.aimFunc1(pop)
# -*- coding: utf-8 -*-
from MyProblem import MyProblem # 导入自定义问题接口
import geatpy as ea # import geatpy
"""
该案例展示了一个需要混合编码种群来进化的最大化目标的单目标优化问题。问题的定义详见MyProblem.py。
分析：
该问题可以单纯用实整数编码'RI'来实现，但由于有一个”x3,x4,x5,x6互不相等“的约束，
因此把x3,x4,x5,x6用排列编码'P'，x1和x2采用实整数编码'RI'来求解会更好。
MyProblem是问题类，本质上是不需要管具体使用什么编码的，因此混合编码的设置在执行脚本main.py中进行而不是在此处。
"""
if __name__ == '__main__':
# 实例化问题对象
problem = MyProblem()
# 快速构建算法
algorithm = ea.soea_psy_EGA_templet(
problem,
ea.PsyPopulation(Encodings=['RI', 'P'],
NIND=40,
EncoIdxs=[[0, 1], [2, 3, 4, 5]]),
MAXGEN=25, # 最大进化代数
logTras=1) # 表示每隔多少代记录一次日志信息，0表示不记录。
# 求解
res = ea.optimize(algorithm,
verbose=True,
drawing=1,
outputMsg=True,
drawLog=False,
saveFlag=True)
print(res)
from MyProblem import MyProblem # 导入自定义问题接口
if __name__ == '__main__':
"""===============================实例化问题对象============================"""
problem = MyProblem() # 生成问题对象
"""==================================种群设置=============================="""
NIND = 30 # 种群规模
# 创建区域描述器，这里需要创建两个，前1个变量用RI编码，剩余变量用排列编码
Encodings = ['RI', 'P'] # 编码方式列表
Field1 = ea.crtfld(Encodings[0], problem.varTypes[:1],
problem.ranges[:, :1],
problem.borders[:, :1]) # 创建区域描述器
Field2 = ea.crtfld(Encodings[1], problem.varTypes[1:],
problem.ranges[:, 1:], problem.borders[:, 1:])
Fields = [Field1, Field2]
population = ea.PsyPopulation(Encodings, Fields,
NIND) # 实例化种群对象（此时种群还没被初始化，仅仅是完成种群对象的实例化）
"""================================算法参数设置============================"""
myAlgorithm = ea.moea_psy_NSGA2_templet(problem, population) # 实例化一个算法模板对象
myAlgorithm.MAXGEN = 200 # 最大进化代数
myAlgorithm.logTras = 0 # 设置每多少代记录日志，若设置成0则表示不记录日志
myAlgorithm.verbose = False # 设置是否打印输出日志信息
myAlgorithm.drawing = 1 # 设置绘图方式（0：不绘图；1：绘制结果图；2：绘制目标空间过程动画；3：绘制决策空间过程动画）
"""==========================调用算法模板进行种群进化=========================
调用run执行算法模板，得到帕累托最优解集NDSet以及最后一代种群。NDSet是一个种群类Population的对象。
NDSet.ObjV为最优解个体的目标函数值；NDSet.Phen为对应的决策变量值。
详见Population.py中关于种群类的定义。
"""
[NDSet, population] = myAlgorithm.run() # 执行算法模板，得到非支配种群以及最后一代种群
NDSet.save() # 把非支配种群的信息保存到文件中
"""==================================输出结果=============================="""
print('用时：%s 秒' % myAlgorithm.passTime)
import numpy as np
import geatpy as ea
from MyProblem import MyProblem #导入自定义问题接口
'''=========== 实例化问题对象==========='''
steps = [3,1,4,2,3,2,2,2,2,1]
problem = MyProblem() #生成问题对象
'''=========== 种群设置==========='''
NIND = 40 #种群规模
# 创建区域描述器，这里需要创建两个，分别是工序编码 机器编码
Encodings = ['RI', 'RI']
# crtfld (生成译码矩阵，俗称“区域描述器”)
Field1 = ea.crtfld(Encodings[0], problem.varTypes[:sum(steps)], problem.ranges[:,:sum(steps)], problem.borders[:,:sum(steps)]) # 创建区域描述器
Field2 = ea.crtfld(Encodings[1], problem.varTypes[sum(steps):], problem.ranges[:,sum(steps):], problem.borders[:,sum(steps):])
Fields = [Field1, Field2]
#实例化种群对象（此时种群还没被初始化，仅仅是完成种群对象的实例化）
population = ea.PsyPopulation(Encodings, Fields, NIND)
'''=================算法参数设置==================='''
myAlgorithm = ea.moea_psy_NSGA2_templet(problem, population) # 实例化一个算法模板对象
myAlgorithm.MAXGEN = 700 # 最大进化代数
myAlgorithm.drawing = 2 # 设置绘图方式（0：不绘图；1：绘制结果图；2：绘制过程动画）
"""===========================调用算法模板进行种群进化======================"""
NDSet = myAlgorithm.run() # 执行算法模板，得到帕累托最优解集NDSet
NDSet.save() # 把结果保存到文件中
# 输出
print('用时：%s 秒'%(myAlgorithm.passTime))
print('非支配个体数：%s 个'%(NDSet.sizes))
print('单位时间找到帕累托前沿点个数：%s 个'%(int(NDSet.sizes // myAlgorithm.passTime)))
def geaty_func(func,
dim,
lb,
ub,
NIND=400,
MAXGEN=25,
fig_dir="",
njobs=0,
method="SEGA",
n_populations=5,
opt_res=None):
"""
将整个遗传算法过程进行整合，编写成一整个函数，便于之后使用。当前此函数，只能处理参数是连续
型的最优化问题。
args：
func: 用于最小化的函数。
dim: 需要优化的params的个数。
lb，ub：array或list，是params的上下限，这里默认都是闭区间。
NIND: 种群规模
MAXGEN: 最大进化代数
fig_dir: 保存图片的地址，注意，需要在最后加/
njobs: 0，1使用单核、否则使用多核，其中-1表示使用所有的核
method: 使用的进化算法模板：
SEGA：增强精英保留的遗传算法模板
multiSEGA：增强精英保留的多种群协同遗传算法
psySEGA：增强精英保留的多染色体遗传算法
rand1lDE: 差分进化DE/rand/1/L算法
n_populations: 如果是multiSEGA，此表示的是种群数量
"""
""" 实例化问题对象 """
problem = MyProblem(func, dim, lb, ub, njobs=njobs) # 生成问题对象
""" 种群设置 """
# 创建区域描述器
# (不同的方法使用不同的编码方式)
# if "DE" in method:
Encoding = "RI"
# else:
# Encoding = "BG"
# 实例化种群对象（此时种群还没被初始化，仅仅是完成种群对象的实例化）
if method == "multiSEGA":
one_ind = NIND // n_populations
res_ind = NIND % n_populations
NINDS = [one_ind] * n_populations
NINDS[-1] = NINDS[-1] + res_ind
population = []
for nind in NINDS:
Field = ea.crtfld(Encoding, problem.varTypes, problem.ranges,
problem.borders)
population.append(ea.Population(Encoding, Field, nind))
# --------------------------------------------
# opt_res = load("./RESULTS2/test0418_5/opt_res.pkl")
if opt_res is not None:
prophetChrom = np.expand_dims(opt_res["BestParam"], axis=0)
prophetChrom = np.tile(opt_res["BestParam"], (2, 1))
prophetPops = []
for i in range(len(population)):
prophetPop = ea.Population(Encoding, Field, 2, prophetChrom)
prophetPop.Phen = prophetPop.decoding()
problem.aimFunc(prophetPop)
prophetPops.append(prophetPop)
else:
prophetPops = None
# --------------------------------------------
else:
# --------------------------------------------
# prophetPops = None
# --------------------------------------------
Field = ea.crtfld(Encoding, problem.varTypes, problem.ranges,
problem.borders)
if method == "psySEGA":
raise NotImplementedError
population = ea.PsyPopulation([Encoding], [Field], NIND)
else:
population = ea.Population(Encoding, Field, NIND)
""" 算法参数设置 """
if method == "SEGA":
algorithm = ea.soea_SEGA_templet
elif method == "multiSEGA":
algorithm = ea.soea_multi_SEGA_templet
elif method == "psySEGA":
algorithm = ea.soea_psy_SEGA_templet
elif method == "rand1lDE":
algorithm = ea.soea_DE_rand_1_L_templet
else:
raise NotImplementedError
# 实例化一个算法模板对象
myAlgorithm = algorithm(problem, population)
# 最大进化代数
myAlgorithm.MAXGEN = MAXGEN
# "进化停滞"判断阈值
# myAlgorithm.trappedValue = 1e-6
# 进化停滞计数器最大上限值，如果连续maxTrappedCount代被判定进化陷入停滞，则终止进化
# myAlgorithm.maxTrappedCount = 100
# 控制是否绘制图片
myAlgorithm.drawing = 1
# 控制绘图的路径（自己改的源码）
myAlgorithm.drawing_file = fig_dir
""" 调用算法模板进行种群进化 """
[population, obj_trace, var_trace] = myAlgorithm.run(prophetPops) # 执行算法模板
# population.save() # 把最后一代种群的信息保存到文件中
""" 输出结果 """
# 记录最优种群个体是在哪一代
best_gen = np.argmin(problem.maxormins * obj_trace[:, 1])
best_ObjV = obj_trace[best_gen, 1]
print('最优的目标函数值为：%s' % (best_ObjV))
# print('最优的控制变量值为：')
# for i in range(var_trace.shape[1]):
# print(var_trace[best_gen, i])
print('有效进化代数：%s' % (obj_trace.shape[0]))
print('最优的一代是第 %s 代' % (best_gen + 1))
print('评价次数：%s' % (myAlgorithm.evalsNum))
print('时间已过 %s 秒' % (myAlgorithm.passTime))
return {
"BestObjv": best_ObjV,
"BestParam": var_trace[best_gen, :],
"AvailableEvoluion": obj_trace.shape[0],
"EvaluationCount": myAlgorithm.evalsNum,
"PassTime": myAlgorithm.passTime,
"VarTrace": var_trace,
"ObjTrace": obj_trace,
"population": population,
}
# -*- coding: utf-8 -*-
from MyProblem import MyProblem # 导入自定义问题接口
import geatpy as ea # import geatpy
if __name__ == '__main__':
# 实例化问题对象
problem = MyProblem()
# 构建算法
algorithm = ea.moea_psy_NSGA2_templet(problem,
ea.PsyPopulation(Encodings=['RI', 'P'], NIND=30, EncoIdxs=[[0], [1,2,3,4]]),
MAXGEN=200, # 最大进化代数
logTras=0) # 表示每隔多少代记录一次日志信息，0表示不记录。
# 求解
res = ea.optimize(algorithm, verbose=False, drawing=1, outputMsg=True, drawLog=False, saveFlag=True)
print(res)
