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
