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

tests/test_osc_features.py

@@ -0,0 +1,424 @@
+import numpy as np
+import pytest
+
+from py_neuromodulation import nm_oscillatory, nm_settings
+
+
+def setup_osc_settings(
+    osc_feature_name: str,
+    osc_feature_setting: str,
+    windowlength_ms: int,
+    log_transform: bool,
+):
+    settings = nm_settings.get_default_settings()
+    settings = nm_settings.reset_settings(settings)
+    settings[osc_feature_name] = True
+    settings[osc_feature_setting]["windowlength_ms"] = windowlength_ms
+    settings[osc_feature_setting]["log_transform"] = log_transform
+
+    return settings
+
+
+def test_fft_wrong_logtransform_param_init():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="fft",
+        osc_feature_setting="fft_settings",
+        windowlength_ms=1000,
+        log_transform="123",
+    )
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "beta": [10, 20]}
+
+    with pytest.raises(Exception) as e_info:
+        nm_oscillatory.FFT.test_settings(settings, ch_names, sfreq)
+
+
+def test_fft_wrong_frequencyband_range_init():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="fft",
+        osc_feature_setting="fft_settings",
+        windowlength_ms=1000,
+        log_transform="123",
+    )
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "broadband": [10, 600]}
+
+    with pytest.raises(Exception):
+        nm_oscillatory.FFT.test_settings(settings, ch_names, sfreq)
+
+
+def test_fft_zero_data():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="fft",
+        osc_feature_setting="fft_settings",
+        windowlength_ms=1000,
+        log_transform=False,
+    )
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "beta": [10, 20]}
+    fft_obj = nm_oscillatory.FFT(settings, ch_names, sfreq)
+    fft_obj.test_settings(settings, ch_names, sfreq)
+
+    data = np.ones([len(ch_names), sfreq])
+    features_out = fft_obj.calc_feature(data, {})
+
+    for f in features_out.keys():
+        if "psd_0" not in f:
+            assert np.isclose(features_out[f], 0, atol=1e-6)
+
+
+def test_fft_random_data():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="fft",
+        osc_feature_setting="fft_settings",
+        windowlength_ms=1000,
+        log_transform=False,
+    )
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "beta": [10, 20]}
+    fft_obj = nm_oscillatory.FFT(settings, ch_names, sfreq)
+    fft_obj.test_settings(settings, ch_names, sfreq)
+
+    data = np.random.random([len(ch_names), sfreq])
+    features_out = fft_obj.calc_feature(data, {})
+
+    for f in features_out.keys():
+        assert features_out[f] != 0
+
+
+def test_fft_beta_osc():
+    ch_names = [
+        "ch1",
+    ]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="fft",
+        osc_feature_setting="fft_settings",
+        windowlength_ms=1000,
+        log_transform=False,
+    )
+
+    settings["frequency_ranges_hz"] = {
+        "theta": [4, 8],
+        "beta": [10, 28],
+        "gamma": [50, 60],
+    }
+
+    fft_obj = nm_oscillatory.FFT(settings, ch_names, sfreq)
+    fft_obj.test_settings(settings, ch_names, sfreq)
+
+    time_duration = 1
+
+    time_points = np.arange(0, time_duration, 1 / sfreq)
+    beta_freq = 20
+
+    beta_wave = np.sin(2 * np.pi * beta_freq * time_points)
+
+    np.random.seed(0)
+    data = np.random.random([len(ch_names), sfreq]) + beta_wave
+
+    features_out = fft_obj.calc_feature(data, {})
+
+    assert (
+        features_out["ch1_fft_beta_mean"] > features_out["ch1_fft_theta_mean"]
+        and features_out["ch1_fft_beta_mean"]
+        > features_out["ch1_fft_gamma_mean"]
+    )
+
+
+def test_stft_wrong_logtransform_param_init():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="stft",
+        osc_feature_setting="stft_settings",
+        windowlength_ms=1000,
+        log_transform="123",
+    )
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "beta": [10, 20]}
+
+    with pytest.raises(Exception) as e_info:
+        nm_oscillatory.STFT.test_settings(settings, ch_names, sfreq)
+
+
+def test_stft_wrong_frequencyband_range_init():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="stft",
+        osc_feature_setting="stft_settings",
+        windowlength_ms=1000,
+        log_transform="123",
+    )
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "broadband": [10, 600]}
+
+    with pytest.raises(Exception):
+        nm_oscillatory.STFT.test_settings(settings, ch_names, sfreq)
+
+
+def test_stft_beta_osc():
+    ch_names = [
+        "ch1",
+    ]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="stft",
+        osc_feature_setting="stft_settings",
+        windowlength_ms=1000,
+        log_transform=True,
+    )
+
+    settings["frequency_ranges_hz"] = {
+        "theta": [4, 8],
+        "beta": [10, 28],
+        "gamma": [50, 60],
+    }
+
+    stft_obj = nm_oscillatory.STFT(settings, ch_names, sfreq)
+    stft_obj.test_settings(settings, ch_names, sfreq)
+
+    time_duration = 1
+
+    time_points = np.arange(0, time_duration, 1 / sfreq)
+    beta_freq = 20
+
+    beta_wave = np.sin(2 * np.pi * beta_freq * time_points)
+
+    np.random.seed(0)
+    data = np.random.random([len(ch_names), sfreq]) + beta_wave
+
+    features_out = stft_obj.calc_feature(data, {})
+
+    assert (
+        features_out["ch1_stft_beta_mean"] > features_out["ch1_stft_theta_mean"]
+        and features_out["ch1_stft_beta_mean"]
+        > features_out["ch1_stft_gamma_mean"]
+    )
+
+
+def test_welch_beta_osc():
+    ch_names = [
+        "ch1",
+    ]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="welch",
+        osc_feature_setting="welch_settings",
+        windowlength_ms=1000,
+        log_transform=True,
+    )
+
+    settings["frequency_ranges_hz"] = {
+        "theta": [4, 8],
+        "beta": [10, 28],
+        "gamma": [50, 60],
+    }
+
+    stft_obj = nm_oscillatory.Welch(settings, ch_names, sfreq)
+    stft_obj.test_settings(settings, ch_names, sfreq)
+
+    time_duration = 1
+
+    time_points = np.arange(0, time_duration, 1 / sfreq)
+    beta_freq = 20
+
+    beta_wave = np.sin(2 * np.pi * beta_freq * time_points)
+
+    np.random.seed(0)
+    data = np.random.random([len(ch_names), sfreq]) + beta_wave
+
+    features_out = stft_obj.calc_feature(data, {})
+
+    assert (
+        features_out["ch1_welch_beta_mean"]
+        > features_out["ch1_welch_theta_mean"]
+        and features_out["ch1_welch_beta_mean"]
+        > features_out["ch1_welch_gamma_mean"]
+    )
+
+
+def test_bp_wrong_logtransform_param_init():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="bandpass_filter",
+        osc_feature_setting="bandpass_filter_settings",
+        windowlength_ms=1000,
+        log_transform="123",
+    )
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "beta": [10, 20]}
+
+    with pytest.raises(Exception) as e_info:
+        nm_oscillatory.BandPower.test_settings(settings, ch_names, sfreq)
+
+
+def test_bp_wrong_frequencyband_range_init():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="bandpass_filter",
+        osc_feature_setting="bandpass_filter_settings",
+        windowlength_ms=1000,
+        log_transform="123",
+    )
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "broadband": [10, 600]}
+
+    with pytest.raises(Exception):
+        nm_oscillatory.BandPower.test_settings(settings, ch_names, sfreq)
+
+
+def test_bp_non_defined_fband():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="bandpass_filter",
+        osc_feature_setting="bandpass_filter_settings",
+        windowlength_ms=1000,
+        log_transform=True,
+    )
+
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "broadband": [10, 600]}
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["theta"] = 1000
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["beta"] = 300
+
+    with pytest.raises(Exception):
+        nm_oscillatory.BandPower.test_settings(settings, ch_names, sfreq)
+
+
+def test_bp_segment_length_fb_exceeds_segment_length_features():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = setup_osc_settings(
+        osc_feature_name="bandpass_filter",
+        osc_feature_setting="bandpass_filter_settings",
+        windowlength_ms=1000,
+        log_transform=True,
+    )
+
+    settings["segment_length_features_ms"] = 500
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "broadband": [10, 600]}
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["theta"] = 1000
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["beta"] = 300
+
+    with pytest.raises(Exception):
+        nm_oscillatory.BandPower.test_settings(settings, ch_names, sfreq)
+
+
+def test_bp_zero_data():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = nm_settings.get_default_settings()
+    settings = nm_settings.reset_settings(settings)
+    settings["features"]["bandpass_filter"] = True
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["theta"] = 1000
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["beta"] = 300
+
+    settings["bandpass_filter_settings"]["log_transform"] = False
+    settings["bandpass_filter_settings"]["kalman_filter"] = False
+    settings["bandpass_filter_settings"]["bandpower_features"][
+        "activity"
+    ] = True
+
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "beta": [10, 20]}
+    stft_obj = nm_oscillatory.BandPower(settings, ch_names, sfreq)
+    stft_obj.test_settings(settings, ch_names, sfreq)
+
+    data = np.zeros([len(ch_names), sfreq])
+    features_out = stft_obj.calc_feature(data, {})
+
+    for f in features_out.keys():
+        assert pytest.approx(0, 0.01) == features_out[f]
+
+
+def test_bp_random_data():
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+    sfreq = 1000
+
+    settings = nm_settings.get_default_settings()
+    settings = nm_settings.reset_settings(settings)
+    settings["frequency_ranges_hz"] = {"theta": [4, 8], "beta": [10, 30]}
+    settings["features"]["bandpass_filter"] = True
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["theta"] = 1000
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["beta"] = 300
+
+    settings["bandpass_filter_settings"]["log_transform"] = False
+    settings["bandpass_filter_settings"]["kalman_filter"] = False
+    settings["bandpass_filter_settings"]["bandpower_features"][
+        "activity"
+    ] = True
+
+    stft_obj = nm_oscillatory.BandPower(settings, ch_names, sfreq)
+    stft_obj.test_settings(settings, ch_names, sfreq)
+
+    np.random.seed(0)
+    data = np.random.random([len(ch_names), sfreq])
+    features_out = stft_obj.calc_feature(data, {})
+
+    for f in features_out.keys():
+        assert pytest.approx(0, 0.01) != features_out[f]
+
+
+def test_bp_beta_osc():
+    ch_names = [
+        "ch1",
+    ]
+    sfreq = 1000
+
+    settings = nm_settings.get_default_settings()
+    settings = nm_settings.reset_settings(settings)
+    settings["frequency_ranges_hz"] = {
+        "theta": [4, 8],
+        "beta": [10, 30],
+        "gamma": [50, 60],
+    }
+
+    settings["features"]["bandpass_filter"] = True
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["theta"] = 1000
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["beta"] = 300
+    settings["bandpass_filter_settings"]["segment_lengths_ms"]["gamma"] = 100
+
+    settings["bandpass_filter_settings"]["log_transform"] = False
+    settings["bandpass_filter_settings"]["kalman_filter"] = False
+    settings["bandpass_filter_settings"]["bandpower_features"][
+        "activity"
+    ] = True
+
+    bp_obj = nm_oscillatory.BandPower(settings, ch_names, sfreq)
+    bp_obj.test_settings(settings, ch_names, sfreq)
+
+    time_duration = 1
+
+    time_points = np.arange(0, time_duration, 1 / sfreq)
+    beta_freq = 20
+
+    beta_wave = np.sin(2 * np.pi * beta_freq * time_points)
+
+    np.random.seed(0)
+    data = np.random.random([len(ch_names), sfreq]) + beta_wave
+
+    features_out = bp_obj.calc_feature(data, {})
+
+    assert (
+        features_out["ch1_bandpass_activity_beta"]
+        > features_out["ch1_bandpass_activity_theta"]
+        and features_out["ch1_bandpass_activity_beta"]
+        > features_out["ch1_bandpass_activity_gamma"]
+    )

tests/test_preprocessing_filter.py

@@ -0,0 +1,151 @@
+import numpy as np
+from scipy import signal
+
+from py_neuromodulation import nm_settings
+from py_neuromodulation.nm_filter_preprocessing import PreprocessingFilter
+
+
+def test_preprocessing_within_pipeline(setup_default_stream_fast_compute):
+
+    data, stream = setup_default_stream_fast_compute
+
+    stream.settings["preprocessing"].append("preprocessing_filter")
+
+    stream.settings["preprocessing_filter"]["bandstop_filter"] = True
+    stream.settings["preprocessing_filter"]["bandpass_filter"] = True
+    stream.settings["preprocessing_filter"]["lowpass_filter"] = True
+    stream.settings["preprocessing_filter"]["highpass_filter"] = True
+
+    stream.sfreq
+
+    try:
+        _ = stream.run(data[:, : int(stream.sfreq * 2)])
+    except Exception as e:
+        assert False, f"Error in pipeline including preprocess filtering : {e}"
+
+
+def test_preprocessing_filter_lowpass():
+
+    data_batch = np.random.random([1, 1000])
+
+    settings = nm_settings.get_default_settings()
+    settings["preprocessing"] = settings["preprocessing"].append(
+        "preprocessing_filter"
+    )
+    settings["preprocessing_filter"]["lowpass_filter"] = True
+    settings["preprocessing_filter"]["highpass_filter"] = False
+    settings["preprocessing_filter"]["bandpass_filter"] = False
+    settings["preprocessing_filter"]["bandstop_filter"] = False
+
+    settings["preprocessing_filter"]["lowpass_filter_settings"][
+        "frequency_cutoff_hz"
+    ] = 100
+
+    sfreq = 1000
+
+    preprocessing_filter = PreprocessingFilter(settings, sfreq)
+    data_filtered = preprocessing_filter.process(data_batch)
+
+    # compute a scipy signal welch to check if the filter worked
+    f, Pxx = signal.welch(data_batch, fs=sfreq, nperseg=1000)
+    f, Pxx_f = signal.welch(data_filtered, fs=sfreq, nperseg=1000)
+
+    # check if the power in the frequency range of the lowpass filter is reduced
+    assert np.mean(Pxx_f[0, 100:500]) < np.mean(Pxx[0, 100:500])
+
+
+def test_preprocessing_filter_highpass():
+
+    data_batch = np.random.random([1, 1000])
+
+    settings = nm_settings.get_default_settings()
+    settings["preprocessing"] = settings["preprocessing"].append(
+        "preprocessing_filter"
+    )
+    settings["preprocessing_filter"]["highpass_filter"] = True
+    settings["preprocessing_filter"]["lowpass_filter"] = False
+    settings["preprocessing_filter"]["bandpass_filter"] = False
+    settings["preprocessing_filter"]["bandstop_filter"] = False
+
+    settings["preprocessing_filter"]["highpass_filter_settings"][
+        "frequency_cutoff_hz"
+    ] = 100
+
+    sfreq = 1000
+
+    preprocessing_filter = PreprocessingFilter(settings, sfreq)
+    data_filtered = preprocessing_filter.process(data_batch)
+
+    # compute a scipy signal welch to check if the filter worked
+    f, Pxx = signal.welch(data_batch, fs=sfreq, nperseg=1000)
+    f, Pxx_f = signal.welch(data_filtered, fs=sfreq, nperseg=1000)
+
+    # check if the power in the frequency range of the highpass filter is reduced
+    assert np.mean(Pxx_f[0, 0:100]) < np.mean(Pxx[0, 0:100])
+
+
+def test_preprocessing_filter_bandstop():
+
+    data_batch = np.random.random([1, 1000])
+
+    settings = nm_settings.get_default_settings()
+    settings["preprocessing"] = settings["preprocessing"].append(
+        "preprocessing_filter"
+    )
+    settings["preprocessing_filter"]["bandstop_filter"] = True
+    settings["preprocessing_filter"]["bandpass_filter"] = False
+    settings["preprocessing_filter"]["lowpass_filter"] = False
+    settings["preprocessing_filter"]["highpass_filter"] = False
+
+    settings["preprocessing_filter"]["bandstop_filter_settings"][
+        "frequency_low_hz"
+    ] = 100
+    settings["preprocessing_filter"]["bandstop_filter_settings"][
+        "frequency_high_hz"
+    ] = 160
+
+    sfreq = 1000
+
+    preprocessing_filter = PreprocessingFilter(settings, sfreq)
+    data_filtered = preprocessing_filter.process(data_batch)
+
+    # compute a scipy signal welch to check if the filter worked
+    f, Pxx = signal.welch(data_batch, fs=sfreq, nperseg=1000)
+    f, Pxx_f = signal.welch(data_filtered, fs=sfreq, nperseg=1000)
+
+    # check if the power in the frequency range of the bandstop filter is reduced
+    assert np.mean(Pxx_f[0, 100:160]) < np.mean(Pxx[0, 100:160])
+
+
+def test_preprocessing_filter_bandpass():
+
+    data_batch = np.random.random([1, 1000])
+
+    settings = nm_settings.get_default_settings()
+    settings["preprocessing"] = settings["preprocessing"].append(
+        "preprocessing_filter"
+    )
+    settings["preprocessing_filter"]["bandstop_filter"] = False
+    settings["preprocessing_filter"]["bandpass_filter"] = True
+    settings["preprocessing_filter"]["lowpass_filter"] = False
+    settings["preprocessing_filter"]["highpass_filter"] = False
+
+    settings["preprocessing_filter"]["bandpass_filter_settings"][
+        "frequency_low_hz"
+    ] = 100
+    settings["preprocessing_filter"]["bandpass_filter_settings"][
+        "frequency_high_hz"
+    ] = 160
+
+    sfreq = 1000
+
+    preprocessing_filter = PreprocessingFilter(settings, sfreq)
+    data_filtered = preprocessing_filter.process(data_batch)
+
+    # compute a scipy signal welch to check if the filter worked
+    f, Pxx = signal.welch(data_batch, fs=sfreq, nperseg=1000)
+    f, Pxx_f = signal.welch(data_filtered, fs=sfreq, nperseg=1000)
+
+    # check if the power in the frequency range of the bandpass filter is reduced
+    assert np.mean(Pxx_f[0, 0:100]) < np.mean(Pxx[0, 0:100])
+    assert np.mean(Pxx_f[0, 160:500]) < np.mean(Pxx[0, 160:500])