added bsoid classifier wrapper

Author: JensBlack

experiments/custom/classifier.py

@@ -44,9 +44,9 @@ def get_win_len(self):
         return self._win_len
 
 
-class SiMBAClassifier():
+class SiMBAClassifier:
     """SiMBA base class for simple behavior classification trigger. Loads pretrained classifier, gets passed features
-    from FeatureExtractor. Returns probability of prediction that can be incorporated into triggers."""
+    from SimbaFeatureExtractor. Returns probability of prediction that can be incorporated into triggers."""
 
     def __init__(self):
         self._classifier = self.load_classifier(PATH_TO_CLASSIFIER)
@@ -68,11 +68,49 @@ def classify(self,features):
         self.last_result = probability
         return probability
 
-    def get_last_result(self,skeleton_window: list):
+    def get_last_result(self):
         """Returns predicted last prediction"""
         return self.last_result
 
 
+class BsoidClassifier:
+    """BSOID base class for multiple behavior classification trigger. Loads pretrained classifier, gets passed features
+    from SimbaFeatureExtractor. Returns probability of prediction that can be incorporated into triggers."""
+
+    def __init__(self):
+        self._classifier = self.load_classifier(PATH_TO_CLASSIFIER)
+        self.last_result = 0.0
+
+    @staticmethod
+    def load_classifier(path_to_sav):
+        """Load saved classifier"""
+        import joblib
+        file = open(path_to_sav,'rb')
+        [_, _, _, clf, _, predictions] = joblib.load(file)
+        file.close()
+        return clf
+
+    def classify(self, features):
+        """predicts motif probability from features    :param feats: list, multiple feats (original feature space)
+        :param clf: Obj, MLP classifier
+        :return nonfs_labels: list, label/100ms
+        Adapted from BSOID; https://github.com/YttriLab/B-SOID
+        """
+        labels_fslow = []
+        for i in range(0, len(features)):
+            labels = self._classifier.predict(features[i].T)
+            labels_fslow.append(labels)
+        self.last_result = labels_fslow
+
+        return labels_fslow
+
+    def get_last_result(self):
+        """Returns predicted last prediction"""
+        return self.last_result
+
+
+"""process protocols"""
+
 def example_classifier_run(input_classification_q: mp.Queue,output_classification_q: mp.Queue):
     classifier = Classifier()  # initialize classifier
     while True:
@@ -102,6 +140,22 @@ def simba_classifier_run(input_q: mp.Queue,output_q: mp.Queue):
             pass
 
 
+def bsoid_classifier_run(input_q: mp.Queue,output_q: mp.Queue):
+    classifier = BsoidClassifier()  # initialize classifier
+    while True:
+        features = None
+        if input_q.full():
+            features = input_q.get()
+        if features is not None:
+            start_time = time.time()
+            last_prob = classifier.classify(features)
+            output_q.put((last_prob))
+            end_time = time.time()
+            print("Classification time: {:.2f} msec".format((end_time-start_time)*1000))
+        else:
+            pass
+
+
 class ClassifierProcess:
     """
     Class to help work with protocol function in multiprocessing
@@ -166,6 +220,15 @@ def __init__(self):
                                                                                     self.output_queue))
 
 
+class BsoidClassifier_Process(ClassifierProcess):
+
+    def __init__(self):
+        super().__init__()
+        self.input_queue = mp.Queue(1)
+        self.output_queue = mp.Queue(1)
+        self._classification_process = mp.Process(target=bsoid_classifier_run,args=(self.input_queue,
+                                                                                    self.output_queue))
+
 """Processing pool for classification"""
 
 
@@ -203,6 +266,22 @@ def simba_classifier_pool_run(input_q: mp.Queue,output_q: mp.Queue):
             pass
 
 
+def bsoid_classifier_pool_run(input_q: mp.Queue,output_q: mp.Queue):
+    classifier = BsoidClassifier()  # initialize classifier
+    while True:
+        features = None
+        feature_id = 0
+        if input_q.full():
+            features,feature_id = input_q.get()
+        if features is not None:
+            start_time = time.time()
+            last_prob = classifier.classify(features)
+            output_q.put((last_prob,feature_id))
+            end_time = time.time()
+            print("Classification time: {:.2f} msec".format((end_time-start_time)*1000))
+        else:
+            pass
+
 class ClassifierProcessPool:
     """
     Class to help work with protocol function in multiprocessing
@@ -309,3 +388,17 @@ def __init__(self,pool_size: int):
         """
         super().__init__(pool_size)
         self._process_pool = super().initiate_pool(simba_classifier_pool_run,pool_size)
+
+
+class BsoidProcessPool(ClassifierProcessPool):
+    """
+    Class to help work with protocol function in multiprocessing
+    spawns a pool of processes that tackle the frame-by-frame issue.
+    """
+
+    def __init__(self,pool_size: int):
+        """
+        Setting up the three queues and the process itself
+        """
+        super().__init__(pool_size)
+        self._process_pool = super().initiate_pool(bsoid_classifier_pool_run,pool_size)

experiments/custom/experiments.py

@@ -11,11 +11,12 @@
 from functools import partial
 from collections import Counter
 from experiments.custom.stimulus_process import ClassicProtocolProcess, SimpleProtocolProcess,Timer, ExampleProtocolProcess
-from experiments.custom.triggers import ScreenTrigger, RegionTrigger, OutsideTrigger, DirectionTrigger, SpeedTrigger, SimbaThresholdBehaviorTriggerPool
+from experiments.custom.triggers import ScreenTrigger, RegionTrigger, OutsideTrigger, DirectionTrigger, SpeedTrigger,\
+    SimbaThresholdBehaviorTriggerPool, BsoidClassBehaviorTriggerPool
 from utils.plotter import plot_triggers_response
 from utils.analysis import angle_between_vectors
 from experiments.custom.stimulation import show_visual_stim_img,laser_switch
-from experiments.custom.classifier import SimbaClassifier_Process, SimbaProcessPool
+from experiments.custom.classifier import SimbaClassifier_Process, SimbaProcessPool, BsoidProcessPool
 
 
 from utils.configloader import THRESHOLD, POOL_SIZE
@@ -125,6 +126,115 @@ def get_info(self):
         info = self._behaviortrigger.get_last_prob()
         return info
 
+
+
+""" experimental classification experiment using BSOID trained classifiers in a pool"""
+
+class BsoidBehaviorExperimentPool:
+    """
+    Test experiment for Simba classification
+    Simple class to contain all of the experiment properties and includes classification
+    Uses multiprocess to ensure the best possible performance and
+        to showcase that it is possible to work with any type of equipment, even timer-dependant
+    """
+
+    def __init__(self):
+        """Classifier process and initiation of behavior trigger"""
+        self.experiment_finished = False
+        self._process_pool = BsoidProcessPool(POOL_SIZE)
+        #pass classifier to trigger, so that check_skeleton is the only function that passes skeleton
+        #initiate in experiment, so that process can be started with start_experiment
+        self._behaviortrigger = BsoidClassBehaviorTriggerPool(target_class= THRESHOLD,
+                                                              class_process_pool = self._process_pool)
+        self._event = None
+        #is not fully utilized in this experiment but is usefull to keep for further adaptation
+        self._current_trial = None
+        self._trial_count = {trial: 0 for trial in self._trials}
+        self._trial_timers = {trial: Timer(10) for trial in self._trials}
+        self._exp_timer = Timer(600)
+
+    def check_skeleton(self, frame, skeleton):
+        """
+        Checking each passed animal skeleton for a pre-defined set of conditions
+        Outputting the visual representation, if exist
+        Advancing trials according to inherent logic of an experiment
+        :param frame: frame, on which animal skeleton was found
+        :param skeleton: skeleton, consisting of multiple joints of an animal
+        """
+        self.check_exp_timer()  # checking if experiment is still on
+        for trial in self._trial_count:
+            # checking if any trial hit a predefined cap
+            if self._trial_count[trial] >= 10:
+                self.stop_experiment()
+
+        if not self.experiment_finished:
+            for trial in self._trials:
+                # check for all trials if condition is met
+                #this passes the skeleton to the trigger, where the feature extraction is done and the extracted features
+                #are passed to the classifier process
+                result, response = self._trials[trial]['trigger'](skeleton, target_class = self._trials[trial]['target_class'])
+                plot_triggers_response(frame, response)
+                #if the trigger is reporting back that the behavior is found: do something
+                #currently nothing is done, expect counting the occurances
+                if result:
+                    if self._current_trial is None:
+                        if not self._trial_timers[trial].check_timer():
+                            self._current_trial = trial
+                            self._trial_timers[trial].reset()
+                            self._trial_count[trial] += 1
+                            print(trial, self._trial_count[trial])
+                else:
+                    if self._current_trial == trial:
+                        self._current_trial = None
+                        self._trial_timers[trial].start()
+    @property
+    def _trials(self):
+        """
+        Defining the trials
+        """
+        trials = {'BSOID1': dict(trigger=self._behaviortrigger.check_skeleton,
+                                    target_class = None,
+                                    count=0)}
+        return trials
+
+    def check_exp_timer(self):
+        """
+        Checking the experiment timer
+        """
+        if not self._exp_timer.check_timer():
+            print("Experiment is finished")
+            print("Time ran out.")
+            self.stop_experiment()
+
+    def start_experiment(self):
+        """
+        Start the experiment
+        """
+        self._process_pool.start()
+        if not self.experiment_finished:
+            self._exp_timer.start()
+
+    def stop_experiment(self):
+        """
+        Stop the experiment and reset the timer
+        """
+        self.experiment_finished = True
+        self._process_pool.end()
+        print('Experiment completed!')
+        self._exp_timer.reset()
+
+    def get_trial(self):
+        """
+        Check which trial is going on right now
+        """
+        return self._event
+
+    def get_info(self):
+        """ returns optional info"""
+        info = self._behaviortrigger.get_last_prob()
+        return info
+
+
 class ExampleExperiment:
     """
     Simple class to contain all of the experiment properties