braindecode 0.1.7__tar.gz → 0.1.9__tar.gz

{Braindecode-0.1.7 → Braindecode-0.1.9}/Braindecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.1.7
+Version: 0.1.9
 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.7 → Braindecode-0.1.9}/PKG-INFO

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

@@ -2,7 +2,7 @@ import numpy as np
 from torch import nn
 from torch.nn import init
 from torch.nn.functional import elu
-from braindecode.torch_ext.modules import Expression
+from braindecode.torch_ext.modules import Expression, AvgPool2dWithConv
 from braindecode.torch_ext.functions import identity
 from braindecode.torch_ext.util import np_to_var
 
@@ -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,7 +54,13 @@ class Deep4Net(object):
         del self.self
 
     def create_network(self):
-        pool_class_dict = dict(max=nn.MaxPool2d, mean=nn.AvgPool2d)
+        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()
@@ -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.1.9/braindecode/torch_ext/modules.py

@@ -0,0 +1,80 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from braindecode.torch_ext.util import np_to_var
+
+
+class Expression(torch.nn.Module):
+    """
+    Compute given expression on forward pass.
+    
+    Parameters
+    ----------
+    expression_fn: function
+        Should accept variable number of objects of type
+        `torch.autograd.Variable` to compute its output.
+    """
+    def __init__(self, expression_fn):
+        super(Expression, self).__init__()
+        self.expression_fn = expression_fn
+
+    def forward(self, *x):
+        return self.expression_fn(*x)
+
+    def __repr__(self):
+        if (hasattr(self.expression_fn, 'func') and
+                  hasattr(self.expression_fn, 'kwargs')):
+                expression_str = "{:s} {:s}".format(
+                    self.expression_fn.func.__name__,
+                    str(self.expression_fn.kwargs))
+        else:
+            expression_str = self.expression_fn.__name__
+        return (self.__class__.__name__ + '(' +
+                'expression=' + str(expression_str) + ')')
+
+
+class AvgPool2dWithConv(torch.nn.Module):
+    """
+    Compute average pooling using a convolution, to have the dilation parameter.
+    
+    Parameters
+    ----------
+    kernel_size: (int,int)
+        Size of the pooling region.
+    stride: (int,int)
+        Stride of the pooling operation.
+    dilation: int or (int,int)
+        Dilation applied to the pooling filter.
+    """
+    def __init__(self, kernel_size, stride, dilation=1):
+        super(AvgPool2dWithConv, self).__init__()
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.dilation = dilation
+        self.weights = None
+
+    def forward(self, x):
+        # Create weights for the convolution on demand:
+        # size or type of x changed...
+        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
+                ) or (
+                    self.weights.data.type() != x.data.type()
+                )):
+            n_pool = np.prod(self.kernel_size)
+            weights = np_to_var(
+                np.ones(weight_shape, dtype=np.float32) / float(n_pool))
+            weights = weights.type_as(x)
+            if x.is_cuda:
+                weights = weights.cuda()
+            self.weights = weights
+
+        pooled = F.conv2d(x, self.weights, bias=None, stride=self.stride,
+                          dilation=self.dilation,
+                          groups=in_channels,)
+        return pooled

{Braindecode-0.1.7 → Braindecode-0.1.9}/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')
 
 
 
@@ -108,9 +110,9 @@ author = 'Robin Tibor Schirrmeister'
 # built documents.
 #
 # The short X.Y version.
-version = '0.1.6'
+version = '0.1.9'
 # The full version, including alpha/beta/rc tags.
-release = '0.1.6'
+release = '0.1.9'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.