py-neuromodulation 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

py_neuromodulation/nm_plots.py

@@ -6,6 +6,9 @@ from matplotlib import gridspec
 from typing import Optional
 import seaborn as sb
 import pandas as pd
+import logging
+
+logger = logging.getLogger("PynmLogger")
 
 from py_neuromodulation import nm_IO, nm_stats
 
@@ -87,7 +90,9 @@ def plot_epoch(
 ):
     if z_score is None:
         X_epoch = stats.zscore(
-            np.nan_to_num(np.nanmean(np.squeeze(X_epoch), axis=0)), axis=0
+            np.nan_to_num(np.nanmean(np.squeeze(X_epoch), axis=0)),
+            axis=0,
+            nan_policy="omit",
         ).T
     y_epoch = np.stack(np.array(y_epoch))
     plt.figure(figsize=(6, 6))
@@ -237,7 +242,7 @@ def plot_corr_matrix(
 
     if save_plot:
         plt.savefig(plt_path, bbox_inches="tight")
-        print("Correlation matrix figure saved to " + str(plt_path))
+        logger.info(f"Correlation matrix figure saved to {plt_path}")
 
     if show_plot is False:
         plt.close()
@@ -329,7 +334,7 @@ def plot_epochs_avg(
 
     if normalize_data:
         X_epoch_mean = stats.zscore(
-            np.nanmean(np.squeeze(X_epoch), axis=0), axis=0
+            np.nanmean(np.squeeze(X_epoch), axis=0), axis=0, nan_policy="omit"
         ).T
     else:
         X_epoch_mean = np.nanmean(np.squeeze(X_epoch), axis=0).T
@@ -385,7 +390,7 @@ def plot_epochs_avg(
             feature_name=feature_str_add,
         )
         plt.savefig(plt_path, bbox_inches="tight")
-        print("Feature epoch average figure saved to: " + str(plt_path))
+        logger.info(f"Feature epoch average figure saved to: {str(plt_path)}")
     if show_plot is False:
         plt.close()
 
@@ -441,7 +446,6 @@ def plot_all_features(
     OUT_PATH: str = None,
     feature_file: str = None,
 ):
-
     if time_limit_high_s is not None:
         df = df[df["time"] < time_limit_high_s * 1000]
     if time_limit_low_s is not None:
@@ -449,7 +453,7 @@ def plot_all_features(
 
     cols_plt = [c for c in df.columns if c != "time"]
     if normalize is True:
-        data_plt = stats.zscore(df[cols_plt])
+        data_plt = stats.zscore(df[cols_plt], nan_policy="omit")
     else:
         data_plt = df[cols_plt]
 
@@ -487,7 +491,6 @@ class NM_Plot:
         sess_right: Optional[bool] = False,
         proj_matrix_cortex: np.ndarray | None = None,
     ) -> None:
-
         self.grid_cortex = grid_cortex
         self.grid_subcortex = grid_subcortex
         self.ecog_strip = ecog_strip
@@ -510,7 +513,6 @@ class NM_Plot:
         ) = nm_IO.read_plot_modules()
 
     def plot_grid_elec_3d(self) -> None:
-
         plot_grid_elec_3d(np.array(self.grid_cortex), np.array(self.ecog_strip))
 
     def plot_cortex(
@@ -552,7 +554,6 @@ class NM_Plot:
         axes.axes.set_aspect("equal", anchor="C")
 
         if grid_cortex is not None:
-
             grid_color = (
                 np.ones(grid_cortex.shape[0])
                 if grid_color is None
@@ -604,6 +605,8 @@ class NM_Plot:
                 feature_name=feature_str_add,
             )
             plt.savefig(plt_path, bbox_inches="tight")
-            print("Feature epoch average figure saved to: " + str(plt_path))
+            logger.info(
+                f"Feature epoch average figure saved to: {str(plt_path)}"
+            )
         if show_plot is False:
             plt.close()

py_neuromodulation/nm_rereference.py

@@ -4,10 +4,8 @@ import pandas as pd
 
 
 class ReReferencer:
-
     ref_matrix: np.ndarray
 
-
     def __init__(
         self,
         sfreq: int | float,
@@ -28,11 +26,15 @@ class ReReferencer:
             ValueError: rereferencing using undefined channel
             ValueError: rereferencing to same channel
         """
-        (channels_used,) = np.where((nm_channels.used == 1))
+        nm_channels = nm_channels[nm_channels["used"] == 1].reset_index(
+            drop=True
+        )
+        # (channels_used,) = np.where((nm_channels.used == 1))
 
         ch_names = nm_channels["name"].tolist()
 
-        if len(ch_names) == 1:
+        # no re-referencing is being performed when there is a single channel present only
+        if nm_channels.shape[0] in (0, 1):
             self.ref_matrix = None
             return
 
@@ -48,8 +50,8 @@ class ReReferencer:
         ref_matrix = np.zeros((len(nm_channels), len(nm_channels)))
         for ind in range(len(nm_channels)):
             ref_matrix[ind, ind] = 1
-            if ind not in channels_used:
-                continue
+            # if ind not in channels_used:
+            #    continue
             ref = refs[ind]
             if ref.lower() == "none" or pd.isnull(ref):
                 ref_idx = None
@@ -84,10 +86,10 @@ class ReReferencer:
                 shape(n_channels, n_samples) - data to be rereferenced.
 
         Returns:
-            reref_data (numpy ndarray): 
+            reref_data (numpy ndarray):
             shape(n_channels, n_samples) - rereferenced data
         """
         if self.ref_matrix is not None:
             return self.ref_matrix @ data
         else:
-            return data
+            return data

py_neuromodulation/nm_run_analysis.py

@@ -1,9 +1,13 @@
 """This module contains the class to process a given batch of data."""
+
 from enum import Enum
 import math
 import os
 from time import time
 from typing import Protocol, Type
+import logging
+
+logger = logging.getLogger("PynmLogger")
 
 import numpy as np
 import pandas as pd
@@ -16,6 +20,7 @@ from py_neuromodulation import (
     nm_projection,
     nm_rereference,
     nm_resample,
+    nm_filter_preprocessing,
 )
 
 _PathLike = str | os.PathLike
@@ -25,8 +30,7 @@ class Preprocessor(Protocol):
     def process(self, data: np.ndarray) -> np.ndarray:
         pass
 
-    def test_settings(self, settings: dict):
-        ...
+    def test_settings(self, settings: dict): ...
 
 
 _PREPROCESSING_CONSTRUCTORS = [
@@ -73,7 +77,7 @@ class DataProcessor:
         notch_filter : nm_filter.NotchFilter,
             Notch Filter object, needs to be instantiated beforehand
         verbose : boolean
-            if True, print out signal processed and computation time
+            if True, log signal processed and computation time
         """
         self.settings = self._load_settings(settings)
         self.nm_channels = self._load_nm_channels(nm_channels)
@@ -119,6 +123,12 @@ class DataProcessor:
                         **self.settings.get(settings_str, {}),
                     )
                     self.preprocessors.append(preprocessor)
+                case "preprocessing_filter":
+                    preprocessor = nm_filter_preprocessing.PreprocessingFilter(
+                        settings=self.settings,
+                        sfreq=self.sfreq_raw,
+                    )
+                    self.preprocessors.append(preprocessor)
                 case _:
                     raise ValueError(
                         "Invalid preprocessing method. Must be one of"
@@ -331,7 +341,7 @@ class DataProcessor:
 
         nan_channels = np.isnan(data).any(axis=1)
 
-        data = np.nan_to_num(data)  # [self.feature_idx, :]needs to be before preprocessing
+        data = np.nan_to_num(data)[self.feature_idx, :]
 
         for processor in self.preprocessors:
             data = processor.process(data)
@@ -341,8 +351,13 @@ class DataProcessor:
 
         # normalize features
         if self.settings["postprocessing"]["feature_normalization"]:
-            normed_features = self.feature_normalizer.process(np.fromiter(features_dict.values(), dtype="float"))
-            features_dict = {key: normed_features[idx] for idx, key in enumerate(features_dict.keys())}
+            normed_features = self.feature_normalizer.process(
+                np.fromiter(features_dict.values(), dtype="float")
+            )
+            features_dict = {
+                key: normed_features[idx]
+                for idx, key in enumerate(features_dict.keys())
+            }
 
         features_current = pd.Series(
             data=list(features_dict.values()),
@@ -364,7 +379,7 @@ class DataProcessor:
                 ] = np.nan
 
         if self.verbose is True:
-            print(
+            logger.info(
                 "Last batch took: "
                 + str(np.round(time() - start_time, 2))
                 + " seconds"
@@ -390,14 +405,14 @@ class DataProcessor:
             sidecar["coords"] = self.projection.coords
             if self.settings["postprocessing"]["project_cortex"]:
                 sidecar["grid_cortex"] = self.projection.grid_cortex
-                sidecar[
-                    "proj_matrix_cortex"
-                ] = self.projection.proj_matrix_cortex
+                sidecar["proj_matrix_cortex"] = (
+                    self.projection.proj_matrix_cortex
+                )
             if self.settings["postprocessing"]["project_subcortex"]:
                 sidecar["grid_subcortex"] = self.projection.grid_subcortex
-                sidecar[
-                    "proj_matrix_subcortex"
-                ] = self.projection.proj_matrix_subcortex
+                sidecar["proj_matrix_subcortex"] = (
+                    self.projection.proj_matrix_subcortex
+                )
         if additional_args is not None:
             sidecar = sidecar | additional_args
 

py_neuromodulation/nm_sharpwaves.py

@@ -105,23 +105,12 @@ class SharpwaveAnalyzer(nm_features_abc.Feature):
         peak_right_val (np.ndarray): value of righ peak
         """
 
-        ind_greater = np.where(arr_ind_peaks > trough_ind)[0]
-        if ind_greater.shape[0] == 0:
-            raise NoValidTroughException("No valid trough")
-        val_ind_greater = arr_ind_peaks[ind_greater]
-        peak_right_idx = arr_ind_peaks[
-            ind_greater[np.argsort(val_ind_greater)[0]]
-        ]
-
-        ind_smaller = np.where(arr_ind_peaks < trough_ind)[0]
-        if ind_smaller.shape[0] == 0:
-            raise NoValidTroughException("No valid trough")
-
-        val_ind_smaller = arr_ind_peaks[ind_smaller]
-        peak_left_idx = arr_ind_peaks[
-            ind_smaller[np.argsort(val_ind_smaller)[-1]]
-        ]
+        try: peak_right_idx = arr_ind_peaks[arr_ind_peaks > trough_ind][0]
+        except IndexError: raise NoValidTroughException("No valid trough")
 
+        try: peak_left_idx  = arr_ind_peaks[arr_ind_peaks < trough_ind][-1]
+        except IndexError: raise NoValidTroughException("No valid trough")
+       
         return (
             peak_left_idx,
             peak_right_idx,
@@ -150,12 +139,10 @@ class SharpwaveAnalyzer(nm_features_abc.Feature):
         """
         for ch_idx, ch_name in enumerate(self.ch_names):
             for filter_name, filter in self.list_filter:
-                if filter_name == "no_filter":
-                    self.data_process_sw = data[ch_idx, :]
-                else:
-                    self.data_process_sw = signal.convolve(
-                        data[ch_idx, :], filter, mode="same"
-                    )
+                self.data_process_sw = (data[ch_idx, :] 
+                    if filter_name == "no_filter" 
+                    else signal.fftconvolve(data[ch_idx, :], filter, mode="same")
+                )
 
                 # check settings if troughs and peaks are analyzed
 
@@ -267,123 +254,103 @@ class SharpwaveAnalyzer(nm_features_abc.Feature):
             distance=self.sw_settings["detect_troughs"]["distance_troughs_ms"],
         )[0]
 
-        for trough_idx in troughs:
-            try:
-                (
-                    peak_idx_left,
-                    peak_idx_right,
-                    peak_left,
-                    peak_right,
-                ) = self._get_peaks_around(
-                    trough_idx, peaks, self.data_process_sw
-                )
-            except NoValidTroughException:
-                # in this case there are no adjacent two peaks around this trough
-                # str(e) could print the exception error message
-                # print(str(e))
+        """ Find left and right peak indexes for each trough """
+        peak_pointer = 0
+        peak_idx_left = []
+        peak_idx_right = []
+        first_valid = last_valid = 0
+
+        for i, trough_idx in enumerate(troughs):
+            
+            # Locate peak right of current trough
+            while peak_pointer < peaks.size and peaks[peak_pointer] < trough_idx:
+                peak_pointer += 1
+
+            if peak_pointer - 1 < 0: 
+                # If trough has no peak to it's left, it's not valid 
+                first_valid = i + 1 # Try with next one
                 continue
 
-            trough = self.data_process_sw[trough_idx]
-            self.trough.append(trough)
-            self.troughs_idx.append(trough_idx)
-
-            if self.sw_settings["sharpwave_features"]["interval"] is True:
-                if len(self.troughs_idx) > 1:
-                    # take the last identified trough idx
-                    # corresponds here to second last trough_idx
-
-                    interval = (trough_idx - self.troughs_idx[-2]) * (
-                        1000 / self.sfreq
-                    )
-                else:
-                    # set first interval to zero
-                    interval = 0
-                self.interval.append(interval)
-
-            if self.sw_settings["sharpwave_features"]["peak_left"] is True:
-                self.peak_left.append(peak_left)
-
-            if self.sw_settings["sharpwave_features"]["peak_right"] is True:
-                self.peak_right.append(peak_right)
-
-            if self.sw_settings["sharpwave_features"]["sharpness"] is True:
-                # check if sharpness can be calculated
-                # trough_idx 5 ms need to be consistent
-                if (trough_idx - int(5 * (1000 / self.sfreq)) <= 0) or (
-                    trough_idx + int(5 * (1000 / self.sfreq))
-                    >= self.data_process_sw.shape[0]
-                ):
-                    continue
-
-                sharpness = (
-                    (
-                        self.data_process_sw[trough_idx]
-                        - self.data_process_sw[
-                            trough_idx - int(5 * (1000 / self.sfreq))
-                        ]
-                    )
-                    + (
-                        self.data_process_sw[trough_idx]
-                        - self.data_process_sw[
-                            trough_idx + int(5 * (1000 / self.sfreq))
-                        ]
-                    )
-                ) / 2
-
-                self.sharpness.append(sharpness)
-
-            if self.sw_settings["sharpwave_features"]["rise_steepness"] is True:
-                # steepness is calculated as the first derivative
-                # from peak/trough to trough/peak
-                # here  + 1 due to python syntax, s.t. the last element is included
-                rise_steepness = np.max(
-                    np.diff(
-                        self.data_process_sw[peak_idx_left : trough_idx + 1]
-                    )
-                )
-                self.rise_steepness.append(rise_steepness)
-
-            if (
-                self.sw_settings["sharpwave_features"]["decay_steepness"]
-                is True
-            ):
-                decay_steepness = np.max(
-                    np.diff(
-                        self.data_process_sw[trough_idx : peak_idx_right + 1]
-                    )
-                )
-                self.decay_steepness.append(decay_steepness)
-
-            if (
-                self.sw_settings["sharpwave_features"]["rise_steepness"] is True
-                and self.sw_settings["sharpwave_features"]["decay_steepness"]
-                is True
-                and self.sw_settings["sharpwave_features"]["slope_ratio"]
-                is True
-            ):
-                self.slope_ratio.append(rise_steepness - decay_steepness)
-
-            if self.sw_settings["sharpwave_features"]["prominence"] is True:
-                self.prominence.append(
-                    np.abs(
-                        (peak_right + peak_left) / 2
-                        - self.data_process_sw[trough_idx]
-                    )
-                )
-
-            if self.sw_settings["sharpwave_features"]["decay_time"] is True:
-                self.decay_time.append(
-                    (peak_idx_left - trough_idx) * (1000 / self.sfreq)
-                )  # ms
-
-            if self.sw_settings["sharpwave_features"]["rise_time"] is True:
-                self.rise_time.append(
-                    (peak_idx_right - trough_idx) * (1000 / self.sfreq)
-                )  # ms
-
-            if self.sw_settings["sharpwave_features"]["width"] is True:
-                self.width.append(peak_idx_right - peak_idx_left)  # ms
+            if peak_pointer == peaks.size:
+                # If we went past the end of the peaks list, trough had no peak to its right
+                continue
 
+            last_valid = i
+            peak_idx_left.append(peaks[peak_pointer - 1])
+            peak_idx_right.append(peaks[peak_pointer])
+
+        troughs = troughs[first_valid:last_valid + 1] # Remove non valid troughs
+        
+        peak_idx_left = np.array(peak_idx_left, dtype=np.integer)
+        peak_idx_right = np.array(peak_idx_right, dtype=np.integer)
+
+        peak_left = self.data_process_sw[peak_idx_left]
+        peak_right = self.data_process_sw[peak_idx_right]
+        trough_values = self.data_process_sw[troughs]
+
+        # No need to store trough data as it is not used anywhere else in the program
+        # self.trough.append(trough)
+        # self.troughs_idx.append(trough_idx)
+         
+        """ Calculate features (vectorized) """
+        
+        if self.sw_settings["sharpwave_features"]["interval"]:
+            self.interval = np.concatenate(([0], np.diff(troughs))) * (1000 / self.sfreq)
+
+        if self.sw_settings["sharpwave_features"]["peak_left"]:
+            self.peak_left = peak_left
+
+        if self.sw_settings["sharpwave_features"]["peak_right"]:
+            self.peak_right = peak_right
+
+        if self.sw_settings["sharpwave_features"]["sharpness"]:
+            # sharpess is calculated on a +- 5 ms window
+            # valid troughs need 5 ms of margin on both siddes
+            troughs_valid = troughs[np.logical_and(
+                                troughs - int(5 * (1000 / self.sfreq)) > 0, 
+                                troughs + int(5 * (1000 / self.sfreq)) < self.data_process_sw.shape[0])]
+
+            self.sharpness = (
+                        (self.data_process_sw[troughs_valid] - self.data_process_sw[troughs_valid - int(5 * (1000 / self.sfreq))]) +
+                        (self.data_process_sw[troughs_valid] - self.data_process_sw[troughs_valid + int(5 * (1000 / self.sfreq))])
+                        ) / 2
+
+        if (self.sw_settings["sharpwave_features"]["rise_steepness"] or
+            self.sw_settings["sharpwave_features"]["decay_steepness"]):
+            
+            # steepness is calculated as the first derivative
+            steepness = np.concatenate(([0],np.diff(self.data_process_sw)))
+
+            if self.sw_settings["sharpwave_features"]["rise_steepness"]: # left peak -> trough
+                # + 1 due to python syntax, s.t. the last element is included
+                self.rise_steepness = np.array([
+                    np.max(np.abs(steepness[peak_idx_left[i] : troughs[i] + 1]))
+                    for i in range(trough_idx.size)
+                ])
+                
+            if self.sw_settings["sharpwave_features"]["decay_steepness"]: # trough -> right peak
+                self.decay_steepness = np.array([
+                    np.max(np.abs(steepness[troughs[i] : peak_idx_right[i] + 1]))
+                    for i in range(trough_idx.size)
+                ])
+
+            if (self.sw_settings["sharpwave_features"]["rise_steepness"] and
+                self.sw_settings["sharpwave_features"]["decay_steepness"] and
+                self.sw_settings["sharpwave_features"]["slope_ratio"]):
+                self.slope_ratio = self.rise_steepness - self.decay_steepness
+
+        if self.sw_settings["sharpwave_features"]["prominence"]:
+            self.prominence = np.abs((peak_right + peak_left) / 2 - trough_values)
+
+        if self.sw_settings["sharpwave_features"]["decay_time"]:
+            self.decay_time = (peak_idx_left - troughs) * (1000 / self.sfreq) # ms
+
+        if self.sw_settings["sharpwave_features"]["rise_time"]:
+            self.rise_time = (peak_idx_right - troughs) * (1000 / self.sfreq) # ms
+
+        if self.sw_settings["sharpwave_features"]["width"]:
+            self.width = peak_idx_right - peak_idx_left  # ms
+    
     @staticmethod
     def test_settings(
         s: dict,