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)
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)
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 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_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 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 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 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 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_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
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
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')
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'
random_state = 42
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')
#PLOT RAW DATA AND PRINCIPAL COMPONENTS FOR 1 TRIAL EVERY CHANNEL
)[:, :, :] # 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))
# Try classifying at all time points with 5 fold CV
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')
plt.show()
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), average=False)
ica_data = ica.fit_transform(X) # (288, 30, 61)
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', time_unit='s')
