braindecode 0.1.7__tar.gz → 0.1.8__tar.gz

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.1.7
+Version: 0.1.8
 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.8}/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
 
@@ -53,7 +53,7 @@ class Deep4Net(object):
         del self.self
 
     def create_network(self):
-        pool_class_dict = dict(max=nn.MaxPool2d, mean=nn.AvgPool2d)
+        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()

Braindecode-0.1.8/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.8}/docs/notebooks/visualization/Perturbation.ipynb

@@ -48,7 +48,9 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "%%capture\n",
@@ -554,7 +556,9 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "mean_corr = np.mean(amp_pred_corrs, axis=0)"
@@ -571,7 +575,9 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "\n",
@@ -720,6 +726,10 @@
   }
  ],
  "metadata": {
+  "celltoolbar": "Edit Metadata",
+  "git": {
+   "keep_outputs": true
+  },
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",

{Braindecode-0.1.7 → Braindecode-0.1.8}/setup.py

@@ -15,7 +15,7 @@ setup(
     # Versions should comply with PEP440.  For a discussion on single-sourcing
     # the version across setup.py and the project code, see
     # http://packaging.python.org/en/latest/tutorial.html#version
-    version='0.1.7', # TODO: read from __init__.py?
+    version='0.1.8', # TODO: read from __init__.py?
 
     description='A deep learning toolbox to decode raw time-domain EEG.',
     long_description=long_description,

Braindecode-0.1.7/braindecode/torch_ext/modules.py

@@ -1,30 +0,0 @@
-import torch
-
-
-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) + ')')