195 lines
6.7 KiB
Python
195 lines
6.7 KiB
Python
import math
|
|
|
|
import numpy as np
|
|
from numpy.testing import assert_allclose, assert_array_almost_equal
|
|
|
|
from scipy.optimize import (
|
|
fmin_cobyla, minimize, Bounds, NonlinearConstraint, LinearConstraint,
|
|
OptimizeResult
|
|
)
|
|
|
|
|
|
class TestCobyla:
|
|
def setup_method(self):
|
|
# The algorithm is very fragile on 32 bit, so unfortunately we need to start
|
|
# very near the solution in order for the test to pass.
|
|
self.x0 = [np.sqrt(25 - (2.0/3)**2), 2.0/3 + 1e-4]
|
|
self.solution = [math.sqrt(25 - (2.0/3)**2), 2.0/3]
|
|
self.opts = {'disp': 0, 'rhobeg': 1, 'tol': 1e-6,
|
|
'maxiter': 100}
|
|
|
|
def fun(self, x):
|
|
return x[0]**2 + abs(x[1])**3
|
|
|
|
def con1(self, x):
|
|
return x[0]**2 + x[1]**2 - 25
|
|
|
|
def con2(self, x):
|
|
return -self.con1(x)
|
|
|
|
def test_simple(self):
|
|
# use disp=True as smoke test for gh-8118
|
|
x = fmin_cobyla(self.fun, self.x0, [self.con1, self.con2], rhobeg=1,
|
|
rhoend=1e-5, maxfun=100, disp=1)
|
|
assert_allclose(x, self.solution, atol=1e-4)
|
|
|
|
def test_minimize_simple(self):
|
|
class Callback:
|
|
def __init__(self):
|
|
self.n_calls = 0
|
|
self.last_x = None
|
|
|
|
def __call__(self, x):
|
|
self.n_calls += 1
|
|
self.last_x = x
|
|
|
|
class CallbackNewSyntax:
|
|
def __init__(self):
|
|
self.n_calls = 0
|
|
|
|
def __call__(self, intermediate_result):
|
|
assert isinstance(intermediate_result, OptimizeResult)
|
|
self.n_calls += 1
|
|
|
|
callback = Callback()
|
|
callback_new_syntax = CallbackNewSyntax()
|
|
|
|
# Minimize with method='COBYLA'
|
|
cons = (NonlinearConstraint(self.con1, 0, np.inf),
|
|
{'type': 'ineq', 'fun': self.con2})
|
|
sol = minimize(self.fun, self.x0, method='cobyla', constraints=cons,
|
|
callback=callback, options=self.opts)
|
|
sol_new = minimize(self.fun, self.x0, method='cobyla', constraints=cons,
|
|
callback=callback_new_syntax, options=self.opts)
|
|
assert_allclose(sol.x, self.solution, atol=1e-4)
|
|
assert sol.success, sol.message
|
|
assert sol.maxcv < 1e-5, sol
|
|
assert sol.nfev < 70, sol
|
|
assert sol.fun < self.fun(self.solution) + 1e-3, sol
|
|
assert_array_almost_equal(
|
|
sol.x,
|
|
callback.last_x,
|
|
decimal=5,
|
|
err_msg="Last design vector sent to the callback is not equal to"
|
|
" returned value.",
|
|
)
|
|
assert sol_new.success, sol_new.message
|
|
assert sol.fun == sol_new.fun
|
|
assert sol.maxcv == sol_new.maxcv
|
|
assert sol.nfev == sol_new.nfev
|
|
assert callback.n_calls == callback_new_syntax.n_calls, \
|
|
"Callback is not called the same amount of times for old and new syntax."
|
|
|
|
def test_minimize_constraint_violation(self):
|
|
# We set up conflicting constraints so that the algorithm will be
|
|
# guaranteed to end up with maxcv > 0.
|
|
cons = ({'type': 'ineq', 'fun': lambda x: 4 - x},
|
|
{'type': 'ineq', 'fun': lambda x: x - 5})
|
|
sol = minimize(lambda x: x, [0], method='cobyla', constraints=cons,
|
|
options={'catol': 0.6})
|
|
assert sol.maxcv > 0.1
|
|
assert sol.success
|
|
sol = minimize(lambda x: x, [0], method='cobyla', constraints=cons,
|
|
options={'catol': 0.4})
|
|
assert sol.maxcv > 0.1
|
|
assert not sol.success
|
|
|
|
def test_f_target(self):
|
|
f_target = 250
|
|
sol = minimize(lambda x: x**2, [500], method='cobyla',
|
|
options={'f_target': f_target})
|
|
assert sol.status == 1
|
|
assert sol.success
|
|
assert sol.fun <= f_target
|
|
|
|
def test_minimize_linear_constraints(self):
|
|
constraints = LinearConstraint([1.0, 1.0], 1.0, 1.0)
|
|
sol = minimize(
|
|
self.fun,
|
|
self.x0,
|
|
method='cobyla',
|
|
constraints=constraints,
|
|
options=self.opts,
|
|
)
|
|
solution = [(4 - np.sqrt(7)) / 3, (np.sqrt(7) - 1) / 3]
|
|
assert_allclose(sol.x, solution, atol=1e-4)
|
|
assert sol.success, sol.message
|
|
assert sol.maxcv < 1e-8, sol
|
|
assert sol.nfev <= 100, sol
|
|
assert sol.fun < self.fun(solution) + 1e-3, sol
|
|
|
|
|
|
def test_vector_constraints():
|
|
# test that fmin_cobyla and minimize can take a combination
|
|
# of constraints, some returning a number and others an array
|
|
def fun(x):
|
|
return (x[0] - 1)**2 + (x[1] - 2.5)**2
|
|
|
|
def fmin(x):
|
|
return fun(x) - 1
|
|
|
|
def cons1(x):
|
|
a = np.array([[1, -2, 2], [-1, -2, 6], [-1, 2, 2]])
|
|
return np.array([a[i, 0] * x[0] + a[i, 1] * x[1] +
|
|
a[i, 2] for i in range(len(a))])
|
|
|
|
def cons2(x):
|
|
return x # identity, acts as bounds x > 0
|
|
|
|
x0 = np.array([2, 0])
|
|
cons_list = [fun, cons1, cons2]
|
|
|
|
xsol = [1.4, 1.7]
|
|
fsol = 0.8
|
|
|
|
# testing fmin_cobyla
|
|
sol = fmin_cobyla(fun, x0, cons_list, rhoend=1e-5)
|
|
assert_allclose(sol, xsol, atol=1e-4)
|
|
|
|
sol = fmin_cobyla(fun, x0, fmin, rhoend=1e-5)
|
|
assert_allclose(fun(sol), 1, atol=1e-4)
|
|
|
|
# testing minimize
|
|
constraints = [{'type': 'ineq', 'fun': cons} for cons in cons_list]
|
|
sol = minimize(fun, x0, constraints=constraints, tol=1e-5)
|
|
assert_allclose(sol.x, xsol, atol=1e-4)
|
|
assert sol.success, sol.message
|
|
assert_allclose(sol.fun, fsol, atol=1e-4)
|
|
|
|
constraints = {'type': 'ineq', 'fun': fmin}
|
|
sol = minimize(fun, x0, constraints=constraints, tol=1e-5)
|
|
assert_allclose(sol.fun, 1, atol=1e-4)
|
|
|
|
|
|
class TestBounds:
|
|
# Test cobyla support for bounds (only when used via `minimize`)
|
|
# Invalid bounds is tested in
|
|
# test_optimize.TestOptimizeSimple.test_minimize_invalid_bounds
|
|
|
|
def test_basic(self):
|
|
def f(x):
|
|
return np.sum(x**2)
|
|
|
|
lb = [-1, None, 1, None, -0.5]
|
|
ub = [-0.5, -0.5, None, None, -0.5]
|
|
bounds = [(a, b) for a, b in zip(lb, ub)]
|
|
# these are converted to Bounds internally
|
|
|
|
res = minimize(f, x0=[1, 2, 3, 4, 5], method='cobyla', bounds=bounds)
|
|
ref = [-0.5, -0.5, 1, 0, -0.5]
|
|
assert res.success
|
|
assert_allclose(res.x, ref, atol=1e-3)
|
|
|
|
def test_unbounded(self):
|
|
def f(x):
|
|
return np.sum(x**2)
|
|
|
|
bounds = Bounds([-np.inf, -np.inf], [np.inf, np.inf])
|
|
res = minimize(f, x0=[1, 2], method='cobyla', bounds=bounds)
|
|
assert res.success
|
|
assert_allclose(res.x, 0, atol=1e-3)
|
|
|
|
bounds = Bounds([1, -np.inf], [np.inf, np.inf])
|
|
res = minimize(f, x0=[1, 2], method='cobyla', bounds=bounds)
|
|
assert res.success
|
|
assert_allclose(res.x, [1, 0], atol=1e-3)
|