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

tests/test_rereference.py

@@ -0,0 +1,171 @@
+import math
+import os
+import numpy as np
+from numpy.testing import assert_allclose
+import pandas as pd
+import pytest
+
+from py_neuromodulation.nm_rereference import ReReferencer
+from py_neuromodulation import (
+    nm_generator,
+    nm_settings,
+    nm_IO,
+    nm_define_nmchannels,
+)
+
+
+def test_rereference_not_used_channels_no_reref(setup_databatch):
+    ch_names, ch_types, bads, data_batch = setup_databatch
+
+    nm_channels = nm_define_nmchannels.set_channels(
+        ch_names=ch_names,
+        ch_types=ch_types,
+        reference="default",
+        bads=bads,
+        new_names="default",
+        used_types=("ecog", "dbs", "seeg"),
+        target_keywords=("MOV_RIGHT",),
+    )
+
+    re_referencer = ReReferencer(1, nm_channels)
+
+    # select here data that will is selected, this operation takes place in the nm_run_analysis
+    data_used = data_batch[nm_channels["used"] == 1]
+
+    ref_dat = re_referencer.process(data_used)
+
+    for no_ref_idx in np.where(
+        (nm_channels.rereference == "None") & nm_channels.used == 1
+    )[0]:
+        assert_allclose(ref_dat[no_ref_idx, :], data_batch[no_ref_idx, :])
+
+
+def test_rereference_car(setup_databatch):
+    ch_names, ch_types, bads, data_batch = setup_databatch
+
+    nm_channels = nm_define_nmchannels.set_channels(
+        ch_names=ch_names,
+        ch_types=ch_types,
+        reference="default",
+        bads=bads,
+        new_names="default",
+        used_types=("ecog", "dbs", "seeg"),
+        target_keywords=("MOV_RIGHT",),
+    )
+
+    re_referencer = ReReferencer(1, nm_channels)
+
+    data_used = data_batch[nm_channels["used"] == 1]
+
+    ref_dat = re_referencer.process(data_used)
+
+    for ecog_ch_idx in np.where(
+        (nm_channels["type"] == "ecog") & (nm_channels.rereference == "average")
+    )[0]:
+        assert_allclose(
+            ref_dat[ecog_ch_idx, :],
+            data_batch[ecog_ch_idx, :]
+            - data_batch[
+                (nm_channels["type"] == "ecog")
+                & (nm_channels.index != ecog_ch_idx)
+            ].mean(axis=0),
+        )
+
+
+def test_rereference_bp(setup_databatch):
+    ch_names, ch_types, bads, data_batch = setup_databatch
+
+    nm_channels = nm_define_nmchannels.set_channels(
+        ch_names=ch_names,
+        ch_types=ch_types,
+        reference="default",
+        bads=bads,
+        new_names="default",
+        used_types=("ecog", "dbs", "seeg"),
+        target_keywords=("MOV_RIGHT",),
+    )
+
+    re_referencer = ReReferencer(1, nm_channels)
+
+    data_used = data_batch[nm_channels["used"] == 1]
+
+    ref_dat = re_referencer.process(data_used)
+
+    for bp_reref_idx in [
+        ch_idx
+        for ch_idx, ch in enumerate(nm_channels.rereference)
+        if ch in list(nm_channels.name)
+    ]:
+        # bp_reref_idx is the channel index of the rereference anode
+        # referenced_bp_channel is the channel index which is the rereference cathode
+        referenced_bp_channel = np.where(
+            nm_channels.iloc[bp_reref_idx]["rereference"] == nm_channels.name
+        )[0][0]
+        assert_allclose(
+            ref_dat[bp_reref_idx, :],
+            data_batch[bp_reref_idx, :] - data_batch[referenced_bp_channel, :],
+        )
+
+
+def test_rereference_wrong_rererference_column_name(setup_databatch):
+    ch_names, ch_types, bads, data_batch = setup_databatch
+
+    nm_channels = nm_define_nmchannels.set_channels(
+        ch_names=ch_names,
+        ch_types=ch_types,
+        reference="default",
+        bads=bads,
+        new_names="default",
+        used_types=("ecog", "dbs", "seeg"),
+        target_keywords=("SQUARED_ROTATION",),
+    )
+
+    nm_channels.loc[0, "rereference"] = "hallo"
+    with pytest.raises(Exception) as e_info:
+        re_referencer = ReReferencer(1, nm_channels)
+
+
+def test_rereference_muliple_channels(setup_databatch):
+    ch_names, ch_types, bads, data_batch = setup_databatch
+
+    nm_channels = nm_define_nmchannels.set_channels(
+        ch_names=ch_names,
+        ch_types=ch_types,
+        reference="default",
+        bads=bads,
+        new_names="default",
+        used_types=("ecog", "dbs", "seeg"),
+        target_keywords=("MOV_RIGHT",),
+    )
+
+    nm_channels.loc[0, "rereference"] = "LFP_RIGHT_1&LFP_RIGHT_2"
+
+    re_referencer = ReReferencer(1, nm_channels)
+
+    data_used = data_batch[nm_channels["used"] == 1]
+
+    ref_dat = re_referencer.process(data_used)
+
+    assert_allclose(
+        ref_dat[0, :],
+        data_batch[0, :] - (data_batch[1, :] + data_batch[2, :]) / 2,
+    )
+
+
+def test_rereference_same_channel(setup_databatch):
+    ch_names, ch_types, bads, data_batch = setup_databatch
+
+    nm_channels = nm_define_nmchannels.set_channels(
+        ch_names=ch_names,
+        ch_types=ch_types,
+        reference="default",
+        bads=bads,
+        new_names="default",
+        used_types=("ecog", "dbs", "seeg"),
+        target_keywords=("MOV_RIGHT",),
+    )
+
+    nm_channels.loc[0, "rereference"] = nm_channels.loc[0, "name"]
+
+    with pytest.raises(Exception):
+        re_referencer = ReReferencer(1, nm_channels)

tests/test_sampling.py

@@ -0,0 +1,57 @@
+import py_neuromodulation as nm
+import numpy as np
+
+
+def get_fast_compute_settings():
+    settings = nm.nm_settings.get_default_settings()
+    settings = nm.nm_settings.reset_settings(settings)
+    settings = nm.nm_settings.set_settings_fast_compute(settings)
+    settings["preprocessing"] = ["re_referencing", "notch_filter"]
+    settings["features"]["fft"] = True
+    settings["postprocessing"]["feature_normalization"] = True
+    return settings
+
+
+def get_features(time_end_ms: int, segment_length_features_ms: int):
+    data = np.random.random([2, time_end_ms])
+    settings = get_fast_compute_settings()
+    settings["segment_length_features_ms"] = segment_length_features_ms
+    settings["fft_settings"]["windowlength_ms"] = segment_length_features_ms
+
+    settings["frequency_ranges_hz"] = {
+        # "high beta" : [20, 35],
+        "low gamma": [60, 80],
+        "high gamma": [90, 200],
+    }
+    stream = nm.Stream(
+        sfreq=1000,
+        data=data,
+        sampling_rate_features_hz=10,
+        verbose=False,
+        settings=settings,
+    )
+
+    features = stream.run(data)
+    return features
+
+
+def test_feature_timing_5s_start_800ms():
+    """Test if the features timing duration are computed correctly for a 5s signal with 800ms segment length"""
+    time_end_ms = 5000
+    segment_length_features_ms = 800
+    features = get_features(time_end_ms, segment_length_features_ms)
+
+    assert int(features["time"].iloc[0]) == segment_length_features_ms
+
+    assert int(features["time"].iloc[-1]) == time_end_ms
+
+
+def test_feature_timing_1s_start_500ms():
+    """Test if the features timing duration are computed correctly for a 1s signal with 500ms segment length"""
+    time_end_ms = 1000
+    segment_length_features_ms = 500
+    features = get_features(time_end_ms, segment_length_features_ms)
+
+    assert int(features["time"].iloc[0]) == segment_length_features_ms
+
+    assert int(features["time"].iloc[-1]) == time_end_ms

tests/test_settings_change_after_init.py

@@ -0,0 +1,76 @@
+import numpy as np
+
+import py_neuromodulation as nm
+from py_neuromodulation import nm_settings
+
+
+def test_post_init_nm_channels_change():
+    """Test if post initialization of nm_channels will also be ported to the feature computation."""
+
+    data = np.random.random((10, 1000))
+    fs = 1000
+
+    stream = nm.Stream(fs, data)
+
+    # default channel names are "ch{i}"
+    # every time the name changes, the "new_name" should also changes
+    # this is however only done during initialization
+    stream.nm_channels["new_name"] = [f"new_ch_name_{i}" for i in range(10)]
+
+    features = stream.run()
+
+    assert len([f for f in features.columns if "new_ch_name_0" in f]) != 0
+
+
+def test_post_init_nm_channels_used_channels_change_single_channel():
+    """Test if post initialization of nm_settings will also be ported to the feature computation."""
+
+    np.random.seed(0)
+    data = np.random.random((3, 1000))
+    sfreq = 1000
+    stream = nm.Stream(sfreq=sfreq, data=data, sampling_rate_features_hz=11)
+    stream.nm_channels["used"] = 0
+    stream.nm_channels.loc[1, "used"] = 1
+
+    features = stream.run(data)
+
+    chs_not_used = stream.nm_channels[stream.nm_channels["used"] == 0][
+        "new_name"
+    ]
+
+    assert (
+        np.sum(
+            [
+                len([c for c in features.columns if c.startswith(ch_not_used)])
+                for ch_not_used in chs_not_used
+            ]
+        )
+        == 0
+    )
+
+
+def test_post_init_nm_channels_used_channels_change_multiple_channel():
+    """Test if post initialization of nm_settings will also be ported to the feature computation."""
+
+    np.random.seed(0)
+    data = np.random.random((3, 1000))
+    sfreq = 1000
+    stream = nm.Stream(sfreq=sfreq, data=data, sampling_rate_features_hz=11)
+    stream.nm_channels["used"] = 0
+    stream.nm_channels.loc[[0, 2], "used"] = 1
+
+    features = stream.run(data)
+
+    chs_not_used = stream.nm_channels[stream.nm_channels["used"] == 0][
+        "new_name"
+    ]
+
+    assert (
+        np.sum(
+            [
+                len([c for c in features.columns if c.startswith(ch_not_used)])
+                for ch_not_used in chs_not_used
+            ]
+        )
+        == 0
+    )

tests/test_sharpwave.py

@@ -0,0 +1,165 @@
+import pytest
+import numpy as np
+
+from py_neuromodulation import nm_sharpwaves, nm_settings
+
+
+def init_sw_settings() -> dict:
+    settings = nm_settings.get_default_settings()
+    settings["sharpwave_analysis"] = True
+    return settings
+
+
+def test_sharpwaveinit_wrong_peak_param():
+
+    settings = init_sw_settings()
+    with pytest.raises(Exception) as e_info:
+
+        settings["sharpwave_analysis_settings"]["sharpwave_features"][
+            "peak_left"
+        ] = 5
+        nm_sharpwaves.SharpwaveAnalyzer.test_settings(
+            settings, ch_names=[], sfreq=1000
+        )
+
+
+def test_sharpwaveinit_wrong_filter_range():
+    settings = init_sw_settings()
+    with pytest.raises(Exception) as e_info:
+        settings["sharpwave_analysis_settings"]["filter_ranges_hz"] = [
+            [5, 1200]
+        ]
+        nm_sharpwaves.SharpwaveAnalyzer.test_settings(
+            settings, ch_names=[], sfreq=1000
+        )
+
+
+def test_sharpwaveinit_missing_estimator():
+    settings = init_sw_settings()
+    with pytest.raises(Exception) as e_info:
+
+        settings["sharpwave_analysis_settings"]["sharpwave_features"][
+            "prominence"
+        ] = True
+        settings["sharpwave_analysis_settings"]["estimator"]["mean"] = []
+        settings["sharpwave_analysis_settings"]["estimator"]["median"] = []
+        settings["sharpwave_analysis_settings"]["estimator"]["max"] = []
+        settings["sharpwave_analysis_settings"]["estimator"]["min"] = []
+        settings["sharpwave_analysis_settings"]["estimator"]["var"] = []
+
+        nm_sharpwaves.SharpwaveAnalyzer.test_settings(
+            settings, ch_names=[], sfreq=1000
+        )
+
+
+def test_sharpwaveinit_correct_featurelist():
+    settings = init_sw_settings()
+    settings["sharpwave_analysis_settings"]["sharpwave_features"][
+        "prominence"
+    ] = True
+    settings["sharpwave_analysis_settings"]["sharpwave_features"][
+        "interval"
+    ] = True
+    settings["sharpwave_analysis_settings"]["sharpwave_features"][
+        "sharpness"
+    ] = True
+    settings["sharpwave_analysis_settings"]["estimator"]["mean"] = [
+        "prominence",
+        "interval",
+    ]
+    settings["sharpwave_analysis_settings"]["estimator"]["median"] = [
+        "sharpness"
+    ]
+    settings["sharpwave_analysis_settings"]["estimator"]["max"] = []
+    settings["sharpwave_analysis_settings"]["estimator"]["min"] = []
+    settings["sharpwave_analysis_settings"]["estimator"]["var"] = []
+
+    assert (
+        nm_sharpwaves.SharpwaveAnalyzer.test_settings(
+            settings, ch_names=[], sfreq=1000
+        )
+        == None
+    )
+
+
+def test_prominence_features():
+
+    settings = init_sw_settings()
+    sfreq = 1000
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+
+    # Reset feataures
+    for f in settings["sharpwave_analysis_settings"][
+        "sharpwave_features"
+    ].keys():
+        settings["sharpwave_analysis_settings"]["sharpwave_features"][f] = False
+    for est in settings["sharpwave_analysis_settings"]["estimator"].keys():
+        settings["sharpwave_analysis_settings"]["estimator"][est] = []
+
+    settings["sharpwave_analysis_settings"]["sharpwave_features"][
+        "prominence"
+    ] = True
+    settings["sharpwave_analysis_settings"]["estimator"]["max"] = ["prominence"]
+
+    settings["sharpwave_analysis_settings"]["filter_ranges_hz"] = [[5, 80]]
+
+    sw = nm_sharpwaves.SharpwaveAnalyzer(settings, ch_names, sfreq)
+
+    data = np.zeros([len(ch_names), sfreq])
+    data[0, 500] = 1
+    data[1, 500] = 2
+    data[2, 500] = 3
+    data[3, 500] = 4
+
+    features = sw.calc_feature(data, {})
+
+    assert (
+        features["ch4_Sharpwave_Max_prominence_range_5_80"]
+        > features["ch3_Sharpwave_Max_prominence_range_5_80"]
+        > features["ch2_Sharpwave_Max_prominence_range_5_80"]
+        > features["ch1_Sharpwave_Max_prominence_range_5_80"]
+    ), "prominence features were not calculated correctly"
+
+
+def test_interval_feature():
+
+    settings = init_sw_settings()
+    sfreq = 1000
+    ch_names = ["ch1", "ch2", "ch3", "ch4"]
+
+    # Reset feataures
+    for f in settings["sharpwave_analysis_settings"][
+        "sharpwave_features"
+    ].keys():
+        settings["sharpwave_analysis_settings"]["sharpwave_features"][f] = False
+    for est in settings["sharpwave_analysis_settings"]["estimator"].keys():
+        settings["sharpwave_analysis_settings"]["estimator"][est] = []
+
+    settings["sharpwave_analysis_settings"]["sharpwave_features"][
+        "interval"
+    ] = True
+    settings["sharpwave_analysis_settings"]["estimator"]["max"] = ["interval"]
+
+    # the filter cannot be too high, since adjacent ripples will be detected as peaks
+    settings["sharpwave_analysis_settings"]["filter_ranges_hz"] = [[5, 200]]
+
+    sw = nm_sharpwaves.SharpwaveAnalyzer(settings, ch_names, sfreq)
+
+    data = np.zeros([len(ch_names), sfreq])
+    for i in np.arange(0, 1000, 100):
+        data[0, i] = 1
+    for i in np.arange(0, 1000, 200):
+        data[1, i] = 1
+    for i in np.arange(0, 1000, 300):
+        data[2, i] = 1
+    for i in np.arange(0, 1000, 400):
+        data[3, i] = 1
+
+    features = sw.calc_feature(data, {})
+
+    assert (
+        features["ch1_Sharpwave_Max_interval_range_5_200"]
+        < features["ch2_Sharpwave_Max_interval_range_5_200"]
+        < features["ch3_Sharpwave_Max_interval_range_5_200"]
+        < features["ch4_Sharpwave_Max_interval_range_5_200"]
+    ), "interval features were not calculated correctly"

tests/test_target_channel_add.py

@@ -0,0 +1,100 @@
+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_label_add_single_target():
+    sampling_rate_features = 10
+    arr_test = np.random.random([2, 5000])
+    target_arr = np.arange(0, 5000, 1)
+    arr_test[1, :] = target_arr
+
+    settings, nm_channels = get_example_settings(arr_test)
+
+    nm_channels["target"] = [0, 1]
+    nm_channels["used"] = [1, 0]
+    nm_channels.loc[1, "name"] = "target_ch"
+
+    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)
+
+    assert df[
+        "target_ch"
+    ].is_monotonic_increasing, "Not all target values are ascending"
+
+    # check if all "target_ch" values are in the target_arr
+    assert all(
+        [i in target_arr for i in df["target_ch"]]
+    ), "Not all target values are were estimated correctly from the simulated target array"
+
+
+def test_label_add_multidimensional_target():
+    sampling_rate_features = 10
+    arr_test = np.random.random([4, 5000])
+    target_arr = np.arange(0, 5000, 1)
+    target_arr = np.tile(target_arr, (2, 1))
+    arr_test[[0, 2], :] = target_arr
+
+    settings, nm_channels = get_example_settings(arr_test)
+
+    nm_channels["target"] = [1, 0, 1, 0]
+    nm_channels["used"] = [0, 1, 0, 1]
+    nm_channels.loc[0, "name"] = "target_ch_0"
+    nm_channels.loc[2, "name"] = "target_ch_1"
+
+    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)
+
+    for target_ch in ["target_ch_0", "target_ch_1"]:
+        assert df[
+            target_ch
+        ].is_monotonic_increasing, "Not all target values are ascending"
+
+        # check if all "target_ch" values are in the target_arr
+        assert all(
+            [i in target_arr for i in df[target_ch]]
+        ), "Not all target values are were estimated correctly from the simulated target array"
+
+
+def test_label_add_no_target():
+    sampling_rate_features = 10
+    arr_test = np.random.random([4, 5000])
+
+    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)
+
+    assert all([col.startswith("ch") or col.startswith("time") for col in df])

tests/test_timing.py

@@ -0,0 +1,80 @@
+import py_neuromodulation as nm
+from py_neuromodulation import (
+    nm_settings,
+)
+
+import numpy as np
+
+
+def test_setting_computation_time():
+    """Intantiate test for feature computation with fixed time duration.
+    The number of output features should match the ratio of the sampling rate of the data and raw signal sampling rate.
+    """
+
+    data_duration_s = 5
+    sampling_rate_features_hz = 200
+    fs = 1000
+    data = np.random.random((1, int(data_duration_s * fs)))
+
+    settings = nm_settings.get_default_settings()
+    settings = nm_settings.set_settings_fast_compute(settings)
+    settings["segment_length_features_ms"] = 1000  # start afte 1 second
+    settings["features"]["fft"] = False
+    settings["features"]["raw_hjorth"] = True
+    stream = nm.Stream(
+        sfreq=fs,
+        data=data,
+        sampling_rate_features_hz=sampling_rate_features_hz,
+        settings=settings,
+    )
+
+    features = stream.run()
+
+    # test if features up till the last sample was computed
+    assert (
+        data_duration_s * 1000 - features["time"].iloc[-1]
+    ) < 1000 / sampling_rate_features_hz
+
+    # test that the time difference between two samples is the feature sampling rate
+    assert (
+        features["time"].iloc[1] - features["time"].iloc[0]
+    ) == 1000 / sampling_rate_features_hz
+
+    assert features["time"].iloc[0] == settings["segment_length_features_ms"]
+
+
+def test_float_fs():
+    """Change sampling rate here to be float, s.t. rounding issues are not affecting overall number of
+    computed features.
+    """
+
+    data_duration_s = 5
+    sampling_rate_features_hz = 200
+    fs = 1111.111
+    data = np.random.random((1, int(data_duration_s * fs)))
+
+    settings = nm_settings.get_default_settings()
+    settings = nm_settings.set_settings_fast_compute(settings)
+    settings["segment_length_features_ms"] = 333  # start afte 1 second
+
+    settings["features"]["fft"] = False
+    settings["features"]["raw_hjorth"] = True
+    stream = nm.Stream(
+        sfreq=fs,
+        data=data,
+        sampling_rate_features_hz=sampling_rate_features_hz,
+        settings=settings,
+    )
+
+    features = stream.run()
+
+    # test if features up till the last sample was computed
+    assert (
+        data_duration_s * 1000 - features["time"].iloc[-1]
+    ) < 1000 / sampling_rate_features_hz
+
+    assert (
+        features["time"].iloc[1] - features["time"].iloc[0]
+    ) == 1000 / sampling_rate_features_hz
+
+    assert features["time"].iloc[0] == settings["segment_length_features_ms"]

py_neuromodulation/data/README

@@ -1,6 +0,0 @@
-References
-----------
-Appelhoff, S., Sanderson, M., Brooks, T., Vliet, M., Quentin, R., Holdgraf, C., Chaumon, M., Mikulan, E., Tavabi, K., Höchenberger, R., Welke, D., Brunner, C., Rockhill, A., Larson, E., Gramfort, A. and Jas, M. (2019). MNE-BIDS: Organizing electrophysiological data into the BIDS format and facilitating their analysis. Journal of Open Source Software 4: (1896). https://doi.org/10.21105/joss.01896
-
-Holdgraf, C., Appelhoff, S., Bickel, S., Bouchard, K., D'Ambrosio, S., David, O., … Hermes, D. (2019). iEEG-BIDS, extending the Brain Imaging Data Structure specification to human intracranial electrophysiology. Scientific Data, 6, 102. https://doi.org/10.1038/s41597-019-0105-7
-

py_neuromodulation/data/dataset_description.json

@@ -1,8 +0,0 @@
-{
-    "Name": " ",
-    "BIDSVersion": "1.7.0",
-    "DatasetType": "raw",
-    "Authors": [
-        "[Unspecified]"
-    ]
-}