return f, g, fail
opt_prob = pyOpt.Optimization('Minimize Chi**2', objfunc)
opt_prob.addVar('Amp', 'c', lower=0.0, upper=42.0, value=1.0)
opt_prob.addVar('LifeTime', 'c', lower=0.0, upper=42.0, value=2.0)
opt_prob.addVar('Offset', 'c', lower=0.0, upper=42.0, value=3.0)
opt_prob.addVar('ScatterAmp', 'c', lower=0.0, upper=42.0, value=4.0)
opt_prob.addObj('Minimize Chi**2', value=0.0, optimum=0.0)
print opt_prob
slsqp = pyOpt.SLSQP()
slsqp.setOption('IPRINT', -1)
[fstr, xstr, inform] = slsqp(opt_prob, disp_opts=True, sens_type='FD')
print opt_prob.solution(0)
# ------------------------------------------------
Plot = False
if Plot:
from Display import ForkDisplay
print "\nPlotting: Aligned Data:"
ForkDisplay(Time,
AlignedRaw,
Title="Aligned Raw Data",
for i, name in enumerate(Con_Names):
The_Problem.addCon(name, 'e')
# inequality constraint
Con_Names = The_Project.config_current['OPT_CONSTR']['INEQUALITY'].keys()
for i, name in enumerate(Con_Names):
The_Problem.addCon(name, 'i')
print The_Problem
# -------------------------------------------------------------------
# Run Optimizer
# -------------------------------------------------------------------
# SLSQP
The_Optimizer = pyOpt.SLSQP()
The_Optimizer.setOption('IPRINT', -1)
The_Optimizer.setOption('MAXIT', its)
The_Optimizer.setOption('ACC', 1e-8)
# CONMIN
#The_Optimizer = pyOpt.CONMIN()
#The_Optimizer.setOption('IPRINT',1)
#The_Optimizer.setOption('ITMAX',its)
#The_Optimizer.setOption('DABFUN',1e-6)
#The_Optimizer.setOption('DELFUN',1e-6)
# Call the Optimizer
The_Optimizer(The_Problem, sens_type=the_Gradient)
print The_Problem.solution(0)
def main():
# Default input parameters
p=para()
nelx = p.nelx
nely = p.nely
nelz = p.nelz
volfrac = p.volfrac
rmin = p.rmin
penal = p.penal
ft = p.ft # ft==0 -> sens, ft==1 -> dens
# Max and min stiffness
Emin = 1e-3
Emax = 1.0
# Set loop counter and gradient vectors
loop = 0
change = 1
# Allocate design variables (as array), initialize and allocate sens.
x = volfrac * np.ones(nely * nelx * nelz, dtype=float)
# Initialize plot and plot the initial design
# plot a cross section perpendicular to z direction
plt.ion() # Ensure that redrawing is possible
for i in range(nelz):
locals()['fig' + str(i+1)], locals()['ax'+str(i+1)] = plt.subplots()
locals()['im' + str(i+1)] = locals()['ax'+str(i+1)].imshow(-x[nelx*nely*i:nelx*nely*(i+1)].reshape((nelx, nely)).T, cmap='gray', \
interpolation='none', norm=colors.Normalize(vmin=-1, vmax=0))
locals()['fig' + str(i + 1)].show()
plt.show()
t1 = 0
while change > 0.01 and loop < 2000:
t1old=t1
t1 = time.clock()
xold = x.copy()
loop = loop + 1
#use pyOpt to solve the problem
opt_prob = pyOpt.Optimization('3d', objfunc)
#Assigning Design Variables
for i in range(nelx * nely * nelz):
opt_prob.addVar('element by order', 'c', lower=Emin, upper=Emax, value=x[i])
#Assigning Objective:
opt_prob.addObj('f')
#Assigning Constraints:
opt_prob.addCon('g', 'e')
t2=time.clock()
opt = pyOpt.SLSQP()
#new x and obj
optsol = opt(opt_prob,sens_type=SENSE)
# Filter design variables
# Finalize assembly and convert to csc format
HH = FILTERMATRIX(nelx, nely, nelz, rmin)
H = HH.assembly()
Hs = H.sum(1)
if ft == 0:
x = optsol[1]
elif ft == 1:
x = np.asarray(H * optsol[1][np.newaxis].T / Hs)[:, 0]
t3=time.clock()
obj = optsol[0][0]
vol = x.sum()/(nelx * nely * nelz)
#Compute the change by the inf. norm
change = np.linalg.norm(x.reshape(nelx * nely * nelz, 1) - xold.reshape(nelx * nely * nelz, 1), np.inf)
t4=time.clock()
# Plot to screen
for i in range(nelz):
locals()['im' + str(i + 1)].set_array(-x[nelx*nely*i:nelx*nely*(i+1)].reshape((nelx, nely)).T)
locals()['fig' + str(i + 1)].canvas.draw()
t5=time.clock()
# Write iteration history to screen (req. Python 2.6 or newer)
print("it.: {0} , obj.: {1:.3f} Vol.: {2:.3f}, ch.: {3:.3f}".format( \
loop, obj, vol, change))
print("t1-t1old.: {0:.5f} , t2-t1.: {1:.5f} , t3-t2.: {2:.5f}".format( \
t1-t1old, t2-t1, t3-t2, t4-t3, t5-t4))
print("t4-t3.: {0:.5f} , t4-t4.: {1:.5f} \n".format( \
t4-t3, t5-t4))
# Make sure the plot stays and that the shell remains
plt.show()
raw_input("Press any key...")
def runOptimizer(self, opt_prob):
# type: (pyOpt.Optimization) -> np._ArrayLike[float]
''' call global followed by local optimizer, return solution '''
import pyOpt
initial = [v.value for v in list(opt_prob.getVarSet().values())]
if self.config['useGlobalOptimization']:
### optimize using pyOpt (global)
sr = random.SystemRandom()
if self.config['globalSolver'] == 'NSGA2':
if parallel:
opt = pyOpt.NSGA2(pll_type='POA') # genetic algorithm
else:
opt = pyOpt.NSGA2()
if self.config['globalOptSize'] % 4:
raise IOError(
"globalOptSize needs to be a multiple of 4 for NSGA2")
opt.setOption('PopSize', self.config['globalOptSize']
) # Population Size (a Multiple of 4)
opt.setOption('maxGen', self.config['globalOptIterations']
) # Maximum Number of Generations
opt.setOption(
'PrintOut', 0
) # Flag to Turn On Output to files (0-None, 1-Subset, 2-All)
opt.setOption(
'xinit', 1
) # Use Initial Solution Flag (0 - random population, 1 - use given solution)
opt.setOption('seed', sr.random(
)) # Random Number Seed 0..1 (0 - Auto based on time clock)
#pCross_real 0.6 Probability of Crossover of Real Variable (0.6-1.0)
opt.setOption(
'pMut_real',
0.5) # Probablity of Mutation of Real Variables (1/nreal)
#eta_c 10.0 # Distribution Index for Crossover (5-20) must be > 0
#eta_m 20.0 # Distribution Index for Mutation (5-50) must be > 0
#pCross_bin 0.0 # Probability of Crossover of Binary Variable (0.6-1.0)
#pMut_real 0.0 # Probability of Mutation of Binary Variables (1/nbits)
self.iter_max = self.config['globalOptSize'] * self.config[
'globalOptIterations']
elif self.config['globalSolver'] == 'ALPSO':
if parallel:
opt = pyOpt.ALPSO(
pll_type='SPM'
) #augmented lagrange particle swarm optimization
else:
opt = pyOpt.ALPSO(
) #augmented lagrange particle swarm optimization
opt.setOption('stopCriteria', 0) # stop at max iters
opt.setOption('dynInnerIter', 1) # dynamic inner iter number
opt.setOption('maxInnerIter', 5)
opt.setOption('maxOuterIter',
self.config['globalOptIterations'])
opt.setOption('printInnerIters', 1)
opt.setOption('printOuterIters', 1)
opt.setOption('SwarmSize', self.config['globalOptSize'])
opt.setOption('xinit', 1)
opt.setOption('seed',
sr.random() *
self.mpi_size) #(self.mpi_rank+1)/self.mpi_size)
#opt.setOption('vcrazy', 1e-2)
#TODO: how to properly limit max number of function calls?
# no. func calls = (SwarmSize * inner) * outer + SwarmSize
self.iter_max = opt.getOption('SwarmSize') * opt.getOption('maxInnerIter') * \
opt.getOption('maxOuterIter') + opt.getOption('SwarmSize')
self.iter_max = self.iter_max // self.mpi_size
else:
print("Solver {} not defined".format(
self.config['globalSolver']))
sys.exit(1)
# run global optimization
#try:
#reuse history
# opt(opt_prob, store_hst=False, hot_start=True) #, xstart=initial)
#except NameError:
if self.config['verbose']:
print('Running global optimization with {}'.format(
self.config['globalSolver']))
self.is_global = True
opt(opt_prob, store_hst=False) #, xstart=initial)
if self.mpi_rank == 0:
print(opt_prob.solution(0))
self.gather_solutions()
### pyOpt local
if self.config['useLocalOptimization']:
print("Runnning local gradient based solver")
# TODO: run local optimization for e.g. the three last best results (global solutions
# could be more or less optimal within their local minima)
# after using global optimization, refine solution with gradient based method init
# optimizer (more or less local)
if self.config['localSolver'] == 'SLSQP':
opt2 = pyOpt.SLSQP() #sequential least squares
opt2.setOption('MAXIT', self.config['localOptIterations'])
if self.config['verbose']:
opt2.setOption('IPRINT', 0)
elif self.config['localSolver'] == 'IPOPT':
opt2 = pyOpt.IPOPT()
opt2.setOption(
'linear_solver', 'ma57'
) #mumps or hsl: ma27, ma57, ma77, ma86, ma97 or mkl: pardiso
opt2.setOption('max_iter', self.config['localOptIterations'])
if self.config['verbose']:
opt2.setOption('print_level', 4) #0 none ... 5 max
else:
opt2.setOption('print_level', 0) #0 none ... 5 max
elif self.config['localSolver'] == 'PSQP':
opt2 = pyOpt.PSQP()
opt2.setOption(
'MIT', self.config['localOptIterations']) # max iterations
#opt2.setOption('MFV', ??) # max function evaluations
elif self.config['localSolver'] == 'COBYLA':
if parallel:
opt2 = pyOpt.COBYLA(pll_type='POA')
else:
opt2 = pyOpt.COBYLA()
opt2.setOption(
'MAXFUN',
self.config['localOptIterations']) # max iterations
opt2.setOption('RHOBEG', 0.1) # initial step size
if self.config['verbose']:
opt2.setOption('IPRINT', 2)
self.iter_max = self.local_iter_max
# use best constrained solution from last run (might be better than what solver thinks)
if len(self.last_best_sol) > 0:
for i in range(len(opt_prob.getVarSet())):
opt_prob.getVar(i).value = self.last_best_sol[i]
if self.config['verbose']:
print('Runing local optimization with {}'.format(
self.config['localSolver']))
self.is_global = False
if self.config['localSolver'] in ['COBYLA', 'CONMIN']:
opt2(opt_prob, store_hst=False)
else:
if parallel:
opt2(opt_prob,
sens_step=0.1,
sens_mode='pgc',
store_hst=False)
else:
opt2(opt_prob, sens_step=0.1, store_hst=False)
self.gather_solutions()
if self.mpi_rank == 0:
sol = opt_prob.solution(0)
print(sol)
#sol_vec = np.array([sol.getVar(x).value for x in range(0,len(sol.getVarSet()))])
if len(self.last_best_sol) > 0:
print(
"using last best constrained solution instead of given solver solution."
)
print("testing final solution")
#self.iter_cnt = 0
self.objectiveFunc(self.last_best_sol, test=True)
print("\n")
return self.last_best_sol
else:
print("No feasible solution found!")
sys.exit(-1)
else:
# parallel sub-processes, close
sys.exit(0)
def PL_identify(D, lamb, T, ini_sol):
""" Idenify the Probability Law (PL)
Parameters
---------------
D : mxn matrix
D_ij is the entropy value calculated using candidate PL i and data in
window j
lamb : float
detection threshold
T : float
parameter in logistic function. The unit step function is approximated
by L(x) = 1 / ( 1 + exp(-x / T))
ini_sol : mxn matrix
initial solution
Returns
--------------
"""
L = lambda x: 1.0 / ( 1 + math.exp(-1.0 * x / T))
# m, n = D.shape
m = len(D)
n = len(D[0])
def objfunc(x):
f = sum(L(sum(x[(n * i):(n * (i + 1))])) for i in range(m))
# print('f', f)
cn = (m * n + n)
g = [0.0] * cn
for j in range(n):
g[j] = -1 * sum(x[i * n + j] for i in range(m)) + 1
for i in range(m):
for j in range(n):
g[n + i * n + j] = D[i][j] * x[i * n + j] - lamb
fail = 0
# print('g, ', g)
return f, g, fail
opt_prob = pyOpt.Optimization("PL Identification Problem", objfunc)
opt_prob.addObj('f')
for i in range(m):
for j in range(n):
opt_prob.addVar('x%d_%d'%(i,j), 'c', lower=0.0,
upper=1.0, value = ini_sol[i][j])
# opt_prob.addVar('x%d%d'%(i,j), 'i', lower=0,
# upper=1, value=0)
opt_prob.addConGroup('eq', n, type='e')
opt_prob.addConGroup('ineq', m * n, type='i')
print('opt_prob: ', opt_prob)
# return
slsqp = pyOpt.SLSQP()
[fstr, xstr, inform] = slsqp(opt_prob, sens_type='FD')
# alg = pyOpt.ALGENCAN ()
# [fstr, xstr, inform] = alg(opt_prob)
print('fstr', fstr)
print('inform', inform)
print('xstr', xstr)
print(opt_prob.solution(0))
def optimize_pyopt(self, solver, sens, options):
"""Deprecated -- only supported in Python 2.7"""
# pyOpt requires empty options to be specified as {}, not None
if options is None: options = {}
eqConstr = ('SLSQP' not in solver and 'CONMIN' not in solver
and 'COBYLA' not in solver and 'FILTERSD' not in solver
and 'SDPEN' not in solver)
# Organize constraints
indLinEq = []
indLinIneq = []
indNonlinEq = []
indNonlinIneq = []
for k, bnd in enumerate(self.lin_bounds):
if bnd[0] == bnd[1] and eqConstr: indLinEq.append(k)
else: indLinIneq.append(k)
indLinEq = np.array(indLinEq)
indLinIneq = np.array(indLinIneq)
for k, bnd in enumerate(self.nonlin_bounds):
if bnd[0] == bnd[1] and eqConstr: indNonlinEq.append(k)
else: indNonlinIneq.append(k)
indNonlinEq = np.array(indNonlinEq)
indNonlinIneq = np.array(indNonlinIneq)
# pyOpt objective
def objectivePyopt(xIn):
x = xIn[:self.nvar]
f = self.objective(x)
g = np.zeros(0, dtype=float)
if len(indLinEq) > 0:
g = np.r_[g, np.dot(self.lin_mat[indLinEq, :], x)]
if len(indNonlinEq) > 0:
g = np.r_[
g,
self.eval_nonlin_constraints(x, 'constr', indNonlinEq)]
if len(indLinIneq) > 0:
g = np.r_[g, np.dot(self.lin_mat[indLinIneq, :], x)]
if len(indNonlinIneq) > 0:
g = np.r_[
g,
self.eval_nonlin_constraints(x, 'constr', indNonlinIneq)]
fail = 0
if hasattr(f, '__iter__'):
f = f[0]
if f >= self.inf or np.any(g >= self.inf): fail = 1
return f, g.tolist(), fail
# pyOpt gradient
def gradientPyopt(xIn, f, g):
x = xIn[:self.nvar]
df = self.gradient(x)
dg = np.zeros((0, self.nvar), dtype=float)
if len(indLinEq) > 0:
dg = np.r_[dg, self.lin_mat[indLinEq, :]]
if len(indNonlinEq) > 0:
dg = np.r_[dg,
self.eval_nonlin_constraints(x, 'jac', indNonlinEq)]
if len(indLinIneq) > 0:
dg = np.r_[dg, self.lin_mat[indLinIneq, :]]
if len(indNonlinIneq) > 0:
dg = np.r_[
dg,
self.eval_nonlin_constraints(x, 'jac', indNonlinIneq)]
fail = 0
if hasattr(f, '__iter__'):
f = f[0]
if f >= self.inf or np.any(g >= self.inf): fail = 1
return df.reshape(1, -1), dg, fail
# Instantiate optimization problem
optProb = pyOpt.Optimization('pyopt', objectivePyopt)
# Add objective
optProb.addObj('objective')
# Add variables
optProb.addVarGroup('var',
self.nvar,
type='c',
value=self.var_init,
lower=self.var_bounds[:, 0],
upper=self.var_bounds[:, 1])
# Add constraints
if len(indLinEq) > 0:
optProb.addConGroup('lin-equality',
len(indLinEq),
type='e',
equal=self.lin_bounds[indLinEq, 0])
if len(indNonlinEq) > 0:
optProb.addConGroup('nonlin-equality',
len(indNonlinEq),
type='e',
equal=self.nonlin_bounds[indNonlinEq, 0])
if len(indLinIneq) > 0:
optProb.addConGroup('lin-inequality',
len(indLinIneq),
type='i',
lower=self.lin_bounds[indLinIneq, 0],
upper=self.lin_bounds[indLinIneq, 1])
if len(indNonlinIneq) > 0:
optProb.addConGroup('nonlin-inequality',
len(indNonlinIneq),
type='i',
lower=self.nonlin_bounds[indNonlinIneq, 0],
upper=self.nonlin_bounds[indNonlinIneq, 1])
# Setup solver
if 'SNOPT' in solver:
optimizer = pyOpt.pySNOPT.SNOPT(options=options)
if 'SLSQP' in solver:
optimizer = pyOpt.SLSQP(options=options)
if 'CONMIN' in solver:
optimizer = pyOpt.CONMIN(options=options)
if 'ALGENCAN' in solver:
optimizer = pyOpt.ALGENCAN(options=options)
if 'ALPSO' in solver:
optimizer = pyOpt.ALPSO(options=options)
if 'ALHSO' in solver:
optimizer = pyOpt.ALHSO(options=options)
if 'COBYLA' in solver:
optimizer = pyOpt.COBYLA(options=options)
if 'FILTERSD' in solver:
optimizer = pyOpt.FILTERSD(options=options)
if 'KOPT' in solver:
optimizer = pyOpt.KOPT(options=options)
if 'MIDACO' in solver:
optimizer = pyOpt.MIDACO(options=options)
if 'KSQP' in solver:
optimizer = pyOpt.KSQP(options=options)
if 'SDPEN' in solver:
optimizer = pyOpt.SDPEN(options=options)
if 'SOLVOPT' in solver:
optimizer = pyOpt.SOLVOPT(options=options)
# Run optimization
if sens == 'finite-difference':
optimizer(optProb, sens_type='FD')
else:
optimizer(optProb, sens_type=gradientPyopt)
# Extract solution
j = len(optProb._solutions) - 1
xStar = np.zeros(self.nvar)
for k in range(self.nvar):
xStar[k] = optProb._solutions[j].getVar(k).value
return xStar, objectivePyopt(xStar)[0]
