braindecode 0.5.1__py3-none-any.whl

test/unit_tests/test_eeg_classifier.py

@@ -0,0 +1,73 @@
+# Authors: Maciej Sliwowski <maciek.sliwowski@gmail.com>
+#
+# License: BSD-3
+
+import numpy as np
+import torch
+from skorch.utils import to_tensor
+from torch import optim
+from torch.nn.functional import nll_loss
+
+from braindecode import EEGClassifier
+from braindecode.training import CroppedLoss
+
+
+class MockDataset(torch.utils.data.Dataset):
+    def __len__(self):
+        return 4
+
+    def __getitem__(self, item):
+        return torch.rand(4, 1), torch.ones(4)
+
+
+class MockModule(torch.nn.Module):
+    def __init__(self, preds):
+        super().__init__()
+        self.preds = to_tensor(preds, device='cpu')
+        self.linear = torch.nn.Linear(5, 5)
+
+    def forward(self, x):
+        return self.preds
+
+
+def test_trialwise_predict_and_predict_proba():
+    preds = np.array(
+        [
+            [0.125, 0.875],
+            [1., 0.],
+            [0.8, 0.2],
+            [0.9, 0.1],
+        ]
+    )
+    clf = EEGClassifier(
+        MockModule(preds),
+        optimizer=optim.Adam,
+        batch_size=32
+    )
+    clf.initialize()
+    np.testing.assert_array_equal(preds.argmax(1), clf.predict(MockDataset()))
+    np.testing.assert_array_equal(preds, clf.predict_proba(MockDataset()))
+
+
+def test_cropped_predict_and_predict_proba():
+    preds = np.array(
+        [
+            [[0.2, 0.1, 0.1, 0.1], [0.8, 0.9, 0.9, 0.9]],
+            [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]],
+            [[1.0, 1.0, 1.0, 0.2], [0.0, 0.0, 0.0, 0.8]],
+            [[0.9, 0.8, 0.9, 1.0], [0.1, 0.2, 0.1, 0.0]],
+        ]
+    )
+    clf = EEGClassifier(
+        MockModule(preds),
+        cropped=True,
+        criterion=CroppedLoss,
+        criterion__loss_function=nll_loss,
+        optimizer=optim.Adam,
+        batch_size=32
+    )
+    clf.initialize()
+    # for cropped decoding classifier returns one label for each trial (averaged over all crops)
+    np.testing.assert_array_equal(preds.mean(-1).argmax(1), clf.predict(MockDataset()))
+    # for cropped decoding classifier returns values for each trial (average over all crops)
+    np.testing.assert_array_equal(preds.mean(-1), clf.predict_proba(MockDataset()))

test/unit_tests/test_eeg_regressor.py

@@ -0,0 +1,72 @@
+# Authors: Maciej Sliwowski <maciek.sliwowski@gmail.com>
+#
+# License: BSD-3
+
+import numpy as np
+import torch
+from skorch.utils import to_tensor
+from torch import optim
+from torch.nn.functional import nll_loss
+
+from braindecode import EEGRegressor
+from braindecode.training import CroppedLoss
+
+
+class MockDataset(torch.utils.data.Dataset):
+    def __len__(self):
+        return 4
+
+    def __getitem__(self, item):
+        return torch.rand(4, 1), torch.ones(4)
+
+
+class MockModule(torch.nn.Module):
+    def __init__(self, preds):
+        super().__init__()
+        self.preds = to_tensor(preds, device='cpu')
+        self.linear = torch.nn.Linear(5, 5)
+
+    def forward(self, x):
+        return self.preds
+
+
+def test_trialwise_predict_and_predict_proba():
+    preds = np.array(
+        [
+            [0.125, 0.875],
+            [1., 0.],
+            [0.8, 0.2],
+            [0.9, 0.1],
+        ]
+    )
+    clf = EEGRegressor(
+        MockModule(preds),
+        optimizer=optim.Adam,
+        batch_size=32
+    )
+    clf.initialize()
+    np.testing.assert_array_equal(preds, clf.predict(MockDataset()))
+    np.testing.assert_array_equal(preds, clf.predict_proba(MockDataset()))
+
+
+def test_cropped_predict_and_predict_proba():
+    preds = np.array(
+        [
+            [[0.2, 0.1, 0.1, 0.1], [0.8, 0.9, 0.9, 0.9]],
+            [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]],
+            [[1.0, 1.0, 1.0, 0.2], [0.0, 0.0, 0.0, 0.8]],
+            [[0.9, 0.8, 0.9, 1.0], [0.1, 0.2, 0.1, 0.0]],
+        ]
+    )
+    clf = EEGRegressor(
+        MockModule(preds),
+        cropped=True,
+        criterion=CroppedLoss,
+        criterion__loss_function=nll_loss,
+        optimizer=optim.Adam,
+        batch_size=32
+    )
+    clf.initialize()
+    # for cropped decoding regressor returns value for each trial (average over all crops)
+    np.testing.assert_array_equal(preds.mean(-1), clf.predict(MockDataset()))
+    np.testing.assert_array_equal(preds.mean(-1), clf.predict_proba(MockDataset()))

test/unit_tests/test_scoring.py

@@ -0,0 +1,282 @@
+# Authors: Maciej Sliwowski
+#          Lukas Gemein
+#          Robin Tibor Schirrmeister
+#
+# License: BSD-3
+
+
+import numpy as np
+import sklearn.datasets
+import torch
+from sklearn.metrics import f1_score, accuracy_score
+from skorch import History
+from skorch.callbacks import Callback
+from skorch.utils import to_numpy, to_tensor
+from torch import optim
+from torch.utils.data import Dataset, DataLoader
+from braindecode.classifier import EEGClassifier
+from braindecode.datautil.xy import create_from_X_y
+from braindecode.training.scoring import CroppedTrialEpochScoring
+from braindecode.training.scoring import PostEpochTrainScoring
+from braindecode.models import ShallowFBCSPNet
+from braindecode.util import set_random_seeds
+from braindecode.training.scoring import trial_preds_from_window_preds
+
+
+class MockSkorchNet:
+    def __init__(self):
+        self.device = "cpu"
+        self.forward_iter = None
+        self.history = History()
+        self.history.new_epoch()
+        self._default_callbacks = []
+
+    def fit(self, X, y=None):
+        return self
+
+    def predict(self, X):
+        return np.concatenate(
+            [to_numpy(x.argmax(1)) for x in self.forward_iter(X)], 0
+        )
+
+    def get_iterator(self, X_test, training):
+        return DataLoader(X_test, batch_size=2)
+
+
+def test_cropped_trial_epoch_scoring():
+
+    dataset_train = None
+    # Definition of test cases
+    predictions_cases = [
+        # Expected predictions classification results: [1, 0, 0, 0]
+        np.array(
+            [
+                [[0.2, 0.1, 0.1, 0.1], [0.8, 0.9, 0.9, 0.9]],  # trial 0 preds
+                [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]],  # trial 1 preds
+                [[1.0, 1.0, 1.0, 0.2], [0.0, 0.0, 0.0, 0.8]],  # trial 2 preds
+                [[0.9, 0.8, 0.9, 1.0], [0.1, 0.2, 0.1, 0.0]],  # trial 3 preds
+            ]
+        ),
+        # Expected predictions classification results: [1, 1, 1, 0]
+        np.array(
+            [
+                [[0.2, 0.1, 0.1, 0.1], [0.8, 0.9, 0.9, 0.9]],
+                [[0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]],
+                [[0.0, 0.0, 0.0, 0.2], [1.0, 1.0, 1.0, 0.8]],
+                [[0.9, 0.8, 0.9, 1.0], [0.1, 0.2, 0.1, 0.0]],
+            ]
+        ),
+    ]
+    y_true_cases = [
+        [torch.tensor([0, 0]), torch.tensor([1, 1])],
+        [torch.tensor([1, 1]), torch.tensor([1, 1])],
+    ]
+    expected_accuracies_cases = [0.25, 0.75]
+
+    window_inds = [(
+            torch.tensor([0, 0]),  # i_window_in_trials
+            [None],  # won't be used
+            torch.tensor([4, 4]),  # i_window_stops
+        ),(
+            torch.tensor([0, 0]),  # i_window_in_trials
+            [None],  # won't be used
+            torch.tensor([4, 4]),  # i_window_stops
+        ),]
+
+    for predictions, y_true, accuracy in zip(
+        predictions_cases, y_true_cases, expected_accuracies_cases
+    ):
+        dataset_valid = create_from_X_y(
+            np.zeros((4, 1, 10)), np.concatenate(y_true),
+            window_size_samples=10, window_stride_samples=4, drop_last_window=False)
+
+        mock_skorch_net = MockSkorchNet()
+        cropped_trial_epoch_scoring = CroppedTrialEpochScoring(
+            "accuracy", on_train=False)
+        mock_skorch_net.callbacks = [(
+            "", cropped_trial_epoch_scoring)]
+        cropped_trial_epoch_scoring.initialize()
+        cropped_trial_epoch_scoring.y_preds_ = [
+            to_tensor(predictions[:2], device="cpu"),
+            to_tensor(predictions[2:], device="cpu"),
+        ]
+        cropped_trial_epoch_scoring.y_trues_ = y_true
+        cropped_trial_epoch_scoring.window_inds_ = window_inds
+
+        cropped_trial_epoch_scoring.on_epoch_end(
+            mock_skorch_net, dataset_train, dataset_valid
+        )
+
+        np.testing.assert_almost_equal(
+            mock_skorch_net.history[0]["accuracy"], accuracy
+        )
+
+
+def test_cropped_trial_epoch_scoring_none_x_test():
+    dataset_train = None
+    dataset_valid = None
+    predictions = np.array(
+        [
+            [[0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]],
+            [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]],
+            [[1.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]],
+            [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]],
+        ]
+    )
+    y_true = [torch.tensor([0, 0]), torch.tensor([1, 1])]
+    window_inds = [(
+        torch.tensor([0, 0]),  # i_window_in_trials
+        [None],  # won't be used
+        torch.tensor([4, 4]),  # i_window_stops
+    ),
+        (
+        torch.tensor([0, 0]),  # i_window_in_trials
+        [None],  # won't be used
+        torch.tensor([4, 4]),  # i_window_stops
+    )]
+    cropped_trial_epoch_scoring = CroppedTrialEpochScoring("accuracy")
+    cropped_trial_epoch_scoring.initialize()
+    cropped_trial_epoch_scoring.y_preds_ = [
+        to_tensor(predictions[:2], device="cpu"),
+        to_tensor(predictions[2:], device="cpu"),
+    ]
+    cropped_trial_epoch_scoring.y_trues_ = y_true
+    cropped_trial_epoch_scoring.window_inds_ = window_inds
+
+    mock_skorch_net = MockSkorchNet()
+    mock_skorch_net.callbacks = [(
+        "", cropped_trial_epoch_scoring)]
+    output = cropped_trial_epoch_scoring.on_epoch_end(
+        mock_skorch_net, dataset_train, dataset_valid
+    )
+    assert output is None
+
+
+def test_post_epoch_train_scoring():
+    cuda = False
+    set_random_seeds(seed=20170629, cuda=cuda)
+
+    n_classes = 2
+
+    class EEGDataSet(Dataset):
+        def __init__(self, X, y):
+            self.X = X
+            if self.X.ndim == 3:
+                self.X = self.X[:, :, :, None]
+            self.y = y
+
+        def __len__(self):
+            return len(self.X)
+
+        def __getitem__(self, idx):
+            return self.X[idx], self.y[idx]
+
+    X, y = sklearn.datasets.make_classification(
+        40, (3 * 100), n_informative=3 * 50, n_classes=2
+    )
+    X = X.reshape(40, 3, 100).astype(np.float32)
+
+    in_chans = X.shape[1]
+
+    train_set = EEGDataSet(X, y)
+
+    class TestCallback(Callback):
+        def on_epoch_end(self, net, *args, **kwargs):
+            preds = net.predict(train_set.X)
+            y_true = train_set.y
+            np.testing.assert_allclose(
+                clf.history[-1]["train_f1"],
+                f1_score(y_true, preds),
+                rtol=1e-4,
+                atol=1e-4,
+            )
+            np.testing.assert_allclose(
+                clf.history[-1]["train_acc"],
+                accuracy_score(y_true, preds),
+                rtol=1e-4,
+                atol=1e-4,
+            )
+
+    set_random_seeds(20200114, cuda)
+
+    # final_conv_length = auto ensures
+    # we only get a single output in the time dimension
+    model = ShallowFBCSPNet(
+        in_chans=in_chans,
+        n_classes=n_classes,
+        input_window_samples=train_set.X.shape[2],
+        pool_time_stride=1,
+        pool_time_length=2,
+        final_conv_length="auto",
+    )
+    if cuda:
+        model.cuda()
+
+    clf = EEGClassifier(
+        model,
+        criterion=torch.nn.NLLLoss,
+        optimizer=optim.AdamW,
+        train_split=None,
+        optimizer__lr=0.0625 * 0.01,
+        optimizer__weight_decay=0,
+        batch_size=64,
+        callbacks=[
+            (
+                "train_accuracy",
+                PostEpochTrainScoring(
+                    "accuracy", lower_is_better=False, name="train_acc"
+                ),
+            ),
+            (
+                "train_f1_score",
+                PostEpochTrainScoring(
+                    "f1", lower_is_better=False, name="train_f1"
+                ),
+            ),
+            ("test_callback", TestCallback()),
+        ],
+    )
+
+    clf.fit(train_set, y=None, epochs=4)
+
+
+def _check_preds_windows_trials(preds, window_inds, expected_trial_preds):
+    # transform to 2 lists from tuples
+    i_window_in_trials = []
+    i_stop_in_trials = []
+    for i_window_in_trial, _, i_stop_in_trial in window_inds:
+        i_window_in_trials.append(i_window_in_trial)
+        i_stop_in_trials.append(i_stop_in_trial)
+    trial_preds = trial_preds_from_window_preds(
+        preds, i_window_in_trials, i_stop_in_trials)
+    np.testing.assert_equal(len(trial_preds), len(expected_trial_preds),)
+    for expected_pred, actual_pred in zip(expected_trial_preds, trial_preds):
+        np.testing.assert_array_equal(actual_pred, expected_pred, )
+
+
+def test_two_windows_same_trial_with_overlap():
+    preds = [[[4, 5, 6, 7]], [[6, 7, 8, 9]], ]
+    window_inds = ((0, 0, 8), (1, 2, 10))
+    expected_trial_preds = [[[4, 5, 6, 7, 8, 9]]]
+    _check_preds_windows_trials(preds, window_inds, expected_trial_preds)
+
+
+def test_three_windows_two_trials_with_overlap():
+    preds = [[[4, 5, 6, 7]], [[6, 7, 8, 9]], [[0, 1, 2, 3]]]
+    window_inds = ((0, 0, 8), (1, 2, 10), (0, 0, 6,))
+    expected_trial_preds = [[[4, 5, 6, 7, 8, 9]], [[0, 1, 2, 3]]]
+    _check_preds_windows_trials(preds, window_inds, expected_trial_preds)
+
+
+def test_one_window_one_trial():
+    preds = [[[4, 5, 6, 7]]]
+    window_inds = ((0, 0, 8),)
+    expected_trial_preds = [[[4, 5, 6, 7]]]
+    _check_preds_windows_trials(preds, window_inds, expected_trial_preds)
+
+
+def test_three_windows_two_trials_no_overlap():
+    preds = [[[4, 5, 6, 7]], [[6, 7, 8, 9]], [[0, 1, 2, 3]]]
+    window_inds = ((0, 0, 8), (1, 4, 12), (0, 0, 6,))
+    expected_trial_preds = [[[4, 5, 6, 7, 6, 7, 8, 9]], [[0, 1, 2, 3]]]
+    _check_preds_windows_trials(preds, window_inds, expected_trial_preds)

test/unit_tests/test_util.py

@@ -0,0 +1,30 @@
+# Authors: Hubert Banville <hubert.jbanville@gmail.com>
+#
+# License: BSD-3
+
+import os
+
+import mne
+import numpy as np
+import h5py
+
+from braindecode.util import create_mne_dummy_raw
+
+
+def test_create_mne_dummy_raw(tmp_path):
+    n_channels, n_times, sfreq = 2, 10000, 100
+    raw, fnames = create_mne_dummy_raw(
+        n_channels, n_times, sfreq, savedir=tmp_path,
+        save_format=['fif', 'hdf5'])
+
+    assert isinstance(raw, mne.io.RawArray)
+    assert len(raw.ch_names) == n_channels
+    assert raw.n_times == n_times
+    assert raw.info['sfreq'] == sfreq
+    assert isinstance(fnames, dict)
+    assert os.path.isfile(fnames['fif'])
+    assert os.path.isfile(fnames['hdf5'])
+
+    raw = mne.io.read_raw_fif(fnames['fif'], preload=False, verbose=None)
+    with h5py.File(fnames['hdf5'], 'r') as hf:
+        _ = np.array(hf['fake_raw'])

test/unit_tests/visualization/test_gradients.py

@@ -0,0 +1,38 @@
+# Authors: Robin Schirrmeister <robintibor@gmail.com>
+#
+# License: BSD (3-clause)
+
+import numpy as np
+import torch
+from torch import nn
+from braindecode.util import set_random_seeds
+from braindecode.visualization.gradients import compute_amplitude_gradients_for_X
+
+
+
+def test_compute_amplitude_gradients_for_X():
+    # If the weights are initalized with a sine function
+    # gradient of amplitude should be only in one frequency bin
+    set_random_seeds(948, False)
+    model = nn.Conv1d(1,1, 16)
+    # torch.linspace(,,n)[:n-1] is same as np.linspace(,,n,endpoint=False)
+    model.weight.data[:,:,:] = torch.sin(torch.linspace(0,2*np.pi,17)[:16])
+    model.bias.data[:] = 0
+    grads = compute_amplitude_gradients_for_X(model, torch.randn(1,1,16))
+    grads = grads.squeeze()
+    assert np.abs(grads[1]) / np.sum(np.abs(grads)) > 0.99
+
+
+def test_compute_amplitude_gradients_for_X_two_filters():
+    # If the weights are initalized with a sine function
+    # gradient of amplitude should be only in one frequency bin
+    set_random_seeds(948, False)
+    model = nn.Conv1d(1,2, 16)
+    # torch.linspace(,,n)[:n-1] is same as np.linspace(,,n,endpoint=False)
+    model.weight.data[0,:,:] = torch.sin(torch.linspace(0,2*np.pi,17)[:16])
+    model.weight.data[1,:,:] = torch.sin(torch.linspace(0,4*np.pi,17)[:16])
+    model.bias.data[:] = 0
+    grads = compute_amplitude_gradients_for_X(model, torch.randn(1,1,16))
+    grads = grads.squeeze()
+    assert np.abs(grads[0][1]) / np.sum(np.abs(grads[0])) > 0.99
+    assert np.abs(grads[1][2]) / np.sum(np.abs(grads[1])) > 0.99