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

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_settings.json

@@ -10,7 +10,8 @@
         "raw_resampling",
         "notch_filter",
         "re_referencing",
-        "raw_normalization"
+        "raw_normalization",
+        "preprocessing_filter"
     ],
     "features": {
         "raw_hjorth": true,
@@ -18,6 +19,7 @@
         "bandpass_filter": false,
         "stft": false,
         "fft": true,
+        "welch": true,
         "sharpwave_analysis": true,
         "fooof": false,
         "bursts": true,
@@ -35,6 +37,29 @@
     "raw_resampling_settings": {
         "resample_freq_hz": 1000
     },
+    "preprocessing_filter": {
+        "bandstop_filter": true,
+        "lowpass_filter": true,
+        "highpass_filter": true,
+        "bandpass_filter": true,
+        "bandstop_filter_settings": {
+            "frequency_low_hz": 100,
+            "frequency_high_hz": 160
+        },
+        "lowpass_filter_settings": {
+            "frequency_cutoff_hz": 200
+        },
+        "highpass_filter_settings": {
+            "frequency_cutoff_hz": 3
+        },
+        "bandpass_filter_settings": {
+            "frequency_low_hz": 3,
+            "frequency_high_hz": 200
+        }
+    },
+    "re_referencing_settings": {
+        "reference": "common"
+    },
     "documentation_normalization_options": [
         "mean",
         "median",
@@ -88,12 +113,35 @@
     "fft_settings": {
         "windowlength_ms": 1000,
         "log_transform": true,
-        "kalman_filter": false
+        "features": {
+            "mean": true,
+            "median": false,
+            "std": false,
+            "max": false
+        },
+        "return_spectrum": false
+    },
+    "welch_settings": {
+        "windowlength_ms": 1000,
+        "log_transform": true,
+        "features": {
+            "mean": true,
+            "median": false,
+            "std": false,
+            "max": false
+        },
+        "return_spectrum": false
     },
     "stft_settings": {
         "windowlength_ms": 500,
         "log_transform": true,
-        "kalman_filter": false
+        "features": {
+            "mean": true,
+            "median": false,
+            "std": false,
+            "max": false
+        },
+        "return_spectrum": false
     },
     "bandpass_filter_settings": {
         "segment_lengths_ms": {

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,

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