def kernel_pca_per_label(num_components, epochs, kernel='linear', plot=True):
data = epochs.get_data()
all_labels = epochs.events[:, 2]
for label in range(8):
label_inds = np.where(all_labels == label)
data_per_label = data[label_inds]
pca = UnsupervisedSpatialFilter(KernelPCA(num_components,
kernel=kernel),
average=False)
print('fitting pca for label {} and kernel {}'.format(label, kernel))
pca_data = pca.fit_transform(data_per_label)
print('fitting done')
if label == 0:
all_pca = pca_data
else:
all_pca = np.concatenate((all_pca, pca_data))
if plot:
info = mne.create_info(pca_data.shape[1], epochs.info['sfreq'])
ev = mne.EvokedArray(np.mean(pca_data, axis=0), info=info)
ev.plot(show=False,
window_title="PCA",
time_unit='s',
titles="Kernel PCA for label {} and kernel".format(
label, kernel))
plt.axvline(x=0.15, color='b', linestyle='--')
plt.show()
return all_pca
def ApplyPCA(raw, n):
SetPaths()
dictionary = {"T2": 100}
eves = mne.events_from_annotations(raw, dictionary)
events = eves[0]
events_ids = {"target/stimulus": 100}
epochs = mne.Epochs(raw, events, event_id=events_ids, preload=True)
fig = epochs.plot()
fig.savefig(PLOT_PATH + '/' + 'raw_epochs.png')
fig = epochs.plot_psd()
fig.savefig(PLOT_PATH + '/' + 'epochs_psd.png')
from mne.decoding import UnsupervisedSpatialFilter
from sklearn.decomposition import PCA
X = epochs.get_data()
pca = UnsupervisedSpatialFilter(PCA(n), average=False)
pca_data = pca.fit_transform(X)
tmin, tmax = -0.1, 0.3
ev = mne.EvokedArray(np.mean(pca_data, axis=0),
mne.create_info(n,
epochs.info['sfreq'],
ch_types='eeg'),
tmin=tmin)
fig = ev.plot(show=False, window_title="PCA", time_unit='s')
fig.savefig(PLOT_PATH + '/' + 'PCA_15_Channels.png')
fig = ev.plot_image()
fig.savefig(PLOT_PATH + '/' + 'EvokedData_As_Image.png')
epoch_avg = np.mean(pca_data, axis=0)
return pca_data, epoch_avg
def kernel_pca(num_components, epochs, kernel='linear', label=-1, plot=True):
data = epochs.get_data()
pca = UnsupervisedSpatialFilter(KernelPCA(num_components, kernel=kernel),
average=False)
print('fitting pca')
pca_data = pca.fit_transform(data)
print('fitting done')
if label != -1:
all_labels = epochs.events[:, 2]
inds_to_keep = np.where(all_labels == label)
pca_subdata = pca_data[inds_to_keep]
pca_data = pca_subdata
if plot:
info = mne.create_info(pca_data.shape[1], epochs.info['sfreq'])
ev = mne.EvokedArray(np.mean(pca_data, axis=0), info=info)
if label != -1:
ev.plot(show=False,
window_title="PCA",
time_unit='s',
titles="Kernel PCA for label {}".format(label))
else:
ev.plot(show=False, window_title="PCA", time_unit='s')
plt.axvline(x=0.15, color='b', linestyle='--')
plt.show()
return pca_data
def cvlr(C,
n_features,
pupil_diff_thresh=None,
threshold=None,
X_raw=X_raw,
y_raw=y_raw):
n_features = int(n_features)
# X, y = exclude_eyes(X_raw, y_raw, threshold=threshold, pupil_diff_thresh=pupil_diff_thresh, timepoints=10)
X, y = (X_raw, y_raw)
X = X[:, 29:302, best_idx - 5:best_idx + 5]
if X.shape[0] > 200:
pca = UnsupervisedSpatialFilter(PCA(n_features), average=False)
pca_data = pca.fit_transform(X)
# X_raw = pca_data
clf = make_pipeline(
StandardScaler(),
LogisticRegression(multi_class='multinomial',
C=C,
penalty='l2',
solver='saga',
tol=0.01))
# clf = make_pipeline(StandardScaler(), LogisticRegression(multi_class='ovr', C=C, penalty='l2', tol=0.01))
cv = KFold(3) # CV
shifts = np.arange(-4,
5) # Additional timepoints to use as features
# shifts = [0]
accuracy = []
for n, (train_index,
test_index) in enumerate(cv.split(pca_data[..., 0])):
print("Fold {0} / 3".format(n + 1))
# Add features + samples to X/y training data and test data
X_train, y_train = add_features(pca_data[train_index, :, :],
shifts, y[train_index])
X_test, y_test = add_features(pca_data[test_index, :, :],
shifts, y[test_index])
# Add samples to training data
# X_train, y_train = augment_samples(X_train, shifts, y_train)
# Fit the classifier to training data and predict on held out data
clf.fit(
X_train[..., 5], y_train
) # X represents timepoints 5 either side of the best index
y_pred = clf.predict(X_test[..., 5])
accuracy.append(recall_score(y_test, y_pred, average='macro'))
acc = np.mean(accuracy)
else:
acc = 0
return acc
def pca_filter(self, data, parameter_list):
pca = UnsupervisedSpatialFilter(PCA(parameter_list[-1]), average=False)
data = data[0:parameter_list[-1], :]
print(data.shape)
eeg_data = np.array([data])
pca_data = pca.fit_transform(eeg_data)
filter_data = pca_data[0]
return filter_data
def PredApplyPCA(raw, n):
dictionary = {"T2": 100}
eves = mne.events_from_annotations(raw, dictionary)
events = eves[0]
events_ids = {"target/stimulus": 100}
epochs = mne.Epochs(raw, events, event_id=events_ids, preload=True)
from mne.decoding import UnsupervisedSpatialFilter
from sklearn.decomposition import PCA
X = epochs.get_data()
pca = UnsupervisedSpatialFilter(PCA(n), average=False)
pca_data = pca.fit_transform(X)
epoch_avg = np.mean(pca_data, axis=0)
return pca_data, epoch_avg
def applyPCA(components, examples, targets):
tmin, tmax = -0.1, 0.3
channel_names = np.loadtxt('./metadata/channel_names.csv', dtype=str)
epochs_info = create_info(channel_names[0:components].tolist(),
240,
ch_types='eeg',
montage='biosemi64')
pca = UnsupervisedSpatialFilter(PCA(components), average=False)
pca_data = pca.fit_transform(examples)
ev = mne.EvokedArray(np.mean(pca_data, axis=0), epochs_info, tmin=tmin)
ev.plot(show=False, window_title="PCA", time_unit='s')
plt.savefig('last_pca_plot.png', dpi=300)
return examples, targets
def save_wavelet_complex(n_components):
all_x_train_samples = []
for sample in range(1, 22):
print("sample {}".format(sample))
epochs = get_epochs(sample, scale=False)
freqs = np.logspace(*np.log10([2, 15]), num=15)
n_cycles = freqs / 4.
print("applying morlet wavelet")
wavelet_output = tfr_array_morlet(epochs.get_data(),
sfreq=epochs.info['sfreq'],
freqs=freqs,
n_cycles=n_cycles,
output='complex')
all_x_train_freqs = []
for freq in range(wavelet_output.shape[2]):
print("frequency: {}".format(freqs[freq]))
wavelet_epochs = wavelet_output[:, :, freq, :]
wavelet_epochs = np.append(wavelet_epochs.real,
wavelet_epochs.imag,
axis=1)
wavelet_info = mne.create_info(ch_names=wavelet_epochs.shape[1],
sfreq=epochs.info['sfreq'],
ch_types='mag')
wavelet_epochs = mne.EpochsArray(wavelet_epochs,
info=wavelet_info,
events=epochs.events)
pca = UnsupervisedSpatialFilter(PCA(n_components=n_components),
average=False)
print('fitting pca')
reduced = pca.fit_transform(wavelet_epochs.get_data())
print('fitting done')
x_train = reduced.transpose(0, 2, 1).reshape(-1, reduced.shape[1])
all_x_train_freqs.append(x_train)
all_x_train_samples.append(all_x_train_freqs)
print('saving x_train for all samples')
pickle.dump(
all_x_train_samples,
open(
"DataTransformed/wavelet_complex/15hz/pca_{}/x_train_all_samples.pkl"
.format(n_components), "wb"))
print("x_train saved")
def eeg_signals():
#获取原始数据，根据采样率大小取出1s的数据
eeg_data = board.get_current_board_data(sampling_rate)[0:9]
# 带通滤波处理（0.5-50），中心频率25.25，带宽49.5
eeg_channels = BoardShim.get_eeg_channels(0)
for count, channel in enumerate(eeg_channels):
eeg_data[channel] = eeg_data[channel] - np.average(eeg_data[channel])
DataFilter.perform_bandpass(eeg_data[channel],
BoardShim.get_sampling_rate(2), 25.25,
49.5, 3, FilterTypes.BESSEL.value, 0)
eeg_data = eeg_data[1:9]
eeg_data = np.array([eeg_data])
pca = UnsupervisedSpatialFilter(PCA(8), average=False)
eeg_data = pca.fit_transform(eeg_data)
eeg_data = eeg_data[0]
return eeg_data
def PCA_score(Beta, Labels, boxcar, hilb_type):
labelsR = np.concatenate((Labels[0][0], Labels[0][1]))
labelsL = np.concatenate((Labels[1][0], Labels[1][1]))
def Boxcar(data, N):
fdata = np.zeros((data.shape))
for i in range(data.shape[0]):
for q in range(data.shape[1]):
for k in range(data.shape[2]):
if k < N:
fdata[i, q, k] = data[i, q, k]
else:
fdata[i, q, k] = np.sqrt(
np.mean(data[i, q, (k - (N - 1)):(k + 1)]**2))
# fdata[i,q,k] = (np.mean(data[i,q,(k-(N-1)):(k+1)]))
# depending on if you want to use RMS vs just mean,
#try out with both, see what works better for you
return (fdata)
from mne.decoding import UnsupervisedSpatialFilter
from sklearn.decomposition import PCA
#of note, here PCA also allows an unsupervised Spatial Filter
pcaR = UnsupervisedSpatialFilter(PCA(3), average=False)
if hilb_type == 'amp':
pca_data_AEFL = pcaR.fit_transform(Beta[0][0][0])
pca_data_WORD = pcaR.fit_transform(Beta[0][1][0])
pca_L = np.concatenate((pca_data_AEFL, pca_data_WORD))
pca_data_AEFR = pcaR.fit_transform(Beta[1][0][0])
pca_data_WORD_R = pcaR.fit_transform(Beta[1][1][0])
pca_RR = np.concatenate((pca_data_AEFR, pca_data_WORD_R))
if hilb_type == 'phase':
pca_data_AEFL = pcaR.fit_transform(Beta[0][0][1])
pca_data_WORD = pcaR.fit_transform(Beta[0][1][1])
pca_L = np.concatenate((pca_data_AEFL, pca_data_WORD))
pca_data_AEFR = pcaR.fit_transform(Beta[1][0][1])
pca_data_WORD_R = pcaR.fit_transform(Beta[1][1][1])
pca_RR = np.concatenate((pca_data_AEFR, pca_data_WORD_R))
labelsR = labelsR[0:len(pca_RR)]
labelsL = labelsL[0:len(pca_L)]
labels_data = labelsL, labelsR
# Apply Boxcar Filter - based on boxcar length specific in upper level functions
pca_RR = Boxcar(pca_RR, boxcar)
pca_L = Boxcar(pca_L, boxcar)
return (pca_L, pca_RR, labels_data)
def ica(num_components, epochs, plot=True):
data = epochs.get_data()
ica = UnsupervisedSpatialFilter(FastICA(n_components=num_components,
max_iter=2000),
average=False)
print('fitting ica')
ica_data = ica.fit_transform(data)
print('fitting done')
info = mne.create_info(ica_data.shape[1], epochs.info['sfreq'])
if plot:
ev = mne.EvokedArray(np.mean(ica_data, axis=0), info=info)
ev.plot(show=False, window_title="ICA", time_unit='s', titles="ICA")
plt.axvline(x=0.15, color='b', linestyle='--')
plt.show()
return ica_data
def ica_filter(self, data, parameter_list):
pca = UnsupervisedSpatialFilter(FastICA(parameter_list[-1], tol=1),
average=False)
data = data[0:parameter_list[-1], :]
# print(data.shape)
eeg_data = np.array([data])
ica_data = pca.fit_transform(eeg_data)
filter_data = ica_data[0]
"""
ica = FastICA(n_components=parameter_list[-1], tol=0.1)
# print(ica.n_iter_)
data = data[0:parameter_list[-1], :].T
filter_data = ica.fit_transform(data)
print(ica.tol)
print(ica.n_iter_)
filter_data = filter_data.T
"""
return filter_data
epochs = mne.Epochs(raw,
events,
event_id,
tmin,
tmax,
proj=False,
picks=picks,
baseline=None,
preload=True,
verbose=False)
X = epochs.get_data()
##############################################################################
# Transform data with PCA computed on the average ie evoked response
pca = UnsupervisedSpatialFilter(PCA(30), average=False)
pca_data = pca.fit_transform(X)
ev = mne.EvokedArray(np.mean(pca_data, axis=0),
mne.create_info(30, epochs.info['sfreq'], ch_types='eeg'),
tmin=tmin)
ev.plot(show=False, window_title="PCA")
##############################################################################
# Transform data with ICA computed on the raw epochs (no averaging)
ica = UnsupervisedSpatialFilter(FastICA(30), average=False)
ica_data = ica.fit_transform(X)
ev1 = mne.EvokedArray(np.mean(ica_data, axis=0),
mne.create_info(30, epochs.info['sfreq'],
ch_types='eeg'),
tmin=tmin)
ev1.plot(show=False, window_title='ICA')
def decode(epochs,
get_y_label_func,
epoch_filter=None,
decoding_method='standard',
sliding_window_size=None,
sliding_window_step=None,
n_jobs=multiprocessing.cpu_count(),
equalize_event_counts=True,
only_fit=False,
generalize_across_time=True):
"""
Basic flow for decoding
"""
config = dict(equalize_event_counts=equalize_event_counts,
only_fit=only_fit,
sliding_window_size=sliding_window_size,
sliding_window_step=sliding_window_step,
decoding_method=decoding_method,
generalize_across_time=generalize_across_time,
epoch_filter=str(epoch_filter))
if epoch_filter is not None:
epochs = epochs[epoch_filter]
#-- Classify epochs into groups (training epochs)
y_labels = get_y_label_func(epochs)
if equalize_event_counts:
epochs.events[:, 2] = y_labels
epochs.event_id = {str(label): label for label in np.unique(y_labels)}
min_n_items_per_y_label = min(
[len(epochs[cond]) for cond in epochs.event_id.keys()])
print("\nEqualizing the number of epochs to %d per condition..." %
min_n_items_per_y_label)
epochs.equalize_event_counts(epochs.event_id.keys())
y_labels = epochs.events[:, 2]
print("The epochs were classified into %d groups:" % len(set(y_labels)))
for g in set(y_labels):
print("Group {:}: {:} epochs".format(g, sum(np.array(y_labels) == g)))
#-- Create the decoding pipeline
print("Creating the classification pipeline...")
epochs_data = epochs.get_data()
preprocess_pipeline = None
if decoding_method.startswith('standard'):
if 'reg' in decoding_method:
clf = make_pipeline(StandardScaler(), Ridge())
else:
clf = make_pipeline(
StandardScaler(),
svm.SVC(C=1, kernel='linear', class_weight='balanced'))
if 'raw' not in decoding_method:
assert sliding_window_size is not None
assert sliding_window_step is not None
preprocess_pipeline = \
make_pipeline(umne.transformers.SlidingWindow(window_size=sliding_window_size, step=sliding_window_step, average=True))
elif decoding_method == 'ERP_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(20), average=False),
ERPCovariances(
estimator='lwf'), # todo how to apply sliding window?
CSP(30, log=False),
TangentSpace('logeuclid'),
LogisticRegression('l2')) # todo why logistic regression?
elif decoding_method == 'Xdawn_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(50), average=False),
XdawnCovariances(12, estimator='lwf', xdawn_estimator='lwf'),
TangentSpace('logeuclid'), LogisticRegression('l2'))
elif decoding_method == 'Hankel_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(70), average=False),
HankelCovariances(delays=[1, 8, 12, 64], estimator='oas'),
CSP(15, log=False), TangentSpace('logeuclid'),
LogisticRegression('l2'))
else:
raise Exception('Unknown decoding method: {:}'.format(decoding_method))
print('\nDecoding pipeline:')
for i in range(len(clf.steps)):
print('Step #{:}: {:}'.format(i + 1, clf.steps[i][1]))
if preprocess_pipeline is not None:
print('\nApplying the pre-processing pipeline:')
for i in range(len(preprocess_pipeline.steps)):
print('Step #{:}: {:}'.format(i + 1,
preprocess_pipeline.steps[i][1]))
epochs_data = preprocess_pipeline.fit_transform(epochs_data)
if only_fit:
#-- Only fit the decoders
procedure = 'only_fit'
scores = None
cv = None
if decoding_method.startswith('standard'):
if 'reg' in decoding_method:
if 'r2' in decoding_method:
scoring = metrics.make_scorer(metrics.r2_score)
else:
scoring = metrics.make_scorer(metrics.mean_squared_error)
else:
scoring = 'accuracy'
if generalize_across_time:
estimator = GeneralizingEstimator(clf,
scoring=scoring,
n_jobs=n_jobs)
else:
estimator = SlidingEstimator(clf,
scoring=scoring,
n_jobs=n_jobs)
else:
estimator = clf
estimator.fit(X=epochs_data, y=y_labels)
else:
#-- Classify & score -- cross-validation
procedure = 'fit_and_score'
print(
"\nCreating a classifier and calculating accuracy scores (this may take some time)..."
)
cv = StratifiedKFold(n_splits=5)
if decoding_method.startswith('standard'):
if 'reg' in decoding_method:
if 'r2' in decoding_method:
scoring = metrics.make_scorer(metrics.r2_score)
else:
scoring = metrics.make_scorer(metrics.mean_squared_error)
else:
scoring = 'accuracy'
if generalize_across_time:
estimator = GeneralizingEstimator(clf,
scoring=scoring,
n_jobs=n_jobs)
else:
estimator = SlidingEstimator(clf,
scoring=scoring,
n_jobs=n_jobs)
scores = cross_val_multiscore(estimator=estimator,
X=epochs_data,
y=np.array(y_labels),
cv=cv)
else:
scores = _run_cross_validation(X=epochs_data,
y=np.array(y_labels),
clf=clf,
cv=cv)
estimator = 'None' # Estimator is not defined in the case of Riemannian decoding
times = np.linspace(epochs.tmin, epochs.tmax, epochs_data.shape[2])
return dict(procedure=procedure,
estimator=estimator,
scores=scores,
pipeline=clf,
preprocess=preprocess_pipeline,
cv=cv,
times=times,
config=config)
def pyR_decoding_on_full_epochs(X,
y,
plot_conf_matrix=0,
class_names=None,
test_size=0.2,
n_splits=5,
classifier='ERP_cov'):
""" This function decodes on the full epoch using the pyRiemannian decoder
cf https://github.com/Team-BK/Biomag2016/blob/master/Final_Submission.ipynb
Parameters
---------
X : data extracted from the epochs provided to the decoder
y : categorical variable (i.e. discrete but it can be more then 2 categories)
plot_confusion_matrix : set to 1 if you wanna see the confusion matrix
class_names: needed for the legend if confusion matrices are plotted ['cat1','cat2','cat3']
test_size : proportion of the data on which you wanna test the decoder
n_splits : when calculating the score, number of cross-validation folds
classifier : set it to 'ERP_cov', 'Xdawn_cov' or 'Hankel_cov' depending on the classification you want to do.
Returns: scores, y_test, y_pred, cnf_matrix or just scores if you don't want the confusion matrix
-------
"""
# ------- define the classifier -------
if classifier == 'ERP_cov':
spatial_filter = UnsupervisedSpatialFilter(PCA(20), average=False)
ERP_cov = ERPCovariances(estimator='lwf')
CSP_30 = CSP(30, log=False)
tang = TangentSpace('logeuclid')
clf = make_pipeline(spatial_filter, ERP_cov, CSP_30, tang,
LogisticRegression('l2'))
if classifier == 'Xdawn_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(50), average=False),
XdawnCovariances(12, estimator='lwf', xdawn_estimator='lwf'),
TangentSpace('logeuclid'), LogisticRegression('l2'))
if classifier == 'Hankel_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(70), average=False),
HankelCovariances(delays=[1, 8, 12, 64], estimator='oas'),
CSP(15, log=False), TangentSpace('logeuclid'),
LogisticRegression('l2'))
cv = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=4343)
y = np.asarray(y)
scores = []
for train_index, test_index in cv.split(X, y):
print(train_index)
print(test_index)
print('we are in the CV loop')
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
# Train on X_train, y_train
clf.fit(X_train, y_train)
# Predict the category on X_test
y_pred = clf.predict(X_test)
scores.append(accuracy_score(y_true=y_test, y_pred=y_pred))
scores = np.asarray(scores)
if plot_conf_matrix == 1:
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=test_size, random_state=7, stratify=y)
print('train and test have been split')
y_pred = clf.fit(X_train, y_train).predict(X_test)
# Compute confusion matrix
cnf_matrix = confusion_matrix(y_test, y_pred)
np.set_printoptions(precision=2)
print(cnf_matrix)
# Plot non-normalized confusion matrix
plt.figure()
plot_confusion_matrix(cnf_matrix,
classes=class_names,
title='Confusion matrix, without normalization')
# Plot normalized confusion matrix
plt.figure()
plot_confusion_matrix(cnf_matrix,
classes=class_names,
normalize=True,
title='Normalized confusion matrix')
plt.show()
return scores, y_test, y_pred, cnf_matrix
return scores, y_test, y_pred, cnf_matrix
})
timing = pd.read_csv("../eeg_tests/timing.csv")
from mne.decoding import UnsupervisedSpatialFilter
from sklearn.decomposition import PCA, FastICA
from mne.preprocessing import ICA, create_ecg_epochs
# response is probably uninteresting as an "EVENT", rather, the stimuli should probably be classified as "got right" and "got wrong" so that the averaging captures evoked responses, and so we can capture induced responses, only on those stimuli that the user noticed! Otherwise we're just watering down caught signals with missed signals.
p25_dat, epochs, events = get_user_data('P25', timing)
X = epochs["target"].get_data()
ica = UnsupervisedSpatialFilter(FastICA(), average=False)
ica_data = ica.fit_transform(X)
ev1 = mne.EvokedArray(
np.mean(ica_data, axis=0),
mne.create_info(32, epochs.info['sfreq'], ch_types='eeg'))
ev1.plot(show=False)
# filter out power-line noise
p25_dat.notch_filter(np.arange(50, 200, 50),
filter_length='auto',
phase='zero')
# band-pass 1-50 contains all the signal we like
p25_dat.filter(8,
13.,
def test_unsupervised_spatial_filter():
"""Test unsupervised spatial filter."""
from sklearn.decomposition import PCA
from sklearn.kernel_ridge import KernelRidge
raw = io.read_raw_fif(raw_fname)
events = read_events(event_name)
picks = pick_types(raw.info, meg=True, stim=False, ecg=False,
eog=False, exclude='bads')
picks = picks[1:13:3]
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
preload=True, baseline=None, verbose=False)
# Test estimator
assert_raises(ValueError, UnsupervisedSpatialFilter, KernelRidge(2))
# Test fit
X = epochs.get_data()
n_components = 4
usf = UnsupervisedSpatialFilter(PCA(n_components))
usf.fit(X)
usf1 = UnsupervisedSpatialFilter(PCA(n_components))
# test transform
assert_equal(usf.transform(X).ndim, 3)
# test fit_transform
assert_array_almost_equal(usf.transform(X), usf1.fit_transform(X))
assert_equal(usf.transform(X).shape[1], n_components)
assert_array_almost_equal(usf.inverse_transform(usf.transform(X)), X)
# Test with average param
usf = UnsupervisedSpatialFilter(PCA(4), average=True)
usf.fit_transform(X)
assert_raises(ValueError, UnsupervisedSpatialFilter, PCA(4), 2)
mne.combine_evoked([evoked_zero, -evoked_one],
weights='equal').plot_joint(**joint_kwargs)
##Apply fft
#fft_data = []
#for epochs_idx in range(len(epochs_data)):
# fft_data.append(abs(fft2(epochs_data[epochs_idx]))/sum(epochs_data[epochs_idx]))
#
#fft_data = np.array(fft_data)
##Apply PCA to the epochs_data
#pca = UnsupervisedSpatialFilter(PCA(14), average=False)
#pca_data = pca.fit_transform(epochs_data)
#Apply ICA to the epochs_data
ica = UnsupervisedSpatialFilter(FastICA(len(picks)), average=False)
ica_data = ica.fit_transform(epochs_data)
##normalizing ICA data
#for epochs_idx in range(len(ica_data)):
# for channels_idx in range(14):
# ica_data[epochs_idx,channels_idx] /= ica_data[epochs_idx].sum()
ica_data_reshape = ica_data.reshape(
(ica_data.shape[0], ica_data.shape[1] * ica_data.shape[2]))
#------------------------------------------------------------------------------
#Checking ICA through plot
method = 'fastica'
##Apply fft #fft_data = [] #for epochs_idx in range(len(epochs_data)): # fft_data.append(abs(fft2(epochs_data[epochs_idx]))/sum(epochs_data[epochs_idx])) # #fft_data = np.array(fft_data) ##Apply PCA to the epochs_data #pca = UnsupervisedSpatialFilter(PCA(14), average=False) #pca_data = pca.fit_transform(epochs_data) #Apply ICA to the epochs_data ica = UnsupervisedSpatialFilter(FastICA(len(picks)), average=False) ica_data = ica.fit_transform(epochs_data) ##normalizing ICA data #for epochs_idx in range(len(ica_data)): # for channels_idx in range(14): # ica_data[epochs_idx,channels_idx] /= ica_data[epochs_idx].sum() ica_data_reshape = ica_data.reshape((ica_data.shape[0],ica_data.shape[1]*ica_data.shape[2])) #------------------------------------------------------------------------------ #Checking ICA through plot method = 'fastica'
info = mne.create_info(ch_names=channel_names[:],
sfreq=sampling_freq,
ch_types=tipos[:],
montage='standard_1020')
channel_pos = []
for i in range(len(info['chs'])):
channel_pos.append(info['chs'][i]['loc'][:2])
datos = data['Datos']
datos = np.swapaxes(datos, 0, 2)
datos_eeg = datos[:, :-3, :]
tiempo = [i / sampling_freq for i in range(len(datos[0][0]))]
#APLICAR PCA
sk_pca = PCA()
pca = UnsupervisedSpatialFilter(sk_pca, average=False)
data_pca = pca.fit_transform(datos_eeg)
#PLOT PRINCIPAL COMPONENTS
W = sk_pca.components_
M = np.linalg.inv(W)
M = M.transpose()
fig = plt.figure(figsize=(15, 25))
for i in range(len(M)):
ax1 = fig.add_subplot(3, 9, (i + 1))
ax1.set_title('PCA {}'.format(i))
mne.viz.plot_topomap(M[i], np.array(channel_pos)[:-3], axes=ax1)
fig.tight_layout()
fig.suptitle('Principal components')
def gen_observed_dissimilarity(epochs0,
epochs1,
n_pca=30,
metric='spearmanr',
sliding_window_size=None,
sliding_window_step=None,
sliding_window_min_size=None,
debug=None):
"""
Generate the observed dissimilarity matrix
:param epochs0: Epohcs, averaged over the relevant parameters
:param epochs1: Epohcs, averaged over the relevant parameters
:param n_pca: the number of PCA components.
:param metric: The metric to use when calculating distance between instances in a feature array, for
non-Riemannian dissimilarity.
If metric is a string, it must be one of the options allowed by scipy.spatial.distance.pdist
for its metric parameter, or a metric listed in pairwise.PAIRWISE_DISTANCE_FUNCTIONS.
If metric is precomputed, X is assumed to be a distance matrix.
Alternatively, if metric is a callable function, it is called on each pair of instances (rows)
and the resulting value recorded.
The callable should take two arrays from X as input and return a value indicating the distance between them.
:param sliding_window_size: If specified (!= None), the data will be averaged using a sliding window before
computing dissimilarity. This parameter is the number of time points included in each window
:param sliding_window_step: The number of time points for sliding the window on each step
:param sliding_window_min_size: The minimal number of time points acceptable in the last step of the sliding window.
If None: min_window_size will be the same as window_size
:return: np.array
"""
#-- Validate input
assert (sliding_window_size is None) == (sliding_window_step is None), \
"Either sliding_window_size and sliding_window_step are both None, or they are both not None"
debug = debug or set()
if metric == 'mahalanobis' and n_pca is not None:
print(
'WARNING: PCA should not be used for metric=mahalanobis, ignoring this parameter'
)
n_pca = None
#-- Original data: #epochs x Channels x TimePoints
data1 = epochs0.get_data()
data2 = epochs1.get_data()
#-- z-scoring doesn't change the data dimensions
data1 = transformers.ZScoreEachChannel(
debug=debug is True or 'zscore' in debug).fit_transform(data1)
data2 = transformers.ZScoreEachChannel(
debug=debug is True or 'zscore' in debug).fit_transform(data2)
#-- Run PCA. Resulting data: Epochs x PCA-Components x TimePoints
if n_pca is not None:
pca = UnsupervisedSpatialFilter(PCA(n_pca), average=False)
combined_data = np.vstack([data1, data2])
pca.fit(combined_data)
data1 = pca.transform(data1)
data2 = pca.transform(data2)
#-- Apply a sliding window
#-- Result in non-Riemann mode: epochs x Channels/components x TimePoints
#-- todo: Result in Riemann: TimeWindows x Stimuli x Channels/components x TimePoints-within-one-window; will require SlidingWindow(average=False)
if sliding_window_size is None:
times = epochs0.times
else:
xformer = transformers.SlidingWindow(
window_size=sliding_window_size,
step=sliding_window_step,
min_window_size=sliding_window_min_size)
data1 = xformer.fit_transform(data1)
data2 = xformer.fit_transform(data2)
mid_window_inds = xformer.start_window_inds(len(
epochs0.times)) + round(sliding_window_size / 2)
times = epochs0.times[mid_window_inds]
#-- Get the dissimilarity matrix
#-- Result: Time point x epochs1 x epochs2
dissim_matrices = _compute_dissimilarity(
data1, data2, metric, debug is True or 'dissim' in debug)
# todo in Riemann: xformer = RiemannDissimilarity(metric=riemann_metric, debug=debug is True or 'dissim' in debug)
assert len(dissim_matrices) == len(
times), "There are {} dissimilarity matrices but {} times".format(
len(dissim_matrices), len(times))
return DissimilarityMatrix(dissim_matrices,
epochs0.metadata,
epochs1.metadata,
times=times,
epochs0_info=epochs0.info,
epochs1_info=epochs1.info)
def test_unsupervised_spatial_filter():
"""Test unsupervised spatial filter."""
from sklearn.decomposition import PCA
from sklearn.kernel_ridge import KernelRidge
raw = io.read_raw_fif(raw_fname)
events = read_events(event_name)
picks = pick_types(raw.info, meg=True, stim=False, ecg=False,
eog=False, exclude='bads')
picks = picks[1:13:3]
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
preload=True, baseline=None, verbose=False)
# Test estimator
assert_raises(ValueError, UnsupervisedSpatialFilter, KernelRidge(2))
# Test fit
X = epochs.get_data()
n_components = 4
usf = UnsupervisedSpatialFilter(PCA(n_components))
usf.fit(X)
usf1 = UnsupervisedSpatialFilter(PCA(n_components))
# test transform
assert_equal(usf.transform(X).ndim, 3)
# test fit_transform
assert_array_almost_equal(usf.transform(X), usf1.fit_transform(X))
# assert shape
assert_equal(usf.transform(X).shape[1], n_components)
# Test with average param
usf = UnsupervisedSpatialFilter(PCA(4), average=True)
usf.fit_transform(X)
assert_raises(ValueError, UnsupervisedSpatialFilter, PCA(4), 2)
X_raw = epochs_clean.get_data(
)[:, :, :] # MEG signals: n_epochs, n_channels, n_times (exclude non MEG channels)
y_raw = epochs_clean.events[:, 2] # Get event types
# y_raw = np.array([i for n, i in enumerate(y_raw) if n not in drop_idx])
# select events and time period of interest
event_selector = (y_raw < 23) | (y_raw == 99)
X_raw = X_raw[event_selector, ...]
y_raw = y_raw[event_selector]
X_raw = X_raw[:, 29:302, :]
# print("Number of unique events = {0}\n\nEvent types = {1}".format(len(np.unique(y_raw)),
# np.unique(y_raw))
# Do PCA with 50 components
pca = UnsupervisedSpatialFilter(PCA(50), average=False)
pca_data = pca.fit_transform(X_raw)
X_raw = pca_data
# CLASSIFIER
# Logistic regression with L2 penalty, multi-class classification performed as one-vs-rest
# Data is transformed to have zero mean and unit variance before being passed to the classifier
clf = make_pipeline(
StandardScaler(),
LogisticRegression(multi_class='multinomial',
C=0.1,
penalty='l2',
solver='saga',
tol=0.01))
raw = mne.io.read_raw_fif(raw_fname, preload=True)
raw.filter(1, 20, fir_design='firwin')
events = mne.read_events(event_fname)
picks = mne.pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False,
exclude='bads')
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=False,
picks=picks, baseline=None, preload=True,
verbose=False)
X = epochs.get_data()
##############################################################################
# Transform data with PCA computed on the average ie evoked response
pca = UnsupervisedSpatialFilter(PCA(30), average=False)
pca_data = pca.fit_transform(X)
ev = mne.EvokedArray(np.mean(pca_data, axis=0),
mne.create_info(30, epochs.info['sfreq'],
ch_types='eeg'), tmin=tmin)
ev.plot(show=False, window_title="PCA")
##############################################################################
# Transform data with ICA computed on the raw epochs (no averaging)
ica = UnsupervisedSpatialFilter(FastICA(30), average=False)
ica_data = ica.fit_transform(X)
ev1 = mne.EvokedArray(np.mean(ica_data, axis=0),
mne.create_info(30, epochs.info['sfreq'],
ch_types='eeg'), tmin=tmin)
ev1.plot(show=False, window_title='ICA')
epochs = mne.Epochs(raw,
events,
event_id,
tmin,
tmax,
proj=False,
picks=picks,
baseline=None,
preload=True,
verbose=False)
X = epochs.get_data()
##############################################################################
# Transform data with PCA computed on the average ie evoked response
pca = UnsupervisedSpatialFilter(PCA(30), average=False)
pca_data = pca.fit_transform(X)
ev = mne.EvokedArray(np.mean(pca_data, axis=0),
mne.create_info(30, epochs.info['sfreq'], ch_types='eeg'),
tmin=tmin)
ev.plot(show=False, window_title="PCA", time_unit='s')
##############################################################################
# Transform data with ICA computed on the raw epochs (no averaging)
ica = UnsupervisedSpatialFilter(FastICA(30, whiten='unit-variance'),
average=False)
ica_data = ica.fit_transform(X)
ev1 = mne.EvokedArray(np.mean(ica_data, axis=0),
mne.create_info(30, epochs.info['sfreq'],
ch_types='eeg'),
tmin=tmin)
