def test_no_bounds():
problem = get_problem("sphere", n_var=2)
problem.xl = None
problem.xu = None
method = NelderMead(x0=np.array([1, 1]), max_restarts=0)
minimize(problem, method, verbose=False)
assert True
def test_against_scipy():
problem = get_problem("rosenbrock")
problem.xl = None
problem.xu = None
x0 = np.array([0.5, 0.5])
hist_scipy = []
def fun(x):
hist_scipy.append(x)
return problem.evaluate(x)
scipy_minimize(fun, x0, method='Nelder-Mead')
hist_scipy = np.array(hist_scipy)
hist = []
def callback(x, _):
if x.shape == 2:
hist.extend(x)
else:
hist.append(x)
problem.callback = callback
minimize(
problem,
NelderMead(x0=x0,
max_restarts=0,
termination=get_termination("n_eval", len(hist_scipy))))
hist = np.row_stack(hist)[:len(hist_scipy)]
np.testing.assert_allclose(hist, hist_scipy, rtol=1e-04)
def test_sphere_no_bounds():
problem = SphereNoBounds()
x0 = np.random.random(problem.n_var)
for algorithm in [NelderMead(x0=x0), PatternSearch(x0=x0)]:
f, f_opt = run(problem, algorithm)
np.testing.assert_almost_equal(f, f_opt, decimal=5)
print(problem.__class__.__name__, algorithm.__class__.__name__, "Yes")
def test_nelder_mead(self):
moo_algorithm = NelderMead(max_restarts=1)
self.moo(moo_algorithm)
def test_with_bounds_with_restart():
problem = get_problem("sphere", n_var=2)
method = NelderMead(x0=np.array([1, 1]), max_restarts=2)
minimize(problem, method, verbose=False)
def test_with_bounds_no_initial_point():
problem = get_problem("sphere", n_var=2)
method = NelderMead(max_restarts=0)
minimize(problem, method, verbose=False)
def test_sphere_with_constraints():
problem = SphereWithConstraints()
for algorithm in [GA(), NelderMead(), PatternSearch()]:
f, f_opt = run(problem, algorithm)
np.testing.assert_almost_equal(f, f_opt, decimal=5)
print(problem.__class__.__name__, algorithm.__class__.__name__, "Yes")
instance = 1
n_evals = 1000
for n_var in [10, 20, 40]:
for function in range(1, 25):
label = f"bbob-f{function:02d}-{instance}"
benchmark.add_problem(label + "-" + str(n_var),
get_problem(label, n_var=n_var),
("n_evals", n_evals))
benchmark.add_algorithm("de", DE())
benchmark.add_algorithm("ga", GA())
benchmark.add_algorithm("pso", PSO())
benchmark.add_algorithm("cmaes", SimpleCMAES())
benchmark.add_algorithm("ps", PatternSearch())
benchmark.add_algorithm("nm", NelderMead())
loader = DefaultLoader(FOLDER)
# loader = None
writer = DefaultWriter(FOLDER)
results = benchmark.run(writer=writer,
loader=loader,
run_if_loading_fails=True)
# _ = SingleObjectiveAnalyzer().run(results, benchmark=benchmark, inplace=True)
results = SingleObjectiveAnalyzer().run(results,
benchmark=benchmark,
inplace=False)
from pymoo.algorithms.soo.nonconvex.de import DE
from pymoo.algorithms.soo.nonconvex.direct import DIRECT
from pymoo.algorithms.soo.nonconvex.es import ES
from pymoo.algorithms.soo.nonconvex.nelder_mead import NelderMead
from pymoo.algorithms.soo.nonconvex.pattern_search import PatternSearch
from pymoo.algorithms.soo.nonconvex.pso import PSO
from pymoo.factory import Sphere, Rosenbrock, Himmelblau, ZDT1, get_reference_directions
from pymoo.indicators.igd import IGD
from pymoo.optimize import minimize
SINGLE_OBJECTIVE_PROBLEMS = [Sphere(n_var=10), Himmelblau(), Rosenbrock()]
SINGLE_OBJECTIVE_ALGORITHMS = [
PatternSearch(),
CMAES(),
NelderMead(),
DIRECT(),
PSO(), DE(),
ES()
]
@pytest.mark.parametrize('problem', SINGLE_OBJECTIVE_PROBLEMS)
@pytest.mark.parametrize('algorithm', SINGLE_OBJECTIVE_ALGORITHMS)
def test_singe_obj(problem, algorithm):
res = minimize(problem, algorithm, seed=1, verbose=True)
fmin = problem.pareto_front().flatten()[0]
np.testing.assert_almost_equal(fmin, res.F[0], decimal=3)
MULTI_OBJECTIVE_PROBLEMS = [ZDT1()]