Add feature computation functions to CellEvaluator, ObjectivesCalculator and Objectives

Author: Tanguy Damart

bluepyopt/ephys/evaluators.py

@@ -182,34 +182,44 @@ def run_protocols(self, protocols, param_values):
 
         return responses
 
-    def evaluate_with_dicts(self, param_dict=None):
+    def evaluate_with_dicts(self, param_dict=None, target='scores'):
         """Run evaluation with dict as input and output"""
-
+        
+        if target not in ['scores', 'values']:
+            raise Exception(
+                'CellEvaluator: target has to be "scores" or "values".')
+            
         if self.fitness_calculator is None:
             raise Exception(
                 'CellEvaluator: need fitness_calculator to evaluate')
 
         logger.debug('Evaluating %s', self.cell_model.name)
-
+    
         responses = self.run_protocols(
             self.fitness_protocols.values(),
             param_dict)
 
-        return self.fitness_calculator.calculate_scores(responses)
+        if target == 'scores':
+            return self.fitness_calculator.calculate_scores(responses)
+
+        elif target == 'values':
+            return self.fitness_calculator.calculate_values(responses)
 
-    def evaluate_with_lists(self, param_list=None):
+    def evaluate_with_lists(self, param_list=None, target='scores'):
         """Run evaluation with lists as input and outputs"""
 
         param_dict = self.param_dict(param_list)
 
-        obj_dict = self.evaluate_with_dicts(param_dict=param_dict)
+        obj_dict = self.evaluate_with_dicts(
+            param_dict=param_dict, target=target
+        )
 
         return self.objective_list(obj_dict)
 
-    def evaluate(self, param_list=None):
+    def evaluate(self, param_list=None, target='scores'):
         """Run evaluation with lists as input and outputs"""
 
-        return self.evaluate_with_lists(param_list)
+        return self.evaluate_with_lists(param_list, target=target)
 
     def __str__(self):
 

bluepyopt/ephys/objectives.py

@@ -47,6 +47,15 @@ def calculate_feature_scores(self, responses):
 
         return scores
 
+    def calculate_feature_values(self, responses):
+        """Calculate the value of an individual features"""
+
+        values = []
+        for feature in self.features:
+            values.append(feature.calculate_feature(responses))
+
+        return values
+
 
 class SingletonObjective(EFeatureObjective):
 
@@ -66,6 +75,11 @@ def calculate_score(self, responses):
         """Objective score"""
 
         return self.calculate_feature_scores(responses)[0]
+    
+    def calculate_value(self, responses):
+        """Objective value"""
+
+        return self.calculate_feature_values(responses)[0]
 
     def __str__(self):
         """String representation"""

bluepyopt/ephys/objectivescalculators.py

@@ -41,6 +41,12 @@ def calculate_scores(self, responses):
         return {objective.name: objective.calculate_score(responses)
                 for objective in self.objectives}
 
+    def calculate_values(self, responses):
+        """Calculator the value of each objective"""
+
+        return {objective.name: objective.calculate_value(responses)
+                for objective in self.objectives}
+
     def __str__(self):
         return 'objectives:\n  %s' % '\n  '.join(
             [str(obj) for obj in self.objectives]) \