def main(): parser = argparse.ArgumentParser() parser.add_argument('--yaml-config', type=str, default='simg_bmi_regression_18_nfs.yaml') # parser.add_argument('--idx-fold', type=int, default=4) args = parser.parse_args() SRC_ROOT = os.path.dirname(os.path.realpath(__file__)) + '/..' yaml_config = os.path.join(SRC_ROOT, f'src/yaml/{args.yaml_config}') logger.info(f'Read yaml file {yaml_config}') f = open(yaml_config, 'r').read() config = yaml.safe_load(f) scatter_plot_dir = os.path.join( '/nfs/masi/xuk9/SPORE/CAC_class/prediction_plots', args.yaml_config) mkdir_p(scatter_plot_dir) for idx_fold in range(5): exp_dir = config['exp_dir'] pred_result_csv = osp.join(exp_dir, f'fold_{idx_fold}/test/predict.csv') pred_result_df = pd.read_csv(pred_result_csv, index_col=False) out_png = os.path.join(scatter_plot_dir, f'fold_{idx_fold}.png') plot_prediction_scatter(pred_result_df, out_png)
def save_average(cam_list_dict, out_folder): mkdir_p(out_folder) for flag in cam_list_dict: # print(cam_list_dict) file_path_list = cam_list_dict[flag] print(f'{flag}: {len(file_path_list)}') out_file = osp.join(out_folder, f'{flag}.nii.gz')
def main(): parser = argparse.ArgumentParser( description='Run preprocess on in data folder') parser.add_argument('--config', type=str, help='Path to the YAML config file', required=True) parser.add_argument('--in-ori-folder', type=str, help='Folder of input data', required=True) parser.add_argument('--in-jac-folder', type=str, required=True) parser.add_argument('--mask-img-path', type=str, required=True) parser.add_argument('--in-file-list', type=str, help='file list to use in pca') parser.add_argument('--out-pc-folder', type=str, help='Output location of principle images') parser.add_argument('--n-components', type=int, help='Number of pc', required=True) parser.add_argument('--batch-size', type=int, help='Batch size') parser.add_argument('--save-pca-result-path', type=str, help='Save the result to the given location') parser.add_argument('--load-pca-obj-file-path', type=str) args = parser.parse_args() config = load_config(args.config) scan_folder_reader = ScanFolderConcatBatchReaderWithMask( args.mask_img_path, config, args.in_ori_folder, args.in_jac_folder, args.batch_size, file_list_txt=args.in_file_list) pca_nii_3d = PCA_NII_3D_Batch(scan_folder_reader, None, args.n_components) if args.load_pca_obj_file_path: pca_nii_3d.load_pca(args.load_pca_obj_file_path) else: pca_nii_3d.run_pca() if args.save_pca_result_path: pca_nii_3d.save_pca_obj(args.save_pca_result_path) if args.out_pc_folder: mkdir_p(args.out_pc_folder) pca_nii_3d.write_pc(args.out_pc_folder)
def __init__(self, config, in_folder, out_folder, average_img, file_list_txt=None): super().__init__(config, in_folder, file_list_txt=file_list_txt) self._out_data_folder = DataFolder.get_data_folder_obj( config, out_folder, data_list_txt=file_list_txt) mkdir_p(out_folder) self._average_img = ScanWrapper(average_img)
def __init__(self, config, in_folder, out_folder, ref_img, order=3): super().__init__(config, in_folder) self._c3d = config['c3d_exe'] self._file_list = self._get_file_list(config['data_file_list']) self._spacing_config = config['spacing'] self._in_folder = in_folder self._out_folder = out_folder mkdir_p(out_folder) self._order = order self._reg_resample = config['niftyreg_resample'] self._reg_resmaple_ref = config['reg_resample_ref_img']
def __init__(self, config, in_folder, out_folder, roi_img, file_list_txt=None): super().__init__(config, in_folder, file_list_txt=file_list_txt) # self._out_data_folder = DataFolder.get_data_folder_obj(config, out_folder, data_list_txt=file_list_txt) self._out_data_folder = DataFolder.get_data_folder_obj_with_list( out_folder, self._in_data_folder.get_data_file_list()) mkdir_p(out_folder) self._roi_img_path = roi_img self._reg_resample_path = config['niftyreg_resample']
def _plot_stacked_view( self, num_clip, step_clip, in_img_data, in_back_data, view_flag, out_png_folder, unit_ratio ): front_img_array = [] back_img_array = [] for clip_idx in range(num_clip): clip_off_set = (clip_idx - 2) * step_clip back_slice = self._clip_image(in_back_data, view_flag, clip_off_set) img_slice = self._clip_image(in_img_data, view_flag, clip_off_set) front_img_array.append(img_slice) back_img_array.append(back_slice) front_img = np.concatenate(front_img_array, axis=0) back_img = np.concatenate(back_img_array, axis=0) fig, ax = plt.subplots() plt.axis('off') ax.imshow( back_img, interpolation='none', cmap='gray', norm=colors.Normalize(vmin=self._vmin_back, vmax=self._vmax_back), alpha=0.7 ) ax.imshow( front_img, interpolation='none', cmap='jet', norm=colors.Normalize(vmin=self._vmin, vmax=self._vmax), alpha=0.5 ) ax.set_aspect(unit_ratio) view_root = os.path.join(out_png_folder, f'{view_flag}') mkdir_p(view_root) out_png_path = os.path.join(view_root, f'{self._in_img_name_no_ext}.png') print(f'Save overlay png to {out_png_path}') plt.savefig(out_png_path, bbox_inches='tight', pad_inches=0) plt.close()
def main(): parser = argparse.ArgumentParser( description='Run preprocess on in data folder') parser.add_argument('--config', type=str, help='Path to the YAML config file', required=True) parser.add_argument('--in-folder', type=str, help='Folder of input data', required=True) parser.add_argument('--ref-img', type=str, help='Use the average as reference image', required=True) parser.add_argument('--out-pc-folder', type=str, help='Output location of principle images') parser.add_argument('--out-mean-img', type=str, help='Output the mean of pca', required=True) parser.add_argument('--n-components', type=int, help='Number of pc', required=True) parser.add_argument('--save-pca-result-path', type=str, help='Save the result to the given location') args = parser.parse_args() config = load_config(args.config) scan_folder_reader = ScanFolderFlatReader(config, args.in_folder, args.ref_img) scan_folder_reader.read_data() pca_nii_3d = PCA_NII_3D(scan_folder_reader, args.ref_img, args.n_components) pca_nii_3d.run_pca() if args.save_pca_result_path: pca_nii_3d.save_pca_obj(args.save_pca_result_path) if args.out_pc_folder: mkdir_p(args.out_pc_folder) pca_nii_3d.write_pc(args.out_pc_folder) if args.out_mean_img: pca_nii_3d.write_mean(args.out_mean_img)
def _plot_view(self, num_clip, step_clip, in_img_data, in_back_data, view_flag, out_png_folder, unit_ratio ): for clip_idx in range(num_clip): fig, ax = plt.subplots() plt.axis('off') clip_off_set = (clip_idx - 2) * step_clip if in_back_data is not None: back_slice = self._clip_image(in_back_data, view_flag, clip_off_set) im_back = ax.imshow( back_slice, interpolation='none', cmap='gray', norm=colors.Normalize(vmin=self._vmin_back, vmax=self._vmax_back), alpha=0.7 ) img_slice = self._clip_image(in_img_data, view_flag, clip_off_set) im = ax.imshow( img_slice, interpolation='none', cmap='jet', norm=colors.Normalize(vmin=self._vmin, vmax=self._vmax), alpha=0.5 ) ax.set_aspect(unit_ratio) if self._unit_label is not None: divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="5%", pad=0.05/unit_ratio) cb = plt.colorbar(im, cax=cax) cb.set_label(self._unit_label) view_root = os.path.join(out_png_folder, f'{view_flag}') mkdir_p(view_root) out_png_path = os.path.join(view_root, f'{self._in_img_name_no_ext}_{clip_idx}.png') print(f'Save overlay png to {out_png_path}') plt.savefig(out_png_path, bbox_inches='tight', pad_inches=0) plt.close()
def main(): parser = argparse.ArgumentParser(description='Load a saved pca object') parser.add_argument('--pc-folder', type=str, help='Location of the principle feature images') parser.add_argument('--file-list-txt', type=str) parser.add_argument('--out-png-folder', type=str) parser.add_argument('--step-axial', type=int, default=50) parser.add_argument('--step-sagittal', type=int, default=75) parser.add_argument('--step-coronal', type=int, default=30) parser.add_argument('--num-show-pc-each-row', type=int, default=10) args = parser.parse_args() mkdir_p(args.out_png_folder) pc_folder_obj = DataFolder(args.pc_folder, args.file_list_txt) plt_obj = PlotPCGrid(pc_folder_obj, args.step_axial, args.step_sagittal, args.step_coronal, args.num_show_pc_each_row) plt_obj.plot_pc_each_view(args.out_png_folder)
def clip_plot(self, out_png_folder): in_int_obj = ScanWrapper(self._in_int_path) in_jac_obj = ScanWrapper(self._in_jac_path) in_att_obj = ScanWrapper(self._in_att_path) in_int_data = in_int_obj.get_data() in_jac_data = in_jac_obj.get_data() in_att_data = in_att_obj.get_data() fig, axs = plt.subplots(1, 3, constrained_layout=True, figsize=(30, 30)) # plt.axis('off') for ax in axs: ax.axis('off') self._plot_view( self._num_clip, self._step_axial, in_int_data, in_jac_data, in_att_data, 'axial', 1, axs[0] ) self._plot_view( self._num_clip, self._step_coronal, in_int_data, in_jac_data, in_att_data, 'coronal', 5.23438 / 2.17388, axs[1] ) self._plot_view( self._num_clip, self._step_sagittal, in_int_data, in_jac_data, in_att_data, 'sagittal', 5.23438 / 2.28335, axs[2] ) out_root_folder = os.path.join(out_png_folder, 'stacked') mkdir_p(out_root_folder) out_png_path = os.path.join(out_root_folder, f'{self._in_img_file_name}.png') print(f'Save overlay png to {out_png_path}') plt.savefig(out_png_path, bbox_inches='tight', pad_inches=0) plt.close()
def main(): parser = argparse.ArgumentParser(description='Load a saved pca object') parser.add_argument('--pc-folder', type=str, help='Location of the principle feature images') parser.add_argument('--file-list-txt', type=str) # parser.add_argument('--out-png', type=str) parser.add_argument('--out-png-folder', type=str) parser.add_argument('--vmin', type=float, default=-0.001) parser.add_argument('--vmax', type=float, default=0.001) args = parser.parse_args() slices_x, slices_y, slices_z = _get_slices_dim_list(args.pc_folder, args.file_list_txt) mkdir_p(args.out_png_folder) out_png_x = os.path.join(args.out_png_folder, 'sagittal.png') out_png_y = os.path.join(args.out_png_folder, 'coronal.png') out_png_z = os.path.join(args.out_png_folder, 'axial.png') _draw_10_pc_plot(slices_x, out_png_x, args.vmax, args.vmin) _draw_10_pc_plot(slices_y, out_png_y, args.vmax, args.vmin) _draw_10_pc_plot(slices_z, out_png_z, args.vmax, args.vmin)
def main(): parser = argparse.ArgumentParser(description='Load a saved pca object') parser.add_argument('--config', type=str, help='Path to the YAML config file', required=True) parser.add_argument('--in-folder', type=str, help='Location of the input images') parser.add_argument('--mask-img', type=str, help='Binary mask image') parser.add_argument('--out-png-folder', type=str, help='Output png file folder') parser.add_argument('--file-list-txt', type=str) args = parser.parse_args() mkdir_p(args.out_png_folder) config = load_config(args.config) plot_obj = OverlayMaskPNG(config, args.in_folder, args.mask_img, args.out_png_folder, args.file_list_txt) plot_obj.run_parallel()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--yaml-config', type=str, default=default_yaml_config) parser.add_argument('--cam-folder', type=str, default=cam_folder_nfs) args = parser.parse_args() mkdir_p(args.cam_folder) SRC_ROOT = os.path.dirname(os.path.realpath(__file__)) + '/..' yaml_config = os.path.join(SRC_ROOT, f'src/yaml/{args.yaml_config}') logger.info(f'Read yaml file {yaml_config}') f = open(yaml_config, 'r').read() config = yaml.safe_load(f) num_fold = config['fold_num'] exp_dir = config['exp_dir'] layer_flag = config['gcam_target_layer'] file_path_list_array = [] for idx_fold in range(num_fold): # for idx_fold in range(0, 1): pred_result_csv = osp.join(exp_dir, f'fold_{idx_fold}/test/predict.csv') cam_folder = osp.join(exp_dir, f'fold_{idx_fold}/grad_CAM/test.{layer_flag}') mkdir_p(cam_folder) pred_result_df = pd.read_csv(pred_result_csv, index_col=False) file_list = pred_result_df['file_name'] file_path_list = [osp.join(cam_folder, file_name) for file_name in file_list] # out_average_path = osp.join(exp_dir, f'fold_{idx_fold}/cam_average_layer2.nii.gz') # get_average_map(file_path_list, out_average_path) file_path_list_array += file_path_list # cam_analysis_folder = osp.join(exp_dir, f'cam_analysis') # mkdir_p(cam_analysis_folder) # out_average_path = osp.join(cam_analysis_folder, 'averaged_all.nii.gz') out_average_path = osp.join(args.cam_folder, f'{args.yaml_config}.{layer_flag}.nii.gz') get_average_map(file_path_list_array, out_average_path)
def main(): # yaml_config = 'simg_bmi_regression_3.6.3_nfs.yaml' yaml_config = 'simg_bmi_regression_3.6.4_nfs.yaml' # yaml_config = 'simg_bmi_regression_3.6.6.1_nfs.yaml' SRC_ROOT = os.path.dirname(os.path.realpath(__file__)) + '/..' yaml_config = os.path.join(SRC_ROOT, f'src/yaml/{yaml_config}') logger.info(f'Read yaml file {yaml_config}') f = open(yaml_config, 'r').read() config = yaml.safe_load(f) num_fold = config['fold_num'] exp_dir = config['exp_dir'] layer_flag = config['gcam_target_layer'] gcam_overlay_out_folder = os.path.join(exp_dir, 'gcam_overlay') gcam_link_out_folder = os.path.join(exp_dir, 'gcam_link') mkdir_p(gcam_overlay_out_folder) mkdir_p(gcam_link_out_folder) pred_result_csv = os.path.join(exp_dir, f'pred_total.csv') file_list = pd.read_csv(pred_result_csv, index_col=False)['file_name'] in_int_folder_obj = DataFolder(atlas_intensity_folder, file_list) in_jac_folder_obj = DataFolder(atlas_jacobian_folder, file_list) in_att_folder_obj = DataFolder(gcam_link_out_folder, file_list) paral_plot_obj = ParaPlotClip( in_int_folder_obj, in_jac_folder_obj, in_att_folder_obj, gcam_overlay_out_folder, 10 ) paral_plot_obj.run_parallel()
def mkdir(self): mkdir_p(self._in_folder)
def get_data(exp_dir, num_fold): gt_list = [] pred_list = [] rmse_list = [] file_name_list = [] mean_diff_list = [] fold_output_root = os.path.join(exp_dir, 'pred_plot') mkdir_p(fold_output_root) for idx_fold in range(num_fold): pred_result_csv = osp.join(exp_dir, f'fold_{idx_fold}/test/predict.csv') pred_result_df = pd.read_csv(pred_result_csv, index_col=False) pred = pred_result_df['pred'].to_numpy() label = pred_result_df['target'].to_numpy() file = pred_result_df['file_name'].to_list() file_name_list += file rmse_val = sqrt(mean_squared_error(label, pred)) out_fold_mean_diff_png = os.path.join(fold_output_root, f'mean_diff_{idx_fold}.png') out_fold_scatter_png = os.path.join(fold_output_root, f'scatter_{idx_fold}.png') mean_diff_plot(pred, label, np.array([rmse_val]), out_fold_mean_diff_png) scatter_plot(pred, label, np.array([rmse_val]), out_fold_scatter_png) mean_diff = np.mean(pred - label) mean_diff_list.append(mean_diff) print(f'Mean diff: {mean_diff:.3f}') rmse_list.append(rmse_val) gt_list.append(label) pred_list.append(pred) rmse_list = np.array(rmse_list) # print(f'RMSE mean: {np.mean(rmse_list):.4f}, std: {np.std(rmse_list):.4f}') pred_list = np.concatenate(pred_list) gt_list = np.concatenate(gt_list) mean_diff_png = osp.join(exp_dir, 'mean_diff.png') scatter_png = osp.join(exp_dir, 'pred_scatter.png') mean_diff_plot(pred_list, gt_list, rmse_list, mean_diff_png) scatter_plot(pred_list, gt_list, rmse_list, scatter_png) print( f'mean diff: mean {np.mean(np.array(mean_diff_list))}, std {np.std(np.array(mean_diff_list))}' ) # output the diff data_dict = { 'file_name': file_name_list, 'pred': pred_list, 'label': gt_list, 'diff': pred_list - gt_list, 'diff_abs': np.abs(pred_list - gt_list) } data_df = pd.DataFrame(data_dict) out_csv = os.path.join(exp_dir, f'pred_total.csv') print(f'Save to {out_csv}') data_df.to_csv(out_csv, index=False)
from src.tools.data_io import ScanWrapper import numpy as np import yaml import pandas as pd import matplotlib.pyplot as plt import yaml from tools.plot import mean_diff_plot, scatter_plot logger = get_logger('Analyze missing ROI') in_body_mask = '/nfs/masi/xuk9/SPORE/CAC_class/data/atlas/atlas_body_mask/body_seg_resampled.nii.gz' body_mask_overlap_roi_folder = '/nfs/masi/xuk9/SPORE/CAC_class/data/atlas/valid_region/s6_body_mask_intersect' file_list_txt = '/nfs/masi/xuk9/SPORE/CAC_class/file_lists/result_temporal' out_analyze_missing_roi_folder = '/nfs/masi/xuk9/SPORE/CAC_class/clinical/missing_roi' mkdir_p(out_analyze_missing_roi_folder) out_missing_ratio_csv = os.path.join(out_analyze_missing_roi_folder, 'missing_ratio.csv') def _get_sess_missing_ratio(file_name): body_mask_data = ScanWrapper(in_body_mask).get_data() in_mask_data = ScanWrapper( os.path.join(body_mask_overlap_roi_folder, file_name)).get_data() missing_ratio = 1 - (np.sum(in_mask_data.astype(int))) / (np.sum( body_mask_data.astype(int))) return missing_ratio
import os.path as osp from src.tools.utils import get_logger from tools.utils import mkdir_p from src.tools.plot import ClipPlotSeriesWithBack from src.tools.utils import read_file_contents_list, save_file_contents_list, get_logger from src.tools.data_io import ScanWrapper import numpy as np import yaml import pandas as pd import matplotlib.pyplot as plt import yaml from tools.plot import mean_diff_plot, scatter_plot in_folder = '/nfs/masi/xuk9/SPORE/CAC_class/debug' out_png_folder = '/nfs/masi/xuk9/SPORE/CAC_class/debug_png' mkdir_p(out_png_folder) file_list_txt = '/nfs/masi/xuk9/SPORE/CAC_class/debug/file_list' def axial_clip_plot_native(): file_name_list = read_file_contents_list(file_list_txt) for file_name in file_name_list: in_img_path = os.path.join(in_folder, file_name) cliper_obj = ClipPlotSeriesWithBack(in_img_path, None, None, 10, 35, 15, 1, -255, 255, None, None, None) cliper_obj.clip_plot_img_only(out_png_folder) def main(): axial_clip_plot_native()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--yaml-config', type=str, default='simg_bmi_regression_3.6.6.2_nfs.yaml') parser.add_argument('--run-train', type=str, default='True') parser.add_argument('--run-test', type=str, default='False') parser.add_argument('--run-grad-cam', type=str, default='False') parser.add_argument('--train-fold', type=int, default=0) args = parser.parse_args() SRC_ROOT = os.path.dirname(os.path.realpath(__file__)) + '/..' yaml_config = os.path.join(SRC_ROOT, f'src/yaml/{args.yaml_config}') logger.info(f'Read yaml file {yaml_config}') f = open(yaml_config, 'r').read() config = yaml.safe_load(f) out_folder = config['exp_dir'] learning_rate = config['learning_rate'] batch_size = config['batch_size'] epoch_num = config['epoch_num'] fold_num = config['fold_num'] mkdir_p(out_folder) # load CUDA cuda = torch.cuda.is_available() print(f'cuda: {cuda}') # cuda = False torch.manual_seed(1) # Create data loader train_loader_list, valid_loader_list, test_loader_list = get_data_loader_cv(config) # Create trainer list performance_array = [] for idx_fold in range(fold_num): # If train only one fold if args.train_fold != -1: # Only train on specified fold. if args.train_fold != idx_fold: continue # Create model model = create_model(config) if cuda: torch.cuda.manual_seed(1) model = model.cuda() # load optimizor optim = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999)) # Create trainer fold_out_folder = os.path.join(out_folder, f'fold_{idx_fold}') train_loader = train_loader_list[idx_fold] validate_loader = valid_loader_list[idx_fold] test_loader = test_loader_list[idx_fold] trainer_obj = Trainer( cuda, model, optimizer=optim, train_loader=train_loader, validate_loader=validate_loader, test_loader=test_loader, out=fold_out_folder, max_epoch=epoch_num, batch_size=batch_size, config=config ) # Train trainer_obj.epoch = config['start_epoch'] if args.run_train == 'True': trainer_obj.train_epoch() # Test if args.run_test == 'True': trainer_obj.run_test() performance_array.append(trainer_obj.test_performance) if args.run_grad_cam == 'True': trainer_obj.run_grad_cam() if args.run_test == 'True': mse_array = np.array([statics_dict['loss'] for statics_dict in performance_array]) rmse_array = np.sqrt(mse_array) rmse_mean = np.mean(rmse_array) rmse_std = np.std(rmse_array) perf_str = f'RMSE {rmse_mean:.5f} ({rmse_std:.5f})\n' print(f'Performance of cross-validation:') print(perf_str) perf_file = os.path.join(out_folder, 'perf') with open(perf_file, 'w') as fv: fv.write(perf_str) fv.close()
from src.tools.utils import read_file_contents_list, save_file_contents_list, get_logger from src.tools.data_io import ScanWrapper import numpy as np import yaml import pandas as pd import matplotlib.pyplot as plt import yaml from tools.plot import mean_diff_plot, scatter_plot logger = get_logger('Analyze Round FOV') in_native_folder = '/nfs/masi/xuk9/SPORE/CAC_class/data/s14_ori_final_resample' file_list_txt = '/nfs/masi/xuk9/SPORE/CAC_class/file_lists/result_temporal' out_folder_axial_clip = '/nfs/masi/xuk9/SPORE/CAC_class/axial_clip_native' mkdir_p(out_folder_axial_clip) def axial_clip_plot_native(): file_name_list = read_file_contents_list(file_list_txt) for file_name in file_name_list: in_img_path = os.path.join(in_native_folder, file_name) cliper_obj = ClipPlotSeriesWithBack(in_img_path, None, None, 10, 35, 15, 1, -3000, 1000, None, None, None) cliper_obj.clip_plot_img_only(out_folder_axial_clip) fov_file_list_folder = '/nfs/masi/xuk9/SPORE/CAC_class/file_lists/fov' mkdir_p(fov_file_list_folder) out_file_list_round_fov = '/nfs/masi/xuk9/SPORE/CAC_class/file_lists/fov/round_fov'
import argparse from tools.classifier import MinibatchLinearClassifierWithCV from tools.utils import read_file_contents_list, mkdir_p from tools.clinical_spore_summary_characteristics import ClinicalDataReaderSPORE import pandas as pd from tools.data_io import save_object, load_object from os import path # in_folder = '/nfs/masi/xuk9/SPORE/clustering/registration/20200512_corrField/male/pca_concat/data/jac/trimed' in_folder = '/nfs/masi/xuk9/SPORE/clustering/registration/20200512_corrField/male/pca_concat/data/jac/trimed_downsampled' file_list_txt = '/nfs/masi/xuk9/SPORE/clustering/registration/20200512_corrField/male/data/success_list_include_cancer' in_csv_file = '/nfs/masi/xuk9/SPORE/clustering/registration/20200512_corrField/male/clinical/label_full.csv' proj_folder = '/nfs/masi/xuk9/SPORE/clustering/registration/20200512_corrField/male/hypothesis_2/train_classifier' mkdir_p(proj_folder) num_fold = 5 batch_size = 10 if_run_training = False if_run_validation = True def main(): file_list = read_file_contents_list(file_list_txt) clinical_data_reader = ClinicalDataReaderSPORE.create_spore_data_reader_csv( in_csv_file) label_list = clinical_data_reader.get_label_for_obese(file_list) data_tuples = list(zip(file_list, label_list)) label_df = pd.DataFrame(data_tuples, columns=['scan', 'label'])