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

py_neuromodulation/nm_RMAP.py

@@ -1,14 +1,304 @@
-import enum
-import nibabel as nib
 import numpy as np
 import os
-#from numba import jit
+import wget
+
+
+# from numba import jit
 from scipy import stats
+import scipy.io as sio
 import pandas as pd
+from typing import Union, Tuple, List
+import nibabel as nib
+from matplotlib import pyplot as plt
+
+import py_neuromodulation
 
 from py_neuromodulation import nm_plots
 
-class RMAPChannelSelector:
+LIST_STRUC_UNCONNECTED_GRIDPOINTS_HULL = [256, 385, 417, 447, 819, 914]
+LIST_STRUC_UNCONNECTED_GRIDPOINTS_WHOLEBRAIN = [
+    1,
+    8,
+    16,
+    33,
+    34,
+    35,
+    36,
+    37,
+    51,
+    75,
+    77,
+    78,
+    99,
+    109,
+    115,
+    136,
+    155,
+    170,
+    210,
+    215,
+    243,
+    352,
+    359,
+    361,
+    415,
+    416,
+    422,
+    529,
+    567,
+    569,
+    622,
+    623,
+    625,
+    627,
+    632,
+    633,
+    634,
+    635,
+    639,
+    640,
+    641,
+    643,
+    644,
+    650,
+    661,
+    663,
+    667,
+    683,
+    684,
+    685,
+    704,
+    708,
+    722,
+    839,
+    840,
+    905,
+    993,
+    1011,
+]
+
+
+class ConnectivityChannelSelector:
+
+    def __init__(
+        self,
+        whole_brain_connectome: bool = True,
+        func_connectivity: bool = True,
+    ) -> None:
+        """ConnectivityChannelSelector
+
+        Parameters
+        ----------
+        whole_brain_connectome : bool, optional
+            if True a 1236 whole-brain point grid is chosen,
+            if False, a 1025 point grid of the cortical hull is loaded,
+            by default True
+        func_connectivity : bool, optional
+            if true, functional connectivity fMRI is loaded,
+            if false structural dMRIby, default True
+        """
+
+        self.connectome_name = self._get_connectome_name(
+            whole_brain_connectome, func_connectivity
+        )
+
+        self.whole_brain_connectome = whole_brain_connectome
+        self.func_connectivity = func_connectivity
+
+        self.PATH_CONN_DECODING = os.path.join(
+            py_neuromodulation.__path__[0],
+            "ConnectivityDecoding",
+        )
+
+        if whole_brain_connectome:
+            self.PATH_GRID = os.path.join(
+                self.PATH_CONN_DECODING,
+                "mni_coords_whole_brain.mat",
+            )
+            self.grid = sio.loadmat(self.PATH_GRID)["downsample_ctx"]
+            if func_connectivity is False:
+                # reduce the grid to only valid points that are not in LIST_STRUC_UNCONNECTED_GRIDPOINTS_WHOLEBRAIN
+                self.grid = np.delete(
+                    self.grid,
+                    LIST_STRUC_UNCONNECTED_GRIDPOINTS_WHOLEBRAIN,
+                    axis=0,
+                )
+        else:
+            self.PATH_GRID = os.path.join(
+                self.PATH_CONN_DECODING,
+                "mni_coords_cortical_surface.mat",
+            )
+            self.grid = sio.loadmat(self.PATH_GRID)["downsample_ctx"]
+            if func_connectivity is False:
+                # reduce the grid to only valid points that are not in LIST_STRUC_UNCONNECTED_GRIDPOINTS_HULL
+                self.grid = np.delete(
+                    self.grid, LIST_STRUC_UNCONNECTED_GRIDPOINTS_HULL, axis=0
+                )
+
+        if func_connectivity:
+            self.RMAP_arr = nib.load(
+                os.path.join(self.PATH_CONN_DECODING, "RMAP_func_all.nii")
+            ).get_fdata()
+        else:
+            self.RMAP_arr = nib.load(
+                os.path.join(self.PATH_CONN_DECODING, "RMAP_struc.nii")
+            ).get_fdata()
+
+    def _get_connectome_name(
+        self, whole_brain_connectome: str, func_connectivity: str
+    ):
+
+        connectome_name = "connectome_"
+        if whole_brain_connectome:
+            connectome_name += "whole_brain_"
+        else:
+            connectome_name += "hull_"
+        if func_connectivity:
+            connectome_name += "func"
+        else:
+            connectome_name += "struc"
+        return connectome_name
+
+    def get_available_connectomes(self) -> list:
+        """Return list of saved connectomes in the
+        package folder/ConnectivityDecoding/connectome_folder/ folder.
+
+        Returns
+        -------
+        list_connectomes: list
+        """
+        return os.listdir(
+            os.path.join(
+                self.PATH_CONN_DECODING,
+                "connectome_folder",
+            )
+        )
+
+    def plot_grid(self) -> None:
+        """Plot the loaded template grid that passed coordinates are matched to."""
+
+        fig = plt.figure()
+        ax = fig.add_subplot(111, projection="3d")
+        ax.scatter(
+            self.grid[:, 0], self.grid[:, 1], self.grid[:, 2], s=50, alpha=0.2
+        )
+        plt.show()
+
+    def get_closest_node(
+        self, coord: Union[List, np.array]
+    ) -> Tuple[List, List]:
+        """Given a list or np.array of coordinates, return the closest nodes in the
+        grid and their indices.
+
+        Parameters
+        ----------
+        coord : np.array
+            MNI coordinates with shape (num_channels, 3)
+
+        Returns
+        -------
+        Tuple[List, List]
+            Grid coordinates, grid indices
+        """
+
+        idx_ = []
+        for c in coord:
+            dist = np.linalg.norm(self.grid - c, axis=1)
+            idx_.append(np.argmin(dist))
+
+        return [self.grid[idx] for idx in idx_], idx_
+
+    def get_rmap_correlations(
+        self, fps: Union[list, np.array], RMAP_use: np.array = None
+    ) -> List:
+        """Calculate correlations of passed fingerprints with the RMAP
+
+        Parameters
+        ----------
+        fps : Union[list, np.array]
+            List of fingerprints
+        RMAP_use : np.array, optional
+            Passed RMAP, by default None
+
+        Returns
+        -------
+        List
+            correlation values
+        """
+
+        RMAP_ = self.RMAP_arr if RMAP_use is None else RMAP_use
+        RMAP_ = RMAP_.flatten()
+        corrs = []
+        for fp in fps:
+            corrs.append(np.corrcoef(RMAP_, fp.flatten())[0][1])
+        return corrs
+
+    def load_connectome(
+        self,
+        whole_brain_connectome: bool = None,
+        func_connectivity: bool = None,
+    ) -> None:
+        """Load connectome, if not available download connectome from
+        Zenodo.
+
+        Parameters
+        ----------
+        whole_brain_connectome : bool, optional
+            if true whole brain connectome
+            if false cortical hull grid connectome, by default None
+        func_connectivity : bool, optional
+            if true fMRI if false dMRI, by default None
+        """
+
+        if whole_brain_connectome is not None:
+            self.whole_brain_connectome = whole_brain_connectome
+        if func_connectivity is not None:
+            self.func_connectivity = func_connectivity
+
+        self.connectome_name = self._get_connectome_name(
+            self.whole_brain_connectome, self.func_connectivity
+        )
+
+        PATH_CONNECTOME = os.path.join(
+            self.PATH_CONN_DECODING,
+            "connectome_folder",
+            self.connectome_name + ".mat",
+        )
+
+        if os.path.exists(PATH_CONNECTOME) is False:
+            user_input = input(
+                "Do you want to download the connectome? (yes/no): "
+            ).lower()
+            if user_input == "yes":
+                self._download_connectome()
+            elif user_input == "no":
+                print("Connectome missing, has to be downloaded")
+
+        self.connectome = sio.loadmat(PATH_CONNECTOME)
+
+    def get_grid_fingerprints(self, grid_idx: Union[list, np.array]) -> list:
+        return [self.connectome[str(grid_idx)] for grid_idx in grid_idx]
+
+    def download_connectome(
+        self,
+    ):
+        # download the connectome from the Zenodo API
+        print("Downloading the connectome...")
+
+        record_id = "10804702"
+        file_name = self.connectome_name
+
+        wget.download(
+            f"https://zenodo.org/api/records/{record_id}/files/{file_name}/content",
+            out=os.path.join(
+                self.PATH_CONN_DECODING,
+                "connectome_folder",
+                f"{self.connectome_name}.mat",
+            ),
+        )
+
+
+class RMAPCross_Val_ChannelSelector:
 
     def __init__(self) -> None:
         pass
@@ -90,7 +380,7 @@ class RMAPChannelSelector:
         return r
 
     @staticmethod
-    #@jit(nopython=True)
+    # @jit(nopython=True)
     def calculate_RMap_numba(fp, performances):
         # The RMap also needs performances; for every fingerprint / channel
         # Save the corresponding performance
@@ -112,7 +402,7 @@ class RMAPChannelSelector:
         return RMAP
 
     @staticmethod
-    #@jit(nopython=True)
+    # @jit(nopython=True)
     def get_corr_numba(fp, fp_test):
         val = np.corrcoef(fp_test, fp)[0][1]
         return val
@@ -126,7 +416,7 @@ class RMAPChannelSelector:
         per_predict = []
 
         for idx_left_out, f_left_out in enumerate(l_fps_names):
-            print(idx_left_out)
+            # print(idx_left_out)
             l_cv = l_fps_dat.copy()
             per_cv = l_per.copy()
 
@@ -160,7 +450,7 @@ class RMAPChannelSelector:
         per_left_out = []
 
         for subject_test in sub_list:
-            print(subject_test)
+            # print(subject_test)
             idx_test = [
                 idx for idx, f in enumerate(l_fps_names) if subject_test in f
             ]
@@ -224,11 +514,18 @@ class RMAPChannelSelector:
         idx_max = np.argmax(np.array(fp_pairs)[:, 3])
         return fp_pairs[idx_max][0:3]
 
-    def plot_performance_prediction_correlation(per_left_out, per_predict, out_path_save: str = None):
+    def plot_performance_prediction_correlation(
+        per_left_out, per_predict, out_path_save: str = None
+    ):
         df_plt_corr = pd.DataFrame()
         df_plt_corr["test_performance"] = per_left_out
-        df_plt_corr["struct_conn_predict"] = per_predict  # change "struct" with "funct" for functional connectivity
+        df_plt_corr["struct_conn_predict"] = (
+            per_predict  # change "struct" with "funct" for functional connectivity
+        )
 
         nm_plots.reg_plot(
-            x_col="test_performance", y_col="struct_conn_predict", data=df_plt_corr, out_path_save=out_path_save
+            x_col="test_performance",
+            y_col="struct_conn_predict",
+            data=df_plt_corr,
+            out_path_save=out_path_save,
         )

py_neuromodulation/nm_analysis.py

@@ -221,7 +221,7 @@ class Feature_Reader:
             pd.DataFrame: z-scored feature_arr
         """
         cols_norm = [c for c in self.feature_arr.columns if "time" not in c]
-        feature_arr_norm = stats.zscore(self.feature_arr[cols_norm])
+        feature_arr_norm = stats.zscore(self.feature_arr[cols_norm], nan_policy="omit")
         feature_arr_norm["time"] = self.feature_arr["time"]
         return feature_arr_norm
 

py_neuromodulation/nm_artifacts.py

@@ -0,0 +1,25 @@
+from pyparrm import PARRM
+
+
+class PARRMArtifactRejection:
+    def __init__(self, data, sampling_freq, artefact_freq, verbose=False):
+        self.data = data
+        self.sampling_freq = sampling_freq
+        self.artefact_freq = artefact_freq
+        self.verbose = verbose
+
+        self.parrm = PARRM(
+            data=data,
+            sampling_freq=sampling_freq,
+            artefact_freq=artefact_freq,
+            verbose=False,
+        )
+
+    def filter_data(self):
+        self.parrm.find_period()
+        self.parrm.create_filter(
+            filter_direction="both",
+        )
+        filtered_data = self.parrm.filter_data()
+
+        return filtered_data

py_neuromodulation/nm_bispectra.py

@@ -4,9 +4,11 @@ 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:
+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
@@ -40,18 +42,14 @@ class Bispectra(nm_features_abc.Feature):
             )
 
         test_range("f1s", s["bispectrum"]["f1s"])
-        test_range("f2s", s["bispectrum"]["f2s"])            
+        test_range("f2s", s["bispectrum"]["f2s"])
 
-        for feature_name, val in s["bispectrum"][
-            "components"
-        ].items():
+        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():
+
+        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}"
@@ -66,10 +64,15 @@ class Bispectra(nm_features_abc.Feature):
             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:
-        
+    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":
@@ -78,9 +81,25 @@ class Bispectra(nm_features_abc.Feature):
                 func = np.nanvar
 
             if f_band is not None:
-                str_feature = "_".join([ch_name, "Bispectrum", component, bispectrum_feature, f_band])
+                str_feature = "_".join(
+                    [
+                        ch_name,
+                        "Bispectrum",
+                        component,
+                        bispectrum_feature,
+                        f_band,
+                    ]
+                )
             else:
-                str_feature = "_".join([ch_name, "Bispectrum", component, bispectrum_feature, "whole_fband_range"])
+                str_feature = "_".join(
+                    [
+                        ch_name,
+                        "Bispectrum",
+                        component,
+                        bispectrum_feature,
+                        "whole_fband_range",
+                    ]
+                )
 
             features_compute[str_feature] = func(spectrum_ch)
 
@@ -89,22 +108,29 @@ class Bispectra(nm_features_abc.Feature):
     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)),
+                data=np.expand_dims(data[ch_idx, :], axis=(0, 1)),
                 sampling_freq=self.sfreq,
                 n_points=data.shape[1],
-            verbose=False,
+                verbose=False,
             )
 
-            f_spectrum_range = freqs[np.logical_and(freqs >= np.min([self.f1s, self.f2s]), freqs <= np.max([self.f1s, self.f2s]))]
+            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.astype(int),
+                freqs=freqs,
                 sampling_freq=self.sfreq,
                 verbose=False,
             )
 
-            waveshape.compute(f1s=tuple(self.f1s), f2s=tuple(self.f2s))
+            waveshape.compute(
+                f1s=(self.f1s[0], self.f1s[-1]), f2s=(self.f2s[0], self.f2s[-1])
+            )
 
             bispectrum = np.squeeze(waveshape.results._data)
 
@@ -120,14 +146,23 @@ class Bispectra(nm_features_abc.Feature):
                         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)
+                    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