py-neuromodulation 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

py_neuromodulation/nm_hjorth_raw.py

@@ -1,73 +0,0 @@
-import enum
-import numpy as np
-from typing import Iterable
-
-from py_neuromodulation import nm_features_abc
-
-
-class Hjorth(nm_features_abc.Feature):
-    def __init__(
-        self, settings: dict, ch_names: Iterable[str], sfreq: float
-    ) -> None:
-        self.s = settings
-        self.ch_names = ch_names
-
-    @staticmethod
-    def test_settings(
-        settings: dict,
-        ch_names: Iterable[str],
-        sfreq: int | float,
-    ):
-        # no settings to test
-        pass
-
-    def calc_feature(self, data: np.array, features_compute: dict) -> dict:
-        for ch_idx, ch_name in enumerate(self.ch_names):
-            features_compute[
-                "_".join([ch_name, "RawHjorth_Activity"])
-            ] = np.nan_to_num(np.var(data[ch_idx, :]))
-            deriv_variance = np.nan_to_num(np.var(np.diff(data[ch_idx, :])))
-            mobility = np.nan_to_num(
-                np.sqrt(deriv_variance / np.var(data[ch_idx, :]))
-            )
-            features_compute[
-                "_".join([ch_name, "RawHjorth_Mobility"])
-            ] = mobility
-
-            dat_deriv_2_var = np.nan_to_num(
-                np.var(np.diff(np.diff(data[ch_idx, :])))
-            )
-            deriv_mobility = np.nan_to_num(
-                np.sqrt(dat_deriv_2_var / deriv_variance)
-            )
-            features_compute[
-                "_".join([ch_name, "RawHjorth_Complexity"])
-            ] = np.nan_to_num(deriv_mobility / mobility)
-
-        return features_compute
-
-
-class Raw(nm_features_abc.Feature):
-    def __init__(
-        self, settings: dict, ch_names: Iterable[str], sfreq: float
-    ) -> None:
-        self.ch_names = ch_names
-
-    def calc_feature(
-        self,
-        data: np.array,
-        features_compute: dict,
-    ) -> dict:
-        for ch_idx, ch_name in enumerate(self.ch_names):
-            features_compute["_".join([ch_name, "raw"])] = data[ch_idx, -1]
-
-        return features_compute
-
-    @staticmethod
-    def test_settings(
-        settings: dict,
-        ch_names: Iterable[str],
-        sfreq: int | float,
-    ):
-        # no settings to test
-        pass

py_neuromodulation/nm_kalmanfilter.py

@@ -1,58 +0,0 @@
-from numpy import array, cov
-from typing import Iterable
-
-from filterpy.kalman import KalmanFilter
-
-
-def define_KF(Tp, sigma_w, sigma_v):
-    """Define Kalman filter according to white noise acceleration model.
-    See DOI: 10.1109/TBME.2009.2038990  for explanation
-    See https://filterpy.readthedocs.io/en/latest/kalman/KalmanFilter.html#r64ca38088676-2 for implementation details
-
-    Parameters
-    ----------
-    Tp : float
-        prediction interval
-    sigma_w : float
-        process noise
-    sigma_v : float
-        measurement noise
-
-    Returns
-    -------
-    filterpy.KalmanFilter
-        initialized KalmanFilter object
-    """
-
-    f = KalmanFilter(dim_x=2, dim_z=1)
-    f.x = array([0, 1])  # x here sensor signal and it's first derivative
-    f.F = array([[1, Tp], [0, 1]])
-    f.H = array([[1, 0]])
-    f.R = sigma_v
-    f.Q = array([[(sigma_w**2)*(Tp**3)/3, (sigma_w**2)*(Tp**2)/2],
-                 [(sigma_w**2)*(Tp**2)/2, (sigma_w**2)*Tp]])
-    f.P = cov([[1, 0], [0, 1]])
-    return f
-
-def test_kf_settings(
-        s: dict,
-        ch_names: Iterable[str],
-        sfreq: int | float,
-    ):
-        assert isinstance(s["kalman_filter_settings"]["Tp"], (float, int))
-        assert isinstance(s["kalman_filter_settings"]["sigma_w"], (float, int))
-        assert isinstance(s["kalman_filter_settings"]["sigma_v"], (float, int))
-        assert s["kalman_filter_settings"][
-            "frequency_bands"
-        ], "No frequency bands specified for Kalman filter."
-        assert isinstance(
-            s["kalman_filter_settings"]["frequency_bands"], list
-        ), "Frequency bands for Kalman filter must be specified as a list."
-        assert (
-            item
-            in s["frequency_ranges_hz"].values()
-            for item in s["kalman_filter_settings"]["frequency_bands"]
-        ), (
-            "Frequency bands for Kalman filter must also be specified in "
-            "bandpass_filter_settings."
-        )

py_neuromodulation/nm_linelength.py

@@ -1,33 +0,0 @@
-import numpy as np
-from typing import Iterable
-
-from py_neuromodulation import nm_features_abc
-
-
-class LineLength(nm_features_abc.Feature):
-    def __init__(
-        self, settings: dict, ch_names: Iterable[str], sfreq: float
-    ) -> None:
-        self.s = settings
-        self.ch_names = ch_names
-
-    @staticmethod
-    def get_line_length(x: np.ndarray) -> np.ndarray:
-        return np.mean(np.abs(np.diff(x)) / (x.shape[0] - 1))
-
-    @staticmethod
-    def test_settings(
-        settings: dict,
-        ch_names: Iterable[str],
-        sfreq: int | float,
-    ):
-        # no settings to be checked
-        pass
-
-    def calc_feature(self, data: np.ndarray, features_compute: dict) -> dict:
-        for ch_idx, ch_name in enumerate(self.ch_names):
-            features_compute[
-                "_".join([ch_name, "LineLength"])
-            ] = self.get_line_length(data[ch_idx, :])
-
-        return features_compute

py_neuromodulation/nm_mne_connectivity.py

@@ -1,112 +0,0 @@
-from typing import Iterable
-import numpy as np
-
-import mne
-from mne_connectivity import spectral_connectivity_epochs
-
-from py_neuromodulation import nm_features_abc
-
-
-class MNEConnectivity(nm_features_abc.Feature):
-    def __init__(
-        self,
-        settings: dict,
-        ch_names: Iterable[str],
-        sfreq: float,
-    ) -> None:
-        self.s = settings
-        self.ch_names = ch_names
-        self.mode = settings["mne_connectiviy"]["mode"]
-        self.method = settings["mne_connectiviy"]["method"]
-        self.sfreq = sfreq
-
-        self.fbands = list(self.s["frequency_ranges_hz"].keys())
-        self.fband_ranges = []
-
-    @staticmethod
-    def test_settings(
-        settings: dict,
-        ch_names: Iterable[str],
-        sfreq: int | float,
-    ):
-        # TODO: Double check passed parameters with mne_connectivity
-        pass
-
-    @staticmethod
-    def get_epoched_data(
-        raw: mne.io.RawArray, epoch_length: float = 1
-    ) -> np.array:
-        time_samples_s = raw.get_data().shape[1] / raw.info["sfreq"]
-        if epoch_length > time_samples_s:
-             raise ValueError(
-                f"the intended epoch length for mne connectivity: {epoch_length}s"
-                f" are longer than the passed data array {np.round(time_samples_s, 2)}s"
-             )
-        events = mne.make_fixed_length_events(
-            raw, duration=epoch_length, overlap=0
-        )
-        event_id = {"rest": 1}
-
-        epochs = mne.Epochs(
-            raw,
-            events=events,
-            event_id=event_id,
-            tmin=0,
-            tmax=epoch_length,
-            baseline=None,
-            reject_by_annotation=True,
-        )
-        if epochs.events.shape[0] < 2:
-            raise Exception(
-                f"A minimum of 2 epochs is required for mne_connectivity,"
-                f" got only {epochs.events.shape[0]}. Increase settings['segment_length_features_ms']"
-            )
-        return epochs
-
-    def estimate_connectivity(self, epochs: mne.Epochs):
-        # n_jobs is here kept to 1, since setup of the multiprocessing Pool 
-        # takes longer than most batch computing sizes
-
-        spec_out = spectral_connectivity_epochs(
-            data=epochs,
-            sfreq=self.sfreq,
-            n_jobs=1,
-            method=self.method,
-            mode=self.mode,
-            indices=(np.array([0, 0, 1, 1]), np.array([2, 3, 2, 3])),
-            faverage=False,
-            block_size=1000,
-        )
-        return spec_out
-
-    def calc_feature(self, data: np.array, features_compute: dict) -> dict:
-
-        raw = mne.io.RawArray(
-            data=data,
-            info=mne.create_info(ch_names=self.ch_names, sfreq=self.sfreq),
-        )
-        epochs = self.get_epoched_data(raw)
-        # there need to be minimum 2 of two epochs, otherwise mne_connectivity 
-        # is not correctly initialized
-
-        spec_out = self.estimate_connectivity(epochs)
-        if len(self.fband_ranges) == 0:
-            for fband in self.fbands:
-                self.fband_ranges.append(
-                    np.where(
-                        np.logical_and(
-                            np.array(spec_out.freqs)
-                            > self.s["frequency_ranges_hz"][fband][0],
-                            np.array(spec_out.freqs)
-                            < self.s["frequency_ranges_hz"][fband][1],
-                        )
-                    )[0]
-                )
-        dat_conn = spec_out.get_data()
-        for conn in np.arange(dat_conn.shape[0]):
-            for fband_idx, fband in enumerate(self.fbands):
-                features_compute[
-                    "_".join(["ch1", self.method, str(conn), fband])
-                ] = np.mean(dat_conn[conn, self.fband_ranges[fband_idx]])
-
-        return features_compute

py_neuromodulation/nm_nolds.py

@@ -1,93 +0,0 @@
-import numpy as np
-from typing import Iterable
-import nolds
-import warnings
-
-from py_neuromodulation import nm_features_abc, nm_oscillatory
-
-
-class Nolds(nm_features_abc.Feature):
-    def __init__(
-        self, settings: dict, ch_names: Iterable[str], sfreq: float
-    ) -> None:
-        self.s = settings
-        self.ch_names = ch_names
-
-        if len(self.s["nolds_features"]["data"]["frequency_bands"]) > 0:
-            self.bp_filter = nm_oscillatory.BandPower(
-                settings, ch_names, sfreq, use_kf=False
-            )
-
-    @staticmethod
-    def test_settings(
-        s: dict,
-        ch_names: Iterable[str],
-        sfreq: int | float,
-    ):
-        nolds_feature_cols = [
-            "sample_entropy",
-            "correlation_dimension",
-            "lyapunov_exponent",
-            "hurst_exponent",
-            "detrended_fluctutaion_analysis",
-        ]
-        if sum([s["nolds_features"][f] for f in nolds_feature_cols]) == 0:
-            warnings.warn(
-                "nolds feature enabled, but no nolds_feature type selected"
-            )
-
-        for fb in s["nolds_features"]["data"]["frequency_bands"]:
-            assert fb in list(
-                s["frequency_ranges_hz"].keys()
-            ), f"{fb} selected in nolds_features, but not defined in s['frequency_ranges_hz']"
-
-    def calc_feature(
-        self,
-        data: np.array,
-        features_compute: dict,
-    ) -> dict:
-
-        data = np.nan_to_num(data)
-        if self.s["nolds_features"]["data"]["raw"]:
-            features_compute = self.calc_nolds(data, features_compute)
-        if len(self.s["nolds_features"]["data"]["frequency_bands"]) > 0:
-            data_filt = self.bp_filter.bandpass_filter.filter_data(data)
-
-            for f_band_idx, f_band in enumerate(
-                self.s["nolds_features"]["data"]["frequency_bands"]
-            ):
-                # filter data now for a specific fband and pass to calc_nolds
-                features_compute = self.calc_nolds(
-                    data_filt[:, f_band_idx, :], features_compute, f_band
-                )  # ch, bands, samples
-        return features_compute
-
-    def calc_nolds(
-        self, data: np.array, features_compute: dict, data_str: str = "raw"
-    ) -> dict:
-
-        for ch_idx, ch_name in enumerate(self.ch_names):
-            dat = data[ch_idx, :]
-            empty_arr = dat.sum() == 0
-            if self.s["nolds_features"]["sample_entropy"]:
-                features_compute[
-                    f"{ch_name}_nolds_sample_entropy"
-                ] = nolds.sampen(dat) if not empty_arr else 0
-            if self.s["nolds_features"]["correlation_dimension"]:
-                features_compute[
-                    f"{ch_name}_nolds_correlation_dimension_{data_str}"
-                ] = nolds.corr_dim(dat, emb_dim=2) if not empty_arr else 0
-            if self.s["nolds_features"]["lyapunov_exponent"]:
-                features_compute[
-                    f"{ch_name}_nolds_lyapunov_exponent_{data_str}"
-                ] = nolds.lyap_r(dat) if not empty_arr else 0
-            if self.s["nolds_features"]["hurst_exponent"]:
-                features_compute[
-                    f"{ch_name}_nolds_hurst_exponent_{data_str}"
-                ] = nolds.hurst_rs(dat) if not empty_arr else 0
-            if self.s["nolds_features"]["detrended_fluctutaion_analysis"]:
-                features_compute[
-                    f"{ch_name}_nolds_detrended_fluctutaion_analysis_{data_str}"
-                ] = nolds.dfa(dat) if not empty_arr else 0
-
-        return features_compute

py_neuromodulation/nm_normalization.py

@@ -1,214 +0,0 @@
-"""Module for real-time data normalization."""
-from enum import Enum
-
-from sklearn import preprocessing
-import numpy as np
-class NORM_METHODS(Enum):
-    MEAN = "mean"
-    MEDIAN = "median"
-    ZSCORE = "zscore"
-    ZSCORE_MEDIAN = "zscore-median"
-    QUANTILE = "quantile"
-    POWER = "power"
-    ROBUST = "robust"
-    MINMAX = "minmax"
-
-
-def test_normalization_settings(
-    normalization_time_s: int | float, normalization_method: str, clip: bool
-):
-    assert isinstance(
-        normalization_time_s,
-        (float, int),
-    )
-
-    assert isinstance(
-        normalization_method, str
-    ), "normalization method needs to be of type string"
-
-    assert normalization_method in [e.value for e in NORM_METHODS], (
-        f"select a valid normalization method, got {normalization_method}, "
-        f"valid options are {[e.value for e in NORM_METHODS]}"
-    )
-
-    assert isinstance(clip, (float, int, bool))
-
-
-class RawNormalizer:
-    def __init__(
-        self,
-        sfreq: int | float,
-        sampling_rate_features_hz: int,
-        normalization_method: str = "zscore",
-        normalization_time_s: int | float = 30,
-        clip: bool | int | float = False,
-    ) -> None:
-        """Normalize raw data.
-
-        normalize_samples : int
-            number of past samples considered for normalization
-        sample_add : int
-            number of samples to add to previous
-        method : str | default is 'mean'
-            data is normalized via subtraction of the 'mean' or 'median' and
-            subsequent division by the 'mean' or 'median'. For z-scoring enter
-            'zscore'.
-        clip : int | float, optional
-            value at which to clip after normalization
-        """
-
-        test_normalization_settings(normalization_time_s, normalization_method, clip)
-
-        self.method = normalization_method
-        self.clip = clip
-        self.num_samples_normalize = int(normalization_time_s * sfreq)
-        self.add_samples = int(sfreq / sampling_rate_features_hz)
-        self.previous = None
-
-    def process(self, data: np.ndarray) -> np.ndarray:
-        data = data.T
-        if self.previous is None:
-            self.previous = data
-            return data.T
-
-        self.previous = np.vstack((self.previous, data[-self.add_samples :]))
-
-        data, self.previous = _normalize_and_clip(
-            current=data,
-            previous=self.previous,
-            method=self.method,
-            clip=self.clip,
-            description="raw",
-        )
-        if self.previous.shape[0] >= self.num_samples_normalize:
-            self.previous = self.previous[1:]
-
-        return data.T
-
-
-class FeatureNormalizer:
-    def __init__(
-        self,
-        sampling_rate_features_hz: int,
-        normalization_method: str = "zscore",
-        normalization_time_s: int | float = 30,
-        clip: bool | int | float = False,
-    ) -> None:
-        """Normalize raw data.
-
-        normalize_samples : int
-            number of past samples considered for normalization
-        sample_add : int
-            number of samples to add to previous
-        method : str | default is 'mean'
-            data is normalized via subtraction of the 'mean' or 'median' and
-            subsequent division by the 'mean' or 'median'. For z-scoring enter
-            'zscore'.
-        clip : int | float, optional
-            value at which to clip after normalization
-        """
-
-        test_normalization_settings(normalization_time_s, normalization_method, clip)
-
-        self.method = normalization_method
-        self.clip = clip
-        self.num_samples_normalize = int(
-            normalization_time_s * sampling_rate_features_hz
-        )
-        self.previous = None
-
-    def process(self, data: np.ndarray) -> np.ndarray:
-        if self.previous is None:
-            self.previous = data
-            return data
-
-        self.previous = np.vstack((self.previous, data))
-
-        data, self.previous = _normalize_and_clip(
-            current=data,
-            previous=self.previous,
-            method=self.method,
-            clip=self.clip,
-            description="feature",
-        )
-        if self.previous.shape[0] >= self.num_samples_normalize:
-            self.previous = self.previous[1:]
-
-        return data
-
-"""
-Functions to check for NaN's before deciding which Numpy function to call
-"""
-def nan_mean(data, axis):
-    return np.nanmean(data, axis=axis) if np.any(np.isnan(sum(data))) else np.mean(data, axis=axis)
-
-def nan_std(data, axis):
-    return np.nanstd(data, axis=axis) if np.any(np.isnan(sum(data))) else np.std(data, axis=axis)
-
-def nan_median(data, axis):
-    return np.nanmedian(data, axis=axis) if np.any(np.isnan(sum(data))) else np.median(data, axis=axis)
-
-def _normalize_and_clip(
-    current: np.ndarray,
-    previous: np.ndarray,
-    method: str,
-    clip: int | float | bool,
-    description: str,
-) -> tuple[np.ndarray, np.ndarray]:
-    """Normalize data."""
-    match method:
-        case NORM_METHODS.MEAN.value:
-            mean = nan_mean(previous, axis=0)
-            current = (current - mean) / mean
-        case NORM_METHODS.MEDIAN.value:
-            median = nan_median(previous, axis=0)
-            current = (current - median) / median
-        case NORM_METHODS.ZSCORE.value:
-            current = (current - nan_mean(previous, axis=0)) / nan_std(previous, axis=0)
-        case NORM_METHODS.ZSCORE_MEDIAN.value:
-            current = (current - nan_median(previous, axis=0)) / nan_std(previous, axis=0)
-        # For the following methods we check for the shape of current
-        # when current is a 1D array, then it is the post-processing normalization,
-        # and we need to expand, and remove the extra dimension afterwards
-        # When current is a 2D array, then it is pre-processing normalization, and
-        # there's no need for expanding.
-        case (NORM_METHODS.QUANTILE.value | 
-              NORM_METHODS.ROBUST.value | 
-              NORM_METHODS.MINMAX.value | 
-              NORM_METHODS.POWER.value):
-            
-            norm_methods = {
-                NORM_METHODS.QUANTILE.value : lambda: preprocessing.QuantileTransformer(n_quantiles=300),
-                NORM_METHODS.ROBUST.value : preprocessing.RobustScaler,
-                NORM_METHODS.MINMAX.value : preprocessing.MinMaxScaler,
-                NORM_METHODS.POWER.value : preprocessing.PowerTransformer
-            }
-                
-            current = (
-                norm_methods[method]()
-                .fit(np.nan_to_num(previous))
-                .transform(
-                    # if post-processing: pad dimensions to 2
-                    np.reshape(current, (2-len(current.shape))*(1,) + current.shape)
-                    )
-                .squeeze() # if post-processing: remove extra dimension
-            )
-            
-        case _:
-            raise ValueError(
-                f"Only {[e.value for e in NORM_METHODS]} are supported as "
-                f"{description} normalization methods. Got {method}."
-            )
-
-    if clip:
-        current = _clip(data=current, clip=clip)
-    return current, previous
-
-
-def _clip(data: np.ndarray, clip: bool | int | float) -> np.ndarray:
-    """Clip data."""
-    if clip is True:
-        clip = 3.0  # default value
-    else:
-        clip = float(clip)
-    return np.nan_to_num(data).clip(min=-clip, max=clip)