def outer_cross_validation(kernel_train, x_test, y_train, y_test, async_res, balanced=False):
best_c, best_acc = select_best_c(async_res)
y_hat = launch_svc(kernel_train, x_test, y_train, best_c, balanced)
result = dict()
result['best_c'] = best_c
result['best_acc'] = best_acc
result['evaluation'] = evaluate_prediction(y_test, y_hat)
result['y_hat'] = y_hat
return result
def inner_grid_search(shared_x,
indices,
train_index,
inner_train_index,
inner_test_index,
y_train,
y_test,
alpha,
positive=False):
x_train = shared_x[indices[train_index[inner_train_index]], :]
x_test = shared_x[indices[train_index[inner_test_index]], :]
y_hat = launch_lasso(x_train, x_test, y_train, alpha, positive)
res = evaluate_prediction(y_test, y_hat)
return res['accuracy']
def outer_cross_validation(shared_x,
indices,
train_index,
test_index,
y_train,
y_test,
async_res,
positive=False):
best_alpha, best_acc = select_best_alpha(async_res)
x_train = shared_x[indices[train_index], :]
x_test = shared_x[indices[test_index], :]
y_hat = launch_lasso(x_train, x_test, y_train, best_alpha, positive)
result = dict()
result['best_alpha'] = best_alpha
result['best_acc'] = best_acc
result['evaluation'] = evaluate_prediction(y_test, y_hat)
result['y_hat'] = y_hat
return result
def lasso_binary_classification(image_list,
diagnosis_list,
output_directory,
existing_gram_matrix=None,
mask_zeros=True,
scale_data=False,
positive=False,
outer_folds=10,
inner_folds=10,
n_threads=10,
alphas=np.arange(0.1, 1.1, 0.1),
save_gram_matrix=False,
save_subject_classification=False,
save_weights=True,
save_features_image=True):
results = dict()
dx_filter = np.unique(diagnosis_list)
print 'Loading ' + str(len(image_list)) + ' subjects'
x0, orig_shape, data_mask = load_data(image_list, mask=mask_zeros)
print 'Subjects loaded'
if scale_data:
x_all = scale(x0)
else:
x_all = x0
# if existing_gram_matrix is not None:
# gram_matrix = existing_gram_matrix
# if (gram_matrix.shape[0] != gram_matrix.shape[1]) | (gram_matrix.shape[0] != len(image_list)):
# raise ValueError('The existing Gram matrix must be a square matrix with number of rows and columns equal to the number of images.')
# else:
# print 'Calculating Gram matrix'
# gram_matrix = gram_matrix_linear(x_all)
# print 'Gram matrix calculated'
# if save_gram_matrix:
# np.savetxt(join(output_directory, 'gram_matrix.txt'), gram_matrix)
# BaseManager.register('ndarray', type(x_all))
# manager = BaseManager()
# manager.start()
# shared_x = manager.ndarray(x_all.shape, buffer=x_all)
shared_x = sharedmem.copy(x_all)
x_all = None
gc.collect()
for i in range(len(dx_filter)):
for j in range(i + 1, len(dx_filter)):
dx1 = dx_filter[i]
dx2 = dx_filter[j]
ind1 = []
ind2 = []
for k in range(len(diagnosis_list)):
if diagnosis_list[k] == dx1:
ind1.append(k)
if diagnosis_list[k] == dx2:
ind2.append(k)
indices = ind1 + ind2
indices = np.array(indices)
current_subjects = [image_list[k] for k in indices]
current_diagnosis = [diagnosis_list[k] for k in indices]
# x = x_all[indices, :]
y = np.array([0] * len(ind1) + [1] * len(ind2))
# gm = gram_matrix[indices, :][:, indices]
classification_str = dx1 + '_vs_' + dx2 + ('_positive'
if positive else '')
print 'Running ' + dx1 + ' vs ' + dx2 + ' classification'
y_hat, coefficients, intersect, alpha = nested_folds(
shared_x,
indices,
y,
alphas,
positive=positive,
outer_folds=outer_folds,
inner_folds=inner_folds,
n_threads=n_threads)
evaluation = evaluate_prediction(y, y_hat)
print '\nTrue positive %0.2f' % len(evaluation['predictions'][0])
print 'True negative %0.2f' % len(evaluation['predictions'][1])
print 'False positive %0.2f' % len(evaluation['predictions'][2])
print 'False negative %0.2f' % len(evaluation['predictions'][3])
print 'Accuracy %0.2f' % evaluation['accuracy']
print 'Balanced accuracy %0.2f' % evaluation['balanced_accuracy']
print 'Sensitivity %0.2f' % evaluation['sensitivity']
print 'Specificity %0.2f' % evaluation['specificity']
print 'Positive predictive value %0.2f' % evaluation['ppv']
print 'Negative predictive value %0.2f \n' % evaluation['npv']
if save_weights or save_features_image:
weights_orig = revert_mask(coefficients, data_mask, orig_shape)
if save_weights:
np.save(
join(output_directory, classification_str + '__intersect'),
intersect)
np.save(
join(output_directory, classification_str + '__weights'),
weights_orig)
if save_features_image:
weights_to_nifti(
weights_orig, image_list[0],
join(output_directory,
classification_str + '__features_image.nii'))
if save_subject_classification:
save_subjects_prediction(
current_subjects, current_diagnosis, y, y_hat,
join(output_directory,
classification_str + '__subjects.csv'))
results[(dx1, dx2)] = evaluate_prediction(y, y_hat)
results_to_csv(
results, dx_filter,
join(output_directory,
'resume' + ('_positive' if positive else '') + '.csv'))
def inner_grid_search(kernel_train, x_test, y_train, y_test, c, balanced=False):
y_hat = launch_svc(kernel_train, x_test, y_train, c, balanced)
res = evaluate_prediction(y_test, y_hat)
return res['accuracy']
def linear_svm_binary_classification(image_list, diagnose_list, output_directory,
mask_zeros=True, balanced=False,
outer_folds=10, inner_folds=10, n_threads=10, c_range=np.logspace(-6, 2, 17),
save_gram_matrix=False, save_subject_classification=False,
save_original_weights=False, save_features_image=True):
results = dict()
dx_filter = np.unique(diagnose_list)
print 'Loading ' + str(len(image_list)) + ' subjects'
x0, orig_shape, data_mask = load_data(image_list, mask=mask_zeros)
print 'Subjects loaded'
print 'Calculating Gram matrix'
x_all = scale(np.nan_to_num(x0))
gram_matrix = gram_matrix_linear(x_all)
print 'Gram matrix calculated'
if save_gram_matrix:
np.savetxt(join(output_directory, 'gram_matrix.txt'), gram_matrix)
# Allow loading precalculated gram_matrix?
# gram_matrix = np.loadtxt(input_gram_matrix)
for i in range(len(dx_filter)):
for j in range(i + 1, len(dx_filter)):
dx1 = dx_filter[i]
dx2 = dx_filter[j]
ind1 = []
ind2 = []
for k in range(len(diagnose_list)):
if diagnose_list[k] == dx1:
ind1.append(k)
if diagnose_list[k] == dx2:
ind2.append(k)
indices = ind1 + ind2
current_subjects = [image_list[k] for k in indices]
current_diagnosis = [diagnose_list[k] for k in indices]
x = [x_all[k] for k in indices]
y = np.array([0] * len(ind1) + [1] * len(ind2))
gm = gram_matrix[indices, :][:, indices]
classification_str = dx1 + '_vs_' + dx2 + ('_balanced' if balanced else '_not_balanced')
print 'Running ' + dx1 + ' vs ' + dx2 + ' classification'
y_hat, w, c = nested_folds(gm, x, y, c_range, balanced=balanced, outer_folds=outer_folds, inner_folds=inner_folds, n_threads=n_threads)
evaluation = evaluate_prediction(y, y_hat)
print '\nTrue positive %0.2f' % len(evaluation['predictions'][0])
print 'True negative %0.2f' % len(evaluation['predictions'][1])
print 'False positive %0.2f' % len(evaluation['predictions'][2])
print 'False negative %0.2f' % len(evaluation['predictions'][3])
print 'Accuracy %0.2f' % evaluation['accuracy']
print 'Balanced accuracy %0.2f' % evaluation['balanced_accuracy']
print 'Sensitivity %0.2f' % evaluation['sensitivity']
print 'Specificity %0.2f' % evaluation['specificity']
print 'Positive predictive value %0.2f' % evaluation['ppv']
print 'Negative predictive value %0.2f \n' % evaluation['npv']
weights_orig = revert_mask(w, data_mask, orig_shape)
if save_original_weights:
np.save(join(output_directory, classification_str + '__weights'), weights_orig)
if save_features_image:
weights_to_nifti(weights_orig, image_list[0], join(output_directory, classification_str + '__features_image.nii'))
if save_subject_classification:
save_subjects_prediction(current_subjects, current_diagnosis, y, y_hat, join(output_directory, classification_str + '__subjects.csv'))
results[(dx1, dx2)] = evaluate_prediction(y, y_hat)
results_to_csv(results, dx_filter, join(output_directory, 'resume.csv'))