braindecode 0.8.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

braindecode/training/scoring.py

@@ -6,20 +6,19 @@
 #
 # License: BSD-3
 
-from contextlib import contextmanager
 import warnings
+from contextlib import contextmanager
 
 import numpy as np
 import torch
 from mne.utils.check import check_version
 from skorch.callbacks.scoring import EpochScoring
-from skorch.utils import to_numpy
 from skorch.dataset import unpack_data
+from skorch.utils import to_numpy
 from torch.utils.data import DataLoader
 
 
-def trial_preds_from_window_preds(
-        preds, i_window_in_trials, i_stop_in_trials):
+def trial_preds_from_window_preds(preds, i_window_in_trials, i_stop_in_trials):
     """
     Assigning window predictions to trials  while removing duplicate
     predictions.
@@ -41,7 +40,8 @@ def trial_preds_from_window_preds(
 
     """
     assert len(preds) == len(i_window_in_trials) == len(i_stop_in_trials), (
-        f'{len(preds)}, {len(i_window_in_trials)}, {len(i_stop_in_trials)}')
+        f"{len(preds)}, {len(i_window_in_trials)}, {len(i_stop_in_trials)}"
+    )
 
     # Algorithm for assigning window predictions to trials
     # while removing duplicate predictions:
@@ -64,11 +64,11 @@ def trial_preds_from_window_preds(
     i_last_stop = None
     i_last_window = -1
     for window_preds, i_window, i_stop in zip(
-            preds, i_window_in_trials, i_stop_in_trials):
+        preds, i_window_in_trials, i_stop_in_trials
+    ):
         window_preds = np.array(window_preds)
         if i_window != (i_last_window + 1):
-            assert i_window == 0, (
-                "window numbers in new trial should start from 0")
+            assert i_window == 0, "window numbers in new trial should start from 0"
             preds_per_trial.append(np.concatenate(cur_trial_preds, axis=1))
             cur_trial_preds = []
             i_last_stop = None
@@ -117,16 +117,17 @@ class CroppedTrialEpochScoring(EpochScoring):
     """
     Class to compute scores for trials from a model that predicts (super)crops.
     """
+
     # XXX needs a docstring !!!
 
     def __init__(
-            self,
-            scoring,
-            lower_is_better=True,
-            on_train=False,
-            name=None,
-            target_extractor=to_numpy,
-            use_caching=True,
+        self,
+        scoring,
+        lower_is_better=True,
+        on_train=False,
+        name=None,
+        target_extractor=to_numpy,
+        use_caching=True,
     ):
         super().__init__(
             scoring=scoring,
@@ -147,8 +148,7 @@ class CroppedTrialEpochScoring(EpochScoring):
         if not self.on_train:
             self.window_inds_ = []
 
-    def on_batch_end(
-             self, net, batch, y_pred, training, **kwargs):
+    def on_batch_end(self, net, batch, y_pred, training, **kwargs):
         # Skorch saves the predictions without moving them from GPU
         # https://github.com/skorch-dev/skorch/blob/fe71e3d55a4ae5f5f94ef7bdfc00fca3b3fd267f/skorch/callbacks/scoring.py#L385
         # This can cause memory issues in case of a large number of predictions
@@ -164,41 +164,42 @@ class CroppedTrialEpochScoring(EpochScoring):
                 # Prevent that rng state of torch is changed by
                 # creation+usage of iterator
                 rng_state = torch.random.get_rng_state()
-                pred_results = net.predict_with_window_inds_and_ys(
-                    dataset_train)
+                pred_results = net.predict_with_window_inds_and_ys(dataset_train)
                 torch.random.set_rng_state(rng_state)
             else:
                 pred_results = {}
-                pred_results['i_window_in_trials'] = np.concatenate(
+                pred_results["i_window_in_trials"] = np.concatenate(
                     [i[0].cpu().numpy() for i in self.window_inds_]
                 )
-                pred_results['i_window_stops'] = np.concatenate(
+                pred_results["i_window_stops"] = np.concatenate(
                     [i[2].cpu().numpy() for i in self.window_inds_]
                 )
-                pred_results['preds'] = np.concatenate(
-                    [y_pred.cpu().numpy() for y_pred in self.y_preds_])
-                pred_results['window_ys'] = np.concatenate(
-                    [y.cpu().numpy() for y in self.y_trues_])
+                pred_results["preds"] = np.concatenate(
+                    [y_pred.cpu().numpy() for y_pred in self.y_preds_]
+                )
+                pred_results["window_ys"] = np.concatenate(
+                    [y.cpu().numpy() for y in self.y_trues_]
+                )
 
             # A new trial starts
             # when the index of the window in trials
             # does not increment by 1
             # Add dummy infinity at start
-            window_0_per_trial_mask = np.diff(
-                pred_results['i_window_in_trials'], prepend=[np.inf]) != 1
-            trial_ys = pred_results['window_ys'][window_0_per_trial_mask]
+            window_0_per_trial_mask = (
+                np.diff(pred_results["i_window_in_trials"], prepend=[np.inf]) != 1
+            )
+            trial_ys = pred_results["window_ys"][window_0_per_trial_mask]
             trial_preds = trial_preds_from_window_preds(
-                pred_results['preds'],
-                pred_results['i_window_in_trials'],
-                pred_results['i_window_stops'])
+                pred_results["preds"],
+                pred_results["i_window_in_trials"],
+                pred_results["i_window_stops"],
+            )
 
             # Average across the timesteps of each trial so we have per-trial
             # predictions already, these will be just passed through the forward
             # method of the classifier/regressor to the skorch scoring function.
             # trial_preds is a list, each item is a 2d array classes x time
-            y_preds_per_trial = np.array(
-                [np.mean(p, axis=1) for p in trial_preds]
-            )
+            y_preds_per_trial = np.array([np.mean(p, axis=1) for p in trial_preds])
             # Move into format expected by skorch (list of torch tensors)
             y_preds_per_trial = [torch.tensor(y_preds_per_trial)]
 
@@ -206,9 +207,10 @@ class CroppedTrialEpochScoring(EpochScoring):
             # that are also on same set
             cbs = net.callbacks_
             epoch_cbs = [
-                cb for name, cb in cbs if
-                isinstance(cb, CroppedTrialEpochScoring) and (
-                        cb.on_train == self.on_train)
+                cb
+                for name, cb in cbs
+                if isinstance(cb, CroppedTrialEpochScoring)
+                and (cb.on_train == self.on_train)
             ]
             for cb in epoch_cbs:
                 cb.y_preds_ = y_preds_per_trial
@@ -218,7 +220,7 @@ class CroppedTrialEpochScoring(EpochScoring):
         dataset = dataset_train if self.on_train else dataset_valid
 
         with _cache_net_forward_iter(
-                net, self.use_caching, self.y_preds_
+            net, self.use_caching, self.y_preds_
         ) as cached_net:
             current_score = self._scoring(cached_net, dataset, self.y_trues_)
         self._record_score(net.history, current_score)
@@ -231,6 +233,7 @@ class CroppedTimeSeriesEpochScoring(CroppedTrialEpochScoring):
     Class to compute scores for trials from a model that predicts (super)crops with
     time series target.
     """
+
     def on_epoch_end(self, net, dataset_train, dataset_valid, **kwargs):
         assert self.use_caching
         if not self.crops_to_trials_computed:
@@ -238,37 +241,40 @@ class CroppedTimeSeriesEpochScoring(CroppedTrialEpochScoring):
                 # Prevent that rng state of torch is changed by
                 # creation+usage of iterator
                 rng_state = torch.random.get_rng_state()
-                pred_results = net.predict_with_window_inds_and_ys(
-                    dataset_train)
+                pred_results = net.predict_with_window_inds_and_ys(dataset_train)
                 torch.random.set_rng_state(rng_state)
             else:
                 pred_results = {}
-                pred_results['i_window_in_trials'] = np.concatenate(
+                pred_results["i_window_in_trials"] = np.concatenate(
                     [i[0].cpu().numpy() for i in self.window_inds_]
                 )
-                pred_results['i_window_stops'] = np.concatenate(
+                pred_results["i_window_stops"] = np.concatenate(
                     [i[2].cpu().numpy() for i in self.window_inds_]
                 )
-                pred_results['preds'] = np.concatenate(
-                    [y_pred.cpu().numpy() for y_pred in self.y_preds_])
-                pred_results['window_ys'] = np.concatenate(
-                    [y.cpu().numpy() for y in self.y_trues_])
+                pred_results["preds"] = np.concatenate(
+                    [y_pred.cpu().numpy() for y_pred in self.y_preds_]
+                )
+                pred_results["window_ys"] = np.concatenate(
+                    [y.cpu().numpy() for y in self.y_trues_]
+                )
 
-            num_preds = pred_results['preds'][-1].shape[-1]
+            num_preds = pred_results["preds"][-1].shape[-1]
             # slice the targets to fit preds shape
-            pred_results['window_ys'] = [
-                targets[:, -num_preds:] for targets in pred_results['window_ys']
+            pred_results["window_ys"] = [
+                targets[:, -num_preds:] for targets in pred_results["window_ys"]
             ]
 
             trial_preds = trial_preds_from_window_preds(
-                pred_results['preds'],
-                pred_results['i_window_in_trials'],
-                pred_results['i_window_stops'])
+                pred_results["preds"],
+                pred_results["i_window_in_trials"],
+                pred_results["i_window_stops"],
+            )
 
             trial_ys = trial_preds_from_window_preds(
-                pred_results['window_ys'],
-                pred_results['i_window_in_trials'],
-                pred_results['i_window_stops'])
+                pred_results["window_ys"],
+                pred_results["i_window_in_trials"],
+                pred_results["i_window_stops"],
+            )
 
             # the output is a list of predictions/targets per trial where each item is a
             # timeseries of predictions/targets of shape (n_classes x timesteps)
@@ -290,9 +296,10 @@ class CroppedTimeSeriesEpochScoring(CroppedTrialEpochScoring):
             # that are also on same set
             cbs = net.callbacks_
             epoch_cbs = [
-                cb for name, cb in cbs if
-                isinstance(cb, CroppedTimeSeriesEpochScoring) and (
-                    cb.on_train == self.on_train)
+                cb
+                for name, cb in cbs
+                if isinstance(cb, CroppedTimeSeriesEpochScoring)
+                and (cb.on_train == self.on_train)
             ]
             masked_preds = [torch.tensor(masked_preds.T)]
             for cb in epoch_cbs:
@@ -365,7 +372,7 @@ class PostEpochTrainScoring(EpochScoring):
             for batch in iterator:
                 batch_X, batch_y = unpack_data(batch)
                 # TODO: remove after skorch 0.10 release
-                if not check_version('skorch', min_version='0.10.1'):
+                if not check_version("skorch", min_version="0.10.1"):
                     yp = net.evaluation_step(batch_X, training=False)
                 # X, y unpacking has been pushed downstream in skorch 0.10
                 else:
@@ -394,9 +401,7 @@ class PostEpochTrainScoring(EpochScoring):
         with _cache_net_forward_iter(
             net, use_caching=True, y_preds=self.y_preds_
         ) as cached_net:
-            current_score = self._scoring(
-                cached_net, dataset_train, self.y_trues_
-            )
+            current_score = self._scoring(cached_net, dataset_train, self.y_trues_)
         self._record_score(net.history, current_score)
 
 
@@ -432,12 +437,14 @@ def predict_trials(module, dataset, return_targets=True, batch_size=1, num_worke
     module.eval()
     # we have a cropped dataset if there exists at least one trial with more
     # than one compute window
-    more_than_one_window = sum(dataset.get_metadata()['i_window_in_trial'] != 0) > 0
+    more_than_one_window = sum(dataset.get_metadata()["i_window_in_trial"] != 0) > 0
     if not more_than_one_window:
-        warnings.warn('This function was designed to predict trials from '
-                      'cropped datasets, which typically have multiple compute '
-                      'windows per trial. The given dataset has exactly one '
-                      'window per trial.')
+        warnings.warn(
+            "This function was designed to predict trials from "
+            "cropped datasets, which typically have multiple compute "
+            "windows per trial. The given dataset has exactly one "
+            "window per trial."
+        )
     loader = DataLoader(
         dataset=dataset,
         batch_size=batch_size,
@@ -463,7 +470,8 @@ def predict_trials(module, dataset, return_targets=True, batch_size=1, num_worke
         if all_ys[0].shape == ():
             all_ys = np.array(all_ys)
             ys_per_trial = all_ys[
-                np.diff(torch.cat(all_inds[0::3]), prepend=[np.inf]) != 1]
+                np.diff(torch.cat(all_inds[0::3]), prepend=[np.inf]) != 1
+            ]
         else:
             ys_per_trial = trial_preds_from_window_preds(
                 preds=all_ys,

braindecode/util.py

@@ -12,6 +12,7 @@ import mne
 import numpy as np
 import torch
 from sklearn.utils import check_random_state
+from torch import Tensor
 
 
 def set_random_seeds(seed, cuda, cudnn_benchmark=None):
@@ -51,7 +52,9 @@ def set_random_seeds(seed, cuda, cudnn_benchmark=None):
                 warn(
                     "torch.backends.cudnn.benchmark was set to True which may results in lack of "
                     "reproducibility. In some cases to ensure reproducibility you may need to "
-                    "set torch.backends.cudnn.benchmark to False.", UserWarning)
+                    "set torch.backends.cudnn.benchmark to False.",
+                    UserWarning,
+                )
         else:
             raise ValueError(
                 f"cudnn_benchmark expected to be bool or None, got '{cudnn_benchmark}'"
@@ -60,19 +63,7 @@ def set_random_seeds(seed, cuda, cudnn_benchmark=None):
     np.random.seed(seed)
 
 
-def np_to_var(
-    X, requires_grad=False, dtype=None, pin_memory=False, **tensor_kwargs
-):
-    warn("np_to_var has been renamed np_to_th, please use np_to_th instead")
-    return np_to_th(
-        X, requires_grad=requires_grad, dtype=dtype, pin_memory=pin_memory,
-        **tensor_kwargs
-    )
-
-
-def np_to_th(
-    X, requires_grad=False, dtype=None, pin_memory=False, **tensor_kwargs
-):
+def np_to_th(X, requires_grad=False, dtype=None, pin_memory=False, **tensor_kwargs):
     """
     Convenience function to transform numpy array to `torch.Tensor`.
 
@@ -103,12 +94,7 @@ def np_to_th(
     return X_tensor
 
 
-def var_to_np(var):
-    warn("var_to_np has been renamed th_to_np, please use th_to_np instead")
-    return th_to_np(var)
-
-
-def th_to_np(var):
+def th_to_np(var: Tensor):
     """Convenience function to transform `torch.Tensor` to numpy
     array.
 
@@ -209,15 +195,11 @@ def wrap_reshape_apply_fn(stat_fn, a, b, axis_a, axis_b):
     )
     assert np.array_equal(n_stat_axis_a, n_stat_axis_b)
     stat_result = stat_fn(flat_topo_a, flat_topo_b)
-    topo_result = stat_result.reshape(
-        tuple(n_other_axis_a) + tuple(n_other_axis_b)
-    )
+    topo_result = stat_result.reshape(tuple(n_other_axis_a) + tuple(n_other_axis_b))
     return topo_result
 
 
-def get_balanced_batches(
-    n_trials, rng, shuffle, n_batches=None, batch_size=None
-):
+def get_balanced_batches(n_trials, rng, shuffle, n_batches=None, batch_size=None):
     """Create indices for batches balanced in size
     (batches will have maximum size difference of 1).
     Supply either batch size or number of batches. Resulting batches
@@ -268,9 +250,17 @@ def get_balanced_batches(
     return batches
 
 
-def create_mne_dummy_raw(n_channels, n_times, sfreq, include_anns=True,
-                         description=None, savedir=None, save_format='fif',
-                         overwrite=True, random_state=None):
+def create_mne_dummy_raw(
+    n_channels,
+    n_times,
+    sfreq,
+    include_anns=True,
+    description=None,
+    savedir=None,
+    save_format="fif",
+    overwrite=True,
+    random_state=None,
+):
     """Create an mne.io.RawArray with fake data, and optionally save it.
 
     This will overwrite already existing files.
@@ -305,20 +295,21 @@ def create_mne_dummy_raw(n_channels, n_times, sfreq, include_anns=True,
     """
     random_state = check_random_state(random_state)
     data = random_state.rand(n_channels, n_times)
-    ch_names = [f'ch{i}' for i in range(n_channels)]
-    ch_types = ['eeg'] * n_channels
+    ch_names = [f"ch{i}" for i in range(n_channels)]
+    ch_types = ["eeg"] * n_channels
     info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
 
     raw = mne.io.RawArray(data, info)
 
     if include_anns:
         n_anns = 10
-        inds = np.linspace(
-            int(sfreq * 2), int(n_times - sfreq * 2), num=n_anns).astype(int)
+        inds = np.linspace(int(sfreq * 2), int(n_times - sfreq * 2), num=n_anns).astype(
+            int
+        )
         onset = raw.times[inds]
         duration = [1] * n_anns
         if description is None:
-            description = ['test'] * n_anns
+            description = ["test"] * n_anns
         anns = mne.Annotations(onset, duration, description)
         raw = raw.set_annotations(anns)
 
@@ -326,18 +317,17 @@ def create_mne_dummy_raw(n_channels, n_times, sfreq, include_anns=True,
     if savedir is not None:
         if not isinstance(save_format, list):
             save_format = [save_format]
-        fname = os.path.join(savedir, 'fake_eeg_raw')
+        fname = os.path.join(savedir, "fake_eeg_raw")
 
-        if 'fif' in save_format:
-            fif_fname = fname + '.fif'
+        if "fif" in save_format:
+            fif_fname = fname + ".fif"
             raw.save(fif_fname, overwrite=overwrite)
-            save_fname['fif'] = fif_fname
-        if 'hdf5' in save_format:
-            h5_fname = fname + '.h5'
-            with h5py.File(h5_fname, 'w') as f:
-                f.create_dataset(
-                    'fake_raw', dtype='f8', data=raw.get_data())
-            save_fname['hdf5'] = h5_fname
+            save_fname["fif"] = fif_fname
+        if "hdf5" in save_format:
+            h5_fname = fname + ".h5"
+            with h5py.File(h5_fname, "w") as f:
+                f.create_dataset("fake_raw", dtype="f8", data=raw.get_data())
+            save_fname["hdf5"] = h5_fname
 
     return raw, save_fname
 
@@ -349,7 +339,9 @@ class ThrowAwayIndexLoader(object):
         self.last_i = None
         self.is_regression = is_regression
 
-    def __iter__(self, ):
+    def __iter__(
+        self,
+    ):
         normal_iter = self.loader.__iter__()
         for batch in normal_iter:
             if len(batch) == 3:
@@ -360,7 +352,7 @@ class ThrowAwayIndexLoader(object):
                 x, y = batch
 
             # TODO: should be on dataset side
-            if hasattr(x, 'type'):
+            if hasattr(x, "type"):
                 x = x.type(torch.float32)
                 if self.is_regression:
                     y = y.type(torch.float32)
@@ -370,23 +362,26 @@ class ThrowAwayIndexLoader(object):
 
 
 def update_estimator_docstring(base_class, docstring):
-    base_doc = base_class.__doc__.replace(' : ', ': ')
-    idx = base_doc.find('callbacks:')
-    idx_end = idx + base_doc[idx:].find('\n\n')
+    base_doc = base_class.__doc__.replace(" : ", ": ")
+    idx = base_doc.find("callbacks:")
+    idx_end = idx + base_doc[idx:].find("\n\n")
     # remove callback descripiton already included in braindecode docstring
-    filtered_doc = base_doc[:idx] + base_doc[idx_end + 6:]
-    splitted = docstring.split('Parameters\n    ----------\n    ')
+    filtered_doc = base_doc[:idx] + base_doc[idx_end + 6 :]
+    splitted = docstring.split("Parameters\n    ----------\n    ")
     out_docstring = (
-        splitted[0] +
-        filtered_doc[filtered_doc.find('Parameters'):filtered_doc.find('Attributes')] +
-        splitted[1] +
-        filtered_doc[filtered_doc.find('Attributes'):])
+        splitted[0]
+        + filtered_doc[
+            filtered_doc.find("Parameters") : filtered_doc.find("Attributes")
+        ]
+        + splitted[1]
+        + filtered_doc[filtered_doc.find("Attributes") :]
+    )
     return out_docstring
 
 
 def _update_moabb_docstring(base_class, docstring):
     base_doc = base_class.__doc__
-    out_docstring = base_doc + f'\n\n{docstring}'
+    out_docstring = base_doc + f"\n\n{docstring}"
     return out_docstring
 
 
@@ -406,8 +401,9 @@ def read_all_file_names(directory, extension):
     file_paths: list(str)
         List of all files found in (sub)directories of path.
     """
-    assert extension.startswith('.')
-    file_paths = glob.glob(directory + '**/*' + extension, recursive=True)
+    assert extension.startswith(".")
+    file_paths = glob.glob(directory + "**/*" + extension, recursive=True)
     assert len(file_paths) > 0, (
-        f'something went wrong. Found no {extension} files in {directory}')
+        f"something went wrong. Found no {extension} files in {directory}"
+    )
     return file_paths

braindecode/version.py

@@ -1 +1 @@
-__version__ = "0.8"
+__version__ = "1.1.0"

braindecode/visualization/__init__.py

@@ -2,8 +2,7 @@
 Functions for visualisations, especially of the ConvNets.
 """
 
-from .gradients import compute_amplitude_gradients
 from .confusion_matrices import plot_confusion_matrix
+from .gradients import compute_amplitude_gradients
 
-__all__ = ["compute_amplitude_gradients",
-           "plot_confusion_matrix"]
+__all__ = ["compute_amplitude_gradients", "plot_confusion_matrix"]