def alpso_wrapper(opt_prob):
alpso = ALPSO()
alpso.setOption('SwarmSize', 10) # default 40 -> 150
alpso.setOption('maxOuterIter', 5) # defualt 200
# alpso.setOption('rinit', 1.) # penalty factor
alpso.setOption('fileout', 0)
alpso.setOption('stopCriteria', 0)
return alpso(opt_prob)
def optimALPSO(opt_prob, swarmsize, maxiter,algo):
if algo == 3:
alpso_none = ALPSO(pll_type='SPM')
else:
alpso_none = ALPSO()
alpso_none.setOption('fileout',1)
alpso_none.setOption('filename',"test.out")
alpso_none.setOption('SwarmSize',swarmsize)
alpso_none.setOption('maxInnerIter',6)
alpso_none.setOption('etol',1e-5)
alpso_none.setOption('rtol',1e-10)
alpso_none.setOption('atol',1e-10)
alpso_none.setOption('vcrazy',1e-4)
alpso_none.setOption('dt',1e0)
alpso_none.setOption('maxOuterIter',maxiter)
alpso_none.setOption('stopCriteria',0)#Stopping Criteria Flag (0 - maxIters, 1 - convergence)
alpso_none.setOption('printInnerIters',1)
alpso_none.setOption('printOuterIters',1)
alpso_none.setOption('HoodSize',int(swarmsize/100))
return(alpso_none(opt_prob))
def train(self, optimizer='pso'):
#Define the optimization problem for training the kriging model
opt_prob = Optimization('Surrogate Test', self.fittingObjective)
for i in range(self.k):
opt_prob.addVar('theta%d' % i,
'c',
lower=1e-3,
upper=1e2,
value=.1)
for i in range(self.k):
opt_prob.addVar('pl%d' % i, 'c', lower=1.5, upper=2, value=2)
opt_prob.addVar('lambda', 'c', lower=1e-5, upper=1, value=1)
opt_prob.addObj('f')
opt_prob.addCon('g1', 'i')
if optimizer == 'pso':
optimizer = ALPSO()
optimizer.setOption('SwarmSize', 150)
optimizer.setOption('maxOuterIter', 150)
optimizer.setOption('stopCriteria', 1)
optimizer.setOption('filename', '{0}Results.log'.format(self.name))
if optimizer == 'ga':
optimizer = NSGA2()
optimizer.setOption('PopSize', (4 * 50))
while True:
try:
self.trainingOptimizer(optimizer, opt_prob)
except Exception as e:
print e
print 'Error traning Model, restarting the optimizer with a larger population'
if optimizer == 'ga':
optimizer.setOption('SwarmSize', 200)
optimizer.setOption('maxOuterIter', 100)
optimizer.setOption('stopCriteria', 1)
if optimizer == 'ga':
optimizer.setOption('PopSize', 400)
else:
break
def infill(self, points, method='error'):
## We'll be making non-permanent modifications to self.X and self.y here, so lets make a copy just in case
initX = np.copy(self.X)
inity = np.copy(self.y)
## This array will hold the new values we add
returnValues = np.zeros([points, self.k], dtype=float)
for i in range(points):
opt_prob1 = Optimization('InFillPSO',
self.errorObjective_normalized)
for k in range(self.k):
opt_prob1.addVar('{0}'.format(k),
'c',
lower=0,
upper=1,
value=.5)
pso1 = ALPSO()
pso1.setOption('SwarmSize', 100)
pso1.setOption('maxOuterIter', 100)
pso1.setOption('stopCriteria', 1)
pso1(opt_prob1)
newpoint = np.zeros(self.k)
for j in range(self.k):
newpoint[j] = opt_prob1.solution(0)._variables[j].value
returnValues[i][:] = self.inversenormX(newpoint)
self.addPoint(returnValues[i],
self.predict(returnValues[i]),
norm=True)
self.updateModel()
del (opt_prob1)
del (pso1)
self.X = np.copy(initX)
self.y = np.copy(inity)
self.n = len(self.X)
self.updateModel()
return returnValues
minstep=1e-8,
debug=1,
phip=0.5,
phig=0.5,
maxiter=maxiter)
##############################################################################
##############################################################################
# solving the problem with yopt
##############################################################################
##############################################################################
swarmsize = comm.bcast(swarmsize, root=0)
maxiter = comm.bcast(maxiter, root=0)
if algo == 2:
# Solve Problem (No-Parallelization)
alpso_none = ALPSO() #pll_type='SPM')
alpso_none.setOption('fileout', 1)
alpso_none.setOption('SwarmSize', swarmsize)
alpso_none.setOption('maxInnerIter', 6)
alpso_none.setOption('etol', 1e-5)
alpso_none.setOption('rtol', 1e-10)
alpso_none.setOption('atol', 1e-10)
alpso_none.setOption('vcrazy', 1e-4)
alpso_none.setOption('dt', 1e0)
alpso_none.setOption('maxOuterIter', maxiter)
alpso_none.setOption(
'stopCriteria',
0) #Stopping Criteria Flag (0 - maxIters, 1 - convergence)
alpso_none.setOption('printInnerIters', 1)
alpso_none.setOption('printOuterIters', 1)
alpso_none.setOption('HoodSize', swarmsize / 100)
# =============================================================================
#
# =============================================================================
# Instantiate Optimization Problem
opt_prob = Optimization('G08 Global Constrained Problem', objfunc)
opt_prob.addVar('x1', 'c', lower=5.0, upper=1e-6, value=10.0)
opt_prob.addVar('x2', 'c', lower=5.0, upper=1e-6, value=10.0)
opt_prob.addObj('f')
opt_prob.addCon('g1', 'i')
opt_prob.addCon('g2', 'i')
# Solve Problem (No-Parallelization)
alpso_none = ALPSO()
alpso_none.setOption('fileout', 0)
alpso_none(opt_prob)
if myrank == 0:
print opt_prob.solution(0)
# end
# Solve Problem (SPM-Parallelization)
alpso_spm = ALPSO(pll_type='SPM')
alpso_spm.setOption('fileout', 0)
alpso_spm(opt_prob)
print opt_prob.solution(1)
# Solve Problem (DPM-Parallelization)
alpso_dpm = ALPSO(pll_type='DPM')
alpso_dpm.setOption('fileout', 0)
# =============================================================================
#
# =============================================================================
# Instantiate Optimization Problem
opt_prob = Optimization('G08 Global Constrained Problem', objfunc)
opt_prob.addVar('x1', 'c', lower=5.0, upper=1e-6, value=10.0)
opt_prob.addVar('x2', 'c', lower=5.0, upper=1e-6, value=10.0)
opt_prob.addObj('f')
opt_prob.addCon('g1', 'i')
opt_prob.addCon('g2', 'i')
# Solve Problem (No-Parallelization)
alpso_none = ALPSO()
alpso_none.setOption('fileout', 0)
alpso_none(opt_prob)
if myrank == 0:
print(opt_prob.solution(0))
# Solve Problem (SPM-Parallelization)
alpso_spm = ALPSO(pll_type='SPM')
alpso_spm.setOption('fileout', 0)
alpso_spm(opt_prob)
print(opt_prob.solution(1))
# Solve Problem (DPM-Parallelization)
alpso_poa = ALPSO(pll_type='POA')
alpso_poa.setOption('fileout', 0)
alpso_poa(opt_prob)
for i in range(x.shape[1]):
opt_prob.addVar('theta%d' % i, 'c', lower=.05, upper=20, value=.2)
for i in range(x.shape[1]):
opt_prob.addVar('pl%d' % i, 'c', lower=1, upper=2, value=1.75)
opt_prob.addObj('f')
opt_prob.addCon('g1', 'i')
#print out the problem
print opt_prob
#Run the GA
# nsga = NSGA2(PopSize=300, maxGen=500, pMut_real=.1)
# nsga(opt_prob)
#
pso = ALPSO()
pso.setOption('SwarmSize', 30)
pso.setOption('maxOuterIter', 100)
pso.setOption('stopCriteria', 1)
# pso.setOption('dt',1)
pso(opt_prob)
#print the best solution
print opt_prob.solution(0)
# Update the model variables to the best solution found by the optimizer
a.update([
opt_prob.solution(0)._variables[0].value,
opt_prob.solution(0)._variables[1].value,
opt_prob.solution(0)._variables[2].value,
opt_prob.solution(0)._variables[3].value,
