def run(self):
"""
Only does coloring when requested.
"""
if self.options['dynamic_simul_derivs']:
coloring_mod.dynamic_simul_coloring(self, do_sparsity=True)
def run(self):
"""
Optimize the problem using selected Scipy optimizer.
Returns
-------
boolean
Failure flag; True if failed to converge, False is successful.
"""
problem = self._problem
opt = self.options['optimizer']
model = problem.model
self.iter_count = 0
self._total_jac = None
# Initial Run
model._solve_nonlinear()
self._con_cache = self.get_constraint_values()
desvar_vals = self.get_design_var_values()
self._dvlist = list(self._designvars)
# maxiter and disp get passsed into scipy with all the other options.
self.opt_settings['maxiter'] = self.options['maxiter']
self.opt_settings['disp'] = self.options['disp']
# Size Problem
nparam = 0
for param in itervalues(self._designvars):
nparam += param['size']
x_init = np.empty(nparam)
# Initial Design Vars
i = 0
use_bounds = (opt in _bounds_optimizers)
if use_bounds:
bounds = []
else:
bounds = None
for name, meta in iteritems(self._designvars):
size = meta['size']
x_init[i:i + size] = desvar_vals[name]
i += size
# Bounds if our optimizer supports them
if use_bounds:
meta_low = meta['lower']
meta_high = meta['upper']
for j in range(size):
if isinstance(meta_low, np.ndarray):
p_low = meta_low[j]
else:
p_low = meta_low
if isinstance(meta_high, np.ndarray):
p_high = meta_high[j]
else:
p_high = meta_high
bounds.append((p_low, p_high))
# Constraints
constraints = []
i = 1 # start at 1 since row 0 is the objective. Constraints start at row 1.
lin_i = 0 # counter for linear constraint jacobian
lincons = [] # list of linear constraints
self._obj_and_nlcons = list(self._objs)
if opt in _constraint_optimizers:
for name, meta in iteritems(self._cons):
size = meta['size']
upper = meta['upper']
lower = meta['lower']
if 'linear' in meta and meta['linear']:
lincons.append(name)
self._con_idx[name] = lin_i
lin_i += size
else:
self._obj_and_nlcons.append(name)
self._con_idx[name] = i
i += size
# Loop over every index separately, because scipy calls each constraint by index.
for j in range(0, size):
con_dict = {}
if meta['equals'] is not None:
con_dict['type'] = 'eq'
else:
con_dict['type'] = 'ineq'
con_dict['fun'] = self._confunc
if opt in _constraint_grad_optimizers:
con_dict['jac'] = self._congradfunc
con_dict['args'] = [name, False, j]
constraints.append(con_dict)
if isinstance(upper, np.ndarray):
upper = upper[j]
if isinstance(lower, np.ndarray):
lower = lower[j]
dblcon = (upper < sys.float_info.max) and (
lower > -sys.float_info.max)
# Add extra constraint if double-sided
if dblcon:
dcon_dict = {}
dcon_dict['type'] = 'ineq'
dcon_dict['fun'] = self._confunc
if opt in _constraint_grad_optimizers:
dcon_dict['jac'] = self._congradfunc
dcon_dict['args'] = [name, True, j]
constraints.append(dcon_dict)
# precalculate gradients of linear constraints
if lincons:
self._lincongrad_cache = self._compute_totals(
of=lincons, wrt=self._dvlist, return_format='array')
else:
self._lincongrad_cache = None
# Provide gradients for optimizers that support it
if opt in _gradient_optimizers:
jac = self._gradfunc
else:
jac = None
# compute dynamic simul deriv coloring if option is set
if coloring_mod._use_sparsity and self.options['dynamic_simul_derivs']:
coloring_mod.dynamic_simul_coloring(self, do_sparsity=False)
# optimize
try:
result = minimize(
self._objfunc,
x_init,
# args=(),
method=opt,
jac=jac,
# hess=None,
# hessp=None,
bounds=bounds,
constraints=constraints,
tol=self.options['tol'],
# callback=None,
options=self.opt_settings)
# If an exception was swallowed in one of our callbacks, we want to raise it
# rather than the cryptic message from scipy.
except Exception as msg:
if self._exc_info is not None:
self._reraise()
else:
raise
if self._exc_info is not None:
self._reraise()
self.result = result
self.fail = False if self.result.success else True
if self.fail:
print('Optimization FAILED.')
print(result.message)
print('-' * 35)
elif self.options['disp']:
print('Optimization Complete')
print('-' * 35)
return self.fail
def run(self):
"""
Optimize the problem using selected Scipy optimizer.
Returns
-------
boolean
Failure flag; True if failed to converge, False is successful.
"""
problem = self._problem
opt = self.options['optimizer']
model = problem.model
self.iter_count = 0
self._total_jac = None
# Initial Run
with RecordingDebugging(self._get_name(), self.iter_count, self) as rec:
model.run_solve_nonlinear()
self.iter_count += 1
self._con_cache = self.get_constraint_values()
desvar_vals = self.get_design_var_values()
self._dvlist = list(self._designvars)
# maxiter and disp get passsed into scipy with all the other options.
self.opt_settings['maxiter'] = self.options['maxiter']
self.opt_settings['disp'] = self.options['disp']
# Size Problem
nparam = 0
for param in itervalues(self._designvars):
nparam += param['size']
x_init = np.empty(nparam)
# Initial Design Vars
i = 0
use_bounds = (opt in _bounds_optimizers)
if use_bounds:
bounds = []
else:
bounds = None
for name, meta in iteritems(self._designvars):
size = meta['size']
x_init[i:i + size] = desvar_vals[name]
i += size
# Bounds if our optimizer supports them
if use_bounds:
meta_low = meta['lower']
meta_high = meta['upper']
for j in range(size):
if isinstance(meta_low, np.ndarray):
p_low = meta_low[j]
else:
p_low = meta_low
if isinstance(meta_high, np.ndarray):
p_high = meta_high[j]
else:
p_high = meta_high
bounds.append((p_low, p_high))
if use_bounds and (opt in _supports_new_style) and _use_new_style:
# For 'trust-constr' it is better to use the new type bounds, because it seems to work
# better (for the current examples in the tests) with the "keep_feasible" option
try:
from scipy.optimize import Bounds
from scipy.optimize._constraints import old_bound_to_new
except ImportError:
msg = ('The "trust-constr" optimizer is supported for SciPy 1.1.0 and above. '
'The installed version is {}')
raise ImportError(msg.format(scipy_version))
# Convert "old-style" bounds to "new_style" bounds
lower, upper = old_bound_to_new(bounds) # tuple, tuple
keep_feasible = self.opt_settings.get('keep_feasible_bounds', True)
bounds = Bounds(lb=lower, ub=upper, keep_feasible=keep_feasible)
# Constraints
constraints = []
i = 1 # start at 1 since row 0 is the objective. Constraints start at row 1.
lin_i = 0 # counter for linear constraint jacobian
lincons = [] # list of linear constraints
self._obj_and_nlcons = list(self._objs)
if opt in _constraint_optimizers:
for name, meta in iteritems(self._cons):
size = meta['size']
upper = meta['upper']
lower = meta['lower']
equals = meta['equals']
if 'linear' in meta and meta['linear']:
lincons.append(name)
self._con_idx[name] = lin_i
lin_i += size
else:
self._obj_and_nlcons.append(name)
self._con_idx[name] = i
i += size
# In scipy constraint optimizers take constraints in two separate formats
# Type of constraints is list of NonlinearConstraint
if opt in _supports_new_style and _use_new_style:
try:
from scipy.optimize import NonlinearConstraint
except ImportError:
msg = ('The "trust-constr" optimizer is supported for SciPy 1.1.0 and'
'above. The installed version is {}')
raise ImportError(msg.format(scipy_version))
if equals is not None:
lb = ub = equals
else:
lb = lower
ub = upper
# Loop over every index separately,
# because scipy calls each constraint by index.
for j in range(size):
# Double-sided constraints are accepted by the algorithm
args = [name, False, j]
# TODO linear constraint if meta['linear']
# TODO add option for Hessian
con = NonlinearConstraint(fun=signature_extender(self._con_val_func, args),
lb=lb, ub=ub,
jac=signature_extender(self._congradfunc, args))
constraints.append(con)
else: # Type of constraints is list of dict
# Loop over every index separately,
# because scipy calls each constraint by index.
for j in range(size):
con_dict = {}
if meta['equals'] is not None:
con_dict['type'] = 'eq'
else:
con_dict['type'] = 'ineq'
con_dict['fun'] = self._confunc
if opt in _constraint_grad_optimizers:
con_dict['jac'] = self._congradfunc
con_dict['args'] = [name, False, j]
constraints.append(con_dict)
if isinstance(upper, np.ndarray):
upper = upper[j]
if isinstance(lower, np.ndarray):
lower = lower[j]
dblcon = (upper < openmdao.INF_BOUND) and (lower > -openmdao.INF_BOUND)
# Add extra constraint if double-sided
if dblcon:
dcon_dict = {}
dcon_dict['type'] = 'ineq'
dcon_dict['fun'] = self._confunc
if opt in _constraint_grad_optimizers:
dcon_dict['jac'] = self._congradfunc
dcon_dict['args'] = [name, True, j]
constraints.append(dcon_dict)
# precalculate gradients of linear constraints
if lincons:
self._lincongrad_cache = self._compute_totals(of=lincons, wrt=self._dvlist,
return_format='array')
else:
self._lincongrad_cache = None
# Provide gradients for optimizers that support it
if opt in _gradient_optimizers:
jac = self._gradfunc
else:
jac = None
# Hessian calculation method for optimizers, which require it
if opt in _hessian_optimizers:
if 'hess' in self.opt_settings:
hess = self.opt_settings.pop('hess')
else:
# Defaults to BFGS, if not in opt_settings
from scipy.optimize import BFGS
hess = BFGS()
else:
hess = None
# compute dynamic simul deriv coloring if option is set
if coloring_mod._use_sparsity and self.options['dynamic_simul_derivs']:
coloring_mod.dynamic_simul_coloring(self, run_model=False, do_sparsity=False)
# optimize
try:
if opt in _optimizers:
result = minimize(self._objfunc, x_init,
# args=(),
method=opt,
jac=jac,
hess=hess,
# hessp=None,
bounds=bounds,
constraints=constraints,
tol=self.options['tol'],
# callback=None,
options=self.opt_settings)
elif opt == 'basinhopping':
from scipy.optimize import basinhopping
def fun(x):
return self._objfunc(x), jac(x)
if 'minimizer_kwargs' not in self.opt_settings:
self.opt_settings['minimizer_kwargs'] = {"method": "L-BFGS-B", "jac": True}
self.opt_settings.pop('maxiter') # It does not have this argument
def accept_test(f_new, x_new, f_old, x_old):
# Used to implement bounds besides the original functionality
if bounds is not None:
bound_check = all([b[0] <= xi <= b[1] for xi, b in zip(x_new, bounds)])
user_test = self.opt_settings.pop('accept_test', None) # callable
# has to satisfy both the bounds and the acceptance test defined by the
# user
if user_test is not None:
test_res = user_test(f_new, x_new, f_old, x_old)
if test_res == 'force accept':
return test_res
else: # result is boolean
return bound_check and test_res
else: # no user acceptance test, check only the bounds
return bound_check
else:
return True
result = basinhopping(fun, x_init,
accept_test=accept_test,
**self.opt_settings)
elif opt == 'dual_annealing':
from scipy.optimize import dual_annealing
self.opt_settings.pop('disp') # It does not have this argument
# There is no "options" param, so "opt_settings" can be used to set the (many)
# keyword arguments
result = dual_annealing(self._objfunc,
bounds=bounds,
**self.opt_settings)
elif opt == 'differential_evolution':
from scipy.optimize import differential_evolution
# There is no "options" param, so "opt_settings" can be used to set the (many)
# keyword arguments
result = differential_evolution(self._objfunc,
bounds=bounds,
**self.opt_settings)
elif opt == 'shgo':
from scipy.optimize import shgo
kwargs = dict()
for param in ('minimizer_kwargs', 'sampling_method ', 'n', 'iters'):
if param in self.opt_settings:
kwargs[param] = self.opt_settings[param]
# Set the Jacobian and the Hessian to the value calculated in OpenMDAO
if 'minimizer_kwargs' not in kwargs or kwargs['minimizer_kwargs'] is None:
kwargs['minimizer_kwargs'] = {}
kwargs['minimizer_kwargs'].setdefault('jac', jac)
kwargs['minimizer_kwargs'].setdefault('hess', hess)
# Objective function tolerance
self.opt_settings['f_tol'] = self.options['tol']
result = shgo(self._objfunc,
bounds=bounds,
constraints=constraints,
options=self.opt_settings,
**kwargs)
else:
msg = 'Optimizer "{}" is not implemented yet. Choose from: {}'
raise NotImplementedError(msg.format(opt, _all_optimizers))
# If an exception was swallowed in one of our callbacks, we want to raise it
# rather than the cryptic message from scipy.
except Exception as msg:
if self._exc_info is not None:
self._reraise()
else:
raise
if self._exc_info is not None:
self._reraise()
self.result = result
if hasattr(result, 'success'):
self.fail = False if result.success else True
if self.fail:
print('Optimization FAILED.')
print(result.message)
print('-' * 35)
elif self.options['disp']:
print('Optimization Complete')
print('-' * 35)
else:
self.fail = True # It is not known, so the worst option is assumed
print('Optimization Complete (success not known)')
print(result.message)
print('-' * 35)
return self.fail
def run(self):
"""
Excute pyOptsparse.
Note that pyOpt controls the execution, and the individual optimizers
(e.g., SNOPT) control the iteration.
Returns
-------
boolean
Failure flag; True if failed to converge, False is successful.
"""
problem = self._problem
model = problem.model
relevant = model._relevant
self.pyopt_solution = None
self._total_jac = None
self.iter_count = 0
fwd = problem._mode == 'fwd'
optimizer = self.options['optimizer']
# Only need initial run if we have linear constraints or if we are using an optimizer that
# doesn't perform one initially.
con_meta = self._cons
model_ran = False
if optimizer in run_required or np.any([con['linear'] for con in itervalues(self._cons)]):
with RecordingDebugging(self._get_name(), self.iter_count, self) as rec:
# Initial Run
model.run_solve_nonlinear()
rec.abs = 0.0
rec.rel = 0.0
model_ran = True
self.iter_count += 1
# compute dynamic simul deriv coloring or just sparsity if option is set
if coloring_mod._use_sparsity:
if self.options['dynamic_simul_derivs']:
coloring_mod.dynamic_simul_coloring(self, run_model=not model_ran,
do_sparsity=True)
elif self.options['dynamic_derivs_sparsity']:
coloring_mod.dynamic_sparsity(self)
opt_prob = Optimization(self.options['title'], self._objfunc)
# Add all design variables
param_meta = self._designvars
self._indep_list = indep_list = list(param_meta)
param_vals = self.get_design_var_values()
for name, meta in iteritems(param_meta):
opt_prob.addVarGroup(name, meta['size'], type='c',
value=param_vals[name],
lower=meta['lower'], upper=meta['upper'])
opt_prob.finalizeDesignVariables()
# Add all objectives
objs = self.get_objective_values()
for name in objs:
opt_prob.addObj(name)
self._quantities.append(name)
# Calculate and save derivatives for any linear constraints.
lcons = [key for (key, con) in iteritems(con_meta) if con['linear']]
if len(lcons) > 0:
_lin_jacs = self._compute_totals(of=lcons, wrt=indep_list, return_format='dict')
# convert all of our linear constraint jacs to COO format. Otherwise pyoptsparse will
# do it for us and we'll end up with a fully dense COO matrix and very slow evaluation
# of linear constraints!
to_remove = []
for jacdct in itervalues(_lin_jacs):
for n, subjac in iteritems(jacdct):
if isinstance(subjac, np.ndarray):
# we can safely use coo_matrix to automatically convert the ndarray
# since our linear constraint jacs are constant, so zeros won't become
# nonzero during the optimization.
mat = coo_matrix(subjac)
if mat.row.size > 0:
# convert to 'coo' format here to avoid an emphatic warning
# by pyoptsparse.
jacdct[n] = {'coo': [mat.row, mat.col, mat.data], 'shape': mat.shape}
# Add all equality constraints
for name, meta in iteritems(con_meta):
if meta['equals'] is None:
continue
size = meta['size']
lower = upper = meta['equals']
if fwd:
wrt = [v for v in indep_list if name in relevant[v]]
else:
rels = relevant[name]
wrt = [v for v in indep_list if v in rels]
if meta['linear']:
jac = {w: _lin_jacs[name][w] for w in wrt}
opt_prob.addConGroup(name, size, lower=lower, upper=upper,
linear=True, wrt=wrt, jac=jac)
else:
if name in self._res_jacs:
resjac = self._res_jacs[name]
jac = {n: resjac[n] for n in wrt}
else:
jac = None
opt_prob.addConGroup(name, size, lower=lower, upper=upper, wrt=wrt, jac=jac)
self._quantities.append(name)
# Add all inequality constraints
for name, meta in iteritems(con_meta):
if meta['equals'] is not None:
continue
size = meta['size']
# Bounds - double sided is supported
lower = meta['lower']
upper = meta['upper']
if fwd:
wrt = [v for v in indep_list if name in relevant[v]]
else:
rels = relevant[name]
wrt = [v for v in indep_list if v in rels]
if meta['linear']:
jac = {w: _lin_jacs[name][w] for w in wrt}
opt_prob.addConGroup(name, size, upper=upper, lower=lower,
linear=True, wrt=wrt, jac=jac)
else:
if name in self._res_jacs:
resjac = self._res_jacs[name]
jac = {n: resjac[n] for n in wrt}
else:
jac = None
opt_prob.addConGroup(name, size, upper=upper, lower=lower, wrt=wrt, jac=jac)
self._quantities.append(name)
# Instantiate the requested optimizer
try:
_tmp = __import__('pyoptsparse', globals(), locals(), [optimizer], 0)
opt = getattr(_tmp, optimizer)()
except Exception as err:
# Change whatever pyopt gives us to an ImportError, give it a readable message,
# but raise with the original traceback.
msg = "Optimizer %s is not available in this installation." % optimizer
reraise(ImportError, ImportError(msg), sys.exc_info()[2])
# Set optimization options
for option, value in self.opt_settings.items():
opt.setOption(option, value)
# Execute the optimization problem
if self.options['gradient method'] == 'pyopt_fd':
# Use pyOpt's internal finite difference
# TODO: Need to get this from OpenMDAO
# fd_step = problem.root.deriv_options['step_size']
fd_step = 1e-6
sol = opt(opt_prob, sens='FD', sensStep=fd_step, storeHistory=self.hist_file,
hotStart=self.hotstart_file)
elif self.options['gradient method'] == 'snopt_fd':
if self.options['optimizer'] == 'SNOPT':
# Use SNOPT's internal finite difference
# TODO: Need to get this from OpenMDAO
# fd_step = problem.root.deriv_options['step_size']
fd_step = 1e-6
sol = opt(opt_prob, sens=None, sensStep=fd_step, storeHistory=self.hist_file,
hotStart=self.hotstart_file)
else:
msg = "SNOPT's internal finite difference can only be used with SNOPT"
raise Exception(msg)
else:
# Use OpenMDAO's differentiator for the gradient
sol = opt(opt_prob, sens=self._gradfunc, storeHistory=self.hist_file,
hotStart=self.hotstart_file)
# Print results
if self.options['print_results']:
print(sol)
# Pull optimal parameters back into framework and re-run, so that
# framework is left in the right final state
dv_dict = sol.getDVs()
for name in indep_list:
self.set_design_var(name, dv_dict[name])
with RecordingDebugging(self._get_name(), self.iter_count, self) as rec:
model.run_solve_nonlinear()
rec.abs = 0.0
rec.rel = 0.0
self.iter_count += 1
# Save the most recent solution.
self.pyopt_solution = sol
try:
exit_status = sol.optInform['value']
self.fail = False
# These are various failed statuses.
if exit_status > 2:
self.fail = True
except KeyError:
# optimizers other than pySNOPT may not populate this dict
pass
return self.fail
def run(self):
"""
Optimize the problem using selected Scipy optimizer.
Returns
-------
boolean
Failure flag; True if failed to converge, False is successful.
"""
problem = self._problem
opt = self.options['optimizer']
model = problem.model
self.iter_count = 0
self._total_jac = None
# Initial Run
with RecordingDebugging(self.options['optimizer'], self.iter_count,
self) as rec:
model._solve_nonlinear()
self.iter_count += 1
self._con_cache = self.get_constraint_values()
desvar_vals = self.get_design_var_values()
self._dvlist = list(self._designvars)
# maxiter and disp get passsed into scipy with all the other options.
self.opt_settings['maxiter'] = self.options['maxiter']
self.opt_settings['disp'] = self.options['disp']
# Size Problem
nparam = 0
for param in itervalues(self._designvars):
nparam += param['size']
x_init = np.empty(nparam)
# Initial Design Vars
i = 0
use_bounds = (opt in _bounds_optimizers)
if use_bounds:
bounds = []
else:
bounds = None
for name, meta in iteritems(self._designvars):
size = meta['size']
x_init[i:i + size] = desvar_vals[name]
i += size
# Bounds if our optimizer supports them
if use_bounds:
meta_low = meta['lower']
meta_high = meta['upper']
for j in range(size):
if isinstance(meta_low, np.ndarray):
p_low = meta_low[j]
else:
p_low = meta_low
if isinstance(meta_high, np.ndarray):
p_high = meta_high[j]
else:
p_high = meta_high
bounds.append((p_low, p_high))
# Constraints
constraints = []
i = 1 # start at 1 since row 0 is the objective. Constraints start at row 1.
lin_i = 0 # counter for linear constraint jacobian
lincons = [] # list of linear constraints
self._obj_and_nlcons = list(self._objs)
if opt in _constraint_optimizers:
for name, meta in iteritems(self._cons):
size = meta['size']
upper = meta['upper']
lower = meta['lower']
equals = meta['equals']
if 'linear' in meta and meta['linear']:
lincons.append(name)
self._con_idx[name] = lin_i
lin_i += size
else:
self._obj_and_nlcons.append(name)
self._con_idx[name] = i
i += size
# In scipy constraint optimizers take constraints in two separate formats
if opt in [
'trust-constr'
]: # Type of constraints is list of NonlinearConstraint
try:
from scipy.optimize import NonlinearConstraint
except ImportError:
msg = (
'The "trust-constr" optimizer is supported for SciPy 1.1.0 and'
'above. The installed version is {}')
raise ImportError(msg.format(scipy_version))
if equals is not None:
lb = ub = equals
else:
lb = lower
ub = upper
# Loop over every index separately,
# because scipy calls each constraint by index.
for j in range(size):
# Double-sided constraints are accepted by the algorithm
args = [name, False, j]
# TODO linear constraint if meta['linear']
# TODO add option for Hessian
con = NonlinearConstraint(
fun=signature_extender(self._con_val_func, args),
lb=lb,
ub=ub,
jac=signature_extender(self._congradfunc, args))
constraints.append(con)
else: # Type of constraints is list of dict
# Loop over every index separately,
# because scipy calls each constraint by index.
for j in range(size):
con_dict = {}
if meta['equals'] is not None:
con_dict['type'] = 'eq'
else:
con_dict['type'] = 'ineq'
con_dict['fun'] = self._confunc
if opt in _constraint_grad_optimizers:
con_dict['jac'] = self._congradfunc
con_dict['args'] = [name, False, j]
constraints.append(con_dict)
if isinstance(upper, np.ndarray):
upper = upper[j]
if isinstance(lower, np.ndarray):
lower = lower[j]
dblcon = (upper < openmdao.INF_BOUND) and (
lower > -openmdao.INF_BOUND)
# Add extra constraint if double-sided
if dblcon:
dcon_dict = {}
dcon_dict['type'] = 'ineq'
dcon_dict['fun'] = self._confunc
if opt in _constraint_grad_optimizers:
dcon_dict['jac'] = self._congradfunc
dcon_dict['args'] = [name, True, j]
constraints.append(dcon_dict)
# precalculate gradients of linear constraints
if lincons:
self._lincongrad_cache = self._compute_totals(
of=lincons, wrt=self._dvlist, return_format='array')
else:
self._lincongrad_cache = None
# Provide gradients for optimizers that support it
if opt in _gradient_optimizers:
jac = self._gradfunc
else:
jac = None
# Hessian calculation method for optimizers, which require it
if opt in _hessian_optimizers:
if 'hess' in self.opt_settings:
hess = self.opt_settings.pop('hess')
else:
# Defaults to BFGS, if not in opt_settings
from scipy.optimize import BFGS
hess = BFGS()
else:
hess = None
# compute dynamic simul deriv coloring if option is set
if coloring_mod._use_sparsity and self.options['dynamic_simul_derivs']:
coloring_mod.dynamic_simul_coloring(self,
run_model=False,
do_sparsity=False)
# optimize
try:
result = minimize(
self._objfunc,
x_init,
# args=(),
method=opt,
jac=jac,
hess=hess,
# hessp=None,
bounds=bounds,
constraints=constraints,
tol=self.options['tol'],
# callback=None,
options=self.opt_settings)
# If an exception was swallowed in one of our callbacks, we want to raise it
# rather than the cryptic message from scipy.
except Exception as msg:
if self._exc_info is not None:
self._reraise()
else:
raise
if self._exc_info is not None:
self._reraise()
self.result = result
if hasattr(result, 'success'):
self.fail = False if result.success else True
if self.fail:
print('Optimization FAILED.')
print(result.message)
print('-' * 35)
elif self.options['disp']:
print('Optimization Complete')
print('-' * 35)
else:
self.fail = True # It is not known, so the worst option is assumed
print('Optimization Complete (success not known)')
print(result.message)
print('-' * 35)
return self.fail