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

py_neuromodulation/nm_stats.py

@@ -2,6 +2,7 @@ import random
 import copy
 
 import matplotlib.pyplot as plt
+
 # from numba import njit
 import numpy as np
 import pandas as pd
@@ -33,7 +34,7 @@ def fitlm_kfold(x, y, kfold_splits=5):
         scores.append(score)
         coeffs = np.vstack((coeffs, model.coef_))
     coeffs = list(np.delete(coeffs, 0))
-    return scores, coeffs, model, ['scores', 'coeffs', 'model']
+    return scores, coeffs, model, ["scores", "coeffs", "model"]
 
 
 def zscore(data):
@@ -76,14 +77,14 @@ def permutationTestSpearmansRho(x, y, plot_distr=True, x_unit=None, p=5000):
 
     # calculate p value
     if gT < 0:
-        p_val = len(np.where(pD <= gT)[0])/p
+        p_val = len(np.where(pD <= gT)[0]) / p
     else:
-        p_val = len(np.where(pD >= gT)[0])/p
+        p_val = len(np.where(pD >= gT)[0]) / p
 
     if plot_distr is True:
         plt.hist(pD, bins=30, label="permutation results")
         plt.axvline(gT, color="orange", label="ground truth")
-        plt.title("ground truth " + x_unit + "="+str(gT) + " p=" + str(p_val))
+        plt.title("ground truth " + x_unit + "=" + str(gT) + " p=" + str(p_val))
         plt.xlabel(x_unit)
         plt.legend()
         plt.show()
@@ -120,19 +121,23 @@ def permutationTest(x, y, plot_distr=True, x_unit=None, p=5000):
         random.shuffle(pS)
         # Compute permuted absolute difference of your two sampled
         # distributions and store it in pD:
-        pD.append(np.abs(np.average(pS[0:int(len(pS)/2)]) - np.average(
-            pS[int(len(pS)/2):])))
+        pD.append(
+            np.abs(
+                np.average(pS[0 : int(len(pS) / 2)])
+                - np.average(pS[int(len(pS) / 2) :])
+            )
+        )
 
     # Calculate p-value
     if gT < 0:
-        p_val = len(np.where(pD <= gT)[0])/p
+        p_val = len(np.where(pD <= gT)[0]) / p
     else:
-        p_val = len(np.where(pD >= gT)[0])/p
+        p_val = len(np.where(pD >= gT)[0]) / p
 
     if plot_distr is True:
         plt.hist(pD, bins=30, label="permutation results")
         plt.axvline(gT, color="orange", label="ground truth")
-        plt.title("ground truth "+x_unit+"="+str(gT)+" p="+str(p_val))
+        plt.title("ground truth " + x_unit + "=" + str(gT) + " p=" + str(p_val))
         plt.xlabel(x_unit)
         plt.legend()
         plt.show()
@@ -165,17 +170,20 @@ def permutationTest_relative(x, y, plot_distr=True, x_unit=None, p=5000):
                 l_.append((x[i], y[i]))
             else:
                 l_.append((y[i], x[i]))
-        pD.append(np.abs(np.average(np.array(l_)[:, 0]) - np.average(
-            np.array(l_)[:, 1])))
+        pD.append(
+            np.abs(
+                np.average(np.array(l_)[:, 0]) - np.average(np.array(l_)[:, 1])
+            )
+        )
     if gT < 0:
-        p_val = len(np.where(pD <= gT)[0])/p
+        p_val = len(np.where(pD <= gT)[0]) / p
     else:
-        p_val = len(np.where(pD >= gT)[0])/p
+        p_val = len(np.where(pD >= gT)[0]) / p
 
     if plot_distr is True:
         plt.hist(pD, bins=30, label="permutation results")
         plt.axvline(gT, color="orange", label="ground truth")
-        plt.title("ground truth "+x_unit+"="+str(gT)+" p="+str(p_val))
+        plt.title("ground truth " + x_unit + "=" + str(gT) + " p=" + str(p_val))
         plt.xlabel(x_unit)
         plt.legend()
         plt.show()
@@ -211,13 +219,13 @@ def permutation_numba_onesample(x, y, n_perm, two_tailed=True):
     """
     if two_tailed is True:
         zeroed = x - y
-        print(zeroed)
         z = np.abs(np.mean(zeroed))
         p = np.empty(n_perm)
         # Run the simulation n_perm times
         for i in np.arange(n_perm):
             sign = np.random.choice(
-                a=np.array([-1., 1.]), size=len(x), replace=True)
+                a=np.array([-1.0, 1.0]), size=len(x), replace=True
+            )
             p[i] = np.abs(np.mean(zeroed * sign))
     else:
         zeroed = x - y
@@ -226,7 +234,8 @@ def permutation_numba_onesample(x, y, n_perm, two_tailed=True):
         # Run the simulation n_perm times
         for i in np.arange(n_perm):
             sign = np.random.choice(
-                a=np.array([-1., 1.]), size=len(x), replace=True)
+                a=np.array([-1.0, 1.0]), size=len(x), replace=True
+            )
             p[i] = np.mean(zeroed * sign)
         # Return p-value
     return z, (np.sum(p >= z)) / n_perm
@@ -311,7 +320,8 @@ def cluster_wise_p_val_correction(p_arr, p_sig=0.05, num_permutations=10000):
         # first cluster is assigned to be 1 from measure.label
         index_cluster[cluster_i] = np.where(labels == cluster_i + 1)[0]
         p_cluster_sum[cluster_i] = np.sum(
-            np.array(1 - p_arr)[index_cluster[cluster_i]])
+            np.array(1 - p_arr)[index_cluster[cluster_i]]
+        )
     # p_min corresponds to the most unlikely cluster
     p_min = np.max(p_cluster_sum)
 
@@ -320,11 +330,13 @@ def cluster_wise_p_val_correction(p_arr, p_sig=0.05, num_permutations=10000):
     # loop through random permutation cycles
     r_per_arr = np.zeros(num_permutations)
     for r in range(num_permutations):
-        r_per = np.random.randint(low=0, high=p_arr.shape[0],
-                                  size=p_arr.shape[0])
+        r_per = np.random.randint(
+            low=0, high=p_arr.shape[0], size=p_arr.shape[0]
+        )
 
-        labels, num_clusters = measure.label(p_arr[r_per] <= p_sig,
-                                             return_num=True)
+        labels, num_clusters = measure.label(
+            p_arr[r_per] <= p_sig, return_num=True
+        )
 
         index_cluster = {}
         if num_clusters == 0:
@@ -332,11 +344,12 @@ def cluster_wise_p_val_correction(p_arr, p_sig=0.05, num_permutations=10000):
         else:
             p_cluster_sum = np.zeros(num_clusters)
             for cluster_i in np.arange(num_clusters):
-                index_cluster[cluster_i] = np.where(
-                    labels == cluster_i + 1)[
-                    0]  # first cluster is assigned to be 1 from measure.label
+                index_cluster[cluster_i] = np.where(labels == cluster_i + 1)[
+                    0
+                ]  # first cluster is assigned to be 1 from measure.label
                 p_cluster_sum[cluster_i] = np.sum(
-                    np.array(1 - p_arr[r_per])[index_cluster[cluster_i]])
+                    np.array(1 - p_arr[r_per])[index_cluster[cluster_i]]
+                )
             # corresponds to the most unlikely cluster
             r_per_arr[r] = np.max(p_cluster_sum)
 
@@ -432,7 +445,8 @@ def cluster_wise_p_val_correction_numba(p_arr, p_sig, n_perm):
         r_per_arr = np.zeros(n_perm_)
         for r in range(n_perm_):
             r_per = np.random.randint(
-                low=0, high=p_arr_.shape[0], size=p_arr_.shape[0])
+                low=0, high=p_arr_.shape[0], size=p_arr_.shape[0]
+            )
             labels_, n_clusters = cluster(p_arr_[r_per] <= p_sig_)
 
             cluster_ind = {}
@@ -441,10 +455,10 @@ def cluster_wise_p_val_correction_numba(p_arr, p_sig, n_perm):
             else:
                 p_sum = np.zeros(n_clusters)
                 for ind in range(n_clusters):
-                    cluster_ind[ind] = \
-                        np.where(labels_ == ind + 1)[0]
+                    cluster_ind[ind] = np.where(labels_ == ind + 1)[0]
                     p_sum[ind] = np.sum(
-                        np.asarray(1 - p_arr_[r_per])[cluster_ind[ind]])
+                        np.asarray(1 - p_arr_[r_per])[cluster_ind[ind]]
+                    )
                 r_per_arr[r] = np.max(p_sum)
         return r_per_arr
 

py_neuromodulation/nm_stream_abc.py

@@ -1,9 +1,15 @@
 """Module that contains PNStream ABC."""
+
 from abc import ABC, abstractmethod
 import os
 import pathlib
 import _pickle as cPickle
 
+from .utils import _logging  # logger initialization
+
+# Logger use in different modules: logger = logging.getLogger("PynmLogger")
+
+
 import pandas as pd
 from sklearn import base
 
@@ -12,7 +18,7 @@ from py_neuromodulation import (
     nm_IO,
     nm_plots,
     nm_run_analysis,
-    nm_settings
+    nm_settings,
 )
 
 _PathLike = str | os.PathLike
@@ -72,7 +78,9 @@ class PNStream(ABC):
         self.settings = self._load_settings(settings)
 
         if sampling_rate_features_hz is not None:
-            self.settings["sampling_rate_features_hz"] = sampling_rate_features_hz
+            self.settings["sampling_rate_features_hz"] = (
+                sampling_rate_features_hz
+            )
 
         self.nm_channels = self._load_nm_channels(nm_channels)
         if path_grids is None:
@@ -138,10 +146,12 @@ class PNStream(ABC):
         nm_channels: pd.DataFrame | _PathLike,
     ) -> pd.DataFrame:
         if not isinstance(nm_channels, pd.DataFrame):
-            nm_channels =  nm_IO.load_nm_channels(nm_channels)
-        
-        if nm_channels.query("used == 1 and target == 0").shape[0]  == 0:
-            raise ValueError("No channels selected for analysis that have column 'used' = 1 and 'target' = 0. Please check your nm_channels")
+            nm_channels = nm_IO.load_nm_channels(nm_channels)
+
+        if nm_channels.query("used == 1 and target == 0").shape[0] == 0:
+            raise ValueError(
+                "No channels selected for analysis that have column 'used' = 1 and 'target' = 0. Please check your nm_channels"
+            )
 
         return nm_channels
 
@@ -149,7 +159,7 @@ class PNStream(ABC):
     def _load_settings(settings: dict | _PathLike | None) -> dict:
         if isinstance(settings, dict):
             return settings
-        if settings is None: 
+        if settings is None:
             return nm_settings.get_default_settings()
         return nm_IO.read_settings(str(settings))
 
@@ -196,9 +206,7 @@ class PNStream(ABC):
     ) -> None:
         self.run_analysis.save_nm_channels(out_path_root, folder_name)
 
-    def save_settings(
-        self, out_path_root: _PathLike, folder_name: str
-    ) -> None:
+    def save_settings(self, out_path_root: _PathLike, folder_name: str) -> None:
         self.run_analysis.save_settings(out_path_root, folder_name)
 
     def save_sidecar(self, out_path_root: _PathLike, folder_name: str) -> None:

py_neuromodulation/nm_stream_offline.py

@@ -1,17 +1,28 @@
 """Module for offline data streams."""
-import math
-import os
 
+import os
+from joblib import Parallel, delayed
 import numpy as np
 import pandas as pd
+from itertools import count
+import logging
+
+logger = logging.getLogger("PynmLogger")
+
+import mne
 
-from py_neuromodulation import nm_generator, nm_IO, nm_stream_abc, nm_define_nmchannels
+from py_neuromodulation import (
+    nm_generator,
+    nm_IO,
+    nm_stream_abc,
+    nm_define_nmchannels,
+)
 
 _PathLike = str | os.PathLike
 
 
 class _OfflineStream(nm_stream_abc.PNStream):
-    """Offline stream base class. 
+    """Offline stream base class.
     This class can be inhereted for different types of offline streams, e.g. epoch-based or continuous.
 
     Parameters
@@ -19,19 +30,38 @@ class _OfflineStream(nm_stream_abc.PNStream):
     nm_stream_abc : nm_stream_abc.PNStream
     """
 
-    def _add_labels(
-        self, features: pd.DataFrame, data: np.ndarray
-    ) -> pd.DataFrame:
-        """Add resampled labels to features if there are target channels."""
+    def _add_target(
+        self, feature_series: pd.Series, data: np.ndarray
+    ) -> pd.Series:
+        """Add target channels to feature series.
+
+        Parameters
+        ----------
+        feature_series : pd.Series
+        data : np.ndarray
+            Raw data with shape (n_channels, n_samples). Channels not for feature computation are also included
+
+        Returns
+        -------
+        pd.Series
+            feature series with target channels added
+        """
+
         if self.nm_channels["target"].sum() > 0:
-            features = nm_IO.add_labels(
-                features=features,
-                settings=self.settings,
-                nm_channels=self.nm_channels,
-                raw_arr_data=data,
-                fs=self.sfreq,
-            )
-        return features
+            if not self.target_idx_initialized:
+                self.target_indexes = self.nm_channels[
+                    self.nm_channels["target"] == 1
+                ].index
+                self.target_names = self.nm_channels.loc[
+                    self.target_indexes, "name"
+                ].to_list()
+                self.target_idx_initialized = True
+
+            for target_idx, target_name in zip(
+                self.target_indexes, self.target_names
+            ):
+                feature_series[target_name] = data[target_idx, -1]
+        return feature_series
 
     def _add_timestamp(
         self, feature_series: pd.Series, cnt_samples: int
@@ -41,11 +71,10 @@ class _OfflineStream(nm_stream_abc.PNStream):
         Due to normalization run_analysis needs to keep track of the counted
         samples. These are accessed here for time conversion.
         """
-        timestamp = cnt_samples * 1000 / self.sfreq
         feature_series["time"] = cnt_samples * 1000 / self.sfreq
 
         if self.verbose:
-            print(
+            logging.info(
                 str(np.round(feature_series["time"] / 1000, 2))
                 + " seconds of data processed"
             )
@@ -76,45 +105,149 @@ class _OfflineStream(nm_stream_abc.PNStream):
             )
         return data.to_numpy()
 
+    def _check_settings_for_parallel(self):
+        """Check specified settings and raise error if parallel processing is not possible.
+
+        Raises:
+            ValueError: depending on the settings, parallel processing is not possible
+        """
+
+        if "raw_normalization" in self.settings["preprocessing"]:
+            raise ValueError(
+                "Parallel processing is not possible with raw_normalization normalization."
+            )
+        if self.settings["postprocessing"]["feature_normalization"] is True:
+            raise ValueError(
+                "Parallel processing is not possible with feature normalization."
+            )
+        if self.settings["features"]["bursts"] is True:
+            raise ValueError(
+                "Parallel processing is not possible with burst estimation."
+            )
+
+    def _process_batch(self, data_batch, cnt_samples):
+        feature_series = self.run_analysis.process(
+            data_batch.astype(np.float64)
+        )
+        feature_series = self._add_timestamp(feature_series, cnt_samples)
+        feature_series = self._add_target(
+            feature_series=feature_series, data=data_batch
+        )
+        return feature_series
+
     def _run_offline(
         self,
         data: np.ndarray,
         out_path_root: _PathLike | None = None,
         folder_name: str = "sub",
+        parallel: bool = False,
+        n_jobs: int = -2,
     ) -> pd.DataFrame:
         generator = nm_generator.raw_data_generator(
             data=data,
             settings=self.settings,
-            sfreq=math.floor(self.sfreq),
+            sfreq=self.sfreq,
         )
-        features = []
-        sample_add = int(self.sfreq / self.run_analysis.sfreq_features)
 
-        offset_time = self.settings["segment_length_features_ms"]
-        offset_start = np.ceil(offset_time / 1000 * self.sfreq).astype(int)
+        sample_add = self.sfreq / self.run_analysis.sfreq_features
 
-        cnt_samples = offset_start
+        offset_time = self.settings["segment_length_features_ms"]
+        # offset_start = np.ceil(offset_time / 1000 * self.sfreq).astype(int)
+        offset_start = offset_time / 1000 * self.sfreq
+
+        if parallel:
+            l_features = Parallel(n_jobs=n_jobs, verbose=10)(
+                delayed(self._process_batch)(data_batch, cnt_samples)
+                for data_batch, cnt_samples in zip(
+                    generator, count(offset_start, sample_add)
+                )
+            )
 
-        while True:
-            data_batch = next(generator, None)
-            if data_batch is None:
-                break
-            feature_series = self.run_analysis.process(data_batch.astype(np.float64))
-            feature_series = self._add_timestamp(feature_series, cnt_samples)
-            features.append(feature_series)
+        else:
+            l_features = []
+            cnt_samples = offset_start
+            while True:
+                data_batch = next(generator, None)
+                if data_batch is None:
+                    break
+                feature_series = self.run_analysis.process(
+                    data_batch.astype(np.float64)
+                )
+                feature_series = self._add_timestamp(
+                    feature_series, cnt_samples
+                )
 
-            if self.model is not None:
-                prediction = self.model.predict(feature_series)
+                feature_series = self._add_target(
+                    feature_series=feature_series, data=data_batch
+                )
 
-            cnt_samples += sample_add
+                l_features.append(feature_series)
 
-        feature_df = pd.DataFrame(features)
-        feature_df = self._add_labels(features=feature_df, data=data)
+                cnt_samples += sample_add
+        feature_df = pd.DataFrame(l_features)
 
         self.save_after_stream(out_path_root, folder_name, feature_df)
 
         return feature_df
 
+    def plot_raw_signal(
+        self,
+        sfreq: float = None,
+        data: np.array = None,
+        lowpass: float = None,
+        highpass: float = None,
+        picks: list = None,
+        plot_time: bool = True,
+        plot_psd: bool = False,
+    ) -> None:
+        """Use MNE-RawArray Plot to investigate PSD or raw_signal plot.
+
+        Parameters
+        ----------
+        sfreq : float
+            sampling frequency [Hz]
+        data : np.array, optional
+            data (n_channels, n_times), by default None
+        plot_time : bool, optional
+            mne.io.RawArray.plot(), by default True
+        plot_psd : bool, optional
+            mne.io.RawArray.plot(), by default True
+
+        Raises
+        ------
+        ValueError
+            raise Exception when no data is passed
+        """
+        if self.data is None and data is None:
+            raise ValueError("No data passed to plot_raw_signal function.")
+
+        if data is None and self.data is not None:
+            data = self.data
+
+        if sfreq is None:
+            sfreq = self.sfreq
+
+        if self.nm_channels is not None:
+            ch_names = self.nm_channels["name"].to_list()
+            ch_types = self.nm_channels["type"].to_list()
+        else:
+            ch_names = [f"ch_{i}" for i in range(data.shape[0])]
+            ch_types = ["ecog" for i in range(data.shape[0])]
+
+        # create mne.RawArray
+        info = mne.create_info(
+            ch_names=ch_names, sfreq=sfreq, ch_types=ch_types
+        )
+        raw = mne.io.RawArray(data, info)
+
+        if picks is not None:
+            raw = raw.pick(picks)
+        self.raw = raw
+        if plot_time:
+            raw.plot(highpass=highpass, lowpass=lowpass)
+        if plot_psd:
+            raw.compute_psd().plot()
+
 
 class Stream(_OfflineStream):
     def __init__(
@@ -128,7 +261,7 @@ class Stream(_OfflineStream):
         path_grids: _PathLike | None = None,
         coord_names: list | None = None,
         coord_list: list | None = None,
-        verbose: bool = True,     
+        verbose: bool = True,
     ) -> None:
         """Stream initialization
 
@@ -153,11 +286,13 @@ class Stream(_OfflineStream):
         coord_list : list | None, optional
             coordinates in the form [[coord_1_x, coord_1_y, coord_1_z], [coord_2_x, coord_2_y, coord_2_z],], by default None
         verbose : bool, optional
-            print out stream computation time information, by default True
+            log stream computation time information, by default True
         """
 
         if nm_channels is None and data is not None:
-            nm_channels = nm_define_nmchannels.get_default_channels_from_data(data)
+            nm_channels = nm_define_nmchannels.get_default_channels_from_data(
+                data
+            )
 
         if nm_channels is None and data is None:
             raise ValueError(
@@ -178,11 +313,15 @@ class Stream(_OfflineStream):
 
         self.data = data
 
+        self.target_idx_initialized = False
+
     def run(
         self,
         data: np.ndarray | pd.DataFrame = None,
         out_path_root: _PathLike | None = None,
         folder_name: str = "sub",
+        parallel: bool = False,
+        n_jobs: int = -2,
     ) -> pd.DataFrame:
         """Call run function for offline stream.
 
@@ -209,8 +348,11 @@ class Stream(_OfflineStream):
         elif self.data is not None:
             data = self._handle_data(self.data)
         elif self.data is None and data is None:
-            raise ValueError(
-                "No data passed to run function."
-            )
+            raise ValueError("No data passed to run function.")
+
+        if parallel is True:
+            self._check_settings_for_parallel()
 
-        return self._run_offline(data, out_path_root, folder_name)
+        return self._run_offline(
+            data, out_path_root, folder_name, parallel=parallel, n_jobs=n_jobs
+        )

py_neuromodulation/utils/_logging.py

@@ -0,0 +1,24 @@
+import logging
+
+# include the filename in the log output
+# Configure the logger
+logger = logging.getLogger("PynmLogger")
+logger.setLevel(logging.INFO)
+
+# Create a file handler and set its level to DEBUG
+file_handler = logging.FileHandler("logfile_pynm.log")
+file_handler.setLevel(logging.INFO)
+
+# console_handler = logging.StreamHandler()
+# console_handler.setLevel(logging.DEBUG)
+
+# Create a formatter and add it to the handler
+formatter = logging.Formatter(
+    "%(asctime)s:%(levelname)s:%(name)s:%(filename)s:%(message)s"
+)
+file_handler.setFormatter(formatter)
+# console_handler.setFormatter(formatter)
+
+# Add the file handler to the logger
+logger.addHandler(file_handler)
+# logger.addHandler(console_handler)