braindecode 0.3.0__tar.gz → 0.3.2__tar.gz

{Braindecode-0.3.0 → Braindecode-0.3.2}/Braindecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.3.0
+Version: 0.3.2
 Summary: A deep learning toolbox to decode raw time-domain EEG.
 Home-page: https://github.com/robintibor/braindecode
 Author: Robin Tibor Schirrmeister
@@ -30,16 +30,7 @@ Description: Note: The old braindecode repository has been moved to
         
           pip install numpy
         
-        3. Install newest version of python-mne:
-        
-        .. code-block:: bash
-        
-          git clone git://github.com/mne-tools/mne-python.git
-          cd mne-python
-          python setup.py install
-        
-        
-        4. Install braindecode via pip:
+        3. Install braindecode via pip:
         
         .. code-block:: bash
         

{Braindecode-0.3.0 → Braindecode-0.3.2}/Braindecode.egg-info/SOURCES.txt

@@ -42,8 +42,10 @@ braindecode/torch_ext/losses.py
 braindecode/torch_ext/modules.py
 braindecode/torch_ext/util.py
 braindecode/visualization/__init__.py
+braindecode/visualization/input_windows.py
 braindecode/visualization/perturbation.py
 braindecode/visualization/plot.py
+braindecode/visualization/sinfit.py
 docs/Makefile
 docs/conf.py
 docs/index.rst

{Braindecode-0.3.0 → Braindecode-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.3.0
+Version: 0.3.2
 Summary: A deep learning toolbox to decode raw time-domain EEG.
 Home-page: https://github.com/robintibor/braindecode
 Author: Robin Tibor Schirrmeister
@@ -30,16 +30,7 @@ Description: Note: The old braindecode repository has been moved to
         
           pip install numpy
         
-        3. Install newest version of python-mne:
-        
-        .. code-block:: bash
-        
-          git clone git://github.com/mne-tools/mne-python.git
-          cd mne-python
-          python setup.py install
-        
-        
-        4. Install braindecode via pip:
+        3. Install braindecode via pip:
         
         .. code-block:: bash
         

{Braindecode-0.3.0 → Braindecode-0.3.2}/README.rst

@@ -22,16 +22,7 @@ Installation
 
   pip install numpy
 
-3. Install newest version of python-mne:
-
-.. code-block:: bash
-
-  git clone git://github.com/mne-tools/mne-python.git
-  cd mne-python
-  python setup.py install
-
-
-4. Install braindecode via pip:
+3. Install braindecode via pip:
 
 .. code-block:: bash
 

{Braindecode-0.3.0 → Braindecode-0.3.2}/braindecode/datasets/bbci.py

@@ -93,7 +93,7 @@ class BBCIDataset(object):
 
     def _determine_samplingrate(self):
         with h5py.File(self.filename, 'r') as h5file:
-            fs = h5file['dat']['fs'][0, 0]
+            fs = h5file['nfo']['fs'][0, 0]
             assert isinstance(fs, int) or fs.is_integer()
             fs = int(fs)
         return fs
@@ -125,7 +125,7 @@ class BBCIDataset(object):
             Sensor names that match the pattern or all sensor names in the file.
         """
         with h5py.File(filename, 'r') as h5file:
-            clab_set = h5file['dat']['clab'][:].squeeze()
+            clab_set = h5file['nfo']['clab'][:].squeeze()
             all_sensor_names = [''.join(chr(c) for c in h5file[obj_ref]) for
                                 obj_ref in clab_set]
             if pattern is not None:
@@ -137,7 +137,7 @@ class BBCIDataset(object):
     def _add_markers(self, cnt):
         with h5py.File(self.filename, 'r') as h5file:
             event_times_in_ms = h5file['mrk']['time'][:].squeeze()
-            event_classes = h5file['mrk']['event']['desc'][:].squeeze()
+            event_classes = h5file['mrk']['event']['desc'][:].squeeze().astype(np.int64)
 
             # Check whether class names known and correct order
             class_name_set = h5file['nfo']['className'][:].squeeze()

{Braindecode-0.3.0 → Braindecode-0.3.2}/braindecode/datasets/sensor_positions.py

@@ -192,26 +192,32 @@ def get_channelpos_from_angle(channame, chan_pos_list=CHANNEL_10_20_APPROX):
         if i[0].lower() == channame:
             # convert the 90/4th angular position into x, y, z
             p = i[1]
-            ea, eb = p[0] * (90 / 4), p[1] * (90 / 4)
-            ea = ea * math.pi / 180
-            eb = eb * math.pi / 180
-            x = math.sin(ea) * math.cos(eb)
-            y = math.sin(eb)
-            z = math.cos(ea) * math.cos(eb)
-            # Calculate the stereographic projection.
-            # Given a unit sphere with radius ``r = 1`` and center at
-            # the origin. Project the point ``p = (x, y, z)`` from the
-            # sphere's South pole (0, 0, -1) on a plane on the sphere's
-            # North pole (0, 0, 1).
-            #
-            # The formula is:
-            #
-            # P' = P * (2r / (r + z))
-            #
-            # We changed the values to move the point of projection
-            # further below the south pole
-            mu = 1 / (1.3 + z)
-            x *= mu
-            y *= mu
+            x, y = _convert_2d_angle_to_2d_coord(*p)
             return x, y
     return None
+
+
+def _convert_2d_angle_to_2d_coord(a,b):
+    # convert the 90/4th angular position into x, y, z
+    ea, eb = a * (90 / 4), b * (90 / 4)
+    ea = ea * math.pi / 180
+    eb = eb * math.pi / 180
+    x = math.sin(ea) * math.cos(eb)
+    y = math.sin(eb)
+    z = math.cos(ea) * math.cos(eb)
+    # Calculate the stereographic projection.
+    # Given a unit sphere with radius ``r = 1`` and center at
+    # the origin. Project the point ``p = (x, y, z)`` from the
+    # sphere's South pole (0, 0, -1) on a plane on the sphere's
+    # North pole (0, 0, 1).
+    #
+    # The formula is:
+    #
+    # P' = P * (2r / (r + z))
+    #
+    # We changed the values to move the point of projection
+    # further below the south pole
+    mu = 1 / (1.3 + z)
+    x *= mu
+    y *= mu
+    return x, y

{Braindecode-0.3.0 → Braindecode-0.3.2}/braindecode/datautil/iterators.py

@@ -162,19 +162,23 @@ class CropsFromTrialsIterator(object):
         Number of predictions ConvNet makes per one input. Can be computed
         by making a forward pass with the given input time length, the
         output length in 3rd dimension is n_preds_per_input.
+    seed: int
+        Random seed for initialization of `numpy.RandomState`.
     
     See Also
     --------
     braindecode.experiments.monitors.compute_preds_per_trial_for_set : Assigns predictions to trials, removes overlaps.
     """
-    def __init__(self, batch_size, input_time_length, n_preds_per_input):
+    def __init__(self, batch_size, input_time_length, n_preds_per_input,
+                 seed=(2017, 6, 28)):
         self.batch_size = batch_size
         self.input_time_length = input_time_length
         self.n_preds_per_input = n_preds_per_input
-        self.rng = RandomState((2017, 6, 28))
+        self.seed = seed
+        self.rng = RandomState(self.seed)
 
     def reset_rng(self):
-        self.rng = RandomState((2017, 6, 28))
+        self.rng = RandomState(self.seed)
 
     def get_batches(self, dataset, shuffle):
         # start always at first predictable sample, so

{Braindecode-0.3.0 → Braindecode-0.3.2}/braindecode/datautil/signalproc.py

@@ -146,7 +146,8 @@ def lowpass_cnt(data, high_cut_hz, fs, filt_order=3, axis=0):
     return data_lowpassed
 
 
-def bandpass_cnt(data, low_cut_hz, high_cut_hz, fs, filt_order=3, axis=0):
+def bandpass_cnt(data, low_cut_hz, high_cut_hz, fs, filt_order=3, axis=0,
+                 filtfilt=False):
     """
      Bandpass signal applying **causal** butterworth filter of given order.
 
@@ -158,6 +159,8 @@ def bandpass_cnt(data, low_cut_hz, high_cut_hz, fs, filt_order=3, axis=0):
     high_cut_hz: float
     fs: float
     filt_order: int
+    filtfilt: bool
+        Whether to use filtfilt instead of lfilter
 
     Returns
     -------
@@ -182,7 +185,10 @@ def bandpass_cnt(data, low_cut_hz, high_cut_hz, fs, filt_order=3, axis=0):
     high = high_cut_hz / nyq_freq
     b, a = scipy.signal.butter(filt_order, [low, high], btype='bandpass')
     assert filter_is_stable(a), "Filter should be stable..."
-    data_bandpassed = scipy.signal.lfilter(b, a, data, axis=axis)
+    if filtfilt:
+        data_bandpassed = scipy.signal.filtfilt(b, a, data, axis=axis)
+    else:
+        data_bandpassed = scipy.signal.lfilter(b, a, data, axis=axis)
     return data_bandpassed
 
 

{Braindecode-0.3.0 → Braindecode-0.3.2}/braindecode/datautil/splitters.py

@@ -77,3 +77,30 @@ def split_into_two_sets(dataset, first_set_fraction=None, n_first_set=None):
     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.3.0 → Braindecode-0.3.2}/braindecode/datautil/trial_segment.py

@@ -9,9 +9,6 @@ from braindecode.datautil.util import ms_to_samples
 
 log = logging.getLogger(__name__)
 
-marker_def = OrderedDict(
-    (['Right', 1], ['Left', [2]], ['Rest', 3], ['Feet', 4]))
-
 
 def create_signal_target_from_raw_mne(
         raw, name_to_start_codes, epoch_ival_ms,

{Braindecode-0.3.0 → Braindecode-0.3.2}/braindecode/experiments/experiment.py

@@ -134,6 +134,9 @@ class Experiment(object):
         Whether to use cuda.
     pin_memory: bool, optional
         Whether to pin memory of inputs and targets of batch.
+    do_early_stop: bool
+        Whether to do an early stop at all. If true, reset to best model
+        even in case experiment does not run after early stop.
         
     Attributes
     ----------
@@ -145,10 +148,21 @@ class Experiment(object):
                  monitors, stop_criterion, remember_best_column,
                  run_after_early_stop,
                  model_loss_function=None,
-                 batch_modifier=None, cuda=True, pin_memory=False):
+                 batch_modifier=None, cuda=True, pin_memory=False,
+                 do_early_stop=True):
+        if run_after_early_stop:
+            assert do_early_stop == True, ("Can only run after early stop if "
+            "doing an early stop")
+        if do_early_stop:
+            assert valid_set is not None
+            assert remember_best_column is not None
         self.model = model
         self.datasets = OrderedDict(
             (('train', train_set), ('valid', valid_set), ('test', test_set)))
+        if valid_set is None:
+            self.datasets.pop('valid')
+            assert run_after_early_stop == False
+            assert do_early_stop == False
         self.iterator = iterator
         self.loss_function = loss_function
         self.optimizer = optimizer
@@ -164,6 +178,8 @@ class Experiment(object):
         self.before_stop_df = None
         self.rememberer = None
         self.pin_memory = pin_memory
+        self.do_early_stop = do_early_stop
+
 
     def run(self):
         """
@@ -171,11 +187,12 @@ class Experiment(object):
         """
         self.setup_training()
         log.info("Run until first stop...")
-        self.run_until_early_stop()
-        # always setup for second stop, in order to get best model
-        # even if not running after early stop...
-        log.info("Setup for second stop...")
-        self.setup_after_stop_training()
+        self.run_until_first_stop()
+        if self.do_early_stop:
+            # always setup for second stop, in order to get best model
+            # even if not running after early stop...
+            log.info("Setup for second stop...")
+            self.setup_after_stop_training()
         if self.run_after_early_stop:
             log.info("Run until second stop...")
             self.run_until_second_stop()
@@ -186,19 +203,20 @@ class Experiment(object):
         initialize monitoring.
         """
         # reset remember best extension in case you rerun some experiment
-        self.rememberer = RememberBest(self.remember_best_column)
+        if self.do_early_stop:
+            self.rememberer = RememberBest(self.remember_best_column)
         self.epochs_df = pd.DataFrame()
         set_random_seeds(seed=2382938, cuda=self.cuda)
         if self.cuda:
             assert th.cuda.is_available(), "Cuda not available"
             self.model.cuda()
 
-    def run_until_early_stop(self):
+    def run_until_first_stop(self):
         """
         Run training and evaluation using only training set for training
         until stop criterion is fulfilled.
         """
-        self.run_until_stop(self.datasets, remember_best=True)
+        self.run_until_stop(self.datasets, remember_best=self.do_early_stop)
 
     def run_until_second_stop(self):
         """
@@ -313,14 +331,20 @@ class Experiment(object):
 
         """
         self.model.eval()
-        input_vars = np_to_var(inputs, pin_memory=self.pin_memory)
-        target_vars = np_to_var(targets, pin_memory=self.pin_memory)
+        input_vars = np_to_var(inputs, pin_memory=self.pin_memory,
+                               volatile=True)
+        target_vars = np_to_var(targets, pin_memory=self.pin_memory,
+                                volatile=True)
         if self.cuda:
             input_vars = input_vars.cuda()
             target_vars = target_vars.cuda()
         outputs = self.model(input_vars)
         loss = self.loss_function(outputs, target_vars)
-        outputs = outputs.cpu().data.numpy()
+        if hasattr(outputs, 'cpu'):
+            outputs = outputs.cpu().data.numpy()
+        else:
+            # assume it is iterable
+            outputs = [o.cpu().data.numpy() for o in outputs]
         loss = loss.cpu().data.numpy()
         return outputs, loss
 

{Braindecode-0.3.0 → Braindecode-0.3.2}/braindecode/experiments/monitors.py

@@ -10,10 +10,15 @@ class MisclassMonitor(object):
     ----------
     col_suffix: str, optional
         Name of the column in the monitoring output.
+    threshold_for_binary_case: bool, optional
+        In case of binary classification with only one output prediction
+        per target, define the threshold for separating the classes, i.e.
+        0.5 for sigmoid outputs, or np.log(0.5) for log sigmoid outputs
     """
 
-    def __init__(self, col_suffix='misclass'):
+    def __init__(self, col_suffix='misclass', threshold_for_binary_case=None):
         self.col_suffix = col_suffix
+        self.threshold_for_binary_case = threshold_for_binary_case
 
     def monitor_epoch(self, ):
         return
@@ -28,11 +33,19 @@ class MisclassMonitor(object):
             # or just
             # examples x classes
             # make sure not to remove first dimension if it only has size one
-            only_one_row = preds.shape[0] == 1
-            pred_labels = np.argmax(preds, axis=1).squeeze()
-            # add first dimension again if needed
-            if only_one_row:
-                pred_labels = pred_labels[None]
+            if preds.ndim > 1:
+                only_one_row = preds.shape[0] == 1
+
+                pred_labels = np.argmax(preds, axis=1).squeeze()
+                # add first dimension again if needed
+                if only_one_row:
+                    pred_labels = pred_labels[None]
+            else:
+                assert self.threshold_for_binary_case is not None, (
+                    "In case of only one output, please supply the "
+                    "threshold_for_binary_case parameter")
+                # binary classification case... assume logits
+                pred_labels = np.int32(preds > self.threshold_for_binary_case)
             # now examples x time or examples
             all_pred_labels.extend(pred_labels)
             targets = all_targets[i_batch]

{Braindecode-0.3.0 → Braindecode-0.3.2}/braindecode/models/deep4.py

@@ -65,8 +65,7 @@ class Deep4Net(object):
         later_pool_class = pool_class_dict[self.later_pool_mode]
         model = nn.Sequential()
         if self.split_first_layer:
-            model.add_module('dimshuffle',
-                             Expression(lambda x: x.permute(0, 3, 2, 1)))
+            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),
@@ -131,6 +130,7 @@ class Deep4Net(object):
                             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),
@@ -141,15 +141,7 @@ class Deep4Net(object):
                              nn.Conv2d(self.n_filters_4, self.n_classes,
                                        (self.final_conv_length, 1), bias=True))
         model.add_module('softmax', nn.LogSoftmax())
-        # 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_output(x):
-            assert x.size()[3] == 1
-            x = x[:,:,:,0]
-            if x.size()[2] == 1:
-                x = x[:,:,0]
-            return x
-        model.add_module('squeeze',  Expression(squeeze_output))
+        model.add_module('squeeze',  Expression(_squeeze_final_output))
 
         # Initialization, xavier is same as in our paper...
         # was default from lasagne
@@ -161,6 +153,9 @@ class Deep4Net(object):
             init.xavier_uniform(model.conv_spat.weight, gain=1)
             if not self.batch_norm:
                 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):
             conv_weight = param_dict['conv_{:d}.weight'.format(block_nr)]
@@ -177,4 +172,21 @@ class Deep4Net(object):
         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.3.0 → Braindecode-0.3.2}/braindecode/torch_ext/modules.py

@@ -8,7 +8,7 @@ from braindecode.torch_ext.util import np_to_var
 class Expression(torch.nn.Module):
     """
     Compute given expression on forward pass.
-    
+
     Parameters
     ----------
     expression_fn: function
@@ -37,7 +37,7 @@ class Expression(torch.nn.Module):
 class AvgPool2dWithConv(torch.nn.Module):
     """
     Compute average pooling using a convolution, to have the dilation parameter.
-    
+
     Parameters
     ----------
     kernel_size: (int,int)
@@ -52,7 +52,10 @@ class AvgPool2dWithConv(torch.nn.Module):
         self.kernel_size = kernel_size
         self.stride = stride
         self.dilation = dilation
-        self.weights = None
+        # don't name them "weights" to
+        # make sure these are not accidentally used by some procedure
+        # that initializes parameters or something
+        self._pool_weights = None
 
     def forward(self, x):
         # Create weights for the convolution on demand:
@@ -60,11 +63,11 @@ class AvgPool2dWithConv(torch.nn.Module):
         in_channels = x.size()[1]
         weight_shape = (in_channels, 1,
                         self.kernel_size[0], self.kernel_size[1])
-        if self.weights is None or (
-                (tuple(self.weights.size()) != tuple(weight_shape)) or (
-                  self.weights.is_cuda != x.is_cuda
+        if self._pool_weights is None or (
+                (tuple(self._pool_weights.size()) != tuple(weight_shape)) or (
+                  self._pool_weights.is_cuda != x.is_cuda
                 ) or (
-                    self.weights.data.type() != x.data.type()
+                    self._pool_weights.data.type() != x.data.type()
                 )):
             n_pool = np.prod(self.kernel_size)
             weights = np_to_var(
@@ -72,9 +75,48 @@ class AvgPool2dWithConv(torch.nn.Module):
             weights = weights.type_as(x)
             if x.is_cuda:
                 weights = weights.cuda()
-            self.weights = weights
+            self._pool_weights = weights
 
-        pooled = F.conv2d(x, self.weights, bias=None, stride=self.stride,
+        pooled = F.conv2d(x, self._pool_weights, bias=None, stride=self.stride,
                           dilation=self.dilation,
                           groups=in_channels,)
         return pooled
+
+
+class IntermediateOutputWrapper(torch.nn.Module):
+    """Wraps network model such that outputs of intermediate layers can be returned.
+    forward() returns list of intermediate activations in a network during forward pass.
+
+    Parameters
+    ----------
+    to_select : list
+        list of module names for which activation should be returned
+    model : model object
+        network model
+
+    Examples
+    --------
+    >>> model = Deep4Net()
+    >>> select_modules = ['conv_spat','conv_2','conv_3','conv_4'] # Specify intermediate outputs
+    >>> model_pert = IntermediateOutputWrapper(select_modules,model) # Wrap model
+    """
+    def __init__(self, to_select, model):
+        if not len(list(model.children()))==len(list(model.named_children())):
+            raise Exception('All modules in model need to have names!')
+
+        super(IntermediateOutputWrapper, self).__init__()
+
+        modules_list = model.named_children()
+        for key, module in modules_list:
+            self.add_module(key, module)
+            self._modules[key].load_state_dict(module.state_dict())
+        self._to_select = to_select
+
+    def forward(self,x):
+        # Call modules individually and append activation to output if module is in to_select
+        o = []
+        for name, module in self._modules.items():
+            x = module(x)
+            if name in self._to_select:
+                o.append(x)
+        return o

{Braindecode-0.3.0 → Braindecode-0.3.2}/braindecode/torch_ext/util.py

@@ -12,7 +12,7 @@ def np_to_var(X, requires_grad=False, dtype=None, pin_memory=False, **var_kwargs
     
     Parameters
     ----------
-    X: ndarray or list
+    X: ndarray or list or number
         Input arrays
     requires_grad: bool
         passed on to Variable constructor
@@ -24,6 +24,8 @@ def np_to_var(X, requires_grad=False, dtype=None, pin_memory=False, **var_kwargs
     -------
     var: `torch.autograd.Variable`
     """
+    if not hasattr(X, '__len__'):
+        X = [X]
     X = np.asarray(X)
     if dtype is not None:
         X = X.astype(dtype)
@@ -58,3 +60,17 @@ def set_random_seeds(seed, cuda):
     if cuda:
         th.cuda.manual_seed_all(seed)
     np.random.seed(seed)
+
+
+def confirm_gpu_availability():
+    """
+    Should crash if gpu not available, attempts to create a FloatTensor on GPU.
+    Returns
+    -------
+    success: bool
+        Always returns true, should crash if gpu not available
+    """
+    a = th.FloatTensor(1).cuda()
+    # Just make sure a is not somehow removed by any smart compiling,
+    # probably not necessary.
+    return a is not None

Braindecode-0.3.2/braindecode/version.py

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