data/src/main_train.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Author: Mélanie Gaillochet
Date: 2020-11-18
"""
from comet_ml import Experiment
import argparse
import copy
import json
import math
import os
import random
import time
import pandas as pd
from datetime import datetime
from types import SimpleNamespace

import numpy as np
import torch
import torch.utils.data as data
from torch.utils.data.sampler import SubsetRandomSampler

from Configs.configs import data_folder, output_folder, random_indices_folder
from Data_loader.data_loader import MyDataset
from Enums.model_enum import all_models
from Enums.solver_enum import all_solvers
from Saver.saver import Saver
from Utils.load_utils import get_config_from_json, create_unexisting_folder
from Utils.main_utils import update_kwargs
from Utils.utils import set_all_seed, print_args, convert_time, round_dic_values, NpEncoder
from Utils.sampler_utils import SubsetSequentialSampler, InfiniteSubsetRandomSampler

#from contrastyou.data.creator import get_data


def run_experiment(raw_args=None):
    """
    We run a single experiment with the given configs
    :param raw_args:
    :return:
    """
    parser = argparse.ArgumentParser()
    parser.add_argument('-c', '--config', type=str, help='config file path ')
    parser.add_argument('--device', type=str, help='device file path ')
    parser.add_argument('--seed', type=int,
                        help='seed to use for randomness', default=42)
    parser.add_argument('--init_labeled', type=str,
                        help="initial labeled indices if 'labels....' or number of initial indices")
    parser.add_argument('--init_num_labeled', type=int,
                        help="number initial labeled indices")
    args = parser.parse_args(raw_args)
    print_args(args)

    # We load the json config file
    config = get_config_from_json(args.config)
    train_config = config['training']
    batch_size = train_config['batch_size']

    # Making experiment replicable
    set_all_seed(args.seed)
    if train_config['deterministic']:
        torch.use_deterministic_algorithms(True)
        torch.backends.cudnn.benchmark = False
        torch.backends.cudnn.deterministic = True

    iter_start_time = time.time()
    if 'overall_start_time' in config.keys():
        overall_start_time = config['overall_start_time']
    else:
        start_time = datetime.today()
        overall_start_time = '{}_{}h{}min'.format(start_time.date(), start_time.hour,
                                                  start_time.minute)

    print('\nUsing {} sample selection\n'.format(train_config['data_selection']['type']))

    torch.cuda.empty_cache()
    device = torch.device(args.device if torch.cuda.is_available() else "cpu")

    # We make the test dataset
    test_data_config = config['data'].copy()
    test_set_name = config['data']['dataset_name'].replace('train', 'test')
    test_data_config['dataset_name'] = test_set_name
    test_data_config['augment'] = False
    test_dataset = MyDataset(data_folder, test_data_config)
    test_dataloader = data.DataLoader(test_dataset, batch_size=1, drop_last=False,
                                        num_workers=train_config['num_workers'],
                                        persistent_workers=True,
                                        pin_memory=True)
    test_dataloader.dataset.training = False

    # We get the test volume lists (for results on 3D volume)
    txt_filepath = os.path.join(data_folder, test_set_name, 'test_indices.txt')
    with open(txt_filepath, encoding='utf8') as f:
        for line in f:
            if 'test_volume_list' in line:
                test_volume_list = line.strip('test_volume_list = ')
                test_volume_list = eval(test_volume_list)

    print('We will be testing on: {} ({} samples from {} volumes)'
            ''.format(test_set_name, len(test_dataset), len(set(test_volume_list))))

    # We load the training data (which allows for augmentations)
    train_dataset = MyDataset(data_folder, config['data'])

    # We load the untransformed dataset (with NO augmentations)
    untrans_data_config = config['data'].copy()
    untrans_data_config['augment'] = False
    dataset = MyDataset(data_folder, untrans_data_config)

    _all_indices = np.arange(len(train_dataset))
    all_indices = _all_indices.tolist()

    # The sample indices used for validation will be the given list or x samples taken randomly
    if isinstance(train_config['val_data'], int):
        val_indices = random.sample(all_indices, train_config['val_data'])
    else:
        val_indices = train_config['val_data']

    # We create a dataloader for validation
    val_sampler = SubsetSequentialSampler(val_indices)
    val_dataloader = data.DataLoader(dataset, sampler=val_sampler, batch_size=batch_size,
                                        drop_last=False, num_workers=train_config['num_workers'],
                                        pin_memory=True)
    val_dataloader.dataset.training = False

    _all_train_indices = np.setdiff1d(all_indices, val_indices)
    all_train_indices = _all_train_indices.tolist()

    # We will take/save the initial indices and subsequent random indices from a given file
    random_indice_filepath = os.path.join(random_indices_folder, 'data_{}_random_init{}_budget{}_seed{}'
                                            ''.format(config['data']['dataset_name'], args.init_labeled,
                                                    train_config['data_selection']['budget'], args.seed))
    print('\nrandom_indice_filepath: {}\n'.format(random_indice_filepath))

    # The labeled sample indices used for training will be the given list or x samples taken randomly
    init_budget = train_config['data_selection']['initial_budget']
    if isinstance(init_budget, list):
        print('\n Taking initial indices from given list')
        _labeled_indices = init_budget
        assert not set(_labeled_indices) & set(val_indices)
    else:
        init_budget = len(
            all_train_indices) if init_budget == "all" else init_budget
        # We check the random indices file to get the initial indices
        try:
            with open(random_indice_filepath + '.txt', encoding='utf8') as f:
                for line in f:
                    if 'init_{}: '.format(init_budget) in line:
                        _indice_list = line.strip('init_{}: '.format(init_budget))
                        _indice_list = _indice_list.strip('\n')
                        _labeled_indices = eval(_indice_list)
                        break
            assert len(_labeled_indices) == init_budget
            print('Initial indices taken from file {}'.format(
                random_indice_filepath + '.txt'))

        # If the initial indice list is not in the file, we will randomly samples them
        except (NameError, FileNotFoundError) as e:
            _labeled_indices = random.sample(all_train_indices, init_budget)

            # If it is the first experiment, then we will save the initial indices
            print('Saving initial indices')
            with open(random_indice_filepath + '.txt', "a") as f:
                f.write('init_{}: {}\n'.format(
                    len(_labeled_indices), _labeled_indices))

    labeled_indices = sorted(_labeled_indices)

    # We initialize the labeled and unlabeled dataloaders
    #sampler = data.sampler.SubsetRandomSampler(labeled_indices, generator=torch.Generator())
    sampler = InfiniteSubsetRandomSampler(
        train_dataset, labeled_indices, shuffle=True)
    querry_dataloader = data.DataLoader(train_dataset, sampler=sampler, batch_size=batch_size,
                                        drop_last=False, num_workers=train_config['num_workers'],
                                        persistent_workers=True,
                                        pin_memory=True)
    querry_dataloader.dataset.training = True

    _unlabeled_indices = np.setdiff1d(all_train_indices, labeled_indices)
    _unlabeled_indices = _unlabeled_indices.tolist()
    unlabeled_indices = sorted(_unlabeled_indices)

    unlabeled_sampler = data.sampler.SubsetRandomSampler(
        unlabeled_indices, generator=torch.Generator())
    #unlabeled_sampler = SubsetSequentialSampler(unlabeled_indices)
    unlabeled_dataloader = data.DataLoader(dataset, sampler=unlabeled_sampler, batch_size=1,
                                            drop_last=False, num_workers=train_config['num_workers'],
                                            persistent_workers=True,
                                            pin_memory=True)
    unlabeled_dataloader.dataset.training = False

    kwargs = {
        'batch_normalization': config['training']['model']['structure']['conv_block']['normalization'],
        'dropout': config['training']['model']['structure']['dropout_rate'],
        'test_volume_list': test_volume_list}

    # For random method or random sampling, we'll take the sampled indices from the file
    if train_config['data_selection']['sampling_type'] == 'Random':
        kwargs['random_indice_filepath'] = random_indice_filepath

    print('\nQuery size: {} (batch size {}), unlabeled size: {}, val size: {}'.format(
        len(labeled_indices), batch_size, len(unlabeled_indices), len(val_indices)))

    # We update the config file
    config['data']['query_size'] = len(labeled_indices)
    config['data']['unlabeled_size'] = len(unlabeled_indices)

    train_config['num_train_iter'] = train_config['num_epochs']

    # We initialize and train all the models
    ModelInit = all_models[train_config['model']['model_name']]
    task_model = ModelInit(train_config['model'])

    # We create a saver to save model, config and losses 
    saver = Saver(config['exp_name'] + 'seed{}_'.format(args.seed) + str(len(labeled_indices)),
                    timestamp=overall_start_time)
    print('Saving model, config and log files in {}'.format(saver.save_folder))
    saver.save_config(config)

    kwargs['model'] = task_model
    kwargs['saver'] = saver
    kwargs['device'] = device
    kwargs['val_dataloader'] = val_dataloader
    kwargs['querry_dataloader'] = querry_dataloader
    kwargs['augment_data'] = config['data']['augment']
    kwargs['augmentations'] = config['data']['augmentations']
    if config['data']['augment'] and 'gaussian_noise' in config['data']['augmentations']:
        kwargs['augmentation_gaussian_mean'] = config['data']['aug_gaussian_mean']
        kwargs['augmentation_gaussian_std'] = config['data']['aug_gaussian_std']
    kwargs['dataset'] = dataset
    kwargs['seed'] = args.seed
    kwargs['labeled_indices'] = labeled_indices

    # We update kwargs according to chosen model
    method = config['training']['data_selection']['type']
    kwargs = update_kwargs(kwargs, method, config, config['training']['data_selection']['sampling_type'], labeled_indices, unlabeled_indices,
                           unlabeled_dataloader, train_dataset,
                           batch_size, args.seed)

    # We initialize the solver
    SolverInit = all_solvers[config['training']['data_selection']['type']]
    solver = SolverInit(config['training'], test_dataloader, **kwargs)

    # We train the models on the current data
    #acc_dic, loss_dic, kwargs_sampler = solver.train()
    acc_dic, loss_dic = solver.train()

    curr_split = len(labeled_indices) / len(all_train_indices)
    nice_last_test_acc_dic = round_dic_values(acc_dic['last_acc'], 4)
    nice_last_3Dtest_acc_dic = round_dic_values(
        acc_dic['3D_last_acc'], 4) if acc_dic['3D_last_acc'] is not None else ''
    print('Final accuracy with {:.3f}% of data (with last model) is: {} and in 3D {}'
          ''.format(curr_split * 100, nice_last_test_acc_dic, nice_last_3Dtest_acc_dic))

    # We sample indices of samples to add to labeled set for the  next experiment
    if len(unlabeled_indices) != 0:
        _sampled_indices = solver.sample_for_labeling(
            unlabeled_dataloader)  # , **kwargs_sampler)
        torch.cuda.empty_cache()
    else:
        _sampled_indices = []
    sampled_indices = sorted(_sampled_indices)

    # We track the runtime
    iter_end_time = time.time()
    min, sec = convert_time(iter_end_time - iter_start_time)
    print('The experiment took {}min {}sec'.format(min, sec))

    summary = 'Split with {:.3f}% of data - query size: {}, unlabeled size: {}, val size: {}' \
              '\n'.format(curr_split * 100, len(labeled_indices), len(unlabeled_indices),
                          len(val_indices))
    summary += 'Best test accuracy: {}  -  best val accuracy: {}\n'.format(acc_dic['best_acc'],
                                                                           acc_dic['val_acc_best'])
    summary += 'Last test accuracy: {}  -  Last val accuracy: {}\n'.format(acc_dic['last_acc'],
                                                                           acc_dic['val_acc_last'])
    summary += 'Best 3D test accuracy: {}\n'.format(
        acc_dic['3D_best_acc'])if acc_dic['3D_best_acc'] is not None else ''
    summary += 'Last 3D test accuracy: {}\n'.format(
        acc_dic['3D_last_acc'])if acc_dic['3D_last_acc'] is not None else ''

    summary += 'Sampling indices: {}\n\n'.format(sampled_indices)

    # (if applicable) We save hyperparameters searched
    hyperparam_dict = config[
        'optimized_hyperparams'] if 'optimized_hyperparams' in config.keys() else ''

    # We save the model, validation score and path in a dictionary
    result_dic = {"num_train_data": len(labeled_indices),
                  "num_val_data": len(val_indices),
                  "test_loss": loss_dic['test_loss'],
                  "test_accuracy_best": acc_dic['best_acc'],
                  "test_accuracy_last": acc_dic['last_acc'],
                  "best_val_loss": loss_dic['val_loss_best'],
                  "best_val_accuracy": acc_dic['val_acc_best'],
                  "last_val_loss": loss_dic['val_loss_last'],
                  "last_val_accuracy": acc_dic['val_acc_last'],
                  "time_taken": '{}min, {}sec'.format(min, sec),
                  "save_path": saver.save_folder,
                  "val_indices": val_indices,
                  "labeled_indices": labeled_indices,
                  "unlabeled_indices": unlabeled_indices,
                  "new_indices_to_sample": sampled_indices,
                  "summary": summary,
                  "hyperparams": hyperparam_dict
                  }

    if acc_dic['3D_last_acc'] is not None:
        result_dic["3Dtest_accuracy_last"] = acc_dic['3D_last_acc']
    if acc_dic['3D_best_acc'] is not None:
        result_dic["3Dtest_accuracy_best"] = acc_dic['3D_best_acc']

    saver.save_txt(result_dic)

    return result_dic


def main(raw_args=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-c', '--config', type=str,
                        help='path to the config file for the optimization', default='example_config')
    parser.add_argument('--device', type=str,
                        help='device file path ', default='cuda:0')
    parser.add_argument('--seed', type=int,
                        help='seed to use for randomness ', default=42)
    raw_args = parser.parse_args()

    # We load the config file with all parameters to search
    config = get_config_from_json(raw_args.config)

    start_time = datetime.today()

    # We create a folder with txt file and total plots
    log_id = '{}_{}h{}min'.format(
        start_time.date(), start_time.hour, start_time.minute)
    _overall_save_folder = os.path.join(output_folder, log_id, 'overall_results' + '_' +
                                        config['exp_name'] + '_modelLR{}'.format(config['training']['optimizer']['init_lr']) +
                                        '_seed{}'.format(raw_args.seed))
    print(_overall_save_folder)
    overall_save_folder = create_unexisting_folder(_overall_save_folder)
    print('Overall results will be saved in {}'.format(overall_save_folder))

    config['overall_start_time'] = log_id

    # We create a dataframe with table of results
    df_3d_dice = pd.DataFrame(index=['Seed{}_{}'.format(raw_args.seed, raw_args.config)])
    df_2d_dice = pd.DataFrame(index=['Seed{}_{}'.format(raw_args.seed, raw_args.config)])
    df_2d_mIoU = pd.DataFrame(index=['Seed{}_{}'.format(raw_args.seed, raw_args.config)])


    # We will define the number of experiments to run
    # We load the training data
    init_indices = config['training']['data_selection']['initial_budget']
    num_init_indices = init_indices if isinstance(init_indices, int) else len(init_indices)

    _max_iter = math.ceil((config['training']['max_num_labeled'] - num_init_indices) /
                          config['training']['data_selection']['budget'])
    max_iter = int(_max_iter)
    print("\nThere will be {} experiments in total".format(max_iter + 1))

    config_paths = []
    for cur_iter in range(max_iter + 1):
        print('\n ### Experiment {} ###'.format(cur_iter))

        config['training']['cycle'] = str(cur_iter)

        # We update the config file after the first iteration
        updated_config = copy.deepcopy(config)
        if cur_iter > 0:
            print('\n Updating config')
            new_labeled_indices = result_dic['labeled_indices'] + result_dic['new_indices_to_sample']
            updated_config['training']['data_selection']['initial_budget'] = new_labeled_indices
            updated_config['training']['val_data'] = result_dic['val_indices']
        config_path = os.path.join(overall_save_folder, 'config_{}.json'.format(cur_iter))
        config_paths.append(config_path)

        with open(config_paths[-1], 'w') as file:
            json.dump(updated_config, file, indent=4, cls=NpEncoder)

        updated_args = ['--config', config_paths[cur_iter],
                        '--device', raw_args.device,
                        '--seed', str(raw_args.seed),
                        '--init_labeled', str(init_indices).replace('[', 'labels').replace(']', '').replace(',', '-').replace(' ', ''),
                        '--init_num_labeled', str(num_init_indices),
                        ]
        result_dic = run_experiment(updated_args)
        print('\n{}'.format(result_dic['summary']))

        # We add the results to the overall results folder
        txt_save_path = os.path.join(overall_save_folder, 'results.txt')
        with open(txt_save_path, "a") as file_object:
            # Append 'hello' at the end of file
            file_object.write(result_dic['summary'])

        # We put result in the dataframe
        if '3Dtest_accuracy_last' in result_dic.keys():
            # We save 3D dice
            df_3d_dice[result_dic['num_train_data']] = result_dic['3Dtest_accuracy_last']['manual_dice']
            result_name = 'mean_3Dtest_dice_last'
            # We save the transposed results dataframe
            df_3d_dice_t = df_3d_dice.transpose()
            df_3d_dice_savepath = os.path.join(overall_save_folder, result_name + '.csv')
            df_3d_dice_t.to_csv(df_3d_dice_savepath, sep='\t', index=True, header=True)
        
        if 'test_accuracy_last' in result_dic.keys():
            # We save 2D dice
            df_2d_dice[result_dic['num_train_data']] = result_dic['test_accuracy_last']['manual_dice']
            result_name = 'mean_2Dtest_dice_last'
            
            # We save the transposed results dataframe
            df_2d_dice_t = df_2d_dice.transpose()
            df_2d_dice_savepath = os.path.join(overall_save_folder, result_name + '.csv')
            df_2d_dice_t.to_csv(df_2d_dice_savepath, sep='\t', index=True, header=True)
            
            # We save the mean IoU
            df_2d_mIoU[result_dic['num_train_data']] = result_dic['test_accuracy_last']['meanIoU']
            result_name = 'mean_2Dtest_IoU_last'
            
            # We save the transposed results dataframe
            df_2d_mIoU_t = df_2d_mIoU.transpose()
            df_2d_mIoU_savepath = os.path.join(overall_save_folder, result_name + '.csv')
            df_2d_mIoU_t.to_csv(df_2d_mIoU_savepath, sep='\t', index=True, header=True)


    print('Done')


if __name__ == '__main__':
    main()