Syntax

Author: damart

bluepyopt/deapext/CMA_SO.py

@@ -19,6 +19,8 @@
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 """
 
+# pylint: disable=R0912, R0914
+
 import logging
 import numpy
 from math import sqrt, log
@@ -110,32 +112,29 @@ 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))
+        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.))))
+        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.update_count += 1
 
-        self.pc = (1 - self.cc) * self.pc + hsig \
-                  * sqrt(self.cc * (2 - self.cc) * self.mueff) / self.sigma \
-                  * c_diff
+        self.pc = (1 - self.cc) * self.pc + hsig * sqrt(self.cc * (2 - self.cc)
+                  * self.mueff) / self.sigma * c_diff  # noqa
 
         # 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
+                 / self.sigma ** 2  # noqa
 
         self.sigma *= numpy.exp((numpy.linalg.norm(self.ps) / self.chiN - 1.) *
-                                self.cs / self.damps)
+                                self.cs / self.damps)  # noqa
 
         self.diagD, self.B = numpy.linalg.eigh(self.C)
         indx = numpy.argsort(self.diagD)

bluepyopt/deapext/algorithms.py

@@ -141,7 +141,11 @@ def eaAlphaMuPlusLambdaCheckpoint(
 
         invalid_count = _evaluate_invalid_fitness(toolbox, population)
         utils.update_history_and_hof(halloffame, history, population)
-        utils.record_stats(stats, logbook, start_gen, population, invalid_count)
+        utils.record_stats(stats,
+                           logbook,
+                           start_gen,
+                           population,
+                           invalid_count)
 
     stopping_criteria = [MaxNGen(ngen)]
 

bluepyopt/deapext/optimisations.py

@@ -171,7 +171,8 @@ def setup_deap(self):
             UPPER.append(parameter.upper_bound)
 
         # Register the 'uniform' function
-        self.toolbox.register("uniformparams", utils.uniform, LOWER, UPPER, IND_SIZE)
+        self.toolbox.register("uniformparams", utils.uniform, LOWER, UPPER,
+                              IND_SIZE)
 
         # Register the individual format
         # An indiviual is create by WSListIndividual and parameters

bluepyopt/deapext/optimisationsCMA.py

@@ -88,7 +88,6 @@ def _ind_convert_space(ind, convert_fcn):
 
 
 class DEAPOptimisationCMA(bluepyopt.optimisations.Optimisation):
-
     """CMA based optimisation class"""
 
     def __init__(self,
@@ -140,8 +139,8 @@ def __init__(self,
         elif self.selector_name == 'multi_objective':
             self.cma_creator = CMA_MO
         else:
-            raise Exception("The selector_name has to be 'single_objective' or "
-                            "'multi_objective'. Not "
+            raise Exception("The selector_name has to be 'single_objective' "
+                            "or 'multi_objective'. Not "
                             "{}".format(self.selector_name))
 
         # Number of objective values
@@ -167,21 +166,22 @@ def __init__(self,
         self.to_space = []
         for r, m in zip(bounds_radius, bounds_mean):
             self.to_norm.append(
-                functools.partial(lambda param, bm, br: (param - bm) / br, bm=m, br=r))
+                functools.partial(lambda param, bm, br: (param - bm) / br,
+                                  bm=m, br=r))
             self.to_space.append(
-                functools.partial(lambda param, bm, br: (param * br) + bm, bm=m, br=r))
+                functools.partial(lambda param, bm, br: (param * br) + bm,
+                                  bm=m, br=r))
 
         # Overwrite the bounds with -1. and 1.
         self.lbounds = numpy.full(self.problem_size, -1.)
         self.ubounds = numpy.full(self.problem_size, 1.)
-        
+
         self.setup_deap()
 
         # In case initial guesses were provided, rescale them to the norm space
         if self.centroids is not None:
-            self.centroids = [self.toolbox.Individual(_ind_convert_space(ind,
-                                                                         self.to_norm))
-                              for ind in centroids]
+            self.centroids = [self.toolbox.Individual(
+                _ind_convert_space(ind, self.to_norm)) for ind in centroids]
 
     def setup_deap(self):
         """Set up optimisation"""
@@ -191,8 +191,8 @@ def setup_deap(self):
         numpy.random.seed(self.seed)
 
         # Register the 'uniform' function
-        self.toolbox.register("uniformparams", 
-                              utils.uniform, 
+        self.toolbox.register("uniformparams",
+                              utils.uniform,
                               self.lbounds,
                               self.ubounds,
                               self.ind_size)
@@ -224,7 +224,7 @@ def setup_deap(self):
 
         # Register the evaluation function for the individuals
         self.toolbox.register("evaluate", self.evaluator.evaluate_with_lists)
-        
+
         import copyreg
         import types
         copyreg.pickle(types.MethodType, utils.reduce_method)
@@ -268,7 +268,7 @@ def run(self,
             numpy.random.set_state(cp["np_rndstate"])
             CMA_es = cp["CMA_es"]
             CMA_es.map_function = self.map_function
-            
+
         else:
             history = deap.tools.History()
             logbook = deap.tools.Logbook()
@@ -291,7 +291,7 @@ def run(self,
                 CMA_es.set_fitness_parents(fitness)
 
             gen = 1
-        
+
         # Run until a termination criteria is met
         while CMA_es.active:
             logger.info("Generation {}".format(gen))
@@ -338,9 +338,8 @@ def run(self,
                 CMA_es.map_function = temp_mf
 
             gen += 1
-            
-        return pop, self.hof, logbook, history
 
+        return pop, self.hof, logbook, history
 
     def get_stats(self):
         """Get the stats that will be saved during optimisation"""

bluepyopt/deapext/stoppingCriteria.py

@@ -26,8 +26,9 @@
 
 logger = logging.getLogger('__main__')
 
+
 def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
-        return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
+    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
 
 
 class MaxNGen(bluepyopt.stoppingCriteria.StoppingCriteria):
@@ -73,12 +74,13 @@ def check(self, kwargs):
         self.stagnation_iter = int(numpy.ceil(
             0.2 * ngen + 120 + 30. * self.problem_size / self.lambda_))
 
-        if len(self.best) > self.stagnation_iter and \
-                len(self.median) > self.stagnation_iter and \
-                numpy.median(self.best[-20:]) >= numpy.median(
-            self.best[-self.stagnation_iter:-self.stagnation_iter + 20]) and \
-                numpy.median(self.median[-20:]) >= numpy.median(
-            self.median[-self.stagnation_iter:-self.stagnation_iter + 20]):
+        cbest = len(self.best) > self.stagnation_iter
+        cmed = len(self.median) > self.stagnation_iter
+        cbest2 = numpy.median(self.best[-20:]) >= numpy.median(
+            self.best[-self.stagnation_iter:-self.stagnation_iter + 20])
+        cmed2 = numpy.median(self.median[-20:]) >= numpy.median(
+            self.median[-self.stagnation_iter:-self.stagnation_iter + 20])
+        if cbest and cmed and cbest2 and cmed2:
             self.criteria_met = True
 
 

bluepyopt/tests/test_CMA/test_optimisationsCMA.py

@@ -16,26 +16,22 @@ def test_optimisationsCMA_normspace():
     optimisation = bluepyopt.deapext.optimisationsCMA.DEAPOptimisationCMA(
         evaluator=evaluator)
 
-    x = [n*0.1 for n in range(len(evaluator.params))]
-    y = [f2(f1(_)) for _,f1,f2 in zip(x, optimisation.to_norm,
-                                      optimisation.to_space)]
+    x = [n * 0.1 for n in range(len(evaluator.params))]
+    y = [f2(f1(_)) for _, f1, f2 in zip(x, optimisation.to_norm,
+                                        optimisation.to_space)]
     for a, b in zip(x, y):
         nt.assert_almost_equal(a, b)
 
+
 @attr('unit')
 def test_optimisationsCMA_run():
     "deapext.optimisationsCMA: Testing optimisationsCMA run from centroid"
 
     evaluator = examples.simplecell.cell_evaluator
     x = [n * 0.1 for n in range(len(evaluator.params))]
 
-    try:
-        optimisation = bluepyopt.deapext.optimisationsCMA.DEAPOptimisationCMA(
-                                                            evaluator=evaluator,
-                                                            centroids=[x])
-        pop, hof, log, hist = optimisation.run(max_ngen=2)
-        raised = False
-    except:
-        raised = True
-
+    optimiser = bluepyopt.deapext.optimisationsCMA.DEAPOptimisationCMA
+    optimisation = optimiser(evaluator=evaluator, centroids=[x])
+    pop, hof, log, hist = optimisation.run(max_ngen=2)
+    raised = False
     nt.assert_equal(raised, False)