braindecode 0.5.1__py3-none-any.whl

test/acceptance_tests/test_eeg_classifier.py

@@ -0,0 +1,255 @@
+# Authors: Maciej Sliwowski
+#          Robin Tibor Schirrmeister
+#          Lukas Gemein
+#
+# License: BSD-3
+
+import mne
+import numpy as np
+from mne.io import concatenate_raws
+from skorch.helper import predefined_split
+from torch import optim
+from torch.nn.functional import nll_loss
+
+from braindecode.classifier import EEGClassifier
+from braindecode.datautil.xy import create_from_X_y
+from braindecode.training.losses import CroppedLoss
+from braindecode.models import ShallowFBCSPNet
+from braindecode.models.util import to_dense_prediction_model
+from braindecode.training.scoring import CroppedTrialEpochScoring
+from braindecode.util import set_random_seeds, np_to_var
+
+
+def assert_deep_allclose(expected, actual, *args, **kwargs):
+    """
+    Assert that two complex structures have almost equal contents.
+
+    Compares lists, dicts and tuples recursively. Checks numeric values
+    using test_case's :py:meth:`unittest.TestCase.assertAlmostEqual` and
+    checks all other values with :py:meth:`unittest.TestCase.assertEqual`.
+    Accepts additional positional and keyword arguments and pass those
+    intact to assertAlmostEqual() (that's how you specify comparison
+    precision).
+    """
+    is_root = not "__trace" in kwargs
+    trace = kwargs.pop("__trace", "ROOT")
+    try:
+        if isinstance(expected, (int, float, complex)):
+            np.testing.assert_allclose(expected, actual, *args, **kwargs)
+        elif isinstance(expected, (list, tuple, np.ndarray)):
+            assert len(expected) == len(actual)
+            for index in range(len(expected)):
+                v1, v2 = expected[index], actual[index]
+                assert_deep_allclose(
+                    v1, v2, __trace=repr(index), *args, **kwargs
+                )
+        elif isinstance(expected, dict):
+            assert set(expected) == set(actual)
+            for key in expected:
+                assert_deep_allclose(
+                    expected[key],
+                    actual[key],
+                    __trace=repr(key),
+                    *args,
+                    **kwargs
+                )
+        else:
+            assert expected == actual
+    except AssertionError as exc:
+        exc.__dict__.setdefault("traces", []).append(trace)
+        msg = (
+            exc.message
+            if hasattr(exc, "message")
+            else exc.args[0]
+            if exc.args
+            else ""
+        )
+        if is_root:
+            trace = " -> ".join(reversed(exc.traces))
+            exc = AssertionError("%s\nTRACE: %s" % (msg, trace))
+        raise exc
+
+
+def test_eeg_classifier():
+    # 5,6,7,10,13,14 are codes for executed and imagined hands/feet
+    subject_id = 1
+    event_codes = [5, 6, 9, 10, 13, 14]
+
+    # This will download the files if you don't have them yet,
+    # and then return the paths to the files.
+    physionet_paths = mne.datasets.eegbci.load_data(
+        subject_id, event_codes, update_path=False
+    )
+
+    # Load each of the files
+    parts = [
+        mne.io.read_raw_edf(
+            path, preload=True, stim_channel="auto", verbose="WARNING"
+        )
+        for path in physionet_paths
+    ]
+
+    # Concatenate them
+    raw = concatenate_raws(parts)
+
+    # Find the events in this dataset
+    events, _ = mne.events_from_annotations(raw)
+
+    # Use only EEG channels
+    eeg_channel_inds = mne.pick_types(
+        raw.info, meg=False, eeg=True, stim=False, eog=False, exclude="bads"
+    )
+
+    # Extract trials, only using EEG channels
+    epoched = mne.Epochs(
+        raw,
+        events,
+        dict(hands=2, feet=3),
+        tmin=1,
+        tmax=4.1,
+        proj=False,
+        picks=eeg_channel_inds,
+        baseline=None,
+        preload=True,
+    )
+
+    # Convert data from volt to millivolt
+    # Pytorch expects float32 for input and int64 for labels.
+    X = (epoched.get_data() * 1e6).astype(np.float32)
+    y = (epoched.events[:, 2] - 2).astype(np.int64)  # 2,3 -> 0,1
+
+    # Set if you want to use GPU
+    # You can also use torch.cuda.is_available() to determine if cuda is available on your machine.
+    cuda = False
+    set_random_seeds(seed=20170629, cuda=cuda)
+
+    # This will determine how many crops are processed in parallel
+    input_window_samples = 450
+    n_classes = 2
+    in_chans = X.shape[1]
+    # final_conv_length determines the size of the receptive field of the ConvNet
+    model = ShallowFBCSPNet(
+        in_chans=in_chans,
+        n_classes=n_classes,
+        input_window_samples=input_window_samples,
+        final_conv_length=12,
+    )
+    to_dense_prediction_model(model)
+
+    if cuda:
+        model.cuda()
+
+    # determine output size
+    test_input = np_to_var(
+        np.ones((2, in_chans, input_window_samples, 1), dtype=np.float32)
+    )
+    if cuda:
+        test_input = test_input.cuda()
+    out = model(test_input)
+    n_preds_per_input = out.cpu().data.numpy().shape[2]
+
+    train_set = create_from_X_y(X[:48], y[:48],
+                                drop_last_window=False,
+                                window_size_samples=input_window_samples,
+                                window_stride_samples=n_preds_per_input)
+
+    valid_set = create_from_X_y(X[48:60], y[48:60],
+                                drop_last_window=False,
+                                window_size_samples=input_window_samples,
+                                window_stride_samples=n_preds_per_input)
+
+    cropped_cb_train = CroppedTrialEpochScoring(
+        "accuracy",
+        name="train_trial_accuracy",
+        lower_is_better=False,
+        on_train=True,
+    )
+
+    cropped_cb_valid = CroppedTrialEpochScoring(
+        "accuracy",
+        on_train=False,
+        name="valid_trial_accuracy",
+        lower_is_better=False,
+    )
+
+    clf = EEGClassifier(
+        model,
+        cropped=True,
+        criterion=CroppedLoss,
+        criterion__loss_function=nll_loss,
+        optimizer=optim.Adam,
+        train_split=predefined_split(valid_set),
+        batch_size=32,
+        callbacks=[
+            ("train_trial_accuracy", cropped_cb_train),
+            ("valid_trial_accuracy", cropped_cb_valid),
+        ],
+    )
+
+    clf.fit(train_set, y=None, epochs=4)
+
+    expected = [{'batches': [{'train_batch_size': 32, 'train_loss': 1.6639312505722046},
+                             {'train_batch_size': 32, 'train_loss': 2.6161606311798096},
+                             {'train_batch_size': 32, 'train_loss': 1.627132773399353},
+                             {'valid_batch_size': 24, 'valid_loss': 0.9677614569664001}],
+                 'epoch': 1,
+                 'train_batch_count': 3,
+                 'train_loss': 1.9690748850504558,
+                 'train_loss_best': True,
+                 'train_trial_accuracy': 0.4791666666666667,
+                 'train_trial_accuracy_best': True,
+                 'valid_batch_count': 1,
+                 'valid_loss': 0.9677614569664001,
+                 'valid_loss_best': True,
+                 'valid_trial_accuracy': 0.5,
+                 'valid_trial_accuracy_best': True},
+                {'batches': [{'train_batch_size': 32, 'train_loss': 1.3829222917556763},
+                             {'train_batch_size': 32, 'train_loss': 1.3123714923858643},
+                             {'train_batch_size': 32, 'train_loss': 1.0109959840774536},
+                             {'valid_batch_size': 24, 'valid_loss': 1.9435862302780151}],
+                 'epoch': 2,
+                 'train_batch_count': 3,
+                 'train_loss': 1.2354299227396648,
+                 'train_loss_best': True,
+                 'train_trial_accuracy': 0.5,
+                 'train_trial_accuracy_best': True,
+                 'valid_batch_count': 1,
+                 'valid_loss': 1.9435862302780151,
+                 'valid_loss_best': False,
+                 'valid_trial_accuracy': 0.5,
+                 'valid_trial_accuracy_best': False},
+                {'batches': [{'train_batch_size': 32, 'train_loss': 1.172208547592163},
+                             {'train_batch_size': 32, 'train_loss': 0.8899562954902649},
+                             {'train_batch_size': 32, 'train_loss': 1.0232216119766235},
+                             {'valid_batch_size': 24, 'valid_loss': 0.9585554599761963}],
+                 'epoch': 3,
+                 'train_batch_count': 3,
+                 'train_loss': 1.0284621516863506,
+                 'train_loss_best': True,
+                 'train_trial_accuracy': 0.5,
+                 'train_trial_accuracy_best': False,
+                 'valid_batch_count': 1,
+                 'valid_loss': 0.9585554599761963,
+                 'valid_loss_best': True,
+                 'valid_trial_accuracy': 0.5,
+                 'valid_trial_accuracy_best': False},
+                {'batches': [{'train_batch_size': 32, 'train_loss': 0.9693693518638611},
+                             {'train_batch_size': 32, 'train_loss': 0.900641918182373},
+                             {'train_batch_size': 32, 'train_loss': 0.8839665651321411},
+                             {'valid_batch_size': 24, 'valid_loss': 0.873468816280365}],
+                 'epoch': 4,
+                 'train_batch_count': 3,
+                 'train_loss': 0.9179926117261251,
+                 'train_loss_best': True,
+                 'train_trial_accuracy': 0.625,
+                 'train_trial_accuracy_best': True,
+                 'valid_batch_count': 1,
+                 'valid_loss': 0.873468816280365,
+                 'valid_loss_best': True,
+                 'valid_trial_accuracy': 0.4166666666666667,
+                 'valid_trial_accuracy_best': False}]
+
+    history_without_dur = [
+        {k: v for k, v in h.items() if k != "dur"} for h in clf.history
+    ]
+    assert_deep_allclose(expected, history_without_dur, atol=1e-3, rtol=1e-3)

test/acceptance_tests/test_model_architectures.py

@@ -0,0 +1,54 @@
+# Authors: Lukas Gemein <l.gemein@gmail.com>
+#
+#
+# License: BSD-3
+
+import torch
+import numpy as np
+
+from braindecode.models.tcn import TCN
+from braindecode.util import set_random_seeds
+
+
+def test_tcn():
+    set_random_seeds(0, False)
+    tcn = TCN(
+        n_in_chans=21,
+        n_outputs=2,
+        n_filters=55,
+        n_blocks=5,
+        kernel_size=16,
+        drop_prob=0.05270154233150525,
+        add_log_softmax=True
+    )
+    # braindecode models are always in eval mode after initialization
+    # original model implementation was not
+    tcn.train()
+    x = torch.rand(1, 21, 1000, 1)
+    out = tcn(x)
+    # this is the output of the original model implementation using the same
+    # initialization arguments as above
+    expected = np.array(
+        [[[-0.5504, -0.5304, -0.6023, -0.5231, -0.5387, -0.5522, -0.5323,
+           -0.5540, -0.5297, -0.5333, -0.5743, -0.5330, -0.5117, -0.5051,
+           -0.5523, -0.5507, -0.5724, -0.5380, -0.5697, -0.4871, -0.5400,
+           -0.4986, -0.5502, -0.5524, -0.5263, -0.5440, -0.5464, -0.5005,
+           -0.5404, -0.5098, -0.5197, -0.5578, -0.5419, -0.5601, -0.5031,
+           -0.5616, -0.5205, -0.5378, -0.5472, -0.4897, -0.5216, -0.5560,
+           -0.5480, -0.5488, -0.5258, -0.5637, -0.5318, -0.5134, -0.5460,
+           -0.5294, -0.5513, -0.5310, -0.5307, -0.5326, -0.5270, -0.5156,
+           -0.5569, -0.5416, -0.5279, -0.5553, -0.5589, -0.5166, -0.5108,
+           -0.5076, -0.5279, -0.5208, -0.5367, -0.5557, -0.5690, -0.5494],
+          [-0.8597, -0.8877, -0.7931, -0.8982, -0.8758, -0.8573, -0.8849,
+           -0.8549, -0.8887, -0.8834, -0.8280, -0.8839, -0.9150, -0.9250,
+           -0.8572, -0.8593, -0.8305, -0.8769, -0.8340, -0.9530, -0.8741,
+           -0.9350, -0.8600, -0.8570, -0.8935, -0.8685, -0.8652, -0.9319,
+           -0.8735, -0.9179, -0.9031, -0.8497, -0.8714, -0.8466, -0.9280,
+           -0.8447, -0.9019, -0.8771, -0.8640, -0.9489, -0.9003, -0.8521,
+           -0.8630, -0.8619, -0.8942, -0.8419, -0.8856, -0.9124, -0.8658,
+           -0.8890, -0.8585, -0.8867, -0.8872, -0.8845, -0.8924, -0.9092,
+           -0.8509, -0.8718, -0.8912, -0.8531, -0.8482, -0.9077, -0.9163,
+           -0.9212, -0.8912, -0.9016, -0.8787, -0.8525, -0.8349,
+           -0.8611]]])
+    np.testing.assert_allclose(
+        out.detach().numpy(), expected, rtol=1e-3, atol=1e-3)

test/acceptance_tests/test_trialwise_decoding.py

@@ -0,0 +1,168 @@
+# Authors: Maciej Sliwowski
+#          Robin Tibor Schirrmeister
+#
+# License: BSD-3
+
+import mne
+import numpy as np
+import torch
+from mne.io import concatenate_raws
+from skorch.helper import predefined_split
+from torch.utils.data import Dataset, Subset
+
+from braindecode.classifier import EEGClassifier
+from braindecode.models import ShallowFBCSPNet
+from braindecode.util import set_random_seeds
+
+
+class EpochsDataset(Dataset):
+    def __init__(self, windows):
+        self.windows = windows
+        self.y = np.array(self.windows.events[:, -1])
+        self.y = self.y - self.y.min()
+
+    def __getitem__(self, index):
+        X = self.windows.get_data(item=index)[0].astype('float32')[:, :, None]
+        y = self.y[index]
+        return X, y
+
+    def __len__(self):
+        return len(self.windows.events)
+
+
+def test_trialwise_decoding():
+    # 5,6,7,10,13,14 are codes for executed and imagined hands/feet
+    subject_id = 1
+    event_codes = [5, 6, 9, 10, 13, 14]
+
+    # This will download the files if you don't have them yet,
+    # and then return the paths to the files.
+    physionet_paths = mne.datasets.eegbci.load_data(
+        subject_id, event_codes, update_path=False
+    )
+
+    # Load each of the files
+    parts = [
+        mne.io.read_raw_edf(
+            path, preload=True, stim_channel="auto", verbose="WARNING"
+        )
+        for path in physionet_paths
+    ]
+
+    # Concatenate them
+    raw = concatenate_raws(parts)
+    raw.apply_function(lambda x: x * 1000000)
+
+    # Find the events in this dataset
+    events, _ = mne.events_from_annotations(raw)
+    # Use only EEG channels
+    eeg_channel_inds = mne.pick_types(
+        raw.info, meg=False, eeg=True, stim=False, eog=False, exclude="bads"
+    )
+
+    # Extract trials, only using EEG channels
+    epoched = mne.Epochs(
+        raw,
+        events,
+        dict(hands=2, feet=3),
+        tmin=1,
+        tmax=4.1,
+        proj=False,
+        picks=eeg_channel_inds,
+        baseline=None,
+        preload=True,
+    )
+
+    ds = EpochsDataset(epoched)
+
+    train_set = Subset(ds, np.arange(60))
+    valid_set = Subset(ds, np.arange(60, len(ds)))
+
+    train_valid_split = predefined_split(valid_set)
+
+    cuda = False
+    if cuda:
+        device = 'cuda'
+    else:
+        device = 'cpu'
+    set_random_seeds(seed=20170629, cuda=cuda)
+    n_classes = 2
+    in_chans = train_set[0][0].shape[0]
+    input_window_samples = train_set[0][0].shape[1]
+    model = ShallowFBCSPNet(
+        in_chans=in_chans,
+        n_classes=n_classes,
+        input_window_samples=input_window_samples,
+        final_conv_length="auto",
+    )
+    if cuda:
+        model.cuda()
+
+    clf = EEGClassifier(
+        model,
+        cropped=False,
+        criterion=torch.nn.NLLLoss,
+        optimizer=torch.optim.Adam,
+        train_split=train_valid_split,
+        optimizer__lr=0.001,
+        batch_size=30,
+        callbacks=["accuracy"],
+        device=device,
+    )
+    clf.fit(train_set, y=None, epochs=6)
+
+    np.testing.assert_allclose(
+        clf.history[:, 'train_loss'],
+        np.array([
+            1.623811,
+            1.141197,
+            0.730361,
+            0.5994,
+            0.738884,
+            0.419241
+        ]),
+        rtol=1e-4,
+        atol=1e-5,
+    )
+
+    np.testing.assert_allclose(
+        clf.history[:, 'valid_loss'],
+        np.array([
+            1.958356261253357,
+            0.8494758009910583,
+            0.9321595430374146,
+            0.8126973509788513,
+            0.7426613569259644,
+            0.7547585368156433
+        ]),
+        rtol=1e-4,
+        atol=1e-5,
+    )
+
+    np.testing.assert_allclose(
+        clf.history[:, 'train_accuracy'],
+        np.array([
+            0.5,
+            0.8166666666666667,
+            0.7,
+            0.8,
+            0.8666666666666667,
+            0.9
+        ]),
+        rtol=1e-4,
+        atol=1e-5,
+    )
+
+    np.testing.assert_allclose(
+        clf.history[:, 'valid_accuracy'],
+        np.array([
+            0.4666666666666667,
+            0.6,
+            0.5,
+            0.5666666666666667,
+            0.6,
+            0.6,
+        ]),
+        rtol=1e-4,
+        atol=1e-5,
+    )