def collect_image_paths(data_dir): image_keys = [ structure.BrainImageTypes.T1w, structure.BrainImageTypes.GroundTruth ] class MyFilePathGenerator(futil.FilePathGenerator): @staticmethod def get_full_file_path(id_: str, root_dir: str, file_key, file_extension: str) -> str: if file_key == structure.BrainImageTypes.T1w: file_name = 'T1native' elif file_key == structure.BrainImageTypes.GroundTruth: file_name = 'labels_native' else: raise ValueError('Unknown key') return os.path.join(root_dir, file_name + file_extension) dir_filter = futil.DataDirectoryFilter() # todo: create an instance of futil.FileSystemDataCrawler and pass the correpsonding arguments crawler = futil.FileSystemDataCrawler('../data/exercise/', image_keys, MyFilePathGenerator(), dir_filter, '.nii.gz') # todo: modify here return crawler
def main(result_dir: str, data_atlas_dir: str, data_train_dir: str, data_test_dir: str): """Brain tissue segmentation using decision forests. The main routine executes the medical image analysis pipeline: - Image loading - Registration - Pre-processing - Feature extraction - Decision forest classifier model building - Segmentation using the decision forest classifier model on unseen images - Post-processing of the segmentation - Evaluation of the segmentation """ # load atlas images putil.load_atlas_images(data_atlas_dir) print('-' * 5, 'Training...') # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_train_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) pre_process_params = { 'skullstrip_pre': True, 'normalization_pre': True, 'registration_pre': True, 'coordinates_feature': True, 'intensity_feature': True, 'gradient_intensity_feature': True } # load images for training and pre-process images = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) # generate feature matrix and label vector data_train = np.concatenate([img.feature_matrix[0] for img in images]) labels_train = np.concatenate([img.feature_matrix[1] for img in images]).squeeze() #warnings.warn('Random forest parameters not properly set.') forest = sk_ensemble.RandomForestClassifier( max_features=images[0].feature_matrix[0].shape[1], n_estimators=10, max_depth=10) start_time = timeit.default_timer() forest.fit(data_train, labels_train) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # create a result directory with timestamp t = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S') result_dir = os.path.join(result_dir, t) os.makedirs(result_dir, exist_ok=True) print('-' * 5, 'Testing...') # initialize evaluator evaluator = putil.init_evaluator() # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_test_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) # load images for testing and pre-process pre_process_params['training'] = False images_test = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) images_prediction = [] images_probabilities = [] for img in images_test: print('-' * 10, 'Testing', img.id_) start_time = timeit.default_timer() predictions = forest.predict(img.feature_matrix[0]) probabilities = forest.predict_proba(img.feature_matrix[0]) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # convert prediction and probabilities back to SimpleITK images image_prediction = conversion.NumpySimpleITKImageBridge.convert( predictions.astype(np.uint8), img.image_properties) image_probabilities = conversion.NumpySimpleITKImageBridge.convert( probabilities, img.image_properties) # evaluate segmentation without post-processing evaluator.evaluate(image_prediction, img.images[structure.BrainImageTypes.GroundTruth], img.id_) images_prediction.append(image_prediction) images_probabilities.append(image_probabilities) # post-process segmentation and evaluate with post-processing post_process_params = {'simple_post': True} images_post_processed = putil.post_process_batch(images_test, images_prediction, images_probabilities, post_process_params, multi_process=False) for i, img in enumerate(images_test): evaluator.evaluate(images_post_processed[i], img.images[structure.BrainImageTypes.GroundTruth], img.id_ + '-PP') # save results sitk.WriteImage( images_prediction[i], os.path.join(result_dir, images_test[i].id_ + '_SEG.mha'), True) sitk.WriteImage( images_post_processed[i], os.path.join(result_dir, images_test[i].id_ + '_SEG-PP.mha'), True) # use two writers to report the results os.makedirs( result_dir, exist_ok=True) # generate result directory, if it does not exists result_file = os.path.join(result_dir, 'results.csv') writer.CSVWriter(result_file).write(evaluator.results) print('\nSubject-wise results...') writer.ConsoleWriter().write(evaluator.results) # report also mean and standard deviation among all subjects result_summary_file = os.path.join(result_dir, 'results_summary.csv') functions = {'MEAN': np.mean, 'STD': np.std} writer.CSVStatisticsWriter(result_summary_file, functions=functions).write(evaluator.results) print('\nAggregated statistic results...') writer.ConsoleStatisticsWriter(functions=functions).write( evaluator.results) # clear results such that the evaluator is ready for the next evaluation evaluator.clear()
def main(result_dir: str, data_atlas_dir: str, data_train_dir: str, data_test_dir: str): """Brain tissue segmentation using decision forests. The main routine executes the medical image analysis pipeline: - Image loading - Registration - Pre-processing - Feature extraction - Decision forest classifier model building - Segmentation using the decision forest classifier model on unseen images - Post-processing of the segmentation - Evaluation of the segmentation """ # load atlas images putil.load_atlas_images(data_atlas_dir) print('-' * 5, 'Training...') # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_train_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) pre_process_params = {'skullstrip_pre': True, 'normalization_pre': True, 'registration_pre': True, 'coordinates_feature': True, 'intensity_feature': True, 'gradient_intensity_feature': True} # load images for training and pre-process images = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) # generate feature matrix and label vector data_train = np.concatenate([img.feature_matrix[0] for img in images]) labels_train = np.concatenate([img.feature_matrix[1] for img in images]).squeeze() warnings.warn('Random forest parameters not properly set.') # visualization(images) print(np.shape(images[0].feature_matrix[0])) dfs= [] aggregated_results = [] print('-' * 5, 'Testing...') crawler = futil.FileSystemDataCrawler(data_test_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) pre_process_params['training'] = False images_test = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) for num_estimator in [10]: forest = sk_ensemble.RandomForestClassifier(max_features=images[0].feature_matrix[0].shape[1], n_estimators=num_estimator, max_depth=10) start_time = timeit.default_timer() forest.fit(data_train, labels_train) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # create a result directory with timestamp t = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S') result_dir = os.path.join(result_dir, t) os.makedirs(result_dir, exist_ok=True) print('-' * 5, 'Testing...') # initialize evaluator evaluator = putil.init_evaluator() # crawl the training image directories # crawler = futil.FileSystemDataCrawler(data_test_dir, # LOADING_KEYS, # futil.BrainImageFilePathGenerator(), # futil.DataDirectoryFilter()) # load images for testing and pre-process # data_test = np.concatenate([img.feature_matrix[0] for img in images_test]) # labels_test = np.concatenate([img.feature_matrix[1] for img in images_test]).squeeze() # ax = plt.gca() # rfc_disp = plot_roc_curve(forest, data_test, labels_test, ax=ax, alpha=0.8) # svc_disp.plot(ax=ax, alpha=0.8) # disp = plot_confusion_matrix(forest, data_test, labels_test, normalize='true') # plt.show() # y = label_binarize(labels_test, classes=[0, 1, 2 , 3, 4 , 5]) # n_classes = y.shape[1] images_prediction = [] images_probabilities = [] for img in images_test: print('-' * 10, 'Testing', img.id_) start_time = timeit.default_timer() predictions = forest.predict(img.feature_matrix[0]) probabilities = forest.predict_proba(img.feature_matrix[0]) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # convert prediction and probabilities back to SimpleITK images image_prediction = conversion.NumpySimpleITKImageBridge.convert(predictions.astype(np.uint8), img.image_properties) image_probabilities = conversion.NumpySimpleITKImageBridge.convert(probabilities, img.image_properties) # evaluate segmentation without post-processing evaluator.evaluate(image_prediction, img.images[structure.BrainImageTypes.GroundTruth], img.id_) images_prediction.append(image_prediction) images_probabilities.append(image_probabilities) results=evaluator.results labels = sorted({result.label for result in results}) metrics = sorted({result.metric for result in results}) # functions = {'MEAN': np.mean, 'STD': np.std} functions = {'MEAN': np.mean} for label in labels: for metric in metrics: # search for results values = [r.value for r in results if r.label == label and r.metric == metric] for fn_id, fn in functions.items(): aggregated_results.append( [num_estimator, label, metric, float(fn(values))]) # for result in aggregated_results: # # print([result.label, result.metric, result.id_, result.value]) # print(result) # writer.ConsoleStatisticsWriter(functions=functions).write(evaluator.results) # clear results such that the evaluator is ready for the next evaluation evaluator.clear() df=pd.DataFrame(aggregated_results, columns=['n_estimators', 'label', 'metric', 'value']) return df xdf = df[df.label == 'WhiteMatter'] del xdf['label'] # new_df=df[df.label=='GreyMatter'] # del new_df['label'] # new_df.set_index('n_estimators', inplace=True) # fig, ax = plt.subplots(figsize=(15, 7)) # new_df.groupby(['metric']).plot(ax=ax) # print(new_df) # plt.show() plt.figure(2) # pd.crosstab(index=[df['Name'], df['Date']], columns=new_df['metric']) my_df = pd.pivot_table(df,index=['label'], columns='metric', values='value') my_df.plot() print(my_df)
def main(result_dir: str, data_atlas_dir: str, data_train_dir: str, data_test_dir: str, tmp_result_dir: str): """Brain tissue segmentation using decision forests. Section of the original main routine. Executes post processing part of the medical image analysis pipeline: Must be done separately in advance: - Image loading - Registration - Pre-processing - Feature extraction - Decision forest classifier model building - Segmentation using the decision forest classifier model on unseen images Is carried out in this section of the pipeline - Loading of temporary data - Post-processing of the segmentation - Evaluation of the segmentation """ # load atlas images putil.load_atlas_images(data_atlas_dir) # print('-' * 5, 'Training...') # # # crawl the training image directories # crawler = futil.FileSystemDataCrawler(data_train_dir, # LOADING_KEYS, # futil.BrainImageFilePathGenerator(), # futil.DataDirectoryFilter()) pre_process_params = { 'skullstrip_pre': True, 'normalization_pre': True, 'registration_pre': True, 'coordinates_feature': True, 'intensity_feature': True, 'gradient_intensity_feature': True } # create a result directory with timestamp t = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S') result_dir = os.path.join(result_dir, t) os.makedirs(result_dir, exist_ok=True) # initialize evaluator evaluator = putil.init_evaluator() # crawl the test image directories crawler = futil.FileSystemDataCrawler(data_test_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) # load necessary data to perform post processing pre_process_params['training'] = False images_test = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) # load the prediction of the test images (segmented image images_prediction, images_probabilities = putil.load_prediction_images( images_test, tmp_result_dir, '2020-10-30-18-31-15') # evaluate images without post-processing for i, img in enumerate(images_test): evaluator.evaluate(images_prediction[i], img.images[structure.BrainImageTypes.GroundTruth], img.id_) # post-process segmentation and evaluate with post-processing post_process_params = { 'simple_post': True, 'variance': 1.0, 'preserve_background': False } images_post_processed = putil.post_process_batch(images_test, images_prediction, images_probabilities, post_process_params, multi_process=False) for i, img in enumerate(images_test): evaluator.evaluate(images_post_processed[i], img.images[structure.BrainImageTypes.GroundTruth], img.id_ + '-PP') # save results sitk.WriteImage( images_prediction[i], os.path.join(result_dir, images_test[i].id_ + '_SEG.mha'), True) sitk.WriteImage( images_post_processed[i], os.path.join(result_dir, images_test[i].id_ + '_SEG-PP.mha'), True) # use two writers to report the results os.makedirs( result_dir, exist_ok=True) # generate result directory, if it does not exists result_file = os.path.join(result_dir, 'results.csv') writer.CSVWriter(result_file).write(evaluator.results) print('\nSubject-wise results...') writer.ConsoleWriter().write(evaluator.results) # report also mean and standard deviation among all subjects result_summary_file = os.path.join(result_dir, 'results_summary.csv') functions = {'MEAN': np.mean, 'STD': np.std} writer.CSVStatisticsWriter(result_summary_file, functions=functions).write(evaluator.results) print('\nAggregated statistic results...') writer.ConsoleStatisticsWriter(functions=functions).write( evaluator.results) # clear results such that the evaluator is ready for the next evaluation evaluator.clear()
def main(result_dir: str, data_atlas_dir: str, data_train_dir: str, data_test_dir: str): """Brain tissue segmentation using decision forests. The main routine executes the medical image analysis pipeline: - Image loading - Registration - Pre-processing - Feature extraction - Decision forest classifier model building - Segmentation using the decision forest classifier model on unseen images - Post-processing of the segmentation - Evaluation of the segmentation """ # load atlas images putil.load_atlas_images(data_atlas_dir) print('-' * 5, 'Training...') # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_train_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) pre_process_params = { 'skullstrip_pre': True, 'normalization_pre': True, 'registration_pre': True, 'coordinates_feature': True, 'intensity_feature': True, 'gradient_intensity_feature': True } # load images for training and pre-process images = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) # generate feature matrix and label vector data_train = np.concatenate([img.feature_matrix[0] for img in images]) labels_train = np.concatenate([img.feature_matrix[1] for img in images]).squeeze() warnings.warn('Random forest parameters not properly set.') # visualization(images) print(np.shape(images[0].feature_matrix[0])) forest = sk_ensemble.RandomForestClassifier( max_features=images[0].feature_matrix[0].shape[1], n_estimators=10, max_depth=10) start_time = timeit.default_timer() # forest.fit(data_train, labels_train) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # create a result directory with timestamp t = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S') result_dir = os.path.join(result_dir, t) os.makedirs(result_dir, exist_ok=True) print('-' * 5, 'Testing...') # initialize evaluator evaluator = putil.init_evaluator() # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_test_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) # load images for testing and pre-process pre_process_params['training'] = False images_test = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) data_test = np.concatenate([img.feature_matrix[0] for img in images_test]) labels_test = np.concatenate( [img.feature_matrix[1] for img in images_test]).squeeze() random_state = np.random.RandomState(0) # ax = plt.gca() # rfc_disp = plot_roc_curve(forest, data_test, labels_test, ax=ax, alpha=0.8) # svc_disp.plot(ax=ax, alpha=0.8) # disp = plot_confusion_matrix(forest, data_test, labels_test, normalize='true') # plt.show() X = np.concatenate((data_train, data_test)) y = np.concatenate((labels_train, labels_test)) y = label_binarize(y, classes=[0, 1, 2, 3, 4, 5]) n_classes = y.shape[1] n_samples, n_features = X.shape X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.5, random_state=0) # classifier = OneVsRestClassifier(svm.SVC(kernel='linear', probability=True, # random_state=random_state)) classifier = OneVsRestClassifier( sk_ensemble.RandomForestClassifier( max_features=images[0].feature_matrix[0].shape[1], n_estimators=10, max_depth=5)) y_score = classifier.fit(X_train, y_train).predict(X_test) # Compute ROC curve and ROC area for each class fpr = dict() tpr = dict() roc_auc = dict() for i in range(n_classes): fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_score[:, i]) roc_auc[i] = auc(fpr[i], tpr[i]) # Compute micro-average ROC curve and ROC area fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_score.ravel()) roc_auc["micro"] = auc(fpr["micro"], tpr["micro"]) # First aggregate all false positive rates all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)])) # Then interpolate all ROC curves at this points mean_tpr = np.zeros_like(all_fpr) for i in range(n_classes): mean_tpr += interp(all_fpr, fpr[i], tpr[i]) # Finally average it and compute AUC mean_tpr /= n_classes fpr["macro"] = all_fpr tpr["macro"] = mean_tpr roc_auc["macro"] = auc(fpr["macro"], tpr["macro"]) plt.figure() lw = 2 plt.plot(fpr[2], tpr[2], color='darkorange', lw=lw, label='ROC curve (area = %0.2f)' % roc_auc[2]) plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--') plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver operating characteristic example') plt.legend(loc="lower right") plt.show() # Plot all ROC curves plt.figure() plt.plot(fpr["micro"], tpr["micro"], label='micro-average ROC curve (area = {0:0.2f})' ''.format(roc_auc["micro"]), color='deeppink', linestyle=':', linewidth=4) plt.plot(fpr["macro"], tpr["macro"], label='macro-average ROC curve (area = {0:0.2f})' ''.format(roc_auc["macro"]), color='navy', linestyle=':', linewidth=4) colors = cycle(['aqua', 'darkorange', 'cornflowerblue']) for i, color in zip(range(n_classes), colors): plt.plot(fpr[i], tpr[i], color=color, lw=lw, label='ROC curve of class {0} (area = {1:0.2f})' ''.format(i, roc_auc[i])) plt.plot([0, 1], [0, 1], 'k--', lw=lw) plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title( 'Some extension of Receiver operating characteristic to multi-class') plt.legend(loc="lower right") plt.show() # # images_prediction = [] # images_probabilities = [] # # # for img in images_test: # print('-' * 10, 'Testing', img.id_) # # # start_time = timeit.default_timer() # predictions = forest.predict(img.feature_matrix[0]) # probabilities = forest.predict_proba(img.feature_matrix[0]) # print(' Time elapsed:', timeit.default_timer() - start_time, 's') # # # convert prediction and probabilities back to SimpleITK images # image_prediction = conversion.NumpySimpleITKImageBridge.convert(predictions.astype(np.uint8), # img.image_properties) # image_probabilities = conversion.NumpySimpleITKImageBridge.convert(probabilities, img.image_properties) # # # evaluate segmentation without post-processing # evaluator.evaluate(image_prediction, img.images[structure.BrainImageTypes.GroundTruth], img.id_) # # images_prediction.append(image_prediction) # images_probabilities.append(image_probabilities) # # # # # # post-process segmentation and evaluate with post-processing # post_process_params = {'simple_post': True} # images_post_processed = putil.post_process_batch(images_test, images_prediction, images_probabilities, # post_process_params, multi_process=True) # # for i, img in enumerate(images_test): # evaluator.evaluate(images_post_processed[i], img.images[structure.BrainImageTypes.GroundTruth], # img.id_ + '-PP') # # # save results # sitk.WriteImage(images_prediction[i], os.path.join(result_dir, images_test[i].id_ + '_SEG.mha'), True) # sitk.WriteImage(images_post_processed[i], os.path.join(result_dir, images_test[i].id_ + '_SEG-PP.mha'), True) # # # use two writers to report the results # os.makedirs(result_dir, exist_ok=True) # generate result directory, if it does not exists # result_file = os.path.join(result_dir, 'results.csv') # writer.CSVWriter(result_file).write(evaluator.results) # # print('\nSubject-wise results...') # writer.ConsoleWriter().write(evaluator.results) # # # report also mean and standard deviation among all subjects # result_summary_file = os.path.join(result_dir, 'results_summary.csv') # functions = {'MEAN': np.mean, 'STD': np.std} # writer.CSVStatisticsWriter(result_summary_file, functions=functions).write(evaluator.results) # print('\nAggregated statistic results...') # writer.ConsoleStatisticsWriter(functions=functions).write(evaluator.results) # clear results such that the evaluator is ready for the next evaluation evaluator.clear()
def main(result_dir: str, data_atlas_dir: str, data_train_dir: str, data_test_dir: str): """Brain tissue segmentation using decision forests. Section of the original main routine. Executes pre-processing and prediction part of the medical image analysis pipeline and and saves the temporary data: Is carried out in this section of the pipeline - Image loading - Registration - Pre-processing - Feature extraction - Decision forest classifier model building - Segmentation using the decision forest classifier model on unseen images - Save prediction data """ # load atlas images putil.load_atlas_images(data_atlas_dir) print('-' * 5, 'Training...') # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_train_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) pre_process_params = { 'skullstrip_pre': True, 'normalization_pre': True, 'registration_pre': True, 'coordinates_feature': True, 'intensity_feature': True, 'gradient_intensity_feature': True } # load images for training and pre-process images = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) # generate feature matrix and label vector data_train = np.concatenate([img.feature_matrix[0] for img in images]) labels_train = np.concatenate([img.feature_matrix[1] for img in images]).squeeze() warnings.warn('Random forest parameters not properly set.') forest = sk_ensemble.RandomForestClassifier( max_features=images[0].feature_matrix[0].shape[1], n_estimators=10, max_depth=10) start_time = timeit.default_timer() forest.fit(data_train, labels_train) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # create a result directory with timestamp t = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S') result_dir = os.path.join(result_dir, t) os.makedirs(result_dir, exist_ok=True) print('-' * 5, 'Testing...') # initialize evaluator evaluator = putil.init_evaluator() # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_test_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) # load images for testing and pre-process pre_process_params['training'] = False images_test = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) images_prediction = [] images_probabilities = [] for img in images_test: print('-' * 10, 'Testing', img.id_) start_time = timeit.default_timer() predictions = forest.predict(img.feature_matrix[0]) probabilities = forest.predict_proba(img.feature_matrix[0]) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # convert prediction and probabilities back to SimpleITK images image_prediction = conversion.NumpySimpleITKImageBridge.convert( predictions.astype(np.uint8), img.image_properties) image_probabilities = conversion.NumpySimpleITKImageBridge.convert( probabilities, img.image_properties) # evaluate segmentation without post-processing evaluator.evaluate(image_prediction, img.images[structure.BrainImageTypes.GroundTruth], img.id_) images_prediction.append(image_prediction) images_probabilities.append(image_probabilities) # save all data used for post processing for i, img in enumerate(images_test): sitk.WriteImage( images_prediction[i], os.path.join(result_dir, images_test[i].id_ + '_SEG.mha'), True) sitk.WriteImage( images_probabilities[i], os.path.join(result_dir, images_test[i].id_ + '_PROB.mha'), True) evaluator.clear()
def main(result_dir: str, data_atlas_dir: str, data_train_dir: str, data_test_dir: str): """Brain tissue segmentation using decision forests. Section of the original main routine. Executes gird search of the probabilistic keyhole filling method parameters: Must be done separately in advance: - Image loading - Registration - Pre-processing - Feature extraction - Decision forest classifier model building - Segmentation using the decision forest classifier model on unseen images Is carried out in this section of the pipeline - Loading of temporary data - Grid search of PKF parameter of the segmentation - Evaluation of the segmentation """ # load atlas images putil.load_atlas_images(data_atlas_dir) print('-' * 5, 'Training...') # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_train_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) pre_process_params = { 'skullstrip_pre': True, 'normalization_pre': True, 'registration_pre': True, 'coordinates_feature': True, 'intensity_feature': True, 'gradient_intensity_feature': True } # load images for training and pre-process images = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) # generate feature matrix and label vector data_train = np.concatenate([img.feature_matrix[0] for img in images]) labels_train = np.concatenate([img.feature_matrix[1] for img in images]).squeeze() #warnings.warn('Random forest parameters not properly set.') forest = sk_ensemble.RandomForestClassifier( max_features=images[0].feature_matrix[0].shape[1], n_estimators=20, max_depth=85) start_time = timeit.default_timer() forest.fit(data_train, labels_train) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # create a result directory with timestamp t = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S') result_dir = os.path.join(result_dir, t) os.makedirs(result_dir, exist_ok=True) print('-' * 5, 'Testing...') # initialize evaluator evaluator = putil.init_evaluator() # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_test_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) # load images for testing and pre-process pre_process_params['training'] = False images_test = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) images_prediction = [] images_probabilities = [] for img in images_test: print('-' * 10, 'Testing', img.id_) start_time = timeit.default_timer() predictions = forest.predict(img.feature_matrix[0]) probabilities = forest.predict_proba(img.feature_matrix[0]) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # convert prediction and probabilities back to SimpleITK images image_prediction = conversion.NumpySimpleITKImageBridge.convert( predictions.astype(np.uint8), img.image_properties) image_probabilities = conversion.NumpySimpleITKImageBridge.convert( probabilities, img.image_properties) # evaluate segmentation without post-processing evaluator.evaluate(image_prediction, img.images[structure.BrainImageTypes.GroundTruth], img.id_) images_prediction.append(image_prediction) images_probabilities.append(image_probabilities) # save results without post-processing name = 'no_PP' sub_dir = os.path.join(result_dir, name) os.makedirs(sub_dir, exist_ok=True) for i, img in enumerate(images_test): sitk.WriteImage(images_prediction[i], os.path.join(sub_dir, images_test[i].id_ + '_SEG.mha'), True) result_file = os.path.join(sub_dir, 'results.csv') writer.CSVWriter(result_file).write(evaluator.results) # report also mean and standard deviation among all subjects result_summary_file = os.path.join(sub_dir, 'results_summary.csv') functions = {'MEAN': np.mean, 'STD': np.std} writer.CSVStatisticsWriter(result_summary_file, functions=functions).write(evaluator.results) # clear results such that the evaluator is ready for the next evaluation evaluator.clear() # define paramter for grid search post_process_param_list = [] variance = np.arange(1, 2) preserve_background = np.asarray([False]) # # # define paramter for grid search # post_process_param_list = [] # variance = np.arange(0.5, 4.0, 0.5) # preserve_background = np.asarray([False, True]) for bg in preserve_background: for var in variance: post_process_param_list.append({ 'simple_post': bool(True), 'variance': float(var), 'preserve_background': bool(bg) }) # execute post processing with definde parameters for post_process_params in post_process_param_list: # create sub-directory for results name = 'PP-V-'+ str(post_process_params.get('variance')).replace('.','_') +\ '-BG-' + str(post_process_params.get('preserve_background')) sub_dir = os.path.join(result_dir, name) os.makedirs(sub_dir, exist_ok=True) #write the used parameter into a text file and store it in the result folder completeName = os.path.join(sub_dir, "parameter.txt") file1 = open(completeName, "w+") json.dump(post_process_params, file1) file1.close() # post-process segmentation and evaluate with post-processing images_post_processed = putil.post_process_batch(images_test, images_prediction, images_probabilities, post_process_params, multi_process=False) for i, img in enumerate(images_test): evaluator.evaluate( images_post_processed[i], img.images[structure.BrainImageTypes.GroundTruth], img.id_ + '-PP') # save results sitk.WriteImage( images_post_processed[i], os.path.join(sub_dir, images_test[i].id_ + '_SEG-PP.mha'), True) # save all results in csv file result_file = os.path.join(sub_dir, 'results.csv') writer.CSVWriter(result_file).write(evaluator.results) print('\nSubject-wise results...') writer.ConsoleWriter().write(evaluator.results) # report also mean and standard deviation among all subjects result_summary_file = os.path.join(sub_dir, 'results_summary.csv') functions = {'MEAN': np.mean, 'STD': np.std} writer.CSVStatisticsWriter( result_summary_file, functions=functions).write(evaluator.results) print('\nAggregated statistic results...') writer.ConsoleStatisticsWriter(functions=functions).write( evaluator.results) # clear results such that the evaluator is ready for the next evaluation evaluator.clear()
def main(result_dir: str, data_atlas_dir: str, data_train_dir: str, data_test_dir: str): """Brain tissue segmentation using decision forests. The main routine executes the medical image analysis pipeline: - Image loading - Registration - Pre-processing - Feature extraction - Decision forest classifier model building - Segmentation using the decision forest classifier model on unseen images - Post-processing of the segmentation - Evaluation of the segmentation """ # load atlas images putil.load_atlas_images(data_atlas_dir) print('-' * 5, 'Training...') # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_train_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) pre_process_params = { 'skullstrip_pre': True, 'normalization_pre': True, 'registration_pre': True, 'coordinates_feature': True, 'intensity_feature': True, 'gradient_intensity_feature': True } # load images for training and pre-process images = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) # generate feature matrix and label vector data_train = np.concatenate([img.feature_matrix[0] for img in images]) labels_train = np.concatenate([img.feature_matrix[1] for img in images]).squeeze() warnings.warn('Random forest parameters not properly set.') # visualization(images) print(np.shape(images[0].feature_matrix[0])) error_rate = [] for num_estimators in range(1, 10): forest = sk_ensemble.RandomForestClassifier( max_features=images[0].feature_matrix[0].shape[1], n_estimators=num_estimators, max_depth=10, oob_score=True) # start_time = timeit.default_timer() forest.fit(data_train, labels_train) oob_error = 1 - forest.oob_score_ print(forest.oob_score_) error_rate += [oob_error] plt.plot(range(1, 10), error_rate) plt.show()
def main(result_dir: str, data_atlas_dir: str, data_train_dir: str, data_test_dir: str, parameters_file: str): """Brain tissue segmentation using decision forests. The main routine executes the medical image analysis pipeline: - Image loading - Registration - Pre-processing - Feature extraction - Decision forest classifier model building - Segmentation using the decision forest classifier model on unseen images - Post-processing of the segmentation - Evaluation of the segmentation """ start_main = timeit.default_timer() # load atlas images putil.load_atlas_images(data_atlas_dir) print('-' * 5, 'Training...') # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_train_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) fof_parameters = {'10Percentile': True, '90Percentile': True, 'Energy': True, 'Entropy': True, 'InterquartileRange': True, 'Kurtosis': True, 'Maximum': True, 'MeanAbsoluteDeviation': True, 'Mean': True, 'Median': True, 'Minimum': True, 'Range': True, 'RobustMeanAbsoluteDeviation': True, 'RootMeanSquared': True, 'Skewness': True, 'TotalEnergy': True, 'Uniformity': True, 'Variance': True} glcm_parameters = {'Autocorrelation': True, 'ClusterProminence': True, 'ClusterShade': True, 'ClusterTendency': True, 'Contrast': True, 'Correlation': True, 'DifferenceAverage': True, 'DifferenceEntropy': True, 'DifferenceVariance': True, 'Id': True, 'Idm': True, 'Idmn': True, 'Idn': True, 'Imc1': True, 'Imc2': True, 'InverseVariance': True, 'JointAverage': True, 'JointEnergy': True, 'JointEntropy': True, 'MCC': True, 'MaximumProbability': True, 'SumAverage': True, 'SumEntropy': True, 'SumSquares': True} pre_process_params = {'skullstrip_pre': True, 'normalization_pre': True, 'registration_pre': True, 'save_features': False, 'coordinates_feature': True, 'intensity_feature': False, 'gradient_intensity_feature': False, 'first_order_feature': False, 'first_order_feature_parameters': fof_parameters, 'HOG_feature': False, 'GLCM_features': False, 'GLCM_features_parameters': glcm_parameters, 'n_estimators': 50, 'max_depth': 60, 'experiment_name': 'default' } parameters = json.load(open(parameters_file, 'r')) if bool(parameters): pre_process_params = parameters # load images for training and pre-process images = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) # generate feature matrix and label vector data_train = np.concatenate([img.feature_matrix[0] for img in images]) labels_train = np.concatenate([img.feature_matrix[1] for img in images]).squeeze() np.nan_to_num(data_train, copy=False) # warnings.warn('Random forest parameters not properly set.') forest = sk_ensemble.RandomForestClassifier(max_features=images[0].feature_matrix[0].shape[1], n_estimators=pre_process_params['n_estimators'], # 100 max_depth=pre_process_params['max_depth']) # 10 # Debugging nan_data_idx = np.argwhere(np.isnan(data_train)) np.savez('data_train.npz', data_train) np.save('data_nan.npy', nan_data_idx) start_time = timeit.default_timer() forest.fit(data_train, labels_train) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # create a result directory with timestamp result_dir = os.path.join(result_dir, pre_process_params['experiment_name']) os.makedirs(result_dir, exist_ok=True) print('-' * 5, 'Testing...') # initialize evaluator evaluator = putil.init_evaluator() # crawl the training image directories crawler = futil.FileSystemDataCrawler(data_test_dir, LOADING_KEYS, futil.BrainImageFilePathGenerator(), futil.DataDirectoryFilter()) # load images for testing and pre-process pre_process_params['training'] = False images_test = putil.pre_process_batch(crawler.data, pre_process_params, multi_process=False) images_prediction = [] images_probabilities = [] for img in images_test: print('-' * 10, 'Testing', img.id_) start_time = timeit.default_timer() predictions = forest.predict(np.nan_to_num(img.feature_matrix[0],copy=False)) probabilities = forest.predict_proba(np.nan_to_num(img.feature_matrix[0],copy=False)) print(' Time elapsed:', timeit.default_timer() - start_time, 's') # convert prediction and probabilities back to SimpleITK images image_prediction = conversion.NumpySimpleITKImageBridge.convert(predictions.astype(np.uint8), img.image_properties) image_probabilities = conversion.NumpySimpleITKImageBridge.convert(probabilities, img.image_properties) # evaluate segmentation without post-processing evaluator.evaluate(image_prediction, img.images[structure.BrainImageTypes.GroundTruth], img.id_) images_prediction.append(image_prediction) images_probabilities.append(image_probabilities) # post-process segmentation and evaluate with post-processing post_process_params = {'simple_post': True} images_post_processed = putil.post_process_batch(images_test, images_prediction, images_probabilities, post_process_params, multi_process=False) for i, img in enumerate(images_test): evaluator.evaluate(images_post_processed[i], img.images[structure.BrainImageTypes.GroundTruth], img.id_ + '-PP') # save results sitk.WriteImage(images_prediction[i], os.path.join(result_dir, images_test[i].id_ + '_SEG.mha'), True) sitk.WriteImage(images_post_processed[i], os.path.join(result_dir, images_test[i].id_ + '_SEG-PP.mha'), True) # use two writers to report the results os.makedirs(result_dir, exist_ok=True) # generate result directory, if it does not exists result_file = os.path.join(result_dir, 'results.csv') writer.CSVWriter(result_file).write(evaluator.results) print('\nSubject-wise results...') writer.ConsoleWriter().write(evaluator.results) # report also mean and standard deviation among all subjects result_summary_file = os.path.join(result_dir, 'results_summary.csv') functions = {'MEAN': np.mean, 'STD': np.std} writer.CSVStatisticsWriter(result_summary_file, functions=functions).write(evaluator.results) print('\nAggregated statistic results...') writer.ConsoleStatisticsWriter(functions=functions).write(evaluator.results) # clear results such that the evaluator is ready for the next evaluation evaluator.clear() end_main = timeit.default_timer() main_time = end_main - start_main # writing information on a txt file reporter.feature_writer(result_dir, pre_process_params, main_time, 'feature_report')