def test_BaseSSVEP_specified_nclasses(self):
# Set the number of classes
paradigm = BaseSSVEP(n_classes=3)
dataset = FakeDataset(event_list=["13", "15", "17", "19"], paradigm="ssvep")
X, labels, metadata = paradigm.get_data(dataset, subjects=[1])
# labels must contain 3 values
self.assertEqual(len(np.unique(labels)), 3)
def test_BaseSSVEP_nclasses_default(self):
# Default is with 2 classes
paradigm = BaseSSVEP()
dataset = FakeDataset(event_list=['13', '15', '17', '19'],
paradigm='ssvep')
X, labels, metadata = paradigm.get_data(dataset, subjects=[1])
# labels must contain 2 values, as n_classes is 2 by default
self.assertEqual(len(np.unique(labels)), 2)
def test_BaseSSVEP_nclasses_default(self):
# Default is with 3 classes
paradigm = BaseSSVEP()
dataset = FakeDataset(paradigm="ssvep")
X, labels, metadata = paradigm.get_data(dataset, subjects=[1])
# labels must contain all 3 classes of dataset,
# as n_classes is "None" by default (taking all classes)
self.assertEqual(len(np.unique(labels)), 3)
def test_BaseSSVEP_channel_order(self):
"""test if paradigm return correct channel order, see issue #227"""
datasetA = FakeDataset(paradigm="ssvep", channels=["C3", "Cz", "C4"])
datasetB = FakeDataset(paradigm="ssvep", channels=["Cz", "C4", "C3"])
paradigm = BaseSSVEP(channels=["C4", "C3", "Cz"])
ep1, _, _ = paradigm.get_data(datasetA, subjects=[1], return_epochs=True)
ep2, _, _ = paradigm.get_data(datasetB, subjects=[1], return_epochs=True)
self.assertEqual(ep1.info["ch_names"], ep2.info["ch_names"])
def test_BaseSSVEP_filters(self):
# Accept filters
paradigm = BaseSSVEP(filters=[(10.5, 11.5), (12.5, 13.5)])
dataset = FakeDataset(paradigm='ssvep')
X, labels, metadata = paradigm.get_data(dataset, subjects=[1])
# X must be a 4D array
self.assertEqual(len(X.shape), 4)
# Last dim should be 2 as the number of filters
self.assertEqual(X.shape[-1], 2)
def test_BaseSSVEP_filters(self):
# Accept filters
paradigm = BaseSSVEP(filters=[(10.5, 11.5), (12.5, 13.5)])
dataset = FakeDataset(paradigm="ssvep")
X, labels, metadata = paradigm.get_data(dataset, subjects=[1])
# X must be a 4D array
self.assertEqual(len(X.shape), 4)
# Last dim should be 2 as the number of filters
self.assertEqual(X.shape[-1], 2)
# should return epochs
epochs, _, _ = paradigm.get_data(dataset, subjects=[1], return_epochs=True)
self.assertIsInstance(epochs, BaseEpochs)
def test_BaseSSVEP_paradigm(self):
paradigm = BaseSSVEP(n_classes=None)
dataset = FakeDataset(paradigm="ssvep")
X, labels, metadata = paradigm.get_data(dataset, subjects=[1])
# Verify that they have the same length
self.assertEqual(len(X), len(labels), len(metadata))
# X must be a 3D array
self.assertEqual(len(X.shape), 3)
# labels must contain 3 values
self.assertEqual(len(np.unique(labels)), 3)
# metadata must have subjets, sessions, runs
self.assertTrue("subject" in metadata.columns)
self.assertTrue("session" in metadata.columns)
self.assertTrue("run" in metadata.columns)
# Only one subject in the metadata
self.assertEqual(np.unique(metadata.subject), 1)
# we should have two sessions in the metadata, n_classes = 2 as default
self.assertEqual(len(np.unique(metadata.session)), 2)
# should return epochs
epochs, _, _ = paradigm.get_data(dataset, subjects=[1], return_epochs=True)
self.assertIsInstance(epochs, BaseEpochs)
def test_BaseSSVEP_paradigm(self):
paradigm = BaseSSVEP(n_classes=None)
dataset = FakeDataset(paradigm='ssvep')
X, labels, metadata = paradigm.get_data(dataset, subjects=[1])
# Verify that they have the same length
self.assertEqual(len(X), len(labels), len(metadata))
# X must be a 3D array
self.assertEqual(len(X.shape), 3)
# labels must contain 3 values
self.assertEqual(len(np.unique(labels)), 3)
# metadata must have subjets, sessions, runs
self.assertTrue('subject' in metadata.columns)
self.assertTrue('session' in metadata.columns)
self.assertTrue('run' in metadata.columns)
# Only one subject in the metadata
self.assertEqual(np.unique(metadata.subject), 1)
# we should have two sessions in the metadata, n_classes = 2 as default
self.assertEqual(len(np.unique(metadata.session)), 2)
def test_BaseSSVEP_toomany_nclasses(self):
paradigm = BaseSSVEP(n_classes=4)
dataset = FakeDataset(event_list=["13", "15"], paradigm="ssvep")
self.assertRaises(ValueError, paradigm.get_data, dataset)
def test_BaseSSVEP_toomany_nclasses(self):
paradigm = BaseSSVEP(n_classes=4)
dataset = FakeDataset(event_list=['13', '15'], paradigm='ssvep')
self.assertRaises(ValueError, paradigm.get_data, dataset)
sig_ext = X_sig[:, :, :, :-1].transpose((0, 3, 1, 2))
n_trials, n_freqs, n_channels, n_times = sig_ext.shape
X_sig = sig_ext.reshape((n_trials, n_channels * n_freqs, n_times))
X_sig = np.concatenate([X_sig[i, :, :] for i in range(X_sig.shape[0])],
axis=1)
cov = Covariances(estimator='lwf').transform(
X_sig.reshape((1, *(X_sig.shape))))
cov_list.append(cov)
return np.concatenate(cov_list, axis=0)
metric = 'logdet' #'riemann' #
##############################################################
# Load SSVEP database
paradigm = BaseSSVEP()
SSVEPExo().download(update_path=False, verbose=False)
datasets = SSVEPExo()
X, y, metadata = paradigm.get_data(dataset=datasets)
# with gzip.open('SSVEPExo.pkz', 'wb') as f:
# o = {'X':X, 'y':y, 'metadata':metadata}
# pickle.dump(o, f)
# with gzip.open('SSVEPExo.pkz', 'rb') as f:
# o = pickle.load(f)
# X, y, metadata = o['X'], o['y'], o['metadata']
n_subjects = len(np.unique(np.array(metadata['subject'])))
##############################################################
# Aggregate all signals for a class from subjects
