Pattern Search and Riesz s-Energy Reference Directions

Author: Julian Blank

pymoo/algorithms/genetic_algorithm.py

@@ -77,7 +77,7 @@ def _initialize(self):
         if self.survival:
             pop = self.survival.do(self.problem, pop, len(pop), algorithm=self)
 
-        self.pop = pop
+        self.pop, self.off = pop, pop
 
     def _next(self):
 

pymoo/algorithms/so_adam.py

@@ -5,7 +5,8 @@
 
 class Adam(GradientBasedAlgorithm):
 
-    def __init__(self, X,
+    def __init__(self,
+                 X,
                  alpha=0.005,
                  beta_1=0.9,
                  beta_2=0.999,

pymoo/algorithms/so_cmaes.py

@@ -1,9 +1,9 @@
 import numpy as np
 
+from pymoo.algorithms.so_local_search import LocalSearch
 from pymoo.docs import parse_doc_string
-from pymoo.model.algorithm import Algorithm, filter_optimum
+from pymoo.model.algorithm import filter_optimum
 from pymoo.model.population import Population
-from pymoo.operators.sampling.random_sampling import FloatRandomSampling
 from pymoo.util.display import Display
 from pymoo.util.termination.max_eval import MaximumFunctionCallTermination
 from pymoo.util.termination.max_gen import MaximumGenerationTermination
@@ -47,10 +47,9 @@ def _do(self, problem, evaluator, algorithm):
         self.output.append("axis", axis, width=8)
 
 
-class CMAES(Algorithm):
+class CMAES(LocalSearch):
 
     def __init__(self,
-                 x0=None,
                  sigma=0.5,
                  parallelize=True,
                  maxfevals=np.inf,
@@ -339,7 +338,6 @@ def __init__(self,
         self.es = None
         self.cma = None
 
-        self.x0 = x0
         self.sigma = sigma
         self.restarts = restarts
         self.restart_from_best = restart_from_best
@@ -362,6 +360,7 @@ def __init__(self,
         self.default_termination = NoTermination()
         self.send_array_to_yield = True
         self.parallelize = parallelize
+        self.al = None
 
     def initialize(self, problem, seed=None, **kwargs):
         super().initialize(problem, **kwargs)
@@ -378,13 +377,18 @@ def initialize(self, problem, seed=None, **kwargs):
         elif isinstance(self.termination, MaximumFunctionCallTermination):
             self.options['maxfevals'] = self.termination.n_max_evals
 
-        if self.x0 is None:
-            np.random.seed(seed)
-            self.x0 = FloatRandomSampling().do(problem, 1).get("X")[0]
+        # if self.problem.n_constr > 0:
+        #     _al = AugmentedLagrangian(problem.n_var)
+        #     _al.set_m(problem.n_constr)
+        #     _al._equality = np.full(problem.n_constr, False)
+        #     self.al = _al
+        #     kwargs.setdefault('options', {}).setdefault('tolstagnation', 0)
 
-        self.es = my_fmin(
-            self.x0,
-            self.sigma,
+    def _initialize(self):
+        super()._initialize()
+        self.pop = Population()
+
+        kwargs = dict(
             options=self.options,
             parallelize=self.parallelize,
             restarts=self.restarts,
@@ -394,19 +398,30 @@ def initialize(self, problem, seed=None, **kwargs):
             noise_handler=self.noise_handler,
             noise_change_sigma_exponent=self.noise_change_sigma_exponent,
             noise_kappa_exponent=self.noise_kappa_exponent,
-            bipop=self.bipop
-        )
+            bipop=self.bipop)
 
-    def _initialize(self):
+        self.es = my_fmin(self.x0.X, self.sigma, **kwargs)
         self._next()
 
     def _next(self):
 
-        if self.pop is None:
+        if self.pop is None or len(self.pop) == 0:
             X = next(self.es)
 
         else:
             F = self.pop.get("F")[:, 0].tolist()
+            #
+            # if self.problem.n_constr > 0:
+            #     G = self.pop.get("G").tolist()
+            #     self.al.set_coefficients(F, G)
+            #
+            #     x = self.es.gi_frame.f_locals["es"].ask(1, sigma_fac=0)[0]
+            #     ind = Individual(X=x)
+            #     self.evaluator.eval(self.problem, ind, algorithm=self)
+            #     self.al.update(ind.F[0], ind.G)
+            #
+            #     F = F + sum(self.al(G))
+
             if not self.send_array_to_yield:
                 F = F[0]
 

pymoo/algorithms/so_de.py

@@ -2,6 +2,7 @@
 
 from pymoo.algorithms.genetic_algorithm import GeneticAlgorithm
 from pymoo.docs import parse_doc_string
+from pymoo.model.replacement import ImprovementReplacement
 from pymoo.operators.crossover.biased_crossover import BiasedCrossover
 from pymoo.operators.crossover.differental_evolution_crossover import DifferentialEvolutionCrossover
 from pymoo.operators.crossover.exponential_crossover import ExponentialCrossover
@@ -123,17 +124,8 @@ def _next(self):
         # evaluate the results
         self.evaluator.eval(self.problem, self.off, algorithm=self)
 
-        _F, _CV, _feasible = self.off.get("F", "CV", "feasible")
-        _F = parameter_less(_F, _CV)
-
-        # find the individuals which are indeed better
-        is_better = np.where((_F <= F)[:, 0])[0]
-
-        # replace the individuals in the population
-        pop[is_better] = self.off[is_better]
-
-        # store the population in the algorithm object
-        self.pop = pop
+        # replace the individuals that have improved
+        self.pop = ImprovementReplacement().do(self.problem, self.pop, self.off)
 
 
 parse_doc_string(DE.__init__)

pymoo/algorithms/so_local_search.py

@@ -0,0 +1,39 @@
+from pymoo.model.algorithm import Algorithm
+from pymoo.model.population import pop_from_array_or_individual
+from pymoo.operators.sampling.latin_hypercube_sampling import LatinHypercubeSampling
+
+
+class LocalSearch(Algorithm):
+
+    def __init__(self,
+                 x0=None,
+                 sampling=LatinHypercubeSampling(),
+                 n_sample_points="auto",
+                 **kwargs):
+
+        super().__init__(**kwargs)
+        self.x0 = x0
+        self.sampling = sampling
+        self.n_sample_points = n_sample_points
+
+    def initialize(self, problem, **kwargs):
+        super().initialize(problem, **kwargs)
+
+        if self.n_sample_points == "auto":
+            self.n_sample_points = self.problem.n_var * 5
+
+    def _initialize(self, **kwargs):
+        super()._initialize(**kwargs)
+
+        # no initial point is provided - sample in bounds and take the best
+        if self.x0 is None:
+            if not self.problem.has_bounds():
+                raise Exception("Either provide an x0 or a problem with variable bounds!")
+
+            self.pop = self.sampling.do(self.problem, self.n_sample_points)
+        else:
+            self.pop = pop_from_array_or_individual(self.x0)
+
+        self.evaluator.eval(self.problem, self.pop, algorithm=self)
+        self._set_optimum()
+        self.x0 = self.opt[0]