braindecode 0.4.1__tar.gz → 0.4.3__tar.gz

{Braindecode-0.4.1 → Braindecode-0.4.3}/Braindecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.4.1
+Version: 0.4.3
 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.1 → Braindecode-0.4.3}/Braindecode.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ braindecode/mne_ext/signalproc.py
 braindecode/models/__init__.py
 braindecode/models/base.py
 braindecode/models/deep4.py
+braindecode/models/deep4new.py
 braindecode/models/eegnet.py
 braindecode/models/hybrid.py
 braindecode/models/shallow_fbcsp.py
@@ -63,7 +64,6 @@ docs/notebooks/Cropped_Trialwise_Explanation_Figures.ipynb
 docs/notebooks/Trialwise_Decoding.ipynb
 docs/notebooks/Trialwise_Manual_Training_Loop.ipynb
 docs/notebooks/visualization/Perturbation.ipynb
-docs/notebooks/visualization/Perturbation_Old.ipynb
 docs/source/braindecode.datasets.rst
 docs/source/braindecode.datautil.rst
 docs/source/braindecode.experiments.rst

{Braindecode-0.4.1 → Braindecode-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.4.1
+Version: 0.4.3
 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.1 → Braindecode-0.4.3}/braindecode/models/base.py

@@ -57,7 +57,7 @@ class BaseModel(object):
             self.cuda = False
             self.compiled = False
 
-    def compile(self, loss, optimizer, monitors=None,  cropped=False, iterator_seed=0):
+    def compile(self, loss, optimizer, extra_monitors=None,  cropped=False, iterator_seed=0):
         """
         Setup training for this model.
         
@@ -66,7 +66,7 @@ class BaseModel(object):
         loss: function (predictions, targets) -> torch scalar
         optimizer: `torch.optim.Optimizer` or string
             Either supply an optimizer or the name of the class (e.g. 'adam')
-        monitors: List of Braindecode monitors, optional
+        extra_monitors: List of Braindecode monitors, optional
             In case you want to monitor additional values except for loss, misclass and runtime.
         cropped: bool
             Whether to perform cropped decoding, see cropped decoding tutorial.
@@ -84,7 +84,7 @@ class BaseModel(object):
             optimizer_class = find_optimizer(optimizer)
             optimizer = optimizer_class(self.network.parameters())
         self.optimizer = optimizer
-        self.extra_monitors = monitors
+        self.extra_monitors = extra_monitors
         # Already setting it here, so multiple calls to fit
         # will lead to different batches being drawn
         self.seed_rng = RandomState(iterator_seed)
@@ -93,7 +93,8 @@ class BaseModel(object):
 
     def fit(self, train_X, train_y, epochs, batch_size, input_time_length=None,
             validation_data=None, model_constraint=None,
-            remember_best_column=None, scheduler=None):
+            remember_best_column=None, scheduler=None,
+            log_0_epoch=True):
         """
         Fit the model using the given training data.
         
@@ -122,6 +123,8 @@ class BaseModel(object):
             determines the best epoch.
         scheduler: 'cosine' or None, optional
             Whether to use cosine annealing (:class:`.CosineAnnealing`).
+        log_0_epoch: bool
+            Whether to compute the metrics once before training as well.
 
         Returns
         -------
@@ -153,7 +156,10 @@ class BaseModel(object):
             self.iterator = BalancedBatchSizeIterator(
                 batch_size=batch_size,
                 seed=self.seed_rng.randint(0, 4294967295))
-        stop_criterion = MaxEpochs(epochs - 1)# -1 since we dont print 0 epoch, which matters for this stop criterion
+        if log_0_epoch:
+            stop_criterion = MaxEpochs(epochs)
+        else:
+            stop_criterion = MaxEpochs(epochs - 1)
         train_set = SignalAndTarget(train_X, train_y)
         optimizer = self.optimizer
         if scheduler is not None:
@@ -193,7 +199,8 @@ class BaseModel(object):
                          monitors=self.monitors,
                          stop_criterion=stop_criterion,
                          remember_best_column=remember_best_column,
-                         run_after_early_stop=False, cuda=self.cuda, log_0_epoch=False,
+                         run_after_early_stop=False, cuda=self.cuda,
+                         log_0_epoch=log_0_epoch,
                          do_early_stop=(remember_best_column is not None))
         exp.run()
         self.epochs_df = exp.epochs_df
@@ -238,7 +245,7 @@ class BaseModel(object):
                          stop_criterion=stop_criterion,
                          remember_best_column=None,
                          run_after_early_stop=False, cuda=self.cuda,
-                         log_0_epoch=False,
+                         log_0_epoch=True,
                          do_early_stop=False)
 
         exp.monitor_epoch({'train': train_set})

Braindecode-0.4.3/braindecode/models/deep4new.py

@@ -0,0 +1,228 @@
+import numpy as np
+from torch import nn
+from torch.nn import init
+from torch.nn.functional import elu
+
+from braindecode.models.base import BaseModel
+from braindecode.torch_ext.modules import Expression, AvgPool2dWithConv
+from braindecode.torch_ext.functions import identity
+from braindecode.torch_ext.util import np_to_var
+
+
+class Deep4NetNew(BaseModel):
+    """
+    Deep ConvNet model from [1]_.
+
+    References
+    ----------
+
+    .. [1] Schirrmeister, R. T., Springenberg, J. T., Fiederer, L. D. J., 
+       Glasstetter, M., Eggensperger, K., Tangermann, M., ... & Ball, T. (2017).
+       Deep learning with convolutional neural networks for EEG decoding and
+       visualization.
+       arXiv preprint arXiv:1703.05051.
+    """
+    def __init__(self, in_chans,
+                 n_classes,
+                 input_time_length,
+                 final_conv_length,
+                 n_filters_time=25,
+                 n_filters_spat=25,
+                 filter_time_length=10,
+                 pool_time_length=3,
+                 pool_time_stride=3,
+                 n_filters_2=50,
+                 filter_length_2=10,
+                 n_filters_3=100,
+                 filter_length_3=10,
+                 n_filters_4=200,
+                 filter_length_4=10,
+                 first_nonlin=elu,
+                 first_pool_mode='max',
+                 first_pool_nonlin=identity,
+                 later_nonlin=elu,
+                 later_pool_mode='max',
+                 later_pool_nonlin=identity,
+                 drop_prob=0.5,
+                 double_time_convs=False,
+                 split_first_layer=True,
+                 batch_norm=True,
+                 batch_norm_alpha=0.1,
+                 stride_before_pool=False,
+                 separable=False):
+        if final_conv_length == 'auto':
+            assert input_time_length is not None
+
+        self.__dict__.update(locals())
+        del self.self
+
+    def create_network(self):
+        def add_conv_2d(separable, model, name,
+                    in_filters, out_filters, kernel_size,  **kwargs):
+            if separable:
+                model.add_module(
+                    name + '_depth',
+                    nn.Conv2d(
+                        in_filters, in_filters, kernel_size, groups=in_filters,
+                        **kwargs))
+                model.add_module(
+                    name + '_point',
+                    nn.Conv2d(
+                        in_filters, out_filters, (1, 1), **kwargs))
+            else:
+                model.add_module(
+                    name,
+                    nn.Conv2d(in_filters, out_filters,
+                              kernel_size, **kwargs))
+
+        if self.stride_before_pool:
+            conv_stride = self.pool_time_stride
+            pool_stride = 1
+        else:
+            conv_stride = 1
+            pool_stride = self.pool_time_stride
+        pool_class_dict = dict(max=nn.MaxPool2d, mean=AvgPool2dWithConv)
+        first_pool_class = pool_class_dict[self.first_pool_mode]
+        later_pool_class = pool_class_dict[self.later_pool_mode]
+        model = nn.Sequential()
+        if self.split_first_layer:
+            model.add_module('dimshuffle', Expression(_transpose_time_to_spat))
+            model.add_module('conv_time', nn.Conv2d(1, self.n_filters_time,
+                                                    (
+                                                    self.filter_time_length, 1),
+                                                    stride=1, ))
+            add_conv_2d(
+                self.separable, model, 'conv_spat',
+                self.n_filters_time, self.n_filters_spat,
+                (1, self.in_chans),
+                stride=(conv_stride, 1),
+                bias=not self.batch_norm)
+            n_filters_conv = self.n_filters_spat
+        else:
+            add_conv_2d(
+                self.separable, model, 'conv_time',
+                self.in_chans, self.n_filters_time,
+               (self.filter_time_length, 1),
+               stride=(conv_stride, 1),
+               bias=not self.batch_norm)
+            n_filters_conv = self.n_filters_time
+        if self.batch_norm:
+            model.add_module('bnorm',
+                             nn.BatchNorm2d(n_filters_conv,
+                                            momentum=self.batch_norm_alpha,
+                                            affine=True,
+                                            eps=1e-5),)
+        model.add_module('conv_nonlin', Expression(self.first_nonlin))
+        model.add_module('pool',
+                         first_pool_class(
+                             kernel_size=(self.pool_time_length, 1),
+                             stride=(pool_stride, 1)))
+        model.add_module('pool_nonlin', Expression(self.first_pool_nonlin))
+
+        def add_conv_pool_block(model, n_filters_before,
+                                n_filters, filter_length, block_nr):
+            suffix = '_{:d}'.format(block_nr)
+            model.add_module('drop' + suffix,
+                             nn.Dropout(p=self.drop_prob))
+            add_conv_2d(
+                self.separable, model, 'conv' + suffix.format(block_nr),
+                n_filters_before, n_filters,
+               (filter_length, 1),
+               stride=(conv_stride, 1),
+               bias=not self.batch_norm)
+            if self.batch_norm:
+                model.add_module('bnorm' + suffix,
+                             nn.BatchNorm2d(n_filters,
+                                            momentum=self.batch_norm_alpha,
+                                            affine=True,
+                                            eps=1e-5))
+            model.add_module('nonlin' + suffix,
+                             Expression(self.later_nonlin))
+
+            model.add_module('pool' + suffix,
+                             later_pool_class(
+                                 kernel_size=(self.pool_time_length, 1),
+                                 stride=(pool_stride, 1)))
+            model.add_module('pool_nonlin' + suffix,
+                             Expression(self.later_pool_nonlin))
+
+        add_conv_pool_block(model, n_filters_conv, self.n_filters_2,
+                            self.filter_length_2, 2)
+        add_conv_pool_block(model, self.n_filters_2, self.n_filters_3,
+                            self.filter_length_3, 3)
+        add_conv_pool_block(model, self.n_filters_3, self.n_filters_4,
+                            self.filter_length_4, 4)
+
+
+        model.eval()
+        if self.final_conv_length == 'auto':
+            out = model(np_to_var(np.ones(
+                (1, self.in_chans, self.input_time_length,1),
+                dtype=np.float32)))
+            n_out_time = out.cpu().data.numpy().shape[2]
+            self.final_conv_length = n_out_time
+        model.add_module('conv_classifier',
+                             nn.Conv2d(self.n_filters_4, self.n_classes,
+                                       (self.final_conv_length, 1), bias=True))
+        model.add_module('softmax', nn.LogSoftmax(dim=1))
+        model.add_module('squeeze',  Expression(_squeeze_final_output))
+
+        # Initialization, xavier is same as in our paper...
+        # was default from lasagne
+        init.xavier_uniform_(model.conv_time.weight, gain=1)
+        # maybe no bias in case of no split layer and batch norm
+        if self.split_first_layer or (not self.batch_norm):
+            init.constant_(model.conv_time.bias, 0)
+        if self.split_first_layer:
+            if self.separable:
+                init.xavier_uniform_(model.conv_spat_depth.weight, gain=1)
+                init.xavier_uniform_(model.conv_spat_point.weight, gain=1)
+            else:
+                init.xavier_uniform_(model.conv_spat.weight, gain=1)
+            if not self.batch_norm:
+                if self.separable:
+                    init.constant_(model.conv_spat_depth.bias, 0)
+                    init.constant_(model.conv_spat_point.bias, 0)
+                else:
+                    init.constant_(model.conv_spat.bias, 0)
+        if self.batch_norm:
+            init.constant_(model.bnorm.weight, 1)
+            init.constant_(model.bnorm.bias, 0)
+        param_dict = dict(list(model.named_parameters()))
+        for block_nr in range(2,5):
+            suffixes = {True: ['_depth', '_point'], False:['']}[self.separable]
+            for suffix in suffixes:
+                conv_weight = param_dict['conv_{:d}{:s}.weight'.format(
+                    block_nr, suffix)]
+                init.xavier_uniform_(conv_weight, gain=1)
+            if not self.batch_norm:
+                for suffix in suffixes:
+                    conv_bias = param_dict['conv_{:d}{:s}.bias'.format(
+                        block_nr, suffix)]
+                    init.constant_(conv_bias, 0)
+            else:
+                bnorm_weight = param_dict['bnorm_{:d}.weight'.format(block_nr)]
+                bnorm_bias = param_dict['bnorm_{:d}.bias'.format(block_nr)]
+                init.constant_(bnorm_weight, 1)
+                init.constant_(bnorm_bias, 0)
+
+        init.xavier_uniform_(model.conv_classifier.weight, gain=1)
+        init.constant_(model.conv_classifier.bias, 0)
+
+        # Start in eval mode
+        model.eval()
+        return model
+
+
+# remove empty dim at end and potentially remove empty time dim
+# do not just use squeeze as we never want to remove first dim
+def _squeeze_final_output(x):
+    assert x.size()[3] == 1
+    x = x[:,:,:,0]
+    if x.size()[2] == 1:
+        x = x[:,:,0]
+    return x
+
+
+def _transpose_time_to_spat(x):
+    return x.permute(0, 3, 2, 1)

Braindecode-0.4.3/braindecode/version.py

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

Braindecode-0.4.1/braindecode/version.py

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