braindecode 0.8__py3-none-any.whl → 1.0.0__py3-none-any.whl

braindecode/datautil/__init__.py

@@ -0,0 +1,49 @@
+"""
+Utilities for data manipulation.
+"""
+
+from .serialization import (
+    _check_save_dir_empty,
+    load_concat_dataset,
+    save_concat_dataset,
+)
+
+
+def __getattr__(name):
+    # ideas from https://stackoverflow.com/a/57110249/1469195
+    import importlib
+    from warnings import warn
+
+    if name == "create_from_X_y":
+        warn(
+            "create_from_X_y has been moved to datasets, please use from braindecode.datasets import create_from_X_y"
+        )
+        xy = importlib.import_module("..datasets.xy", __package__)
+        return xy.create_from_X_y
+    if name in ["create_from_mne_raw", "create_from_mne_epochs"]:
+        warn(
+            f"{name} has been moved to datasets, please use from braindecode.datasets import {name}"
+        )
+        mne = importlib.import_module("..datasets.mne", __package__)
+        return mne.__dict__[name]
+    if name in [
+        "scale",
+        "exponential_moving_demean",
+        "exponential_moving_standardize",
+        "filterbank",
+        "preprocess",
+        "Preprocessor",
+    ]:
+        warn(
+            f"{name} has been moved to preprocessing, please use from braindecode.preprocessing import {name}"
+        )
+        preprocess = importlib.import_module("..preprocessing.preprocess", __package__)
+        return preprocess.__dict__[name]
+    if name in ["create_windows_from_events", "create_fixed_length_windows"]:
+        warn(
+            f"{name} has been moved to preprocessing, please use from braindecode.preprocessing import {name}"
+        )
+        windowers = importlib.import_module("..preprocessing.windowers", __package__)
+        return windowers.__dict__[name]
+
+    raise AttributeError("No possible import named " + name)

braindecode/datautil/serialization.py

@@ -0,0 +1,342 @@
+"""
+Convenience functions for storing and loading of windows datasets.
+"""
+
+# Authors: Lukas Gemein <l.gemein@gmail.com>
+#
+# License: BSD (3-clause)
+
+import json
+import os
+import pickle
+import warnings
+from glob import glob
+from pathlib import Path
+
+import mne
+import pandas as pd
+from joblib import Parallel, delayed
+
+from ..datasets.base import (
+    BaseConcatDataset,
+    BaseDataset,
+    EEGWindowsDataset,
+    WindowsDataset,
+)
+
+
+def save_concat_dataset(path, concat_dataset, overwrite=False):
+    warnings.warn(
+        '"save_concat_dataset()" is deprecated and will be removed in'
+        " the future. Use dataset.save() instead.",
+        UserWarning,
+    )
+    concat_dataset.save(path=path, overwrite=overwrite)
+
+
+def _outdated_load_concat_dataset(path, preload, ids_to_load=None, target_name=None):
+    """Load a stored BaseConcatDataset of BaseDatasets or WindowsDatasets from
+    files.
+
+    Parameters
+    ----------
+    path: pathlib.Path
+        Path to the directory of the .fif / -epo.fif and .json files.
+    preload: bool
+        Whether to preload the data.
+    ids_to_load: None | list(int)
+        Ids of specific files to load.
+    target_name: None or str
+        Load specific description column as target. If not given, take saved
+        target name.
+
+    Returns
+    -------
+    concat_dataset: BaseConcatDataset of BaseDatasets or WindowsDatasets
+    """
+    # assume we have a single concat dataset to load
+    is_raw = (path / "0-raw.fif").is_file()
+    assert not (not is_raw and target_name is not None), (
+        "Setting a new target is only supported for raws."
+    )
+    is_epochs = (path / "0-epo.fif").is_file()
+    paths = [path]
+    # assume we have multiple concat datasets to load
+    if not (is_raw or is_epochs):
+        is_raw = (path / "0" / "0-raw.fif").is_file()
+        is_epochs = (path / "0" / "0-epo.fif").is_file()
+        paths = path.glob("*/")
+        paths = sorted(paths, key=lambda p: int(p.name))
+        if ids_to_load is not None:
+            paths = [paths[i] for i in ids_to_load]
+        ids_to_load = None
+    # if we have neither a single nor multiple datasets, something went wrong
+    assert is_raw or is_epochs, (
+        f"Expect either raw or epo to exist in {path} or in {path / '0'}"
+    )
+
+    datasets = []
+    for path in paths:
+        if is_raw and target_name is None:
+            target_file_name = path / "target_name.json"
+            target_name = json.load(open(target_file_name, "r"))["target_name"]
+
+        all_signals, description = _load_signals_and_description(
+            path=path, preload=preload, is_raw=is_raw, ids_to_load=ids_to_load
+        )
+        for i_signal, signal in enumerate(all_signals):
+            if is_raw:
+                datasets.append(
+                    BaseDataset(
+                        signal, description.iloc[i_signal], target_name=target_name
+                    )
+                )
+            else:
+                datasets.append(WindowsDataset(signal, description.iloc[i_signal]))
+    concat_ds = BaseConcatDataset(datasets)
+    for kwarg_name in ["raw_preproc_kwargs", "window_kwargs", "window_preproc_kwargs"]:
+        kwarg_path = path / ".".join([kwarg_name, "json"])
+        if kwarg_path.exists():
+            with open(kwarg_path, "r") as f:
+                kwargs = json.load(f)
+            kwargs = [tuple(kwarg) for kwarg in kwargs]
+            setattr(concat_ds, kwarg_name, kwargs)
+    return concat_ds
+
+
+def _load_signals_and_description(path, preload, is_raw, ids_to_load=None):
+    all_signals = []
+    file_name = "{}-raw.fif" if is_raw else "{}-epo.fif"
+    description_df = pd.read_json(path / "description.json")
+    if ids_to_load is None:
+        file_names = path.glob(f"*{file_name.lstrip('{}')}")
+        # Extract ids, e.g.,
+        # '/home/schirrmr/data/preproced-tuh/all-sensors/11-raw.fif' ->
+        # '11-raw.fif' -> 11
+        ids_to_load = sorted(
+            [int(os.path.split(f)[-1].split("-")[0]) for f in file_names]
+        )
+    for i in ids_to_load:
+        fif_file = path / file_name.format(i)
+        all_signals.append(_load_signals(fif_file, preload, is_raw))
+    description_df = description_df.iloc[ids_to_load]
+    return all_signals, description_df
+
+
+def _load_signals(fif_file, preload, is_raw):
+    # Reading the raw file from pickle if it has been save before.
+    # The pickle file only contain the raw object without the data.
+    pkl_file = fif_file.with_suffix(".pkl")
+    if pkl_file.exists():
+        with open(pkl_file, "rb") as f:
+            signals = pickle.load(f)
+
+        # If the file has been moved together with the pickle file, make sure
+        # the path links to correct fif file.
+        signals._fname = str(fif_file)
+        if preload:
+            signals.load_data()
+        return signals
+
+    # If pickle didn't exist read via mne (likely slower) and save pkl after
+    if is_raw:
+        signals = mne.io.read_raw_fif(fif_file, preload=preload)
+    elif fif_file.name.endswith("-epo.fif"):
+        signals = mne.read_epochs(fif_file, preload=preload)
+    else:
+        raise ValueError("fif_file must end with raw.fif or epo.fif.")
+
+    # Only do this for raw objects. Epoch objects are not picklable as they
+    # hold references to open files in `signals._raw[0].fid`.
+    if is_raw:
+        # Saving the raw file without data into a pickle file, so it can be
+        # retrieved faster on the next use of this dataset.
+        with open(pkl_file, "wb") as f:
+            if preload:
+                data = signals._data
+                signals._data, signals.preload = None, False
+            pickle.dump(signals, f)
+            if preload:
+                signals._data, signals.preload = data, True
+
+    return signals
+
+
+def load_concat_dataset(path, preload, ids_to_load=None, target_name=None, n_jobs=1):
+    """Load a stored BaseConcatDataset of BaseDatasets or WindowsDatasets from
+    files.
+
+    Parameters
+    ----------
+    path: str | pathlib.Path
+        Path to the directory of the .fif / -epo.fif and .json files.
+    preload: bool
+        Whether to preload the data.
+    ids_to_load: list of int | None
+        Ids of specific files to load.
+    target_name: str | list | None
+        Load specific description column as target. If not given, take saved
+        target name.
+    n_jobs: int
+        Number of jobs to be used to read files in parallel.
+
+    Returns
+    -------
+    concat_dataset: BaseConcatDataset of BaseDatasets or WindowsDatasets
+    """
+    # Make sure we always work with a pathlib.Path
+    path = Path(path)
+
+    # if we encounter a dataset that was saved in 'the old way', call the
+    # corresponding 'old' loading function
+    if _is_outdated_saved(path):
+        warnings.warn(
+            "The way your dataset was saved is deprecated by now. "
+            "Please save it again using dataset.save().",
+            UserWarning,
+        )
+        return _outdated_load_concat_dataset(
+            path=path, preload=preload, ids_to_load=ids_to_load, target_name=target_name
+        )
+
+    # else we have a dataset saved in the new way with subdirectories in path
+    # for every dataset with description.json and -epo.fif or -raw.fif,
+    # target_name.json, raw_preproc_kwargs.json, window_kwargs.json,
+    # window_preproc_kwargs.json
+    if ids_to_load is None:
+        ids_to_load = [p.name for p in path.iterdir()]
+        ids_to_load = sorted(ids_to_load, key=lambda i: int(i))
+    ids_to_load = [str(i) for i in ids_to_load]
+    first_raw_fif_path = path / ids_to_load[0] / f"{ids_to_load[0]}-raw.fif"
+    is_raw = first_raw_fif_path.exists()
+    metadata_path = path / ids_to_load[0] / "metadata_df.pkl"
+    has_stored_windows = metadata_path.exists()
+
+    # Parallelization of mne.read_epochs with preload=False fails with
+    # 'TypeError: cannot pickle '_io.BufferedReader' object'.
+    # So ignore n_jobs in that case and load with a single job.
+    if not is_raw and n_jobs != 1:
+        warnings.warn(
+            "Parallelized reading with `preload=False` is not supported for "
+            "windowed data. Will use `n_jobs=1`.",
+            UserWarning,
+        )
+        n_jobs = 1
+    datasets = Parallel(n_jobs)(
+        delayed(_load_parallel)(path, i, preload, is_raw, has_stored_windows)
+        for i in ids_to_load
+    )
+    return BaseConcatDataset(datasets)
+
+
+def _load_parallel(path, i, preload, is_raw, has_stored_windows):
+    sub_dir = path / i
+    file_name_patterns = ["{}-raw.fif", "{}-epo.fif"]
+    if all([(sub_dir / p.format(i)).exists() for p in file_name_patterns]):
+        raise FileExistsError("Found -raw.fif and -epo.fif in directory.")
+
+    fif_name_pattern = file_name_patterns[0] if is_raw else file_name_patterns[1]
+    fif_file_name = fif_name_pattern.format(i)
+    fif_file_path = sub_dir / fif_file_name
+
+    signals = _load_signals(fif_file_path, preload, is_raw)
+
+    description_file_path = sub_dir / "description.json"
+    description = pd.read_json(description_file_path, typ="series")
+
+    target_file_path = sub_dir / "target_name.json"
+    target_name = None
+    if target_file_path.exists():
+        target_name = json.load(open(target_file_path, "r"))["target_name"]
+
+    if is_raw and (not has_stored_windows):
+        dataset = BaseDataset(signals, description, target_name)
+    else:
+        window_kwargs = _load_kwargs_json("window_kwargs", sub_dir)
+        windows_ds_kwargs = [
+            kwargs[1] for kwargs in window_kwargs if kwargs[0] == "WindowsDataset"
+        ]
+        windows_ds_kwargs = windows_ds_kwargs[0] if len(windows_ds_kwargs) == 1 else {}
+        if is_raw:
+            metadata = pd.read_pickle(path / i / "metadata_df.pkl")
+            dataset = EEGWindowsDataset(
+                signals,
+                metadata=metadata,
+                description=description,
+                targets_from=windows_ds_kwargs.get("targets_from", "metadata"),
+                last_target_only=windows_ds_kwargs.get("last_target_only", True),
+            )
+        else:
+            # MNE epochs dataset
+            dataset = WindowsDataset(
+                signals,
+                description,
+                targets_from=windows_ds_kwargs.get("targets_from", "metadata"),
+                last_target_only=windows_ds_kwargs.get("last_target_only", True),
+            )
+        setattr(dataset, "window_kwargs", window_kwargs)
+    for kwargs_name in ["raw_preproc_kwargs", "window_preproc_kwargs"]:
+        kwargs = _load_kwargs_json(kwargs_name, sub_dir)
+        setattr(dataset, kwargs_name, kwargs)
+    return dataset
+
+
+def _load_kwargs_json(kwargs_name, sub_dir):
+    kwargs_file_name = ".".join([kwargs_name, "json"])
+    kwargs_file_path = os.path.join(sub_dir, kwargs_file_name)
+    if os.path.exists(kwargs_file_path):
+        kwargs = json.load(open(kwargs_file_path, "r"))
+        kwargs = [tuple(kwarg) for kwarg in kwargs]
+        return kwargs
+
+
+def _is_outdated_saved(path):
+    """Data was saved in the old way if there are 'description.json', '-raw.fif'
+    or '-epo.fif' in path (no subdirectories) OR if there are more 'fif' files
+    than 'description.json' files."""
+    description_files = glob(os.path.join(path, "**/description.json"))
+    fif_files = glob(os.path.join(path, "**/*-raw.fif")) + glob(
+        os.path.join(path, "**/*-epo.fif")
+    )
+    multiple = len(description_files) != len(fif_files)
+    kwargs_in_path = any(
+        [
+            os.path.exists(os.path.join(path, kwarg_name))
+            for kwarg_name in [
+                "raw_preproc_kwargs",
+                "window_kwargs",
+                "window_preproc_kwargs",
+            ]
+        ]
+    )
+    return (
+        os.path.exists(os.path.join(path, "description.json"))
+        or os.path.exists(os.path.join(path, "0-raw.fif"))
+        or os.path.exists(os.path.join(path, "0-epo.fif"))
+        or multiple
+        or kwargs_in_path
+    )
+
+
+def _check_save_dir_empty(save_dir):
+    """Make sure a BaseConcatDataset can be saved under a given directory.
+
+    Parameters
+    ----------
+    save_dir : str
+        Directory under which a `BaseConcatDataset` will be saved.
+
+    Raises
+    -------
+    FileExistsError
+        If ``save_dir`` is not a valid directory for saving.
+    """
+    sub_dirs = [
+        os.path.basename(s).isdigit() for s in glob(os.path.join(save_dir, "*"))
+    ]
+    if any(sub_dirs):
+        raise FileExistsError(
+            f"Directory {save_dir} already contains subdirectories. Please "
+            "select a different directory, set overwrite=True, or resolve "
+            "manually."
+        )

braindecode/datautil/util.py

@@ -0,0 +1,41 @@
+# Authors: Robin Schirrmeister <robintibor@gmail.com>
+#
+# License: BSD (3-clause)
+
+
+def ms_to_samples(ms, fs):
+    """
+    Compute milliseconds to number of samples.
+
+    Parameters
+    ----------
+    ms: number
+        Milliseconds
+    fs: number
+        Sampling rate
+
+    Returns
+    -------
+    n_samples: int
+        Number of samples
+
+    """
+    return ms * fs / 1000.0
+
+
+def samples_to_ms(n_samples, fs):
+    """
+    Compute milliseconds to number of samples.
+
+    Parameters
+    ----------
+    n_samples: number
+        Number of samples
+    fs: number
+        Sampling rate
+
+    Returns
+    -------
+    milliseconds: int
+    """
+    return n_samples * 1000.0 / fs

braindecode/eegneuralnet.py

@@ -5,32 +5,36 @@
 
 
 import abc
-import logging
 import inspect
+import logging
 
 import mne
 import numpy as np
 import torch
-from skorch import NeuralNet
 from sklearn.metrics import get_scorer
+from skorch import NeuralNet
 from skorch.callbacks import BatchScoring, EpochScoring, EpochTimer, PrintLog
-from skorch.utils import noop, to_numpy, train_loss_score, valid_loss_score, is_dataset
+from skorch.helper import SliceDataset
+from skorch.utils import is_dataset, noop, to_numpy, train_loss_score, valid_loss_score
 
-from .training.scoring import (CroppedTimeSeriesEpochScoring,
-                               CroppedTrialEpochScoring, PostEpochTrainScoring)
-from .models.util import models_dict
 from .datasets.base import BaseConcatDataset, WindowsDataset
+from .models.util import models_dict
+from .training.scoring import (
+    CroppedTimeSeriesEpochScoring,
+    CroppedTrialEpochScoring,
+    PostEpochTrainScoring,
+)
 
 log = logging.getLogger(__name__)
 
 
-def _get_model(model):
-    ''' Returns the corresponding class in case the model passed is a string. '''
+def _get_model(model: str):
+    """Returns the corresponding class in case the model passed is a string."""
     if isinstance(model, str):
         if model in models_dict:
             model = models_dict[model]
         else:
-            raise ValueError(f'Unknown model name {model!r}.')
+            raise ValueError(f"Unknown model name {model!r}.")
     return model
 
 
@@ -50,7 +54,7 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
         will be left as is.
 
         """
-        kwargs = self.get_params_for('module')
+        kwargs = self.get_params_for("module")
         module = _get_model(self.module)
         module = self.initialized_instance(module, kwargs)
         # pylint: disable=attribute-defined-outside-init
@@ -61,7 +65,7 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
         # Here we parse the callbacks supplied as strings,
         # e.g. 'accuracy', to the callbacks skorch expects
         for name, cb, named_by_user in super()._yield_callbacks():
-            if name == 'str':
+            if name == "str":
                 train_cb, valid_cb = self._parse_str_callback(cb)
                 yield train_cb
                 if self.train_split is not None:
@@ -72,15 +76,13 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
     def _parse_str_callback(self, cb_supplied_name):
         scoring = get_scorer(cb_supplied_name)
         scoring_name = scoring._score_func.__name__
-        assert scoring_name.endswith(
-            ('_score', '_error', '_deviance', '_loss'))
-        if (scoring_name.endswith('_score') or
-                cb_supplied_name.startswith('neg_')):
+        assert scoring_name.endswith(("_score", "_error", "_deviance", "_loss"))
+        if scoring_name.endswith("_score") or cb_supplied_name.startswith("neg_"):
             lower_is_better = False
         else:
             lower_is_better = True
-        train_name = f'train_{cb_supplied_name}'
-        valid_name = f'valid_{cb_supplied_name}'
+        train_name = f"train_{cb_supplied_name}"
+        valid_name = f"valid_{cb_supplied_name}"
         if self.cropped:
             train_scoring = CroppedTrialEpochScoring(
                 cb_supplied_name, lower_is_better, on_train=True, name=train_name
@@ -98,7 +100,7 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
         named_by_user = True
         train_valid_callbacks = [
             (train_name, train_scoring, named_by_user),
-            (valid_name, valid_scoring, named_by_user)
+            (valid_name, valid_scoring, named_by_user),
         ]
         return train_valid_callbacks
 
@@ -108,8 +110,13 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
         if not training:
             epoch_cbs = []
             for name, cb in self.callbacks_:
-                if isinstance(cb, (CroppedTrialEpochScoring, CroppedTimeSeriesEpochScoring)) and (
-                        hasattr(cb, 'window_inds_')) and (not cb.on_train):
+                if (
+                    isinstance(
+                        cb, (CroppedTrialEpochScoring, CroppedTimeSeriesEpochScoring)
+                    )
+                    and (hasattr(cb, "window_inds_"))
+                    and (not cb.on_train)
+                ):
                     epoch_cbs.append(cb)
             # for trialwise decoding stuffs it might also be we don't have
             # cropped loader, so no indices there
@@ -136,8 +143,11 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
         i_window_stops = np.concatenate(i_window_stops)
         window_ys = np.concatenate(window_ys)
         return dict(
-            preds=preds, i_window_in_trials=i_window_in_trials,
-            i_window_stops=i_window_stops, window_ys=window_ys)
+            preds=preds,
+            i_window_in_trials=i_window_in_trials,
+            i_window_stops=i_window_stops,
+            window_ys=window_ys,
+        )
 
     # Changes the default target extractor to noop
     @property
@@ -156,7 +166,9 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
             (
                 "valid_loss",
                 BatchScoring(
-                    valid_loss_score, name="valid_loss", target_extractor=noop,
+                    valid_loss_score,
+                    name="valid_loss",
+                    target_extractor=noop,
                 ),
             ),
             ("print_log", PrintLog()),
@@ -179,17 +191,27 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
             return
         # get kwargs from signal:
         signal_kwargs = dict()
-        if isinstance(X, mne.BaseEpochs) or isinstance(X, np.ndarray):
+        # Using shape to work both with torch.tensor and numpy.array:
+        if (
+            isinstance(X, mne.BaseEpochs)
+            or (hasattr(X, "shape") and len(X.shape) >= 2)
+            or isinstance(X, SliceDataset)
+        ):
             if y is None:
-                raise ValueError("y must be specified if X is a numpy array.")
-            signal_kwargs['n_outputs'] = self._get_n_outputs(y, classes)
+                raise ValueError("y must be specified if X is array-like.")
+            signal_kwargs["n_outputs"] = self._get_n_outputs(y, classes)
             if isinstance(X, mne.BaseEpochs):
                 self.log.info("Using mne.Epochs to find signal-related parameters.")
                 signal_kwargs["n_times"] = len(X.times)
-                signal_kwargs["sfreq"] = X.info['sfreq']
-                signal_kwargs["chs_info"] = X.info['chs']
+                signal_kwargs["sfreq"] = X.info["sfreq"]
+                signal_kwargs["chs_info"] = X.info["chs"]
+            elif isinstance(X, SliceDataset):
+                self.log.info("Using SliceDataset to find signal-related parameters.")
+                Xshape = X[0].shape
+                signal_kwargs["n_times"] = Xshape[-1]
+                signal_kwargs["n_chans"] = Xshape[-2]
             else:
-                self.log.info("Using numpy array to find signal-related parameters.")
+                self.log.info("Using array-like to find signal-related parameters.")
                 signal_kwargs["n_times"] = X.shape[-1]
                 signal_kwargs["n_chans"] = X.shape[-2]
         elif is_dataset(X):
@@ -198,21 +220,17 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
             Xshape = X0.shape
             signal_kwargs["n_times"] = Xshape[-1]
             signal_kwargs["n_chans"] = Xshape[-2]
-            if (
-                    isinstance(X, BaseConcatDataset) and
-                    all(ds.targets_from == 'metadata' for ds in X.datasets)
+            if isinstance(X, BaseConcatDataset) and all(
+                ds.targets_from == "metadata" for ds in X.datasets
             ):
                 y_target = X.get_metadata().target
-                signal_kwargs['n_outputs'] = self._get_n_outputs(y_target, classes)
-            elif (
-                    isinstance(X, WindowsDataset) and
-                    X.targets_from == "metadata"
-            ):
+                signal_kwargs["n_outputs"] = self._get_n_outputs(y_target, classes)
+            elif isinstance(X, WindowsDataset) and X.targets_from == "metadata":
                 y_target = X.windows.metadata.target
-                signal_kwargs['n_outputs'] = self._get_n_outputs(y_target, classes)
+                signal_kwargs["n_outputs"] = self._get_n_outputs(y_target, classes)
         else:
             self.log.warning(
-                "Can only infer signal shape of numpy arrays or and Datasets, "
+                "Can only infer signal shape of array-like and Datasets, "
                 f"got {type(X)!r}."
             )
             return
@@ -227,15 +245,13 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
             if k in all_module_kwargs:
                 module_kwargs[k] = v
             else:
-                self.log.warning(
-                    f"Module {self.module!r} "
-                    f"is missing parameter {k!r}."
-                )
+                self.log.warning(f"Module {self.module!r} is missing parameter {k!r}.")
 
         # save kwargs to self:
         self.log.info(
             f"Passing additional parameters {module_kwargs!r} "
-            f"to module {self.module!r}.")
+            f"to module {self.module!r}."
+        )
         module_kwargs = {f"module__{k}": v for k, v in module_kwargs.items()}
         self.set_params(**module_kwargs)
 
@@ -275,7 +291,7 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
 
         """
         if isinstance(X, mne.BaseEpochs):
-            X = X.get_data(units='uV')
+            X = X.get_data(units="uV")
         return super().get_dataset(X, y)
 
     def partial_fit(self, X, y=None, classes=None, **fit_params):
@@ -291,7 +307,7 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
 
           * mne.Epochs: ``n_times``, ``n_chans``, ``n_outputs``, ``chs_info``,
             ``sfreq``, ``input_window_seconds``
-          * numpy array: ``n_times``, ``n_chans``, ``n_outputs``
+          * array-like: ``n_times``, ``n_chans``, ``n_outputs``
           * WindowsDataset with ``targets_from='metadata'``
             (or BaseConcatDataset of such datasets): ``n_times``, ``n_chans``, ``n_outputs``
           * other Dataset: ``n_times``, ``n_chans``
@@ -345,7 +361,7 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
 
           * mne.Epochs: ``n_times``, ``n_chans``, ``n_outputs``, ``chs_info``,
             ``sfreq``, ``input_window_seconds``
-          * numpy array: ``n_times``, ``n_chans``, ``n_outputs``
+          * array-like: ``n_times``, ``n_chans``, ``n_outputs``
           * WindowsDataset with ``targets_from='metadata'``
             (or BaseConcatDataset of such datasets): ``n_times``, ``n_chans``, ``n_outputs``
           * other Dataset: ``n_times``, ``n_chans``

braindecode/functional/__init__.py

@@ -0,0 +1,10 @@
+from .functions import (
+    _get_gaussian_kernel1d,
+    drop_path,
+    hilbert_freq,
+    identity,
+    plv_time,
+    safe_log,
+    square,
+)
+from .initialization import glorot_weight_zero_bias, rescale_parameter