Syntax fixes

Author: Tanguy Damart

bluepyopt/__init__.py

@@ -33,6 +33,7 @@
 import bluepyopt.stoppingCriteria
 import bluepyopt.deapext.optimisations
 import bluepyopt.deapext.optimisationsCMA
+import bluepyopt.deapext.hype
 
 # Add some backward compatibility for the time when DEAPoptimisation not in
 # deapext yet

bluepyopt/deapext/CMA_MO.py

@@ -1,7 +1,7 @@
 """Multi Objective CMA-es class"""
 
 """
-Copyright (c) 2016, EPFL/Blue Brain Project
+Copyright (c) 2016-2020, EPFL/Blue Brain Project
 
  This file is part of BluePyOpt <https://github.com/BlueBrain/BluePyOpt>
 
@@ -34,13 +34,13 @@
 from . import utils
 from . import hype
 
-logger = logging.getLogger('__main__')
+logger = logging.getLogger("__main__")
 
 
 def get_hyped(pop):
     # Cap the obj at 250
     points = numpy.array([ind.fitness.values for ind in pop])
-    points[points > 250.] = 250.
+    points[points > 250.0] = 250.0
     lbounds = numpy.min(points, axis=0)
     ubounds = numpy.max(points, axis=0)
 
@@ -55,28 +55,29 @@ def get_hyped(pop):
 
     # Rescale the objective space
     points = (points - lbounds) / numpy.max(ubounds.flatten())
-    ubounds = numpy.max(points, axis=0) + 2.
+    ubounds = numpy.max(points, axis=0) + 2.0
 
-    hv = hype.hypeIndicatorSampled(points=points,
-                                   bounds=ubounds,
-                                   k=5,
-                                   nrOfSamples=200000)
+    hv = hype.hypeIndicatorSampled(
+        points=points, bounds=ubounds, k=5, nrOfSamples=200000
+    )
     return hv
 
 
 class CMA_MO(cma.StrategyMultiObjective):
     """Multiple objective covariance matrix adaption"""
 
-    def __init__(self,
-                 centroids,
-                 offspring_size,
-                 sigma,
-                 max_ngen,
-                 IndCreator,
-                 RandIndCreator,
-                 weight_hv=0.5,
-                 map_function=None,
-                 use_scoop=False):
+    def __init__(
+        self,
+        centroids,
+        offspring_size,
+        sigma,
+        max_ngen,
+        IndCreator,
+        RandIndCreator,
+        weight_hv=0.5,
+        map_function=None,
+        use_scoop=False,
+    ):
         """Constructor
 
         Args:
@@ -85,8 +86,8 @@ def __init__(self,
             sigma (float): initial standard deviation of the distribution
             max_ngen (int): total number of generation to run
             IndCreator (fcn): function returning an individual of the pop
-            weight_hv (float): between 0 and 1. Weight given to the 
-                hypervolume contribution when computing the score of an 
+            weight_hv (float): between 0 and 1. Weight given to the
+                hypervolume contribution when computing the score of an
                 individual in MO-CMA. The weight of the fitness contribution
                 is computed as 1 - weight_hv.
         """
@@ -101,18 +102,19 @@ def __init__(self,
         else:
             if len(centroids) != lambda_:
                 from itertools import cycle
+
                 generator = cycle(centroids)
                 starters = [next(generator) for i in range(lambda_)]
             else:
                 starters = centroids
 
-        cma.StrategyMultiObjective.__init__(self, starters, sigma,
-                                            mu=int(lambda_ * 0.5),
-                                            lambda_=lambda_)
+        cma.StrategyMultiObjective.__init__(
+            self, starters, sigma, mu=int(lambda_ * 0.5), lambda_=lambda_
+        )
 
         self.population = []
         self.problem_size = len(starters[0])
-        
+
         self.weight_hv = weight_hv
 
         self.map_function = map_function
@@ -126,16 +128,19 @@ def __init__(self,
         if self.use_scoop:
             if self.map_function:
                 raise Exception(
-                    'Impossible to use scoop is providing self defined map '
-                    'function: %s' % self.map_function)
+                    "Impossible to use scoop is providing self defined map "
+                    "function: %s" % self.map_function
+                )
             from scoop import futures
+
             self.map_function = futures.map
 
         # Set termination conditions
         self.active = True
         if max_ngen <= 0:
             max_ngen = 100 + 50 * (self.problem_size + 3) ** 2 / numpy.sqrt(
-                self.lambda_)
+                self.lambda_
+            )
 
         self.stopping_conditions = [MaxNGen(max_ngen)]
 
@@ -146,29 +151,30 @@ def _select(self, candidates):
         absolute fitness and hyper-volume contribution.
         """
 
-        if self.weight_hv == 0.: 
+        if self.weight_hv == 0.0:
             fit = [numpy.sum(ind.fitness.values) for ind in candidates]
             idx_fit = list(numpy.argsort(fit))
             idx_scores = idx_fit[:]
 
-        elif self.weight_hv == 1.:
+        elif self.weight_hv == 1.0:
             hv = get_hyped(candidates)
-            idx_hv = list(numpy.argsort(hv))[::-1] 
-            idx_scores = idx_hv[:] 
+            idx_hv = list(numpy.argsort(hv))[::-1]
+            idx_scores = idx_hv[:]
 
         else:
             hv = get_hyped(candidates)
-            idx_hv = list(numpy.argsort(hv))[::-1] 
+            idx_hv = list(numpy.argsort(hv))[::-1]
             fit = [numpy.sum(ind.fitness.values) for ind in candidates]
             idx_fit = list(numpy.argsort(fit))
             scores = []
             for i in range(len(candidates)):
-                score = (self.weight_hv * idx_hv.index(i)) + \
-                        ((1.-self.weight_hv) * idx_fit.index(i))
+                score = (self.weight_hv * idx_hv.index(i)) + (
+                    (1.0 - self.weight_hv) * idx_fit.index(i)
+                )
                 scores.append(score)
             idx_scores = list(numpy.argsort(scores))
 
-        chosen = [candidates[i] for i in idx_scores[:self.mu]]
+        chosen = [candidates[i] for i in idx_scores[: self.mu]]
         not_chosen = [candidates[i] for i in idx_scores[self.mu:]]
         return chosen, not_chosen
 
@@ -213,6 +219,8 @@ def check_termination(self, gen):
         [c.check(stopping_params) for c in self.stopping_conditions]
         for c in self.stopping_conditions:
             if c.criteria_met:
-                logger.info('CMA stopped because of termination criteria: ' +
-                            ' '.join(c.name))
+                logger.info(
+                    "CMA stopped because of termination criteria: " +
+                    "" + " ".join(c.name)
+                )
                 self.active = False

bluepyopt/deapext/CMA_SO.py

@@ -1,7 +1,7 @@
 """Single Objective CMA-es class"""
 
 """
-Copyright (c) 2016, EPFL/Blue Brain Project
+Copyright (c) 2016-2020, EPFL/Blue Brain Project
 
  This file is part of BluePyOpt <https://github.com/BlueBrain/BluePyOpt>
 
@@ -29,26 +29,37 @@
 from deap import base
 from deap import cma
 
-from .stoppingCriteria import MaxNGen, Stagnation, TolHistFun, EqualFunVals, \
-    NoEffectAxis, TolUpSigma, TolX, ConditionCov, NoEffectCoor
+from .stoppingCriteria import (
+    MaxNGen,
+    Stagnation,
+    TolHistFun,
+    EqualFunVals,
+    NoEffectAxis,
+    TolUpSigma,
+    TolX,
+    ConditionCov,
+    NoEffectCoor,
+)
 
 from . import utils
 
-logger = logging.getLogger('__main__')
+logger = logging.getLogger("__main__")
 
 
 class CMA_SO(cma.Strategy):
     """Single objective covariance matrix adaption"""
 
-    def __init__(self,
-                 centroids,
-                 offspring_size,
-                 sigma,
-                 max_ngen,
-                 IndCreator,
-                 RandIndCreator,
-                 map_function=None,
-                 use_scoop=False):
+    def __init__(
+        self,
+        centroids,
+        offspring_size,
+        sigma,
+        max_ngen,
+        IndCreator,
+        RandIndCreator,
+        map_function=None,
+        use_scoop=False,
+    ):
         """Constructor
 
         Args:
@@ -86,7 +97,8 @@ def __init__(self,
         self.active = True
         if max_ngen <= 0:
             max_ngen = 100 + 50 * (self.problem_size + 3) ** 2 / numpy.sqrt(
-                self.lambda_)
+                self.lambda_
+            )
 
         self.stopping_conditions = [
             MaxNGen(max_ngen),
@@ -97,7 +109,7 @@ def __init__(self,
             TolUpSigma(float(self.sigma)),
             TolX(),
             ConditionCov(),
-            NoEffectCoor()
+            NoEffectCoor(),
         ]
 
     def update(self, population):
@@ -113,29 +125,47 @@ def update(self, population):
         c_diff = self.centroid - old_centroid
 
         # Cumulation : update evolution path
-        self.ps = (1 - self.cs) * self.ps + sqrt(self.cs * (2 - self.cs) *
-                   self.mueff) / self.sigma * numpy.dot(self.B, (1. /
-                   self.diagD) * numpy.dot(self.B.T, c_diff))  # noqa
-
-        hsig = float((numpy.linalg.norm(self.ps) / sqrt(1. - (1. - self.cs)
-                     ** (2. * (self.update_count + 1.))) / self.chiN <
-                      (1.4 + 2. / (self.dim + 1.))))  # noqa
+        self.ps = (1 - self.cs) * self.ps + sqrt(
+            self.cs * (2 - self.cs) * self.mueff
+        ) / self.sigma * numpy.dot(
+            self.B, (1.0 / self.diagD) * numpy.dot(self.B.T, c_diff)
+        )  # noqa
+
+        hsig = float(
+            (
+                numpy.linalg.norm(self.ps)
+                / sqrt(1.0 - (1.0 - self.cs) **
+                    (2.0 * (self.update_count + 1.0)))
+                / self.chiN
+                < (1.4 + 2.0 / (self.dim + 1.0))
+            )
+        )
 
         self.update_count += 1
 
-        self.pc = (1 - self.cc) * self.pc + hsig * sqrt(self.cc * (2 - self.cc)
-                  * self.mueff) / self.sigma * c_diff  # noqa
+        self.pc = (1 - self.cc) * self.pc + hsig * sqrt(
+            self.cc * (2 - self.cc) * self.mueff
+        ) / self.sigma * c_diff
 
         # Update covariance matrix
         artmp = population[0:self.mu] - old_centroid
-        self.C = (1 - self.ccov1 - self.ccovmu + (1 - hsig) *
-                  self.ccov1 * self.cc * (2 - self.cc)) * self.C \
-                 + self.ccov1 * numpy.outer(self.pc, self.pc) \
-                 + self.ccovmu * numpy.dot((self.weights * artmp.T), artmp) \
-                 / self.sigma ** 2  # noqa
-
-        self.sigma *= numpy.exp((numpy.linalg.norm(self.ps) / self.chiN - 1.) *
-                                self.cs / self.damps)  # noqa
+        self.C = (
+            (
+                1
+                - self.ccov1
+                - self.ccovmu
+                + (1 - hsig) * self.ccov1 * self.cc * (2 - self.cc)
+            )
+            * self.C
+            + self.ccov1 * numpy.outer(self.pc, self.pc)
+            + self.ccovmu * numpy.dot((self.weights * artmp.T), artmp)
+            / self.sigma ** 2
+        )
+
+        self.sigma *= numpy.exp(
+            (numpy.linalg.norm(self.ps) / self.chiN - 1.0) * self.cs
+            / self.damps
+        )
 
         self.diagD, self.B = numpy.linalg.eigh(self.C)
         indx = numpy.argsort(self.diagD)
@@ -182,6 +212,8 @@ def check_termination(self, gen):
         [c.check(stopping_params) for c in self.stopping_conditions]
         for c in self.stopping_conditions:
             if c.criteria_met:
-                logger.info('CMA stopped because of termination criteria: ' +
-                            ' '.join(c.name))
+                logger.info(
+                    "CMA stopped because of termination criteria: " +
+                    "" + " ".join(c.name)
+                )
                 self.active = False