braindecode 0.1.8__tar.gz → 0.2.0__tar.gz

{Braindecode-0.1.8 → Braindecode-0.2.0}/Braindecode.egg-info/PKG-INFO

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

{Braindecode-0.1.8 → Braindecode-0.2.0}/Braindecode.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ Braindecode.egg-info/requires.txt
 Braindecode.egg-info/top_level.txt
 braindecode/__init__.py
 braindecode/util.py
+braindecode/version.py
 braindecode/datasets/__init__.py
 braindecode/datasets/bbci.py
 braindecode/datasets/bcic_iv_2a.py

{Braindecode-0.1.8 → Braindecode-0.2.0}/PKG-INFO

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

Braindecode-0.2.0/braindecode/__init__.py

@@ -0,0 +1 @@
+from braindecode.version import __version__

{Braindecode-0.1.8 → Braindecode-0.2.0}/braindecode/datautil/iterators.py

@@ -218,7 +218,7 @@ class CropsFromTrialsIterator(object):
         for i_blocks in blocks_per_batch:
             start_stop_blocks = i_trial_start_stop_block[i_blocks]
             batch = _create_batch_from_i_trial_start_stop_blocks(
-                X, y, start_stop_blocks)
+                X, y, start_stop_blocks, self.n_preds_per_input)
             yield batch
 
 
@@ -231,7 +231,7 @@ def _compute_start_stop_block_inds(i_trial_starts, i_trial_stops,
     ----------
     i_trial_starts: 1darray/list of int
         Indices of first samples to predict(!).
-    i_trial_stops: 1daray/list of int
+    i_trial_stops: 1darray/list of int
         Indices one past last sample to predict.
     input_time_length: int
     n_preds_per_input: int
@@ -299,12 +299,17 @@ def _get_start_stop_blocks_for_trial(i_trial_start, i_trial_stop,
     return start_stop_blocks
 
 
-def _create_batch_from_i_trial_start_stop_blocks(X, y, i_trial_start_stop_block):
+def _create_batch_from_i_trial_start_stop_blocks(X, y, i_trial_start_stop_block,
+                                                 n_preds_per_input=None):
     Xs = []
     ys = []
     for i_trial, start, stop in i_trial_start_stop_block:
         Xs.append(X[i_trial][:,start:stop])
-        ys.append(y[i_trial])
+        if not hasattr(y[i_trial], '__len__'):
+            ys.append(y[i_trial])
+        else:
+            assert n_preds_per_input is not None
+            ys.append(y[i_trial][stop-n_preds_per_input:stop])
     batch_X = np.array(Xs)
     batch_y = np.array(ys)
     # add empty fourth dimension if necessary

{Braindecode-0.1.8 → Braindecode-0.2.0}/braindecode/datautil/signalproc.py

@@ -17,7 +17,7 @@ def exponential_running_standardize(data, factor_new=0.001,
     :math:`m_t=\mathrm{factornew} \cdot mean(x_t) + (1 - \mathrm{factornew}) \cdot m_{t-1}`.
     
     Then, compute exponential running variance :math:`v_t` at time `t` as 
-    :math:`m_t=\mathrm{factornew} \cdot (m_t - x_t)^2 + (1 - \mathrm{factornew}) \cdot v_{t-1}`.
+    :math:`v_t=\mathrm{factornew} \cdot (m_t - x_t)^2 + (1 - \mathrm{factornew}) \cdot v_{t-1}`.
     
     Finally, standardize the data point :math:`x_t` at time `t` as:
     :math:`x'_t=(x_t - m_t) / max(\sqrt{v_t}, eps)`.
@@ -214,4 +214,3 @@ def filter_is_stable(a):
         "a: {:s}".format(str(a)))
     # from http://stackoverflow.com/a/8812737/1469195
     return np.all(np.abs(np.roots(a))<1)
-

{Braindecode-0.1.8 → Braindecode-0.2.0}/braindecode/datautil/splitters.py

@@ -33,17 +33,22 @@ def concatenate_two_sets(set_a, set_b):
     -------
     concatenated_set: :class:`.SignalAndTarget`
     """
-    if hasattr(set_a.X, 'ndim') and hasattr(set_b.X, 'ndim'):
-        new_X = np.concatenate((set_a.X, set_b.X), axis=0)
-    else:
-        if hasattr(set_a.X, 'ndim'):
-            set_a.X = set_a.X.tolist()
-        if hasattr(set_b.X, 'ndim'):
-            set_b.X = set_b.X.tolist()
-        new_X = set_a.X + set_b.X
-    new_y = np.concatenate((set_a.y, set_b.y), axis=0)
+    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):
     """

{Braindecode-0.1.8 → Braindecode-0.2.0}/braindecode/models/deep4.py

@@ -45,7 +45,8 @@ class Deep4Net(object):
                  double_time_convs=False,
                  split_first_layer=True,
                  batch_norm=True,
-                 batch_norm_alpha=0.1):
+                 batch_norm_alpha=0.1,
+                 stride_before_pool=False):
         if final_conv_length == 'auto':
             assert input_time_length is not None
 
@@ -53,6 +54,12 @@ class Deep4Net(object):
         del self.self
 
     def create_network(self):
+        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]
@@ -66,14 +73,15 @@ class Deep4Net(object):
                                                     stride=1, ))
             model.add_module('conv_spat',
                              nn.Conv2d(self.n_filters_time, self.n_filters_spat,
-                                       (1, self.in_chans), stride=1,
+                                       (1, self.in_chans),
+                                       stride=(conv_stride, 1),
                                        bias=not self.batch_norm))
             n_filters_conv = self.n_filters_spat
         else:
             model.add_module('conv_time',
                              nn.Conv2d(self.in_chans, self.n_filters_time,
                                        (self.filter_time_length, 1),
-                                       stride=1,
+                                       stride=(conv_stride, 1),
                                        bias=not self.batch_norm))
             n_filters_conv = self.n_filters_time
         if self.batch_norm:
@@ -86,7 +94,7 @@ class Deep4Net(object):
         model.add_module('pool',
                          first_pool_class(
                              kernel_size=(self.pool_time_length, 1),
-                             stride=(self.pool_time_stride, 1)))
+                             stride=(pool_stride, 1)))
         model.add_module('pool_nonlin', Expression(self.first_pool_nonlin))
 
         def add_conv_pool_block(model, n_filters_before,
@@ -97,7 +105,8 @@ class Deep4Net(object):
             model.add_module('conv' + suffix.format(block_nr),
                              nn.Conv2d(n_filters_before, n_filters,
                                        (filter_length, 1),
-                                       stride=1, bias=not self.batch_norm))
+                                       stride=(conv_stride, 1),
+                                       bias=not self.batch_norm))
             if self.batch_norm:
                 model.add_module('bnorm' + suffix,
                              nn.BatchNorm2d(n_filters,
@@ -110,7 +119,7 @@ class Deep4Net(object):
             model.add_module('pool' + suffix,
                              later_pool_class(
                                  kernel_size=(self.pool_time_length, 1),
-                                 stride=(self.pool_time_stride, 1)))
+                                 stride=(pool_stride, 1)))
             model.add_module('pool_nonlin' + suffix,
                              Expression(self.later_pool_nonlin))
 

Braindecode-0.2.0/braindecode/torch_ext/losses.py

@@ -0,0 +1,76 @@
+import torch as th
+
+
+def log_categorical_crossentropy_1_hot(logpreds, targets, dims=None):
+    """
+    Returns log categorical crossentropy for given log-predictions and targets,
+    targets should be one-hot-encoded.
+    
+    Computes :math:`-\mathrm{logpreds} \cdot \mathrm{targets}`
+    
+    Parameters
+    ----------
+    logpreds: `torch.autograd.Variable`
+        Logarithm of softmax output.
+    targets: `torch.autograd.Variable`
+        One-hot encoded targets
+    dims: int or iterable of int, optional.
+        Compute sum across these dims
+
+    Returns
+    -------
+    loss: `torch.autograd.Variable`
+        :math:`-\mathrm{logpreds} \cdot \mathrm{targets}`
+    """
+    assert logpreds.size() == targets.size()
+    result = -logpreds * targets
+    # Sum across dims if axis given or more than 1 dim
+    if dims is not None:
+        if not hasattr(dims, '__len__'):
+            dims = [dims]
+        for dim in dims:
+            result = th.sum(result, dim=int(dim))
+    return result
+
+
+def log_categorical_crossentropy(log_preds, targets):
+    """
+    Returns log categorical crossentropy for given log-predictions and targets.
+    
+    Computes :math:`-\mathrm{logpreds} \cdot \mathrm{targets}` if you assume
+    targets to be one-hot-encoded. Also works for targets that are not
+    one-hot-encoded, in this case only uses targets that are in the range
+    of the expected class labels, i.e., [0,log_preds.size()[1]-1].
+
+    Parameters
+    ----------
+    log_preds: torch.autograd.Variable`
+        Logarithm of softmax output.
+    targets: `torch.autograd.Variable`
+
+    Returns
+    -------
+
+    loss: `torch.autograd.Variable`
+    """
+    if log_preds.size() == targets.size():
+        return log_categorical_crossentropy_1_hot(log_preds, targets)
+    n_classes = log_preds.size()[1]
+    n_elements = 0
+    losses = []
+    for i_class in range(n_classes):
+        mask = targets == i_class
+        mask = mask.type_as(log_preds)
+        n_elements -= th.sum(mask)
+        losses.append(th.sum(mask * log_preds[:,i_class]))
+    return th.sum(th.stack(losses)) / n_elements
+
+
+def l2_loss(model):
+    losses = [th.sum(p * p) for p in model.parameters()]
+    return sum(losses)
+
+
+def l1_loss(model):
+    losses = [th.sum(th.abs(p)) for p in model.parameters()]
+    return sum(losses)

{Braindecode-0.1.8 → Braindecode-0.2.0}/braindecode/util.py

@@ -59,6 +59,7 @@ def wrap_reshape_apply_fn(stat_fn, a, b, axis_a, axis_b):
     """
     Reshape two nd-arrays into 2d-arrays, apply function and reshape
     result back.
+
     Parameters
     ----------
     stat_fn: function

Braindecode-0.2.0/braindecode/version.py

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

{Braindecode-0.1.8 → Braindecode-0.2.0}/docs/Makefile

@@ -21,3 +21,13 @@ apidoc:
 # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
 %: Makefile
 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+
+removeipynbcheckpoints: Makefile
+	rm -rf notebooks/.ipynb_checkpoints/ notebooks/visualization/.ipynb_checkpoints/
+
+removesource: Makefile
+	rm -rf source/
+
+rmanddoc: removesource removeipynbcheckpoints apidoc html
+	echo "Done"

{Braindecode-0.1.8 → Braindecode-0.2.0}/docs/conf.py

@@ -21,6 +21,8 @@ import os
 import sys
 sys.path.insert(0, os.path.abspath('.'))
 sys.path.insert(0, os.path.abspath('..'))
+import matplotlib
+matplotlib.use('agg')
 
 
 
@@ -80,8 +82,9 @@ autodoc_member_order = 'bysource'
 ## Default flags used by autodoc directives
 autodoc_default_flags = ['members', 'show-inheritance']
 
-exclude_patterns = ['_build', '_templates',]
- 
+exclude_patterns = ['_build', '_templates']
+
+
 napoleon_google_docstring = False
 napoleon_use_param = False
 napoleon_use_ivar = True
@@ -108,9 +111,10 @@ author = 'Robin Tibor Schirrmeister'
 # built documents.
 #
 # The short X.Y version.
-version = '0.1.6'
+import braindecode
+version = braindecode.__version__
 # The full version, including alpha/beta/rc tags.
-release = '0.1.6'
+release = version
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -209,20 +213,3 @@ texinfo_documents = [
      author, 'Braindecode', 'One line description of project.',
      'Miscellaneous'),
 ]
-
-
-## mock stuff
-"""
-import sys
-from mock import Mock as MagicMock
-#from unittest.mock import MagicMock
-
-class Mock(MagicMock):
-    @classmethod
-    def __getattr__(cls, name):
-            return MagicMock()
-
-MOCK_MODULES = ['torch', 'h5py',]
-sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
-
-"""

{Braindecode-0.1.8 → Braindecode-0.2.0}/docs/index.rst

@@ -3,7 +3,7 @@ Welcome to Braindecode
 
 A deep learning toolbox to decode raw time-domain EEG.
 
-For EEG researchers that want to want to work with deep learning and
+For EEG researchers that want to work with deep learning and
 deep learning researchers that want to work with EEG data.
 For now focussed on convolutional networks.