def save_weights_as_nifti(self, weights, output_dir):
if self._images is None:
self.get_images()
output_filename = path.join(output_dir, 'weights.nii.gz')
data = vbio.revert_mask(weights, self._data_mask, self._orig_shape)
vbio.weights_to_nifti(data, self._images[0], output_filename)
def save_weights_as_nifti(self, weights, output_dir):
if self._images is None:
self.get_images()
output_filename = path.join(output_dir, 'weights.nii.gz')
data = vbio.revert_mask(weights, self._data_mask, self._orig_shape)
features = data / abs(data).max()
img = nib.load(self._images[0])
output_image = nib.Nifti1Image(features, img.affine)
nib.save(output_image, output_filename)
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'))
input_images = CAPSVoxelBasedInput(caps_dir,
subjects_visits_tsv,
diagnoses_tsv,
group_id,
image_type,
fwhm,
modulated='on',
pvc=pvc,
mask_zeros=False)
adni_x, adni_orig_shape, adni_data_mask = vbio.load_data(
adni_images.get_images(), mask=True)
weights = np.loadtxt(
path.join(adni_classifier_dir, 'weights.txt'))
w = vbio.revert_mask(weights, adni_data_mask,
adni_orig_shape).flatten()
b = np.loadtxt(path.join(adni_classifier_dir, 'intersect.txt'))
x = input_images.get_x()
y = input_images.get_y()
y_hat = np.dot(w, x.transpose()) + b
y_binary = (y_hat > 0) * 1.0
evaluation = utils.evaluate_prediction(y, y_binary)
auc = roc_auc_score(y, y_hat)
evaluation['AUC'] = auc
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'))