Loop-wise Algorithm Execution and Checkpoints

Author: Julian Blank

.gitignore

@@ -1,6 +1,7 @@
 **/.DS_Store
 **/.vscode
 **/.mp4
+**/.npy
 
 
 # Byte-compiled / optimized / DLL files

benchmark/benchmark_nsga3.py

@@ -191,7 +191,6 @@ def get_setup(n_obj):
     },
 
 
-
 }
 
 

pymoo/algorithms/ctaea.py

@@ -4,6 +4,7 @@
 from scipy.spatial.distance import cdist, pdist, squareform
 
 from pymoo.algorithms.genetic_algorithm import GeneticAlgorithm
+from pymoo.docs import parse_doc_string
 from pymoo.factory import get_decomposition
 from pymoo.model.individual import Individual
 from pymoo.model.population import Population
@@ -89,17 +90,16 @@ def __init__(self,
                  display=MultiObjectiveDisplay(),
                  **kwargs):
         """
+        CTAEA
 
         Parameters
         ----------
-
         ref_dirs : {ref_dirs}
         sampling : {sampling}
         selection : {selection}
         crossover : {crossover}
         mutation : {mutation}
         eliminate_duplicates : {eliminate_duplicates}
-
         """
 
         self.ref_dirs = ref_dirs
@@ -194,7 +194,7 @@ def __init__(self, ref_dirs):
         self._decomposition = get_decomposition('asf')
         self._calc_perpendicular_distance = load_function("calc_perpendicular_distance")
 
-    def do(self, problem, pop, da, n_survive, **kwargs):
+    def do(self, _, pop, da, n_survive, **kwargs):
         # Offspring are last of merged population
         off = pop[-n_survive:]
         # Update ideal point
@@ -322,3 +322,6 @@ def _updateDA(self, pop, Hd, n_survive):
                     break
             itr += 1
         return Hd[S]
+
+
+parse_doc_string(CTAEA.__init__)

pymoo/algorithms/moead.py

@@ -25,6 +25,8 @@ def __init__(self,
                  **kwargs):
         """
 
+        MOEAD Algorithm.
+
         Parameters
         ----------
         ref_dirs

pymoo/algorithms/nsga2.py

@@ -121,6 +121,7 @@ class RankAndCrowdingSurvival(Survival):
 
     def __init__(self) -> None:
         super().__init__(filter_infeasible=True)
+        self.nds = NonDominatedSorting()
 
     def _do(self, problem, pop, n_survive, D=None, **kwargs):
 
@@ -131,7 +132,7 @@ def _do(self, problem, pop, n_survive, D=None, **kwargs):
         survivors = []
 
         # do the non-dominated sorting until splitting front
-        fronts = NonDominatedSorting().do(F, n_stop_if_ranked=n_survive)
+        fronts = self.nds.do(F, n_stop_if_ranked=n_survive)
 
         for k, front in enumerate(fronts):
 

pymoo/algorithms/nsga3.py

@@ -71,8 +71,16 @@ def __init__(self,
 
         self.ref_dirs = ref_dirs
 
-        if pop_size is None:
-            pop_size = len(ref_dirs)
+        # in case of R-NSGA-3 they will be None - otherwise this will be executed
+        if self.ref_dirs is not None:
+
+            if pop_size is None:
+                pop_size = len(self.ref_dirs)
+
+            if pop_size < len(self.ref_dirs):
+                print(f"WARNING: pop_size={pop_size} is less than the number of reference directions ref_dirs={len(self.ref_dirs)}.\n"
+                      "This might cause unwanted behavior of the algorithm. \nPlease make sure pop_size is equal or larger "
+                      "than the number of reference directions. ")
 
         kwargs['individual'] = Individual(rank=np.inf, niche=-1, dist_to_niche=np.inf)
 

pymoo/algorithms/so_cmaes.py

@@ -363,8 +363,8 @@ def __init__(self,
         self.parallelize = parallelize
         self.al = None
 
-    def initialize(self, problem, seed=None, **kwargs):
-        super().initialize(problem, **kwargs)
+    def setup(self, problem, seed=None, **kwargs):
+        super().setup(problem, **kwargs)
         self.n_gen = 0
 
         xl = problem.xl.tolist() if problem.xl is not None else None
@@ -438,7 +438,7 @@ def _next(self):
             X = np.atleast_2d(X)
 
             # evaluate the population
-            self.pop = Population().new("X", X)
+            self.pop = Population.new("X", X)
             self.evaluator.eval(self.problem, self.pop, algorithm=self)
 
             # set infeasible individual's objective values to np.nan - then CMAES can handle it

pymoo/algorithms/so_de.py

@@ -7,7 +7,7 @@
 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
-from pymoo.operators.repair.bounds_back_repair import BoundsBackRepair
+from pymoo.operators.repair.bounce_back import BounceBackOutOfBoundsRepair
 from pymoo.operators.sampling.latin_hypercube_sampling import LatinHypercubeSampling
 from pymoo.operators.selection.random_selection import RandomSelection
 from pymoo.util.display import SingleObjectiveDisplay
@@ -120,7 +120,7 @@ def _next(self):
         self.off = mutation.do(self.problem, _pop, _P, algorithm=self)[:len(self.pop)]
 
         # bounds back if something is out of bounds
-        self.off = BoundsBackRepair().do(self.problem, self.off)
+        self.off = BounceBackOutOfBoundsRepair().do(self.problem, self.off)
 
         # evaluate the results
         self.evaluator.eval(self.problem, self.off, algorithm=self)

pymoo/algorithms/so_direct.py

@@ -38,8 +38,8 @@ def __init__(self,
         self.penalty = penalty
         self.n_max_candidates = n_max_candidates
 
-    def initialize(self, problem, **kwargs):
-        super().initialize(problem, **kwargs)
+    def setup(self, problem, **kwargs):
+        super().setup(problem, **kwargs)
 
         xl, xu = problem.bounds()
         X = denormalize(0.5 * np.ones(problem.n_var), xl, xu)

pymoo/algorithms/so_gradient_descent.py

@@ -2,7 +2,7 @@
 
 from pymoo.model.algorithm import Algorithm
 from pymoo.model.population import Population
-from pymoo.operators.repair.out_of_bounds_repair import repair_out_of_bounds
+from pymoo.operators.repair.to_bound import set_to_bounds_if_outside_by_problem
 from pymoo.util.display import SingleObjectiveDisplay
 from pymoo.util.termination.default import SingleObjectiveDefaultTermination
 
@@ -60,7 +60,7 @@ def _next(self):
 
                 # make the step and check out of bounds for X
                 self.apply()
-                self.X = repair_out_of_bounds(self.problem, self.X)
+                self.X = set_to_bounds_if_outside_by_problem(self.problem, self.X)
 
                 # set the population object for automatic print
                 self.pop = Population(len(self.X)).set("X", self.X, "F", self.F,