""" Unit test for DIRECT optimization algorithm. """ from numpy.testing import (assert_allclose, assert_array_less) import pytest import numpy as np from scipy.optimize import direct, Bounds class TestDIRECT: def setup_method(self): self.fun_calls = 0 self.bounds_sphere = 4*[(-2, 3)] self.optimum_sphere_pos = np.zeros((4, )) self.optimum_sphere = 0.0 self.bounds_stylinski_tang = Bounds([-4., -4.], [4., 4.]) self.maxiter = 1000 # test functions def sphere(self, x): self.fun_calls += 1 return np.square(x).sum() def inv(self, x): if np.sum(x) == 0: raise ZeroDivisionError() return 1/np.sum(x) def nan_fun(self, x): return np.nan def inf_fun(self, x): return np.inf def styblinski_tang(self, pos): x, y = pos return 0.5 * (x**4 - 16 * x**2 + 5 * x + y**4 - 16 * y**2 + 5 * y) @pytest.mark.parametrize("locally_biased", [True, False]) def test_direct(self, locally_biased): res = direct(self.sphere, self.bounds_sphere, locally_biased=locally_biased) # test accuracy assert_allclose(res.x, self.optimum_sphere_pos, rtol=1e-3, atol=1e-3) assert_allclose(res.fun, self.optimum_sphere, atol=1e-5, rtol=1e-5) # test that result lies within bounds _bounds = np.asarray(self.bounds_sphere) assert_array_less(_bounds[:, 0], res.x) assert_array_less(res.x, _bounds[:, 1]) # test number of function evaluations. Original DIRECT overshoots by # up to 500 evaluations in last iteration assert res.nfev <= 1000 * (len(self.bounds_sphere) + 1) # test that number of function evaluations is correct assert res.nfev == self.fun_calls # test that number of iterations is below supplied maximum assert res.nit <= self.maxiter @pytest.mark.parametrize("locally_biased", [True, False]) def test_direct_callback(self, locally_biased): # test that callback does not change the result res = direct(self.sphere, self.bounds_sphere, locally_biased=locally_biased) def callback(x): x = 2*x dummy = np.square(x) print("DIRECT minimization algorithm callback test") return dummy res_callback = direct(self.sphere, self.bounds_sphere, locally_biased=locally_biased, callback=callback) assert_allclose(res.x, res_callback.x) assert res.nit == res_callback.nit assert res.nfev == res_callback.nfev assert res.status == res_callback.status assert res.success == res_callback.success assert res.fun == res_callback.fun assert_allclose(res.x, res_callback.x) assert res.message == res_callback.message # test accuracy assert_allclose(res_callback.x, self.optimum_sphere_pos, rtol=1e-3, atol=1e-3) assert_allclose(res_callback.fun, self.optimum_sphere, atol=1e-5, rtol=1e-5) @pytest.mark.parametrize("locally_biased", [True, False]) def test_exception(self, locally_biased): bounds = 4*[(-10, 10)] with pytest.raises(ZeroDivisionError): direct(self.inv, bounds=bounds, locally_biased=locally_biased) @pytest.mark.parametrize("locally_biased", [True, False]) def test_nan(self, locally_biased): bounds = 4*[(-10, 10)] direct(self.nan_fun, bounds=bounds, locally_biased=locally_biased) @pytest.mark.parametrize("len_tol", [1e-3, 1e-4]) @pytest.mark.parametrize("locally_biased", [True, False]) def test_len_tol(self, len_tol, locally_biased): bounds = 4*[(-10., 10.)] res = direct(self.sphere, bounds=bounds, len_tol=len_tol, vol_tol=1e-30, locally_biased=locally_biased) assert res.status == 5 assert res.success assert_allclose(res.x, np.zeros((4, ))) message = ("The side length measure of the hyperrectangle containing " "the lowest function value found is below " f"len_tol={len_tol}") assert res.message == message @pytest.mark.parametrize("vol_tol", [1e-6, 1e-8]) @pytest.mark.parametrize("locally_biased", [True, False]) def test_vol_tol(self, vol_tol, locally_biased): bounds = 4*[(-10., 10.)] res = direct(self.sphere, bounds=bounds, vol_tol=vol_tol, len_tol=0., locally_biased=locally_biased) assert res.status == 4 assert res.success assert_allclose(res.x, np.zeros((4, ))) message = ("The volume of the hyperrectangle containing the lowest " f"function value found is below vol_tol={vol_tol}") assert res.message == message @pytest.mark.parametrize("f_min_rtol", [1e-3, 1e-5, 1e-7]) @pytest.mark.parametrize("locally_biased", [True, False]) def test_f_min(self, f_min_rtol, locally_biased): # test that desired function value is reached within # relative tolerance of f_min_rtol f_min = 1. bounds = 4*[(-2., 10.)] res = direct(self.sphere, bounds=bounds, f_min=f_min, f_min_rtol=f_min_rtol, locally_biased=locally_biased) assert res.status == 3 assert res.success assert res.fun < f_min * (1. + f_min_rtol) message = ("The best function value found is within a relative " f"error={f_min_rtol} of the (known) global optimum f_min") assert res.message == message def circle_with_args(self, x, a, b): return np.square(x[0] - a) + np.square(x[1] - b).sum() @pytest.mark.parametrize("locally_biased", [True, False]) def test_f_circle_with_args(self, locally_biased): bounds = 2*[(-2.0, 2.0)] res = direct(self.circle_with_args, bounds, args=(1, 1), maxfun=1250, locally_biased=locally_biased) assert_allclose(res.x, np.array([1., 1.]), rtol=1e-5) @pytest.mark.parametrize("locally_biased", [True, False]) def test_failure_maxfun(self, locally_biased): # test that if optimization runs for the maximal number of # evaluations, success = False is returned maxfun = 100 result = direct(self.styblinski_tang, self.bounds_stylinski_tang, maxfun=maxfun, locally_biased=locally_biased) assert result.success is False assert result.status == 1 assert result.nfev >= maxfun message = ("Number of function evaluations done is " f"larger than maxfun={maxfun}") assert result.message == message @pytest.mark.parametrize("locally_biased", [True, False]) def test_failure_maxiter(self, locally_biased): # test that if optimization runs for the maximal number of # iterations, success = False is returned maxiter = 10 result = direct(self.styblinski_tang, self.bounds_stylinski_tang, maxiter=maxiter, locally_biased=locally_biased) assert result.success is False assert result.status == 2 assert result.nit >= maxiter message = f"Number of iterations is larger than maxiter={maxiter}" assert result.message == message @pytest.mark.parametrize("locally_biased", [True, False]) def test_bounds_variants(self, locally_biased): # test that new and old bounds yield same result lb = [-6., 1., -5.] ub = [-1., 3., 5.] x_opt = np.array([-1., 1., 0.]) bounds_old = list(zip(lb, ub)) bounds_new = Bounds(lb, ub) res_old_bounds = direct(self.sphere, bounds_old, locally_biased=locally_biased) res_new_bounds = direct(self.sphere, bounds_new, locally_biased=locally_biased) assert res_new_bounds.nfev == res_old_bounds.nfev assert res_new_bounds.message == res_old_bounds.message assert res_new_bounds.success == res_old_bounds.success assert res_new_bounds.nit == res_old_bounds.nit assert_allclose(res_new_bounds.x, res_old_bounds.x) assert_allclose(res_new_bounds.x, x_opt, rtol=1e-2) @pytest.mark.parametrize("locally_biased", [True, False]) @pytest.mark.parametrize("eps", [1e-5, 1e-4, 1e-3]) def test_epsilon(self, eps, locally_biased): result = direct(self.styblinski_tang, self.bounds_stylinski_tang, eps=eps, vol_tol=1e-6, locally_biased=locally_biased) assert result.status == 4 assert result.success @pytest.mark.xslow @pytest.mark.parametrize("locally_biased", [True, False]) def test_no_segmentation_fault(self, locally_biased): # test that an excessive number of function evaluations # does not result in segmentation fault bounds = [(-5., 20.)] * 100 result = direct(self.sphere, bounds, maxfun=10000000, maxiter=1000000, locally_biased=locally_biased) assert result is not None @pytest.mark.parametrize("locally_biased", [True, False]) def test_inf_fun(self, locally_biased): # test that an objective value of infinity does not crash DIRECT bounds = [(-5., 5.)] * 2 result = direct(self.inf_fun, bounds, locally_biased=locally_biased) assert result is not None @pytest.mark.parametrize("len_tol", [-1, 2]) def test_len_tol_validation(self, len_tol): error_msg = "len_tol must be between 0 and 1." with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, self.bounds_stylinski_tang, len_tol=len_tol) @pytest.mark.parametrize("vol_tol", [-1, 2]) def test_vol_tol_validation(self, vol_tol): error_msg = "vol_tol must be between 0 and 1." with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, self.bounds_stylinski_tang, vol_tol=vol_tol) @pytest.mark.parametrize("f_min_rtol", [-1, 2]) def test_fmin_rtol_validation(self, f_min_rtol): error_msg = "f_min_rtol must be between 0 and 1." with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, self.bounds_stylinski_tang, f_min_rtol=f_min_rtol, f_min=0.) @pytest.mark.parametrize("maxfun", [1.5, "string", (1, 2)]) def test_maxfun_wrong_type(self, maxfun): error_msg = "maxfun must be of type int." with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, self.bounds_stylinski_tang, maxfun=maxfun) @pytest.mark.parametrize("maxiter", [1.5, "string", (1, 2)]) def test_maxiter_wrong_type(self, maxiter): error_msg = "maxiter must be of type int." with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, self.bounds_stylinski_tang, maxiter=maxiter) def test_negative_maxiter(self): error_msg = "maxiter must be > 0." with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, self.bounds_stylinski_tang, maxiter=-1) def test_negative_maxfun(self): error_msg = "maxfun must be > 0." with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, self.bounds_stylinski_tang, maxfun=-1) @pytest.mark.parametrize("bounds", ["bounds", 2., 0]) def test_invalid_bounds_type(self, bounds): error_msg = ("bounds must be a sequence or " "instance of Bounds class") with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, bounds) @pytest.mark.parametrize("bounds", [Bounds([-1., -1], [-2, 1]), Bounds([-np.nan, -1], [-2, np.nan]), ] ) def test_incorrect_bounds(self, bounds): error_msg = 'Bounds are not consistent min < max' with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, bounds) def test_inf_bounds(self): error_msg = 'Bounds must not be inf.' bounds = Bounds([-np.inf, -1], [-2, np.inf]) with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, bounds) @pytest.mark.parametrize("locally_biased", ["bias", [0, 0], 2.]) def test_locally_biased_validation(self, locally_biased): error_msg = 'locally_biased must be True or False.' with pytest.raises(ValueError, match=error_msg): direct(self.styblinski_tang, self.bounds_stylinski_tang, locally_biased=locally_biased)