misleep 0.2.2b0__tar.gz → 0.2.3__tar.gz

{misleep-0.2.2b0 → misleep-0.2.3}/LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2018, Raphael Vallat
+Copyright (c) 2023, Xueqiang Wang
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

misleep-0.2.3/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: misleep
+Version: 0.2.3
+Summary: MiSleep: Mice Sleep EEG/EMG visualization, scoring and analysis.
+Home-page: https://github.com/BryanWang0702/MiSleep/
+Download-URL: https://github.com/BryanWang0702/MiSleep/
+Author: Xueqiang Wang
+Author-email: swang@gmail.com
+Maintainer: Xueqiang Wang
+Maintainer-email: swang@gmail.com
+License: BSD (3-clause)
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.18.1
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: pyedflib
+Requires-Dist: hdf5storage
+Requires-Dist: pyqt5
+Requires-Dist: mat73
+Requires-Dist: pandas
+Requires-Dist: openpyxl
+Requires-Dist: antropy
+Requires-Dist: lightgbm
+
+# MiSleep
+MiSleep is for EEG/EMG signal processing and visualization
+
+![logo](resources/entire_logo.png)
+
+The name 'MiSleep' is from '**Mi**ce **Sleep**' and sounds like '**my sleep**'.
+
+---
+
+## Get start
+```shell
+pip install misleep
+```
+
+Find the directory where you installed misleep, run
+```shell
+python -m misleep
+```
+If you use the miniconda or anaconda, the path will be like `D:/miniconda3/envs/misleep/Lib/site-packages`.
+
+See [https://bryanwang.cn/MiSleep/](https://bryanwang.cn/MiSleep/) for a simple documentation.
+
+---
+
+## Some features
+1. Free self-define data structure
+
+You can organize your data with matlab structure like this:
+```matlab
+data.EEG = AN_ARRAY_OF_EEG_DATA;
+data.EMG_DIFF = AN_ARRAY_OF_EMG_DIFFERENTIAL_DATA;
+% Channel name must be the same with you defined above
+data.channels = {'EEG' 'EMG_DIFF'};
+% Sampling frequency for each channel of data
+data.sf = {256 256};
+% Acquisition time of your data
+data.time = {'20240409-18:00:00'}; 
+```
+Or if your data format is `.edf`, misleep will also support well.
+
+2. Event Detection
+
+For sleep spindle and sleep slow-wave activities detection, you can check the tools menu for event detection. The auto stage will coming soon.
+
+3. Self-define `config.ini`
+
+There is a config.ini in the root directory of MiSleep source package, multiple parameters can be self define there, check [config.ini](https://bryanwang.cn/MiSleep/#config-file) for detail.
+
+4. Auto stage
+
+Finally, now we have the auto stage function! Check it in the tool. The overall test accuracy of NREM and Wake is higher than 90%, and for REM, the accuracy is higher than 80%. Currently the model's result is rather fragmented in the state transition segments, we will add some constraints to fix this.
+
+**Future**: Open for suggestions :).
+
+---
+
+## Cite this work
+
+If you use this software, please cite it as below.
+Xueqiang Wang. (2024). BryanWang0702/MiSleep. Zenodo. https://doi.org/10.5281/zenodo.14511905
+

misleep-0.2.3/README.md

@@ -0,0 +1,61 @@
+# MiSleep
+MiSleep is for EEG/EMG signal processing and visualization
+
+![logo](resources/entire_logo.png)
+
+The name 'MiSleep' is from '**Mi**ce **Sleep**' and sounds like '**my sleep**'.
+
+---
+
+## Get start
+```shell
+pip install misleep
+```
+
+Find the directory where you installed misleep, run
+```shell
+python -m misleep
+```
+If you use the miniconda or anaconda, the path will be like `D:/miniconda3/envs/misleep/Lib/site-packages`.
+
+See [https://bryanwang.cn/MiSleep/](https://bryanwang.cn/MiSleep/) for a simple documentation.
+
+---
+
+## Some features
+1. Free self-define data structure
+
+You can organize your data with matlab structure like this:
+```matlab
+data.EEG = AN_ARRAY_OF_EEG_DATA;
+data.EMG_DIFF = AN_ARRAY_OF_EMG_DIFFERENTIAL_DATA;
+% Channel name must be the same with you defined above
+data.channels = {'EEG' 'EMG_DIFF'};
+% Sampling frequency for each channel of data
+data.sf = {256 256};
+% Acquisition time of your data
+data.time = {'20240409-18:00:00'}; 
+```
+Or if your data format is `.edf`, misleep will also support well.
+
+2. Event Detection
+
+For sleep spindle and sleep slow-wave activities detection, you can check the tools menu for event detection. The auto stage will coming soon.
+
+3. Self-define `config.ini`
+
+There is a config.ini in the root directory of MiSleep source package, multiple parameters can be self define there, check [config.ini](https://bryanwang.cn/MiSleep/#config-file) for detail.
+
+4. Auto stage
+
+Finally, now we have the auto stage function! Check it in the tool. The overall test accuracy of NREM and Wake is higher than 90%, and for REM, the accuracy is higher than 80%. Currently the model's result is rather fragmented in the state transition segments, we will add some constraints to fix this.
+
+**Future**: Open for suggestions :).
+
+---
+
+## Cite this work
+
+If you use this software, please cite it as below.
+Xueqiang Wang. (2024). BryanWang0702/MiSleep. Zenodo. https://doi.org/10.5281/zenodo.14511905
+

{misleep-0.2.2b0 → misleep-0.2.3}/misleep/__main__.py

@@ -1,7 +1,6 @@
 import sys
 import os
 sys.path.append(os.getcwd()+'\misleep')
-print(os.getcwd())
 
 from misleep.gui.show import show
     

misleep-0.2.3/misleep/analysis/__init__.py

@@ -0,0 +1,2 @@
+
+from .detection import *

misleep-0.2.3/misleep/analysis/auto_stage.py

@@ -0,0 +1,158 @@
+import misleep
+import numpy as np
+from math import floor
+import pandas as pd
+from scipy import stats
+import antropy
+import joblib
+import copy
+
+
+def filter_power_line_noise(data, sf, noise_band='50-100-150'):
+    """Use 50-100-150 Hz bandstop filter to filter the power line noise
+    The noise band can be '50-100-150' or '60-120-180'
+    TODO: add the 60-120-180 band
+    """
+    filter_band = []
+    if noise_band == '50-100-150' and sf > 306:
+        filter_band = [[47, 53], [97, 103], [147, 153]]
+    elif noise_band == '50-100-150' and sf > 206:
+        filter_band = [[47, 53], [97, 103]]
+    elif sf > 106:
+        filter_band = [[47, 53]]
+    for each in filter_band:
+        data, _ = misleep.signal_filter(data, sf, btype='bandstop', low=each[0], high=each[1])
+    
+    return data
+
+def split_window_data(data, sf, state, window_length=20, stride_length=5):
+    """Split the data into several windows with the window length
+    window length is in seconds, so we need the sampling frequency (sf) to locate the data point,
+    stride length is the step
+    Also contain the state information within the data
+    """
+
+    # If the data is shorter than the window length, remove it
+    if data.shape[0]/sf < 20:
+        return []
+    
+    window_data = []
+    # Make sure we have enough data point of the final segment
+    data_sec_length = floor(data.shape[0] / sf)
+    for i in range(0, data_sec_length-stride_length, stride_length):
+        window = data[int(i*sf):int((i+window_length)*sf)]
+        window_data.append([window, state])
+
+    return window_data
+
+def delta_theta_ratio(data, sf):
+    """Calculate the delta/theta ratio from the original signal data
+    Note, here the data is 20 seconds, we only need the ratio from the 5 seconds beginning
+    """
+    freq, t, Sxx = misleep.spectrogram(data, sf, window=1)
+    band_second = np.where(t < 5)
+    psd = np.sum(np.array([each[band_second] for each in Sxx]), axis=1)
+    band_power = misleep.band_power(psd, freq, bands=[[0.5, 4, 'delta'], [5, 9, 'theta']])
+    return band_power['delta'] / band_power['theta']
+
+def get_data_features(data, sf, data_format='EEG'):
+    """ Get data features, data format can be 'EEG' or 'EMG'
+    data: list of window signal data, [[signal_array(20s), signal_label], ...]
+    """
+
+    # Extract the time-domain and frequency domain features from window data, use a dataframe to store all the features
+    window_feature_df = pd.DataFrame()
+    window_feature_df['label'] = [each[1] for each in data]
+
+    # Time-domain features, both EEG and EMG
+    # 1. standard deviation
+    data_std = np.array([np.std(each[0][:int(5*sf)]) for each in data])
+    # Set those abnormal points to the upper quartile
+    data_std_upper_quantile = np.quantile(data_std, 0.95)
+    data_std = [each if each < data_std_upper_quantile else data_std_upper_quantile for each in data_std]
+    # Z-score the std features
+    window_feature_df[f'{data_format}_std_zscore'] = (data_std - np.mean(data_std)) / np.std(data_std)
+    
+    # 2. Zero crossing rate for EEG and EMG
+    zerocross_rate = [antropy.num_zerocross(each[0][:int(5*sf)]) / (5*sf) for each in data]
+    window_feature_df[f'{data_format}_zerocross_rate'] = (zerocross_rate - np.mean(zerocross_rate)) / np.std(zerocross_rate)
+
+    # 3. Hjorth parameters -- Mobility and Complexity
+    hjorth = [antropy.hjorth_params(each[0][:int(5*sf)]) for each in data]
+    hjorth_M = [each[0] for each in hjorth]
+    hjorth_C = [each[1] for each in hjorth]
+    window_feature_df[f'{data_format}_Hjorth_M'] = (hjorth_M - np.mean(hjorth_M)) / np.std(hjorth_M)
+    window_feature_df[f'{data_format}_Hjorth_C'] = (hjorth_C - np.mean(hjorth_C)) / np.std(hjorth_C)
+
+    # 4. Permutation entropy
+    perm_entropy= [antropy.perm_entropy(each[0][:int(5*sf)]) for each in data]
+    window_feature_df[f'{data_format}_perm_entropy'] = (perm_entropy - np.mean(perm_entropy)) / np.std(perm_entropy) 
+
+    # Some features only with EEG
+    if data_format.startswith('EEG'):
+        # 1. Skewness and kurtosis for EEG signal(s)
+        data_skewness = np.array([stats.skew(each[0][:int(5*sf)]) for each in data])
+        data_kurtosis = np.array([stats.kurtosis(each[0][:int(5*sf)]) for each in data])
+        window_feature_df[f'{data_format}_skewness_zscore'] = (data_skewness - np.mean(data_skewness)) / np.std(data_skewness)
+        window_feature_df[f'{data_format}_kurtosis_zscore'] = (data_kurtosis - np.mean(data_kurtosis)) / np.std(data_kurtosis)
+        # Frequency-domain features
+        # 1. delta/theta
+        delta_theta = [delta_theta_ratio(each[0], sf) for each in data]
+        window_feature_df[f'{data_format}_delta_theta'] = (delta_theta - np.mean(delta_theta)) / np.std(delta_theta) 
+
+    return window_feature_df
+
+def result_constraints(pred_label):
+    """
+    Once finished the prediction, add some constraints to make the result more smooth
+    1. No REM after Wake, set to NREM
+    2. All one epoch between two same state will be set to the around state
+    """
+
+    pred_label = copy.deepcopy(pred_label)
+    for idx in range(1, len(pred_label)-1):
+        label_ = pred_label[idx]
+        if label_ == 3 and pred_label[idx+1] == 2:  # REM after Wake
+            pred_label[idx+1] = 1
+        if pred_label[idx-1] ==pred_label[idx+1]:  # Same state previous and after
+            pred_label[idx] = pred_label[idx-1]
+    
+    return pred_label
+
+
+def auto_stage_gbm(EEG, EMG, sf, EEG_channel='F'):
+    """
+    Auto stage with lightgbm method
+    
+    Parameters
+    ----------
+    EEG : array
+        EEG data for auto stage. For channel specify, see EEG_channel.
+    EMG : array
+        EMG data for auto stage.
+    sf : double
+        Sampling frequency of the EEG and EMG data, should be the same.
+    EEG_channel : string
+        Specify the channel of EEG, frontal or parietal. Options: {'F', 'P'}. Default is 'F' for frontal.
+
+    Return
+    ------
+    pred_label : list
+        Predicted labels for every second. May less than the data length for about 15 seconds.
+    """ 
+    EEG = split_window_data(EEG, sf, state=4)  # All set the initial state '4'
+    EMG = split_window_data(EMG, sf, state=4)
+
+    window_feature_df = pd.DataFrame()
+    window_feature_df = pd.concat([get_data_features(EEG, sf, data_format='EEG'), get_data_features(EMG, sf, data_format='EMG')], axis=1)
+    window_feature_df = window_feature_df.filter(like='E')
+
+    if EEG_channel == 'F':
+        gbm_model = joblib.load(r'./misleep/analysis/auto_stage_model/EEG_F_lightgbm_20241221.pkl')
+    if EEG_channel == 'P':
+        gbm_model = joblib.load(r'./misleep/analysis/auto_stage_model/EEG_P_lightgbm_20241221.pkl')
+
+    pred_label = gbm_model.predict(window_feature_df, num_iteration=gbm_model.best_iteration_)
+    pred_label = result_constraints(pred_label)
+    pred_label = [item for each in pred_label for item in [each]*5]
+    return pred_label

misleep-0.2.3/misleep/analysis/detection.py

@@ -0,0 +1,178 @@
+from misleep.utils.signals import signal_filter
+from misleep.preprocessing.spectral import spectrogram
+from misleep.utils.annotation import lst2group
+from scipy.signal import find_peaks
+import numpy as np
+import pandas as pd
+
+def SWA_detection(signal, sf, freq_band=[0.5, 4], amp_threshold=(75, ), df=False, start_time_sec=0):
+    """Slow wave activity detection
+    Detect form trough to peaks with relative amplitude
+
+    Parameters
+    ----------
+    signal : ndarray
+        Signal to detect Slow wave activity
+    sf : int or float
+        Sampling frequency of signal
+    freq_band : List
+        Frequency band of slow wave activity
+    amp_threshold : float
+        minimum and maximum absolute amplitude
+    df : bool, optional
+        Whether return as a dataframe, when analyze with code, this will be useful
+    start_time : float, optional
+        When use gui, this will be useful to locate each state's analysis
+
+    TODO: add relative methods
+    """
+
+    # filter
+    band_data, _ = signal_filter(signal, sf, btype='bandpass', 
+                                 low=freq_band[0], high=freq_band[1])
+
+    # Find peaks and zerocrossing
+    pos_peak_idx, _ = find_peaks(band_data, amp_threshold)
+    neg_peak_idx, _ = find_peaks(-1*band_data, amp_threshold)
+    zero_crossing = np.where(np.diff(np.signbit(band_data), axis=0))[0]
+
+    # Find zero -> neg_peak -> zero -> pos_peak -> zero
+    negative_peaks_hold = []
+    positive_peaks_hold = []
+    zero_crossing_hold = []
+    for neg_idx in neg_peak_idx:
+        # find the zero cross after the current negative peak
+        for zero_idx in zero_crossing:
+            if zero_idx > neg_idx:
+                # find the positive peak after the zero cross
+                for pos_idx in pos_peak_idx:
+                    if pos_idx > zero_idx and zero_idx not in zero_crossing_hold:
+                        # no zero cross between pos and zero, neg and zero
+                        if True not in (band_data[zero_idx+1: pos_idx] <= 0) and \
+                        True not in (band_data[neg_idx: zero_idx] >= 0):
+                            negative_peaks_hold.append(neg_idx)
+                            positive_peaks_hold.append(pos_idx)
+                            zero_crossing_hold.append(zero_idx)
+                    
+                        break
+                break
+
+    if negative_peaks_hold == []:
+        return None
+    # find the zero before negative peak and after positive peak
+    # see np.searchsorted(a, v) insert v's element into a, find the index which will make the a's order preserve
+    start_zero_cross_hold = zero_crossing[:-1][np.diff(
+        np.searchsorted(negative_peaks_hold, zero_crossing)).astype(bool)]
+    # start_zero_cross_hold = [start_zero_cross_hold, band_data[start_zero_cross_hold]]
+
+    if zero_crossing[-1] < positive_peaks_hold[-1]:
+        zero_crossing = np.append(zero_crossing, positive_peaks_hold[-1] + 1)
+    end_zero_cross_hold = zero_crossing[np.searchsorted(zero_crossing, positive_peaks_hold)]
+    # end_zero_cross_hold = [end_zero_cross_hold, band_data[end_zero_cross_hold]]
+
+    df_lst = []
+    for idx, start_zero in enumerate(start_zero_cross_hold):
+        start_time = start_zero/sf + start_time_sec
+        end_time = end_zero_cross_hold[idx]/sf + start_time_sec
+        total_duration = end_time - start_time
+        frequency = 1/total_duration
+        if frequency > freq_band[1] or frequency < freq_band[0]:
+            continue
+
+        middle_cross_time = zero_crossing_hold[idx] / sf + start_time_sec
+
+        time_pos_peak = positive_peaks_hold[idx] / sf + start_time_sec
+        val_pos_peak = band_data[positive_peaks_hold[idx]]
+        time_neg_peak = negative_peaks_hold[idx] / sf + start_time_sec
+        val_neg_peak = band_data[negative_peaks_hold[idx]]
+
+        peak_to_peak = val_pos_peak - val_neg_peak
+
+        slope = peak_to_peak / (time_pos_peak - time_neg_peak)
+
+        df_lst.append([start_time, time_neg_peak, middle_cross_time, time_pos_peak, 
+                    end_time, total_duration, val_neg_peak, val_pos_peak, 
+                    peak_to_peak, slope, frequency])
+
+    if df:
+        return pd.DataFrame(df_lst, columns=['StartTime', 'NegTime', 'MiddleTime', 
+                                            'PosTime', 'EndTime', 'Duration', 'NegPeak', 
+                                            'PosPeak', 'PTP', 'Slope', 'Frequency'])
+    else:
+        return df_lst
+    
+
+def spindle_detection(signal, sf, freq_band=[10, 15],  start_time_sec=0, 
+                      std_thresh=None, duration_thresh=None):
+    """Spindle detection"""
+    
+    f, t, Sxx = spectrogram(signal, sf, band=freq_band, 
+                                    step=0.2, window=2, norm=False)
+    
+    # Get squared spectrum
+    Sxx = np.sum(Sxx, axis=0)
+    Sxx_squared = Sxx ** 2
+
+    # Use z score to find the real value for threshold
+    Sxx = Sxx_squared
+    Sxx_mean = np.mean(Sxx)
+    Sxx_std = np.std(Sxx)
+    spindle_threshold = std_thresh*Sxx_std + Sxx_mean
+    duration_threshold = duration_thresh*Sxx_std + Sxx_mean
+
+    Sxx_peaks_idx, _ = find_peaks(Sxx, (spindle_threshold))
+
+    # Fund duration
+    duration_group = lst2group([[idx, each] for idx, each in enumerate(Sxx > duration_threshold)])
+    start_time = []
+    end_time = []
+    for each in duration_group:
+        if each[0] != 0 and each[2]:
+            if each[1] < len(t) and each[2]:
+                start_time.append(t[each[0]])
+                end_time.append(t[each[1]])
+
+    start_time = np.array(start_time)
+    end_time = np.array(end_time)
+
+    if Sxx_peaks_idx.shape == (0, ):
+        return None
+    
+    # # find the minimum peak for duration 
+    # minimum_peaks_idx = find_peaks(-1*Sxx)[0]
+
+    # # find the minimum peak around the Sxx peak
+    # if minimum_peaks_idx[-1] < Sxx_peaks_idx[-1]:
+    #     minimum_peaks_idx = np.append(minimum_peaks_idx, Sxx_peaks_idx[-1]+1)
+
+    # end_minimun_sorted_idx = np.searchsorted(minimum_peaks_idx, Sxx_peaks_idx)
+
+    # end_minimum_peak_idx = minimum_peaks_idx[end_minimun_sorted_idx]
+
+    # if end_minimun_sorted_idx[0] == 0:
+    #     end_minimun_sorted_idx = end_minimun_sorted_idx[1:]
+    #     start_minimum_peak_idx = minimum_peaks_idx[end_minimun_sorted_idx-1]
+    #     start_minimum_peak_idx = np.append(0, start_minimum_peak_idx)
+
+    # else:
+    #     start_minimum_peak_idx = minimum_peaks_idx[end_minimun_sorted_idx-1]
+
+    # get time index based on peak index
+    start_time = start_time + start_time_sec
+    end_time = end_time + start_time_sec
+
+    if start_time.shape != end_time.shape:
+        return None
+    if start_time.shape == (0, ):
+        return None
+    
+    return [[each, end_time[idx]] for 
+            idx, each in enumerate(start_time) if 
+            end_time[idx] - each >= 0.5]
+    
+
+def artifact_detection(signal):
+    """Artifact detection"""
+
+
+

misleep-0.2.3/misleep/config.ini

@@ -0,0 +1,13 @@
+[gui]
+version = v0.2.3
+updatetime = 2024/12/23
+marker = ['long REM', 'first REM', 'WindEEG', 'W-R ', 'maker']
+startend = ['burst-supression', 'REM', 'Wake', 'Spindle', 'SWA', 'start end label', 'start end label']
+statemap = {"1": "NREM", "2": "REM", "3": "Wake", "4": "INIT", "5": "IS", "6": "MicroArousal"}
+statecolor = {"1": "orange", "2": "skyblue", "3": "red", "4": "white", "5": "green", "6": "pink"}
+startendcolor = {"NREM": "orange", "REM": "skyblue", "Wake": "red"}
+statecolorbgalpha = 0.1
+markerlinecolor = "red"
+startendlinecolor = "blue"
+openpath = E:
+

{misleep-0.2.2b0 → misleep-0.2.3}/misleep/gui/about.py

@@ -19,8 +19,6 @@ class about_dialog(QDialog, Ui_AboutDialog):
         """
         super().__init__(parent)
 
-        # Enable high dpi devices
-        QCoreApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
         self.setupUi(self)
         if version:
             self.VersionLabel.setText(f"Version: {version}")