debugged and cleaned + implement stimulation skeletton

portiloop/capture.py

@@ -399,7 +399,7 @@ def _capture_process(p_data_o, p_msg_io, duration, frequency, python_clock, time
 
 
 class Capture:
-    def __init__(self, quantInferenceClass):
+    def __init__(self, detector_cls=None, stimulator_cls=None):
         # {now.strftime('%m_%d_%Y_%H_%M_%S')}
         self.filename = EDF_PATH / 'recording.edf'
         self._p_capture = None
@@ -433,7 +433,8 @@ class Capture:
         self._t_capture = None
         self.channel_states = ['disabled', 'disabled', 'disabled', 'disabled', 'disabled', 'disabled', 'disabled', 'disabled']
         
-        self.quantInferenceClass = quantInferenceClass
+        self.detector_cls = detector_cls
+        self.stimulator_cls = stimulator_cls
         
         # widgets ===============================
         
@@ -665,6 +666,7 @@ class Capture:
         self.b_duration.observe(self.on_b_duration, 'value')
         self.b_filter.observe(self.on_b_filter, 'value')
         self.b_detect.observe(self.on_b_detect, 'value')
+        self.b_stimulate.observe(self.on_b_stimulate, 'value')
         self.b_record.observe(self.on_b_record, 'value')
         self.b_lsl.observe(self.on_b_lsl, 'value')
         self.b_display.observe(self.on_b_display, 'value')
@@ -707,7 +709,7 @@ class Capture:
         self.b_filter.disabled = False
         self.b_detect.disabled = False
         self.b_record.disabled = False
-        self.b_record.lsl = False
+        self.b_lsl.disabled = False
         self.b_display.disabled = False
         self.b_clock.disabled = False
         self.b_radio_ch2.disabled = False
@@ -733,8 +735,9 @@ class Capture:
         self.b_filter.disabled = True
         self.b_stimulate.disabled = True
         self.b_filter.disabled = True
+        self.b_detect.disabled = True
         self.b_record.disabled = True
-        self.b_record.lsl = True
+        self.b_lsl.disabled = True
         self.b_display.disabled = True
         self.b_clock.disabled = True
         self.b_radio_ch2.disabled = True
@@ -784,8 +787,18 @@ class Capture:
             if self._t_capture is not None:
                 warnings.warn("Capture already running, operation aborted.")
                 return
+            detector_cls = self.detector_cls if self.detect else None
+            stimulator_cls = self.stimulator_cls if self.stimulate else None
             self._t_capture = Thread(target=self.start_capture,
-                                args=(self.filter, self.detect, self.quantInferenceClass, self.record, self.lsl, self.display, 500, self.python_clock))
+                                args=(self.filter,
+                                      detector_cls,
+                                      self.threshold,
+                                      stimulator_cls,
+                                      self.record,
+                                      self.lsl,
+                                      self.display,
+                                      500,
+                                      self.python_clock))
             self._t_capture.start()
         elif val == 'Stop':
             with self._lock_msg_out:
@@ -944,8 +957,9 @@ class Capture:
 
     def start_capture(self,
                       filter,
-                      detect,
-                      quantInferenceClass,
+                      detector_cls,
+                      threshold,
+                      stimulator_cls,
                       record,
                       lsl,
                       viz,
@@ -971,8 +985,8 @@ class Capture:
                                 alpha_std=self.polyak_std,
                                 epsilon=self.epsilon)
             
-        if detect:
-            infer = quantInferenceClass()
+        detector = detector_cls(threshold) if detector_cls is not None else None
+        stimulator = stimulator_cls() if stimulator_cls is not None else None
 
         self._p_capture = mp.Process(target=_capture_process,
                                      args=(p_data_o,
@@ -984,7 +998,7 @@ class Capture:
                                            self.channel_states)
                                     )
         self._p_capture.start()
-        # print(f"PID capture: {self._p_capture.pid}")
+        print(f"PID capture: {self._p_capture.pid}")
 
         if viz:
             live_disp = LiveDisplay(channel_names = self.signal_labels, window_len=width)
@@ -1030,14 +1044,11 @@ class Capture:
             
             filtered_point = n_array.tolist()
             
-            if detect:
-                results = infer.add_datapoints(filtered_points)
+            if detector is not None:
+                detection_signal = detector.detect(filtered_point)
                 
-                for r in results:
-                    print(r >= threshold)
-                
-                if stimulate and True:
-                    print('stimulation')
+                if stimulator is not None:
+                    stimulator.stimulate(detection_signal)
             
             if lsl:
                 lsl_outlet.push_sample(filtered_point[-1])

portiloop/{inference.py → detection.py}

@@ -1,19 +1,49 @@
-from pycoral.utils import edgetpu
-import time
 from abc import ABC, abstractmethod
+import time
 from pathlib import Path
+
+from pycoral.utils import edgetpu
 import numpy as np
 
-DEFAULT_MODEL_PATH = str(Path(__file__).parent / "models/portiloop_model_quant.tflite")
-print(DEFAULT_MODEL_PATH)
 
-class AbstractQuantizedModelForInference(ABC):
+# Abstract interface for developers:
+
+class Detector(ABC):
+    
+    def __init__(self, threshold=None):
+        """
+        If implementing __init__() in your subclass, it must take threshold as a keyword argument.
+        This is the value of the threshold that the user can set in the Portiloop GUI.
+        Caution: even if you don't need this manual threshold in your application,
+        your implementation of __init__() still needs to have this keyword argument.
+        """
+        self.threshold = threshold
+
     @abstractmethod
-    def add_datapoints(self, input_float):
-        return NotImplemented
+    def detect(self, datapoints):
+        """
+        Takes datapoints as input and outputs a detection signal.
+        
+        Args:
+            datapoints: list of lists of n channels: may contain several datapoints.
+                A datapoint is a list of n floats, 1 for each channel.
+                In the current version of Portiloop, there is always only one datapoint per datapoints list.
+        
+        Returns:
+            signal: Object: output detection signal (for instance, the output of a neural network);
+                this output signal is the input of the Stimulator.stimulate method.
+                If you don't mean to use a Stimulator, you can simply return None.
+        """
+        raise NotImplementedError
+
+
+# Example implementation for sleep spindles:
+        
+DEFAULT_MODEL_PATH = str(Path(__file__).parent / "models/portiloop_model_quant.tflite")
+# print(DEFAULT_MODEL_PATH)
 
-class QuantizedModelForInference(AbstractQuantizedModelForInference):
-    def __init__(self, num_models_parallel=8, window_size=54, seq_stride=42, model_path=None, verbose=False, channel=2):
+class SleepSpindleRealTimeDetector(Detector):
+    def __init__(self, threshold=0.5, num_models_parallel=8, window_size=54, seq_stride=42, model_path=None, verbose=False, channel=2):
         model_path = DEFAULT_MODEL_PATH if model_path is None else model_path
         self.verbose = verbose
         self.channel = channel
@@ -32,60 +62,63 @@ class QuantizedModelForInference(AbstractQuantizedModelForInference):
         self.seq_stride = seq_stride
         self.window_size = window_size 
         
-        self.stride_counters = [np.floor((self.seq_stride / self.num_models_parallel) * i) for i in range(self.num_models_parallel)]
-        for idx, i in enumerate(self.stride_counters[1:]):
-            self.stride_counters[idx+1] = i - self.stride_counters[idx]
+        self.stride_counters = [np.floor((self.seq_stride / self.num_models_parallel) * (i + 1)) for i in range(self.num_models_parallel)]
+        for idx in reversed(range(1, len(self.stride_counters))):
+            self.stride_counters[idx] -= self.stride_counters[idx-1]
+        assert sum(self.stride_counters) == self.seq_stride, f"{self.stride_counters} does not sum to {self.seq_stride}"
+            
         self.current_stride_counter = self.stride_counters[0] - 1
         
-        
-    def add_datapoints(self, inputs_float):
+        super().__init__(threshold)
+
+    def detect(self, datapoints):
         res = []
-        for inp in inputs_float:
+        for inp in datapoints:
             result = self.add_datapoint(inp)
             if result is not None:
-                res.append(result)
+                res.append(result >= self.threshold)
         return res
-    
-        
+
     def add_datapoint(self, input_float):
-        input_float = input_float[self.channel-1]
+        input_float = input_float[self.channel - 1]
         result = None
         self.buffer.append(input_float)
         if len(self.buffer) > self.window_size:
             self.buffer = self.buffer[1:]
             self.current_stride_counter += 1
-            if self.current_stride_counter == self.stride_counter[self.interpreter_counter]:
+            if self.current_stride_counter == self.stride_counters[self.interpreter_counter]:
                 result = self.call_model(self.interpreter_counter, self.buffer)
                 self.interpreter_counter += 1
-                self.interpreter_counter %= self.num_model_parallel
+                self.interpreter_counter %= self.num_models_parallel
                 self.current_stride_counter = 0
         return result
-            
-                
-        
+
     def call_model(self, idx, input_float=None):
         if input_float is None:
-            # For debuggin purposes
-            input_shape = input_details[0]['shape']
+            # For debugging purposes
+            input_shape = self.input_details[0]['shape']
             input = np.array(np.random.random_sample(input_shape), dtype=np.int8)
         else:
             # Convert float input to Int
-            input_scale, input_zero_point = input_details[0]["quantization"]
+            input_scale, input_zero_point = self.input_details[0]["quantization"]
             input = np.asarray(input_float) / input_scale + input_zero_point
-            input = input.astype(input_details[0]["dtype"])
-
-        interpreter.set_tensor(input_details[0]['index'], input)
-        if self.verbose:
-            start_time = time.time()
-
-        interpreter.invoke()
-
-        if self.verbose:
-            end_time = time.time()
+            input = input.astype(self.input_details[0]["dtype"])
+        input = input.reshape((1, 1, -1))
 
-        output = interpreter.get_tensor(output_details[0]['index'])
-        output_scale, output_zero_point = input_details[0]["quantization"]
-        output = float(output - output_zero_point) * output_scale
+        # FIXME: bad sequence length: 50 instead of 1:
+        # self.interpreters[idx].set_tensor(self.input_details[0]['index'], input)
+        #
+        # if self.verbose:
+        #     start_time = time.time()
+        #
+        # self.interpreters[idx].invoke()
+        #
+        # if self.verbose:
+        #     end_time = time.time()
+        # output = self.interpreters[idx].get_tensor(self.output_details[0]['index'])
+        # output_scale, output_zero_point = self.input_details[0]["quantization"]
+        # output = float(output - output_zero_point) * output_scale
+        output = np.random.uniform()  # FIXME: remove
 
         if self.verbose:
             print(f"Computed output {output} in {end_time - start_time} seconds")

portiloop/notebooks/tests.ipynb

@@ -2,47 +2,18 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "7b2fc5da",
    "metadata": {
     "scrolled": false
    },
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "910f8e489b6341119f4d6e17a5b2aedc",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "VBox(children=(Accordion(children=(GridBox(children=(Label(value='CH1'), Label(value='CH2'), Label(value='CH3'…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Process Process-1:\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n",
-      "    self.run()\n",
-      "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n",
-      "    self._target(*self._args, **self._kwargs)\n",
-      "  File \"/home/mendel/software/portiloop-software/portiloop/capture.py\", line 325, in _capture_process\n",
-      "    assert data == [0x3E], \"The communication with the ADS cannot be established.\"\n",
-      "AssertionError: The communication with the ADS cannot be established.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from portiloop.capture import Capture\n",
-    "from portiloop.inference import QuantizedModelForInference\n",
+    "from portiloop.detection import SleepSpindleRealTimeDetector\n",
+    "from portiloop.stimulation import SleepSpindleRealTimeStimulator\n",
     "\n",
-    "cap = Capture(QuantizedModelForInference)"
+    "cap = Capture(detector_cls=SleepSpindleRealTimeDetector, stimulator_cls=SleepSpindleRealTimeStimulator)"
    ]
   }
  ],

portiloop/stimulation.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+import time
+
+
+# Abstract interface for developers:
+
+class Stimulator(ABC):
+
+    @abstractmethod
+    def stimulate(self, detection_signal):
+        """
+        Stimulates accordingly to the output of the Detector.
+        
+        Args:
+            detection_signal: Object: the output of the Detector.add_datapoints method.
+        """
+        raise NotImplementedError
+
+        
+# Example implementation for sleep spindles:
+
+class SleepSpindleRealTimeStimulator(Stimulator):
+    def __init__(self):
+        self.last_detected_ts = time.time()
+        self.wait_t = 0.4  # 400 ms
+    
+    def stimulate(self, detection_signal):
+        for sig in detection_signal:
+            if sig:
+                ts = time.time()
+                if ts - self.last_detected_ts > self.wait_t:
+                    print("stimulation")
+                else:
+                    print("same spindle")
+                self.last_detected_ts = ts