def main(): parser = cli.parse_command_line() args = parser.parse_args() if args.task == "train" and args.mode == "slice": args.mode_task = "cnn" commandline = parser.parse_known_args() arguments = vars(args) if (arguments['task'] != 'preprocessing') \ and (arguments['task'] != 'extract') \ and (arguments['task'] != 'generate') \ and (arguments['task'] != 'tsvtool') \ and (arguments['task'] != 'quality_check') \ and (arguments['task'] != 'classify'): commandline_to_json(commandline) text_file = open(path.join(args.output_dir, 'environment.txt'), 'w') text_file.write('Version of python: %s \n' % sys.version) text_file.write('Version of pytorch: %s \n' % torch.__version__) text_file.close() if arguments['task'] in ['train', 'quality_check']: if not args.use_cpu and not torch.cuda.is_available(): raise ValueError( "No GPU is available. Please add the -cpu flag to run on CPU.") args.func(args)
def main(): parser = cli.parse_command_line() args = parser.parse_args() if args.task == "train" and args.mode == "slice": args.mode_task = "cnn" commandline = parser.parse_known_args() arguments = vars(args) if (arguments['task'] != 'preprocessing') \ and (arguments['task'] != 'extract') \ and (arguments['task'] != 'generate') \ and (arguments['task'] != 'tsvtool') \ and (arguments['task'] != 'quality_check') \ and (arguments['task'] != 'classify'): commandline_to_json(commandline) write_requirements_version(args.output_dir) if hasattr(args, "use_cpu"): if not args.use_cpu and not torch.cuda.is_available(): raise ValueError( "No GPU is available. Please add the -cpu flag to run on CPU.") args.func(args)
def main(): parser = cli.parse_command_line() args = parser.parse_args() commandline = parser.parse_known_args() if args.train_autoencoder: model_type = 'autoencoder' else: model_type = 'cnn' commandline_to_json(commandline, model_type) args.func(args)
def main(): parser = cli.parse_command_line() args = parser.parse_args() print(args) commandline = parser.parse_known_args() if hasattr(args, 'train_autoencoder'): model_type = 'autoencoder' else: model_type = 'cnn' arguments = vars(args) if arguments['task'] != 'preprocessing': commandline_to_json(commandline, model_type) args.func(args)
optimizer = eval("torch.optim." + params.optimizer)( filter(lambda x: x.requires_grad, model.parameters()), lr=params.learning_rate, weight_decay=params.weight_decay) setattr(params, 'beginning_epoch', 0) # Define output directories log_dir = os.path.join(params.output_dir, 'fold-%i' % fi, 'tensorboard_logs') model_dir = os.path.join(params.output_dir, 'fold-%i' % fi, 'models') print('Beginning the training task') train(model, train_loader, valid_loader, criterion, optimizer, False, log_dir, model_dir, params) test_cnn(train_loader, "train", fi, criterion, options) test_cnn(valid_loader, "validation", fi, criterion, options) total_time = time() - total_time print("Total time of computation: %d s" % total_time) if __name__ == "__main__": commandline = parser.parse_known_args() commandline_to_json(commandline) options = commandline[0] if commandline[1]: raise Exception("unknown arguments: %s" % (parser.parse_known_args()[1])) train_CNN_bad_data_split(options)
valid_df, metrics_valid, fi, dataset='validation', selection=selection) soft_voting_to_tsvs(params.output_dir, fi, dataset='train', selection=selection, selection_threshold=params.selection_threshold) soft_voting_to_tsvs(params.output_dir, fi, dataset='validation', selection=selection, selection_threshold=params.selection_threshold) torch.cuda.empty_cache() total_time = time() - total_time print("Total time of computation: %d s" % total_time) if __name__ == "__main__": commandline = parser.parse_known_args() commandline_to_json(commandline, "CNN") options = commandline[0] if commandline[1]: raise Exception("unknown arguments: %s" % (parser.parse_known_args()[1])) train_CNN_bad_data_split(options)
def inference_from_model(caps_dir, tsv_path, model_path=None, json_file=None, prefix=None, labels=True, gpu=True, num_workers=0, batch_size=1, prepare_dl=False, selection_metrics=None, diagnoses=None, logger=None, multi_cohort=False): """ Inference from previously trained model. This functions uses a previously trained model to classify the input(s). The model is stored in the variable model_path and it assumes the folder structure given by the training stage. Particullary to have a prediction at image level, it assumes that results of the validation set are stored in the model_path folder in order to perform soft-voiting at the slice/patch level and also for multicnn. Args: caps_dir: folder containing the tensor files (.pt version of MRI) tsv_path: file with the name of the MRIs to process (single or multiple) model_path: file with the model (pth format). json_file: file containing the training parameters. prefix: prefix of all classification outputs. labels: by default is True. If False no metrics tsv files will be written. measurements.tsv gpu: if true, it uses gpu. num_workers: num_workers used in DataLoader batch_size: batch size of the DataLoader prepare_dl: if true, uses extracted patches/slices otherwise extract them on-the-fly. selection_metrics: list of metrics to find best models to be evaluated. diagnoses: list of diagnoses to be tested if tsv_path is a folder. logger: Logger instance. multi_cohort (bool): If True caps_directory is the path to a TSV file linking cohort names and paths. Returns: Files written in the output folder with prediction results and metrics. By default the output folder is named cnn_classification and it is inside the model_folder. Raises: """ import argparse import logging if logger is None: logger = logging parser = argparse.ArgumentParser() parser.add_argument("model_path", type=str, help="Path to the trained model folder.") options = parser.parse_args([model_path]) options = read_json(options, json_path=json_file) logger.debug("Load model with these options:") logger.debug(options) # Overwrite options with user input options.use_cpu = not gpu options.nproc = num_workers options.batch_size = batch_size if diagnoses is not None: options.diagnoses = diagnoses options = translate_parameters(options) if options.mode_task == "multicnn": num_cnn = compute_num_cnn(caps_dir, tsv_path, options, "test") else: num_cnn = None # Define the path currentDirectory = pathlib.Path(model_path) # Search for 'fold-*' pattern currentPattern = "fold-*" # loop depending the number of folds found in the model folder for fold_dir in currentDirectory.glob(currentPattern): fold = int(str(fold_dir).split("-")[-1]) out_path = join(fold_dir, 'models') for selection_metric in selection_metrics: if options.mode_task == 'multicnn': for cnn_dir in listdir(out_path): if not exists( join(out_path, cnn_dir, "best_%s" % selection_metric, 'model_best.pth.tar')): raise FileNotFoundError( errno.ENOENT, strerror(errno.ENOENT), join(out_path, cnn_dir, "best_%s" % selection_metric, 'model_best.pth.tar')) else: full_model_path = join(out_path, "best_%s" % selection_metric) if not exists(join(full_model_path, 'model_best.pth.tar')): raise FileNotFoundError( errno.ENOENT, strerror(errno.ENOENT), join(full_model_path, 'model_best.pth.tar')) performance_dir = join(fold_dir, 'cnn_classification', 'best_%s' % selection_metric) makedirs(performance_dir, exist_ok=True) commandline_to_json( { "output_dir": model_path, "caps_dir": caps_dir, "tsv_path": tsv_path, "prefix": prefix, "labels": labels }, filename=f"commandline_classify-{prefix}") # It launch the corresponding function, depending on the mode. inference_from_model_generic(caps_dir, tsv_path, out_path, options, prefix, currentDirectory, fold, "best_%s" % selection_metric, labels=labels, num_cnn=num_cnn, logger=logger, multi_cohort=multi_cohort, prepare_dl=prepare_dl) # Soft voting if hasattr(options, 'selection_threshold'): selection_thresh = options.selection_threshold else: selection_thresh = 0.8 # Write files at the image level (for patch, roi and slice). # It assumes the existance of validation files to perform soft-voting if options.mode in ["patch", "roi", "slice"]: soft_voting_to_tsvs(currentDirectory, fold, "best_%s" % selection_metric, options.mode, prefix, num_cnn=num_cnn, selection_threshold=selection_thresh, use_labels=labels, logger=logger) logger.info("Prediction results and metrics are written in the " "following folder: %s" % performance_dir)