Reorganization and syntax fixes

Author: damart

bluepyopt/deapext/CMA_MO.py

@@ -133,12 +133,13 @@ def __init__(self,
         self.stopping_conditions = [MaxNGen(max_ngen)]
 
     def hyper_volume(self, front):
-
+        """Compute the hypervolume contribution of each individual"""
         wobj = numpy.array([ind.fitness.values for ind in front])
         obj_ranges = (numpy.max(wobj, axis=0) - numpy.min(wobj, axis=0))
         ref = numpy.max(wobj, axis=0) + 1
 
-        # Above 23 dim, hypervolume is too slow, so I settle for an approximation
+        # Above 23 dimension, the hypervolume computation is too slow,
+        # we settle for the 23 dimension showing the largest range of values
         max_ndim = 23
         if len(ref) > max_ndim:
             idxs = list(range(len(ref)))
@@ -148,15 +149,21 @@ def hyper_volume(self, front):
             wobj = wobj[:, idxs]
             ref = ref[idxs]
 
-        to_evaluate = []
+        # Prepare the data and send it to multiprocess
         for i in range(len(front)):
             to_evaluate.append([i, numpy.copy(wobj), numpy.copy(ref)])
-
         contrib_values = self.toolbox.map(contribution, to_evaluate)
 
         return list(contrib_values)
 
     def _select(self, candidates):
+        """Select the best candidates of the population
+
+        Fill the next population (chosen) with the Pareto fronts until there is
+        not enouch space. When an entire front does not fit in the space left
+        we rely on the hypervolume for this front. The remaining fronts are
+        explicitly not chosen"""
+
         if len(candidates) <= self.mu:
             return candidates, []
 
@@ -167,10 +174,6 @@ def _select(self, candidates):
         mid_front = None
         not_chosen = list()
 
-        # Fill the next population (chosen) with the fronts until there is not enouch space
-        # When an entire front does not fit in the space left we rely on the hypervolume
-        # for this front
-        # The remaining fronts are explicitly not chosen
         full = False
         for front in pareto_fronts:
             if len(chosen) + len(front) <= self.mu and not full:
@@ -182,6 +185,8 @@ def _select(self, candidates):
             else:
                 not_chosen += front
 
+        # Hypervolume contribution to get the best candidates on the remaining
+        # front
         k = self.mu - len(chosen)
         if k > 0:
             hyperv = self.hyper_volume(mid_front)

bluepyopt/deapext/CMA_SO.py

@@ -104,7 +104,8 @@ def update(self, population):
         """Update the current covariance matrix strategy from the
         population"""
 
-        population.sort(key=lambda ind: ind.fitness.reduce_weight, reverse=True)
+        population.sort(key=lambda ind: ind.fitness.reduce_weight,
+                        reverse=True)
 
         old_centroid = self.centroid
         self.centroid = numpy.dot(self.weights, population[0:self.mu])

bluepyopt/deapext/optimisations.py

@@ -44,51 +44,6 @@
 # settings of the algorithm can be stored in objects of these classes
 
 
-class WeightedSumFitness(deap.base.Fitness):
-
-    """Fitness that compares by weighted sum"""
-
-    def __init__(self, values=(), obj_size=None):
-        self.weights = [-1.0] * obj_size if obj_size is not None else [-1]
-
-        super(WeightedSumFitness, self).__init__(values)
-
-    @property
-    def weighted_sum(self):
-        """Weighted sum of wvalues"""
-        return sum(self.wvalues)
-
-    @property
-    def sum(self):
-        """Weighted sum of values"""
-        return sum(self.values)
-
-    def __le__(self, other):
-        return self.weighted_sum <= other.weighted_sum
-
-    def __lt__(self, other):
-        return self.weighted_sum < other.weighted_sum
-
-    def __deepcopy__(self, _):
-        """Override deepcopy"""
-
-        cls = self.__class__
-        result = cls.__new__(cls)
-        result.__dict__.update(self.__dict__)
-        return result
-
-
-class WSListIndividual(list):
-
-    """Individual consisting of list with weighted sum field"""
-
-    def __init__(self, *args, **kwargs):
-        """Constructor"""
-        self.fitness = WeightedSumFitness(obj_size=kwargs['obj_size'])
-        del kwargs['obj_size']
-        super(WSListIndividual, self).__init__(*args, **kwargs)
-
-
 class DEAPOptimisation(bluepyopt.optimisations.Optimisation):
 
     """DEAP Optimisation class"""
@@ -162,7 +117,6 @@ def setup_deap(self):
         IND_SIZE = len(self.evaluator.params)
 
         # Bounds for the parameters
-
         LOWER = []
         UPPER = []
 
@@ -181,7 +135,7 @@ def setup_deap(self):
         self.toolbox.register(
             "Individual",
             deap.tools.initIterate,
-            functools.partial(WSListIndividual, obj_size=OBJ_SIZE),
+            functools.partial(utils.WSListIndividual, obj_size=OBJ_SIZE),
             self.toolbox.uniformparams)
 
         # Register the population format. It is a list of individuals

bluepyopt/deapext/optimisationsCMA.py

@@ -36,59 +36,13 @@
 logger = logging.getLogger('__main__')
 
 
-class ReduceFitness(deap.base.Fitness):
-    """Fitness that compares by weighted"""
-
-    def __init__(self, values=(), obj_size=None, reduce_fcn=numpy.sum):
-        self.weights = [-1.0] * obj_size if obj_size is not None else [-1]
-        self.reduce_fcn = reduce_fcn
-        super(ReduceFitness, self).__init__(values)
-
-    @property
-    def reduce(self):
-        return self.reduce_fcn(self.values)
-
-    @property
-    def reduce_weight(self):
-        """Weighted reduce of wvalues"""
-        return self.reduce_fcn(self.wvalues)
-
-    def __le__(self, other):
-        return self.reduce_weight <= other.reduce_weight
-
-    def __lt__(self, other):
-        return self.reduce_weight < other.reduce_weight
-
-    def __deepcopy__(self, _):
-        """Override deepcopy"""
-
-        cls = self.__class__
-        result = cls.__new__(cls)
-        result.__dict__.update(self.__dict__)
-        return result
-
-
-class ListIndividual(list):
-    """Individual consisting of list with weighted fitness field"""
-
-    def __init__(self, *args, **kwargs):
-        """Constructor"""
-        self.fitness = ReduceFitness(obj_size=kwargs['obj_size'],
-                                     reduce_fcn=kwargs['reduce_fcn'])
-        del kwargs['obj_size']
-        del kwargs['reduce_fcn']
-        super(ListIndividual, self).__init__(*args, **kwargs)
-
-        # Used by CMA multi objective
-        self._ps = "p", 0
-
-
 def _ind_convert_space(ind, convert_fcn):
     return [f(x) for f, x in zip(convert_fcn, ind)]
 
 
 class DEAPOptimisationCMA(bluepyopt.optimisations.Optimisation):
-    """CMA based optimisation class"""
+
+    """Optimisation class for CMA-based evolution strategies"""
 
     def __init__(self,
                  evaluator=None,
@@ -105,10 +59,12 @@ def __init__(self,
 
         Args:
             evaluator (Evaluator): Evaluator object
+            seed (float): Random number generator seed
+            offspring_size (int): Number of offspring individuals in each
+                generation
             centroids (list): list of initial guesses used as the starting
                 points of the CMA-ES
             sigma (float): initial standard deviation of the distribution
-            seed (float): Random number generator seed
             map_function (function): Function used to map (parallelize) the
                 evaluation function calls
             hof (hof): Hall of Fame object
@@ -124,11 +80,12 @@ def __init__(self,
         self.use_scoop = use_scoop
         self.seed = seed
         self.map_function = map_function
+
         self.hof = hof
         if self.hof is None:
             self.hof = deap.tools.HallOfFame(10)
-        self.fitness_reduce = fitness_reduce
 
+        self.fitness_reduce = fitness_reduce
         self.offspring_size = offspring_size
         self.centroids = centroids
         self.sigma = sigma
@@ -162,6 +119,7 @@ def __init__(self,
         self.lbounds = numpy.asarray(self.lbounds)
         bounds_radius = (self.ubounds - self.lbounds) / 2.
         bounds_mean = (self.ubounds + self.lbounds) / 2.
+
         self.to_norm = []
         self.to_space = []
         for r, m in zip(bounds_radius, bounds_mean):
@@ -200,17 +158,17 @@ def setup_deap(self):
         # Register the individual format
         self.toolbox.register(
             "Individual",
-            functools.partial(ListIndividual,
+            functools.partial(utils.WSListIndividual,
                               obj_size=self.ind_size,
                               reduce_fcn=self.fitness_reduce)
         )
 
         # A Random Indiviual is create by ListIndividual and parameters are
         # initially picked by 'uniform'
         self.toolbox.register(
-            "RandomIndividual",
+            "RandomInd",
             deap.tools.initIterate,
-            functools.partial(ListIndividual,
+            functools.partial(WSListIndividual,
                               obj_size=self.ind_size,
                               reduce_fcn=self.fitness_reduce),
             self.toolbox.uniformparams)
@@ -220,7 +178,7 @@ def setup_deap(self):
             "population",
             deap.tools.initRepeat,
             list,
-            self.toolbox.RandomIndividual)
+            self.toolbox.RandomInd)
 
         # Register the evaluation function for the individuals
         self.toolbox.register("evaluate", self.evaluator.evaluate_with_lists)
@@ -251,13 +209,14 @@ def run(self,
         Args:
             max_ngen(int): Total number of generation to run
             cp_frequency(int): generations between checkpoints
-            cp_filename(string): path to checkpoint filename
             continue_cp(bool): whether to continue
+            cp_filename(string): path to checkpoint filename
         """
 
         stats = self.get_stats()
 
         if continue_cp:
+
             # A file name has been given, then load the data from the file
             cp = pickle.load(open(cp_filename, "br"))
             gen = cp["generation"]
@@ -270,17 +229,18 @@ def run(self,
             CMA_es.map_function = self.map_function
 
         else:
+
             history = deap.tools.History()
             logbook = deap.tools.Logbook()
             logbook.header = ["gen", "nevals"] + stats.fields
 
-            # Instantiate the CMA strategies centered on the centroids
+            # Instantiate the CMA strategy centered on the centroids
             CMA_es = self.cma_creator(centroids=self.centroids,
                                       offspring_size=self.offspring_size,
                                       sigma=self.sigma,
                                       max_ngen=max_ngen,
                                       IndCreator=self.toolbox.Individual,
-                                      RandIndCreator=self.toolbox.RandomIndividual,
+                                      RandIndCreator=self.toolbox.RandomInd,
                                       map_function=self.map_function,
                                       use_scoop=self.use_scoop)
 
@@ -299,8 +259,9 @@ def run(self,
             # Generate the new populations
             n_out = CMA_es.generate_new_pop(lbounds=self.lbounds,
                                             ubounds=self.ubounds)
-            logger.info("Number of individuals outside of bounds: {} ({:.2f}%)"
-                        "".format(n_out, 100. * n_out / len(CMA_es.population)))
+            logger.debug("Number of individuals outside of bounds: {} "
+                         "({:.2f}%)".format(n_out, 100. *
+                                            n_out / len(CMA_es.population)))
 
             # Get all the individuals in the original space for evaluation
             to_evaluate = CMA_es.get_population(self.to_space)
@@ -323,8 +284,11 @@ def run(self,
             CMA_es.check_termination(gen)
 
             if cp_filename and cp_frequency and gen % cp_frequency == 0:
+
+                # Map function shouldn't be pickled
                 temp_mf = CMA_es.map_function
                 CMA_es.map_function = None
+
                 cp = dict(population=pop,
                           generation=gen,
                           halloffame=self.hof,
@@ -335,6 +299,7 @@ def run(self,
                           CMA_es=CMA_es)
                 pickle.dump(cp, open(cp_filename, "wb"))
                 logger.debug('Wrote checkpoint to %s', cp_filename)
+
                 CMA_es.map_function = temp_mf
 
             gen += 1