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'])