Revmoed Templated Individual

Author: Julian Blank

benchmark/benchmark_nsga2.py

@@ -91,7 +91,7 @@
     prefix = "runs"
 
     # name of the experiment
-    name = "pynsga2-0.4.0"
+    name = "pynsga2-0.4.2"
 
     # number of runs to execute
     n_runs = 100

benchmark/benchmark_nsga3.py

@@ -203,7 +203,7 @@ def get_setup(n_obj):
     prefix = "runs"
 
     # name of the experiment
-    name = "pynsga3-0.4.0"
+    name = "pynsga3-0.4.2"
 
     # number of runs to execute
     n_runs = 50

pymoo/algorithms/ctaea.py

@@ -105,8 +105,6 @@ def __init__(self,
         self.ref_dirs = ref_dirs
         pop_size = len(ref_dirs)
 
-        kwargs['individual'] = Individual(rank=np.inf, niche=-1, FV=-1)
-
         if 'survival' in kwargs:
             survival = kwargs['survival']
             del kwargs['survival']
@@ -129,7 +127,7 @@ def __init__(self,
 
     def _initialize(self):
         # Prepare diversity archives
-        da = Population(0, individual=self.individual)
+        da = Population()
 
         # create the initial population
         pop = self.initialization.do(self.problem, self.pop_size, algorithm=self)

pymoo/algorithms/genetic_algorithm.py

@@ -1,6 +1,5 @@
 from pymoo.model.algorithm import Algorithm
 from pymoo.model.duplicate import DefaultDuplicateElimination, NoDuplicateElimination
-from pymoo.model.individual import Individual
 from pymoo.model.initialization import Initialization
 from pymoo.model.mating import Mating
 from pymoo.model.population import Population
@@ -20,7 +19,6 @@ def __init__(self,
                  eliminate_duplicates=DefaultDuplicateElimination(),
                  repair=None,
                  mating=None,
-                 individual=Individual(),
                  min_infeas_pop_size=0,
                  **kwargs
                  ):
@@ -43,9 +41,6 @@ def __init__(self,
         if self.n_offsprings is None:
             self.n_offsprings = pop_size
 
-        # the object to be used to represent an individual - either individual or derived class
-        self.individual = individual
-
         # set the duplicate detection class - a boolean value chooses the default duplicate detection
         if isinstance(eliminate_duplicates, bool):
             if eliminate_duplicates:
@@ -59,7 +54,6 @@ def __init__(self,
         self.repair = repair if repair is not None else NoRepair()
 
         self.initialization = Initialization(sampling,
-                                             individual=individual,
                                              repair=self.repair,
                                              eliminate_duplicates=self.eliminate_duplicates)
 

pymoo/algorithms/moead.py

@@ -2,7 +2,10 @@
 from scipy.spatial.distance import cdist
 
 from pymoo.algorithms.genetic_algorithm import GeneticAlgorithm
+from pymoo.algorithms.nsga2 import NSGA2
 from pymoo.factory import get_decomposition
+from pymoo.model.individual import Individual
+from pymoo.model.population import Population
 from pymoo.operators.crossover.simulated_binary_crossover import SimulatedBinaryCrossover
 from pymoo.operators.mutation.polynomial_mutation import PolynomialMutation
 from pymoo.operators.sampling.random_sampling import FloatRandomSampling

pymoo/algorithms/nsga2.py

@@ -46,7 +46,7 @@ def binary_tournament(pop, P, algorithm, **kwargs):
                     S[i] = b
 
             elif tournament_type == 'comp_by_rank_and_crowding':
-                S[i] = compare(a, pop[a].rank, b, pop[b].rank,
+                S[i] = compare(a, pop[a].get("rank"), b, pop[b].get("rank"),
                                method='smaller_is_better')
 
             else:
@@ -91,7 +91,6 @@ def __init__(self,
 
         """
 
-        kwargs['individual'] = Individual(rank=np.inf, crowding=-1)
         super().__init__(pop_size=pop_size,
                          sampling=sampling,
                          selection=selection,

pymoo/algorithms/nsga3.py

@@ -82,8 +82,6 @@ def __init__(self,
                       "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)
-
         if 'survival' in kwargs:
             survival = kwargs['survival']
             del kwargs['survival']

pymoo/model/crossover.py

@@ -61,6 +61,6 @@ def do(self, problem, pop, parents, **kwargs):
         X = X.reshape(-1, X.shape[-1])
 
         # create a population object
-        off = pop.new("X", X)
+        off = Population.new("X", X)
 
         return off

pymoo/model/individual.py

@@ -1,28 +1,118 @@
 import copy
 
-from pymoo.util.dynamic_dict import DynamicDict
 
+class Individual:
 
-class Individual(DynamicDict):
+    def __init__(self, X=None, F=None, CV=None, G=None, feasible=None, **kwargs) -> None:
+        self.X = X
+        self.F = F
+        self.CV = CV
+        self.G = G
+        self.feasible = feasible
+        self.data = kwargs
+        self.attr = set(self.__dict__.keys())
 
     def has(self, key):
-        return key in self
+        return key in self.attr or key in self.data
 
-    def set(self, key, val):
-        self[key] = val
+    def set(self, key, value):
+        if key in self.attr:
+            self.__dict__[key] = value
+        else:
+            self.data[key] = value
+        return self
 
     def copy(self, deep=False):
-        if not deep:
-            d = dict(**self.__dict__)
+        ind = copy.copy(self)
+        ind.data = copy.copy(self.data) if not deep else copy.deepcopy(self.data)
+        return ind
+
+    def get(self, *keys):
+
+        def _get(key):
+            if key in self.data:
+                return self.data[key]
+            elif key in self.attr:
+                return self.__dict__[key]
+            else:
+                return None
+
+        ret = []
+
+        for key in keys:
+            ret.append(_get(key))
+
+        if len(ret) == 1:
+            return ret[0]
         else:
-            d = copy.deepcopy(**self.__dict__)
+            return tuple(ret)
 
-        ind = Individual(**d)
-        return ind
+
+class eIndividual:
+
+    def __init__(self, **kwargs) -> None:
+        kwargs = {**kwargs, **dict(X=None, F=None, CV=None, G=None, feasible=None)}
+        for k, v in kwargs.items():
+            self.__dict__[k] = v
+
+    def has(self, key):
+        return key in self.__dict__
+
+    def set(self, key, val):
+        self.__dict__[key] = val
 
     def get(self, *keys):
         if len(keys) == 1:
-            key, = keys
-            return super().get(key)
+            return self.__dict__.get(keys[0])
+        else:
+            return tuple([self.__dict__.get(key) for key in keys])
+
+    def copy(self, deep=False):
+        ind = copy.copy(self)
+        ind.data = copy.copy(self.__dict__) if not deep else copy.deepcopy(self.__dict__)
+        return ind
+
+
+        if not deep:
+            d = dict(self.__dict__)
         else:
-            return tuple([super().get(key) for key in keys])
+            d = copy.deepcopy(self.__dict__)
+        ind = Individual(**d)
+        return ind
+
+    # @property
+    # def F(self):
+    #     attr = "F"
+    #     if attr in self.__dict__:
+    #         return self.__dict__[attr]
+    #     else:
+    #         return None
+
+    # Gets called when the item is not found via __getattribute__
+    # def __getattr__(self, item):
+    #     return super(Individual, self).__setattr__(item, 'orphan')
+
+    def __getattr__(self, val):
+        return self.__dict__.get(val)
+
+    # def __setitem__(self, key, value):
+    #     self.__dict__[key] = value
+    #
+    # def __getitem__(self, key):
+    #     return self.__dict__.get(key)
+
+    # def __getattr__(self, attr):
+    #
+    #     if attr == "F":
+    #         if attr in self.__dict__:
+    #             return self.__dict__[attr]
+    #         else:
+    #             return None
+    #
+    #     if attr in self.__dict__:
+    #         return self.__dict__[attr]
+    #
+    #
+    #
+    def __setattr__(self, key, value):
+        self.__dict__[key] = value

pymoo/model/initialization.py

@@ -1,7 +1,6 @@
 import numpy as np
 
 from pymoo.model.duplicate import NoDuplicateElimination
-from pymoo.model.individual import Individual
 from pymoo.model.population import Population
 from pymoo.model.repair import NoRepair
 
@@ -10,13 +9,11 @@ class Initialization:
 
     def __init__(self,
                  sampling,
-                 individual=Individual(),
                  repair=None,
                  eliminate_duplicates=None) -> None:
 
         super().__init__()
         self.sampling = sampling
-        self.individual = individual
         self.eliminate_duplicates = eliminate_duplicates if eliminate_duplicates is not None else NoDuplicateElimination()
         self.repair = repair if repair is not None else NoRepair()
 
@@ -27,11 +24,10 @@ def do(self, problem, n_samples, **kwargs):
             pop = self.sampling
 
         else:
-            pop = Population(0, individual=self.individual)
             if isinstance(self.sampling, np.ndarray):
-                pop = pop.new("X", self.sampling)
+                pop = Population.new(X=self.sampling)
             else:
-                pop = self.sampling.do(problem, n_samples, pop=pop, **kwargs)
+                pop = self.sampling.do(problem, n_samples, **kwargs)
 
         # repair all solutions that are not already evaluated
         not_eval_yet = [k for k in range(len(pop)) if pop[k].F is None]