VERSION 0.3.2

Author: Julian Blank

README.rst

@@ -78,7 +78,7 @@ However, for instance executing NSGA2:
 
     problem = get_problem("zdt2")
 
-    algorithm = NSGA2(pop_size=100, elimate_duplicates=True)
+    algorithm = NSGA2(pop_size=100, eliminate_duplicates=True)
 
     res = minimize(problem,
                    algorithm,

benchmark/benchmark_nelder_mead.py

@@ -4,10 +4,9 @@
 import os
 import pickle
 
-from pymoo.algorithms.so_genetic_algorithm import ga
-from pymoo.algorithms.so_nelder_mead import nelder_mead
-from pymoo.factory import get_problem, get_termination
-from pymoo.operators.crossover.nelder_mead_crossover import NelderMeadCrossover
+from pymoo.algorithms.so_nelder_mead import NelderMead
+
+from pymoo.factory import get_problem
 
 setup = [
     "go-amgm",
@@ -222,7 +221,7 @@ def add_with_variables(D, problem, n_vars):
     prefix = "runs"
 
     # name of the experiment
-    name = "nelder-mead-0.3.1"
+    name = "nelder-mead-0.3.2"
 
     # number of runs to execute
     n_runs = 10
@@ -234,7 +233,7 @@ def add_with_variables(D, problem, n_vars):
 
         problem = get_problem(_problem)
 
-        method = nelder_mead(n_max_restarts=100)
+        method = NelderMead(n_max_local_restarts=2)
 
         for run in range(1, n_runs + 1):
             fname = "%s_%s.run" % (_problem, run)

benchmark/benchmark_nsga2.py

@@ -4,7 +4,8 @@
 import os
 import pickle
 
-from pymoo.algorithms.nsga2 import nsga2
+from pymoo.algorithms.nsga2 import NSGA2
+
 from pymoo.factory import get_sampling, get_crossover, get_mutation, get_problem
 from pymoo.operators.crossover.simulated_binary_crossover import SimulatedBinaryCrossover
 from pymoo.operators.mutation.polynomial_mutation import PolynomialMutation
@@ -90,7 +91,7 @@
     prefix = "runs"
 
     # name of the experiment
-    name = "pynsga2-0.3.1"
+    name = "pynsga2-0.3.2"
 
     # number of runs to execute
     n_runs = 100
@@ -107,7 +108,7 @@
         s = setup[_problem]
         problem = s['problem']
 
-        method = nsga2(
+        method = NSGA2(
             pop_size=s['pop_size'],
             crossover=s['crossover'],
             mutation=s['mutation'],

benchmark/benchmark_nsga3.py

@@ -1,7 +1,7 @@
 import os
 import pickle
 
-from pymoo.algorithms.nsga3 import nsga3
+from pymoo.algorithms.nsga3 import NSGA3
 from pymoo.factory import get_problem, get_reference_directions
 from pymoo.operators.crossover.simulated_binary_crossover import SimulatedBinaryCrossover
 from pymoo.operators.mutation.polynomial_mutation import PolynomialMutation
@@ -206,7 +206,7 @@ def get_setup(n_obj):
     prefix = "runs"
 
     # name of the experiment
-    name = "pynsga3-0.3.1"
+    name = "pynsga3-0.3.2"
 
     # number of runs to execute
     n_runs = 50
@@ -222,7 +222,7 @@ def get_setup(n_obj):
         s = setup[_problem]
         problem = s['problem']
 
-        method = nsga3(
+        method = NSGA3(
             s['ref_dirs'],
             pop_size=s['pop_size'],
             crossover=s['crossover'],

pymoo/algorithms/moead.py

@@ -130,12 +130,4 @@ def _next(self):
             pop[N[I]] = off
 
 
-# =========================================================================================================
-# Interface
-# =========================================================================================================
-
-def moead(*args, **kwargs):
-    return MOEAD(*args, **kwargs)
-
-
 parse_doc_string(MOEAD.__init__)

pymoo/algorithms/nsga2.py

@@ -202,12 +202,4 @@ def calc_crowding_distance(F, filter_out_duplicates=True):
     return crowding
 
 
-# =========================================================================================================
-# Interface
-# =========================================================================================================
-
-def nsga2(*args, **kwargs):
-    return NSGA2(*args, **kwargs)
-
-
 parse_doc_string(NSGA2.__init__)

pymoo/algorithms/nsga3.py

@@ -335,12 +335,4 @@ def calc_niche_count(n_niches, niche_of_individuals):
     return niche_count
 
 
-# =========================================================================================================
-# Interface
-# =========================================================================================================
-
-def nsga3(*args, **kwargs):
-    return NSGA3(*args, **kwargs)
-
-
 parse_doc_string(NSGA3.__init__)

pymoo/algorithms/rnsga2.py

@@ -185,13 +185,4 @@ def calc_norm_pref_distance(A, B, weights, ideal, nadir):
     return np.reshape(N, (A.shape[0], B.shape[0]))
 
 
-# =========================================================================================================
-# Interface
-# =========================================================================================================
-
-
-def rnsga2(*args, **kwargs):
-    return RNSGA2(*args, **kwargs)
-
-
 parse_doc_string(RNSGA2.__init__)

pymoo/algorithms/rnsga3.py

@@ -244,13 +244,4 @@ def line_plane_intersection(l0, l1, p0, p_no, epsilon=1e-6):
         return ref_proj
 
 
-# =========================================================================================================
-# Interface
-# =========================================================================================================
-
-
-def rnsga3(*args, **kwargs):
-    return RNSGA3(*args, **kwargs)
-
-
 parse_doc_string(RNSGA3.__init__)

pymoo/algorithms/so_adam.py

@@ -0,0 +1,48 @@
+import numpy as np
+
+from pymoo.algorithms.so_gradient_descent import GradientBasedAlgorithm
+
+
+class Adam(GradientBasedAlgorithm):
+
+    def __init__(self, X,
+                 alpha=0.005,
+                 beta_1=0.9,
+                 beta_2=0.999,
+                 epsilon=1e-8,
+                 **kwargs) -> None:
+        super().__init__(X, **kwargs)
+
+        self.alpha = alpha
+        self.beta_1 = beta_1
+        self.beta_2 = beta_2
+        self.epsilon = epsilon
+
+        self.t = 0
+        self.m_t = 0
+        self.v_t = 0
+
+    def apply(self):
+        X, dX = self.X, self.dX
+
+        self.t += 1
+        beta_1, beta_2 = self.beta_1, self.beta_2
+
+        # update moving average of gradient and squared gradient
+        self.m_t = beta_1 * self.m_t + (1 - beta_1) * dX
+        self.v_t = beta_2 * self.v_t + (1 - beta_2) * (dX * dX)
+
+        # calculates the bias-corrected estimates
+        m_cap = self.m_t / (1 - (beta_1 ** self.t))
+        v_cap = self.v_t / (1 - (beta_2 ** self.t))
+
+        # do the gradient update
+        self.X = X - (self.alpha * m_cap) / (np.sqrt(v_cap) + self.epsilon)
+
+    def restart(self):
+        self.t = 0
+        self.m_t = 0
+        self.v_t = 0
+        self.alpha /= 2
+
+