py-neuromodulation 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

tests/test_nm_filter.py

@@ -0,0 +1,95 @@
+"""Test the nm_filter module."""
+import numpy as np
+from py_neuromodulation import nm_filter
+import pytest
+
+
+class TestMNEFilterData:
+    """Test filter_data method of MNEFilter class."""
+
+    @pytest.mark.parametrize(
+        "filter_length",
+        ["500ms", "999ms", "1999ms", "3999ms", "2s"],
+    )
+    def test_filter_length(self, filter_length) -> None:
+        """Test different filter lengths."""
+        f_ranges = [
+            [13, 35],
+        ]
+        sfreq = 4000
+        duration = 10
+        times = np.linspace(0, duration, int(duration * sfreq))
+        bandpass_filter = nm_filter.MNEFilter(
+            f_ranges=f_ranges,
+            sfreq=sfreq,
+            filter_length=filter_length,
+            l_trans_bandwidth=8,  # transition bandwidth needs to be adjusted for smaller filter length
+            h_trans_bandwidth=8,
+            verbose=None,
+        )
+        oscill_freqs = 50
+        data = np.sin(2 * np.pi * times * oscill_freqs)
+        data_filtered = bandpass_filter.filter_data(data)
+        assert data_filtered.shape == (
+            1,
+            len(f_ranges),
+            duration * sfreq,
+        )
+
+    def test_filter_1d(self) -> None:
+        """Test filtering of 1d array with multiple frequency ranges."""
+        f_ranges = [
+            [4, 8],
+            [8, 12],
+            [13, 35],
+            [60, 200],
+            [200, 500],
+        ]
+        sfreq = 4000
+        duration = 10
+        times = np.linspace(0, duration, int(duration * sfreq))
+        bandpass_filter = nm_filter.MNEFilter(
+            f_ranges=f_ranges,
+            sfreq=sfreq,
+            filter_length="999ms",
+            l_trans_bandwidth=4,
+            h_trans_bandwidth=4,
+            verbose=None,
+        )
+        oscill_freqs = 50
+        data = np.sin(2 * np.pi * times * oscill_freqs)
+        data_filtered = bandpass_filter.filter_data(data)
+        assert data_filtered.shape == (
+            1,
+            len(f_ranges),
+            duration * sfreq,
+        )
+
+    def test_filter_2d(self) -> None:
+        """Test filtering of 2d array with multiple frequency ranges and multiple channels."""
+        f_ranges = [
+            [4, 8],
+            [8, 12],
+            [13, 35],
+            [60, 200],
+            [200, 500],
+        ]
+        sfreq = 4000
+        duration = 10
+        times = np.linspace(0, duration, int(duration * sfreq))
+        bandpass_filter = nm_filter.MNEFilter(
+            f_ranges=f_ranges,
+            sfreq=sfreq,
+            filter_length="999ms",
+            l_trans_bandwidth=4,
+            h_trans_bandwidth=4,
+            verbose=None,
+        )
+        oscill_freqs = np.expand_dims(np.arange(10, 51, 10), axis=-1)
+        data = np.sin(2 * np.pi * times * oscill_freqs)
+        data_filtered = bandpass_filter.filter_data(data)
+        assert data_filtered.shape == (
+            oscill_freqs.shape[0],
+            len(f_ranges),
+            duration * sfreq,
+        )

tests/test_nm_resample.py

@@ -0,0 +1,63 @@
+"""Test the nm_resample module."""
+import numpy as np
+
+from py_neuromodulation import nm_resample
+
+
+def test_upsample():
+    """Test case where data is upsampled."""
+    sfreq_old = 4000.0
+    duration = 10
+    times = np.linspace(0, duration, int(duration * sfreq_old))
+    oscill_freqs = np.expand_dims(np.arange(10, 51, 10), axis=-1)
+    data = np.sin(2 * np.pi * times * oscill_freqs)
+
+    sfreq_new = 1000.0
+    resample = nm_resample.Resampler(
+        resample_freq_hz=sfreq_new,
+        sfreq=sfreq_old,
+    )
+    data_resampled = resample.process(data)
+    assert data_resampled.shape[-1] == int(duration * sfreq_new)
+    # This test only works when ratio of old and new sfreq is an integer
+    # It will also only work up to a certain decimal precision.
+    resampled_naive = data[..., :: int(sfreq_old / sfreq_new)]
+    np.testing.assert_array_almost_equal(
+        data[..., :: int(sfreq_old / sfreq_new)],
+        resampled_naive,
+        decimal=2,
+    )
+
+
+def test_downsample():
+    """Test case where data is downsampled."""
+    sfreq_old = 1000.0
+    duration = 10
+    times = np.linspace(0, duration, int(duration * sfreq_old))
+    oscill_freqs = np.expand_dims(np.arange(10, 51, 10), axis=-1)
+    data = np.sin(2 * np.pi * times * oscill_freqs)
+
+    sfreq_new = 4000.0
+    resample = nm_resample.Resampler(
+        resample_freq_hz=sfreq_new,
+        sfreq=sfreq_old,
+    )
+    data_resampled = resample.process(data)
+    assert data_resampled.shape[-1] == int(duration * sfreq_new)
+
+
+def test_no_resample():
+    """Test case where no resampling is performed."""
+    sfreq_old = 1000.0
+    duration = 10
+    times = np.linspace(0, duration, int(duration * sfreq_old))
+    oscill_freqs = np.expand_dims(np.arange(10, 51, 10), axis=-1)
+    data = np.sin(2 * np.pi * times * oscill_freqs)
+
+    sfreq_new = 1000.0
+    resample = nm_resample.Resampler(
+        resample_freq_hz=sfreq_new,
+        sfreq=sfreq_old,
+    )
+    data_resampled = resample.process(data)
+    np.testing.assert_array_almost_equal(data, data_resampled)

tests/test_normalization_settings.py

@@ -0,0 +1,146 @@
+import os
+import unittest
+import pytest
+import numpy as np
+
+from py_neuromodulation import nm_normalization
+
+
+def test_raw_normalization_init():
+    with pytest.raises(Exception):
+        nm_normalization.RawNormalizer(
+            sfreq=1000,
+            sampling_rate_features_hz=500,
+            normalization_method="meann",
+            normalization_time_s=30,
+            clip=3,
+        )
+
+
+def test_feature_normalization_init():
+    with pytest.raises(Exception):
+        nm_normalization.FeatureNormalizer(
+            sampling_rate_features_hz=500,
+            normalization_method="meann",
+            normalization_time_s=30,
+            clip=3,
+        )
+
+
+def test_process_norm_features():
+    norm = nm_normalization.FeatureNormalizer(
+        sampling_rate_features_hz=500,
+        normalization_method="mean",
+        normalization_time_s=30,
+        clip=3,
+    )
+    data = np.ones([1, 5])
+    data_normed = norm.process(data)
+
+    assert np.all(np.isfinite(data_normed) == True)
+
+    assert np.all(np.equal(data, norm.previous) == 1)
+
+
+def test_previous_size_FeatureNorm():
+    norm = nm_normalization.FeatureNormalizer(
+        sampling_rate_features_hz=10,
+        normalization_method="zscore",
+        normalization_time_s=10,
+        clip=3,
+    )
+
+    num_features = 5
+
+    for _ in range(150):
+        np.random.seed(0)
+        data = norm.process(np.random.random([1, num_features]))
+
+    assert norm.previous.shape[0] < norm.num_samples_normalize
+
+
+def test_zscore_feature_analysis():
+    norm = nm_normalization.FeatureNormalizer(
+        sampling_rate_features_hz=10,
+        normalization_method="zscore",
+        normalization_time_s=30,
+        clip=False,
+    )
+
+    num_features = 5
+
+    for _ in range(400):
+        np.random.seed(0)
+        data_to_norm = np.random.random([1, num_features])
+        data_normed = norm.process(data_to_norm)
+
+    expect_res = (
+        norm.previous[:, 0].std() * data_normed[0, 0]
+        + norm.previous[:, 0].mean()
+    )
+
+    assert pytest.approx(expect_res, 0.1) == data_to_norm[0, 0]
+
+
+def test_zscore_raw_analysis():
+    norm = nm_normalization.RawNormalizer(
+        sampling_rate_features_hz=10,
+        normalization_method="zscore",
+        normalization_time_s=30,
+        sfreq=10,
+        clip=False,
+    )
+
+    num_samples = 100
+
+    for _ in range(400):
+        data_to_norm = np.random.random([1, num_samples])
+        data_normed = norm.process(data_to_norm)
+
+    expect_res = (
+        norm.previous[:, 0].std() * data_normed[0, 0]
+        + norm.previous[:, 0].mean()
+    )
+
+    np.testing.assert_allclose(
+        expect_res, data_to_norm[0, 0], rtol=0.1, atol=0.1
+    )
+
+
+def test_all_norm_methods_raw():
+    for norm_method in [e.value for e in nm_normalization.NORM_METHODS]:
+        norm = nm_normalization.RawNormalizer(
+            sampling_rate_features_hz=10,
+            normalization_method=norm_method,
+            normalization_time_s=30,
+            sfreq=10,
+            clip=False,
+        )
+
+        num_samples = 10
+
+        for _ in range(10):
+            np.random.seed(0)
+            data_to_norm = np.random.random([1, num_samples])
+            data_normed = norm.process(data_to_norm)
+
+        assert np.all(np.isfinite(data_normed) == True)
+
+
+def test_all_norm_methods_feature():
+    for norm_method in [e.value for e in nm_normalization.NORM_METHODS]:
+        norm = nm_normalization.FeatureNormalizer(
+            sampling_rate_features_hz=10,
+            normalization_method=norm_method,
+            normalization_time_s=30,
+            clip=False,
+        )
+
+        num_samples = 10
+
+        for i in range(10):
+            np.random.seed(i)
+            data_to_norm = np.random.random([1, num_samples])
+            data_normed = norm.process(data_to_norm)
+
+        assert np.all(np.isfinite(data_normed) == True)

tests/test_notch_filter.py

@@ -0,0 +1,31 @@
+import numpy as np
+import pytest
+from scipy import fft, signal
+
+from py_neuromodulation import nm_filter
+
+
+def test_notch_filter_setup():
+
+    # by Nyquist theorem, frequencies are computed up to half sfreq
+    for sfreq in [150, 200, 500, 1000]:
+        line_noise = 50
+
+        notch_filter = nm_filter.NotchFilter(sfreq, line_noise)
+
+        # the computed filter is saved in self.filter_bank
+
+        data = np.random.random(sfreq)
+        filtered_dat = notch_filter.process(data)
+
+        Z_filtered = np.abs(fft.rfft(filtered_dat))
+        Z_nonfiltered = np.abs(fft.rfft(data))
+        freqs = fft.rfftfreq(sfreq, 1 / sfreq)
+        idx = (np.abs(freqs - line_noise)).argmin()
+
+        assert np.mean(Z_filtered[idx - 1 : idx + 1]) < np.mean(
+            Z_nonfiltered[idx - 1 : idx + 1]
+        ), (
+            f"testing notch filter with sampling frequency {line_noise} failed"
+            f" for comparison fft power vs no filtering"
+        )