def fit(self, x_train, y_train):
self.x_train = x_train
self.y_train = y_train
self.n_unit = y_train.shape[1]
# normalize mri data x (along each voxel)
mu = np.mean(self.x_train, axis=0)
std = np.std(self.x_train, axis=0, ddof=1)
std[std == 0] = 1
self.x_train = (self.x_train - mu) / std
# for each feature unit train a sparse linear regression
for i in range(self.n_unit):
feature_unit = self.y_train[:, i]
print(f'start training on unit {i}')
# normalize image features y (along each unit)
# this must be done separately because we need to de-normalize later
mu = np.mean(feature_unit, axis=0)
std = np.std(feature_unit, axis=0, ddof=1)
std = 1 if std == 0 else std
feature_unit = (feature_unit - mu) / std
self.normal_terms.append((mu, std))
# voxel selection, select the top `n_voxel` voxels with highest correlations
# corr = corrcoef(feature_unit, x_train, var='col')
corr = corr2_coeff(feature_unit.reshape((-1, 1)).T, x_train.T).ravel()
corr[np.isnan(corr)] = 0 # mark np.nan values as 0 contribution
x_train_subset, subset_index = select_top(x_train, np.abs(corr), self.n_voxel, axis=1, verbose=False)
# add bias terms
x_train_subset = add_bias(x_train_subset, axis=1)
# set up the model
model = SparseLinearRegression(n_iter=self.n_iter, prune_mode=1)
# model = LinearRegression()
# train model parameters
try:
model.fit(x_train_subset, feature_unit)
self.models.append(model)
self.subset_indices.append(subset_index)
except:
self.models.append(0)
self.subset_indices.append(0)
def test_select_top_default(cls):
'''Test for select_top (default, axis=0)'''
test_data = np.array([[1, 2, 3, 4, 5], [11, 12, 13, 14, 15],
[21, 22, 23, 24, 25], [31, 32, 33, 34, 35],
[41, 42, 43, 44, 45]])
test_value = np.array([15, 3, 6, 20, 0])
test_num = 3
exp_output_data = np.array([[1, 2, 3, 4, 5], [21, 22, 23, 24, 25],
[31, 32, 33, 34, 35]])
exp_output_index = np.array([0, 2, 3])
test_output_data, test_output_index = preproc.select_top(
test_data, test_value, test_num)
np.testing.assert_array_equal(test_output_data, exp_output_data)
np.testing.assert_array_equal(test_output_index, exp_output_index)
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