def test_old_bounds_to_new():
bounds = ([1, 2], (None, 3), (-1, None))
lb_true = np.array([1, -np.inf, -1])
ub_true = np.array([2, 3, np.inf])
lb, ub = old_bound_to_new(bounds)
assert_array_equal(lb, lb_true)
assert_array_equal(ub, ub_true)
bounds = [(-np.inf, np.inf), (np.array([1]), np.array([1]))]
lb, ub = old_bound_to_new(bounds)
assert_array_equal(lb, [-np.inf, 1])
assert_array_equal(ub, [np.inf, 1])
def test_old_bounds_to_new():
bounds = ([1, 2], (None, 3), (-1, None))
lb_true = np.array([1, -np.inf, -1])
ub_true = np.array([2, 3, np.inf])
lb, ub = old_bound_to_new(bounds)
assert_array_equal(lb, lb_true)
assert_array_equal(ub, ub_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
self._check_for_missing_objective()
# 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_total_sparsity:
if self._coloring_info['coloring'] is coloring_mod._DYN_COLORING:
coloring_mod.dynamic_total_coloring(
self,
run_model=False,
fname=self._get_total_coloring_fname())
elif self.options['dynamic_simul_derivs']:
warn_deprecation(
"The 'dynamic_simul_derivs' option has been deprecated. Call "
"the 'declare_coloring' function instead.")
coloring_mod.dynamic_total_coloring(
self,
run_model=False,
fname=self._get_total_coloring_fname())
# 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):
"""
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):
"""
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))
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:
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
def _minimize_slsqp(func,
x0,
args=(),
jac=None,
bounds=None,
constraints=(),
maxiter=100,
ftol=1.0E-6,
iprint=1,
disp=False,
eps=_epsilon,
callback=None,
finite_diff_rel_step=None,
**unknown_options):
"""
Minimize a scalar function of one or more variables using Sequential
Least Squares Programming (SLSQP).
Options
-------
ftol : float
Precision goal for the value of f in the stopping criterion.
eps : float
Step size used for numerical approximation of the Jacobian.
disp : bool
Set to True to print convergence messages. If False,
`verbosity` is ignored and set to 0.
maxiter : int
Maximum number of iterations.
finite_diff_rel_step : None or array_like, optional
If `jac in ['2-point', '3-point', 'cs']` the relative step size to
use for numerical approximation of `jac`. The absolute step
size is computed as ``h = rel_step * sign(x0) * max(1, abs(x0))``,
possibly adjusted to fit into the bounds. For ``method='3-point'``
the sign of `h` is ignored. If None (default) then step is selected
automatically.
"""
_check_unknown_options(unknown_options)
iter = maxiter - 1
acc = ftol
epsilon = eps
if not disp:
iprint = 0
# Constraints are triaged per type into a dictionary of tuples
if isinstance(constraints, dict):
constraints = (constraints, )
cons = {'eq': (), 'ineq': ()}
for ic, con in enumerate(constraints):
# check type
try:
ctype = con['type'].lower()
except KeyError:
raise KeyError('Constraint %d has no type defined.' % ic)
except TypeError:
raise TypeError('Constraints must be defined using a '
'dictionary.')
except AttributeError:
raise TypeError("Constraint's type must be a string.")
else:
if ctype not in ['eq', 'ineq']:
raise ValueError("Unknown constraint type '%s'." % con['type'])
# check function
if 'fun' not in con:
raise ValueError('Constraint %d has no function defined.' % ic)
# check Jacobian
cjac = con.get('jac')
if cjac is None:
# approximate Jacobian function. The factory function is needed
# to keep a reference to `fun`, see gh-4240.
def cjac_factory(fun):
def cjac(x, *args):
if jac in ['2-point', '3-point', 'cs']:
return approx_derivative(fun,
x,
method=jac,
args=args,
rel_step=finite_diff_rel_step)
else:
return approx_derivative(fun,
x,
method='2-point',
abs_step=epsilon,
args=args)
return cjac
cjac = cjac_factory(con['fun'])
# update constraints' dictionary
cons[ctype] += ({
'fun': con['fun'],
'jac': cjac,
'args': con.get('args', ())
}, )
exit_modes = {
-1: "Gradient evaluation required (g & a)",
0: "Optimization terminated successfully",
1: "Function evaluation required (f & c)",
2: "More equality constraints than independent variables",
3: "More than 3*n iterations in LSQ subproblem",
4: "Inequality constraints incompatible",
5: "Singular matrix E in LSQ subproblem",
6: "Singular matrix C in LSQ subproblem",
7: "Rank-deficient equality constraint subproblem HFTI",
8: "Positive directional derivative for linesearch",
9: "Iteration limit reached"
}
# Transform x0 into an array.
x = asfarray(x0).flatten()
# SLSQP is sent 'old-style' bounds, 'new-style' bounds are required by
# ScalarFunction
if bounds is None or len(bounds) == 0:
new_bounds = (-np.inf, np.inf)
else:
new_bounds = old_bound_to_new(bounds)
# clip the initial guess to bounds, otherwise ScalarFunction doesn't work
x = np.clip(x, new_bounds[0], new_bounds[1])
# Set the parameters that SLSQP will need
# meq, mieq: number of equality and inequality constraints
meq = sum(
map(len, [atleast_1d(c['fun'](x, *c['args'])) for c in cons['eq']]))
mieq = sum(
map(len, [atleast_1d(c['fun'](x, *c['args'])) for c in cons['ineq']]))
# m = The total number of constraints
m = meq + mieq
# la = The number of constraints, or 1 if there are no constraints
la = array([1, m]).max()
# n = The number of independent variables
n = len(x)
# Define the workspaces for SLSQP
n1 = n + 1
mineq = m - meq + n1 + n1
len_w = (3*n1+m)*(n1+1)+(n1-meq+1)*(mineq+2) + 2*mineq+(n1+mineq)*(n1-meq) \
+ 2*meq + n1 + ((n+1)*n)//2 + 2*m + 3*n + 3*n1 + 1
len_jw = mineq
w = zeros(len_w)
jw = zeros(len_jw)
# Decompose bounds into xl and xu
if bounds is None or len(bounds) == 0:
xl = np.empty(n, dtype=float)
xu = np.empty(n, dtype=float)
xl.fill(np.nan)
xu.fill(np.nan)
else:
bnds = array([(_arr_to_scalar(l), _arr_to_scalar(u))
for (l, u) in bounds], float)
if bnds.shape[0] != n:
raise IndexError('SLSQP Error: the length of bounds is not '
'compatible with that of x0.')
with np.errstate(invalid='ignore'):
bnderr = bnds[:, 0] > bnds[:, 1]
if bnderr.any():
raise ValueError('SLSQP Error: lb > ub in bounds %s.' %
', '.join(str(b) for b in bnderr))
xl, xu = bnds[:, 0], bnds[:, 1]
# Mark infinite bounds with nans; the Fortran code understands this
infbnd = ~isfinite(bnds)
xl[infbnd[:, 0]] = np.nan
xu[infbnd[:, 1]] = np.nan
# ScalarFunction provides function and gradient evaluation
sf = _prepare_scalar_function(func,
x,
jac=jac,
args=args,
epsilon=eps,
finite_diff_rel_step=finite_diff_rel_step,
bounds=new_bounds)
# Initialize the iteration counter and the mode value
mode = array(0, int)
acc = array(acc, float)
majiter = array(iter, int)
majiter_prev = 0
# Initialize internal SLSQP state variables
alpha = array(0, float)
f0 = array(0, float)
gs = array(0, float)
h1 = array(0, float)
h2 = array(0, float)
h3 = array(0, float)
h4 = array(0, float)
t = array(0, float)
t0 = array(0, float)
tol = array(0, float)
iexact = array(0, int)
incons = array(0, int)
ireset = array(0, int)
itermx = array(0, int)
line = array(0, int)
n1 = array(0, int)
n2 = array(0, int)
n3 = array(0, int)
# Print the header if iprint >= 2
if iprint >= 2:
print("%5s %5s %16s %16s" % ("NIT", "FC", "OBJFUN", "GNORM"))
# mode is zero on entry, so call objective, constraints and gradients
# there should be no func evaluations here because it's cached from
# ScalarFunction
fx = sf.fun(x)
try:
fx = float(np.asarray(fx))
except (TypeError, ValueError):
raise ValueError("Objective function must return a scalar")
g = append(sf.grad(x), 0.0)
c = _eval_constraint(x, cons)
a = _eval_con_normals(x, cons, la, n, m, meq, mieq)
while 1:
# Call SLSQP
slsqp(m, meq, x, xl, xu, fx, c, g, a, acc, majiter, mode, w, jw, alpha,
f0, gs, h1, h2, h3, h4, t, t0, tol, iexact, incons, ireset,
itermx, line, n1, n2, n3)
if mode == 1: # objective and constraint evaluation required
fx = sf.fun(x)
c = _eval_constraint(x, cons)
if mode == -1: # gradient evaluation required
g = append(sf.grad(x), 0.0)
a = _eval_con_normals(x, cons, la, n, m, meq, mieq)
if majiter > majiter_prev:
# call callback if major iteration has incremented
if callback is not None:
callback(np.copy(x))
# Print the status of the current iterate if iprint > 2
if iprint >= 2:
print("%5i %5i % 16.6E % 16.6E" %
(majiter, sf.nfev, fx, linalg.norm(g)))
# If exit mode is not -1 or 1, slsqp has completed
if abs(mode) != 1:
break
majiter_prev = int(majiter)
# Optimization loop complete. Print status if requested
if iprint >= 1:
print(exit_modes[int(mode)] + " (Exit mode " + str(mode) + ')')
print(" Current function value:", fx)
print(" Iterations:", majiter)
print(" Function evaluations:", sf.nfev)
print(" Gradient evaluations:", sf.ngev)
return OptimizeResult(x=x,
fun=fx,
jac=g[:-1],
nit=int(majiter),
nfev=sf.nfev,
njev=sf.ngev,
status=int(mode),
message=exit_modes[int(mode)],
success=(mode == 0))
