def __init__(self, num_classes: int): """ :param num_classes: """ super(ViTBase16, self).__init__() self.model = create_model('vit_base_patch16_384', num_classes=num_classes, pretrained=False)
def __init__(self, num_classes: int): """ :param num_classes: int """ super(Efficient_b6, self).__init__() self.model = create_model('tf_efficientnet_b6_ns', num_classes=num_classes, pretrained=True)
def __init__(self, num_classes: int): super().__init__() self.model = create_model('resnet200d', pretrained=False) n_features = self.model.fc.in_features self.model.global_pool = nn.Identity() self.model.fc = nn.Identity() self.pooling = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(n_features, num_classes)
import os from options.test_options import TestOptions from dataloader.data_loader import dataloader from model.models import create_model from util.visualizer import Visualizer from util import html opt = TestOptions().parse() dataset = dataloader(opt) dataset_size = len(dataset) * opt.batchSize print ('testing images = %d ' % dataset_size) model = create_model(opt) visualizer = Visualizer(opt) web_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' %(opt.phase, opt.which_epoch)) web_page = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.which_epoch)) # testing for i,data in enumerate(dataset): model.set_input(data) model.test() model.save_results(visualizer, web_page)
parser.add_argument( '--model_size_info', type=int, nargs="+", default=[1, 100], help='Model dimensions - different for various models') args = parser.parse_args() model_settings = models.prepare_model_settings( len(input_data.prepare_words_list(args.wanted_words.split(','))), args.sample_rate, args.clip_duration_ms, args.window_size_ms, args.window_stride_ms, args.dct_coefficient_count) print(model_settings) model = models.create_model(model_settings, args.arch, args.model_size_info) model.cuda() model_path = os.path.join(args.save_dir, args.load_model_name) print(model_path) model.load_state_dict(torch.load(model_path)["state_dict"],strict=False)#i modify here for name, weight in model.named_parameters(): print (name) unique, counts = np.unique((weight.cpu().detach().numpy()).flatten(), return_counts=True) un_list = np.asarray((unique, counts)).T print("Unique quantized weights counts:\n", un_list) print(len(un_list))
dataset = dataloader(opt) dataset_size = len(dataset) * opt.batch_size print('training images = %d' % dataset_size) # create datasets for Gaussian Process labeled_dataset = None unlabeled_dataset = None if opt.gp: labeled_dataset, unlabeled_dataset = dataloader(opt, gp=True) print('The number of labeled training images for GP = %d' % len(labeled_dataset)) print('The number of unlabeled training images for GP = %d' % len(unlabeled_dataset)) model = create_model(opt, labeled_dataset, unlabeled_dataset) visualizer = Visualizer(opt) total_steps = 0 for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1): epoch_start_time = time.time() epoch_iter = 0 # training for i, data in enumerate(dataset): iter_start_time = time.time() total_steps += opt.batch_size epoch_iter += opt.batch_size model.set_input(data) model.optimize_parameters(i)
import time from options.train_options import TrainOptions from dataloader.data_loader import dataloader from model.models import create_model from util.visualizer import Visualizer opt = TrainOptions().parse() dataset = dataloader(opt) dataset_size = len(dataset) * opt.batchSize print('training images = %d' % dataset_size) s_model, t_model = create_model(opt) visualizer = Visualizer(opt) total_steps = 0 for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1): epoch_start_time = time.time() epoch_iter = 0 # training for i, data in enumerate(dataset): iter_start_time = time.time() total_steps += opt.batchSize epoch_iter += opt.batchSize model.set_input(data) model.optimize_parameters(i) if total_steps % opt.display_freq == 0: if epoch >= opt.transform_epoch: model.validation_target()
# parser.add_argument("--log", type=str, default='', help="Training log file") # parser.add_argument("--saved_model_file", type=str, default='', help="Saved trainde models") # parser.add_argument("--checkpoint", type=str, default='', help="Load chenkpoint") args = parser.parse_args() csv_file = './five_folders/' + args.csv_file + '/{}.csv' root_dir = '/home/gtwell/all_images/dataset' out = create_dataset(csv_file=csv_file, root_dir=root_dir, img_size=args.img_size, batch_size=args.batch_size) dataloaders = out['dataloaders'] dataset_sizes = out['dataset_sizes'] use_gpu = torch.cuda.is_available() model_conv = create_model(model_key=args.model, pretrained=eval(args.pretrained), num_of_classes=6, use_gpu=use_gpu) criterion = nn.CrossEntropyLoss() # Observe that only parameters of final layer are being optimized as # opoosed to before. if eval(args.pretrained): parameters_totrain = model_conv.fc.parameters() else: parameters_totrain = model_conv.parameters() # Choose optimizer for training if args.optimizer == 'SGD': optimizer_conv = optim.SGD(parameters_totrain, lr=0.001, momentum=0.9) elif args.optimizer == 'Adam':
data_dir=cfg.DATA_DIR_TRAIN, transform=transforms.Compose(train_transforms)) val_dataset = conc_dataset.AlignedConcDataset( cfg, data_dir=cfg.DATA_DIR_VAL, transform=transforms.Compose(val_transforms)) train_loader = DataProvider(cfg, dataset=train_dataset) val_loader = DataProvider(cfg, dataset=val_dataset, shuffle=False) # class weights num_classes_train = list( Counter([i[1] for i in train_loader.dataset.imgs]).values()) cfg.CLASS_WEIGHTS_TRAIN = torch.FloatTensor(num_classes_train) writer = SummaryWriter(log_dir=cfg.LOG_PATH) # tensorboard model = create_model(cfg, writer) model.set_data_loader(train_loader, val_loader, unlabeled_loader) def train(): print('>>> task path is {0}'.format(project_name)) # train model.train_parameters(cfg) print('save model ...') model_filename = '{0}_{1}_finish.pth'.format(cfg.MODEL, cfg.WHICH_DIRECTION) model.save_checkpoint(cfg.NITER_TOTAL, model_filename)
def main(): global config, best_prec1 args = parser.parse_known_args()[0].__dict__ config = Config() for key, value in args.items(): if value is not None: setattr(config, key, value) if config.logger: logging.basicConfig(level=logging.INFO, format='%(message)s') logger = logging.getLogger() try: os.makedirs("logger", exist_ok=True) except TypeError: raise Exception("Direction not create!") logger.addHandler( logging.FileHandler( strftime('logger/GSC_%m-%d-%Y-%H:%M_id_') + str(uuid.uuid4()) + '.log', 'a')) global print print = logger.info use_cuda = not config.no_cuda and torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") # Check the save_dir exists or not if not os.path.exists(config.save_dir): os.makedirs(config.save_dir) print("Current network is {}".format(config.arch)) # Start a new TensorFlow session. sess = tf.InteractiveSession() # Begin by making sure we have the training data we need. If you already have # training data of your own, use `--data_url= ` on the command line to avoid # downloading. model_settings = models.prepare_model_settings( len(input_data.prepare_words_list(config.wanted_words.split(','))), config.sample_rate, config.clip_duration_ms, config.window_size_ms, config.window_stride_ms, config.dct_coefficient_count) print(model_settings) time_shift_samples = int( (config.time_shift_ms * config.sample_rate) / 1000) train_loader = torch.utils.data.DataLoader(GSCDataset( config.data_url, config.data_dir, config.silence_percentage, config.unknown_percentage, config.wanted_words.split(','), config.validation_percentage, config.testing_percentage, model_settings, sess, config.arch, mode="training", background_frequency=config.background_frequency, background_volume_range=config.background_frequency, time_shift=time_shift_samples), shuffle=True, batch_size=config.batch_size, num_workers=config.workers) print("train set size: {}".format(len(train_loader.dataset))) val_loader = torch.utils.data.DataLoader(GSCDataset( config.data_url, config.data_dir, config.silence_percentage, config.unknown_percentage, config.wanted_words.split(','), config.validation_percentage, config.testing_percentage, model_settings, sess, config.arch, mode="validation"), batch_size=config.batch_size, num_workers=config.workers) print("validation set size: {}".format(len(val_loader.dataset))) test_loader = torch.utils.data.DataLoader(GSCDataset( config.data_url, config.data_dir, config.silence_percentage, config.unknown_percentage, config.wanted_words.split(','), config.validation_percentage, config.testing_percentage, model_settings, sess, config.arch, mode="testing"), batch_size=config.batch_size, num_workers=config.workers) print("test set size: {}".format(len(test_loader.dataset))) model = models.create_model(config, model_settings) model.cuda() if config.resume: if os.path.isfile(config.resume): print("=> loading checkpoint '{}'".format(config.resume)) checkpoint = torch.load(config.resume) try: model.load_state_dict(checkpoint) except: print("Trying load with dict 'state_dict'") # try: # if not config.admm_quant: # model.set_alpha(checkpoint['alpha']) model.load_state_dict(checkpoint['state_dict']) # except: # print("Cann't load model") # return else: print("=> no checkpoint found at '{}'".format(config.resume)) return cudnn.benchmark = True # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() if config.optimizer_type == "sgd": optimizer = torch.optim.SGD(model.parameters(), config.lr, momentum=config.momentum, weight_decay=config.weight_decay, nesterov=True) elif config.optimizer_type == "adam": optimizer = torch.optim.Adam(model.parameters(), config.lr, weight_decay=config.weight_decay) elif config.optimizer_type == "adamw": optimizer = AdamW(model.parameters(), lr=config.lr, weight_decay=config.weight_decay) elif config.optimizer_type == "rmsprop": optimizer = torch.optim.RMSprop(model.parameters(), config.lr, weight_decay=config.weight_decay) elif config.optimizer_type == "adagrad": optimizer = torch.optim.Adagrad(model.parameters(), config.lr, weight_decay=config.weight_decay) elif config.optimizer_type == "adadelta": optimizer = torch.optim.Adadelta(model.parameters(), config.lr, weight_decay=config.weight_decay) else: raise ValueError("The optimizer type is not defined!") if config.evaluate: # validate(val_loader, model, criterion) val_acc = validate_by_step(config, val_loader, model, criterion, model_settings, sess) # test(test_loader, model, criterion) test_acc = test_by_step(config, test_loader, model, criterion, model_settings, sess) return if config.admm_quant: pass # name_list = [] # for name, w in model.named_parameters(): # if "weight" or "bias" in name: # name_list.append(name) # print("Quantized Layer name list is :") # print(", ".join(name_list)) # print("Before quantized:") # validate_by_step(config, audio_processor, model, criterion, model_settings, sess) # admm.admm_initialization(config, model, device, name_list, print) # print("After quantized:") # validate_quant_by_step(config, audio_processor, model, criterion, model_settings, # sess, name_list, device) # for epoch in range(config.start_epoch, config.epochs): # if config.lr_scheduler == 'default': # adjust_learning_rate(optimizer, epoch) # elif config.lr_scheduler == 'cosine': # pass # admm_quant_train_by_step(config, audio_processor, model, criterion, optimizer, epoch, model_settings, # time_shift_samples, sess, name_list, device) # # evaluate on validation set # print("After Quantized:") # prec1, quantized_model = validate_quant_by_step(config, audio_processor, model, criterion, model_settings, # sess, name_list, device) # # remember best prec@1 and save checkpoint # is_best = prec1 > best_prec1 # if is_best: # path_name = os.path.join(config.save_dir, # '{arch}_{type}_{num_bits}bits_quantized_GSC_acc_{prec1:.3f}.pt'.format( # arch=config.arch, # type=config.quant_type, num_bits=config.num_bits, # prec1=best_prec1)) # new_path_name = os.path.join(config.save_dir, # '{arch}_{type}_{num_bits}bits_quantized_GSC_acc_{prec1:.3f}.pt'.format( # arch=config.arch, type=config.quant_type, num_bits=config.num_bits, # prec1=prec1)) # if os.path.isfile(path_name): # os.remove(path_name) # best_prec1 = prec1 # save_checkpoint(quantized_model, new_path_name) # print("Admm training, best top 1 acc {best_prec1:.3f}".format(best_prec1=best_prec1)) # print("Best testing dataset:") # test_by_step(config, audio_processor, quantized_model, criterion, model_settings, sess) # else: # print("Admm training, best top 1 acc {best_prec1:.3f}, current top 1 acc {prec1:.3f}".format( # best_prec1=best_prec1, prec1=prec1)) else: for epoch in range(0, config.epochs): if config.lr_scheduler == 'default': adjust_learning_rate(optimizer, epoch) elif config.lr_scheduler == 'cosine': pass # scheduler.step() # train for one epoch train_by_step(config, train_loader, model, criterion, optimizer, epoch, model_settings, time_shift_samples, sess) # evaluate on validation set # prec1 = validate(val_loader, model, criterion) prec1 = validate_by_step(config, val_loader, model, criterion, model_settings, sess) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 if is_best: path_name = os.path.join( config.save_dir, '{arch}_GSC_acc_{prec1:.3f}.pt'.format(arch=config.arch, prec1=best_prec1)) new_path_name = os.path.join( config.save_dir, '{arch}_GSC_acc_{prec1:.3f}.pt'.format(arch=config.arch, prec1=prec1)) if os.path.isfile(path_name): os.remove(path_name) best_prec1 = prec1 save_checkpoint(model, new_path_name) print( "Current best validation accuracy {best_prec1:.3f}".format( best_prec1=best_prec1)) else: print("Current validation accuracy {prec1:.3f}, " "best validation accuracy {best_prec1:.3f}".format( prec1=prec1, best_prec1=best_prec1)) # test(test_loader, model, criterion) test_by_step(config, test_loader, model, criterion, model_settings, sess)
def validate_quant_by_step(config, audio_processor, model, criterion, model_settings, sess, name_list, device): batch_time = AverageMeter() losses = AverageMeter() top1 = AverageMeter() quantized_model = models.create_model(config, model_settings) quantized_model.alpha = model.alpha quantized_model.Q = model.Q quantized_model.Z = model.Z quantized_model.load_state_dict(model.state_dict()) quantized_model.cuda() admm.apply_quantization(config, quantized_model, name_list, device) quantized_model.eval() valid_set_size = audio_processor.set_size('validation') max_step_epoch = valid_set_size // config.batch_size input_frequency_size = model_settings[ 'dct_coefficient_count'] # sequence length 10 input_time_size = model_settings['spectrogram_length'] # input_size 25 end = time.time() for i in range(0, valid_set_size, config.batch_size): input, target = audio_processor.get_data(config.batch_size, i, model_settings, 0.0, 0.0, 0, 'validation', sess) target = torch.Tensor(target).cuda() _, target = target.max(dim=1) target = target.cuda() input = input.reshape((-1, input_time_size, input_frequency_size)) input = torch.Tensor(input).cuda() with torch.no_grad(): input_var = torch.autograd.Variable(input.float()).cuda() target_var = torch.autograd.Variable(target.long()) # compute output output = quantized_model(input_var) loss = criterion(output, target_var) output = output.float() loss = loss.float() # measure accuracy and record loss prec1 = accuracy(output.data, target)[0] losses.update(loss.data, input.size(0)) top1.update(prec1, input.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() if (i // config.batch_size) % config.print_freq == 0: print('Validation: [{0}/{1}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' 'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format( i // config.batch_size, max_step_epoch, batch_time=batch_time, loss=losses, top1=top1)) print(' * Prec@1 {top1.avg:.3f}'.format(top1=top1)) return top1.avg, quantized_model
def main(): global args, best_prec1 args = parser.parse_args() args.save_name = 'loushu' if args.logger: logging.basicConfig(level=logging.INFO, format='%(message)s') logger = logging.getLogger() try: os.makedirs("logger", exist_ok=True) except TypeError: raise Exception("Direction not create!") logger.addHandler( logging.FileHandler( strftime('logger/GSC_%m-%d-%Y-%H:%M_id_') + str(uuid.uuid4()) + '.log', 'a')) global print print = logger.info print("The config arguments showed as below:") print(args) use_cuda = not args.no_cuda and torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") # Check the save_dir exists or not if not os.path.exists(args.save_dir): os.makedirs(args.save_dir) print("Current network is {}".format(args.arch)) # Start a new TensorFlow session. sess = tf.InteractiveSession() # Begin by making sure we have the training data we need. If you already have # training data of your own, use `--data_url= ` on the command line to avoid # downloading. model_settings = models.prepare_model_settings( len(input_data.prepare_words_list(args.wanted_words.split(','))), args.sample_rate, args.clip_duration_ms, args.window_size_ms, args.window_stride_ms, args.dct_coefficient_count) print(model_settings) audio_processor = input_data.AudioProcessor(args.data_url, args.data_dir, args.silence_percentage, args.unknown_percentage, args.wanted_words.split(','), args.validation_percentage, args.testing_percentage, model_settings) # fingerprint_size = model_settings['fingerprint_size'] # label_count = model_settings['label_count'] # train_set_size = audio_processor.set_size('training') # print('set_size=%d', train_set_size) # valid_set_size = audio_processor.set_size('validation') # print('set_size=%d', valid_set_size) time_shift_samples = int((args.time_shift_ms * args.sample_rate) / 1000) # train_loader = torch.utils.data.DataLoader( # GSCDataset(args.data_url, args.data_dir, args.silence_percentage, args.unknown_percentage, # args.wanted_words.split(','), args.validation_percentage, args.testing_percentage, # model_settings, sess, args.arch, mode="training", background_frequency=args.background_frequency, # background_volume_range=args.background_frequency, time_shift=time_shift_samples), shuffle=True, # batch_size=args.batch_size, num_workers=args.workers) # print("train set size: {}".format(len(train_loader.dataset))) val_loader = torch.utils.data.DataLoader(GSCDataset( args.data_url, args.data_dir, args.silence_percentage, args.unknown_percentage, args.wanted_words.split(','), args.validation_percentage, args.testing_percentage, model_settings, sess, args.arch, mode="validation"), batch_size=args.batch_size, num_workers=args.workers) print("validation set size: {}".format(len(val_loader.dataset))) test_loader = torch.utils.data.DataLoader(GSCDataset( args.data_url, args.data_dir, args.silence_percentage, args.unknown_percentage, args.wanted_words.split(','), args.validation_percentage, args.testing_percentage, model_settings, sess, args.arch, mode="testing"), batch_size=args.batch_size, num_workers=args.workers) print("test set size: {}".format(len(test_loader.dataset))) #model = models.create_model(model_settings, args.arch, args.model_size_info) model = models.create_model(model_settings, args.arch, args.model_size_info, args.save_act_value, args.save_act_dir) model.cuda() # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume, map_location='cuda:0') try: model.load_state_dict(checkpoint) except: print("Trying load with dict 'state_dict'") try: model.load_state_dict(checkpoint['state_dict']) except: print("Cann't load model") return else: print("=> no checkpoint found at '{}'".format(args.resume)) return cudnn.benchmark = True # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() if args.optimizer_type == "sgd": optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) elif args.optimizer_type == "adam": optimizer = torch.optim.Adam(model.parameters(), args.lr, weight_decay=args.weight_decay) elif args.optimizer_type == "adamw": optimizer = AdamW(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) elif args.optimizer_type == "rmsprop": optimizer = torch.optim.RMSprop(model.parameters(), args.lr, weight_decay=args.weight_decay) elif args.optimizer_type == "adagrad": optimizer = torch.optim.Adagrad(model.parameters(), args.lr, weight_decay=args.weight_decay) elif args.optimizer_type == "adadelta": optimizer = torch.optim.Adadelta(model.parameters(), args.lr, weight_decay=args.weight_decay) else: raise ValueError("The optimizer type is not defined!") if args.evaluate: # validate(val_loader, model, criterion) validate_by_step(args, audio_processor, model, criterion, model_settings, sess) #test(test_loader, model, criterion) test_by_step(args, audio_processor, model, criterion, model_settings, sess) return # scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs * len(train_loader), # eta_min=4e-08) if args.admm_quant: name_list = [] for name, w in model.named_parameters(): if "weight" or "bias" in name: name_list.append(name) print("Quantized Layer name list is :") print(", ".join(name_list)) print("Before quantized:") validate_by_step(args, audio_processor, model, criterion, model_settings, sess) admm.admm_initialization(args, model, device, name_list, print) print("After quantized:") validate_quant_by_step(args, audio_processor, model, criterion, model_settings, sess, name_list, device) for epoch in range(args.start_epoch, args.epochs): if args.lr_scheduler == 'default': adjust_learning_rate(optimizer, epoch) elif args.lr_scheduler == 'cosine': pass admm_quant_train_by_step(args, audio_processor, model, criterion, optimizer, epoch, model_settings, time_shift_samples, sess, name_list, device) # evaluate on validation set print("After Quantized:") prec1, quantized_model = validate_quant_by_step( args, audio_processor, model, criterion, model_settings, sess, name_list, device) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 if is_best: path_name = os.path.join( args.save_dir, '{arch}_{type}_{num_bits}bits_quantized_GSC_acc_{prec1:.3f}_{add}.pt' .format(arch=args.arch, type=args.quant_type, num_bits=args.num_bits, prec1=best_prec1, add=args.save_name)) new_path_name = os.path.join( args.save_dir, '{arch}_{type}_{num_bits}bits_quantized_GSC_acc_{prec1:.3f}_{add}.pt' .format(arch=args.arch, type=args.quant_type, num_bits=args.num_bits, prec1=prec1, add=args.save_name)) if os.path.isfile(path_name): os.remove(path_name) best_prec1 = prec1 save_checkpoint(quantized_model, new_path_name) print("Admm training, best top 1 acc {best_prec1:.3f}".format( best_prec1=best_prec1)) print("Best testing dataset:") test_by_step(args, audio_processor, quantized_model, criterion, model_settings, sess) else: print( "Admm training, best top 1 acc {best_prec1:.3f}, current top 1 acc {prec1:.3f}" .format(best_prec1=best_prec1, prec1=prec1)) else: for epoch in range(args.start_epoch, args.epochs): if args.lr_scheduler == 'default': adjust_learning_rate(optimizer, epoch) elif args.lr_scheduler == 'cosine': pass # scheduler.step() # train for one epoch train_by_step(args, audio_processor, model, criterion, optimizer, epoch, model_settings, time_shift_samples, sess) # evaluate on validation set # prec1 = validate(val_loader, model, criterion) prec1 = validate_by_step(args, audio_processor, model, criterion, model_settings, sess) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 if is_best: path_name = os.path.join( args.save_dir, '{arch}_GSC_acc_{prec1:.3f}_{add}.pt'.format( arch=args.arch, prec1=best_prec1, add=args.save_name)) new_path_name = os.path.join( args.save_dir, '{arch}_GSC_acc_{prec1:.3f}_{add}.pt'.format( arch=args.arch, prec1=prec1, add=args.save_name)) if os.path.isfile(path_name): os.remove(path_name) best_prec1 = prec1 save_checkpoint(model, new_path_name) print( "Current best validation accuracy {best_prec1:.3f}".format( best_prec1=best_prec1)) else: print("Current validation accuracy {prec1:.3f}, " "best validation accuracy {best_prec1:.3f}".format( prec1=prec1, best_prec1=best_prec1)) # test(test_loader, model, criterion) test_by_step(args, audio_processor, model, criterion, model_settings, sess)
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()