braindecode 0.4.4__tar.gz → 0.4.6__tar.gz

{Braindecode-0.4.4 → Braindecode-0.4.6}/Braindecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.4.4
+Version: 0.4.6
 Summary: A deep learning toolbox to decode raw time-domain EEG.
 Home-page: https://github.com/robintibor/braindecode
 Author: Robin Tibor Schirrmeister

{Braindecode-0.4.4 → Braindecode-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.4.4
+Version: 0.4.6
 Summary: A deep learning toolbox to decode raw time-domain EEG.
 Home-page: https://github.com/robintibor/braindecode
 Author: Robin Tibor Schirrmeister

Braindecode-0.4.6/braindecode/datautil/splitters.py

@@ -0,0 +1,190 @@
+import numpy as np
+
+from braindecode.datautil.iterators import get_balanced_batches
+from braindecode.datautil.signal_target import apply_to_X_y, SignalAndTarget
+
+
+def concatenate_sets(sets):
+    """
+    Concatenate all sets together.
+    
+    Parameters
+    ----------
+    sets: list of :class:`.SignalAndTarget`
+
+    Returns
+    -------
+    concatenated_set: :class:`.SignalAndTarget`
+    """
+    concatenated_set = sets[0]
+    for s in sets[1:]:
+        concatenated_set = concatenate_two_sets(concatenated_set, s)
+    return concatenated_set
+
+
+def concatenate_two_sets(set_a, set_b):
+    """
+    Concatenate two sets together.
+    
+    Parameters
+    ----------
+    set_a, set_b: :class:`.SignalAndTarget`
+
+    Returns
+    -------
+    concatenated_set: :class:`.SignalAndTarget`
+    """
+    new_X = concatenate_np_array_or_add_lists(set_a.X, set_b.X)
+    new_y = concatenate_np_array_or_add_lists(set_a.y, set_b.y)
+    return SignalAndTarget(new_X, new_y)
+
+def concatenate_np_array_or_add_lists(a, b):
+    if hasattr(a, 'ndim') and hasattr(b, 'ndim'):
+        new = np.concatenate((a, b), axis=0)
+    else:
+        if hasattr(a, 'ndim'):
+            a = a.tolist()
+        if hasattr(b, 'ndim'):
+            b = b.tolist()
+        new = a + b
+    return new
+
+
+
+def split_into_two_sets(dataset, first_set_fraction=None, n_first_set=None):
+    """
+    Split set into two sets either by fraction of first set or by number
+    of trials in first set.
+
+    Parameters
+    ----------
+    dataset: :class:`.SignalAndTarget`
+    first_set_fraction: float, optional
+        Fraction of trials in first set.
+    n_first_set: int, optional
+        Number of trials in first set
+
+    Returns
+    -------
+    first_set, second_set: :class:`.SignalAndTarget`
+        The two splitted sets.
+    """
+    assert (first_set_fraction is None) != (n_first_set is None), (
+        "Pass either first_set_fraction or n_first_set")
+    if n_first_set is None:
+        n_first_set = int(round(len(dataset.X) * first_set_fraction))
+    assert n_first_set < len(dataset.X)
+    first_set = apply_to_X_y(lambda a: a[:n_first_set], dataset)
+    second_set = apply_to_X_y(lambda a: a[n_first_set:], dataset)
+    return first_set, second_set
+
+
+def select_examples(dataset, indices):
+    """
+    Select examples from dataset.
+    
+    Parameters
+    ----------
+    dataset: :class:`.SignalAndTarget`
+    indices: list of int, 1d-array of int
+        Indices to select
+
+    Returns
+    -------
+    reduced_set: :class:`.SignalAndTarget`
+        Dataset with only examples selected.
+    """
+    # probably not necessary
+    indices = np.array(indices)
+    if hasattr(dataset.X, 'ndim'):
+        # numpy array
+        new_X = np.array(dataset.X)[indices]
+    else:
+        # list
+        new_X = [dataset.X[i] for i in indices]
+    new_y = np.asarray(dataset.y)[indices]
+    return SignalAndTarget(new_X, new_y)
+
+
+def split_into_train_valid_test(dataset, n_folds, i_test_fold, rng=None):
+    """
+    Split datasets into folds, select one valid fold, one test fold and merge rest as train fold.
+
+    Parameters
+    ----------
+    dataset: :class:`.SignalAndTarget`
+    n_folds: int
+        Number of folds to split dataset into.
+    i_test_fold: int
+        Index of the test fold (0-based). Validation fold will be immediately preceding fold.
+    rng: `numpy.random.RandomState`, optional
+        Random Generator for shuffling, None means no shuffling
+
+    Returns
+    -------
+    reduced_set: :class:`.SignalAndTarget`
+        Dataset with only examples selected.
+    """
+    n_trials = len(dataset.X)
+    if n_trials < n_folds:
+        raise ValueError("Less Trials: {:d} than folds: {:d}".format(
+            n_trials, n_folds
+            ))
+    shuffle = rng is not None
+    folds = get_balanced_batches(
+        n_trials, rng, shuffle, n_batches=n_folds)
+    test_inds = folds[i_test_fold]
+    valid_inds = folds[i_test_fold - 1]
+    all_inds = list(range(n_trials))
+    train_inds = np.setdiff1d(all_inds, np.union1d(test_inds, valid_inds))
+    assert np.intersect1d(train_inds, valid_inds).size == 0
+    assert np.intersect1d(train_inds, test_inds).size == 0
+    assert np.intersect1d(valid_inds, test_inds).size == 0
+    assert np.array_equal(np.sort(
+        np.union1d(train_inds, np.union1d(valid_inds, test_inds))),
+        all_inds)
+
+    train_set = select_examples(dataset, train_inds)
+    valid_set = select_examples(dataset, valid_inds)
+    test_set = select_examples(dataset, test_inds)
+
+    return train_set, valid_set, test_set
+
+
+def split_into_train_test(dataset, n_folds, i_test_fold, rng=None):
+    """
+     Split datasets into folds, select one test fold and merge rest as train fold.
+
+    Parameters
+    ----------
+    dataset: :class:`.SignalAndTarget`
+    n_folds: int
+        Number of folds to split dataset into.
+    i_test_fold: int
+        Index of the test fold (0-based)
+    rng: `numpy.random.RandomState`, optional
+        Random Generator for shuffling, None means no shuffling
+
+    Returns
+    -------
+    reduced_set: :class:`.SignalAndTarget`
+        Dataset with only examples selected.
+    """
+    n_trials = len(dataset.X)
+    if n_trials < n_folds:
+        raise ValueError("Less Trials: {:d} than folds: {:d}".format(
+            n_trials, n_folds
+        ))
+    shuffle = rng is not None
+    folds = get_balanced_batches(n_trials, rng, shuffle,
+                                 n_batches=n_folds)
+    test_inds = folds[i_test_fold]
+    all_inds = list(range(len(n_trials)))
+    train_inds = np.setdiff1d(all_inds, test_inds)
+    assert np.intersect1d(train_inds, test_inds).size == 0
+    assert np.array_equal(np.sort(np.union1d(train_inds, test_inds)),
+                          all_inds)
+
+    train_set = select_examples(dataset, train_inds)
+    test_set = select_examples(dataset, test_inds)
+    return train_set, test_set

{Braindecode-0.4.4 → Braindecode-0.4.6}/braindecode/models/base.py

@@ -15,6 +15,9 @@ from braindecode.datautil.signal_target import SignalAndTarget
 from braindecode.models.util import to_dense_prediction_model
 from braindecode.torch_ext.schedulers import CosineAnnealing, ScheduledOptimizer
 from braindecode.torch_ext.util import np_to_var, var_to_np
+import logging
+
+log = logging.getLogger(__name__)
 
 
 def find_optimizer(optimizer_name):
@@ -79,7 +82,14 @@ class BaseModel(object):
         self.loss = loss
         self._ensure_network_exists()
         if cropped:
-            to_dense_prediction_model(self.network)
+            model_already_dense = np.any([
+                hasattr(m, 'dilation') and (m.dilation != 1) and
+                (m.dilation) != (1, 1) for m in self.network.modules()
+            ])
+            if not model_already_dense:
+                to_dense_prediction_model(self.network)
+            else:
+                log.info("Seems model was already converted to dense model...")
         if not hasattr(optimizer, 'step'):
             optimizer_class = find_optimizer(optimizer)
             optimizer = optimizer_class(self.network.parameters())
@@ -141,7 +151,9 @@ class BaseModel(object):
                              "the network in a single pass.")
         if self.cropped:
             self.network.eval()
-            test_input = np_to_var(train_X[0:1], dtype=np.float32)
+            test_input = np_to_var(np.ones(
+                (1, train_X.shape[1], input_time_length,) + train_X.shape[3:],
+                dtype=np.float32))
             while len(test_input.size()) < 4:
                 test_input = test_input.unsqueeze(-1)
             if self.cuda:
@@ -273,8 +285,12 @@ class BaseModel(object):
             Predicted labels per trial. 
         """
         all_preds = []
-        for b_X, _ in self.iterator.get_batches(SignalAndTarget(X, X), False):
-            all_preds.append(var_to_np(self.network(np_to_var(b_X))))
+        with th.no_grad():
+            for b_X, _ in self.iterator.get_batches(SignalAndTarget(X, X), False):
+                b_X_var = np_to_var(b_X)
+                if self.cuda:
+                    b_X_var = b_X_var.cuda()
+                all_preds.append(var_to_np(self.network(b_X_var)))
         if self.cropped:
             pred_labels = compute_trial_labels_from_crop_preds(
                 all_preds, self.iterator.input_time_length, X)

{Braindecode-0.4.4 → Braindecode-0.4.6}/braindecode/models/eegnet.py

@@ -21,7 +21,7 @@ class Conv2dWithConstraint(nn.Conv2d):
 
 class EEGNetv4(BaseModel):
     """
-    EEGNet v4 model from [EEGNet]_.
+    EEGNet v4 model from [EEGNet4]_.
 
     Notes
     -----
@@ -31,7 +31,7 @@ class EEGNetv4(BaseModel):
     References
     ----------
 
-    .. [EEGNet] Lawhern, V. J., Solon, A. J., Waytowich, N. R., Gordon,
+    .. [EEGNet4] Lawhern, V. J., Solon, A. J., Waytowich, N. R., Gordon,
        S. M., Hung, C. P., & Lance, B. J. (2018).
        EEGNet: A Compact Convolutional Network for EEG-based
        Brain-Computer Interfaces.

{Braindecode-0.4.4 → Braindecode-0.4.6}/braindecode/models/hybrid.py

@@ -8,7 +8,24 @@ from braindecode.models.shallow_fbcsp import ShallowFBCSPNet
 from braindecode.models.util import to_dense_prediction_model
 
 
-class HybridNet(nn.Module, BaseModel):
+class HybridNet(BaseModel):
+    """
+    Wrapper for HybridNetModule
+    """
+    def __init__(self, in_chans, n_classes, input_time_length):
+        self.in_chans  = in_chans
+        self.n_classes = n_classes
+        self.input_time_length = input_time_length
+
+    def create_network(self):
+        return HybridNetModule(
+            in_chans=self.in_chans,
+            n_classes=self.n_classes,
+            input_time_length=self.input_time_length
+        )
+
+
+class HybridNetModule(nn.Module):
     """
     Hybrid ConvNet model from [3]_.
        
@@ -23,16 +40,16 @@ class HybridNet(nn.Module, BaseModel):
        visualization.
        Human Brain Mapping , Aug. 2017. Online: http://dx.doi.org/10.1002/hbm.23730
     """
-    def __init__(self, n_chans, n_classes, input_time_length):
-        super(HybridNet, self).__init__()
-        deep_model = Deep4Net(n_chans, n_classes, n_filters_time=20,
+    def __init__(self, in_chans, n_classes, input_time_length):
+        super(HybridNetModule, self).__init__()
+        deep_model = Deep4Net(in_chans, n_classes, n_filters_time=20,
                               n_filters_spat=30,
                               n_filters_2=40,
                               n_filters_3=50,
                               n_filters_4=60,
                               input_time_length=input_time_length,
                               final_conv_length=2).create_network()
-        shallow_model = ShallowFBCSPNet(n_chans, n_classes,
+        shallow_model = ShallowFBCSPNet(in_chans, n_classes,
                                         input_time_length=input_time_length,
                                         n_filters_time=30,
                                         n_filters_spat=40,

{Braindecode-0.4.4 → Braindecode-0.4.6}/braindecode/torch_ext/init.py

@@ -17,7 +17,7 @@ def glorot_weight_zero_bias(model):
             if not ('BatchNorm' in module.__class__.__name__):
                 init.xavier_uniform_(module.weight, gain=1)
             else:
-                init.constant(module.weight, 1)
+                init.constant_(module.weight, 1)
         if hasattr(module, 'bias'):
             if module.bias is not None:
                 init.constant_(module.bias, 0)

{Braindecode-0.4.4 → Braindecode-0.4.6}/braindecode/torch_ext/optimizers.py

@@ -4,7 +4,7 @@ from torch.optim.optimizer import Optimizer
 
 
 class AdamW(Optimizer):
-    """Implements Adam algorithm with fixed as TODO 
+    """Implements Adam algorithm with fixed as in `AdamW`
 
     It has been proposed in `Adam: A Method for Stochastic Optimization`_.
 

Braindecode-0.4.6/braindecode/version.py

@@ -0,0 +1 @@
+__version__ = "0.4.6"

{Braindecode-0.4.4 → Braindecode-0.4.6}/braindecode/visualization/perturbation.py

@@ -8,7 +8,7 @@ from braindecode.util import wrap_reshape_apply_fn, corr
 log = logging.getLogger(__name__)
 
 
-def phase_perturbation(amps,phases,rng=np.random.RandomState()):
+def phase_perturbation(amps,phases,rng=None):
     """Takes amps and phases of BxCxF with B input, C channels, F frequencies
     Shifts spectral phases randomly U(-pi,pi) for input and frequencies, but same for all channels
 
@@ -19,7 +19,7 @@ def phase_perturbation(amps,phases,rng=np.random.RandomState()):
     phases : numpy array
         Spectral phases
     rng : object
-        Random Seed
+        Random Generator
 
     Returns
     -------
@@ -30,6 +30,8 @@ def phase_perturbation(amps,phases,rng=np.random.RandomState()):
     pert_vals : numpy array
         Absolute phase shifts
     """
+    if rng is None:
+        rng = np.random.RandomState()
     noise_shape = list(phases.shape)
     noise_shape[1] = 1 # Do not sample noise for channels individually
 
@@ -44,7 +46,7 @@ def phase_perturbation(amps,phases,rng=np.random.RandomState()):
     pert_vals = np.abs(phase_noise)
     return amps,phases_pert,pert_vals
 
-def amp_perturbation_additive(amps,phases,rng=np.random.RandomState()):
+def amp_perturbation_additive(amps,phases,rng=None):
     """Takes amplitudes and phases of BxCxF with B input, C channels, F frequencies
     Adds additive noise N(0,0.02) to amplitudes
 
@@ -66,13 +68,15 @@ def amp_perturbation_additive(amps,phases,rng=np.random.RandomState()):
     pert_vals : numpy array
         Amplitude noise
     """
+    if rng is None:
+        rng = np.random.RandomState()
     amp_noise = rng.normal(0,1,amps.shape).astype(np.float32)
     amps_pert = amps+amp_noise
     amps_pert[amps_pert<0] = 0
     amp_noise = amps_pert-amps
     return amps_pert,phases,amp_noise
 
-def amp_perturbation_multiplicative(amps,phases,rng=np.random.RandomState()):
+def amp_perturbation_multiplicative(amps,phases,rng=None):
     """Takes amplitude and phases of BxCxF with B input, C channels, F frequencies
     Adds multiplicative noise N(1,0.02) to amplitudes
 
@@ -94,6 +98,8 @@ def amp_perturbation_multiplicative(amps,phases,rng=np.random.RandomState()):
     pert_vals : numpy array
         Amplitude scaling factor
     """
+    if rng is None:
+        rng = np.random.RandomState()
     amp_noise = rng.normal(1,0.02,amps.shape).astype(np.float32)
     amps_pert = amps*amp_noise
     amps_pert[amps_pert<0] = 0

Braindecode-0.4.4/braindecode/datautil/splitters.py

@@ -1,106 +0,0 @@
-import numpy as np
-
-from braindecode.datautil.signal_target import apply_to_X_y, SignalAndTarget
-
-
-def concatenate_sets(sets):
-    """
-    Concatenate all sets together.
-    
-    Parameters
-    ----------
-    sets: list of :class:`.SignalAndTarget`
-
-    Returns
-    -------
-    concatenated_set: :class:`.SignalAndTarget`
-    """
-    concatenated_set = sets[0]
-    for s in sets[1:]:
-        concatenated_set = concatenate_two_sets(concatenated_set, s)
-    return concatenated_set
-
-
-def concatenate_two_sets(set_a, set_b):
-    """
-    Concatenate two sets together.
-    
-    Parameters
-    ----------
-    set_a, set_b: :class:`.SignalAndTarget`
-
-    Returns
-    -------
-    concatenated_set: :class:`.SignalAndTarget`
-    """
-    new_X = concatenate_np_array_or_add_lists(set_a.X, set_b.X)
-    new_y = concatenate_np_array_or_add_lists(set_a.y, set_b.y)
-    return SignalAndTarget(new_X, new_y)
-
-def concatenate_np_array_or_add_lists(a, b):
-    if hasattr(a, 'ndim') and hasattr(b, 'ndim'):
-        new = np.concatenate((a, b), axis=0)
-    else:
-        if hasattr(a, 'ndim'):
-            a = a.tolist()
-        if hasattr(b, 'ndim'):
-            b = b.tolist()
-        new = a + b
-    return new
-
-
-
-def split_into_two_sets(dataset, first_set_fraction=None, n_first_set=None):
-    """
-    Split set into two sets either by fraction of first set or by number
-    of trials in first set.
-
-    Parameters
-    ----------
-    dataset: :class:`.SignalAndTarget`
-    first_set_fraction: float, optional
-        Fraction of trials in first set.
-    n_first_set: int, optional
-        Number of trials in first set
-
-    Returns
-    -------
-    first_set, second_set: :class:`.SignalAndTarget`
-        The two splitted sets.
-    """
-    assert (first_set_fraction is None) != (n_first_set is None), (
-        "Pass either first_set_fraction or n_first_set")
-    if n_first_set is None:
-        n_first_set = int(round(len(dataset.X) * first_set_fraction))
-    assert n_first_set < len(dataset.X)
-    first_set = apply_to_X_y(lambda a: a[:n_first_set], dataset)
-    second_set = apply_to_X_y(lambda a: a[n_first_set:], dataset)
-    return first_set, second_set
-
-
-def select_examples(dataset, indices):
-    """
-    Select examples from dataset.
-    
-    Parameters
-    ----------
-    dataset: :class:`.SignalAndTarget`
-    indices: list of int, 1d-array of int
-        Indices to select
-
-    Returns
-    -------
-    reduced_set: :class:`.SignalAndTarget`
-        Dataset with only examples selected.
-    """
-    # probably not necessary
-    indices = np.array(indices)
-    if hasattr(dataset.X, 'ndim'):
-        # numpy array
-        new_X = np.array(dataset.X)[indices]
-    else:
-        # list
-        new_X = [dataset.X[i] for i in indices]
-    new_y = np.asarray(dataset.y)[indices]
-    return SignalAndTarget(new_X, new_y)
-

Braindecode-0.4.4/braindecode/version.py

@@ -1 +0,0 @@
-__version__ = "0.4.4"