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

py_neuromodulation/nm_bispectra.py

@@ -1,168 +0,0 @@
-from typing import Iterable
-import numpy as np
-from pybispectra import compute_fft, get_example_data_paths, WaveShape
-
-from py_neuromodulation import nm_features_abc
-
-
-class Bispectra(nm_features_abc.Feature):
-    def __init__(
-        self, settings: dict, ch_names: Iterable[str], sfreq: int | float
-    ) -> None:
-        super().__init__(settings, ch_names, sfreq)
-        self.sfreq = sfreq
-        self.ch_names = ch_names
-        self.s = settings
-        self.f1s = settings["bispectrum"]["f1s"]
-        self.f2s = settings["bispectrum"]["f2s"]
-
-    @staticmethod
-    def test_settings(
-        settings: dict,
-        ch_names: Iterable[str],
-        sfreq: int | float,
-    ):
-        s = settings
-
-        def test_range(f_name, filter_range):
-            assert isinstance(
-                filter_range[0],
-                int,
-            ), f"bispectrum frequency range {f_name} needs to be of type int, got {filter_range[0]}"
-            assert isinstance(
-                filter_range[1],
-                int,
-            ), f"bispectrum frequency range {f_name} needs to be of type int, got {filter_range[1]}"
-            assert (
-                filter_range[1] > filter_range[0]
-            ), f"second frequency range value needs to be higher than first one, got {filter_range}"
-            assert filter_range[0] < sfreq and filter_range[1] < sfreq, (
-                "filter frequency range has to be smaller than sfreq, "
-                f"got sfreq {sfreq} and filter range {filter_range}"
-            )
-
-        test_range("f1s", s["bispectrum"]["f1s"])
-        test_range("f2s", s["bispectrum"]["f2s"])
-
-        for feature_name, val in s["bispectrum"]["components"].items():
-            assert isinstance(
-                val, bool
-            ), f"bispectrum component {feature_name} has to be of type bool, got {val}"
-
-        for feature_name, val in s["bispectrum"]["bispectrum_features"].items():
-            assert isinstance(
-                val, bool
-            ), f"bispectrum feature {feature_name} has to be of type bool, got {val}"
-
-        assert (
-            f_band_bispectrum in s["frequency_ranges_hz"]
-            for f_band_bispectrum in s["bispectrum"]["frequency_bands"]
-        ), (
-            "bispectrum selected frequency bands don't match the ones"
-            "specified in s['frequency_ranges_hz']"
-            f"bispectrum frequency bands: {s['bispectrum']['frequency_bands']}"
-            f"specified frequency_ranges_hz: {s['frequency_ranges_hz']}"
-        )
-
-    def compute_bs_features(
-        self,
-        spectrum_ch: np.array,
-        features_compute: dict,
-        ch_name: str,
-        component: str,
-        f_band: str,
-    ) -> dict:
-        for bispectrum_feature in self.s["bispectrum"]["bispectrum_features"]:
-            if bispectrum_feature == "mean":
-                func = np.nanmean
-            if bispectrum_feature == "sum":
-                func = np.nansum
-            if bispectrum_feature == "var":
-                func = np.nanvar
-
-            if f_band is not None:
-                str_feature = "_".join(
-                    [
-                        ch_name,
-                        "Bispectrum",
-                        component,
-                        bispectrum_feature,
-                        f_band,
-                    ]
-                )
-            else:
-                str_feature = "_".join(
-                    [
-                        ch_name,
-                        "Bispectrum",
-                        component,
-                        bispectrum_feature,
-                        "whole_fband_range",
-                    ]
-                )
-
-            features_compute[str_feature] = func(spectrum_ch)
-
-        return features_compute
-
-    def calc_feature(self, data: np.array, features_compute: dict) -> dict:
-        for ch_idx, ch_name in enumerate(self.ch_names):
-            fft_coeffs, freqs = compute_fft(
-                data=np.expand_dims(data[ch_idx, :], axis=(0, 1)),
-                sampling_freq=self.sfreq,
-                n_points=data.shape[1],
-                verbose=False,
-            )
-
-            f_spectrum_range = freqs[
-                np.logical_and(
-                    freqs >= np.min([self.f1s, self.f2s]),
-                    freqs <= np.max([self.f1s, self.f2s]),
-                )
-            ]
-
-            waveshape = WaveShape(
-                data=fft_coeffs,
-                freqs=freqs,
-                sampling_freq=self.sfreq,
-                verbose=False,
-            )
-
-            waveshape.compute(
-                f1s=(self.f1s[0], self.f1s[-1]), f2s=(self.f2s[0], self.f2s[-1])
-            )
-
-            bispectrum = np.squeeze(waveshape.results._data)
-
-            for component in self.s["bispectrum"]["components"]:
-                if self.s["bispectrum"]["components"][component]:
-                    if component == "real":
-                        spectrum_ch = bispectrum.real
-                    if component == "imag":
-                        spectrum_ch = bispectrum.imag
-                    if component == "absolute":
-                        spectrum_ch = np.abs(bispectrum)
-                    if component == "phase":
-                        spectrum_ch = np.angle(bispectrum)
-
-                for fb in self.s["bispectrum"]["frequency_bands"]:
-                    range_ = (
-                        f_spectrum_range >= self.s["frequency_ranges_hz"][fb][0]
-                    ) & (
-                        f_spectrum_range <= self.s["frequency_ranges_hz"][fb][1]
-                    )
-                    # waveshape.results.plot()
-                    data_bs = spectrum_ch[range_, range_]
-
-                    features_compute = self.compute_bs_features(
-                        data_bs, features_compute, ch_name, component, fb
-                    )
-
-                if self.s["bispectrum"][
-                    "compute_features_for_whole_fband_range"
-                ]:
-                    features_compute = self.compute_bs_features(
-                        spectrum_ch, features_compute, ch_name, component, None
-                    )
-
-        return features_compute

py_neuromodulation/nm_bursts.py

@@ -1,198 +0,0 @@
-import enum
-import numpy as np
-from typing import Iterable
-from scipy import signal
-
-from py_neuromodulation import nm_features_abc, nm_filter
-
-
-class Burst(nm_features_abc.Feature):
-    def __init__(
-        self, settings: dict, ch_names: Iterable[str], sfreq: float
-    ) -> None:
-        self.s = settings
-        self.sfreq = sfreq
-        self.ch_names = ch_names
-        self.threshold = self.s["burst_settings"]["threshold"]
-        self.time_duration_s = self.s["burst_settings"]["time_duration_s"]
-        self.samples_overlap = int(
-            self.sfreq
-            * (self.s["segment_length_features_ms"] / 1000)
-            / self.s["sampling_rate_features_hz"]
-        )
-
-        self.fband_names = self.s["burst_settings"]["frequency_bands"]
-        self.f_ranges = [
-            self.s["frequency_ranges_hz"][fband_name]
-            for fband_name in self.fband_names
-        ]
-        self.seglengths = np.floor(
-            self.sfreq
-            / 1000
-            * np.array(
-                [
-                    self.s["bandpass_filter_settings"]["segment_lengths_ms"][
-                        fband
-                    ]
-                    for fband in self.fband_names
-                ]
-            )
-        ).astype(int)
-
-        self.num_max_samples_ring_buffer = int(
-            self.sfreq * self.time_duration_s
-        )
-
-        self.bandpass_filter = nm_filter.MNEFilter(
-            f_ranges=self.f_ranges,
-            sfreq=self.sfreq,
-            filter_length=self.sfreq - 1,
-            verbose=False,
-        )
-
-        # create dict with fband, channel specific data store
-        # for previous time_duration_s
-        def init_ch_fband_dict() -> dict:
-            d = {}
-            for ch in self.ch_names:
-                if ch not in d:
-                    d[ch] = {}
-                for fb in self.fband_names:
-                    if fb not in d[ch]:
-                        d[ch][fb] = None
-            return d
-
-        self.data_buffer = init_ch_fband_dict()
-
-    def test_settings(
-        settings: dict,
-        ch_names: Iterable[str],
-        sfreq: int | float,
-    ):
-        assert isinstance(
-            settings["burst_settings"]["threshold"], (float, int)
-        ), f"burst settings threshold needs to be type int or float, got: {settings['burst_settings']['threshold']}"
-        assert (
-            0 < settings["burst_settings"]["threshold"] < 100
-        ), f"burst setting threshold needs to be between 0 and 100, got: {settings['burst_settings']['threshold']}"
-        assert isinstance(
-            settings["burst_settings"]["time_duration_s"], (float, int)
-        ), f"burst settings time_duration_s needs to be type int or float, got: {settings['burst_settings']['time_duration_s']}"
-        assert (
-            settings["burst_settings"]["time_duration_s"] > 0
-        ), f"burst setting time_duration_s needs to be greater than 0, got: {settings['burst_settings']['time_duration_s']}"
-
-        for fband_burst in settings["burst_settings"]["frequency_bands"]:
-            assert fband_burst in list(
-                settings["frequency_ranges_hz"].keys()
-            ), f"bursting {fband_burst} needs to be defined in settings['frequency_ranges_hz']"
-
-        for burst_feature in settings["burst_settings"][
-            "burst_features"
-        ].keys():
-            assert isinstance(
-                settings["burst_settings"]["burst_features"][burst_feature],
-                bool,
-            ), (
-                f"bursting feature {burst_feature} needs to be type bool, "
-                f"got: {settings['burst_settings']['burst_features'][burst_feature]}"
-            )
-
-    def calc_feature(self, data: np.array, features_compute: dict) -> dict:
-        # filter_data returns (n_channels, n_fbands, n_samples)
-        filtered_data = np.abs(
-            signal.hilbert(self.bandpass_filter.filter_data(data), axis=2)
-        )
-        for ch_idx, ch_name in enumerate(self.ch_names):
-            for fband_idx, fband_name in enumerate(self.fband_names):
-                new_dat = filtered_data[ch_idx, fband_idx, :]
-                if self.data_buffer[ch_name][fband_name] is None:
-                    self.data_buffer[ch_name][fband_name] = new_dat
-                else:
-                    self.data_buffer[ch_name][fband_name] = np.concatenate(
-                        (
-                            self.data_buffer[ch_name][fband_name],
-                            new_dat[-self.samples_overlap :],
-                        ),
-                        axis=0,
-                    )[-self.num_max_samples_ring_buffer :]
-
-                # calc features
-                burst_thr = np.percentile(
-                    self.data_buffer[ch_name][fband_name], q=self.threshold
-                )
-
-                burst_amplitude, burst_length = self.get_burst_amplitude_length(
-                    new_dat, burst_thr, self.sfreq
-                )
-
-                features_compute[
-                    f"{ch_name}_bursts_{fband_name}_duration_mean"
-                ] = (np.mean(burst_length) if len(burst_length) != 0 else 0)
-                features_compute[
-                    f"{ch_name}_bursts_{fband_name}_amplitude_mean"
-                ] = (
-                    np.mean([np.mean(a) for a in burst_amplitude])
-                    if len(burst_length) != 0
-                    else 0
-                )
-
-                features_compute[
-                    f"{ch_name}_bursts_{fband_name}_duration_max"
-                ] = (np.max(burst_length) if len(burst_length) != 0 else 0)
-                features_compute[
-                    f"{ch_name}_bursts_{fband_name}_amplitude_max"
-                ] = (
-                    np.max([np.max(a) for a in burst_amplitude])
-                    if len(burst_amplitude) != 0
-                    else 0
-                )
-
-                features_compute[
-                    f"{ch_name}_bursts_{fband_name}_burst_rate_per_s"
-                ] = (
-                    np.mean(burst_length)
-                    / (self.s["segment_length_features_ms"] / 1000)
-                    if len(burst_length) != 0
-                    else 0
-                )
-
-                in_burst = False
-                if self.data_buffer[ch_name][fband_name][-1] > burst_thr:
-                    in_burst = True
-
-                features_compute[f"{ch_name}_bursts_{fband_name}_in_burst"] = (
-                    in_burst
-                )
-        return features_compute
-
-    @staticmethod
-    def get_burst_amplitude_length(
-        beta_averp_norm, burst_thr: float, sfreq: float
-    ):
-        """
-        Analysing the duration of beta burst
-        """
-        bursts = np.zeros((beta_averp_norm.shape[0] + 1), dtype=bool)
-        bursts[1:] = beta_averp_norm >= burst_thr
-        deriv = np.diff(bursts)
-        burst_length = []
-        burst_amplitude = []
-
-        burst_time_points = np.where(deriv == True)[0]
-
-        for i in range(burst_time_points.size // 2):
-            burst_length.append(
-                burst_time_points[2 * i + 1] - burst_time_points[2 * i]
-            )
-            burst_amplitude.append(
-                beta_averp_norm[
-                    burst_time_points[2 * i] : burst_time_points[2 * i + 1]
-                ]
-            )
-
-        # the last burst length (in case isburst == True) is omitted,
-        # since the true burst length cannot be estimated
-        burst_length = np.array(burst_length) / sfreq
-
-        return burst_amplitude, burst_length

py_neuromodulation/nm_coherence.py

@@ -1,205 +0,0 @@
-from scipy import signal
-import numpy as np
-from typing import Iterable
-import warnings
-
-from py_neuromodulation import nm_features_abc
-
-
-class CoherenceObject:
-    def __init__(
-        self,
-        sfreq,
-        window,
-        fbands,
-        fband_names,
-        ch_1_name,
-        ch_2_name,
-        ch_1_idx,
-        ch_2_idx,
-        coh,
-        icoh,
-        features_coh,
-    ) -> None:
-        self.sfreq = sfreq
-        self.window = window
-        self.Pxx = None
-        self.Pyy = None
-        self.Pxy = None
-        self.f = None
-        self.coh = coh
-        self.icoh = icoh
-        self.coh_val = None
-        self.icoh_val = None
-        self.ch_1 = ch_1_name
-        self.ch_2 = ch_2_name
-        self.ch_1_idx = ch_1_idx
-        self.ch_2_idx = ch_2_idx
-        self.fbands = fbands  # list of lists, e.g. [[10, 15], [15, 20]]
-        self.fband_names = fband_names
-        self.features_coh = features_coh
-
-    def get_coh(self, features_compute, x, y):
-        self.f, self.Pxx = signal.welch(x, self.sfreq, self.window, nperseg=128)
-        self.Pyy = signal.welch(y, self.sfreq, self.window, nperseg=128)[1]
-        self.Pxy = signal.csd(x, y, self.sfreq, self.window, nperseg=128)[1]
-
-        if self.coh is True:
-            self.coh_val = np.abs(self.Pxy**2) / (self.Pxx * self.Pyy)
-        if self.icoh is True:
-            self.icoh_val = np.array(self.Pxy / (self.Pxx * self.Pyy)).imag
-
-        for coh_idx, coh_type in enumerate([self.coh, self.icoh]):
-            if coh_type is True:
-                if coh_idx == 0:
-                    coh_val = self.coh_val
-                    coh_name = "coh"
-                else:
-                    coh_val = self.icoh_val
-                    coh_name = "icoh"
-
-            for idx, fband in enumerate(self.fbands):
-                if self.features_coh["mean_fband"] is True:
-                    feature_calc = np.mean(
-                        coh_val[
-                            np.bitwise_and(self.f > fband[0], self.f < fband[1])
-                        ]
-                    )
-                    feature_name = "_".join(
-                        [
-                            coh_name,
-                            self.ch_1,
-                            "to",
-                            self.ch_2,
-                            "mean_fband",
-                            self.fband_names[idx],
-                        ]
-                    )
-                    features_compute[feature_name] = feature_calc
-                if self.features_coh["max_fband"] is True:
-                    feature_calc = np.max(
-                        coh_val[
-                            np.bitwise_and(self.f > fband[0], self.f < fband[1])
-                        ]
-                    )
-                    feature_name = "_".join(
-                        [
-                            coh_name,
-                            self.ch_1,
-                            "to",
-                            self.ch_2,
-                            "max_fband",
-                            self.fband_names[idx],
-                        ]
-                    )
-                    features_compute[feature_name] = feature_calc
-            if self.features_coh["max_allfbands"] is True:
-                feature_calc = self.f[np.argmax(coh_val)]
-                feature_name = "_".join(
-                    [
-                        coh_name,
-                        self.ch_1,
-                        "to",
-                        self.ch_2,
-                        "max_allfbands",
-                        self.fband_names[idx],
-                    ]
-                )
-                features_compute[feature_name] = feature_calc
-        return features_compute
-
-
-class NM_Coherence(nm_features_abc.Feature):
-
-    
-
-    def __init__(
-        self, settings: dict, ch_names: Iterable[str], sfreq: float
-    ) -> None:
-        self.s = settings
-        self.sfreq = sfreq
-        self.ch_names = ch_names
-        self.coherence_objects: Iterable[CoherenceObject] = []
-
-        for idx_coh in range(len(self.s["coherence"]["channels"])):
-            fband_names = self.s["coherence"]["frequency_bands"]
-            fband_specs = []
-            for band_name in fband_names:
-                fband_specs.append(self.s["frequency_ranges_hz"][band_name])
-
-            ch_1_name = self.s["coherence"]["channels"][idx_coh][0]
-            ch_1_name_reref = [
-                ch for ch in self.ch_names if ch.startswith(ch_1_name)
-            ][0]
-            ch_1_idx = self.ch_names.index(ch_1_name_reref)
-
-            ch_2_name = self.s["coherence"]["channels"][idx_coh][1]
-            ch_2_name_reref = [
-                ch for ch in self.ch_names if ch.startswith(ch_2_name)
-            ][0]
-            ch_2_idx = self.ch_names.index(ch_2_name_reref)
-
-            self.coherence_objects.append(
-                CoherenceObject(
-                    sfreq,
-                    "hann",
-                    fband_specs,
-                    fband_names,
-                    ch_1_name,
-                    ch_2_name,
-                    ch_1_idx,
-                    ch_2_idx,
-                    self.s["coherence"]["method"]["coh"],
-                    self.s["coherence"]["method"]["icoh"],
-                    self.s["coherence"]["features"],
-                )
-            )
-
-    @staticmethod
-    def test_settings(
-        s: dict,
-        ch_names: Iterable[str],
-        sfreq: int | float,
-    ):
-
-        assert (
-            len(s["coherence"]["frequency_bands"]) > 0
-        ), "coherence frequency_bands list needs to specify at least one frequency band"
-        assert (ch_coh in ch_names for ch_coh in s["coherence"]["channels"]), (
-            f"coherence selected channels don't match the ones in nm_channels"
-            f"ch_names: {ch_names} settings['coherence']['channels']: {s['coherence']['channels']}"
-        )
-
-        assert (
-            f_band_coh in s["frequency_ranges_hz"]
-            for f_band_coh in s["coherence"]["frequency_bands"]
-        ), (
-            "coherence selected frequency bands don't match the ones"
-            "specified in s['frequency_ranges_hz']"
-            f"coherence frequency bands: {s['coherence']['frequency_bands']}"
-            f"specified frequency_ranges_hz: {s['frequency_ranges_hz']}"
-        )
-
-        assert (
-            s["frequency_ranges_hz"][fb][0] < sfreq / 2
-            and s["frequency_ranges_hz"][fb][1] < sfreq / 2
-            for fb in s["coherence"]["frequency_bands"]
-        ), (
-            "the coherence frequency band ranges need to be smaller than the nyquist frequency"
-            f"got sfreq = {sfreq} and fband ranges {s['coherence']['frequency_bands']}"
-        )
-
-        if sum(list(s["coherence"]["method"].values())) == 0:
-            warnings.warn(
-                "feature coherence enabled, but no coherence['method'] selected"
-            )
-
-    def calc_feature(self, data: np.array, features_compute: dict) -> dict:
-        for coh_obj in self.coherence_objects:
-            features_compute = coh_obj.get_coh(
-                features_compute,
-                data[coh_obj.ch_1_idx, :],
-                data[coh_obj.ch_2_idx, :],
-            )
-
-        return features_compute