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

tests/test_feature_sampling_rates.py

@@ -0,0 +1,143 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from py_neuromodulation import (
+    nm_settings,
+    nm_stream_offline,
+    nm_define_nmchannels,
+    nm_stream_abc,
+)
+
+
+def get_example_settings(test_arr: np.array) -> nm_stream_abc.PNStream:
+    settings = nm_settings.set_settings_fast_compute(
+        nm_settings.get_default_settings()
+    )
+
+    nm_channels = nm_define_nmchannels.get_default_channels_from_data(test_arr)
+
+    return settings, nm_channels
+
+
+def test_different_sampling_rate_100Hz():
+    sampling_rate_features = 100
+
+    arr_test = np.random.random([2, 1020])
+    settings, nm_channels = get_example_settings(arr_test)
+
+    settings["sampling_rate_features_hz"] = sampling_rate_features
+    stream = nm_stream_offline.Stream(
+        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
+    )
+
+    df = stream.run(arr_test)
+
+    # check the difference between time points
+
+    assert np.diff(df["time"].iloc[:2]) / 1000 == (1 / sampling_rate_features)
+
+
+def test_different_sampling_rate_10Hz():
+    sampling_rate_features = 10
+
+    arr_test = np.random.random([2, 1200])
+    settings, nm_channels = get_example_settings(arr_test)
+
+    settings["sampling_rate_features_hz"] = sampling_rate_features
+    stream = nm_stream_offline.Stream(
+        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
+    )
+
+    df = stream.run(arr_test)
+
+    # check the difference between time points
+
+    assert np.diff(df["time"].iloc[:2]) / 1000 == (1 / sampling_rate_features)
+
+
+def test_different_sampling_rate_1Hz():
+    sampling_rate_features = 1
+
+    arr_test = np.random.random([2, 3000])
+    settings, nm_channels = get_example_settings(arr_test)
+
+    settings["sampling_rate_features_hz"] = sampling_rate_features
+    stream = nm_stream_offline.Stream(
+        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
+    )
+
+    df = stream.run(arr_test)
+
+    # check the difference between time points
+
+    assert np.diff(df["time"].iloc[:2]) / 1000 == (1 / sampling_rate_features)
+
+
+def test_different_sampling_rate_0DOT1Hz():
+    sampling_rate_features = 0.1
+
+    arr_test = np.random.random([2, 30000])
+    settings, nm_channels = get_example_settings(arr_test)
+
+    settings["sampling_rate_features_hz"] = sampling_rate_features
+    stream = nm_stream_offline.Stream(
+        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
+    )
+
+    df = stream.run(arr_test)
+
+    # check the difference between time points
+
+    assert np.diff(df["time"].iloc[:2]) / 1000 == (1 / sampling_rate_features)
+
+
+def test_wrong_initalization_of_segment_length_features_ms_and_osc_window_length():
+    segment_length_features_ms = 800
+
+    arr_test = np.random.random([2, 1200])
+    settings, nm_channels = get_example_settings(arr_test)
+
+    settings["segment_length_features_ms"] = 800
+    settings["fft_settings"]["windowlength_ms"] = 1000
+
+    with pytest.raises(Exception):
+        stream = nm_stream_offline.Stream(
+            sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
+        )
+
+
+def test_different_segment_lengths():
+    segment_length_features_ms = 800
+
+    arr_test = np.random.random([2, 1200])
+    settings, nm_channels = get_example_settings(arr_test)
+
+    settings["segment_length_features_ms"] = segment_length_features_ms
+    settings["fft_settings"]["windowlength_ms"] = segment_length_features_ms
+
+    stream = nm_stream_offline.Stream(
+        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
+    )
+
+    df_seglength_800 = stream.run(arr_test)
+
+    segment_length_features_ms = 1000
+
+    arr_test = np.random.random([2, 1200])
+    settings, nm_channels = get_example_settings(arr_test)
+
+    settings["segment_length_features_ms"] = segment_length_features_ms
+    settings["fft_settings"]["windowlength_ms"] = segment_length_features_ms
+
+    stream = nm_stream_offline.Stream(
+        sfreq=1000, nm_channels=nm_channels, settings=settings, verbose=True
+    )
+
+    df_seglength_1000 = stream.run(arr_test)
+    # check the difference between time points
+
+    assert (
+        df_seglength_1000.iloc[0]["ch0-avgref_fft_theta_mean"]
+        != df_seglength_800.iloc[0]["ch0-avgref_fft_theta_mean"]
+    )

tests/test_fooof.py

@@ -0,0 +1,16 @@
+from py_neuromodulation import nm_generator
+
+
+def test_fooof_features(setup_default_stream_fast_compute):
+
+    data, stream = setup_default_stream_fast_compute
+
+    generator = nm_generator.raw_data_generator(
+        data, stream.settings, stream.sfreq
+    )
+    data_batch = next(generator, None)
+    feature_series = stream.run_analysis.process(data_batch)
+    # since the settings can define searching for "max_n_peaks" peaks
+    # there can be None's in the feature_series
+    # with a non successful fit, aperiodic features can also be None
+    assert feature_series is not None

tests/test_initalization_offline_stream.py

@@ -0,0 +1,41 @@
+import numpy as np
+import pytest
+
+import py_neuromodulation as nm
+
+
+def test_stream_init():
+    """Test if stream initialization with passed data will setup nm_channels correctly"""
+    np.random.seed(0)
+    data = np.random.random((10, 1000))
+    sfreq = 100
+    stream = nm.Stream(sfreq=sfreq, data=data, sampling_rate_features_hz=11)
+
+    assert stream.nm_channels.shape[0] == 10
+    assert stream.settings["sampling_rate_features_hz"] == 11
+
+
+def test_stream_init_no_sfreq():
+    """Check if stream initialization without sfreq will raise an error"""
+    np.random.seed(0)
+    data = np.random.random((10, 1000))
+    with pytest.raises(Exception):
+        nm.Stream(data=data, sampling_rate_features_hz=11)
+
+
+def test_init_warning_no_used_channel():
+    """Check if a warning is raised when a stream is initialized with nm_channels, but no row has used == 1 and target == 0"""
+    np.random.seed(0)
+    data = np.random.random((10, 1000))
+    sfreq = 1000
+    stream = nm.Stream(sfreq=sfreq, data=data, sampling_rate_features_hz=11)
+    channels = stream.nm_channels
+    channels["used"] = 0
+
+    with pytest.raises(Exception):
+        nm.Stream(
+            sfreq=sfreq,
+            data=data,
+            nm_channels=channels,
+            sampling_rate_features_hz=11,
+        )

tests/test_multiprocessing.py

@@ -0,0 +1,58 @@
+import py_neuromodulation as pn
+import numpy as np
+from py_neuromodulation import nm_settings
+import pytest
+
+
+@pytest.fixture
+def get_stream():
+    NUM_CHANNELS = 10
+    NUM_DATA = 10000
+    sfreq = 1000  # Hz
+    sampling_rate_features_hz = 3  # Hz
+
+    data = np.random.random([NUM_CHANNELS, NUM_DATA])
+
+    stream = pn.Stream(
+        sfreq=sfreq,
+        data=data,
+        sampling_rate_features_hz=sampling_rate_features_hz,
+    )
+    stream.nm_channels.loc[0, "target"] = 1
+    stream.nm_channels.loc[0, "used"] = 0
+    stream.settings["postprocessing"]["feature_normalization"] = False
+    stream.settings["segment_length_features_ms"] = 5000
+    for feature in stream.settings["features"]:
+        stream.settings["features"][feature] = False
+    stream.settings["features"]["nolds"] = False
+    stream.settings["features"]["fooof"] = True
+    stream.settings["features"]["bursts"] = False
+    stream.settings["features"]["mne_connectivity"] = False
+    stream.settings["coherence"]["channels"] = [["ch1", "ch2"]]
+    return stream
+
+
+def test_setting_exception(get_stream):
+    stream = get_stream
+    stream.settings["features"]["burst"] = True
+
+    with pytest.raises(Exception) as e_info:
+        stream.run(parallel=True, n_jobs=-1)
+
+
+def test_multiprocessing_and_sequntial_features(get_stream):
+    stream_seq = get_stream
+    features_sequential = stream_seq.run(parallel=False)
+
+    stream_par = get_stream
+    features_multiprocessing = stream_par.run(parallel=True, n_jobs=-1)
+
+    for column in features_sequential.columns:
+        if "fooof" in column:
+            # fooof results are different in multiprocessing and sequential processing
+            # This tests fails on Linux and Windows but passes on Mac OS; no idea why
+            continue
+
+        assert features_sequential[column].equals(
+            features_multiprocessing[column]
+        ), f"Column {column} is not equal between sequential and parallel dataframes computation"

tests/test_nan_values.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+import py_neuromodulation as nm
+
+
+def test_stream_with_none_data():
+    """Test if passing None as the data to a Stream object results in None features."""
+
+    fs = 1000
+    data = np.random.random([2, 2000])
+    data[0, :] = None
+
+    stream = nm.Stream(fs, data)
+
+    features = stream.run(data)
+
+    # assert if all features if name ch0 are None
+    assert len(
+        [f for f in features.columns if "ch0" in f and features[f].isna().all()]
+    ) == len([f for f in features if "ch0" in f])
+
+    # and check if all features of the second channel are not None
+    assert len(
+        [
+            f
+            for f in features.columns
+            if "ch1" in f and features[f].notna().all()
+        ]
+    ) == len([f for f in features if "ch1" in f])

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"
+        )