# Cross validator cv = StratifiedKFold(y=labels, n_folds=10, shuffle=True, random_state=42) # Do cross-validation preds = np.empty(len(labels)) for train, test in cv: clf.fit(epochs[train], labels[train]) preds[test] = clf.predict(epochs[test]) # Classification report target_names = ['aud_l', 'aud_r', 'vis_l', 'vis_r'] report = classification_report(labels, preds, target_names=target_names) print(report) # Normalized confusion matrix cm = confusion_matrix(labels, preds) cm_normalized = cm.astype(float) / cm.sum(axis=1)[:, np.newaxis] # Plot confusion matrix plt.imshow(cm_normalized, interpolation='nearest', cmap=plt.cm.Blues) plt.title('Normalized Confusion matrix') plt.colorbar() tick_marks = np.arange(len(target_names)) plt.xticks(tick_marks, target_names, rotation=45) plt.yticks(tick_marks, target_names) tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') plt.show()
def main(args): data_dir = args.data_dir figure_path = args.figure_dir model_path = args.model_dir # Generate the parameters class. parameters = SPoC_params( subject_n=args.sub, hand=args.hand, duration=args.duration, overlap=args.overlap, y_measure=args.y_measure, alpha=args.alpha, ) # Import and epoch the MEG data X_train, y_train, _ = import_MEG_within_subject_ivan( data_dir, args.sub, args.hand, "train") X_valid, y_valid, _ = import_MEG_within_subject_ivan( data_dir, args.sub, args.hand, "val") X_test, y_test, _ = import_MEG_within_subject_ivan(data_dir, args.sub, args.hand, "test") # Select hand X_train, y_train = ( np.array(X_train.squeeze()).astype(np.float64), np.array(y_train[..., args.hand].squeeze()).astype(np.float64), ) X_valid, y_valid = ( np.array(X_valid.squeeze()).astype(np.float64), np.array(y_valid[..., args.hand].squeeze()).astype(np.float64), ) X_test, y_test = ( np.array(X_test.squeeze()).astype(np.float64), np.array(y_test[..., args.hand].squeeze()).astype(np.float64), ) print("Processing hand {}".format("sx" if parameters.hand == 0 else "dx")) print( "X_train shape {}, y_train shape {} \n X_test shape {}, y_test shape {}" .format(X_train.shape, y_train.shape, X_test.shape, y_test.shape)) start = time.time() print("Start Fitting model ...") best_pipeline = None best_mse_valid = np.Inf best_rmse_valid = 0 best_r2_valid = 0 best_alpha = 0 best_n_comp = 0 for n_components in np.arange(2, 30, 4): for alpha in [0.8, 1.0, 5, 10]: pipeline = Pipeline([ ( "Spoc", SPoC( log=True, reg="oas", rank="full", n_components=int(n_components), ), ), ("Ridge", Ridge(alpha=alpha)), ]) pipeline.fit(X_train, y_train) # Validate the pipeline print("evaluation parameters n_comp :{}, alpha {}".format( n_components, alpha)) y_new = pipeline.predict(X_valid) mse = mean_squared_error(y_valid, y_new) rmse = mean_squared_error(y_valid, y_new, squared=False) # mae = mean_absolute_error(y_test, y_new) r2 = r2_score(y_valid, y_new) if mse < best_mse_valid: print("saving new best model mse {} ---> {}".format( best_mse_valid, mse)) best_pipeline = pipeline best_mse_valid = mse best_r2_valid = r2 best_rmse_valid = rmse best_alpha = alpha best_n_comp = n_components print(f"Training time : {time.time() - start}s ") print("Best compination of parameters:") print("Number of components: ", best_n_comp) print("Alpha: ", best_alpha) print("Validation set") print("mean squared error valid {}".format(best_mse_valid)) print("root mean squared error valid{}".format(best_rmse_valid)) print("r2 score {}".format(best_r2_valid)) #%% # Test the pipeline print("Test set") y_new = best_pipeline.predict(X_test) mse = mean_squared_error(y_test, y_new) rmse = mean_squared_error(y_test, y_new, squared=False) # mae = mean_absolute_error(y_test, y_new) r2 = r2_score(y_test, y_new) print("mean squared error {}".format(mse)) print("root mean squared error {}".format(rmse)) # print("mean absolute error {}".format(mae)) print("r2 score {}".format(r2)) #%% # Plot the y expected vs y predicted. fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(100) ax.plot(times, y_new[100:200], color="b", label="Predicted") ax.plot(times, y_test[100:200], color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("{}".format(parameters.y_measure)) ax.set_title("SPoC: Sub {}, hand {}, {} prediction".format( str(parameters.subject_n), "sx" if parameters.hand == 0 else "dx", parameters.y_measure, )) plt.legend() viz.tight_layout() plt.savefig(os.path.join(figure_path, "MEG_SPoC_focus.pdf")) plt.show() # plot y_new against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(len(y_new)) ax.plot(times, y_new, color="b", label="Predicted") ax.plot(times, y_test, color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("{}".format(parameters.y_measure)) ax.set_title("Sub {}, hand {}, {} prediction".format( str(parameters.subject_n), "sx" if parameters.hand == 0 else "dx", parameters.y_measure, )) plt.legend() plt.savefig(os.path.join(figure_path, "MEG_SPoC.pdf")) plt.show() # scatterplot y predicted against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) ax.scatter(np.array(y_test), np.array(y_new), color="b", label="Predicted") ax.set_xlabel("True") ax.set_ylabel("Predicted") # plt.legend() plt.savefig(os.path.join(figure_path, "Scatter.pdf")) plt.show() # %% # Save the model. name = "MEG_SPoC.p" save_skl_model(best_pipeline, model_path, name) # log the model with mlflow.start_run(experiment_id=args.experiment) as run: for key, value in vars(parameters).items(): mlflow.log_param(key, value) mlflow.log_metric("MSE", mse) mlflow.log_metric("RMSE", rmse) # mlflow.log_metric('MAE', mae) mlflow.log_metric("R2", r2) mlflow.log_metric("RMSE_v", best_rmse_valid) mlflow.log_metric("R2_v", best_r2_valid) mlflow.log_param("n_components", best_n_comp) mlflow.log_param("alpha", best_alpha) mlflow.log_artifact(os.path.join(figure_path, "MEG_SPoC_focus.pdf")) mlflow.log_artifact(os.path.join(figure_path, "MEG_SPoC.pdf")) mlflow.sklearn.log_model(best_pipeline, "models")
# Cross validator cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=42) # Do cross-validation preds = np.empty(len(labels)) for train, test in cv.split(epochs, labels): clf.fit(epochs[train], labels[train]) preds[test] = clf.predict(epochs[test]) # Classification report target_names = ['aud_l', 'aud_r', 'vis_l', 'vis_r'] report = classification_report(labels, preds, target_names=target_names) print(report) # Normalized confusion matrix cm = confusion_matrix(labels, preds) cm_normalized = cm.astype(float) / cm.sum(axis=1)[:, np.newaxis] # Plot confusion matrix plt.imshow(cm_normalized, interpolation='nearest', cmap=plt.cm.Blues) plt.title('Normalized Confusion matrix') plt.colorbar() tick_marks = np.arange(len(target_names)) plt.xticks(tick_marks, target_names, rotation=45) plt.yticks(tick_marks, target_names) tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') plt.show()
def plot_temporal_clusters(good_cluster_inds, evokeds, T_obs, clusters, times, info): colors = {"low": "crimson", "high": "steelblue"} # linestyles = {"low": "-", "high": "--"} # # loop over clusters for i_clu, clu_idx in enumerate(good_cluster_inds): # unpack cluster information, get unique indices time_inds, space_inds = np.squeeze(clusters[clu_idx]) ch_inds = np.unique(space_inds) time_inds = np.unique(time_inds) # get topography for F stat f_map = T_obs[time_inds, ...].mean(axis=0) # get signals at the sensors contributing to the cluster sig_times = times[time_inds] # create spatial mask mask = np.zeros((f_map.shape[0], 1), dtype=bool) mask[ch_inds, :] = True # initialize figure fig, ax_topo = plt.subplots(1, 1, figsize=(10, 3)) # plot average test statistic and mark significant sensors f_evoked = EvokedArray(f_map[:, np.newaxis], info, tmin=0) f_evoked.plot_topomap( times=0, mask=mask, axes=ax_topo, cmap="Reds", vmin=np.min, vmax=np.max, show=False, colorbar=False, mask_params=dict(markersize=10), scalings=dict(eeg=1, mag=1, grad=1), res=240, ) image = ax_topo.images[0] # create additional axes (for ERF and colorbar) divider = make_axes_locatable(ax_topo) # add axes for colorbar ax_colorbar = divider.append_axes("right", size="5%", pad=0.05) plt.colorbar(image, cax=ax_colorbar) ax_topo.set_xlabel( "Averaged F-map ({:0.3f} - {:0.3f} s)".format(*sig_times[[0, -1]])) # add new axis for time courses and plot time courses ax_signals = divider.append_axes("right", size="300%", pad=1.2) title = "Cluster #{0}, {1} sensor".format(i_clu + 1, len(ch_inds)) if len(ch_inds) > 1: title += "s (mean)" plot_compare_evokeds( evokeds, title=title, picks=ch_inds, axes=ax_signals, colors=colors, # linestyles=linestyles, show=False, split_legend=True, truncate_yaxis="auto", ) # plot temporal cluster extent ymin, ymax = ax_signals.get_ylim() ax_signals.fill_betweenx( (ymin, ymax), sig_times[0], sig_times[-1], color="orange", alpha=0.3, ) # clean up viz tight_layout(fig=fig) fig.subplots_adjust(bottom=0.05) plt.show()
This example shows how to display topographies of SSP projection vectors. The projections used are the ones correcting for ECG artifacts. """ # Author: Alexandre Gramfort <*****@*****.**> # Denis A. Engemann <*****@*****.**> # License: BSD (3-clause) print(__doc__) import matplotlib.pyplot as plt from mne import read_proj, find_layout from mne.io import read_evokeds from mne.datasets import sample from mne import viz data_path = sample.data_path() ecg_fname = data_path + "/MEG/sample/sample_audvis_ecg_proj.fif" ave_fname = data_path + "/MEG/sample/sample_audvis-ave.fif" evoked = read_evokeds(ave_fname, condition="Left Auditory") projs = read_proj(ecg_fname) layouts = [find_layout(evoked.info, k) for k in "meg", "eeg"] plt.figure(figsize=(12, 6)) viz.plot_projs_topomap(projs, layout=layouts) viz.tight_layout(w_pad=0.5)
def main(args): data_dir = args.data_dir figure_path = args.figure_dir model_path = args.model_dir file_name = "data.hdf5" # Generate the parameters class. parameters = SPoC_params( subject_n=args.sub, hand=args.hand, duration=args.duration, overlap=args.overlap, y_measure=args.y_measure, alpha=args.alpha, ) X_train, y_train, _ = import_MEG_cross_subject_train( data_dir, file_name, parameters.subject_n, parameters.hand) X_test, y_test, _ = import_MEG_cross_subject_test(data_dir, file_name, parameters.subject_n, parameters.hand) # Required conversion and double float precision. if parameters.hand == 0: X_train, y_train = ( np.array(X_train.squeeze()).astype(np.float64), np.array(y_train[..., 0].squeeze()).astype(np.float64), ) X_test, y_test = ( np.array(X_test.squeeze()).astype(np.float64), np.array(y_test[..., 0].squeeze()).astype(np.float64), ) else: X_train, y_train = ( np.array(X_train.squeeze()).astype(np.float64), np.array(y_train[..., 1].squeeze()).astype(np.float64), ) X_test, y_test = ( np.array(X_test.squeeze()).astype(np.float64), np.array(y_test[..., 1].squeeze()).astype(np.float64), ) # Add the transfer part to the train_set test_len, transfer_len = len_split_cross(X_test.shape[0]) X_transfer = X_test[:transfer_len, ...] X_test = X_test[transfer_len:, ...] X_train = np.concatenate((X_train, X_transfer), axis=0) y_transfer = y_test[:transfer_len, ...] y_test = y_test[transfer_len:, ...] y_train = np.concatenate((y_train, y_transfer), axis=0) print("Processing hand {}".format("sx" if parameters.hand == 0 else "dx")) print( "X_train shape {}, y_train shape {} \n X_test shape {}, y_test shape {}" .format(X_train.shape, y_train.shape, X_test.shape, y_test.shape)) pipeline = Pipeline([ ("Spoc", SPoC(log=True, reg="oas", rank="full")), ("Ridge", Ridge(alpha=parameters.alpha)), ]) # %% # Initialize the cross-validation pipeline and grid search cv = KFold(n_splits=5, shuffle=False) tuned_parameters = [{ "Spoc__n_components": list(map(int, list(np.arange(1, 30, 5)))) }] clf = GridSearchCV( pipeline, tuned_parameters, scoring=["neg_mean_squared_error", "r2"], n_jobs=-1, cv=cv, refit="neg_mean_squared_error", verbose=3, ) #%% # Tune the pipeline start = time.time() print("Start Fitting model ...") clf.fit(X_train, y_train) print(clf) print(f"Training time : {time.time() - start}s ") print("Number of cross-validation splits folds/iteration: {}".format( clf.n_splits_)) print("Best Score and parameter combination: ") print(clf.best_score_) print(clf.best_params_["Spoc__n_components"]) print("CV results") print(clf.cv_results_) print("Number of splits") print(clf.n_splits_) #%% # Validate the pipeline y_new = clf.predict(X_test) mse = mean_squared_error(y_test, y_new) rmse = mean_squared_error(y_test, y_new, squared=False) mae = mean_absolute_error(y_test, y_new) r2 = r2_score(y_test, y_new) print("mean squared error {}".format(mse)) print("root mean squared error {}".format(rmse)) print("mean absolute error {}".format(mae)) print("r2 score {}".format(r2)) #%% # Plot the y expected vs y predicted. fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(100) ax.plot(times, y_new[100:200], color="b", label="Predicted") ax.plot(times, y_test[100:200], color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("{}".format(parameters.y_measure)) ax.set_title("SPoC: Sub {}, hand {}, {} prediction".format( str(parameters.subject_n), "sx" if parameters.hand == 0 else "dx", parameters.y_measure, )) plt.legend() viz.tight_layout() plt.savefig(os.path.join(figure_path, "MEG_SPoC_focus.pdf")) plt.show() # plot y_new against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(len(y_new)) ax.plot(times, y_new, color="b", label="Predicted") ax.plot(times, y_test, color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("{}".format(parameters.y_measure)) ax.set_title("Sub {}, hand {}, {} prediction".format( str(parameters.subject_n), "sx" if parameters.hand == 0 else "dx", parameters.y_measure, )) plt.legend() plt.savefig(os.path.join(figure_path, "MEG_SPoC.pdf")) plt.show() # scatterplot y predicted against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) ax.scatter(np.array(y_test), np.array(y_new), color="b", label="Predicted") ax.set_xlabel("True") ax.set_ylabel("Predicted") # plt.legend() plt.savefig(os.path.join(figure_path, "Scatter.pdf")) plt.show() # %% n_components = np.ma.getdata(clf.cv_results_["param_Spoc__n_components"]) MSE_valid = clf.cv_results_["mean_test_neg_mean_squared_error"][0] R2_valid = clf.cv_results_["mean_test_r2"][0] # %% # Save the model. name = "MEG_SPoC.p" save_skl_model(clf, model_path, name) # log the model with mlflow.start_run(experiment_id=args.experiment) as run: for key, value in vars(parameters).items(): mlflow.log_param(key, value) mlflow.log_metric("MSE", mse) mlflow.log_metric("RMSE", rmse) mlflow.log_metric("MAE", mae) mlflow.log_metric("R2", r2) mlflow.log_metric("RMSE_Valid", MSE_valid) mlflow.log_metric("R2_Valid", R2_valid) mlflow.log_param("n_components", clf.best_params_["Spoc__n_components"]) mlflow.log_param("alpha", parameters.alpha) mlflow.log_artifact(os.path.join(figure_path, "MEG_SPoC_focus.pdf")) mlflow.log_artifact(os.path.join(figure_path, "MEG_SPoC.pdf")) mlflow.log_artifact( os.path.join(figure_path, "MEG_SPoC_Components_Analysis.pdf")) mlflow.sklearn.log_model(clf, "models")
ax_topo.set_xlabel( 'Averaged F-map ({:0.3f} - {:0.3f} s)'.format(*sig_times[[0, -1]])) # add new axis for time courses and plot time courses ax_signals = divider.append_axes('right', size='300%', pad=1.2) title = 'Cluster #{0}, {1} sensor'.format(i_clu + 1, len(ch_inds)) if len(ch_inds) > 1: title += "s (mean)" plot_compare_evokeds(evokeds, title=title, picks=ch_inds, axes=ax_signals, colors=colors, linestyles=linestyles, show=False, split_legend=True, truncate_yaxis='auto') # plot temporal cluster extent ymin, ymax = ax_signals.get_ylim() ax_signals.fill_betweenx((ymin, ymax), sig_times[0], sig_times[-1], color='orange', alpha=0.3) # clean up viz tight_layout(fig=fig) fig.subplots_adjust(bottom=.05) plt.show()
def main(args): data_dir = args.data_dir figure_path = args.figure_dir model_path = args.model_dir # Generate the parameters class. parameters = SPoC_params( subject_n=args.sub, hand=args.hand, duration=args.duration, overlap=args.overlap, y_measure=args.y_measure, alpha=0, ) # Import and epoch the MEG data _, y_train, rps_train = import_MEG_within_subject_ivan( data_dir, args.sub, args.hand, "train") _, y_val, rps_val = import_MEG_within_subject_ivan(data_dir, args.sub, args.hand, "val") _, y_test, rps_test = import_MEG_within_subject_ivan( data_dir, args.sub, args.hand, "test") # Select hand rps_train = rps_train.reshape(rps_train.shape[0], -1) rps_val = rps_val.reshape(rps_val.shape[0], -1) rps_test = rps_test.reshape(rps_test.shape[0], -1) rps_train = np.array(rps_train).astype(np.float64) y_train = np.array(y_train[..., args.hand].squeeze()).astype(np.float64) rps_val = np.array(rps_val).astype(np.float64) y_val = np.array(y_val[..., args.hand].squeeze()).astype(np.float64) rps_test = np.array(rps_test).astype(np.float64) y_test = np.array(y_test[..., args.hand].squeeze()).astype(np.float64) print("Processing hand {}".format("sx" if parameters.hand == 0 else "dx")) start = time.time() print("Start Fitting model ...") best_pipeline = None best_mse_valid = np.Inf best_rmse_valid = 0 best_r2_valid = 0 best_alpha = 0 best_n_comp = 0 # for _C in [2, 10, 30, 50, 100]: for _C in [2, 10, 30, 50, 100]: print("Processing C = ", _C) regressor = SVR(kernel='rbf', C=_C) regressor.fit(rps_train, y_train) # Validate the pipeline print("evaluation parameters C :{}".format(_C)) y_new = regressor.predict(rps_val) mse = mean_squared_error(y_val, y_new) rmse = mean_squared_error(y_val, y_new, squared=False) # mae = mean_absolute_error(y_test, y_new) r2 = r2_score(y_val, y_new) if mse < best_mse_valid: print("saving new best model mse {} ---> {}".format( best_mse_valid, mse)) best_regressor = regressor best_mse_valid = mse best_r2_valid = r2 best_rmse_valid = rmse best_C = _C print(f"Training time : {time.time() - start}s ") print("Best parameter C: ", best_C) print("Validation set") print("mean squared error valid {}".format(best_mse_valid)) print("root mean squared error valid{}".format(best_rmse_valid)) print("r2 score {}".format(best_r2_valid)) #%% # Test the pipeline print("Test set") y_new = best_regressor.predict(rps_test) mse = mean_squared_error(y_test, y_new) rmse = mean_squared_error(y_test, y_new, squared=False) # mae = mean_absolute_error(y_test, y_new) r2 = r2_score(y_test, y_new) print("mean squared error {}".format(mse)) print("root mean squared error {}".format(rmse)) # print("mean absolute error {}".format(mae)) print("r2 score {}".format(r2)) #%% # Plot the y expected vs y predicted. fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(100) ax.plot(times, y_new[100:200], color="b", label="Predicted") ax.plot(times, y_test[100:200], color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("{}".format(parameters.y_measure)) ax.set_title("SVM: Sub {}, hand {}, {} prediction".format( str(parameters.subject_n), "sx" if parameters.hand == 0 else "dx", parameters.y_measure, )) plt.legend() viz.tight_layout() plt.savefig(os.path.join(figure_path, "MEG_SVM_focus.pdf")) plt.show() # plot y_new against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(len(y_new)) ax.plot(times, y_new, color="b", label="Predicted") ax.plot(times, y_test, color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("{}".format(parameters.y_measure)) ax.set_title("Sub {}, hand {}, {} prediction".format( str(parameters.subject_n), "sx" if parameters.hand == 0 else "dx", parameters.y_measure, )) plt.legend() plt.savefig(os.path.join(figure_path, "MEG_SVM.pdf")) plt.show() # scatterplot y predicted against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) ax.scatter(np.array(y_test), np.array(y_new), color="b", label="Predicted") ax.set_xlabel("True") ax.set_ylabel("Predicted") # plt.legend() plt.savefig(os.path.join(figure_path, "Scatter.pdf")) plt.show() # %% # Save the model. name = "MEG_SVR.p" save_skl_model(best_pipeline, model_path, name) # log the model with mlflow.start_run(experiment_id=args.experiment) as run: for key, value in vars(parameters).items(): mlflow.log_param(key, value) mlflow.log_metric("MSE", mse) mlflow.log_metric("RMSE", rmse) # mlflow.log_metric('MAE', mae) mlflow.log_metric("R2", r2) mlflow.log_metric("RMSE_v", best_rmse_valid) mlflow.log_metric("R2_v", best_r2_valid) mlflow.log_param("C", best_C) mlflow.log_artifact(os.path.join(figure_path, "MEG_SVM_focus.pdf")) mlflow.log_artifact(os.path.join(figure_path, "MEG_SVM.pdf")) mlflow.sklearn.log_model(best_pipeline, "models")
def main(args): data_dir = args.data_dir figure_path = args.figure_dir model_path = args.model_dir parameters = SPoC_params( subject_n=args.sub, finger=args.finger, duration=args.duration, overlap=args.overlap, ) #%% file_name = "/sub" + str(parameters.subject_n) + "_comp.mat" sampling_rate = 1000 #%% # import ECoG <-- datadir, filename, finger, duration, overlap, normalize_input=True, y_measure="mean" X, y = import_ECoG( data_dir, file_name, parameters.finger, parameters.duration, parameters.overlap, ) # %% print("X shape {}, y shape {}".format(X.shape, y.shape)) X_train, X_test, y_train, y_test = split_data(X, y, 0.3) print( "X_train shape {}, y_train shape {} \n X_test shape {}, y_test shape {}" .format(X_train.shape, y_train.shape, X_test.shape, y_test.shape)) pipeline = Pipeline([("Spoc", SPoC(log=True, reg="oas", rank="full")), ("Ridge", Ridge())]) # %% cv = KFold(n_splits=10, shuffle=False) tuned_parameters = [{ "Spoc__n_components": list(map(int, list(np.arange(2, 30)))), "Ridge__alpha": [0.8, 1.0, 2, 5, 10, 15], }] clf = GridSearchCV( pipeline, tuned_parameters, scoring="neg_mean_squared_error", n_jobs=4, cv=cv, verbose=3, ) # %% start = time.time() print("Start Fitting model ...") clf.fit(X_train, y_train) print(f"Training time : {time.time() - start}s ") print("Number of cross-validation splits folds/iteration: {}".format( clf.n_splits_)) print("Best Score and parameter combination: ") print(clf.best_score_) print(clf.best_params_["Spoc__n_components"]) # %% y_new = clf.predict(X_test) mse = mean_squared_error(y_test, y_new) rmse = mean_squared_error(y_test, y_new, squared=False) mae = mean_absolute_error(y_test, y_new) print("mean squared error {}".format(mse)) print("root mean squared error {}".format(rmse)) print("mean absolute error {}".format(mae)) # %% fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(100) ax.plot(times, y_new[100:200], color="b", label="Predicted") ax.plot(times, y_test[100:200], color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("Finger Movement") ax.set_title("Sub {}, finger {} prediction".format( str(parameters.subject_n), parameters.finger)) plt.legend() viz.tight_layout() plt.savefig(os.path.join(figure_path, "ECoG_SPoC_focus.pdf")) plt.show() # plot y_new against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(len(y_new)) ax.plot(times, y_new, color="b", label="Predicted") ax.plot(times, y_test, color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("Finger Movement") ax.set_title("Sub {}, finger {} prediction".format( str(parameters.subject_n), parameters.finger)) plt.legend() plt.savefig(os.path.join(figure_path, "ECoG_SPoC.pdf")) plt.show() # %% n_components = np.ma.getdata(clf.cv_results_["param_Spoc__n_components"]) MSEs = clf.cv_results_["mean_test_score"] # %% fig, ax = plt.subplots(1, 1, figsize=[10, 4]) ax.plot(n_components, MSEs, color="b") ax.set_xlabel("Number of SPoC components") ax.set_ylabel("MSE") ax.set_title("SPoC Components Analysis") # plt.legend() plt.xticks(n_components, n_components) viz.tight_layout() plt.savefig(os.path.join(figure_path, "ECoG_SPoC_Components_Analysis.pdf")) plt.show() # %% name = "ECoG_SPoC.p" save_skl_model(clf, model_path, name) # log the model with mlflow.start_run(experiment_id=args.experiment) as run: for key, value in vars(parameters).items(): mlflow.log_param(key, value) mlflow.log_metric("MSE", mse) mlflow.log_metric("RMSE", rmse) mlflow.log_metric("MAE", mae) mlflow.log_param("n_components", clf.best_params_["Spoc__n_components"]) mlflow.log_artifact(os.path.join(figure_path, "ECoG_SPoC_focus.pdf")) mlflow.log_artifact(os.path.join(figure_path, "ECoG_SPoC.pdf")) mlflow.log_artifact( os.path.join(figure_path, "ECoG_SPoC_Components_Analysis.pdf")) mlflow.sklearn.log_model(clf, "models")
================================= This example shows how to display topographies of SSP projection vectors. The projections used are the ones correcting for ECG artifacts. """ # Author: Alexandre Gramfort <*****@*****.**> # Denis A. Engemann <*****@*****.**> # License: BSD (3-clause) print(__doc__) import matplotlib.pyplot as plt from mne import read_proj, find_layout from mne.io import read_evokeds from mne.datasets import sample from mne import viz data_path = sample.data_path() ecg_fname = data_path + '/MEG/sample/sample_audvis_ecg_proj.fif' ave_fname = data_path + '/MEG/sample/sample_audvis-ave.fif' evoked = read_evokeds(ave_fname, condition='Left Auditory') projs = read_proj(ecg_fname) layouts = [find_layout(evoked.info, k) for k in 'meg', 'eeg'] plt.figure(figsize=(12, 6)) viz.plot_projs_topomap(projs, layout=layouts) viz.tight_layout(w_pad=0.5)
rmse = mean_squared_error(y, y_pred, squared=False) mae = mean_absolute_error(y, y_pred) print("mean squared error {}".format(mse)) print("root mean squared error {}".format(rmse)) print("mean absolute error {}".format(mae)) fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(100) ax.plot(times, np.array(y_pred[100:200]), color="b", label="Predicted") ax.plot(times, np.array(y[100:200]), color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("Finger Movement") ax.set_title("Sub {}, finger {} prediction".format( str(parameters.subject_n), parameters.finger)) plt.legend() viz.tight_layout() plt.savefig(os.path.join(figure_path, "ECoG_DL_focus.pdf")) plt.show() # plot y_new against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(len(y_pred)) ax.plot(times, np.array(y_pred), color="b", label="Predicted") ax.plot(times, np.array(y), color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("Finger Movement") ax.set_title("Sub {}, finger {} prediction".format( str(parameters.subject_n), parameters.finger)) plt.legend() plt.savefig(os.path.join(figure_path, "ECoG_DL.pdf")) plt.show()
def main(args): data_dir = args.data_dir figure_path = args.figure_dir model_path = args.model_dir # Generate the parameters class. parameters = SPoC_params(subject_n=8, hand=0, duration=1., overlap=0.8, y_measure=args.y_measure) # Generate list of input files subj_id = "/sub"+str(args.sub)+"/ball0" raw_fnames = ["".join([data_dir, subj_id, str(i), "_sss_trans.fif"]) for i in range(1 if args.sub != 3 else 2, 4)] # LOCAL # subj_n = 8 # subj_id = "sub" + str(subj_n) + "\\ball" # raw_fnames = ["".join([data_dir, subj_id, str(i), "_sss.fif"]) for i in range(1, 2)] # Import and epoch the MEG data X, y_left, y_right = import_MEG_no_bp(raw_fnames, duration=parameters.duration, overlap=parameters.overlap, y_measure=parameters.y_measure, normalize_input=True) # concentrate the analysis only on the left hand print('X shape {}, y shape {}'.format(X.shape, y_left.shape)) # Select hand if parameters.hand == 0: X_train, X_test, y_train, y_test = split_data(X, y_left, 0.3) else: X_train, X_test, y_train, y_test = split_data(X, y_right, 0.3) X_train, X_test = np.reshape(X_train, (X_train.shape[0], -1)), np.reshape(X_test, (X_test.shape[0], -1)) print("Processing hand {}".format("sx" if parameters.hand == 0 else "dx")) print('X_train shape {}, y_train shape {} \n X_test shape {}, y_test shape {}'.format(X_train.shape, y_train.shape, X_test.shape, y_test.shape)) reg = LinearRegression() #%% # Tune the pipeline start = time.time() print('Start Fitting model ...') reg.fit(X_train, y_train) print(f'Training time : {time.time() - start}s ') #%% # Validate the pipeline y_new = reg.predict(X_test) mse = mean_squared_error(y_test, y_new) rmse = mean_squared_error(y_test, y_new, squared=False) mae = mean_absolute_error(y_test, y_new) r2 = r2_score(y_test, y_new) print("mean squared error {}".format(mse)) print("root mean squared error {}".format(rmse)) print("mean absolute error {}".format(mae)) print("r2 score {}".format(r2)) #%% # Plot the y expected vs y predicted. fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(100) ax.plot(times, y_new[100:200], color='b', label='Predicted') ax.plot(times, y_test[100:200], color='r', label='True') ax.set_xlabel("Times") ax.set_ylabel("{}".format(parameters.y_measure)) ax.set_title("SPoC: Sub {}, hand {}, {} prediction".format(str(parameters.subject_n), "sx" if parameters.hand == 0 else "dx", parameters.y_measure)) plt.legend() viz.tight_layout() plt.savefig(os.path.join(figure_path, 'MEG_SPoC_focus.pdf')) plt.show() # plot y_new against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) times = np.arange(len(y_new)) ax.plot(times, y_new, color="b", label="Predicted") ax.plot(times, y_test, color="r", label="True") ax.set_xlabel("Times") ax.set_ylabel("{}".format(parameters.y_measure)) ax.set_title("Sub {}, hand {}, {} prediction".format(str(parameters.subject_n), "sx" if parameters.hand == 0 else "dx", parameters.y_measure)) plt.legend() plt.savefig(os.path.join(figure_path, 'MEG_SPoC.pdf')) plt.show() # scatterplot y predicted against the true value fig, ax = plt.subplots(1, 1, figsize=[10, 4]) ax.scatter(np.array(y_test), np.array(y_new), color="b", label="Predicted") ax.set_xlabel("True") ax.set_ylabel("Predicted") # plt.legend() plt.savefig(os.path.join(figure_path, "Scatter.pdf")) plt.show() # %% # Save the model. name = 'MEG_SPoC.p' save_skl_model(reg, model_path, name) # log the model with mlflow.start_run(experiment_id=args.experiment) as run: for key, value in vars(parameters).items(): mlflow.log_param(key, value) mlflow.log_metric('MSE', mse) mlflow.log_metric('RMSE', rmse) mlflow.log_metric('MAE', mae) mlflow.log_metric('R2', r2) mlflow.log_artifact(os.path.join(figure_path, 'MEG_SPoC_focus.pdf')) mlflow.log_artifact(os.path.join(figure_path, 'MEG_SPoC.pdf')) mlflow.log_artifact(os.path.join(figure_path, 'MEG_SPoC_Components_Analysis.pdf')) mlflow.log_artifact(os.path.join(figure_path, "Scatter.pdf")) mlflow.sklearn.log_model(reg, "models")