misleep 0.2.5__tar.gz → 0.2.6__tar.gz

{misleep-0.2.5 → misleep-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: misleep
-Version: 0.2.5
+Version: 0.2.6
 Summary: MiSleep: Mice Sleep EEG/EMG visualization, scoring and analysis.
 Home-page: https://github.com/BryanWang0702/MiSleep/
 Download-URL: https://github.com/BryanWang0702/MiSleep/

{misleep-0.2.5 → misleep-0.2.6}/misleep/analysis/auto_stage.py

@@ -3,7 +3,7 @@ import numpy as np
 from math import floor
 import pandas as pd
 from scipy import stats
-import antropy
+from misleep.utils.self_antropy import num_zerocross, perm_entropy, hjorth_params
 import joblib
 import copy
 import lightgbm
@@ -81,19 +81,19 @@ def get_data_features(data, sf, data_format='EEG'):
     window_feature_df[f'{data_format}_std_zscore'] = self_zscore(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]
+    zerocross_rate = [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 = [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'] = self_zscore(hjorth_M)
     window_feature_df[f'{data_format}_Hjorth_C'] = self_zscore(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'] = self_zscore(perm_entropy)
+    perm_entropy_ = [perm_entropy(each[0][:int(5*sf)]) for each in data]
+    window_feature_df[f'{data_format}_perm_entropy'] = self_zscore(perm_entropy_)
 
     # Some features only with EEG
     if data_format.startswith('EEG'):

{misleep-0.2.5 → misleep-0.2.6}/misleep/config.ini

@@ -1,6 +1,6 @@
 [gui]
-version = v0.2.5
-updatetime = 2025/1/17
+version = v0.2.6
+updatetime = 2025/3/24
 marker = ['good', '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"}

{misleep-0.2.5 → misleep-0.2.6}/misleep/gui/dialog.py

@@ -396,6 +396,49 @@ class stateSpectral_dialog(QDialog, Ui_StateSpectralDialog):
             4: 'Init'
         }
 
+        # Check the hour segmentation checkbox, and calculate the spectrum for each hour, with the second
+        # if enabled
+        NREM_hour_spec = []
+        REM_hour_spec = []
+        Wake_hour_spec = []
+        if self.HourSegmentCheckBox.isChecked():
+            for sec in range(start_sec, end_sec, 3600):
+                sleep_state = mianno.sleep_state[sec:sec+3601]
+                sleep_state = lst2group([[idx, each] for idx, each in enumerate(sleep_state)])
+
+                # Merge 4 states' data
+                NREM_data = [channel_data[int((each[0]+sec)*sf): int((each[1]+sec)*sf)] 
+                            for each in sleep_state if each[2] == 1]
+                NREM_data = [element for sublist in NREM_data for element in sublist]
+                REM_data = [channel_data[int((each[0]+sec)*sf): int((each[1]+sec)*sf)] 
+                            for each in sleep_state if each[2] == 2]
+                REM_data = [element for sublist in REM_data for element in sublist]
+                Wake_data = [channel_data[int((each[0]+sec)*sf): int((each[1]+sec)*sf)] 
+                            for each in sleep_state if each[2] == 3]
+                Wake_data = [element for sublist in Wake_data for element in sublist]
+                Init_data = [channel_data[int((each[0]+sec)*sf): int((each[1]+sec)*sf)] 
+                            for each in sleep_state if each[2] == 4]
+                Init_data = [element for sublist in Init_data for element in sublist]
+
+                if self.RejectArtifactCheckBox.isChecked():
+                    threshold = self.ArtThresholdSpinBox.value()
+                else:
+                    threshold = 1.5
+                if self.RejectArtifactCheckBox.isChecked():
+                    NREM_data = reject_artifact(NREM_data, sf=sf, threshold=threshold)
+                    REM_data = reject_artifact(REM_data, sf=sf, threshold=threshold)
+                    Wake_data = reject_artifact(Wake_data, sf=sf, threshold=threshold)
+                    Init_data = reject_artifact(Init_data, sf=sf, threshold=threshold)
+
+                NREM_hour_spec.append(cal_draw_spectrum(data=NREM_data, sf=sf, 
+                                                   nperseg=nperseg, relative=relative)[0][1])
+                REM_hour_spec.append(cal_draw_spectrum(data=REM_data, sf=sf, 
+                                                        nperseg=nperseg, relative=relative)[0][1])
+                Wake_hour_spec.append(cal_draw_spectrum(data=Wake_data, sf=sf,
+                                                        nperseg=nperseg, relative=relative)[0][1])
+        hour_spec = [NREM_hour_spec, REM_hour_spec, Wake_hour_spec]
+                            
+
         fd = QFileDialog.getExistingDirectory(self, 
                                               "Select a folder to save 4 stages' data", 
                                               f"{config['gui']['openpath']}")
@@ -411,6 +454,9 @@ class stateSpectral_dialog(QDialog, Ui_StateSpectralDialog):
         # Write to excel file
         for idx, spec in enumerate([NREM_spec, REM_spec, Wake_spec]):
             _df = pd.DataFrame(data=spec.T, columns=['frequency', 'power'])
+            if hour_spec[idx] != []:
+                # Add the hour spectrum to the dataframe
+                _df[[str(each) for each in range(1, len(hour_spec[idx])+1)]] = pd.DataFrame(hour_spec[idx]).T
             _df.to_excel(excel_writer=writer, sheet_name=name_map[idx+1], index=False)
         if len(Init_data) > sf*10:
             Init_spec, Init_figure = cal_draw_spectrum(data=Init_data, sf=sf,

{misleep-0.2.5 → misleep-0.2.6}/misleep/gui/main_window.py

@@ -1332,11 +1332,11 @@ class main_window(QMainWindow, Ui_MiSleep):
 
     def show_spec_window(self):
         """Show spectrum dialog, triggered by PlotSpecBt"""
-        if self.SleepStateRadio.isChecked() and len(self.start_end) == 2 and self.start_end[1] - self.start_end[0] >= 10:
+        if self.SleepStateRadio.isChecked() and len(self.start_end) == 2 and self.start_end[1] - self.start_end[0] >= 5:
             start_ = self.start_end[0]
             end_ = self.start_end[1]
         
-        elif self.StartEndRadio.isChecked() and len(self.start_end_ms) == 2 and self.start_end_ms[1] - self.start_end_ms[0] >= 10:
+        elif self.StartEndRadio.isChecked() and len(self.start_end_ms) == 2 and self.start_end_ms[1] - self.start_end_ms[0] >= 5:
             start_ = self.start_end_ms[0]
             end_ = self.start_end_ms[1]
         
@@ -1344,7 +1344,7 @@ class main_window(QMainWindow, Ui_MiSleep):
             QMessageBox.about(
                 self,
                 "Error",
-                "Please select a start-end larger than 10 seconds.",
+                "Please select a start-end larger than 5 seconds.",
             )
             return
         

{misleep-0.2.5 → misleep-0.2.6}/misleep/gui/uis/state_spectral_dialog_ui.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'misleep/gui/uis/state_spectral_dialog.ui'
 #
-# Created by: PyQt5 UI code generator 5.15.10
+# Created by: PyQt5 UI code generator 5.15.9
 #
 # WARNING: Any manual changes made to this file will be lost when pyuic5 is
 # run again.  Do not edit this file unless you know what you are doing.
@@ -14,7 +14,7 @@ from PyQt5 import QtCore, QtGui, QtWidgets
 class Ui_StateSpectralDialog(object):
     def setupUi(self, StateSpectralDialog):
         StateSpectralDialog.setObjectName("StateSpectralDialog")
-        StateSpectralDialog.resize(261, 424)
+        StateSpectralDialog.resize(279, 471)
         icon = QtGui.QIcon()
         icon.addPixmap(QtGui.QPixmap(":/logo/logo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         StateSpectralDialog.setWindowIcon(icon)
@@ -73,18 +73,21 @@ class Ui_StateSpectralDialog(object):
         self.groupBox_2.setObjectName("groupBox_2")
         self.gridLayout_3 = QtWidgets.QGridLayout(self.groupBox_2)
         self.gridLayout_3.setObjectName("gridLayout_3")
-        self.EndTimeEditor = QtWidgets.QDateTimeEdit(self.groupBox_2)
-        self.EndTimeEditor.setObjectName("EndTimeEditor")
-        self.gridLayout_3.addWidget(self.EndTimeEditor, 3, 0, 1, 1)
-        self.StartTimeEditor = QtWidgets.QDateTimeEdit(self.groupBox_2)
-        self.StartTimeEditor.setObjectName("StartTimeEditor")
-        self.gridLayout_3.addWidget(self.StartTimeEditor, 1, 0, 1, 1)
-        self.StartTimeCheckBox = QtWidgets.QCheckBox(self.groupBox_2)
-        self.StartTimeCheckBox.setObjectName("StartTimeCheckBox")
-        self.gridLayout_3.addWidget(self.StartTimeCheckBox, 0, 0, 1, 1)
         self.EndTimeCheckBox = QtWidgets.QCheckBox(self.groupBox_2)
         self.EndTimeCheckBox.setObjectName("EndTimeCheckBox")
         self.gridLayout_3.addWidget(self.EndTimeCheckBox, 2, 0, 1, 1)
+        self.StartTimeCheckBox = QtWidgets.QCheckBox(self.groupBox_2)
+        self.StartTimeCheckBox.setObjectName("StartTimeCheckBox")
+        self.gridLayout_3.addWidget(self.StartTimeCheckBox, 0, 0, 1, 1)
+        self.StartTimeEditor = QtWidgets.QDateTimeEdit(self.groupBox_2)
+        self.StartTimeEditor.setObjectName("StartTimeEditor")
+        self.gridLayout_3.addWidget(self.StartTimeEditor, 1, 0, 1, 1)
+        self.EndTimeEditor = QtWidgets.QDateTimeEdit(self.groupBox_2)
+        self.EndTimeEditor.setObjectName("EndTimeEditor")
+        self.gridLayout_3.addWidget(self.EndTimeEditor, 3, 0, 1, 1)
+        self.HourSegmentCheckBox = QtWidgets.QCheckBox(self.groupBox_2)
+        self.HourSegmentCheckBox.setObjectName("HourSegmentCheckBox")
+        self.gridLayout_3.addWidget(self.HourSegmentCheckBox, 4, 0, 1, 1)
         self.gridLayout_2.addWidget(self.groupBox_2, 0, 0, 1, 2)
 
         self.retranslateUi(StateSpectralDialog)
@@ -102,8 +105,9 @@ class Ui_StateSpectralDialog(object):
         self.MergeDataCheckBox.setText(_translate("StateSpectralDialog", "Merge data"))
         self.CancelBt.setText(_translate("StateSpectralDialog", "Cancel"))
         self.groupBox_2.setTitle(_translate("StateSpectralDialog", "Time options"))
-        self.EndTimeEditor.setDisplayFormat(_translate("StateSpectralDialog", "yyyy/MM/dd HH:mm:ss"))
-        self.StartTimeEditor.setDisplayFormat(_translate("StateSpectralDialog", "yyyy/MM/dd HH:mm:ss"))
-        self.StartTimeCheckBox.setText(_translate("StateSpectralDialog", "Start time"))
         self.EndTimeCheckBox.setText(_translate("StateSpectralDialog", "Stop time"))
+        self.StartTimeCheckBox.setText(_translate("StateSpectralDialog", "Start time"))
+        self.StartTimeEditor.setDisplayFormat(_translate("StateSpectralDialog", "yyyy/MM/dd HH:mm:ss"))
+        self.EndTimeEditor.setDisplayFormat(_translate("StateSpectralDialog", "yyyy/MM/dd HH:mm:ss"))
+        self.HourSegmentCheckBox.setText(_translate("StateSpectralDialog", "Hour segmentation"))
 from misleep.gui.resources import misleep

{misleep-0.2.5 → misleep-0.2.6}/misleep/gui/utils.py

@@ -143,6 +143,8 @@ def cal_draw_spectrum(data, sf, nperseg, freq_band=None, relative=None):
     import numpy as np
     import matplotlib.pyplot as plt
 
+    plt.close()
+
     if freq_band is None:
         freq_band = [0.5, 30]
     F, P = welch(data, sf, nperseg=nperseg)

{misleep-0.2.5 → misleep-0.2.6}/misleep/utils/__init__.py

@@ -9,4 +9,5 @@
 
 from .signals import *
 from .annotation import *
-from .logger_handler import *
+from .logger_handler import *
+from .self_antropy import *

misleep-0.2.6/misleep/utils/self_antropy.py

@@ -0,0 +1,386 @@
+# -*- coding: UTF-8 -*-
+"""
+@Project: misleep
+@File: signals.py
+@Author: Xueqiang Wang
+@Date: 2025/2/21
+@Description:  Self implemente some functions from the 'antropy' package, 
+because to import the antropy package cost a lot of time
+I just copy the functions there
+"""
+
+import numpy as np
+from math import factorial
+
+def num_zerocross(x, normalize=False, axis=-1):
+    """Number of zero-crossings.
+
+    .. versionadded: 0.1.3
+
+    Parameters
+    ----------
+    x : list or np.array
+        1D or N-D data.
+    normalize : bool
+        If True, divide by the number of samples to normalize the output
+        between 0 and 1. Otherwise, return the absolute number of zero
+        crossings.
+    axis : int
+        The axis along which to perform the computation. Default is -1 (last).
+
+    Returns
+    -------
+    nzc : int or float
+        Number of zero-crossings.
+
+    Examples
+    --------
+    Simple examples
+
+    >>> import numpy as np
+    >>> import antropy as ant
+    >>> ant.num_zerocross([-1, 0, 1, 2, 3])
+    1
+
+    >>> ant.num_zerocross([0, 0, 2, -1, 0, 1, 0, 2])
+    2
+
+    Number of zero crossings of a pure sine
+
+    >>> import numpy as np
+    >>> import antropy as ant
+    >>> sf, f, dur = 100, 1, 4
+    >>> N = sf * dur # Total number of discrete samples
+    >>> t = np.arange(N) / sf # Time vector
+    >>> x = np.sin(2 * np.pi * f * t)
+    >>> ant.num_zerocross(x)
+    7
+
+    Random 2D data
+
+    >>> np.random.seed(42)
+    >>> x = np.random.normal(size=(4, 3000))
+    >>> ant.num_zerocross(x)
+    array([1499, 1528, 1547, 1457])
+
+    Same but normalized by the number of samples
+
+    >>> np.round(ant.num_zerocross(x, normalize=True), 4)
+    array([0.4997, 0.5093, 0.5157, 0.4857])
+
+    Fractional Gaussian noise with H = 0.5
+
+    >>> import stochastic.processes.noise as sn
+    >>> rng = np.random.default_rng(seed=42)
+    >>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
+    >>> print(f"{ant.num_zerocross(x, normalize=True):.4f}")
+    0.4973
+
+    Fractional Gaussian noise with H = 0.9
+
+    >>> rng = np.random.default_rng(seed=42)
+    >>> x = sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(10000)
+    >>> print(f"{ant.num_zerocross(x, normalize=True):.4f}")
+    0.2615
+
+    Fractional Gaussian noise with H = 0.1
+
+    >>> rng = np.random.default_rng(seed=42)
+    >>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
+    >>> print(f"{ant.num_zerocross(x, normalize=True):.4f}")
+    0.6451
+    """
+    x = np.asarray(x)
+    # https://stackoverflow.com/a/29674950/10581531
+    nzc = np.diff(np.signbit(x), axis=axis).sum(axis=axis)
+    if normalize:
+        nzc = nzc / x.shape[axis]
+    return nzc
+
+
+def hjorth_params(x, axis=-1):
+    """Calculate Hjorth mobility and complexity on given axis.
+
+    .. versionadded: 0.1.3
+
+    Parameters
+    ----------
+    x : list or np.array
+        1D or N-D data.
+    axis : int
+        The axis along which to perform the computation. Default is -1 (last).
+
+    Returns
+    -------
+    mobility, complexity : float
+        Mobility and complexity parameters.
+
+    Notes
+    -----
+    Hjorth Parameters are indicators of statistical properties used in signal
+    processing in the time domain introduced by Bo Hjorth in 1970. The
+    parameters are activity, mobility, and complexity. EntroPy only returns the
+    mobility and complexity parameters, since activity is simply the variance
+    of :math:`x`, which can be computed easily with :py:func:`numpy.var`.
+
+    The **mobility** parameter represents the mean frequency or the proportion
+    of standard deviation of the power spectrum. This is defined as the square
+    root of variance of the first derivative of :math:`x` divided by the
+    variance of :math:`x`.
+
+    The **complexity** gives an estimate of the bandwidth of the signal, which
+    indicates the similarity of the shape of the signal to a pure sine wave
+    (where the value converges to 1). Complexity is defined as the ratio of
+    the mobility of the first derivative of :math:`x` to the mobility of
+    :math:`x`.
+
+    References
+    ----------
+    - https://en.wikipedia.org/wiki/Hjorth_parameters
+    - https://doi.org/10.1016%2F0013-4694%2870%2990143-4
+
+    Examples
+    --------
+    Hjorth parameters of a pure sine
+
+    >>> import numpy as np
+    >>> import antropy as ant
+    >>> sf, f, dur = 100, 1, 4
+    >>> N = sf * dur # Total number of discrete samples
+    >>> t = np.arange(N) / sf # Time vector
+    >>> x = np.sin(2 * np.pi * f * t)
+    >>> np.round(ant.hjorth_params(x), 4)
+    array([0.0627, 1.005 ])
+
+    Random 2D data
+
+    >>> np.random.seed(42)
+    >>> x = np.random.normal(size=(4, 3000))
+    >>> mob, com = ant.hjorth_params(x)
+    >>> print(mob)
+    [1.42145064 1.4339572  1.42186993 1.40587512]
+
+    >>> print(com)
+    [1.21877527 1.21092261 1.217278   1.22623163]
+
+    Fractional Gaussian noise with H = 0.5
+
+    >>> import stochastic.processes.noise as sn
+    >>> rng = np.random.default_rng(seed=42)
+    >>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
+    >>> np.round(ant.hjorth_params(x), 4)
+    array([1.4073, 1.2283])
+
+    Fractional Gaussian noise with H = 0.9
+
+    >>> rng = np.random.default_rng(seed=42)
+    >>> x = sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(10000)
+    >>> np.round(ant.hjorth_params(x), 4)
+    array([0.8395, 1.9143])
+
+    Fractional Gaussian noise with H = 0.1
+
+    >>> rng = np.random.default_rng(seed=42)
+    >>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
+    >>> np.round(ant.hjorth_params(x), 4)
+    array([1.6917, 1.0717])
+    """
+    x = np.asarray(x)
+    # Calculate derivatives
+    dx = np.diff(x, axis=axis)
+    ddx = np.diff(dx, axis=axis)
+    # Calculate variance
+    x_var = np.var(x, axis=axis)  # = activity
+    dx_var = np.var(dx, axis=axis)
+    ddx_var = np.var(ddx, axis=axis)
+    # Mobility and complexity
+    mob = np.sqrt(dx_var / x_var)
+    com = np.sqrt(ddx_var / dx_var) / mob
+    return mob, com
+
+
+def perm_entropy(x, order=3, delay=1, normalize=False):
+    """Permutation Entropy.
+
+    Parameters
+    ----------
+    x : list or np.array
+        One-dimensional time series of shape (n_times)
+    order : int
+        Order of permutation entropy. Default is 3.
+    delay : int, list, np.ndarray or range
+        Time delay (lag). Default is 1. If multiple values are passed
+        (e.g. [1, 2, 3]), AntroPy will calculate the average permutation
+        entropy across all these delays.
+    normalize : bool
+        If True, divide by log2(order!) to normalize the entropy between 0
+        and 1. Otherwise, return the permutation entropy in bit.
+
+    Returns
+    -------
+    pe : float
+        Permutation Entropy.
+
+    Notes
+    -----
+    The permutation entropy is a complexity measure for time-series first
+    introduced by Bandt and Pompe in 2002.
+
+    The permutation entropy of a signal :math:`x` is defined as:
+
+    .. math:: H = -\\sum p(\\pi)\\log_2(\\pi)
+
+    where the sum runs over all :math:`n!` permutations :math:`\\pi` of order
+    :math:`n`. This is the information contained in comparing :math:`n`
+    consecutive values of the time series. It is clear that
+    :math:`0 ≤ H (n) ≤ \\log_2(n!)` where the lower bound is attained for an
+    increasing or decreasing sequence of values, and the upper bound for a
+    completely random system where all :math:`n!` possible permutations appear
+    with the same probability.
+
+    The embedded matrix :math:`Y` is created by:
+
+    .. math::
+        y(i)=[x_i,x_{i+\\text{delay}}, ...,x_{i+(\\text{order}-1) *
+        \\text{delay}}]
+
+    .. math:: Y=[y(1),y(2),...,y(N-(\\text{order}-1))*\\text{delay})]^T
+
+    References
+    ----------
+    Bandt, Christoph, and Bernd Pompe. "Permutation entropy: a
+    natural complexity measure for time series." Physical review letters
+    88.17 (2002): 174102.
+
+    Examples
+    --------
+    Permutation entropy with order 2
+
+    >>> import numpy as np
+    >>> import antropy as ant
+    >>> import stochastic.processes.noise as sn
+    >>> x = [4, 7, 9, 10, 6, 11, 3]
+    >>> # Return a value in bit between 0 and log2(factorial(order))
+    >>> print(f"{ant.perm_entropy(x, order=2):.4f}")
+    0.9183
+
+    Normalized permutation entropy with order 3
+
+    >>> # Return a value comprised between 0 and 1.
+    >>> print(f"{ant.perm_entropy(x, normalize=True):.4f}")
+    0.5888
+
+    Fractional Gaussian noise with H = 0.5, averaged across multiple delays
+    >>> rng = np.random.default_rng(seed=42)
+    >>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
+    >>> print(f"{ant.perm_entropy(x, delay=[1, 2, 3], normalize=True):.4f}")
+    0.9999
+
+    Fractional Gaussian noise with H = 0.1, averaged across multiple delays
+
+    >>> rng = np.random.default_rng(seed=42)
+    >>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
+    >>> print(f"{ant.perm_entropy(x, delay=[1, 2, 3], normalize=True):.4f}")
+    0.9986
+
+    Random
+
+    >>> rng = np.random.default_rng(seed=42)
+    >>> print(f"{ant.perm_entropy(rng.random(1000), normalize=True):.4f}")
+    0.9997
+
+    Pure sine wave
+
+    >>> x = np.sin(2 * np.pi * 1 * np.arange(3000) / 100)
+    >>> print(f"{ant.perm_entropy(x, normalize=True):.4f}")
+    0.4463
+
+    Linearly-increasing time-series
+
+    >>> x = np.arange(1000)
+    >>> print(f"{ant.perm_entropy(x, normalize=True):.4f}")
+    -0.0000
+    """
+    # If multiple delay are passed, return the average across all d
+    if isinstance(delay, (list, np.ndarray, range)):
+        return np.mean([perm_entropy(x, order=order, delay=d, normalize=normalize) for d in delay])
+    x = np.array(x)
+    ran_order = range(order)
+    hashmult = np.power(order, ran_order)
+    assert delay > 0, "delay must be greater than zero."
+    # Embed x and sort the order of permutations
+    sorted_idx = _embed(x, order=order, delay=delay).argsort(kind="quicksort")
+    # Associate unique integer to each permutations
+    hashval = (np.multiply(sorted_idx, hashmult)).sum(1)
+    # Return the counts
+    _, c = np.unique(hashval, return_counts=True)
+    # Use np.true_divide for Python 2 compatibility
+    p = np.true_divide(c, c.sum())
+    pe = -_xlogx(p).sum()
+    if normalize:
+        pe /= np.log2(factorial(order))
+    return pe
+
+def _embed(x, order=3, delay=1):
+    """Time-delay embedding.
+
+    Parameters
+    ----------
+    x : array_like
+        1D-array of shape (n_times) or 2D-array of shape (signal_indice, n_times)
+    order : int
+        Embedding dimension (order).
+    delay : int
+        Delay.
+
+    Returns
+    -------
+    embedded : array_like
+        Embedded time series, of shape (..., n_times - (order - 1) * delay, order)
+    """
+    x = np.asarray(x)
+    N = x.shape[-1]
+    assert x.ndim in [1, 2], "Only 1D or 2D arrays are currently supported."
+    if order * delay > N:
+        raise ValueError("Error: order * delay should be lower than x.size")
+    if delay < 1:
+        raise ValueError("Delay has to be at least 1.")
+    if order < 2:
+        raise ValueError("Order has to be at least 2.")
+
+    if x.ndim == 1:
+        # 1D array (n_times)
+        Y = np.zeros((order, N - (order - 1) * delay))
+        for i in range(order):
+            Y[i] = x[(i * delay) : (i * delay + Y.shape[1])]
+        return Y.T
+    else:
+        # 2D array (signal_indice, n_times)
+        Y = []
+        # pre-defiend an empty list to store numpy.array (concatenate with a list is faster)
+        embed_signal_length = N - (order - 1) * delay
+        # define the new signal length
+        indice = [[(i * delay), (i * delay + embed_signal_length)] for i in range(order)]
+        # generate a list of slice indice on input signal
+        for i in range(order):
+            # loop with the order
+            temp = x[:, indice[i][0] : indice[i][1]].reshape(-1, embed_signal_length, 1)
+            # slicing the signal with the indice of each order (vectorized operation)
+            Y.append(temp)
+            # append the sliced signal to list
+        Y = np.concatenate(Y, axis=-1)
+        return Y
+
+
+def _xlogx(x, base=2):
+    """Returns x log_b x if x is positive, 0 if x == 0, and np.nan
+    otherwise. This handles the case when the power spectrum density
+    takes any zero value.
+    """
+    x = np.asarray(x)
+    xlogx = np.zeros(x.shape)
+    xlogx[x < 0] = np.nan
+    valid = x > 0
+    xlogx[valid] = x[valid] * np.log(x[valid]) / np.log(base)
+    return xlogx
+

{misleep-0.2.5 → misleep-0.2.6}/misleep.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: misleep
-Version: 0.2.5
+Version: 0.2.6
 Summary: MiSleep: Mice Sleep EEG/EMG visualization, scoring and analysis.
 Home-page: https://github.com/BryanWang0702/MiSleep/
 Download-URL: https://github.com/BryanWang0702/MiSleep/

{misleep-0.2.5 → misleep-0.2.6}/misleep.egg-info/SOURCES.txt

@@ -54,6 +54,7 @@ misleep/preprocessing/spectral.py
 misleep/utils/__init__.py
 misleep/utils/annotation.py
 misleep/utils/logger_handler.py
+misleep/utils/self_antropy.py
 misleep/utils/signals.py
 misleep/viz/__init__.py
 misleep/viz/hypnogram.py

{misleep-0.2.5 → misleep-0.2.6}/setup.py

@@ -11,7 +11,7 @@ MAINTAINER_EMAIL = "swang@gmail.com"
 URL = "https://github.com/BryanWang0702/MiSleep/"
 LICENSE = "BSD (3-clause)"
 DOWNLOAD_URL = "https://github.com/BryanWang0702/MiSleep/"
-VERSION = "0.2.5"
+VERSION = "0.2.6"
 
 INSTALL_REQUIRES = [
     "numpy>=1.18.1",