def test_correct_classlabels(self): """lda_train must throw an error if the class labels are not exactly [0, 1].""" data = np.random.random((50, 100)) labels = np.zeros(50) # only 0s -> fail fv = Data(data=data, axes=[labels, np.arange(100)], units=['x', 'y'], names=['foo', 'bar']) with self.assertRaises(ValueError): lda_train(fv) # 0s and 1s -> ok labels[1] = 1 fv = Data(data=data, axes=[labels, np.arange(100)], units=['x', 'y'], names=['foo', 'bar']) try: lda_train(fv) except ValueError: self.fail() # 0s, 1s, and 2s -> fail labels[2] = 2 fv = Data(data=data, axes=[labels, np.arange(100)], units=['x', 'y'], names=['foo', 'bar']) with self.assertRaises(ValueError): lda_train(fv)
def setUp(self): self.empty_dat = Data(np.array([]), [], [], []) self.dat_1 = Data( np.array([0, 0])[np.newaxis, :], [np.array([0]), np.array(['ch1', 'ch2'])], ['time', 'channel'], ['ms', '#']) self.dat_1.fs = 1000 self.dat_1.markers = [[0, 'x']] self.dat_5 = reduce(append_cnt, [self.dat_1 for i in range(5)])
def setUp(self): dat = np.zeros((SAMPLES, CHANS)) # [-10, -9, ... 20) dat[:, 0] = np.arange(SAMPLES) - SAMPLES / 2 channels = ['chan{i}'.format(i=i) for i in range(CHANS)] time = np.arange(SAMPLES) self.cnt = Data(dat, [time, channels], ['time', 'channels'], ['ms', '#']) # construct epo epo_dat = np.array([dat + i for i in range(EPOS)]) classes = ['class{i}'.format(i=i) for i in range(EPOS)] self.epo = Data(epo_dat, [classes, time, channels], ['class', 'time', 'channels'], ['#', 'ms', '#'])
def setUp(self): data = np.random.randn(SAMPLES, CHANS) data[:, 1] += 0.5 * data[:, 0] data[:, 2] -= 0.5 * data[:, 0] t = np.arange(SAMPLES) chans = ['chan{i}'.format(i=i) for i in range(CHANS)] self.cnt = Data(data, [t, chans], ['time', 'channels'], ['ms', '#']) # construct epo epo_dat = np.array([data for i in range(EPOS)]) classes = ['class{i}'.format(i=i) for i in range(EPOS)] self.epo = Data(epo_dat, [classes, t, chans], ['class', 'time', 'channels'], ['#', 'ms', '#']) # my little spatial filter self.w = np.array([[0, 0.5, 1], [-1, 0.5, 0], [1, 0.5, 0]])
def setUp(self): data = np.random.randn(SAMPLES, CHANS) data[:, 1] += 0.5 * data[:, 0] data[:, 2] -= 0.5 * data[:, 0] t = np.arange(SAMPLES) chans = ['chan{i}'.format(i=i) for i in range(CHANS)] self.cnt = Data(data, [t, chans], ['time', 'channels'], ['ms', '#'])
def setUp(self): # generate sources with independent variance modulations, the # first source will be the target source z = np.abs(np.random.randn(self.EPOCHS, self.SOURCES)) for i in range(self.SOURCES): z[:, i] /= z[:, i].std() self.s = np.random.randn(self.EPOCHS, self.SAMPLES, self.SOURCES) for i in range(self.SOURCES): for j in range(self.EPOCHS): self.s[j, :, i] *= z[j, i] # the mixmatrix which converts our sources to channels # X = As + noise self.A = np.random.randn(self.CHANNELS, self.SOURCES) # our 'signal' which 50 epochs, 100 samples and 10 channels self.X = np.empty((self.EPOCHS, self.SAMPLES, self.CHANNELS)) for i in range(self.EPOCHS): self.X[i] = np.dot(self.A, self.s[i].T).T noise = np.random.randn(self.EPOCHS, self.SAMPLES, self.CHANNELS) * 0.01 self.X += noise # convert to epo axes = [ z[:, 0], np.arange(self.X.shape[1]), np.arange(self.X.shape[2]) ] self.epo = Data(self.X, axes=axes, names=['target_variable', 'time', 'channel'], units=['#', 'ms', '#'])
def setUp(self): # create a random noise signal with 50 epochs, 100 samples, and # 2 sources # even epochs and source 0: *= 5 # odd epochs and source 1: *= 5 self.s = np.random.randn(self.EPOCHS, self.SAMPLES, self.SOURCES) self.s[::2, :, 0] *= 5 self.s[1::2, :, 1] *= 5 # the mixmatrix which converts our sources to channels # X = As + noise self.A = np.random.randn(self.CHANNELS, self.SOURCES) # our 'signal' which 50 epochs, 100 samples and 10 channels self.X = np.empty((self.EPOCHS, self.SAMPLES, self.CHANNELS)) for i in range(self.EPOCHS): self.X[i] = np.dot(self.A, self.s[i].T).T noise = np.random.randn(self.EPOCHS, self.SAMPLES, self.CHANNELS) * 0.01 self.X += noise a = np.array([1 for i in range(self.X.shape[0])]) a[0::2] = 0 axes = [a, np.arange(self.X.shape[1]), np.arange(self.X.shape[2])] self.epo = Data(self.X, axes=axes, names=['class', 'time', 'channel'], units=['#', 'ms', '#']) self.epo.class_names = ['foo', 'bar'] self.filter = np.random.random((self.CHANNELS, self.CHANNELS))
def test_eq_and_ne(self): """Check if __ne__ is properly implemented.""" d1 = Data(self.data, self.axes, self.names, self.units) d2 = d1.copy() # if __eq__ is implemented and __ne__ is not, this evaluates to # True! self.assertFalse(d1 == d2 and d1 != d2)
def setUp(self): # X is a random mixture matrix of random variables Sx = randn(self.SAMPLES, self.CHANNELS_X) Ax = randn(self.CHANNELS_X, self.CHANNELS_X) self.X = np.dot(Sx, Ax) # Y is a random mixture matrix of random variables except the # first component Sy = randn(self.SAMPLES, self.CHANNELS_Y) Sy[:, 0] = Sx[:, 0] + self.NOISE_LEVEL * randn(self.SAMPLES) Ay = randn(self.CHANNELS_Y, self.CHANNELS_Y) self.Y = np.dot(Sy, Ay) # generate Data object axes_x = [np.arange(self.X.shape[0]), np.arange(self.X.shape[1])] axes_y = [np.arange(self.Y.shape[0]), np.arange(self.Y.shape[1])] self.dat_x = Data(self.X, axes=axes_x, names=['time', 'channel'], units=['ms', '#']) self.dat_y = Data(self.Y, axes=axes_y, names=['time', 'channel'], units=['ms', '#'])
def convert_mushu_data(data, markers, fs, channels): """Convert mushu data into wyrm's ``Data`` format. This convenience method creates a continuous ``Data`` object from the parameters given. The timeaxis always starts from zero and its values are calculated from the sampling frequency ``fs`` and the length of ``data``. The ``names`` and ``units`` attributes are filled with default vaules. Parameters ---------- data : 2d array an 2 dimensional numpy array with the axes: (time, channel) markers : list of tuples: (float, str) a list of markers. Each element is a tuple of timestamp and string. The timestamp is the time in ms relative to the onset of the block of data. Note that negative values are *allowed* as well as values bigger than the length of the block of data returned. That is to be interpreted as a marker from the last block and a marker for a future block respectively. fs : float the sampling frequency, this number is used to calculate the timeaxis for the data channels : list or 1d array of strings the channel names Returns ------- cnt : continuous ``Data`` object Examples -------- Assuming that ``amp`` is an Amplifier instance from ``libmushu``, already configured but not started yet: >>> amp_fs = amp.get_sampling_frequency() >>> amp_channels = amp.get_channels() >>> amp.start() >>> while True: ... data, markers = amp.get_data() ... cnt = convert_mushu_data(data, markers, amp_fs, amp_channels) ... # some more code >>> amp.stop() References ---------- https://github.com/bbci/mushu """ time_axis = np.linspace(0, 1000 * data.shape[0] / fs, data.shape[0], endpoint=False) chan_axis = channels[:] axes = [time_axis, chan_axis] names = ['time', 'channel'] units = ['uV', '#'] cnt = Data(data=data.copy(), axes=axes, names=names, units=units) cnt.markers = markers[:] cnt.fs = fs return cnt
def test_init_with_inconsistent_values(self): """Test init with inconsistent values.""" data = self.data[np.newaxis, :] with self.assertRaises(AssertionError): Data(data, self.axes, self.names, self.units) axes = self.axes[:] axes[0] = np.arange(100) with self.assertRaises(AssertionError): Data(self.data, axes, self.names, self.units) names = self.names[:] names.append('baz') with self.assertRaises(AssertionError): Data(self.data, self.axes, names, self.units) units = self.units[:] units.append('u3') with self.assertRaises(AssertionError): Data(self.data, self.axes, self.names, units)
def setUp(self): data = np.arange(10).reshape(5, 2) axes = [np.arange(5), np.array(['ch1', 'ch2'])] names = ['time', 'channel'] units = ['ms', '#'] fs = 1000 self.dat = Data(data, axes, names, units) self.dat.fs = fs
def test_init(self): """Test init with correct values.""" d = Data(self.data, self.axes, self.names, self.units) np.testing.assert_array_equal(d.data, self.data) for a, b in zip(d.axes, self.axes): np.testing.assert_array_equal(a, b) self.assertEqual(self.names, d.names) self.assertEqual(self.units, d.units)
def test_raise_error_with_non_continuous_data(self): """Raise error if ``dat_x`` is not continuous Data object.""" dat = Data(randn(2, self.SAMPLES, self.CHANNELS_X), axes=[[0, 1], self.dat_x.axes[0], self.dat_x.axes[1]], names=['class', 'time', 'channel'], units=['#', 'ms', '#']) with self.assertRaises(AssertionError): calculate_cca(dat, self.dat_x)
def train_test(data, test_size): """Splits data into train and test set of equal class proportions Params ------ data : wyrm.Data data to be split test_size : float between 0 and 1, proportion of test to training size Returns ------- dat_train : wyrm.Data Data object holding training data dat_test : wyrm.Data Data object holding test data Raises ------ TypeError if data of wrong shape """ labels = data.axes[0] n_classes = len(np.unique(labels)) ind = equalize_proportions(labels=labels, n_classes=n_classes) if len(data.axes) > 2: try: data = prep.create_fvs(data) except Exception as e: msg = ('It seems you have to reshape your data first.\n\n' + str(e)) raise TypeError(msg) dat = data.data[ind, :] labels = data.axes[0][ind] X_train, X_test, y_train, y_test = train_test_split(dat, labels, test_size=test_size, shuffle=True) ax_train = [y_train, data.axes[1]] ax_test = [y_test, data.axes[1]] names = data.names units = data.units dat_train = Data(data=X_train, axes=ax_train, names=names, units=units) dat_test = Data(data=X_test, axes=ax_test, names=names, units=units) return dat_train, dat_test
def setUp(self): ones = np.ones((10, 5)) # epo with 0, 1, 2 data = np.array([0 * ones, ones, 2 * ones]) channels = ['ca1', 'ca2', 'cb1', 'cb2', 'cc1'] time = np.linspace(0, 1000, 10, endpoint=False) classes = [0, 1, 2] self.dat = Data(data, [classes, time, channels], ['class', 'time', 'channel'], ['#', 'ms', '#'])
def setUp(self): ones = np.ones((10, 5)) # three blocks: 1s, -1s, and 0s cnt_data = np.concatenate([ones, -ones, 0 * ones], axis=0) classes = [0, 0, 0] channels = ['ca1', 'ca2', 'cb1', 'cb2', 'cc1'] time = np.linspace(-1000, 2000, 30, endpoint=False) epo_data = np.array([cnt_data, cnt_data, cnt_data]) self.dat = Data(epo_data, [classes, time, channels], ['class', 'time', 'channels'], ['#', 'ms', '#'])
def setUp(self): ones = np.ones((10, 5)) channels = ['ca1', 'ca2', 'cb1', 'cb2', 'cc1'] time = np.linspace(-1000, 0, 10, endpoint=False) classes = [0, 0, 0] # three cnts: 1s, -1s, and 0s data = np.array([ones, ones * -1, ones * 0]) self.dat = Data(data, [classes, time, channels], ['class', 'time', 'channel'], ['#', 'ms', '#']) self.dat.fs = 10
def setUp(self): ones = np.ones((10, 5)) channels = ['ca1', 'ca2', 'cb1', 'cb2', 'cc1'] time = np.linspace(0, 1000, 10, endpoint=False) classes = [0, 1, 2, 1] class_names = ['zeros', 'ones', 'twoes'] # four cnts: 0s, 1s, -1s, and 0s data = np.array([ones * 0, ones * 1, ones * 2, ones * 0]) self.dat = Data(data, [classes, time, channels], ['class', 'time', 'channel'], ['#', 'ms', '#']) self.dat.class_names = class_names
def setUp(self): raw = np.arange(2000).reshape(-1, 5) channels = ['ca1', 'ca2', 'cb1', 'cb2', 'cc1'] time = np.linspace(0, 4000, 400, endpoint=False) fs = 100 marker = [[100, 'foo'], [200, 'bar']] self.dat = Data(raw, [time, channels], ['time', 'channels'], ['ms', '#']) self.dat.fs = fs self.dat.markers = marker
def test_copy(self): """Copy must work.""" d1 = Data(self.data, self.axes, self.names, self.units) d2 = d1.copy() self.assertEqual(d1, d2) # we can't really check of all references to be different in # depth recursively, so we only check on the first level for k in d1.__dict__: self.assertNotEqual(id(getattr(d1, k)), id(getattr(d2, k))) d2 = d1.copy(foo='bar') self.assertEqual(d2.foo, 'bar')
def setUp(self): ones = np.ones((10, 5)) # cnt with 1, 2, 3 cnt = np.append(ones, ones * 2, axis=0) cnt = np.append(cnt, ones * 3, axis=0) channels = ['ca1', 'ca2', 'cb1', 'cb2', 'cc1'] time = np.linspace(0, 3000, 30, endpoint=False) self.dat = Data(cnt, [time, channels], ['time', 'channel'], ['ms', '#']) self.dat.markers = [[0, 'a'], [1, 'b']] self.dat.fs = 10
def setUp(self): # create epoched data with only 0s in class0, 1s in class1 and # 2s in class2 cnt = np.ones((10, 3)) epo = np.array([0 * cnt, 1 * cnt, 2 * cnt]) time = np.arange(10) channels = np.array(['ch1', 'ch2', 'ch3']) classes = np.arange(3) axes = ['class', 'time', 'channel'] units = ['#', 'ms', '#'] self.dat = Data(epo, [classes, time, channels], axes, units)
def compute_cleaner(data, eog_data, marker_positions, ival, max_min=2, whisker_percent=5, whisker_length=3): """For Cleaner tests...""" assert eog_data.shape[0] == data.shape[0] axes = [range(data.shape[0]), range(data.shape[1])] markers = zip(marker_positions, [0] * len(marker_positions)) marker_def = {'0': [0]} cnt = Data(data, axes=axes, names=['time', 'channels'], units=['ms', '#']) cnt.fs = 1000 cnt.markers = markers eog_axes = [range(eog_data.shape[0]), range(eog_data.shape[1])] eog_cnt = Data(eog_data, axes=eog_axes, names=['time', 'channels'], units=['ms', '#']) eog_cnt.fs = 1000 eog_cnt.markers = markers eog_proc = SignalProcessor(FakeLoader(eog_cnt), segment_ival=ival, marker_def=marker_def) cleaner = Cleaner(cnt, eog_proc, rejection_blink_ival=ival, max_min=max_min, rejection_var_ival=ival, whisker_percent=whisker_percent, whisker_length=whisker_length, low_cut_hz=None, high_cut_hz=None, filt_order=None, marker_def=marker_def) cleaner.clean() return cleaner
def setUp(self): # create 100 samples and tree channels data ones = np.ones((100, 3)) data = np.array([ones, ones * 2, ones * 3]).reshape(-1, 3) time = np.linspace(0, 3000, 300, endpoint=False) channels = ['a', 'b', 'c'] markers = [[500, 'M1'], [1500, 'M2'], [2500, 'M3']] self.dat = Data(data, [time, channels], ['time', 'channels'], ['ms', '#']) self.dat.markers = markers self.dat.fs = 100 self.mrk_def = {'class 1': ['M1'], 'class 2': ['M2', 'M3']}
def setUp(self): ones = np.ones((10, 5)) # cnt with 1, 2, 3 cnt = np.append(ones, ones*2, axis=0) cnt = np.append(cnt, ones*3, axis=0) channels = ['ca1', 'ca2', 'cb1', 'cb2', 'cc1'] time = np.linspace(0, 3000, 30, endpoint=False) classes = [0, 1, 2, 1] # four cnts: 1s, -1s, and 0s data = np.array([cnt * 0, cnt * 1, cnt * 2, cnt * 0]) self.dat = Data(data, [classes, time, channels], ['class', 'time', 'channel'], ['#', 'ms', '#']) self.dat.class_names = ['zero', 'one', 'two']
def setUp(self): ones = np.ones((10, 2)) twoes = ones * 2 # 7 epochs data = np.array([ones, ones, twoes, twoes, ones, twoes, twoes]) channels = ['c1', 'c2'] time = np.linspace(0, 1000, 10) classes = [0, 0, 1, 1, 0, 1, 1] class_names = ['ones', 'twoes'] self.dat = Data(data, [classes, time, channels], ['class', 'time', 'channel'], ['#', 'ms', '#']) self.dat.class_names = class_names
def load_mushu_data(meta): """Load saved EEG data in Mushu's format. This method loads saved data in Mushu's format and returns a continuous ``Data`` object. Parameters ---------- meta : str Path to `.meta` file. A Mushu recording consists of three different files: `.eeg`, `.marker`, and `.meta`. Returns ------- dat : Data Continuous Data object Examples -------- >>> dat = load_mushu_data('testrecording.meta') """ # reverse and replace and reverse again to replace only the last # (occurrence of .meta) datafile = meta[::-1].replace('atem.', 'gee.', 1)[::-1] markerfile = meta[::-1].replace('atem.', 'rekram.', 1)[::-1] assert path.exists(meta) and path.exists(datafile) and path.exists( markerfile) # load meta data with open(meta) as fh: metadata = json.load(fh) fs = metadata['Sampling Frequency'] channels = np.array(metadata['Channels']) # load eeg data data = np.fromfile(datafile, np.float32) data = data.reshape((-1, len(channels))) # load markers markers = [] with open(markerfile) as fh: for line in fh: ts, m = line.split(' ', 1) markers.append([float(ts), str(m).strip()]) # construct Data duration = len(data) * 1000 / fs axes = [np.linspace(0, duration, len(data), endpoint=False), channels] names = ['time', 'channels'] units = ['ms', '#'] dat = Data(data=data, axes=axes, names=names, units=units) dat.fs = fs dat.markers = markers return dat
def setUp(self): self.sorted_channels = np.array([name for name, pos in CHANNEL_10_20]) channels = self.sorted_channels.copy() random.shuffle(channels) raw = np.random.random((5, 10, len(channels))) time = np.linspace(0, 1000, 10, endpoint=False) epochs = np.array([0, 1, 0, 1, 0]) fs = 100 marker = [[100, 'foo'], [200, 'bar']] self.dat = Data(raw, [epochs, time, channels], ['class', 'time', 'channels'], ['#', 'ms', '#']) self.dat.fs = fs self.dat.markers = marker
def setUp(self): # create some data fs = 100 dt = 5 self.freqs = [2, 7, 15] amps = [30, 10, 2] t = np.linspace(0, dt, fs*dt) data = np.sum([a * np.sin(2*np.pi*t*f) for a, f in zip(amps, self.freqs)], axis=0) data = data[:, np.newaxis] data = np.concatenate([data, data], axis=1) channel = np.array(['ch1', 'ch2']) self.dat = Data(data, [t, channel], ['time', 'channel'], ['s', '#']) self.dat.fs = fs