braindecode 0.1.4__tar.gz → 0.1.4.2__tar.gz

{Braindecode-0.1.4 → Braindecode-0.1.4.2}/Braindecode.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.1.4
-Summary: A deep learning for raw time-domain EEG decoding toolbox.
+Version: 0.1.4.2
+Summary: A deep learning toolbox to decode raw time-domain EEG.
 Home-page: https://github.com/robintibor/braindecode
 Author: Robin Tibor Schirrmeister
 Author-email: robintibor@gmail.com

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

@@ -0,0 +1,53 @@
+LICENSE.txt
+MANIFEST.in
+README.rst
+setup.py
+Braindecode.egg-info/PKG-INFO
+Braindecode.egg-info/SOURCES.txt
+Braindecode.egg-info/dependency_links.txt
+Braindecode.egg-info/not-zip-safe
+Braindecode.egg-info/requires.txt
+Braindecode.egg-info/top_level.txt
+braindecode/__init__.py
+braindecode/util.py
+braindecode/datasets/__init__.py
+braindecode/datasets/bbci.py
+braindecode/datasets/multiple.py
+braindecode/datautil/__init__.py
+braindecode/datautil/iterators.py
+braindecode/datautil/signal_target.py
+braindecode/datautil/signalproc.py
+braindecode/datautil/splitters.py
+braindecode/datautil/trial_segment.py
+braindecode/datautil/util.py
+braindecode/experiments/__init__.py
+braindecode/experiments/experiment.py
+braindecode/experiments/monitors.py
+braindecode/experiments/stopcriteria.py
+braindecode/mne_ext/__init__.py
+braindecode/mne_ext/signalproc.py
+braindecode/models/__init__.py
+braindecode/models/deep4.py
+braindecode/models/shallow_fbcsp.py
+braindecode/torch_ext/__init__.py
+braindecode/torch_ext/constraints.py
+braindecode/torch_ext/functions.py
+braindecode/torch_ext/losses.py
+braindecode/torch_ext/modules.py
+braindecode/torch_ext/util.py
+docs/Makefile
+docs/conf.py
+docs/index.rst
+docs/notebooks/BBCI_Data.ipynb
+docs/notebooks/BBCI_Data_Start_Stop.ipynb
+docs/notebooks/Cropped_Decoding.ipynb
+docs/notebooks/Experiment_Class.ipynb
+docs/notebooks/TrialWise_Decoding.ipynb
+docs/source/braindecode.datasets.rst
+docs/source/braindecode.datautil.rst
+docs/source/braindecode.experiments.rst
+docs/source/braindecode.mne_ext.rst
+docs/source/braindecode.models.rst
+docs/source/braindecode.rst
+docs/source/braindecode.torch_ext.rst
+docs/source/modules.rst

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

@@ -0,0 +1,6 @@
+numpy
+mne
+torch
+h5py
+pandas
+resampy

{Braindecode-0.1.4 → Braindecode-0.1.4.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 1.1
 Name: Braindecode
-Version: 0.1.4
-Summary: A deep learning for raw time-domain EEG decoding toolbox.
+Version: 0.1.4.2
+Summary: A deep learning toolbox to decode raw time-domain EEG.
 Home-page: https://github.com/robintibor/braindecode
 Author: Robin Tibor Schirrmeister
 Author-email: robintibor@gmail.com

Braindecode-0.1.4.2/braindecode/datasets/bbci.py

@@ -0,0 +1,337 @@
+import logging
+import re
+from glob import glob
+import os.path
+
+import numpy as np
+import h5py
+import mne
+
+log = logging.getLogger(__name__)
+
+
+class BBCIDataset(object):
+    def __init__(self, filename, load_sensor_names=None, check_class_names=False):
+        self.__dict__.update(locals())
+        del self.self
+
+    def load(self):
+        cnt = self.load_continuous_signal()
+        cnt = self.add_markers(cnt)
+        return cnt
+
+    def load_continuous_signal(self):
+        wanted_chan_inds, wanted_sensor_names = self.determine_sensors()
+        fs = self.determine_samplingrate()
+        with h5py.File(self.filename, 'r') as h5file:
+            samples = int(h5file['nfo']['T'][0, 0])
+            cnt_signal_shape = (samples, len(wanted_chan_inds))
+            continuous_signal = np.ones(cnt_signal_shape,
+                                        dtype=np.float32) * np.nan
+            for chan_ind_arr, chan_ind_set in enumerate(wanted_chan_inds):
+                # + 1 because matlab/this hdf5-naming logic
+                # has 1-based indexing
+                # i.e ch1,ch2,....
+                chan_set_name = 'ch' + str(chan_ind_set + 1)
+                # first 0 to unpack into vector, before it is 1xN matrix
+                chan_signal = h5file[chan_set_name][
+                              :].squeeze()  # already load into memory
+                continuous_signal[:, chan_ind_arr] = chan_signal
+            assert not np.any(
+                np.isnan(continuous_signal)), "No NaNs expected in signal"
+
+        # Assume we cant know channel type here automatically
+        ch_types = ['misc'] * len(wanted_chan_inds)
+        info = mne.create_info(ch_names=wanted_sensor_names, sfreq=fs,
+                               ch_types=ch_types)
+
+        cnt = mne.io.RawArray(continuous_signal.T, info)
+        return cnt
+
+    def determine_sensors(self):
+        all_sensor_names = self.get_all_sensors(self.filename, pattern=None)
+        if self.load_sensor_names is None:
+
+            # if no sensor names given, take all EEG-chans
+            eeg_sensor_names = all_sensor_names
+            eeg_sensor_names = filter(lambda s: not s.startswith('BIP'),
+                                      eeg_sensor_names)
+            eeg_sensor_names = filter(lambda s: not s.startswith('E'),
+                                      eeg_sensor_names)
+            eeg_sensor_names = filter(lambda s: not s.startswith('Microphone'),
+                                      eeg_sensor_names)
+            eeg_sensor_names = filter(lambda s: not s.startswith('Breath'),
+                                      eeg_sensor_names)
+            eeg_sensor_names = filter(lambda s: not s.startswith('GSR'),
+                                      eeg_sensor_names)
+            eeg_sensor_names = list(eeg_sensor_names)
+            assert (len(eeg_sensor_names) == 128 or
+                    len(eeg_sensor_names) == 64 or
+                    len(eeg_sensor_names) == 32 or
+                    len(eeg_sensor_names) == 16), (
+                "Recheck this code if you have different sensors...")
+            self.load_sensor_names = eeg_sensor_names
+        chan_inds = self.determine_chan_inds(all_sensor_names,
+                                             self.load_sensor_names)
+        return chan_inds, self.load_sensor_names
+
+    def determine_samplingrate(self):
+        with h5py.File(self.filename, 'r') as h5file:
+            fs = h5file['dat']['fs'][0, 0]
+            assert isinstance(fs, int) or fs.is_integer()
+            fs = int(fs)
+        return fs
+
+    @staticmethod
+    def determine_chan_inds(all_sensor_names, sensor_names):
+        assert sensor_names is not None
+        chan_inds = [all_sensor_names.index(s) for s in sensor_names]
+        assert len(chan_inds) == len(sensor_names), ("All"
+                                                     "sensors should be there.")
+        assert len(set(chan_inds)) == len(chan_inds), ("No"
+                                                       "duplicated sensors wanted.")
+        return chan_inds
+
+    @staticmethod
+    def get_all_sensors(filename, pattern=None):
+        with h5py.File(filename, 'r') as h5file:
+            clab_set = h5file['dat']['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:
+                all_sensor_names = filter(
+                    lambda sname: re.search(pattern, sname),
+                    all_sensor_names)
+        return all_sensor_names
+
+    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()
+
+            # Check whether class names known and correct order
+            class_name_set = h5file['nfo']['className'][:].squeeze()
+            all_class_names = [''.join(chr(c) for c in h5file[obj_ref])
+                               for obj_ref in class_name_set]
+
+            if self.check_class_names:
+                check_class_names(
+                    all_class_names, event_times_in_ms, event_classes,)
+
+        event_times_in_samples = event_times_in_ms * cnt.info['sfreq'] / 1000.0
+        event_times_in_samples = np.uint32(np.round(event_times_in_samples))
+
+        # Check if there are markers at the same time
+        previous_i_sample = -1
+        for i_event, (i_sample, id_class) in enumerate(
+                zip(event_times_in_samples, event_classes)):
+            if i_sample == previous_i_sample:
+                log.warning("Same sample has at least two markers.\n"
+                            "{:d}: ({:d} and {:d}).\n".format(i_sample,
+                                                              event_classes[
+                                                                  i_event - 1],
+                                                              event_classes[
+                                                                  i_event]) +
+                            "Marker codes will be summed.")
+            previous_i_sample = i_sample
+
+        # Now create stim chan
+        stim_chan = np.zeros_like(cnt.get_data()[0])
+        for i_sample, id_class in zip(event_times_in_samples, event_classes):
+            stim_chan[i_sample] += id_class
+        info = mne.create_info(ch_names=['STI 014'],
+                               sfreq=cnt.info['sfreq'],
+                               ch_types=['stim'])
+        stim_cnt = mne.io.RawArray(stim_chan[None], info, verbose='WARNING')
+        cnt = cnt.add_channels([stim_cnt])
+        event_arr = [event_times_in_samples,
+                     [0] * len(event_times_in_samples),
+                     event_classes]
+        cnt.info['events'] = np.array(event_arr).T
+        return cnt
+
+
+def check_class_names(all_class_names, event_times_in_ms, event_classes,):
+    if all_class_names == ['Right Hand', 'Left Hand', 'Rest', 'Feet']:
+        pass
+    elif ((all_class_names == ['1', '10', '11', '111', '12', '13',
+                               '150',
+                               '2', '20', '22', '3', '30', '33', '4',
+                               '40', '44', '99']) or
+              (all_class_names == ['1', '10', '11', '12', '13', '150',
+                                   '2', '20', '22', '3', '30', '33',
+                                   '4', '40', '44', '99']) or
+              (all_class_names == ['1', '2', '3', '4'])):
+        pass  # Semantic classes
+    elif all_class_names == ['Rest', 'Feet', 'Left Hand', 'Right Hand']:
+        # Have to swap from
+        # ['Rest', 'Feet', 'Left Hand', 'Right Hand']
+        # to
+        # ['Right Hand', 'Left Hand', 'Rest', 'Feet']
+        right_mask = event_classes == 4
+        left_mask = event_classes == 3
+        rest_mask = event_classes == 1
+        feet_mask = event_classes == 2
+        event_classes[right_mask] = 1
+        event_classes[left_mask] = 2
+        event_classes[rest_mask] = 3
+        event_classes[feet_mask] = 4
+    elif all_class_names == ['Right Hand Start', 'Left Hand Start',
+                             'Rest Start', 'Feet Start',
+                             'Right Hand End',
+                             'Left Hand End', 'Rest End', 'Feet End']:
+        pass
+    elif all_class_names == ['Right Hand', 'Left Hand', 'Rest',
+                             'Feet', 'Face', 'Navigation', 'Music',
+                             'Rotation',
+                             'Subtraction', 'Words']:
+        pass  # robot hall 10 class decoding
+    elif (all_class_names == ['RightHand', 'Feet', 'Rotation', 'Words',
+                              '\x00\x00', '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00',
+                              'RightHand_End', '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00',
+                              'Feet_End', '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00',
+                              'Rotation_End', '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00', '\x00\x00',
+                              '\x00\x00', '\x00\x00',
+                              'Words_End'] or
+                  all_class_names == ['RightHand', 'Feet', 'Rotation',
+                                      'Words',
+                                      'Rest', '\x00\x00', '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      'RightHand_End', '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00',
+                                      '\x00\x00', 'Feet_End',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00',
+                                      '\x00\x00', 'Rotation_End',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      'Words_End', '\x00\x00',
+                                      '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      '\x00\x00',
+                                      '\x00\x00', '\x00\x00',
+                                      'Rest_End']):
+        pass  # weird stuff when we recorded cursor in robot hall
+        # on 2016-09-14 and 2016-09-16 :D
+
+    elif (all_class_names == ['0004', '0016', '0032', '0056', '0064',
+                              '0088', '0095', '0120']):
+        pass
+    elif (all_class_names == ['0004', '0056', '0088', '0120']):
+        pass
+    elif (all_class_names == ['0004', '0016', '0032', '0048', '0056',
+                              '0064', '0080', '0088', '0095', '0120']):
+        pass
+    elif (all_class_names == ['0004', '0016', '0056', '0088', '0120',
+                              '__']):
+        pass
+    elif (all_class_names == ['0004', '0056', '0088', '0120', '__']):
+        pass
+    elif (all_class_names == ['0004', '0032', '0048', '0056', '0064',
+                              '0080', '0088', '0095', '0120', '__']):
+        pass
+    elif (all_class_names == ['0004', '0056', '0080', '0088', '0096',
+                              '0120', '__']):
+        pass
+    elif (all_class_names == ['0004', '0032', '0056', '0064', '0080',
+                              '0088', '0095', '0120']):
+        pass
+    elif (all_class_names == ['0004', '0032', '0048', '0056', '0064',
+                              '0080', '0088', '0095', '0120']):
+        pass
+    elif (all_class_names == ['0004', '0016', '0032', '0048', '0056',
+                              '0064', '0080', '0088', '0095', '0096',
+                              '0120']):
+        pass
+    elif (all_class_names == ['4', '16', '32', '56', '64', '88', '95',
+                              '120']):
+        pass
+    elif (all_class_names == ['4', '56', '88', '120']):
+        pass
+    elif (all_class_names == ['4', '16', '32', '48', '56',
+                              '64', '80', '88', '95', '120']):
+        pass
+    elif (all_class_names == ['0', '4', '56', '88', '120']):
+        pass
+    elif (all_class_names == ['0', '4', '16', '56', '88', '120']):
+        pass
+    elif (all_class_names == ['0', '4', '32', '48', '56', '64', '80',
+                              '88', '95', '120']):
+        pass
+    elif (all_class_names == ['0', '4', '56', '80', '88', '96', '120']):
+        pass
+    elif (all_class_names == ['4', '32', '56', '64', '80', '88', '95',
+                              '120']):
+        pass
+    elif (all_class_names == ['One', 'Two', 'Three', 'Four']):
+        pass
+    elif (
+                all_class_names == ['1', '10', '11', '12', '2', '20', '3', '30',
+                                    '4', '40']):
+        pass
+    elif (
+                all_class_names == ['1', '10', '12', '13', '2', '20', '3', '30',
+                                    '4', '40']):
+        pass
+    elif (
+                all_class_names == ['1', '10', '13', '2', '20', '3', '30', '4',
+                                    '40', '99']):
+        pass
+    elif (all_class_names == ['1', '10', '11', '14', '18', '20', '21',
+                              '24', '251', '252', '28', '30', '4',
+                              '8']):
+        pass
+    elif (all_class_names == ['1', '10', '11', '14', '18', '20', '21',
+                              '24', '252', '253', '28', '30', '4',
+                              '8']):
+        pass
+    elif len(event_times_in_ms) == len(all_class_names):
+        pass  # weird neuroone(?) logic where class names have event classes
+    elif (all_class_names == ['Right_hand_stimulus_onset',
+                              'Feet_stimulus_onset',
+                              'Rotation_stimulus_onset',
+                              'Words_stimulus_onset',
+                              'Right_hand_stimulus_offset',
+                              'Feet_stimulus_offset',
+                              'Rotation_stimulus_offset',
+                              'Words_stimulus_offset']):
+        pass
+    else:
+        # remove this whole if else stuffs?
+        log.warn("Unknown class names {:s}".format(
+            all_class_names))
+
+def load_bbci_sets_from_folder(folder, runs='all'):
+    bbci_mat_files = sorted(glob(os.path.join(folder, '*.BBCI.mat')))
+    if runs != 'all':
+        file_run_numbers = [int(re.search('S[0-9]{3,3}R[0-9]{2,2}_', f).group()[5:7])
+                            for f in bbci_mat_files]
+        indices = [file_run_numbers.index(num) for num in runs]
+
+        wanted_files = np.array(bbci_mat_files)[indices]
+    else:
+        wanted_files = bbci_mat_files
+    cnts = []
+    for f in wanted_files:
+        log.info("Loading {:s}".format(f))
+        cnts.append(BBCIDataset(f).load())
+    return cnts

Braindecode-0.1.4.2/braindecode/datasets/multiple.py

@@ -0,0 +1,38 @@
+import logging
+
+from braindecode.mne_ext.signalproc import resample_cnt, \
+    concatenate_raws_with_events
+
+log = logging.getLogger(__name__)
+
+
+class MultipleSetLoader(object):
+    """
+    Class to load multiple sets.
+    Resamples sets down as necessary.
+
+    Parameters
+    ----------
+    set_loaders: object with load method: () -> MNE Raw object
+    """
+
+    def __init__(self, set_loaders):
+        self.set_loaders = set_loaders
+
+    def load(self):
+        cnt = self.set_loaders[0].load()
+        for loader in self.set_loaders[1:]:
+            next_cnt = loader.load()
+            # always sample down to lowest common denominator
+            if next_cnt.fs > cnt.fs:
+                log.warning("Next set has larger sampling rate ({:d}) "
+                         "than before ({:d}), resampling next set".format(
+                    next_cnt.fs, cnt.fs))
+                next_cnt = resample_cnt(next_cnt, cnt.fs)
+            if next_cnt.fs < cnt.fs:
+                log.warning("Next set has smaller sampling rate ({:d}) "
+                         "than before ({:d}), resampling set so far".format(
+                    next_cnt.fs, cnt.fs))
+                cnt = resample_cnt(cnt, next_cnt.fs)
+            cnt = concatenate_raws_with_events(cnt, next_cnt)
+        return cnt

{Braindecode-0.1.4/braindecode/datautils → Braindecode-0.1.4.2/braindecode/datautil}/iterators.py

@@ -137,13 +137,18 @@ class CropsFromTrialsIterator(object):
                                       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)
+        i_trial_start_stop_block = np.array(i_trial_start_stop_block)
+        if i_trial_start_stop_block.ndim == 1:
+            i_trial_start_stop_block = i_trial_start_stop_block[None,:]
+        #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]
+        blocks_per_batch = get_balanced_batches(len(i_trial_start_stop_block),
+                                       batch_size=self.batch_size,
+                                       rng=self.rng,
+                                       shuffle=shuffle)
+        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, self.n_preds_per_input)
             yield batch
@@ -205,12 +210,10 @@ def create_batch_from_i_trial_start_stop_blocks(X, y, i_trial_start_stop_block,
     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)
+    # add empty fourth dimension if necessary
+    if batch_X.ndim == 3:
+        batch_X = batch_X[:,:,:, None]
     return batch_X, batch_y

Braindecode-0.1.4.2/braindecode/datautil/signalproc.py

@@ -0,0 +1,145 @@
+import logging
+
+import pandas as pd
+import numpy as np
+import scipy
+
+log = logging.getLogger(__name__)
+
+
+def exponential_running_standardize(data, factor_new=0.001,
+                                    init_block_size=None, eps=1e-4):
+    df = pd.DataFrame(data)
+    meaned = df.ewm(alpha=factor_new).mean()
+    demeaned = df - meaned
+    squared = demeaned * demeaned
+    square_ewmed = squared.ewm(alpha=factor_new).mean()
+    standardized = demeaned / np.maximum(eps, np.sqrt(np.array(square_ewmed)))
+    standardized = np.array(standardized)
+    if init_block_size is not None:
+        other_axis = tuple(range(1, len(data.shape)))
+        init_mean = np.mean(data[0:init_block_size], axis=other_axis,
+                            keepdims=True)
+        init_std = np.std(data[0:init_block_size], axis=other_axis,
+                          keepdims=True)
+        init_block_standardized = (data[0:init_block_size] - init_mean) / \
+                                  np.maximum(eps, init_std)
+        standardized[0:init_block_size] = init_block_standardized
+    return standardized
+
+
+def exponential_running_demean(data, factor_new=0.001, init_block_size=None):
+    df = pd.DataFrame(data)
+    meaned = df.ewm(alpha=factor_new).mean()
+    demeaned = df - meaned
+    demeaned = np.array(demeaned)
+    if init_block_size is not None:
+        other_axis = tuple(range(1, len(data.shape)))
+        init_mean = np.mean(data[0:init_block_size], axis=other_axis,
+                            keepdims=True)
+        demeaned[0:init_block_size] = (data[0:init_block_size] - init_mean)
+    return demeaned
+
+
+def highpass_cnt(data, low_cut_hz, fs, filt_order=3, axis=0):
+    """
+     Highpass signal using butterworth filter of given order.
+
+    Parameters
+    ----------
+    data: 2d-array
+        Time x channels
+    low_cut_hz: float
+    fs: float
+    filt_order: int
+
+    Returns
+    -------
+    highpassed_data: 2d-array
+        Data after applying highpass filter.
+    """
+    if (low_cut_hz is None) or (low_cut_hz == 0):
+        log.info("Not doing any highpass, since low 0 or None")
+        return data.copy()
+    b, a = scipy.signal.butter(filt_order, low_cut_hz / (fs / 2.0),
+                               btype='highpass')
+    assert filter_is_stable(a)
+    data_highpassed = scipy.signal.lfilter(b, a, data, axis=axis)
+    return data_highpassed
+
+
+def lowpass_cnt(data, high_cut_hz, fs, filt_order=3, axis=0):
+    """
+     Lowpass signal using butterworth filter of given order.
+
+    Parameters
+    ----------
+    data: 2d-array
+        Time x channels
+    high_cut_hz: float
+    fs: float
+    filt_order: int
+
+    Returns
+    -------
+    lowpassed_data: 2d-array
+        Data after applying lowpass filter.
+    """
+    if (high_cut_hz is None) or (high_cut_hz ==  fs / 2.0):
+        log.info(
+            "Not doing any lowpass, since high cut hz is None or nyquist freq.")
+        return data.copy()
+    b, a = scipy.signal.butter(filt_order, high_cut_hz / (fs / 2.0),
+                               btype='lowpass')
+    assert filter_is_stable(a)
+    data_lowpassed = scipy.signal.lfilter(b, a, data, axis=axis)
+    return data_lowpassed
+
+
+def bandpass_cnt(data, low_cut_hz, high_cut_hz, fs, filt_order=3, axis=0):
+    """
+     Bandpass signal using butterworth filter of given order.
+
+    Parameters
+    ----------
+    data: 2d-array
+        Time x channels
+    low_cut_hz: float
+    high_cut_hz: float
+    fs: float
+    filt_order: int
+
+    Returns
+    -------
+    bandpassed_data: 2d-array
+        Data after applying bandpass filter.
+    """
+    if (low_cut_hz == 0 or low_cut_hz is None) and (
+                    high_cut_hz == None or high_cut_hz == fs / 2.0):
+        log.info("Not doing any bandpass, since low 0 or None and "
+                 "high None or nyquist frequency")
+        return data.copy()
+    if low_cut_hz == 0 or low_cut_hz == None:
+        log.info("Using lowpass filter since low cut hz is 0 or None")
+        return lowpass_cnt(data, high_cut_hz, fs, filt_order=filt_order, axis=axis)
+    if high_cut_hz == None or high_cut_hz == (fs / 2.0):
+        log.info(
+            "Using highpass filter since high cut hz is None or nyquist freq")
+        return highpass_cnt(data, low_cut_hz, fs, filt_order=filt_order, axis=axis)
+
+    nyq_freq = 0.5 * fs
+    low = low_cut_hz / nyq_freq
+    high = high_cut_hz / nyq_freq
+    b, a = scipy.signal.butter(filt_order, [low, high], btype='bandpass', axis=axis)
+    assert filter_is_stable(a), "Filter should be stable..."
+    data_bandpassed = scipy.signal.lfilter(b, a, data, axis=0)
+    return data_bandpassed
+
+
+def filter_is_stable(a):
+    assert a[0] == 1.0, (
+        "a[0] should normally be zero, did you accidentally supply b?\n"
+        "a: {:s}".format(str(a)))
+    # from http://stackoverflow.com/a/8812737/1469195
+    return np.all(np.abs(np.roots(a))<1)
+