def test_manual_class_selection(self):
"""Manual class indices selection must work."""
w, a, d = calculate_csp(self.epo)
w2, a2, d2 = calculate_csp(self.epo, [0, 1])
np.testing.assert_array_equal(w, w2)
np.testing.assert_array_equal(a, a2)
np.testing.assert_array_equal(d, d2)
w2, a2, d2 = calculate_csp(self.epo, [1, 0])
np.testing.assert_array_almost_equal(np.abs(w), np.abs(w2[:, ::-1]))
np.testing.assert_array_almost_equal(np.abs(a), np.abs(a2[:, ::-1]))
np.testing.assert_array_almost_equal(np.abs(d), np.abs(d2[::-1]))
def preprocess(data, filt=None):
# copying data
dat = data.copy()
fs_n = dat.fs / 2.0
# butter filtering low
b, a = proc.signal.butter(5, [13 / fs_n], btype='low')
#dat = proc.filtfilt(dat, b, a)
# butter filtering high
b, a = proc.signal.butter(4, [9 / fs_n], btype='high')
dat = proc.filtfilt(dat, b, a)
# subsampling
#dat = proc.subsample(dat, 50)
if filt is None:
# calculate_csp
filt, pattern, _ = proc.calculate_csp(dat)
# plot_csp_pattern
#plot_csp_pattern(pattern)
# apply_csp
dat = proc.apply_csp(dat, filt)
# variance and logarithm
dat = proc.variance(dat)
#dat = proc.logarithm(dat)
return dat, filt
def apply_csp(data,
return_as='filtered',
time_axis=1,
columns_to_apply=(0, 1, -2, -1)):
"""Calculates and applies CSP"""
w, a, d = calculate_csp(data)
if return_as == 'patterns':
return w, a
w = w[:, list(columns_to_apply)]
filtered = apply_spatial_filter(data, w)
if return_as == 'logvar':
filtered.data = np.log(np.var(filtered.data, axis=time_axis))
filtered.axes[1] = np.arange(filtered.data.shape[0])
return filtered
else:
return filtered
def test_s(self):
"""Test if s_est is elementwise almost equal s."""
W, A_est, d = calculate_csp(self.X[::2], self.X[1::2])
# applying the filter to X gives us s_est which should be almost
# equal s
s_est = np.empty(self.s.shape)
for i in range(self.EPOCHS):
s_est[i] = np.dot(self.X[i], W[:, [0, -1]])
# correct for scaling, and sign
self.s = self.s.reshape(-1, self.SOURCES)
s_est2 = s_est.reshape(-1, self.SOURCES)
epsilon = 0.01
for i in range(self.SOURCES):
idx = np.argmax(np.abs(s_est2[:, i]))
s_est2[:, i] /= s_est2[idx, i]
idx = np.argmax(np.abs(self.s[:, i]))
self.s[:, i] /= self.s[idx, i]
diff = np.sum(np.abs(self.s[:, i] - s_est2[:, i])) / self.s.shape[0]
self.assertTrue(diff < epsilon)
def test_A(self):
"""Test if A_est is elementwise almost equal A."""
W, A_est, d = calculate_csp(self.X[::2], self.X[1::2])
# A and A_est can have a different scaling, after normalizing
# and correcting for sign, they should be almost equal
# normalize (we're only interested in the first and last column)
for i in 0, -1:
idx = np.argmax(np.abs(A_est[:, i]))
A_est[:, i] /= A_est[idx, i]
idx = np.argmax(np.abs(self.A[:, i]))
self.A[:, i] /= self.A[idx, i]
# for i in 0, -1:
# check elementwise if A[:, i] almost A_est[:, i]
epsilon = 0.01
for i in 0, -1:
diff = self.A[:, i] - A_est[:, i]
diff = np.abs(diff)
diff = np.sum(diff) / self.A.shape[0]
self.assertTrue(diff < epsilon)
def test_s(self):
"""Test if s_est is elementwise almost equal s."""
W, A_est, d = calculate_csp(self.epo)
# applying the filter to X gives us s_est which should be almost
# equal s
s_est = np.empty(self.s.shape)
for i in range(self.EPOCHS):
s_est[i] = np.dot(self.X[i], W[:, [0, -1]])
# correct for scaling, and sign
self.s = self.s.reshape(-1, self.SOURCES)
s_est2 = s_est.reshape(-1, self.SOURCES)
epsilon = 0.01
for i in range(self.SOURCES):
idx = np.argmax(np.abs(s_est2[:, i]))
s_est2[:, i] /= s_est2[idx, i]
idx = np.argmax(np.abs(self.s[:, i]))
self.s[:, i] /= self.s[idx, i]
diff = np.sum(np.abs(self.s[:, i] - s_est2[:, i])) / self.s.shape[0]
self.assertTrue(diff < epsilon)
def test_A(self):
"""Test if A_est is elementwise almost equal A."""
W, A_est, d = calculate_csp(self.epo)
# A and A_est can have a different scaling, after normalizing
# and correcting for sign, they should be almost equal
# normalize (we're only interested in the first and last column)
for i in 0, -1:
idx = np.argmax(np.abs(A_est[:, i]))
A_est[:, i] /= A_est[idx, i]
idx = np.argmax(np.abs(self.A[:, i]))
self.A[:, i] /= self.A[idx, i]
# for i in 0, -1:
# check elementwise if A[:, i] almost A_est[:, i]
epsilon = 0.01
for i in 0, -1:
diff = self.A[:, i] - A_est[:, i]
diff = np.abs(diff)
diff = np.sum(diff) / self.A.shape[0]
self.assertTrue(diff < epsilon)
def preprocess(data, filt=None):
dat = data.copy()
fs_n = 250 # sample rate is 250 for us
b, a = proc.signal.butter(5, [13 / fs_n], btype='low')
dat = proc.filtfilt(dat, b, a)
b, a = proc.signal.butter(5, [9 / fs_n], btype='high')
dat = proc.filtfilt(dat, b, a)
dat = proc.subsample(dat, 50)
if filt is None:
filt, pattern, _ = proc.calculate_csp(dat)
plot_csp_pattern(pattern)
dat = proc.apply_csp(dat, filt)
dat = proc.variance(dat)
dat = proc.logarithm(dat)
return dat, filt
def preprocess(data, filt=None):
dat = data.copy()
fs_n = dat.fs / 2
b, a = proc.signal.butter(5, [13 / fs_n], btype='low')
dat = proc.filtfilt(dat, b, a)
b, a = proc.signal.butter(5, [9 / fs_n], btype='high')
dat = proc.filtfilt(dat, b, a)
dat = proc.subsample(dat, 50)
if filt is None:
filt, pattern, _ = proc.calculate_csp(dat)
plot_csp_pattern(pattern)
dat = proc.apply_csp(dat, filt)
dat = proc.variance(dat)
dat = proc.logarithm(dat)
return dat, filt
def preprocess(dat,filt=None):
'''fs_n = dat.fs / 2
b, a = proc.signal.butter(5, [13 / fs_n], btype='low')
dat = proc.lfilter(dat, b, a)
b, a = proc.signal.butter(5, [8 / fs_n], btype='high')
dat = proc.lfilter(dat, b, a)
print dat'''
dat = proc.subsample(dat, 64)
#epo = proc.segment_dat(dat, MRK_DEF, SEG_IVAL)
#fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
#fv = proc.create_feature_vectors(dat)
if filt is None:
filt, pattern, _ = proc.calculate_csp(dat)
#plot_csp_pattern(pattern)
dat = proc.apply_csp(dat, filt)
dat = proc.variance(dat)
dat = proc.logarithm(dat)
return dat, filt
def test_d(self):
"""Test if the first lambda is almost 1 and the last one almost -1."""
W, A_est, d = calculate_csp(self.X[::2], self.X[1::2])
epsilon = 0.1
self.assertAlmostEqual(d[0], 1, delta=epsilon)
self.assertAlmostEqual(d[-1], -1, delta=epsilon)
for x in range(len(epoch)):
cA_Energy.append(abs(np.sum(np.square(cA_values[x]))))
features.append(abs(np.sum(np.square(cA_values[x]))))
for x in range(len(epoch)):
cD_Energy.append(abs(np.sum(np.square(cD_values[x]))))
features.append(abs(np.sum(np.square(cD_values[x]))))
return features
final_epoch1 = append_epo(epoch_subject1_class1, epoch_subject1_class2)
final_epoch_ch1 = append_epo(
epoch_subject1_ch1_class1,
epoch_subject1_ch1_class2) #appended both the epoch data sets
w1, a1, d1 = calculate_csp(final_epoch1)
w2, a2, d2 = calculate_csp(
final_epoch_ch1
) #calculate csp but why we need to append the data and calculate the csp paramters waht if we calculate it individually
fil_epoch_subject1_class1 = apply_csp(
epoch_subject1_class1, w1,
[0, 1, 2, 3, 4, -5, -4, -3, -2, -1
]) # brackets number are the column number to use
fil_epoch_subject1_class2 = apply_csp(epoch_subject1_class2, w1,
[0, 1, 2, 3, 4, -5, -4, -3, -2, -1])
fil_final_epoch1 = append_epo(
fil_epoch_subject1_class1,
fil_epoch_subject1_class2) # final filtered epo class*time*channel
fil_epoch_subject1_ch1_class1 = apply_csp(
epoch_subject1_ch1_class1, w2,
[0, 1, 2, 3, 4, -5, -4, -3, -2, -1
def test_d(self):
"""Test if the first lambda is almost 1 and the last one almost -1."""
W, A_est, d = calculate_csp(self.epo)
epsilon = 0.1
self.assertAlmostEqual(d[0], 1, delta=epsilon)
self.assertAlmostEqual(d[-1], -1, delta=epsilon)
def test_calculate_csp_copy(self):
"""caluclate_csp must not modify argument."""
cpy = self.epo.copy()
calculate_csp(self.epo)
self.assertEqual(self.epo, cpy)
def test_raise_error_with_automatic_classes(self):
"""Raise error if not enough classes in epo."""
self.epo.axes[0][:] = 0
with self.assertRaises(AssertionError):
calculate_csp(self.epo)
def test_raise_error_on_wrong_manual_classes(self):
"""Raise error if classes not in epo."""
with self.assertRaises(AssertionError):
calculate_csp(self.epo, [0, 2])
calculate_csp(self.epo, [0, -1])
