braindecode 0.1.0__tar.gz

Braindecode-0.1.0/Braindecode.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 1.1
+Name: Braindecode
+Version: 0.1.0
+Summary: A deep learning for raw time-domain EEG decoding toolbox.
+Home-page: https://github.com/robintibor/braindecode
+Author: Robin Tibor Schirrmeister
+Author-email: robintibor@gmail.com
+License: BSD 3-Clause
+Description: Note: The old braindecode repository has been moved to https://github.com/robintibor/braindevel.
+        
+        # Braindecode
+        A deep learning for raw time-domain EEG decoding toolbox.
+        
+Keywords: eeg deep-learning brain-state-decoding
+Platform: UNKNOWN
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.5

Braindecode-0.1.0/Braindecode.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+setup.py
+Braindecode.egg-info/PKG-INFO
+Braindecode.egg-info/SOURCES.txt
+Braindecode.egg-info/dependency_links.txt
+Braindecode.egg-info/requires.txt
+Braindecode.egg-info/top_level.txt
+braindecode/__init__.py
+braindecode/iterators.py
+braindecode/splitters.py
+braindecode/trial_segment.py
+braindecode/util.py

Braindecode-0.1.0/Braindecode.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

Braindecode-0.1.0/Braindecode.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+mne

Braindecode-0.1.0/Braindecode.egg-info/top_level.txt

@@ -0,0 +1 @@
+braindecode

Braindecode-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 1.1
+Name: Braindecode
+Version: 0.1.0
+Summary: A deep learning for raw time-domain EEG decoding toolbox.
+Home-page: https://github.com/robintibor/braindecode
+Author: Robin Tibor Schirrmeister
+Author-email: robintibor@gmail.com
+License: BSD 3-Clause
+Description: Note: The old braindecode repository has been moved to https://github.com/robintibor/braindevel.
+        
+        # Braindecode
+        A deep learning for raw time-domain EEG decoding toolbox.
+        
+Keywords: eeg deep-learning brain-state-decoding
+Platform: UNKNOWN
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.5

Braindecode-0.1.0/braindecode/iterators.py

@@ -0,0 +1,216 @@
+import numpy as np
+from numpy.random import RandomState
+
+
+def get_balanced_batches(n_trials, rng, shuffle, n_batches=None,
+                         batch_size=None):
+    """Create indices for batches balanced in size (batches will have maximum size difference of 1).
+    Supply either batch size or number of batches. Resulting batches
+    will not have the given batch size but rather the next largest batch size
+    that allows to split the set into balanced batches (maximum size difference 1).
+
+    Parameters
+    ----------
+    n_trials : int
+        Size of set.
+    rng :
+
+    shuffle :
+        Whether to shuffle indices before splitting set.
+    n_batches :
+         (Default value = None)
+    batch_size :
+         (Default value = None)
+
+    Returns
+    -------
+
+    """
+    assert batch_size is not None or n_batches is not None
+    if n_batches is None:
+        n_batches = int(np.round(n_trials / float(batch_size)))
+
+    if n_batches > 0:
+        min_batch_size = n_trials // n_batches
+        n_batches_with_extra_trial = n_trials % n_batches
+    else:
+        n_batches = 1
+        min_batch_size = n_trials
+        n_batches_with_extra_trial = 0
+    assert n_batches_with_extra_trial < n_batches
+    all_inds = np.array(range(n_trials))
+    if shuffle:
+        rng.shuffle(all_inds)
+    i_start_trial = 0
+    i_stop_trial = 0
+    batches = []
+    for i_batch in range(n_batches):
+        i_stop_trial += min_batch_size
+        if i_batch < n_batches_with_extra_trial:
+            i_stop_trial += 1
+        batch_inds = all_inds[range(i_start_trial, i_stop_trial)]
+        batches.append(batch_inds)
+        i_start_trial = i_stop_trial
+    assert i_start_trial == n_trials
+    return batches
+
+
+class BalancedBatchSizeIterator(object):
+    """
+    Create batches of balanced size.
+    
+    Parameters
+    ----------
+    batch_size: int
+        Resulting batches will not necessarily have the given batch size
+        but rather the next largest batch size that allows to split the set into
+        balanced batches (maximum size difference 1).
+    """
+    def __init__(self, batch_size):
+        self.batch_size = batch_size
+        self.rng = RandomState(328774)
+
+    def get_batches(self, dataset, shuffle):
+        n_trials = dataset.X.shape[0]
+        batches = get_balanced_batches(n_trials,
+                                       batch_size=self.batch_size,
+                                       rng=self.rng,
+                                       shuffle=shuffle)
+        for batch_inds in batches:
+            yield (dataset.X[batch_inds], dataset.y[batch_inds])
+
+    def reset_rng(self):
+        self.rng = RandomState(328774)
+
+
+class CropsFromTrialsIterator(object):
+    def __init__(self, batch_size, input_time_length, n_preds_per_input,
+                 check_preds_smaller_trial_len=True):
+        # TODO: remove this check preds smaller trila len and check that
+        # trials are smaller than input length
+        """
+
+        Parameters
+        ----------
+        batch_size: int
+        input_time_length: int
+            Input time length of the ConvNet, determines size of batches in
+            3rd dimension.
+        n_preds_per_input: int
+            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.
+        """
+        self.batch_size = batch_size
+        self.input_time_length = input_time_length
+        self.n_preds_per_input = n_preds_per_input
+        self.check_preds_smaller_trial_len = check_preds_smaller_trial_len
+        self.rng = RandomState((2017, 6, 28))
+
+    def reset_rng(self):
+        self.rng = RandomState((2017, 6, 28))
+
+    def get_batches(self, dataset, shuffle):
+        # start always at first predictable sample, so
+        # start at end of receptive field
+        n_receptive_field = self.input_time_length - self.n_preds_per_input + 1
+        i_trial_starts = [n_receptive_field - 1] * len(dataset.X)
+        i_trial_stops = [trial.shape[1] for trial in dataset.X]
+
+        if self.check_preds_smaller_trial_len:
+            check_trial_bounds(i_trial_starts, i_trial_stops,
+                               self.n_preds_per_input)
+        start_stop_blocks_per_trial = compute_start_stop_block_inds(
+            i_trial_starts, i_trial_stops, self.input_time_length,
+            self.n_preds_per_input, self.check_preds_smaller_trial_len)
+        for i_trial, trial_blocks in enumerate(start_stop_blocks_per_trial):
+            assert trial_blocks[0][0] == 0
+            assert trial_blocks[-1][1] == i_trial_stops[i_trial]
+
+        return self.yield_block_batches(dataset.X, dataset.y,
+                                        start_stop_blocks_per_trial,
+                                        shuffle=shuffle)
+
+    def yield_block_batches(self, X, y, start_stop_blocks_per_trial, shuffle):
+        # add trial nr to start stop blocks and flatten at same time
+        i_trial_start_stop_block = [(i_trial, start, stop)
+                                      for i_trial, block in
+                                          enumerate(start_stop_blocks_per_trial)
+                                      for (start, stop) in block]
+        if shuffle:
+            self.rng.shuffle(i_trial_start_stop_block)
+
+        for i_block in range(0, len(i_trial_start_stop_block), self.batch_size):
+            i_block_stop = min(i_block + self.batch_size,
+                               len(i_trial_start_stop_block))
+            start_stop_blocks = i_trial_start_stop_block[i_block:i_block_stop]
+            batch = create_batch_from_i_trial_start_stop_blocks(
+                X, y, start_stop_blocks, self.n_preds_per_input)
+            yield batch
+
+
+def check_trial_bounds(i_trial_starts, i_trial_stops, n_preds_per_input):
+    for start, stop in zip(i_trial_starts, i_trial_stops):
+        assert stop - start >= n_preds_per_input, (
+            "Trial should be longer or equal than number of sample preds, "
+            "Trial length: {:d}, sample preds {:d}...".
+                format(stop - start, n_preds_per_input))
+
+
+def compute_start_stop_block_inds(i_trial_starts, i_trial_stops,
+                                 input_time_length, n_preds_per_input,
+                                 check_preds_smaller_trial_len):
+    # create start stop indices for all batches still 2d trial -> start stop
+    start_stop_blocks_per_trial = []
+    for i_trial in range(len(i_trial_starts)):
+        trial_start = i_trial_starts[i_trial]
+        trial_stop = i_trial_stops[i_trial]
+        start_stop_blocks = get_start_stop_blocks_for_trial(
+            trial_start, trial_stop, input_time_length,
+            n_preds_per_input)
+
+        if check_preds_smaller_trial_len:
+            # check that block is correct, all predicted samples together
+            # should be the trial samples
+            all_predicted_samples = [
+                range(stop - n_preds_per_input,
+                      stop) for _,stop in start_stop_blocks]
+            # this check takes about 50 ms in performance test
+            # whereas loop itself takes only 5 ms.. deactivate it if not necessary
+            assert np.array_equal(
+                range(i_trial_starts[i_trial], i_trial_stops[i_trial]),
+                np.unique(np.concatenate(all_predicted_samples)))
+
+        start_stop_blocks_per_trial.append(start_stop_blocks)
+    return start_stop_blocks_per_trial
+
+
+def get_start_stop_blocks_for_trial(trial_start, trial_stop, input_time_length,
+                                   n_preds_per_input):
+    start_stop_blocks = []
+    i_window_stop = trial_start  # now when we add sample preds in loop,
+    # first sample of trial corresponds to first prediction
+    while i_window_stop < trial_stop:
+        i_window_stop += n_preds_per_input
+        i_adjusted_stop = min(i_window_stop, trial_stop)
+        i_window_start = i_adjusted_stop - input_time_length
+        start_stop_blocks.append((i_window_start, i_adjusted_stop))
+
+    return start_stop_blocks
+
+
+def create_batch_from_i_trial_start_stop_blocks(X, y, i_trial_start_stop_block,
+                                               n_preds_per_input):
+    Xs = []
+    ys = []
+    for i_trial, start, stop in i_trial_start_stop_block:
+        Xs.append(X[i_trial][:,start:stop])
+        # one-hot-encode targets
+        #block_y = np.zeros((n_classes, n_preds_per_input), dtype=np.float32)
+        #block_y[y[i_trial]] = 1
+        #block_y = np.ones((n_preds_per_input), dtype=np.int64) * y[i_trial]
+        #ys.append(block_y)
+        ys.append(y[i_trial])
+    batch_X = np.array(Xs)
+    batch_y = np.array(ys)
+    return batch_X, batch_y

Braindecode-0.1.0/braindecode/splitters.py

@@ -0,0 +1,18 @@
+import numpy as np
+
+from braindecode.datasets.signal_target import apply_to_X_y
+
+
+def concatenate_sets(set_a, set_b):
+    return apply_to_X_y(lambda a,b: np.concatenate((a,b), axis=0),
+                        set_a, set_b)
+
+
+def split_into_two_sets(dataset, first_set_fraction=None, n_boundary=None):
+    assert (first_set_fraction is None) != (n_boundary is None), (
+        "Supply either first_set_fraction or n_boundary")
+    if n_boundary is None:
+        n_boundary = int(round(len(dataset.X) * first_set_fraction))
+    first_set = apply_to_X_y(lambda a: a[:n_boundary], dataset)
+    second_set = apply_to_X_y(lambda a: a[n_boundary:], dataset)
+    return first_set, second_set

Braindecode-0.1.0/braindecode/trial_segment.py

@@ -0,0 +1,198 @@
+import logging
+import numpy as np
+import xarray as xr
+
+log = logging.getLogger(__name__)
+
+
+def create_target_series(cnt, marker_def, ival):
+    """
+    Compute one-hot encoded target series.
+    Parameters
+    ----------
+    cnt : DateArray
+    marker_def: OrderedDict (str -> list int)
+        Dictionary mapping class names -> list of marker codes. Order of keys
+         is used to determine indices of classes in one-hot encoded result. 
+    ival : (number, number) tuple
+        Segmentation interval for each trial.
+    Returns
+    -------
+    2darray
+        One-hot encoded target series.
+
+    """
+    assert 'fs' in cnt.attrs
+    assert 'events' in cnt.attrs
+    assert ival[0] < ival[1]
+    sample_ival = cnt.attrs['fs'] * np.array(ival) / 1000.0
+    sample_ival = np.int32(np.round(sample_ival))
+    assert sample_ival[0] < sample_ival[1]
+
+
+    class_names = marker_def.keys()
+    targets = np.zeros((len(cnt.data), len(class_names)), dtype=np.int32)
+    for i_sample, m in cnt.attrs['events']:
+        for class_idx, classname in enumerate(class_names):
+            if m in marker_def[classname]:
+                start_index = i_sample + sample_ival[0]
+                stop_index = i_sample + sample_ival[1]
+                assert stop_index > start_index
+                if start_index >= 0 and stop_index <= len(cnt.coords['time']):
+                    targets[start_index:stop_index, class_idx] = 1
+                elif start_index < 0:
+                    log.warn("Ignoring trial, start index < 0: {:d}".format(
+                        start_index))
+                else:
+                    assert stop_index > len(cnt.coords['time'])
+                    log.warn("Ignoring trial, start index > n_samples:"
+                        "{:d} > {:d} ".format(
+                        stop_index, len(cnt.coords['time'])))
+    return targets
+
+
+def compute_trial_start_stop_samples(y, check_trial_lengths_equal=True,
+                                    input_time_length=None):
+    """Computes trial start and end samples (end is inclusive) from
+    one-hot encoded y-matrix.
+    Specify input time length to kick out trials that are too short after
+    signal start.
+
+    Parameters
+    ----------
+    y : 2darray
+    check_trial_lengths_equal : bool
+         (Default value = True)
+    input_time_length : int, optional
+         (Default value = None)
+
+    Returns
+    -------
+
+    """
+    #TODO: change to start stop
+    trial_part = np.sum(y, 1) == 1
+    boundaries = np.diff(trial_part.astype(np.int32))
+    i_trial_starts = np.flatnonzero(boundaries == 1) + 1
+    i_trial_stops = np.flatnonzero(boundaries == -1) + 1
+    # it can happen that a trial is only partially there since the
+    # cnt signal was split in the middle of a trial
+    # for now just remove these
+    # use that start marker should always be before or equal to end marker
+    if i_trial_starts[0] >= i_trial_stops[0]:
+        # cut out first trial which only has end marker
+        i_trial_stops = i_trial_stops[1:]
+    if i_trial_starts[-1] >= i_trial_stops[-1]:
+        # cut out last trial which only has start marker
+        i_trial_starts = i_trial_starts[:-1]
+
+    assert (len(i_trial_starts) == len(i_trial_stops))
+    assert (np.all(i_trial_starts < i_trial_stops))
+    # possibly remove first trials if they are too early
+    if input_time_length is not None:
+        while i_trial_starts[0] < (input_time_length - 1):
+            i_trial_starts = i_trial_starts[1:]
+            i_trial_stops = i_trial_stops[1:]
+    if check_trial_lengths_equal:
+        # just checking that all trial lengths are equal
+        all_trial_lens = np.array(i_trial_stops) - np.array(i_trial_starts)
+        assert all(all_trial_lens == all_trial_lens[0]), (
+            "All trial lengths should be equal...")
+    return i_trial_starts, i_trial_stops
+
+
+def segment_dat(cnt, marker_def, ival):
+    """Convert a continuous data object to an epoched one.
+
+    Given a continuous data object, a definition of classes, and an
+    interval, this method looks for markers as defined in ``marker_def``
+    and slices the dat according to the time interval given with
+    ``ival`` along the ``timeaxis``. The returned ``dat`` object stores
+    those slices and the class each slice belongs to.
+
+    Epochs that are too close to the borders and thus too short are
+    ignored.
+
+    If the segmentation does not result in any epochs (i.e. the markers
+    in ``marker_def`` could not be found in ``dat``, the resulting
+    epo.data will be an empty array.
+
+    This method is also suitable for **online processing**, please read
+    the documentation for the ``newsamples`` parameter and have a look
+    at the Examples below.
+
+    Parameters
+    ----------
+    dat : Data
+        the data object to be segmented
+    marker_def : dict
+        The keys are class names, the values are lists of markers
+    ival : [int, int]
+        The interval in milliseconds to cut around the markers. I.e. to
+        get the interval starting with the marker plus the remaining
+        100ms define the interval like [0, 100]. The start point is
+        included, the endpoint is not (like: ``[start, end)``).  To get
+        200ms before the marker until 100ms after the marker do:
+        ``[-200, 100]`` Only negative or positive values are possible
+        (i.e. ``[-500, -100]``)
+
+    Returns
+    -------
+    epo : Data
+        a copy of the resulting epoched data.
+
+    Raises
+    ------
+    AssertionError
+        * if ``dat`` has not ``.fs`` or ``.markers`` attribute or if
+          ``ival[0] > ival[1]``.
+
+    Examples
+    --------
+
+    Offline Experiment
+
+    >>> # Define the markers belonging to class 1 and 2
+    >>> md = {'class 1': ['S1', 'S2'],
+    ...       'class 2': ['S3', 'S4']
+    ...      }
+    >>> # Epoch the data -500ms and +700ms around the markers defined in
+    >>> # md
+    >>> epo = segment_dat(cnt, md, [-500, 700])
+
+    """
+
+    assert 'fs' in cnt.attrs
+    assert 'events' in cnt.attrs
+    y = create_target_series(cnt, marker_def, ival=ival)
+    # Create classes per trial
+    # and sample inds per trial from the target series
+    starts, stops = compute_trial_start_stop_samples(y)
+    classes = [np.argmax(y[i_s]) for i_s in starts]
+    sample_inds_per_trial = [list(range(i_start, i_stop))
+                             for (i_start, i_stop) in zip(starts, stops)]
+
+    if len(sample_inds_per_trial) == 0:
+        assert "No epochs not tested yet"
+        data = np.array([])
+    else:
+        timeaxis = list(cnt.dims).index('time')
+        # np.take inserts a new dimension at `axis`...
+        data = cnt.data.take(sample_inds_per_trial, axis=timeaxis)
+        # we want that new dimension at axis 0 so we have to swap it.
+        # before that we have to convert the negative axis indices to
+        # their equivalent positive one, otherwise swapaxis will be one
+        # off.
+        data = data.swapaxes(0, timeaxis)
+    time = np.linspace(ival[0], ival[1],
+                       data.shape[1], # assume timeaxis now on 1
+                       endpoint=False)
+    epo = xr.DataArray(data,
+                       coords={'trials': classes, 'time': time,
+                               'channels': cnt.channels,},
+                       dims=('trials', 'time','channels',))
+    epo.attrs = cnt.attrs.copy()
+    # remove events part
+    epo.attrs.pop('events')
+    return epo
+

Braindecode-0.1.0/braindecode/util.py

@@ -0,0 +1,156 @@
+import os
+import errno
+import numpy as np
+from copy import deepcopy
+
+
+def deepcopy_xarr(xarr):
+    """
+    Deepcopy for xarray that makes sure coords and attrs
+    are properly deepcopied.
+    With normal copy method from xarray, when i mutated
+    xarr.coords[coord].data it would also mutate in the copy
+    and vice versa.
+    Parameters
+    ----------
+    xarr: DateArray
+
+    Returns
+    -------
+    xcopy: DateArray
+        Deep copy of xarr
+    """
+    xcopy = xarr.copy(deep=True)
+
+    for dim in xcopy.coords:
+        xcopy.coords[dim].data = np.copy(xcopy.coords[dim].data)
+    xcopy.attrs = deepcopy(xcopy.attrs)
+    for attr in xcopy.attrs:
+        xcopy.attrs[attr] = deepcopy(xcopy.attrs[attr])
+    return xcopy
+
+
+class FuncAndArgs(object):
+    """Container for a function and its arguments. 
+    Useful in case you want to pass a function and its arguments 
+    to another function without creating a new class.
+    You can call the new instance either with the apply method or 
+    the ()-call operator:
+    
+    >>> FuncAndArgs(max, 2,3).apply(4)
+    4
+    >>> FuncAndArgs(max, 2,3)(4)
+    4
+    >>> FuncAndArgs(sum, [3,4])(8)
+    15
+    
+    """
+    def __init__(self, func, *args, **kwargs):
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        
+    
+    def apply(self, *other_args, **other_kwargs):
+        all_args = self.args + other_args
+        all_kwargs = self.kwargs.copy()
+        all_kwargs.update(other_kwargs)
+        return self.func(*all_args, **all_kwargs)
+        
+    def __call__(self, *other_args, **other_kwargs):
+        return self.apply(*other_args, **other_kwargs)
+    
+    
+class GetAttr(object):
+    """ Hacky class for yaml to return attr of something.
+    Uses new to actually return completely different object... """
+    def __new__(cls, obj, attr):
+        return getattr(obj, attr) 
+
+class ApplyFunc(object):
+    """ Hacky class to wrap function call in object for yaml loading... """
+    def __new__(cls, func,args, kwargs):
+        return func(*args, **kwargs)
+
+def add_message_to_exception(exc, additional_message):
+    #  give some more info...
+    # see http://www.ianbicking.org/blog/2007/09/re-raising-exceptions.html
+    args = exc.args
+    if not args:
+        arg0 = ''
+    else:
+                    
+        arg0 = args[0]
+    arg0 += additional_message
+    exc.args = (arg0, ) + args[1:]
+    
+def unzip(l):
+    return zip(*l)
+
+def dict_compare(d1, d2):
+    """From http://stackoverflow.com/a/18860653/1469195"""
+    d1_keys = set(d1.keys())
+    d2_keys = set(d2.keys())
+    intersect_keys = d1_keys.intersection(d2_keys)
+    added = d1_keys - d2_keys
+    removed = d2_keys - d1_keys
+    modified = {o : (d1[o], d2[o]) for o in intersect_keys if d1[o] != d2[o]}
+    same = set(o for o in intersect_keys if d1[o] == d2[o])
+    return added, removed, modified, same
+
+def dict_equal(d1,d2):
+    d1_keys = set(d1.keys())
+    d2_keys = set(d2.keys())
+    intersect_keys = d1_keys.intersection(d2_keys)
+    modified = {o : (d1[o], d2[o]) for o in intersect_keys if d1[o] != d2[o]}
+    return (intersect_keys == d2_keys and intersect_keys == d1_keys and
+        len(modified) == 0)
+    
+def dict_is_subset(d1,d2):
+    added, removed, modified, same = dict_compare(d1, d2)
+    return (len(added) == 0 and len(modified) == 0)
+    
+def merge_dicts(*dict_args):
+    '''
+    Given any number of dicts, shallow copy and merge into a new dict,
+    precedence goes to key value pairs in latter dicts.
+    http://stackoverflow.com/a/26853961
+    '''
+    result = {}
+    for dictionary in dict_args:
+        result.update(dictionary)
+    return result
+
+def touch_file(path):
+    # from http://stackoverflow.com/a/12654798/1469195
+    basedir = os.path.dirname(path)
+    if not os.path.exists(basedir):
+        os.makedirs(basedir)
+    with open(path, 'a'):
+        os.utime(path, None)
+
+
+def to_tuple(sequence_or_element, length=None):
+    if hasattr(sequence_or_element, '__len__'):
+        assert length is None
+        return tuple(sequence_or_element)
+    else:
+        if length is None:
+            return (sequence_or_element, )
+        else:
+            return (sequence_or_element,) * length
+    
+
+def mkdir_p(path):
+    try:
+        os.makedirs(path)
+    except OSError as exc:  # Python >2.5
+        if exc.errno == errno.EEXIST and os.path.isdir(path):
+            pass
+        else:
+            raise
+        
+def select_inverse_inds(arr, inds):
+    mask = np.ones(len(arr),dtype=bool)
+    mask[inds] = False
+    return arr[mask]

Braindecode-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

Braindecode-0.1.0/setup.py

@@ -0,0 +1,62 @@
+from setuptools import setup, find_packages  # Always prefer setuptools over distutils
+from codecs import open  # To use a consistent encoding
+from os import path
+
+here = path.abspath(path.dirname(__file__))
+
+# README.md is used as the long description by default
+# Get the long description from the relevant file
+with open(path.join(here, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+
+setup(
+    name='Braindecode',
+
+    # 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.0',
+
+    description='A deep learning for raw time-domain EEG decoding toolbox.',
+    long_description=long_description,  #this is the
+
+    # The project's main homepage.
+    url='https://github.com/robintibor/braindecode',
+
+    # Author details
+    author='Robin Tibor Schirrmeister',
+    author_email='robintibor@gmail.com',
+
+    # Choose your license
+    license='BSD 3-Clause',
+
+    install_requires=['numpy','mne'],
+    #tests_require = [...]
+
+    # See https://PyPI.python.org/PyPI?%3Aaction=list_classifiers
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+
+        # Indicate who your project is intended for
+        "Intended Audience :: Developers",
+        "Intended Audience :: Science/Research",
+        'Topic :: Software Development :: Build Tools',
+
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+
+        # Pick your license as you wish (should match "license" above)
+        'License :: OSI Approved :: BSD License',
+
+        # Specify the Python versions you support here. In particular, ensure
+        # that you indicate whether you support Python 2, Python 3 or both.
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3.5',
+    ],
+
+    # What does your project relate to?
+    keywords='eeg deep-learning brain-state-decoding',
+
+    packages=['braindecode'],
+
+)