Test Case

Author: Julian Blank

pymoo/algorithms/so_pattern_search.py

@@ -51,15 +51,35 @@ def __init__(self,
                  display=PatternSearchDisplay(),
                  **kwargs):
         """
+        An implementation of well-known Hooke and Jeeves Pattern Search.
 
         Parameters
         ----------
-        explr_delta
-        explr_rho
-        pattern_step
-        eps
-        display
-        kwargs
+
+        x0 : numpy.array
+            The initial value where the local search should be initiated. If not provided `n_sample_points` are created
+            created using latin hypercube sampling and the best solution found is set to `x0`.
+
+        n_sample_points : int
+            Number of sample points to be used to determine the initial search point. (Only used of `x0` is not provided)
+
+        explr_delta : float
+            The `delta` values which is used for the exploration move. If lower and upper bounds are provided the
+            value is in relation to the overall search space. For instance, a value of 0.25 means that initially the
+            pattern is created in 25% distance of the initial search point.
+
+        explr_rho : float
+            If the move was unsuccessful then the `delta` value is reduced by multiplying it with the value provided.
+            For instance, `explr_rho` implies that with a value of `delta/2` is continued.
+
+        pattern_step : float
+            After the exploration move the new center is determined by following a promising direction.
+            This value defines how large to step on this direction will be.
+
+        eps : float
+            This value is used for an additional termination criterion. When all delta values (maximum move along each variable)
+            is less than epsilon the algorithm is terminated. Otherwise, the default termination criteria are also used.
+
         """
 
         super().__init__(display=display, **kwargs)

pymoo/usage/algorithms/usage_nelder_mead.py

@@ -11,5 +11,4 @@
                seed=1,
                verbose=False)
 
-print(res.X)
-print(res.F)
+print("Best solution found: \nX = %s\nF = %s" % (res.X, res.F))

pymoo/usage/algorithms/usage_pattern_search.py

@@ -9,8 +9,6 @@
 res = minimize(problem,
                algorithm,
                seed=1,
-               verbose=True)
+               verbose=False)
 
-print(res.X)
-print(res.F)
-print(res.CV)
+print("Best solution found: \nX = %s\nF = %s" % (res.X, res.F))

tests/algorithms/test_algorithms.py

@@ -70,13 +70,14 @@ def _evaluate(self, x, out, *args, **kwargs):
         self.assertEqual(res.G, None)
 
         res = minimize(MyProblem(),
-                       NSGA2(return_least_infeasible=True),
+                       NSGA2(),
                        ("n_gen", 10),
                        seed=1,
                        verbose=True,
+                       return_least_infeasible=True,
                        save_history=True)
 
-        self.assertEqual(res.CV, 1)
+        self.assertAlmostEqual(res.CV[0], 1.0)
 
 
     def test_thread_pool(self):

tests/algorithms/test_pattern_search.py

@@ -16,9 +16,9 @@ class PatternSearchTest(unittest.TestCase):
     def test_against_orginal_implementation(self):
 
         for problem in [
-            Sphere(n_var=10),
             Ackley(n_var=2),
             Rosenbrock(n_var=2),
+            Sphere(n_var=10),
         ]:
 
             print(problem.__class__.__name__)
@@ -49,8 +49,8 @@ def test_against_orginal_implementation(self):
             n = min(len(X), len(_X))
             X, _X, F, _F = X[:n], _X[:n], F[:n], _F[:n]
 
-            np.testing.assert_allclose(X, _X, rtol=0, atol=1e-4)
-            np.testing.assert_allclose(F, _F, rtol=0, atol=1e-4)
+            np.testing.assert_allclose(X, _X, rtol=0, atol=1e-3)
+            np.testing.assert_allclose(F, _F, rtol=0, atol=1e-3)
 
 
 def best_nearby(delta, point, prevbest, nvars, f, funevals):

tests/algorithms/test_single_objective.py

@@ -2,89 +2,67 @@
 
 import numpy as np
 
-from pymoo.algorithms.nsga2 import NSGA2
-from pymoo.factory import get_problem, Problem, ZDT
+from pymoo.algorithms.so_genetic_algorithm import GA
+from pymoo.algorithms.so_nelder_mead import NelderMead
+from pymoo.algorithms.so_pattern_search import PatternSearch
+from pymoo.algorithms.so_pso import PSO
+from pymoo.factory import Sphere, Problem
 from pymoo.optimize import minimize
 
-class MyThreadedProblem(Problem):
 
-    def __init__(self):
-        super().__init__(n_var=2,
-                         n_obj=1,
-                         n_constr=0,
-                         elementwise_evaluation=True,
-                         parallelization=("threads", 4),
-                         xl=np.array([0, 0]),
-                         xu=np.array([100, 100]))
+class SphereNoBounds(Sphere):
 
-    def _evaluate(self, x, out, *args, **kwargs):
-        out["F"] = x[0] + x[1]
-
-
-class AlgorithmTest(unittest.TestCase):
+    def __init__(self, n_var=10, **kwargs):
+        super().__init__(n_var=n_var, **kwargs)
+        self.xl = None
+        self.xu = None
 
-    def test_same_seed_same_result(self):
-        problem = get_problem("zdt3")
-        algorithm = NSGA2(pop_size=100, eliminate_duplicates=True)
 
-        res1 = minimize(problem, algorithm, ('n_gen', 20), seed=1)
-        np.random.seed(200)
-        res2 = minimize(problem, algorithm, ('n_gen', 20), seed=1)
+class SphereWithConstraints(Problem):
 
-        self.assertEqual(res1.X.shape, res2.X.shape)
-        self.assertTrue(np.all(np.allclose(res1.X, res2.X)))
+    def __init__(self, n_var=10):
+        super().__init__(n_var=n_var, n_obj=1, n_constr=1, xl=-0, xu=1, type_var=np.double)
 
-    def test_no_pareto_front_given(self):
-        class ZDT1NoPF(ZDT):
-            def _evaluate(self, x, out, *args, **kwargs):
-                f1 = x[:, 0]
-                g = 1 + 9.0 / (self.n_var - 1) * np.sum(x[:, 1:], axis=1)
-                f2 = g * (1 - np.power((f1 / g), 0.5))
-                out["F"] = np.column_stack([f1, f2])
-
-        algorithm = NSGA2(pop_size=100, eliminate_duplicates=True)
-        minimize(ZDT1NoPF(), algorithm, ('n_gen', 20), seed=1, verbose=True)
+    def _evaluate(self, x, out, *args, **kwargs):
+        out["F"] = np.sum(np.square(x - 0.5), axis=1)
+        out["G"] = 0.1 - out["F"]
 
-    def test_no_feasible_solution_found(self):
-        class MyProblem(Problem):
+    def _calc_pareto_front(self):
+        return 0.1
 
-            def __init__(self):
-                super().__init__(n_var=2,
-                                 n_obj=1,
-                                 n_constr=36,
-                                 xl=np.array([0, 0]),
-                                 xu=np.array([100, 100]))
 
-            def _evaluate(self, x, out, *args, **kwargs):
-                f1 = x[:, 0] + x[:, 1]
-                out["F"] = np.column_stack([f1])
-                out["G"] = np.ones(len(x))
+def test(problem, algorithm):
+    res = minimize(problem, algorithm, seed=1)
+    f = res.F[0]
+    print(res.CV)
+    f_opt = problem.pareto_front()[0, 0]
+    return f, f_opt
 
-        res = minimize(MyProblem(),
-                       NSGA2(),
-                       ("n_gen", 10),
-                       seed=1)
 
-        self.assertEqual(res.X, None)
-        self.assertEqual(res.F, None)
-        self.assertEqual(res.G, None)
+class SingleObjectiveAlgorithmTest(unittest.TestCase):
 
-        res = minimize(MyProblem(),
-                       NSGA2(return_least_infeasible=True),
-                       ("n_gen", 10),
-                       seed=1,
-                       verbose=True,
-                       save_history=True)
+    def test_sphere(self):
+        problem = Sphere()
+        for algorithm in [NelderMead(), PatternSearch(), PSO(), GA()]:
+            f, f_opt = test(problem, algorithm)
+            self.assertAlmostEqual(f, f_opt, places=5)
+            print(problem.__class__.__name__, algorithm.__class__.__name__, "Yes")
 
-        self.assertEqual(res.CV, 1)
+    def test_sphere_with_constraints(self):
+        problem = SphereWithConstraints()
+        for algorithm in [GA(), NelderMead(), PatternSearch()]:
+            f, f_opt = test(problem, algorithm)
+            self.assertAlmostEqual(f, f_opt, places=3)
+            print(problem.__class__.__name__, algorithm.__class__.__name__, "Yes")
 
+    def test_sphere_no_bounds(self):
+        problem = SphereNoBounds()
+        x0 = np.random.random(problem.n_var)
 
-    def test_thread_pool(self):
-        minimize(MyThreadedProblem(),
-                 NSGA2(),
-                 ("n_gen", 10),
-                 seed=1,
-                 save_history=False)
+        for algorithm in [NelderMead(x0=x0), PatternSearch(x0=x0)]:
+            f, f_opt = test(problem, algorithm)
+            self.assertAlmostEqual(f, f_opt, places=5)
+            print(problem.__class__.__name__, algorithm.__class__.__name__, "Yes")
 
 
 if __name__ == '__main__':