PySDKit

https://pysdkit.readthedocs.io/en/latest/
Admin
PySDKit is a Python library for signal decomposition that provides a unified scikit-learn-style...
Tokens:626,394
Snippets:3,404
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Quick start with APMD and OVMD

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Example usage of the APMD and OVMD decomposition algorithms.

```python
from pysdkit import APMD, OVMD

modes_apmd = APMD(n_modes=5).fit_transform(signal, fs=fs)
modes_ovmd = OVMD(alpha=100, K=5).fit_transform(signal)
```

--------------------------------

### Run classic command

Source: https://pysdkit.readthedocs.io/en/latest/auto_examples/emd_variants/eemd.html

Command to run the classic example.

```text
run classic

```

--------------------------------

### Install PySDKit from source

Source: https://pysdkit.readthedocs.io/en/latest/user_guide/index.html

Commands to clone the repository and install it in editable mode for development.

```bash
git clone https://github.com/wwhenxuan/PySDKit.git
cd PySDKit
pip install -e .
```

--------------------------------

### Install scikit-learn

Source: https://pysdkit.readthedocs.io/en/latest/_downloads/2fb0f67702479905408a191d431f49ad/emd_forecasting.ipynb

Install the scikit-learn package, required for the forecasting models used in the notebook.

```bash
pip install scikit-learn
```

--------------------------------

### Clone and install PySDKit from source

Source: https://pysdkit.readthedocs.io/en/latest/development/index.html

Clones the PySDKit repository, changes into the directory, installs the package in editable mode, and installs documentation requirements.

```bash
git clone https://github.com/wwhenxuan/PySDKit.git
cd PySDKit
pip install -e .
pip install -r docs/requirements.txt

```

--------------------------------

### Quick start with PySDKit algorithms

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates basic usage of MEMD, EMD2D, VME, and ITD algorithms using provided test data.

```python
from pysdkit import MEMD, EMD2D, VME, ITD
from pysdkit.data import load_memd_syn_hex, test_univariate_signal, test_univariate_image

# Multivariate EMD (channels x time)
hex_sig = load_memd_syn_hex()["signal"]          # (6, 1001)
imfs = MEMD(n_dir=64)(hex_sig)                   # (K, 1001, 6)

# 2-D EMD of a grayscale image
image = test_univariate_image()
bimfs = EMD2D(max_imfs=3).fit_transform(image)   # (K, H, W)

# Variational Mode Extraction
from pysdkit.data import test_emd
t, x = test_emd()
u, omega = VME(alpha=2000, fs=1000.0).fit_transform(x, omega_init=36.0)

# Intrinsic Time-Scale Decomposition
_, x1 = test_univariate_signal(case=1)
prcs = ITD(N_max=10)(x1)                         # last row = residue
```

--------------------------------

### Quick start with VMD and Entropy

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates how to import modules, perform Variational Mode Decomposition (VMD), and calculate spectral and sample entropy on the resulting IMFs.

```python
from pysdkit import VMD
from pysdkit.data import test_vmd
from pysdkit.entropy import spectral_entropy, sample_entropy
from pysdkit.utils import BSS

t, x, fs = test_vmd()
imfs = VMD(alpha=2000, K=4, tau=0.0, tol=1e-7).fit_transform(x)
print(spectral_entropy(imfs[0]), sample_entropy(imfs[0], m=2, r=0.2))

# Underdetermined BSS: mix, cluster frequency energy, recover sources
# y = BSS(num=2).fit_transform(mixture)  # see examples/utils/bss.py
```

--------------------------------

### Quick start with NSTEMD and OnlineEMD

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates how to import and initialize the new NSTEMD and OnlineEMD classes, including loading sample ECG data.

```python
from pysdkit import NSTEMD, OnlineEMD
from pysdkit.data import load_oemd_ecg

# NS-TEMD: (n_channels, n_samples) -> (n_imfs, n_samples, n_channels)
nstemd = NSTEMD(n_dir=32)
# imfs = nstemd(signal_ct)

# Online EMD: univariate stream or batch
ecg = load_oemd_ecg()["signal"]
imfs = OnlineEMD(n_extrema=10, emd_algo="fix_h")(ecg)
```

--------------------------------

### Quick start with DD_ACMD

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates how to import the DD_ACMD class and a stationary demo generator to perform decomposition on a signal.

```python
from pysdkit import DD_ACMD
from pysdkit._acmd.dd_acmd import generate_stationary_demo

demo = generate_stationary_demo(fs=300.0, duration=1.0, noise_std=0.3)
dd = DD_ACMD(fs=300.0)
imfs = dd.fit_transform(demo["signal"])
# or: imfs, ini_if, e_if, e_ia = dd.fit_transform(..., return_all=True)
```

--------------------------------

### Quick start with IMD

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates how to load demo data and perform Impulsive Mode Decomposition using the IMD class.

```python
from pysdkit import IMD
from pysdkit._imd import load_imd_input_sig

demo = load_imd_input_sig()
imd = IMD(n_particles=45, max_iter=20, threshold=1.60, max_modes=4, seg_num=10, seed=0)
modes = imd.fit_transform(demo["signal"], fs=demo["fs"])
# or: out = imd.fit_transform(..., return_all=True)
```

--------------------------------

### Quick start with IVGNMD, LMD, and RLMD

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates basic usage of the IVGNMD, LMD, and RLMD algorithms for signal decomposition.

```python
from pysdkit import IVGNMD, LMD, RLMD

# Improved VGNMD for crossed chirps
imfs = IVGNMD()(signal)

# Classical / robust local mean decomposition
pfs = LMD()(signal)
pfs, ams, fms = RLMD(max_imfs=10, max_iter=30)(signal, return_all=True)
```

--------------------------------

### DDIFI initialization output

Source: https://pysdkit.readthedocs.io/en/latest/auto_examples/acmd/dd_acmd.html

The expected console output when running the DDIFI initialization example.

```text
median init IF ≈ 35.73 Hz (target 35 Hz)
```

--------------------------------

### Build HTML documentation with Sphinx

Source: https://pysdkit.readthedocs.io/en/latest/development/index.html

Builds the HTML documentation using Sphinx. The output is in docs/build/html/index.html. Read the Docs uses the same Sphinx config and installs the checkout with pip install . (see .readthedocs.yaml).

```bash
sphinx-build -b html docs/source docs/build/html

```

--------------------------------

### Quick start with OSD presets

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Basic usage of the OSD class using a preset configuration to decompose a signal.

```python
from pysdkit import OSD

# preset: residual + smooth trend + total-variation jumps
osd = OSD.preset("convex_demo", length=len(y), max_iter=120)
X = osd.fit_transform(y)   # shape: (K, N)
```

--------------------------------

### Quick start with SET and blind deconvolution

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates initializing the SET transform for ridge reconstruction and applying blind deconvolution to a signal.

```python
from pysdkit import SET
from pysdkit.data import load_set_batdata2, load_imckd_sig1
from pysdkit.utils import imckd, acycbd, smhd

# SET: TFR, then ridge reconstruction (last row is the residual)
bat = load_set_batdata2()
te, freq = SET(hlength=50, fs=bat["fs"]).transform(bat["signal"])
imfs = SET(hlength=50, fs=bat["fs"], n_imfs=3)(bat["signal"])  # (4, T)

# Blind deconvolution: inverse FIR + period estimated on the fly
sig1 = load_imckd_sig1()
y, fir, info = imckd(sig1["signal"], fs=sig1["fs"])
```

--------------------------------

### Define custom OSD components

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Example of configuring OSD with custom components for specific signal decomposition tasks.

```python
from pysdkit import OSD
from pysdkit._osd import MeanSquareSmall, SparseSecondDiffConvex

osd = OSD(
    components=[
        MeanSquareSmall(size=len(y), weight=1 / len(y)),
        SparseSecondDiffConvex(weight=1.0),  # L1 trend filtering
    ],
    max_iter=80,
)
X = osd.fit_transform(y)
```

--------------------------------

### Quick start: STNBMD decomposition with make_order_tracking_demo

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates the unified OOP fit_transform API for STNBMD. Creates a demo signal with make_order_tracking_demo, configures STNBMD parameters (alpha, beta, abitr, tol), and decomposes into modes. Optionally, return_all=True provides additional outputs (xnb, err, amp, phz).

```python
from pysdkit import STNBMD
from pysdkit._vncmd.stnbmd import make_order_tracking_demo

demo = make_order_tracking_demo(fs=100.0, nt=1000)
stn = STNBMD(
    fs=100.0,
    alpha=[1e-1, 1e-2, 1e-2],
    beta=[1.0, 1e-1, 1e-3],
    abitr=[20, 50, 200],
    tol=1e-6,
)
modes = stn.fit_transform(demo["signal"], frequencies=[2.0, 4.0, 6.0])  # (K, nt)
# or: modes, xnb, err, amp, phz = stn.fit_transform(..., return_all=True)
```

--------------------------------

### Quick start with SST and Fast Kurtogram

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates how to perform SST decomposition on multivariate signals and use the Fast Kurtogram utility to identify and extract impulsive bands.

```python
from pysdkit import SST
from pysdkit.data import load_sst_float, load_fast_kurtogram_x
from pysdkit.utils import fast_kurtogram, find_wav_kurt

# SST: univariate (T,) or multivariate (C, T) -> IMFs
float_sig = load_sst_float()["signal"]          # (2, 1116)
imfs = SST(wavelet="bump")(float_sig)           # (K, 1116, 2)

# Fast kurtogram: map + peak band, then optional envelope
demo = load_fast_kurtogram_x()
Kwav, info = fast_kurtogram(demo["signal"], nlevel=7, fs=1.0)
env = find_wav_kurt(info["x"], info["level"], info["fc"] / info["fs"], fs=1.0)
```

--------------------------------

### Unified Interface Example

Source: https://pysdkit.readthedocs.io/en/latest/user_guide/index.html

Demonstrates the standard workflow: importing an algorithm, initializing it, fitting the model, and plotting the results.

```python
from pysdkit import VMD
from pysdkit.data import test_vmd
from pysdkit.plot import plot_IMFs

t, signal, fs = test_vmd()
vmd = VMD(alpha=2000, K=4, tau=0.0, tol=1e-7)
IMFs = vmd.fit_transform(signal)
plot_IMFs(signal, IMFs, view="2d_freq", fs=fs, freq_max=fs / 2)
```

--------------------------------

### Import required libraries: numpy, matplotlib, and pysdkit functions

Source: https://pysdkit.readthedocs.io/en/latest/auto_examples/deconvolution/acycbd.html

Imports the necessary libraries for numerical processing, plotting, and the ACYCBD-related functions used in the example. Ensure pysdkit is installed.

```python
import numpy as np
import matplotlib.pyplot as plt

from pysdkit.data import load_acycbd_sig2
from pysdkit.utils import acycbd, annotate_harmonics, envelope_spectrum, matlab_kurtosis

```

--------------------------------

### Install PySDKit via pip

Source: https://pysdkit.readthedocs.io/en/latest/user_guide/index.html

Standard installation command for the PySDKit package.

```bash
pip install pysdkit
```

--------------------------------

### 1D EWT Output Example

Source: https://pysdkit.readthedocs.io/en/latest/auto_examples/ewt/ewt_ewt2d.html

Example output showing the shape of the extracted IMFs and the detected spectral boundaries.

```text
IMF shape (K, N): (3, 1000)
Detected boundaries (rad): [0.02199115 0.05654867]
```

--------------------------------

### Initialize and run VTFMTD

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates how to load demo signal data and perform decomposition using the VTFMTD class.

```python
from pysdkit import VTFMTD
from pysdkit._tfa import load_dual_signal_noise

demo = load_dual_signal_noise()
vtf = VTFMTD(hlength=28, K=2, alpha=5e-5, sigma=0.01, beta=0.3)
Gk, omega = vtf.fit_transform(demo["signal"], omega_init=[250.0, 950.0])
# Gk: (F, T, K) mode STFTs; omega: IF field (MATLAB-style bin units)
```

--------------------------------

### CEEMDAN output example

Source: https://pysdkit.readthedocs.io/en/latest/auto_examples/emd_variants/ceemdan.html

Example console output showing the shape of the resulting cIMFs and the reconstruction error.

```text
cIMFs (+ residue): (5, 600)
complete reconstruction error: 4.440892098500626e-16
run classic
```

--------------------------------

### Initialize and run APITMEMD

Source: https://pysdkit.readthedocs.io/en/latest/release_notes/index.html

Demonstrates how to import the APITMEMD class and a sample dataset, then execute the decomposition on a signal.

```python
from pysdkit import APITMEMD
from pysdkit.data import load_apitmemd_section_2b

sig = load_apitmemd_section_2b()["signal"]  # (6, 360)
imfs = APITMEMD(n_dir=16, alpha=0.3)(sig)    # (K, 360, 6)
```

--------------------------------

### Run MATLAB Example 3 (parts a and b)

Source: https://pysdkit.readthedocs.io/en/latest/auto_examples/vmd/vme.html

Reproduces example 3 from the paper: Eq. (25) with a linear chirp and a jumping tone. Extracts the chirp (3a) with omega_init=6 Hz and the first piecewise tone (3b) with omega_init=26 Hz. Expected output: Example 3a: n_iter=20, omega = 10.030 Hz and Example 3b: n_iter=7, omega = 30.087 Hz.

```python
mode3a, omega3a = run_demo(generate_vme_example3a())
mode3b, omega3b = run_demo(generate_vme_example3b())
```

```text
Example 3a: n_iter=20, omega = 10.030 Hz
Example 3b: n_iter=7, omega = 30.087 Hz
```

--------------------------------

### Tensor EWT2D output example

Source: https://pysdkit.readthedocs.io/en/latest/auto_examples/ewt/ewt_ewt2d.html

Example output showing the shape and bounds resulting from the Tensor EWT2D fit_transform operation.

```text
modes shape: (9, 128, 128)
n_row x n_col = 3 x 3
row bounds: [0.17180585 0.3436117 ]
col bounds: [0.17180585 0.46633016]
```

--------------------------------

### Initialize and use STVMD class

Source: https://pysdkit.readthedocs.io/en/latest/_downloads/e2a140d2cb5baf2b2d3d570a9ed7967f/stvmd.ipynb

Demonstrates how to import the STVMD class, initialize it with specific parameters, and perform signal decomposition using fit_transform.

```python
from pysdkit import STVMD, stvmd

st = STVMD(K=3, alpha=50, n_fft=64, dynamic=True)
modes = st.fit_transform(signal)                 # (K, T)
modes, u_hat, omega = st.fit_transform(signal, return_all=True)
```

--------------------------------

### Import libraries for SMHD example

Source: https://pysdkit.readthedocs.io/en/latest/_downloads/98bd18b787497848d095f6faf053209c/smhd.ipynb

Imports required for the SMHD example: NumPy, Matplotlib, and pysdkit functions including load_smhd_sig3, envelope_spectrum, matlab_kurtosis, and smhd.

```python
import numpy as np
import matplotlib.pyplot as plt

from pysdkit.data import load_smhd_sig3
from pysdkit.utils import (
    annotate_harmonics,
    envelope_spectrum,
    matlab_kurtosis,
    peak_frequency,
    smhd,
)
```
Tokens:
Raw