scitex 2.0.0__py2.py3-none-any.whl

scitex/dsp/filt.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-04 02:05:47 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/dsp/filt.py
+
+import scitex
+import numpy as np
+
+from ..decorators import signal_fn
+from ..nn import (
+    BandPassFilter,
+    BandStopFilter,
+    GaussianFilter,
+    HighPassFilter,
+    LowPassFilter,
+)
+
+
+@signal_fn
+def gauss(x, sigma, t=None):
+    return GaussianFilter(sigma)(x, t=t)
+
+
+@signal_fn
+def bandpass(x, fs, bands, t=None):
+    import torch
+
+    # Convert bands to tensor if it's not already
+    if not isinstance(bands, torch.Tensor):
+        bands = torch.tensor(bands, dtype=torch.float32)
+    return BandPassFilter(bands, fs, x.shape[-1])(x, t=t)
+
+
+@signal_fn
+def bandstop(x, fs, bands, t=None):
+    return BandStopFilter(bands, fs, x.shape[-1])(x, t=t)
+
+
+@signal_fn
+def lowpass(x, fs, cutoffs_hz, t=None):
+    return LowPassFilter(cutoffs_hz, fs, x.shape[-1])(x, t=t)
+
+
+@signal_fn
+def highpass(x, fs, cutoffs_hz, t=None):
+    return HighPassFilter(cutoffs_hz, fs, x.shape[-1])(x, t=t)
+
+
+def _custom_print(x):
+    print(type(x), x.shape)
+
+
+if __name__ == "__main__":
+    import sys
+
+    import matplotlib.pyplot as plt
+    import torch
+
+    # Start
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt)
+
+    # Parametes
+    T_SEC = 1
+    SRC_FS = 1024
+    FREQS_HZ = list(np.linspace(0, 500, 10, endpoint=False).astype(int))
+    SIG_TYPE = "periodic"
+    BANDS = np.vstack([[80, 310]])
+    SIGMA = 3
+
+    # Demo Signal
+    xx, tt, fs = scitex.dsp.demo_sig(
+        t_sec=T_SEC,
+        fs=SRC_FS,
+        freqs_hz=FREQS_HZ,
+        sig_type=SIG_TYPE,
+    )
+
+    # Filtering
+    x_bp, t_bp = scitex.dsp.filt.bandpass(xx, fs, BANDS, t=tt)
+    x_bs, t_bs = scitex.dsp.filt.bandstop(xx, fs, BANDS, t=tt)
+    x_lp, t_lp = scitex.dsp.filt.lowpass(xx, fs, BANDS[:, 0], t=tt)
+    x_hp, t_hp = scitex.dsp.filt.highpass(xx, fs, BANDS[:, 1], t=tt)
+    x_g, t_g = scitex.dsp.filt.gauss(xx, sigma=SIGMA, t=tt)
+    filted = {
+        f"Original (Sum of {FREQS_HZ}-Hz signals)": (xx, tt, fs),
+        f"Bandpass-filtered ({BANDS[0][0]} - {BANDS[0][1]} Hz)": (
+            x_bp,
+            t_bp,
+            fs,
+        ),
+        f"Bandstop-filtered ({BANDS[0][0]} - {BANDS[0][1]} Hz)": (
+            x_bs,
+            t_bs,
+            fs,
+        ),
+        f"Lowpass-filtered ({BANDS[0][0]} Hz)": (x_lp, t_lp, fs),
+        f"Highpass-filtered ({BANDS[0][1]} Hz)": (x_hp, t_hp, fs),
+        f"Gaussian-filtered (sigma = {SIGMA} SD [point])": (x_g, t_g, fs),
+    }
+
+    # Plots traces
+    fig, axes = plt.subplots(nrows=len(filted), ncols=1, sharex=True, sharey=True)
+    i_batch = 0
+    i_ch = 0
+    i_filt = 0
+    for ax, (k, v) in zip(axes, filted.items()):
+        _xx, _tt, _fs = v
+        if _xx.ndim == 3:
+            _xx = _xx[i_batch, i_ch]
+        elif _xx.ndim == 4:
+            _xx = _xx[i_batch, i_ch, i_filt]
+        ax.plot(_tt, _xx, label=k)
+        ax.legend(loc="upper left")
+
+    fig.suptitle("Filtered")
+    fig.supxlabel("Time [s]")
+    fig.supylabel("Amplitude")
+
+    scitex.io.save(fig, "traces.png")
+
+    # Calculates and Plots PSD
+    fig, axes = plt.subplots(nrows=len(filted), ncols=1, sharex=True, sharey=True)
+    i_batch = 0
+    i_ch = 0
+    i_filt = 0
+    for ax, (k, v) in zip(axes, filted.items()):
+        _xx, _tt, _fs = v
+
+        _psd, ff = scitex.dsp.psd(_xx, _fs)
+        if _psd.ndim == 3:
+            _psd = _psd[i_batch, i_ch]
+        elif _psd.ndim == 4:
+            _psd = _psd[i_batch, i_ch, i_filt]
+
+        ax.plot(ff, _psd, label=k)
+        ax.legend(loc="upper left")
+
+        for bb in np.hstack(BANDS):
+            ax.axvline(x=bb, color=CC["grey"], linestyle="--")
+
+    fig.suptitle("PSD (power spectrum density) of filtered signals")
+    fig.supxlabel("Frequency [Hz]")
+    fig.supylabel("log(Power [uV^2 / Hz]) [a.u.]")
+    scitex.io.save(fig, "psd.png")
+
+    # Close
+    scitex.gen.close(CONFIG)
+
+# EOF
+
+"""
+/home/ywatanabe/proj/scitex/src/scitex/dsp/filt.py
+"""
+
+# EOF

scitex/dsp/norm.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-04-05 12:15:42 (ywatanabe)"
+
+import torch as _torch
+from ..decorators import signal_fn as _signal_fn
+
+
+@_signal_fn
+def z(x, dim=-1):
+    return (x - x.mean(dim=dim, keepdim=True)) / x.std(dim=dim, keepdim=True)
+
+
+@_signal_fn
+def minmax(x, amp=1.0, dim=-1, fn="mean"):
+    MM = x.max(dim=dim, keepdims=True)[0].abs()
+    mm = x.min(dim=dim, keepdims=True)[0].abs()
+    return amp * x / _torch.maximum(MM, mm)

scitex/dsp/params.py

@@ -0,0 +1,51 @@
+import numpy as np
+import pandas as pd
+
+BANDS = pd.DataFrame(
+    data=np.array([[0.5, 4], [4, 8], [8, 10], [10, 13], [13, 32], [32, 75]]).T,
+    index=["low_hz", "high_hz"],
+    columns=["delta", "theta", "lalpha", "halpha", "beta", "gamma"],
+)
+
+EEG_MONTAGE_1020 = [
+    "FP1",
+    "F3",
+    "C3",
+    "P3",
+    "O1",
+    "FP2",
+    "F4",
+    "C4",
+    "P4",
+    "O2",
+    "F7",
+    "T7",
+    "P7",
+    "F8",
+    "T8",
+    "P8",
+    "FZ",
+    "CZ",
+    "PZ",
+]
+
+EEG_MONTAGE_BIPOLAR_TRANVERSE = [
+    # Frontal
+    "FP1-FP2",
+    "F7-F3",
+    "F3-FZ",
+    "FZ-F4",
+    "F4-F8",
+    # Central
+    "T7-C3",
+    "C3-CZ",
+    "CZ-C4",
+    "C4-T8",
+    # Parietal
+    "P7-P3",
+    "P3-PZ",
+    "PZ-P4",
+    "P4-P8",
+    # Occipital
+    "O1-O2",
+]

scitex/dsp/reference.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "ywatanabe (2024-11-02 22:48:44)"
+# File: ./scitex_repo/src/scitex/dsp/reference.py
+
+import torch as _torch
+from ..decorators import torch_fn as _torch_fn
+
+
+@_torch_fn
+def common_average(x, dim=-2):
+    re_referenced = (x - x.mean(dim=dim, keepdims=True)) / x.std(dim=dim, keepdims=True)
+    assert x.shape == re_referenced.shape
+    return re_referenced
+
+
+@_torch_fn
+def random(x, dim=-2):
+    idx_all = [slice(None)] * x.ndim
+    idx_rand_dim = _torch.randperm(x.shape[dim])
+    idx_all[dim] = idx_rand_dim
+    y = x[idx_all]
+    re_referenced = x - y
+    assert x.shape == re_referenced.shape
+    return re_referenced
+
+
+@_torch_fn
+def take_reference(x, tgt_indi, dim=-2):
+    idx_all = [slice(None)] * x.ndim
+    idx_all[dim] = tgt_indi
+    re_referenced = x - x[tgt_indi]
+    assert x.shape == re_referenced.shape
+    return re_referenced
+
+
+if __name__ == "__main__":
+    import scitex
+
+    x, f, t = scitex.dsp.demo_sig()
+    y = common_average(x)
+
+# EOF

scitex/dsp/template.py

@@ -0,0 +1,25 @@
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-04-10 15:57:54 (ywatanabe)"
+
+
+# FUnctions
+
+if __name__ == "__main__":
+    import sys
+
+    import matplotlib.pyplot as plt
+
+    import torch
+
+    # Start
+    CONFIG, sys.stdout, sys.stderr, plt, cc = scitex.gen.start(sys, plt)
+
+    # Close
+    scitex.gen.close(CONFIG)
+
+    """
+    /home/ywatanabe/proj/scitex/src/scitex/dsp/template.py
+    """
+
+    # EOF

scitex/dsp/utils/__init__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Scitex utils module."""
+
+from ._differential_bandpass_filters import build_bandpass_filters, init_bandpass_filters
+from ._ensure_3d import ensure_3d
+from ._ensure_even_len import ensure_even_len
+from ._zero_pad import zero_pad
+
+__all__ = [
+    "build_bandpass_filters",
+    "ensure_3d",
+    "ensure_even_len",
+    "init_bandpass_filters",
+    "zero_pad",
+]

scitex/dsp/utils/_differential_bandpass_filters.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-26 22:24:13 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/dsp/utils/_differential_bandpass_filters.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/dsp/utils/_differential_bandpass_filters.py"
+
+import sys
+
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+
+from ...decorators import torch_fn
+from ...gen._to_even import to_even
+from ...gen._to_odd import to_odd
+
+try:
+    from torchaudio.prototype.functional import sinc_impulse_response
+except:
+    pass
+
+
+# Functions
+@torch_fn
+def init_bandpass_filters(
+    sig_len,
+    fs,
+    pha_low_hz=2,
+    pha_high_hz=20,
+    pha_n_bands=30,
+    amp_low_hz=60,
+    amp_high_hz=160,
+    amp_n_bands=50,
+    cycle=3,
+):
+    # Learnable parameters
+    pha_mids = nn.Parameter(torch.linspace(pha_low_hz, pha_high_hz, pha_n_bands))
+    amp_mids = nn.Parameter(torch.linspace(amp_low_hz, amp_high_hz, amp_n_bands))
+    filters = build_bandpass_filters(sig_len, fs, pha_mids, amp_mids, cycle)
+    return filters, pha_mids, amp_mids
+
+
+@torch_fn
+def build_bandpass_filters(sig_len, fs, pha_mids, amp_mids, cycle):
+    def _define_freqs(mids, factor):
+        lows = mids - mids / factor
+        highs = mids + mids / factor
+        return lows, highs
+
+    def define_order(low_hz, fs, sig_len, cycle):
+        order = cycle * int((fs // low_hz))
+        order = order if 3 * order >= sig_len else (sig_len - 1) // 3
+        order = to_even(order)
+        return order
+
+    def _calc_filters(lows_hz, highs_hz, fs, order):
+        nyq = fs / 2.0
+        order = to_odd(order)
+        # lowpass filters
+        irs_ll = sinc_impulse_response(lows_hz / nyq, window_size=order)
+        irs_hh = sinc_impulse_response(highs_hz / nyq, window_size=order)
+        irs = irs_ll - irs_hh
+        return irs
+
+    # Main
+    pha_lows, pha_highs = _define_freqs(pha_mids, factor=4.0)
+    amp_lows, amp_highs = _define_freqs(amp_mids, factor=8.0)
+
+    lowest = min(pha_lows.min().item(), amp_lows.min().item())
+    order = define_order(lowest, fs, sig_len, cycle)
+
+    pha_bp_filters = _calc_filters(pha_lows, pha_highs, fs, order)
+    amp_bp_filters = _calc_filters(amp_lows, amp_highs, fs, order)
+    return torch.vstack([pha_bp_filters, amp_bp_filters])
+
+
+if __name__ == "__main__":
+    import scitex
+
+    # Start
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, agg=True)
+
+    # Demo signal
+    freqs_hz = [10, 30, 100, 300]
+    fs = 1024
+    xx, tt, fs = scitex.dsp.demo_sig(fs=fs, freqs_hz=freqs_hz)
+
+    # Main
+    filters, pha_mids, amp_mids = init_bandpass_filters(xx.shape[-1], fs)
+
+    filters.sum().backward()  # OK. The filtering bands are trainable with backpropagation.
+
+    # Update 'pha_mids' and 'amp_mids' in the forward method.
+    # Then, re-build filters using optimized parameters like this:
+    # self.filters = build_bandpass_filters(self.sig_len, self.fs, self.pha_mids, self.amp_mids, self.cycle)
+
+    mids_all = np.concatenate(
+        [pha_mids.detach().cpu().numpy(), amp_mids.detach().cpu().numpy()]
+    )
+
+    for i_filter in range(len(mids_all)):
+        mid = mids_all[i_filter]
+        fig = scitex.dsp.utils.filter.plot_filter_responses(
+            filters[i_filter].detach().cpu().numpy(), fs, title=f"{mid:.1f} Hz"
+        )
+        scitex.io.save(
+            fig,
+            f"differentiable_bandpass_filter_reponses_filter#{i_filter:03d}_{mid:.1f}_Hz.png",
+        )
+    # plt.show()
+
+# EOF
+
+"""
+python -m scitex.dsp.utils._differential_bandpass_filters
+"""
+
+# EOF

scitex/dsp/utils/_ensure_3d.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-05 01:04:03 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/dsp/utils/_ensure_3d.py
+
+from ...decorators import torch_fn
+
+
+@torch_fn
+def ensure_3d(x):
+    if x.ndim == 1:  # assumes (seq_len,)
+        x = x.unsqueeze(0).unsqueeze(0)
+    elif x.ndim == 2:  # assumes (batch_siize, seq_len)
+        x = x.unsqueeze(1)
+    return x
+
+
+# EOF

scitex/dsp/utils/_ensure_even_len.py

@@ -0,0 +1,10 @@
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-04-10 11:59:49 (ywatanabe)"
+
+
+def ensure_even_len(x):
+    if x.shape[-1] % 2 == 0:
+        return x
+    else:
+        return x[..., :-1]

scitex/dsp/utils/_zero_pad.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-26 10:30:34 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/dsp/utils/_zero_pad.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/dsp/utils/_zero_pad.py"
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from ...decorators import torch_fn
+
+
+def _zero_pad_1d(x, target_length):
+    """Zero pad a 1D tensor to target length."""
+    if not isinstance(x, torch.Tensor):
+        x = torch.tensor(x)
+    padding_needed = target_length - len(x)
+    padding_left = padding_needed // 2
+    padding_right = padding_needed - padding_left
+    return F.pad(x, (padding_left, padding_right), "constant", 0)
+
+
+def zero_pad(xs, dim=0):
+    """Zero pad a list of arrays to the same length.
+
+    Args:
+        xs: List of tensors or arrays
+        dim: Dimension to stack along
+
+    Returns:
+        Stacked tensor with zero padding
+    """
+    # Convert to tensors if needed
+    tensors = []
+    for x in xs:
+        if isinstance(x, np.ndarray):
+            tensors.append(torch.tensor(x))
+        elif isinstance(x, torch.Tensor):
+            tensors.append(x)
+        else:
+            tensors.append(torch.tensor(x))
+
+    max_len = max([len(x) for x in tensors])
+    return torch.stack([_zero_pad_1d(x, max_len) for x in tensors], dim=dim)
+
+
+# EOF