def main():
sample = 1
exp_name = "ICA"
epochs = get_epochs(sample)
num_components = 80
label = -1
def main():
model_type = "lda"
exp_name = "PCA/scaled/all_samples"
if exp_name.split("/")[1] == "scaled":
scaled = True
else:
scaled = False
all_sample_results = np.zeros((21, 50))
for i, sample in enumerate(range(1, 22)):
print("sample {}".format(sample))
if exp_name == "raw/all_samples":
x_train, y_train = get_raw_data(sample, scale=scaled)
else:
epochs = get_epochs(sample, scale=scaled)
reduced_data = pca(80, epochs, plot=False)
x_train = reduced_data.transpose(0, 2, 1).reshape(-1, reduced_data.shape[1])
y_train = get_y_train(sample)
results = linear_models(x_train, y_train, model_type=model_type)
all_sample_results[i] = results
sns.set()
ax = sns.lineplot(data=results, dashes=False)
ax.set(ylim=(0, 0.6), xlabel='Time', ylabel='Accuracy',
title='Cross Val Accuracy {} for sample {}'.format(model_type, sample))
plt.axvline(x=15, color='b', linestyle='--')
ax.figure.savefig("Results/{}/{}/sample{}".format(model_type, exp_name, sample), dpi=300)
# plt.show()
plt.clf()
all_results_df = pd.DataFrame(all_sample_results)
all_results_df.to_csv("Results/{}/{}/all_sample_results.csv".format(model_type, exp_name))
average_results = np.mean(all_sample_results, axis=0)
sns.set()
ax = sns.lineplot(data=average_results, dashes=False)
ax.set(ylim=(0, 0.6), xlabel='Time', ylabel='Accuracy',
title='Average Cross Val Accuracy {} across all samples'.format(model_type))
plt.axvline(x=15, color='b', linestyle='--')
ax.figure.savefig("Results/{}/{}/average_all_samples".format(model_type, exp_name), dpi=300)
# plt.show()
plt.clf()
def main():
sample = 4
model_type = "svm"
exp_name = "ICA/sample_{}".format(sample)
hps = ["linear", "poly", "rbf", "sigmoid"]
epochs = get_epochs(sample)
all_results = np.zeros((len(hps), 50))
for i, hp in enumerate(hps):
print("iteration with hp set to: {}".format(hp))
reduced_data = ica(70, epochs, plot=False)
x_train = reduced_data.transpose(0, 2,
1).reshape(-1, reduced_data.shape[1])
y_train = get_y_train(sample)
results = nonlinear_models(x_train,
y_train,
model_type=model_type,
kernel=hp)
all_results[i] = results
sns.set()
ax = sns.lineplot(data=results, dashes=False)
ax.set(ylim=(0, 0.6),
xlabel='Time',
ylabel='Accuracy',
title='Cross Val Accuracy {} and {} comps'.format(
model_type, hp))
plt.axvline(x=15, color='b', linestyle='--')
ax.figure.savefig("Results/{}/{}/kernel_{}_sample{}".format(
model_type, exp_name, hp, sample),
dpi=300)
# plt.show()
plt.clf()
all_results_df = pd.DataFrame(all_results)
all_results_df.to_csv("Results/{}/{}/all_kernels_sample{}.csv".format(
model_type, exp_name, sample))
def main():
model_type = "lda"
exp_name = "wavelet_class/lsqr/complex"
save_dir = "Results/{}/{}".format(model_type, exp_name)
sample_models = []
for sample in range(1, 22):
print("sample {}".format(sample))
epochs = get_epochs(sample, scale=False)
freqs = np.logspace(*np.log10([2, 25]), num=15)
n_cycles = freqs / 4.
print("applying morlet wavelet")
# returns (n_epochs, n_channels, n_freqs, n_times)
wavelet_output = tfr_array_morlet(epochs.get_data(),
sfreq=epochs.info['sfreq'],
freqs=freqs,
n_cycles=n_cycles,
output='complex')
y_train = get_y_train(sample)
freq_models = []
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)
reduced = pca(80, wavelet_epochs, plot=False)
x_train = reduced.transpose(0, 2, 1).reshape(-1, reduced.shape[1])
time_models = []
for time in range(50):
print("time {}".format(time))
intervals = np.arange(start=time,
stop=x_train.shape[0],
step=50)
x_sample = x_train[intervals, :]
y_sample = y_train[intervals]
model = LinearDiscriminantAnalysis(solver='lsqr',
shrinkage='auto')
model.fit(x_sample, y_sample)
time_models.append(model)
freq_models.append(time_models)
sample_models.append(freq_models)
print('saving models for sample {}'.format(sample))
pickle.dump(
freq_models,
open("{}/sample_{}/all_freq_models.pkl".format(save_dir, sample),
"wb"))
print("models saved")
print('saving models for all samples')
pickle.dump(sample_models, open("{}/all_models.pkl".format(save_dir),
"wb"))
print("models saved")
def main():
model_type = "lda"
exp_name = "freq_gen_matrix/"
for i, sample in enumerate(range(1, 22)):
print("sample {}".format(sample))
if not os.path.isdir("Results/{}/{}/sample_{}".format(
model_type, exp_name, sample)):
os.mkdir("Results/{}/{}/sample_{}".format(model_type, exp_name,
sample))
epochs = get_epochs(sample, scale=False)
y_train = epochs.events[:, 2]
freqs = np.logspace(*np.log10([2, 25]), num=15)
n_cycles = freqs / 4.
string_freqs = [round(x, 2) for x in freqs]
print("applying morlet wavelet")
wavelet_output = tfr_array_morlet(epochs.get_data(),
sfreq=epochs.info['sfreq'],
freqs=freqs,
n_cycles=n_cycles,
output='complex')
time_results = np.zeros(
(wavelet_output.shape[3], len(freqs), len(freqs)))
for time in range(wavelet_output.shape[3]):
print("time: {}".format(time))
wavelet_epochs = wavelet_output[:, :, :, time]
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)
x_train = pca(80, wavelet_epochs, plot=False)
model = LinearModel(
LinearDiscriminantAnalysis(solver='lsqr', shrinkage='auto'))
freq_gen = GeneralizingEstimator(model,
n_jobs=1,
scoring='accuracy',
verbose=True)
scores = cross_val_multiscore(freq_gen,
x_train,
y_train,
cv=5,
n_jobs=1)
scores = np.mean(scores, axis=0)
time_results[time] = scores
sns.set()
ax = sns.barplot(
np.sort(string_freqs),
np.diag(scores),
)
ax.set(ylim=(0, 0.8),
xlabel='Frequencies',
ylabel='Accuracy',
title='Cross Val Accuracy {} for Subject {} for Time {}'.
format(model_type, sample, time))
ax.axhline(0.12, color='k', linestyle='--')
ax.figure.set_size_inches(8, 6)
ax.figure.savefig(
"Results/{}/{}/sample_{}/time_{}_accuracy.png".format(
model_type, exp_name, sample, time),
dpi=300)
plt.close('all')
# plt.show()
fig, ax = plt.subplots(1, 1)
im = ax.imshow(scores,
interpolation='lanczos',
origin='lower',
cmap='RdBu_r',
extent=[2, 25, 2, 25],
vmin=0.,
vmax=0.8)
ax.set_xlabel('Testing Frequency (hz)')
ax.set_ylabel('Training Frequency (hz)')
ax.set_title(
'Frequency generalization for Subject {} at Time {}'.format(
sample, time))
plt.colorbar(im, ax=ax)
ax.grid(False)
ax.figure.savefig(
"Results/{}/{}/sample_{}/time_{}_matrix.png".format(
model_type, exp_name, sample, time),
dpi=300)
plt.close('all')
# plt.show()
time_results = time_results.reshape(time_results.shape[0], -1)
all_results_df = pd.DataFrame(time_results)
all_results_df.to_csv(
"Results/{}/{}/sample_{}/all_time_matrix_results.csv".format(
model_type, exp_name, sample))
def main():
model_type = "lda"
exp_name = "wavelet_class/lsqr/complex/15hz"
for sample in range(1, 22):
print("sample {}".format(sample))
if not os.path.isdir("Results/{}/{}/sample_{}".format(
model_type, exp_name, sample)):
os.mkdir("Results/{}/{}/sample_{}".format(model_type, exp_name,
sample))
epochs = get_epochs(sample, scale=False)
freqs = np.logspace(*np.log10([2, 15]), num=15)
n_cycles = freqs / 4.
print("applying morlet wavelet")
# returns (n_epochs, n_channels, n_freqs, n_times)
if exp_name.split("/")[-2] == "real" or exp_name.split(
"/")[-2] == "complex":
wavelet_output = tfr_array_morlet(epochs.get_data(),
sfreq=epochs.info['sfreq'],
freqs=freqs,
n_cycles=n_cycles,
output='complex')
elif exp_name.split("/")[-2] == "power":
wavelet_output = tfr_array_morlet(epochs.get_data(),
sfreq=epochs.info['sfreq'],
freqs=freqs,
n_cycles=n_cycles,
output='power')
elif exp_name.split("/")[-2] == "phase":
wavelet_output = tfr_array_morlet(epochs.get_data(),
sfreq=epochs.info['sfreq'],
freqs=freqs,
n_cycles=n_cycles,
output='phase')
else:
raise ValueError("{} not an output of wavelet function".format(
exp_name.split("/")[-2]))
y_train = get_y_train(sample)
freq_results = np.zeros((wavelet_output.shape[2], 50))
for freq in range(wavelet_output.shape[2]):
print("frequency: {}".format(freqs[freq]))
wavelet_epochs = wavelet_output[:, :, freq, :]
if exp_name.split("/")[-2] == "real":
wavelet_epochs = wavelet_epochs.real
if exp_name.split("/")[-2] == "complex":
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)
reduced = pca(80, wavelet_epochs, plot=False)
x_train = reduced.transpose(0, 2, 1).reshape(-1, reduced.shape[1])
results = linear_models(x_train, y_train, model_type=model_type)
freq_results[freq] = results
curr_freq = str(round(freqs[freq], 2))
sns.set()
ax = sns.lineplot(data=results, dashes=False)
ax.set(ylim=(0, 1),
xlabel='Time',
ylabel='Accuracy',
title='Cross Val Accuracy {} for Subject {} for Freq {}'.
format(model_type, sample, curr_freq))
plt.axvline(x=15, color='b', linestyle='--')
ax.figure.savefig("Results/{}/{}/sample_{}/freq_{}.png".format(
model_type, exp_name, sample, curr_freq),
dpi=300)
plt.clf()
all_results_df = pd.DataFrame(freq_results)
all_results_df.to_csv(
"Results/{}/{}/sample_{}/all_freq_results.csv".format(
model_type, exp_name, sample))