def test_corrcoef_matrix_vector_varcol(self): '''Test for corrcoef (matrix and vector, var=col)''' x = np.random.rand(100, 10) y = np.random.rand(100) exp_output = np.corrcoef(y, x, rowvar=0)[0, 1:] test_output = bdst.corrcoef(x, y, var='col') np.testing.assert_array_almost_equal(test_output, exp_output)
def test_corrcoef_hvector_hvector(self): '''Test for corrcoef (horizontal vector and horizontal vector)''' x = np.random.rand(1, 100) y = np.random.rand(1, 100) exp_output = np.corrcoef(x, y)[0, 1] test_output = bdst.corrcoef(x, y) np.testing.assert_array_equal(test_output, exp_output)
def test_corrcoef_vvector_vvector(self): '''Test for corrcoef (vertical vector and vertical vector)''' x = np.random.rand(100, 1) y = np.random.rand(100, 1) exp_output = np.corrcoef(x.T, y.T)[0, 1] test_output = bdst.corrcoef(x, y) np.testing.assert_array_equal(test_output, exp_output)
def test_corrcoef_matrix_matrix_default(self): '''Test for corrcoef (matrix and matrix, default, var=row)''' x = np.random.rand(100, 10) y = np.random.rand(100, 10) exp_output = np.diag(np.corrcoef(x, y)[:x.shape[0], x.shape[0]:]) test_output = bdst.corrcoef(x, y) np.testing.assert_array_equal(test_output, exp_output)
def test_corrcoef_vector_matrix_varrow(self): '''Test for corrcoef (vector and matrix, var=row)''' x = np.random.rand(10) y = np.random.rand(100, 10) exp_output = np.corrcoef(x, y)[0, 1:] test_output = bdst.corrcoef(x, y) np.testing.assert_array_almost_equal(test_output, exp_output)
def test_corrcoef_matrix_matrix_varcol(self): '''Test for corrcoef (matrix and matrix, var=col)''' x = np.random.rand(100, 10) y = np.random.rand(100, 10) exp_output = np.diag( np.corrcoef(x, y, rowvar=0)[:x.shape[1], x.shape[1]:]) test_output = bdst.corrcoef(x, y, var='col') np.testing.assert_array_equal(test_output, exp_output)
def main(): results_dir = config.results_dir output_file = config.results_file # Load results ----------------------------------------------------- result_list = [] for rf in os.listdir(results_dir): rf_full = os.path.join(results_dir, rf) print('Loading %s' % rf_full) with open(rf_full, 'rb') as f: res = pickle.load(f) result_list.append(res) # Merge result dataframes ------------------------------------------ results = pd.concat(result_list, ignore_index=True) # Drop unnecessary columns results.drop('predicted_feature', axis=1, inplace=True) results.drop('true_feature', axis=1, inplace=True) results.drop('test_label', axis=1, inplace=True) # Calculated feature prediction accuracy --------------------------- res_pt = results.query('test_type == "perception"') res_im = results.query('test_type == "imagery"') # Profile correlation (image) res_pt['profile_correlation_image'] = [ corrcoef(t, p, var='col') for t, p in zip(res_pt['true_feature_averaged'], res_pt['predicted_feature_averaged']) ] res_pt[ 'mean_profile_correlation_image'] = res_pt.loc[:, 'profile_correlation_image'].apply( np.nanmean) # Profile correlation (category, seen) res_pt['profile_correlation_cat_percept'] = [ corrcoef(t, p, var='col') for t, p in zip(res_pt['category_feature_averaged'], res_pt['predicted_feature_averaged']) ] res_pt[ 'mean_profile_correlation_cat_percept'] = res_pt.loc[:, 'profile_correlation_cat_percept'].apply( np.nanmean) # Profile correlation (category, imagined) res_im['profile_correlation_cat_imagery'] = [ corrcoef(t, p, var='col') for t, p in zip(res_im['category_feature_averaged'], res_im['predicted_feature_averaged']) ] res_im[ 'mean_profile_correlation_cat_imagery'] = res_im.loc[:, 'profile_correlation_cat_imagery'].apply( np.nanmean) # Merge results results_merged = pd.merge(res_pt, res_im, on=['subject', 'roi', 'feature']) # Rename columns results_merged = results_merged.rename( columns={ 'test_label_set_x': 'test_label_set_percept', 'test_label_set_y': 'test_label_set_imagery', 'true_feature_averaged_x': 'true_feature_averaged_percept', 'true_feature_averaged_y': 'true_feature_averaged_imagery', 'predicted_feature_averaged_x': 'predicted_feature_averaged_percept', 'predicted_feature_averaged_y': 'predicted_feature_averaged_imagery', 'category_label_set_x': 'category_label_set_percept', 'category_label_set_y': 'category_label_set_imagery', 'category_feature_averaged_x': 'category_feature_averaged_percept', 'category_feature_averaged_y': 'category_feature_averaged_imagery' }) # Drop unnecessary columns results_merged.drop('test_type_x', axis=1, inplace=True) results_merged.drop('test_type_y', axis=1, inplace=True) # Save the merged dataframe ---------------------------------------- with open(output_file, 'wb') as f: pickle.dump(results_merged, f) print('Saved %s' % output_file)
ind_imgtest = feature_type == 2 ind_cattest = feature_type == 3 test_feat_img = bdpy.get_refdata(feature[ind_imgtest, :], feature_catlabel[ind_imgtest], cat_percept) test_feat_cat_percept = bdpy.get_refdata(feature[ind_cattest, :], feature_catlabel[ind_cattest], cat_percept) test_feat_cat_imagery = bdpy.get_refdata(feature[ind_cattest, :], feature_catlabel[ind_cattest], cat_imagery) ## Get image and category feature prediction accuracy predacc_image_percept = np.nanmean( corrcoef(pred_percept, test_feat_img, var='col')) predacc_category_percept = np.nanmean( corrcoef(pred_percept, test_feat_cat_percept, var='col')) predacc_category_imagery = np.nanmean( corrcoef(pred_imagery, test_feat_cat_imagery, var='col')) print 'Pred acc (image_percpet): %f' % predacc_image_percept print 'Pred acc (category_percpet): %f' % predacc_category_percept print 'Pred acc (category_imagery): %f' % predacc_category_imagery df_tmp = pd.DataFrame( { 'subject': [sbj], 'roi': [roi], 'feature': [feat], 'category_test_percept': [cat_percept],
def predict_feature_unit(analysis): '''Run feature prediction for each unit Parameters ---------- analysis : dict Analysis parameters. This contains the following items: - subject - roi - num_voxel - feature - unit - num_test_category - ardreg_num_itr Returns ------- dict Results dictionary. This contains the following items: - subject - roi - feature - unit - predict_percept - predict_imagery - predict_percept_ave - predict_imagery_ave ''' ## Set analysis parameters ------------- num_voxel = analysis['num_voxel'] unit = analysis['unit'] nitr = analysis['ardreg_num_itr'] print 'Unit %d' % unit ## Get data ---------------------------- ## Get brain data for training, test (perception), and test (imagery) ind_tr = data_type == 1 ind_te_p = data_type == 2 ind_te_i = data_type == 3 data_train = data[ind_tr, :] data_test_percept = data[ind_te_p, :] data_test_imagery = data[ind_te_i, :] label_train = data_label[ind_tr] label_test_percept = data_label[ind_te_p] label_test_imagery = data_label[ind_te_i] ## Get image features for training ind_feat_tr = feature_type == 1 feature_train = feature[ind_feat_tr, unit - 1] feature_label_train = feature_label[ind_feat_tr] ## Match training features to labels feature_train = bdpy.get_refdata(feature_train, feature_label_train, label_train) ## Preprocessing ----------------------- ## Normalize data data_train_mean = np.mean(data_train, axis=0) data_train_std = np.std(data_train, axis=0, ddof=1) data_train_norm = (data_train - data_train_mean) / data_train_std data_test_percept_norm = (data_test_percept - data_train_mean) / data_train_std data_test_imagery_norm = (data_test_imagery - data_train_mean) / data_train_std feature_train_mean = np.mean(feature_train, axis=0) feature_train_std = np.std(feature_train, axis=0, ddof=1) if feature_train_std == 0: feature_train_norm = feature_train - feature_train_mean else: feature_train_norm = (feature_train - feature_train_mean) / feature_train_std ## Voxel selection based on correlation corr = corrcoef(feature_train_norm, data_train_norm, var='col') data_train_norm, select_ind = select_top(data_train_norm, np.abs(corr), num_voxel, axis=1, verbose=False) data_test_percept_norm = data_test_percept_norm[:, select_ind] data_test_imagery_norm = data_test_imagery_norm[:, select_ind] ## Add bias term data_train_norm = add_bias(data_train_norm, axis=1) data_test_percept_norm = add_bias(data_test_percept_norm, axis=1) data_test_imagery_norm = add_bias(data_test_imagery_norm, axis=1) ## Decoding ---------------------------- if feature_train_std == 0: predict_percept_norm = np.zeros(data_test_percept.shape[0], feature_train_norm[1]) predict_imagery_norm = np.zeros(data_test_imagery.shape[0], feature_train_norm[1]) else: try: model = SparseLinearRegression(n_iter=nitr, prune_mode=1) ## Model training #import pdb; pdb.set_trace() model.fit(data_train_norm, feature_train_norm) except: model = SparseLinearRegression(n_iter=75, prune_mode=1) ## Model training # import pdb; pdb.set_trace() model.fit(data_train_norm, feature_train_norm) ## Image feature preiction (percept & imagery) predict_percept_norm = model.predict(data_test_percept_norm) predict_imagery_norm = model.predict(data_test_imagery_norm) # De-normalize predicted features predict_percept = predict_percept_norm * feature_train_std + feature_train_mean predict_imagery = predict_imagery_norm * feature_train_std + feature_train_mean ## Average prediction results for each test category # [Note] # Image IDs (labels) is '<category_id>.<image_id>' # (e.g., '123456.7891011' is 'image 7891011 in category 123456'). # Thus, the integer part of `label` represents the category ID. cat_te_p = np.floor(label_test_percept) cat_te_i = np.floor(label_test_imagery) category_test_percept = sorted(set(cat_te_p)) category_test_imagery = sorted(set(cat_te_i)) predict_percept_ave = [ np.mean(predict_percept[cat_te_p == i]) for i in category_test_percept ] predict_imagery_ave = [ np.mean(predict_imagery[cat_te_i == i]) for i in category_test_imagery ] #import pdb; pdb.set_trace() ## Return results return { 'subject': analysis['subject'], 'roi': analysis['roi'], 'feature': analysis['feature'], 'unit': unit, 'predict_percept': predict_percept, 'predict_imagery': predict_imagery, 'predict_percept_catave': predict_percept_ave, 'predict_imagery_catave': predict_imagery_ave, 'category_test_percept': category_test_percept, 'category_test_imagery': category_test_imagery }
def feature_prediction(x_train, y_train, x_test, y_test, n_voxel=500, n_iter=200): '''Run feature prediction Parameters ---------- x_train, y_train : array_like [shape = (n_sample, n_voxel)] Brain data and image features for training x_test, y_test : array_like [shape = (n_sample, n_unit)] Brain data and image features for test n_voxel : int The number of voxels n_iter : int The number of iterations Returns ------- predicted_label : array_like [shape = (n_sample, n_unit)] Predicted features ture_label : array_like [shape = (n_sample, n_unit)] True features in test data ''' n_unit = y_train.shape[1] # Normalize brian data (x) norm_mean_x = np.mean(x_train, axis=0) norm_scale_x = np.std(x_train, axis=0, ddof=1) x_train = (x_train - norm_mean_x) / norm_scale_x x_test = (x_test - norm_mean_x) / norm_scale_x # Feature prediction for each unit print('Running feature prediction') y_true_list = [] y_pred_list = [] for i in range(n_unit): print('Unit %03d' % (i + 1)) start_time = time() # Get unit features y_train_unit = y_train[:, i] y_test_unit = y_test[:, i] # Normalize image features for training (y_train_unit) norm_mean_y = np.mean(y_train_unit, axis=0) std_y = np.std(y_train_unit, axis=0, ddof=1) norm_scale_y = 1 if std_y == 0 else std_y y_train_unit = (y_train_unit - norm_mean_y) / norm_scale_y # Voxel selection corr = corrcoef(y_train_unit, x_train, var='col') x_train_unit, voxel_index = select_top(x_train, np.abs(corr), n_voxel, axis=1, verbose=False) x_test_unit = x_test[:, voxel_index] # Add bias terms x_train_unit = add_bias(x_train_unit, axis=1) x_test_unit = add_bias(x_test_unit, axis=1) # Setup regression # For quick demo, use linaer regression model = LinearRegression() #model = SparseLinearRegression(n_iter=n_iter, prune_mode=1) # Training and test try: model.fit(x_train_unit, y_train_unit) # Training y_pred = model.predict(x_test_unit) # Test except: # When SLiR failed, returns zero-filled array as predicted features y_pred = np.zeros(y_test_unit.shape) # Denormalize predicted features y_pred = y_pred * norm_scale_y + norm_mean_y y_true_list.append(y_test_unit) y_pred_list.append(y_pred) print('Time: %.3f sec' % (time() - start_time)) # Create numpy arrays for return values y_predicted = np.vstack(y_pred_list).T y_true = np.vstack(y_true_list).T return y_predicted, y_true