def test01_availability(self): """Quick API check on available optimizers""" import skquant.opt as skqopt bounds = np.array([[-1, 1], [-1, 1]], dtype=float) budget = 40 x0 = np.array([0.5, 0.5]) # interface with incorrect input assert raises(RuntimeError, skqopt.minimize, f_easy_simple, x0, bounds, budget, method='does not exist') # ImFil result, history = \ skqopt.minimize(f_easy_simple, x0, bounds, budget, method='imfil') assert type(result.optpar) == np.ndarray assert np.round( sum(result.optpar) - sum(ref_results[f_easy_simple]['imfil']), 8) == 0.0 # SnobFit from SQSnobFit import optset options = optset(maxmp=len(x0) + 6) result, history = \ skqopt.minimize(f_easy_simple, [], bounds, budget, method='snobfit', options=options) assert type(result.optpar) == np.ndarray assert np.round( sum(result.optpar) - sum(ref_results[f_easy_simple]['snobfit']), 8) == 0.0 # Py-BOBYQA result, history = \ skqopt.minimize(f_easy_simple, x0, bounds, budget, method='bobyqa') assert type(result.optpar) == np.ndarray assert np.round(sum(result.optpar), 5) == 0 # ORBIT if skqopt._check_orbit_prerequisites(): randstate = 1 np.random.seed(randstate) result, history = \ skqopt.minimize(f_easy_simple, x0, bounds, budget, method='orbit') assert type(result.optpar) == np.ndarray assert np.round( sum(result.optpar) - sum((0.00076624, 0.00060909)), 7) == 0
def optimize( self, num_vars, objective_function, gradient_function=None, variable_bounds=None, initial_point=None, ): """Runs the optimization.""" super().optimize(num_vars, objective_function, gradient_function, variable_bounds, initial_point) snobfit_settings = { "maxmp": self._maxmp, "maxfail": self._maxfail, "verbose": self._verbose, } options = optset(optin=snobfit_settings) # counters the error when initial point is outside the acceptable bounds for idx, theta in enumerate(initial_point): if abs(theta) > variable_bounds[idx][0]: initial_point[ idx] = initial_point[idx] % variable_bounds[idx][0] elif abs(theta) > variable_bounds[idx][1]: initial_point[ idx] = initial_point[idx] % variable_bounds[idx][1] res, history = skq.minimize( objective_function, np.array(initial_point, dtype=float), bounds=variable_bounds, budget=self._maxiter, method="snobfit", options=options, ) return res.optpar, res.optval, len(history)
def minimize( self, fun: Callable[[POINT], float], x0: POINT, jac: Optional[Callable[[POINT], POINT]] = None, bounds: Optional[List[Tuple[float, float]]] = None, ) -> OptimizerResult: snobfit_settings = { "maxmp": self._maxmp, "maxfail": self._maxfail, "verbose": self._verbose, } options = optset(optin=snobfit_settings) # counters the error when initial point is outside the acceptable bounds x0 = np.asarray(x0) for idx, theta in enumerate(x0): if abs(theta) > bounds[idx][0]: x0[idx] = x0[idx] % bounds[idx][0] elif abs(theta) > bounds[idx][1]: x0[idx] = x0[idx] % bounds[idx][1] res, history = skq.minimize( fun, x0, bounds=bounds, budget=self._maxiter, method="snobfit", options=options, ) optimizer_result = OptimizerResult() optimizer_result.x = res.optpar optimizer_result.fun = res.optval optimizer_result.nfev = len(history) return optimizer_result
def optimize(self, num_vars, objective_function, gradient_function=None, variable_bounds=None, initial_point=None): """ Runs the optimization. """ super().optimize(num_vars, objective_function, gradient_function, variable_bounds, initial_point) res, history = skq.minimize(objective_function, np.array(initial_point), bounds=np.array(variable_bounds), budget=self._maxiter, method="bobyqa") return res.optpar, res.optval, len(history)
def optimize(self, num_vars, objective_function, gradient_function=None, variable_bounds=None, initial_point=None): """ Runs the optimization. """ super().optimize(num_vars, objective_function, gradient_function, variable_bounds, initial_point) res, history = skq.minimize(func=objective_function, x0=initial_point, bounds=variable_bounds, budget=self._maxiter, method="imfil") return res.optpar, res.optval, len(history)
def test_issue4(self): """error in imfil with multivariate function""" from skquant.opt import minimize def g(a): return a[0]**2 - a[0] + a[1]**3 - 4 * a[1] bounds = np.array([[0, 2], [-2, 2]], dtype=np.float) init = np.array([1., 0.]) res, hist = minimize(g, init, bounds, method='imfil')
def test_issue3(self): """error with snobfit for univariate function""" from skquant.opt import minimize def f(a): return a[0]**2 - a[0] bounds = np.array([[0, 2]], dtype=np.float) init = np.array([1.]) res, hist = minimize(f, init, bounds, method='snobfit')
def test_issue2(self): """Errors with imfil for univariate functions""" from skquant.opt import minimize def f(a): return a**2 - a bounds = np.array([[0, 2]], dtype=np.float) init = np.array([1.]) res, hist = minimize(f, init, bounds, method='imfil')
def optimize(self, num_vars, objective_function, gradient_function=None, variable_bounds=None, initial_point=None): super().optimize(num_vars, objective_function, gradient_function, variable_bounds, initial_point) res, history = \ skqopt.minimize(objective_function, initial_point, variable_bounds, self.maxfun, method='imfil', options=self._options) return res.optpar, res.optval, len(history)
def test_issue10(self): """SNOBFIT error for initialization with nreq=1""" from skquant.opt import minimize def f(a): return a[0]**2 - a[0] bounds = np.array([[0, 2]], dtype=np.float) init = np.array([1.]) res, hist = minimize(f, init, bounds, method='snobfit', options={'maxmp': 1})
def imfil(fun, x0, *args, **options): """ Implicit Filtering Algorithm designed for problems with local minima caused by high-frequency, low-amplitude noise, with an underlying large scale structure. This uses the SQImFil Python rewrite. Reference: C.T. Kelley, "Implicit Filtering", 2011, ISBN: 978-1-61197-189-7 Original MATLAB code available at ctk.math.ncsu.edu/imfil.html """ budget, bounds, options = _split_options(options) result, history = skqopt.minimize(fun, x0, bounds=bounds, budget=budget, \ method='imfil', options=options) return _res2scipy(result, history)
def minimize( self, fun: Callable[[POINT], float], x0: POINT, jac: Optional[Callable[[POINT], POINT]] = None, bounds: Optional[List[Tuple[float, float]]] = None, ) -> OptimizerResult: res, history = skq.minimize( func=fun, x0=x0, bounds=bounds, budget=self._maxiter, method="imfil", ) optimizer_result = OptimizerResult() optimizer_result.x = res.optpar optimizer_result.fun = res.optval optimizer_result.nfev = len(history) return optimizer_result
def snobfit(fun, x0, *args, **options): """ Stable Noisy Optimization by Branch and FIT SnobFit is specifically developed for optimization problems with noisy and expensive to compute objective functions. This implementation uses the SQSnobFit Python rewrite. Reference: W. Huyer and A. Neumaier, “Snobfit - Stable Noisy Optimization by Branch and Fit”, ACM Trans. Math. Software 35 (2008), Article 9. Original MATLAB code available at www.mat.univie.ac.at/~neum/software/snobfit """ budget, bounds, options = _split_options(options) result, history = skqopt.minimize(fun, x0, bounds=bounds, budget=budget, \ method='snobfit', options=options) return _res2scipy(result, history)
def pybobyqa(fun, x0, *args, **options): """ Bound Optimization BY Quadratic Approximation Trust region method that builds a quadratic approximation in each iteration based on a set of automatically chosen and adjusted interpolation points. Reference: Coralia Cartis, et. al., “Improving the Flexibility and Robustness of Model-Based Derivative-Free Optimization Solvers”, technical report, University of Oxford, (2018). Code available at github.com/numericalalgorithmsgroup/pybobyqa/ """ budget, bounds, options = _split_options(options) result, history = skqopt.minimize(fun, x0, bounds=bounds, budget=budget, \ method='bobyqa', options=options) return _res2scipy(result, history)
def minimize( self, fun: Callable[[POINT], float], x0: POINT, jac: Optional[Callable[[POINT], POINT]] = None, bounds: Optional[List[Tuple[float, float]]] = None, ) -> OptimizerResult: from skquant import opt as skq res, history = skq.minimize( func=fun, x0=np.asarray(x0), bounds=np.array(bounds), budget=self._maxiter, method="bobyqa", ) optimizer_result = OptimizerResult() optimizer_result.x = res.optpar optimizer_result.fun = res.optval optimizer_result.nfev = len(history) return optimizer_result
def nomad(fun, x0, *args, **options): """ Nonlinear Optimization by Mesh Adaptive Direct Search NOMAD is designed for time-consuming blackbox simulations, with a small number of variables, that may fail. It samples the parameter space using a mesh that is adaptively adjusted based on the progress of the search. Reference: C. Audet, S. Le Digabel, C. Tribes and V. Rochon Montplaisir. "The NOMAD project." Software available at https://www.gerad.ca/nomad . S. Le Digabel. "NOMAD: Nonlinear Optimization with the MADS algorithm." ACM Trans. on Mathematical Software, 37(4):44:1–44:15, 2011. Original C++ code available at www.gerad.ca/nomad """ budget, bounds, options = _split_options(options) result, history = skqopt.minimize(fun, x0, bounds=bounds, budget=budget, \ method='nomad', options=options) return _res2scipy(result, history)