Added rules

Author: Tanguy Damart

bluepyopt/deapext/algorithms.py

@@ -109,7 +109,11 @@ def eaAlphaMuPlusLambdaCheckpoint(
         cp_filename(string): path to checkpoint filename
         continue_cp(bool): whether to continue
     """
+<<<<<<< HEAD
 
+=======
+    
+>>>>>>> 7e9c3ea (Added rules)
     if cp_filename:
         cp_filename_tmp = cp_filename + '.tmp'
 
@@ -140,6 +144,7 @@ def eaAlphaMuPlusLambdaCheckpoint(
         history = deap.tools.History()
 
         invalid_count = _evaluate_invalid_fitness(toolbox, population)
+        
         utils.update_history_and_hof(halloffame, history, population)
         utils.record_stats(stats,
                            logbook,
@@ -148,7 +153,7 @@ def eaAlphaMuPlusLambdaCheckpoint(
                            invalid_count)
 
     stopping_criteria = [MaxNGen(ngen)]
-
+        
     # Begin the generational process
     gen = start_gen + 1
     stopping_params = {"gen": gen}
@@ -160,7 +165,7 @@ def eaAlphaMuPlusLambdaCheckpoint(
         invalid_count = _evaluate_invalid_fitness(toolbox, offspring)
         utils.update_history_and_hof(halloffame, history, population)
         utils.record_stats(stats, logbook, gen, population, invalid_count)
-
+        
         # Select the next generation parents
         parents = toolbox.select(population, mu)
 

bluepyopt/ephys/__init__.py

@@ -37,6 +37,7 @@
 from . import recordings  # NOQA
 from . import objectivescalculators  # NOQA
 from . import stimuli  # NOQA
+from . import rules  # NOQA
 
 # TODO create all the necessary abstract methods
 # TODO check inheritance structure

bluepyopt/ephys/evaluators.py

@@ -116,8 +116,8 @@ def objective_dict(self, objective_array):
     def objective_list(self, objective_dict):
         """Convert objective_dict in objective_list"""
         objective_list = []
-        objective_names = [objective.name
-                           for objective in self.fitness_calculator.objectives]
+        objective_names = [objective.name for objective in self.fitness_calculator.objectives]
+        
         for objective_name in objective_names:
             objective_list.append(objective_dict[objective_name])
 

bluepyopt/ephys/objectives.py

@@ -127,3 +127,52 @@ def calculate_score(self, responses):
             score += weight * feature_score
 
         return score
+
+
+class RuleObjective(bluepyopt.objectives.Objective):
+
+    """Multi rules objective"""
+
+    def __init__(self, name, rules=None):
+        """Constructor
+        Args:
+            name (str): name of this object
+            rules (list): rule used in the Objective
+        """
+
+        super(RuleObjective, self).__init__(name)
+        self.name = name
+        self.rules = rules
+
+    def calculate_scores(self, cell_model):
+        """Calculate the scores for the individual rules"""
+
+        scores = []
+        for rule in self.rules:
+            scores.append(rule.calculate_score(cell_model))
+
+        return scores
+
+
+class SingletonRuleObjective(RuleObjective):
+
+    """Single rule objective"""
+
+    def __init__(self, name, rule):
+        """Constructor
+        Args:
+            name (str): name of this object
+            rule (EFeature): single rule inside this objective
+        """
+
+        super(SingletonRuleObjective, self).__init__(name, [rule])
+
+    def calculate_score(self, cell_model):
+        """Objective score"""
+
+        return self.calculate_scores(cell_model)[0]
+
+    def __str__(self):
+        """String representation"""
+
+        return '( %s )' % self.rule[0]

bluepyopt/ephys/objectivescalculators.py

@@ -19,6 +19,7 @@
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 """
 
+from . import objectives
 
 class ObjectivesCalculator(object):
 
@@ -35,11 +36,25 @@ def __init__(
 
         self.objectives = objectives
 
-    def calculate_scores(self, responses):
+    def calculate_scores(self, responses, cell_model, param_dict):
         """Calculator the score for every objective"""
-
-        return {objective.name: objective.calculate_score(responses)
-                for objective in self.objectives}
+        
+        scores = {}
+        
+        cell_model.freeze(param_dict)
+        
+        for objective in self.objectives:
+            
+            if issubclass(type(objective), objectives.EFeatureObjective):
+                scores[objective.name] = objective.calculate_score(responses)
+            elif issubclass(type(objective), objectives.RuleObjective):
+                scores[objective.name] = objective.calculate_score(cell_model)
+            else:
+                raise Exception('Unknown objective class: {}'.format(type(objective)))
+
+        cell_model.unfreeze(param_dict.keys())
+        
+        return scores
 
     def calculate_values(self, responses):
         """Calculator the value of each objective"""
@@ -48,6 +63,7 @@ def calculate_values(self, responses):
                 for objective in self.objectives}
 
     def __str__(self):
+        
         return 'objectives:\n  %s' % '\n  '.join(
             [str(obj) for obj in self.objectives]) \
             if self.objectives is not None else 'objectives:\n'

bluepyopt/ephys/rules.py

@@ -0,0 +1,151 @@
+"""Rules classes"""
+
+"""
+Copyright (c) 2016-2020, EPFL/Blue Brain Project
+
+ This file is part of BluePyOpt <https://github.com/BlueBrain/BluePyOpt>
+
+ This library is free software; you can redistribute it and/or modify it under
+ the terms of the GNU Lesser General Public License version 3.0 as published
+ by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+ details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this library; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+"""
+import logging
+
+import bluepyopt
+import math
+
+logger = logging.getLogger(__name__)
+
+
+def sigmoid(x):
+    """Sigmoid function"""
+    return 1 / (1 + math.exp(-x))
+
+
+class Rule():
+    
+    """Abstract Rule class"""
+    
+    name = ""
+
+    def __init__(
+        self,
+        name=None,
+        force_max_score=False,
+        max_score=250
+    ):
+        """Constructor
+        Args:
+            name (str): name of the eFELFeature object
+            force_max_score (bool): should the max_score limit be applied to
+                the score
+            max_score (float): upper bound for the score
+        """
+        
+        if name:
+            self.name = name
+
+        self.force_max_score = force_max_score
+        self.max_score = max_score
+    
+    def _rule(self, cell_model):
+        return None
+    
+    def _loss_function(self, value):
+        return None
+    
+    def calculate_value(self, cell_model):
+        """Calculate rule value"""
+
+        if cell_model is None:
+            rule_value = None
+        else:
+            rule_value = self._rule(cell_model)
+
+        logger.debug(
+            'Calculated value for %s: %s',
+            self.name,
+            str(rule_value)
+        )
+
+        return rule_value
+
+    def calculate_score(self, cell_model):
+        """Calculate the score"""
+
+        if cell_model is None:
+            score =  self.max_score
+        else:
+            score = self._loss_function(self._rule(cell_model))
+
+        if self.force_max_score:
+            score = min(score, self.max_score)
+
+        logger.debug('Calculated score for %s: %f', self.name, score)
+
+        return score
+
+    def __str__(self):
+        """String representation"""
+
+        return "Rule %s " % (self.name)
+
+ 
+class SumConductivityRule(Rule):
+
+    """SumConductivityRule class
+
+       Punish high sum of conductivity based on a sigmoid loss function
+    """
+
+    name = "SumConductivity"
+
+    def __init__(
+        self,
+        name=None,
+        force_max_score=False,
+        max_score=250,
+        conductivity_target=2.
+    ):
+        """Constructor
+        Args:
+            name (str): name of the eFELFeature object
+            force_max_score (bool): should the max_score limit be applied to
+                the score
+            max_score (float): upper bound for the score
+        """
+
+        super(SumConductivityRule, self).__init__(
+            name=name,
+            force_max_score=force_max_score,
+            max_score=max_score
+        )
+        
+        self.conductivity_target = conductivity_target
+        
+    def _rule(self, cell_model):
+
+        sum_g = 0
+        for param in cell_model.params.values():
+            if param.name[0] == "g":
+                sum_g += param.value
+
+        return sum_g
+
+    def _loss_function(self, value):
+
+        # Center on conductivity_target
+        _ = (value / self.conductivity_target) - 1.
+        
+        # Take the sigmoid
+        return self.max_score * sigmoid(_)
+