def main(spec, num_samples, pool): checkpoint_dir = os.path.join(CHECKPOINT_ROOT, spec) model_type, model_args, dataset_names = spec_util.parse_setup_spec(spec) if model_type == 'VAE': model = vae.VAE(model_args) trainer = vae.Trainer(model, beta=4.) trainer.cuda() models.load_checkpoint(trainer, checkpoint_dir) model.eval() sample_latent = model.sample_latent(num_samples) sample_imgs = model.dec(sample_latent) elif model_type in ['GAN', 'GANmc']: model = gan.GAN(model_args) trainer = gan.Trainer(model) trainer.cuda() models.load_checkpoint(trainer, checkpoint_dir) model.eval() sample_imgs = model(num_samples) else: raise ValueError(f"Invalid model type: {model_type}") print(f"Loaded model {checkpoint_dir}. Measuring samples...") sample_imgs_np = sample_imgs.detach().cpu().squeeze().numpy() sample_metrics = measure.measure_batch(sample_imgs_np, pool=pool) os.makedirs(METRICS_ROOT, exist_ok=True) metrics_path = os.path.join(METRICS_ROOT, f"{spec}_metrics.csv") sample_metrics.to_csv(metrics_path, index_label='index') print(f"Morphometrics saved to {metrics_path}")
def main(): opt = get_opt() print(opt) print("GMM: Start to %s, named: %s!" % (opt.stage, "GMM")) # dataset setup dataset = Dataset(opt, "GMM") dataset_loader = DataLoader(opt, dataset) model = GMM(opt) if opt.stage == 'train': if not opt.checkpoint == '' and os.path.exists(opt.checkpoint): load_checkpoint(model, opt.checkpoint) train_gmm(opt, dataset_loader, model) save_checkpoint( model, os.path.join(opt.checkpoint_dir, opt.name, 'gmm_trained.pth')) elif opt.stage == 'test': load_checkpoint(model, opt.checkpoint) with torch.no_grad(): test_gmm(opt, dataset_loader, model) else: raise NotImplementedError('Please input train or test stage') print('Finished %s stage, named: %s!' % (opt.datamode, opt.name))
def load_model(model_name='dpn131', checkpoint='../models/model_best.pth.tar', device='cpu'): model = create_model(model_name, num_classes=NUM_CLASS, in_chans=3, pretrained=False) load_checkpoint(model, checkpoint) model = model.to(device) model.eval() return model
def load_gan(spec): _, latent_dims, dataset_names = spec_util.parse_setup_spec(spec) checkpoint_dir = os.path.join(CHECKPOINT_ROOT, spec) device = torch.device('cuda') gan = InfoGAN(*latent_dims) trainer = Trainer(gan).to(device) load_checkpoint(trainer, checkpoint_dir) gan.eval() return gan
def load_gan(spec): _, latent_dims, dataset_names = spec_util.parse_setup_spec(spec) checkpoint_dir = os.path.join(CHECKPOINT_ROOT, spec) device = torch.device('cuda') gan = InfoGAN(*latent_dims) trainer = Trainer(gan).to(device) load_checkpoint(trainer, checkpoint_dir) gan.eval() return gan
def main(use_cuda: bool, data_dirs: Union[str, Sequence[str]], weights: Optional[Sequence[Number]], ckpt_root: str, latent_dim: int, num_epochs: int, batch_size: int, save: bool, resume: bool, plot: bool): device = torch.device('cuda' if use_cuda else 'cpu') if isinstance(data_dirs, str): data_dirs = [data_dirs] dataset_names = [os.path.split(data_dir)[-1] for data_dir in data_dirs] ckpt_name = spec_util.format_setup_spec('VAE', latent_dim, dataset_names) print(f"Training {ckpt_name}...") ckpt_dir = None if ckpt_root is None else os.path.join(ckpt_root, ckpt_name) train_set = data_util.get_dataset(data_dirs, weights, train=True) test_set = data_util.get_dataset(data_dirs, weights, train=False) test_batch_size = 32 dl_kwargs = dict(num_workers=1, pin_memory=True) if use_cuda else {} train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, **dl_kwargs) test_loader = DataLoader(test_set, batch_size=test_batch_size, shuffle=True, **dl_kwargs) num_batches = len(train_loader.dataset) // train_loader.batch_size model = vae.VAE(latent_dim) trainer = vae.Trainer(model, beta=4.) trainer.to(device) test_iterator = iter(test_loader) start_epoch = -1 if resume: try: start_epoch = load_checkpoint(trainer, ckpt_dir) if plot: test(model, next(test_iterator)[0]) except ValueError: print(f"No checkpoint to resume from in {ckpt_dir}") except FileNotFoundError: print(f"Invalid checkpoint directory: {ckpt_dir}") elif save: if os.path.exists(ckpt_dir): print(f"Clearing existing checkpoints in {ckpt_dir}") for filename in os.listdir(ckpt_dir): os.remove(os.path.join(ckpt_dir, filename)) for epoch in range(start_epoch + 1, num_epochs): trainer.train() for batch_idx, (data, _) in enumerate(train_loader): verbose = batch_idx % 10 == 0 if verbose: print(f"[{epoch}/{num_epochs}: {batch_idx:3d}/{num_batches:3d}] ", end='') real_data = data.to(device).unsqueeze(1).float() / 255. trainer.step(real_data, verbose) if save: save_checkpoint(trainer, ckpt_dir, epoch) if plot: test(model, next(test_iterator)[0])
def main(checkpoint_dir, pcorr_dir=None): spec = os.path.split(checkpoint_dir)[-1] _, latent_dims, dataset_names = spec_util.parse_setup_spec(spec) device = torch.device('cuda') gan = infogan.InfoGAN(*latent_dims) trainer = infogan.Trainer(gan).to(device) load_checkpoint(trainer, checkpoint_dir) gan.eval() dataset_name = SPEC_TO_DATASET['+'.join(dataset_names)] data_dirs = [os.path.join(DATA_ROOT, dataset_name)] test_metrics, test_images, test_labels, test_which = load_test_data( data_dirs) print(test_metrics.head()) idx = np.random.permutation(10000) #[:1000] X = torch.from_numpy( test_images[idx]).float().unsqueeze(1).to(device) / 255. cols = ['length', 'thickness', 'slant', 'width', 'height'] test_cols = cols[:] test_hrule = None if 'swel+frac' in spec: add_swel_frac(data_dirs[0], test_metrics) test_cols += ['swel', 'frac'] test_hrule = len(cols) if pcorr_dir is None: pcorr_dir = checkpoint_dir os.makedirs(pcorr_dir, exist_ok=True) process(gan, X, test_metrics.loc[idx], test_cols, pcorr_dir, spec, 'test', test_hrule) X_ = gan(1000).detach() with multiprocessing.Pool() as pool: sample_metrics = measure.measure_batch(X_.cpu().squeeze().numpy(), pool=pool) sample_hrule = None process(gan, X_, sample_metrics, cols, pcorr_dir, spec, 'sample', sample_hrule)
def main(): opt = get_opt() print(opt) print("TOM: Start to %s, named: %s!" % (opt.datamode, opt.name)) # Dataset setup dataset = Dataset(opt, "TOM") data_loader = DataLoader(opt, dataset) model = UnetGenerator(25, 4, 6, ngf=64, norm_layer=nn.InstanceNorm2d) if opt.datamode == 'train': if not opt.checkpoint =='' and os.path.exists(opt.checkpoint): load_checkpoint(model, opt.checkpoint) train_tom(opt, data_loader, model) save_checkpoint(model, os.path.join(opt.checkpoint_dir, opt.name, 'tom_trained.pth')) elif opt.datamode == 'test': load_checkpoint(model, opt.checkpoint) with torch.no_grad(): test_tom(opt, data_loader, model) else: raise NotImplementedError('Please input train or test stage') print('Finished test %s, named: %s!' % (opt.stage, opt.name))
def train(args): cfg_from_file(args.cfg) cfg.WORKERS = args.num_workers pprint.pprint(cfg) # set the seed manually np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) # define outputer outputer_train = Outputer(args.output_dir, cfg.IMAGETEXT.PRINT_EVERY, cfg.IMAGETEXT.SAVE_EVERY) outputer_val = Outputer(args.output_dir, cfg.IMAGETEXT.PRINT_EVERY, cfg.IMAGETEXT.SAVE_EVERY) # define the dataset split_dir, bshuffle = 'train', True # Get data loader imsize = cfg.TREE.BASE_SIZE * (2**(cfg.TREE.BRANCH_NUM - 1)) train_transform = transforms.Compose([ transforms.Scale(int(imsize * 76 / 64)), transforms.RandomCrop(imsize), ]) val_transform = transforms.Compose([ transforms.Scale(int(imsize * 76 / 64)), transforms.CenterCrop(imsize), ]) if args.dataset == 'bird': train_dataset = ImageTextDataset(args.data_dir, split_dir, transform=train_transform, sample_type='train') val_dataset = ImageTextDataset(args.data_dir, 'val', transform=val_transform, sample_type='val') elif args.dataset == 'coco': train_dataset = CaptionDataset(args.data_dir, split_dir, transform=train_transform, sample_type='train', coco_data_json=args.coco_data_json) val_dataset = CaptionDataset(args.data_dir, 'val', transform=val_transform, sample_type='val', coco_data_json=args.coco_data_json) else: raise NotImplementedError train_dataloader = torch.utils.data.DataLoader( train_dataset, batch_size=cfg.IMAGETEXT.BATCH_SIZE, shuffle=bshuffle, num_workers=int(cfg.WORKERS)) val_dataloader = torch.utils.data.DataLoader( val_dataset, batch_size=cfg.IMAGETEXT.BATCH_SIZE, shuffle=False, num_workers=1) # define the model and optimizer if args.raw_checkpoint != '': encoder, decoder = load_raw_checkpoint(args.raw_checkpoint) else: encoder = Encoder() decoder = DecoderWithAttention( attention_dim=cfg.IMAGETEXT.ATTENTION_DIM, embed_dim=cfg.IMAGETEXT.EMBED_DIM, decoder_dim=cfg.IMAGETEXT.DECODER_DIM, vocab_size=train_dataset.n_words) # load checkpoint if cfg.IMAGETEXT.CHECKPOINT != '': outputer_val.log("load model from: {}".format( cfg.IMAGETEXT.CHECKPOINT)) encoder, decoder = load_checkpoint(encoder, decoder, cfg.IMAGETEXT.CHECKPOINT) encoder.fine_tune(False) # to cuda encoder = encoder.cuda() decoder = decoder.cuda() loss_func = torch.nn.CrossEntropyLoss() if args.eval: # eval only outputer_val.log("only eval the model...") assert cfg.IMAGETEXT.CHECKPOINT != '' val_rtn_dict, outputer_val = validate_one_epoch( 0, val_dataloader, encoder, decoder, loss_func, outputer_val) outputer_val.log("\n[valid]: {}\n".format(dict2str(val_rtn_dict))) return # define optimizer optimizer_encoder = torch.optim.Adam(encoder.parameters(), lr=cfg.IMAGETEXT.ENCODER_LR) optimizer_decoder = torch.optim.Adam(decoder.parameters(), lr=cfg.IMAGETEXT.DECODER_LR) encoder_lr_scheduler = torch.optim.lr_scheduler.StepLR( optimizer_encoder, step_size=10, gamma=cfg.IMAGETEXT.LR_GAMMA) decoder_lr_scheduler = torch.optim.lr_scheduler.StepLR( optimizer_decoder, step_size=10, gamma=cfg.IMAGETEXT.LR_GAMMA) print("train the model...") for epoch_idx in range(cfg.IMAGETEXT.EPOCH): # val_rtn_dict, outputer_val = validate_one_epoch(epoch_idx, val_dataloader, encoder, # decoder, loss_func, outputer_val) # outputer_val.log("\n[valid] epoch: {}, {}".format(epoch_idx, dict2str(val_rtn_dict))) train_rtn_dict, outputer_train = train_one_epoch( epoch_idx, train_dataloader, encoder, decoder, optimizer_encoder, optimizer_decoder, loss_func, outputer_train) # adjust lr scheduler encoder_lr_scheduler.step() decoder_lr_scheduler.step() outputer_train.log("\n[train] epoch: {}, {}\n".format( epoch_idx, dict2str(train_rtn_dict))) val_rtn_dict, outputer_val = validate_one_epoch( epoch_idx, val_dataloader, encoder, decoder, loss_func, outputer_val) outputer_val.log("\n[valid] epoch: {}, {}\n".format( epoch_idx, dict2str(val_rtn_dict))) outputer_val.save_step({ "encoder": encoder.state_dict(), "decoder": decoder.state_dict() }) outputer_val.save({ "encoder": encoder.state_dict(), "decoder": decoder.state_dict() })
def main(args): assert torch.cuda.is_available(), 'CUDA is not available.' torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True torch.set_num_threads(args.workers) print('Evaluate the Robustness of a Detector : prepare_seed : {:}'.format( args.rand_seed)) prepare_seed(args.rand_seed) assert args.init_model is not None and Path( args.init_model).exists(), 'invalid initial model path : {:}'.format( args.init_model) checkpoint = load_checkpoint(args.init_model) xargs = checkpoint['args'] eval_func = procedures[xargs.procedure] logger = prepare_logger(args) if xargs.use_gray == False: mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]]) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) else: mean_fill = (0.5, ) normalize = transforms.Normalize(mean=[mean_fill[0]], std=[0.5]) robust_component = [ transforms.ToTensor(), normalize, transforms.PreCrop(xargs.pre_crop_expand) ] robust_component += [ transforms.RandomTrans(args.robust_scale, args.robust_offset, args.robust_rotate, args.robust_iters, args.robust_cache_dir, True) ] robust_transform = transforms.Compose3V(robust_component) logger.log('--- arguments --- : {:}'.format(args)) logger.log('robust_transform : {:}'.format(robust_transform)) recover = xvision.transforms2v.ToPILImage(normalize) model_config = load_configure(xargs.model_config, logger) shape = (xargs.height, xargs.width) logger.log('Model : {:} $$$$ Shape : {:}'.format(model_config, shape)) # Evaluation Dataloader assert args.eval_lists is not None and len( args.eval_lists) > 0, 'invalid args.eval_lists : {:}'.format( args.eval_lists) eval_loaders = [] for eval_list in args.eval_lists: eval_data = RobustDataset(robust_transform, xargs.sigma, model_config.downsample, xargs.heatmap_type, shape, xargs.use_gray, xargs.data_indicator) if xargs.x68to49: eval_data.load_list(eval_list, 68, xargs.boxindicator, True) convert68to49(eval_data) else: eval_data.load_list(eval_list, xargs.num_pts, xargs.boxindicator, True) eval_data.get_normalization_distance(None, True) if hasattr(xargs, 'batch_size'): batch_size = xargs.batch_size elif hasattr(xargs, 'i_batch_size') and xargs.i_batch_size > 0: batch_size = xargs.i_batch_size elif hasattr(xargs, 'v_batch_size') and xargs.v_batch_size > 0: batch_size = xargs.v_batch_size else: raise ValueError( 'can not find batch size information in xargs : {:}'.format( xargs)) eval_loader = torch.utils.data.DataLoader(eval_data, batch_size=batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) eval_loaders.append(eval_loader) # define the detection network detector = obtain_pro_model(model_config, xargs.num_pts, xargs.sigma, xargs.use_gray) assert model_config.downsample == detector.downsample, 'downsample is not correct : {:} vs {:}'.format( model_config.downsample, detector.downsample) logger.log("=> detector :\n {:}".format(detector)) logger.log("=> Net-Parameters : {:} MB".format( count_parameters_in_MB(detector))) for i, eval_loader in enumerate(eval_loaders): logger.log('The [{:2d}/{:2d}]-th testing-data = {:}'.format( i, len(eval_loaders), eval_loader.dataset)) logger.log('basic-arguments : {:}\n'.format(xargs)) logger.log('xoxox-arguments : {:}\n'.format(args)) detector.load_state_dict(remove_module_dict(checkpoint['detector'])) detector = detector.cuda() for ieval, loader in enumerate(eval_loaders): errors, valids, meta = eval_func(detector, loader, args.print_freq, logger) logger.log( '[{:2d}/{:02d}] eval-data : error : mean={:.3f}, std={:.3f}'. format(ieval, len(eval_loaders), np.mean(errors), np.std(errors))) logger.log( '[{:2d}/{:02d}] eval-data : valid : mean={:.3f}, std={:.3f}'. format(ieval, len(eval_loaders), np.mean(valids), np.std(valids))) nme, auc, pck_curves = meta.compute_mse(loader.dataset.dataset_name, logger) logger.close()
def main(args): assert torch.cuda.is_available(), 'CUDA is not available.' torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True torch.set_num_threads(args.workers) print('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed)) prepare_seed(args.rand_seed) temporal_main, eval_all = procedures['{:}-train'.format( args.procedure)], procedures['{:}-test'.format(args.procedure)] logger = prepare_logger(args) # General Data Argumentation normalize, train_transform, eval_transform, robust_transform = prepare_data_augmentation( transforms, args) recover = transforms.ToPILImage(normalize) args.tensor2imageF = recover assert (args.scale_min + args.scale_max) / 2 == 1, 'The scale is not ok : {:} ~ {:}'.format( args.scale_min, args.scale_max) # Model Configure Load model_config = load_configure(args.model_config, logger) sbr_config = load_configure(args.sbr_config, logger) shape = (args.height, args.width) logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format( model_config, args.sigma, shape)) logger.log('--> SBR Configuration : {:}\n'.format(sbr_config)) # Training Dataset train_data = VDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, \ args.data_indicator, sbr_config, transforms.ToPILImage(normalize, 'cv2gray')) train_data.load_list(args.train_lists, args.num_pts, args.boxindicator, args.normalizeL, True) # Evaluation Dataloader assert len( args.eval_ilists) == 1, 'invalid length of eval_ilists : {:}'.format( len(eval_ilists)) eval_data = IDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, args.data_indicator) eval_data.load_list(args.eval_ilists[0], args.num_pts, args.boxindicator, args.normalizeL, True) if args.x68to49: assert args.num_pts == 68, 'args.num_pts is not 68 vs. {:}'.format( args.num_pts) if train_data is not None: train_data = convert68to49(train_data) eval_data = convert68to49(eval_data) args.num_pts = 49 # define the temporal model (accelerated SBR) net = obtain_pro_temporal(model_config, sbr_config, args.num_pts, args.sigma, args.use_gray) assert model_config.downsample == net.downsample, 'downsample is not correct : {:} vs {:}'.format( model_config.downsample, net.downsample) logger.log("=> network :\n {}".format(net)) logger.log('Training-data : {:}'.format(train_data)) logger.log('Evaluate-data : {:}'.format(eval_data)) logger.log('arguments : {:}'.format(args)) opt_config = load_configure(args.opt_config, logger) optimizer, scheduler, criterion = obtain_optimizer(net.parameters(), opt_config, logger) logger.log('criterion : {:}'.format(criterion)) net, criterion = net.cuda(), criterion.cuda() net = torch.nn.DataParallel(net) last_info = logger.last_info() try: last_checkpoint = load_checkpoint(args.init_model) checkpoint = remove_module_dict(last_checkpoint['state_dict'], False) net.module.detector.load_state_dict(checkpoint) except: last_checkpoint = load_checkpoint(args.init_model) net.load_state_dict(last_checkpoint['state_dict']) detector = torch.nn.DataParallel(net.module.detector) logger.log("=> initialize the detector : {:}".format(args.init_model)) net.eval() detector.eval() logger.log('SBR Config : {:}'.format(sbr_config)) save_xdir = logger.path('meta') type_error = 0 random.seed(111) index_list = list(range(len(train_data))) random.shuffle(index_list) #selected_list = index_list[: min(200, len(index_list))] selected_list = [ 7260, 11506, 39952, 75196, 51614, 41061, 37747, 41355, 47875 ] for iidx, i in enumerate(selected_list): frames, Fflows, Bflows, targets, masks, normpoints, transthetas, meanthetas, image_index, nopoints, shapes, is_images = train_data[ i] frames, Fflows, Bflows, is_images = frames.unsqueeze( 0), Fflows.unsqueeze(0), Bflows.unsqueeze(0), is_images.unsqueeze( 0) # batch_heatmaps is a list for stage-predictions, each element should be [Batch, Sequence, PTS, H/Down, W/Down] if args.procedure == 'heatmap': batch_heatmaps, batch_locs, batch_scos, batch_past2now, batch_future2now, batch_FBcheck = net( frames, Fflows, Bflows, is_images) else: batch_locs, batch_past2now, batch_future2now, batch_FBcheck = net( frames, Fflows, Bflows, is_images) (batch_size, frame_length, C, H, W), num_pts, annotate_index = frames.size( ), args.num_pts, train_data.video_L batch_locs = batch_locs.cpu()[:, :, :num_pts] video_mask = masks.unsqueeze(0)[:, :num_pts] batch_past2now = batch_past2now.cpu()[:, :, :num_pts] batch_future2now = batch_future2now.cpu()[:, :, :num_pts] batch_FBcheck = batch_FBcheck[:, :num_pts].cpu() FB_check_oks = FB_communication(criterion, batch_locs, batch_past2now, batch_future2now, batch_FBcheck, video_mask, sbr_config) # locations norm_past_det_locs = torch.cat( (batch_locs[0, annotate_index - 1, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) norm_noww_det_locs = torch.cat( (batch_locs[0, annotate_index, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) norm_next_det_locs = torch.cat( (batch_locs[0, annotate_index + 1, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) norm_next_locs = torch.cat( (batch_past2now[0, annotate_index, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) norm_past_locs = torch.cat( (batch_future2now[0, annotate_index - 1, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) transtheta = transthetas[:2, :] norm_past_det_locs = torch.mm(transtheta, norm_past_det_locs) norm_noww_det_locs = torch.mm(transtheta, norm_noww_det_locs) norm_next_det_locs = torch.mm(transtheta, norm_next_det_locs) norm_next_locs = torch.mm(transtheta, norm_next_locs) norm_past_locs = torch.mm(transtheta, norm_past_locs) real_past_det_locs = denormalize_points(shapes.tolist(), norm_past_det_locs) real_noww_det_locs = denormalize_points(shapes.tolist(), norm_noww_det_locs) real_next_det_locs = denormalize_points(shapes.tolist(), norm_next_det_locs) real_next_locs = denormalize_points(shapes.tolist(), norm_next_locs) real_past_locs = denormalize_points(shapes.tolist(), norm_past_locs) gt_noww_points = train_data.labels[image_index.item()].get_points() FB_check_oks = FB_check_oks[:num_pts].squeeze() #import pdb; pdb.set_trace() if FB_check_oks.sum().item() > 2: point_index = FB_check_oks.nonzero().squeeze().tolist() something_wrong = False for pidx in point_index: real_now_det_loc = real_noww_det_locs[:, pidx] real_pst_det_loc = real_past_det_locs[:, pidx] real_net_det_loc = real_next_det_locs[:, pidx] real_nex_loc = real_next_locs[:, pidx] real_pst_loc = real_next_locs[:, pidx] grdt_now_loc = gt_noww_points[:2, pidx] #if torch.abs(real_now_loc - grdt_now_loc).max() > 5: # something_wrong = True #if torch.abs(real_nex_loc - grdt_nex_loc).max() > 5: # something_wrong = True #if something_wrong == True: if True: [image_past, image_noww, image_next] = train_data.datas[image_index.item()] try: crop_box = train_data.labels[ image_index.item()].get_box().tolist() #crop_box = [crop_box[0]-20, crop_box[1]-20, crop_box[2]+20, crop_box[3]+20] except: crop_box = False RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255) colors = [ GREEN if _i in point_index else RED for _i in range(num_pts) ] if crop_box != False or True: I_past_det = draw_image_by_points(image_past, real_past_det_locs[:], 3, colors, crop_box, (400, 500)) I_noww_det = draw_image_by_points(image_noww, real_noww_det_locs[:], 3, colors, crop_box, (400, 500)) I_next_det = draw_image_by_points(image_next, real_next_det_locs[:], 3, colors, crop_box, (400, 500)) I_next = draw_image_by_points(image_next, real_next_locs[:], 3, colors, crop_box, (400, 500)) I_past = draw_image_by_points(image_past, real_past_locs[:], 3, colors, crop_box, (400, 500)) I_past.save( str(save_xdir / '{:05d}-v1-a-pastt.png'.format(i))) I_noww_det.save( str(save_xdir / '{:05d}-v1-b-curre.png'.format(i))) I_next.save( str(save_xdir / '{:05d}-v1-c-nextt.png'.format(i))) I_past_det.save( str(save_xdir / '{:05d}-v1-det-a-past.png'.format(i))) I_noww_det.save( str(save_xdir / '{:05d}-v1-det-b-curr.png'.format(i))) I_next_det.save( str(save_xdir / '{:05d}-v1-det-c-next.png'.format(i))) #[image_past, image_noww, image_next] = train_data.datas[image_index.item()] #image_noww = draw_image_by_points(image_noww, real_noww_locs[:], 2, colors, False, False) #image_next = draw_image_by_points(image_next, real_next_locs[:], 2, colors, False, False) #image_past = draw_image_by_points(image_past, real_past_locs[:], 2, colors, False, False) #image_noww.save( str(save_xdir / '{:05d}-v2-b-curre.png'.format(i)) ) #image_next.save( str(save_xdir / '{:05d}-v2-c-nextt.png'.format(i)) ) #image_past.save( str(save_xdir / '{:05d}-v2-a-pastt.png'.format(i)) ) #type_error += 1 logger.log( 'Handle {:05d}/{:05d} :: {:05d}, ok-points={:.3f}, wrong data={:}'. format(iidx, len(selected_list), i, FB_check_oks.float().mean().item(), type_error)) save_xx_dir = save_xdir.parent / 'image-data' save_xx_dir.mkdir(parents=True, exist_ok=True) selected_list = [100, 115, 200, 300, 400] + list(range(200, 220)) for iidx, i in enumerate(selected_list): inputs, targets, masks, normpoints, transthetas, meanthetas, image_index, nopoints, shapes = eval_data[ i] inputs = inputs.unsqueeze(0) (batch_size, C, H, W), num_pts = inputs.size(), args.num_pts _, _, batch_locs, batch_scos = detector(inputs) # inputs batch_locs, batch_scos = batch_locs.cpu(), batch_scos.cpu() norm_locs = normalize_points((H, W), batch_locs[0, :num_pts].transpose(1, 0)) norm_det_locs = torch.cat((norm_locs, torch.ones(1, num_pts)), dim=0) norm_det_locs = torch.mm(transthetas[:2, :], norm_det_locs) real_det_locs = denormalize_points(shapes.tolist(), norm_det_locs) gt_now_points = eval_data.labels[image_index.item()].get_points() image_now = eval_data.datas[image_index.item()] crop_box = eval_data.labels[image_index.item()].get_box().tolist() RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255) Gcolors = [GREEN for _ in range(num_pts)] points = torch.cat((real_det_locs, gt_now_points[:2]), dim=1) colors = [GREEN for _ in range(num_pts)] + [BLUE for _ in range(num_pts)] image = draw_image_by_points(image_now, real_det_locs, 3, Gcolors, crop_box, (400, 500)) image.save(str(save_xx_dir / '{:05d}-crop.png'.format(i))) image = draw_image_by_points(image_now, points, 3, colors, False, False) #image = draw_image_by_points(image_now, real_det_locs, 3, colors , False, False) image.save(str(save_xx_dir / '{:05d}-orig.png'.format(i))) logger.log('Finish drawing : {:}'.format(save_xdir)) logger.log('Finish drawing : {:}'.format(save_xx_dir)) logger.close()
type=str, default=random_flower, help='Path to image') parser.add_argument('--checkpoint', type=str, default='checkpoint.pth', help='Path to checkpoint') parser.add_argument('--topk', type=int, default=5, help='Top N Classes and Probabilities') parser.add_argument('--json', type=str, default='cat_to_name.json', help='class_to_name json file') parser.add_argument('--gpu', type=str, default='cuda', help='GPU or CPU') arg, unknown = parser.parse_known_args() device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') class_name = open_json(arg.json) model = load_checkpoint(arg.checkpoint) checkpoint = torch.load(arg.checkpoint) image = process_image(arg.image_dir) probs, classes = predict(random_flower, model) prediction_test(class_name, classes, probs, random_folder)
else: raise Exception("Dataset {} undefined".format(opts.dataset)) train_dataloader = get_dataloader(dataset=train_data, opts=opts, collate_fxn=lambda x: torch.cat(x)) # Setup the model and optimizer model = models.ValueNet(opts) model_dict = {"value_model": model} if opts.cuda == 1: to_cuda([model, lfn]) optimizer = models.get_optim(model.parameters(), opts) # Load checkpoint if it exists if opts.checkpoint != "": models.load_checkpoint(model_dict, optimizer, opts.checkpoint, opts) else: models.check_and_print_opts(opts, None) # Run the train loop for i in range(opts.nepoch): train_loss, train_error = train_epoch(model, lfn, optimizer, train_dataloader, opts) pretty_log("train loss {:<5.4f} error {:<5.2f} {}".format( train_loss, train_error * 100, i)) if opts.checkpoint != "": metadata = { "epoch": i, "train_loss": train_loss, "train_error": train_error }
def main(args): assert torch.cuda.is_available(), 'CUDA is not available.' torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True torch.set_num_threads( args.workers ) print ('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed)) prepare_seed(args.rand_seed) temporal_main, eval_all = procedures['{:}-train'.format(args.procedure)], procedures['{:}-test'.format(args.procedure)] logger = prepare_logger(args) # General Data Argumentation normalize, train_transform, eval_transform, robust_transform = prepare_data_augmentation(transforms, args) recover = transforms.ToPILImage(normalize) args.tensor2imageF = recover assert (args.scale_min+args.scale_max) / 2 == 1, 'The scale is not ok : {:} ~ {:}'.format(args.scale_min, args.scale_max) # Model Configure Load model_config = load_configure(args.model_config, logger) sbr_config = load_configure(args.sbr_config, logger) shape = (args.height, args.width) logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format(model_config, args.sigma, shape)) logger.log('--> SBR Configuration : {:}\n'.format(sbr_config)) # Training Dataset train_data = VDataset(train_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, \ args.data_indicator, sbr_config, transforms.ToPILImage(normalize, 'cv2gray')) train_data.load_list(args.train_lists, args.num_pts, args.boxindicator, args.normalizeL, True) batch_sampler = SbrBatchSampler(train_data, args.i_batch_size, args.v_batch_size, args.sbr_sampler_use_vid) train_loader = torch.utils.data.DataLoader(train_data, batch_sampler=batch_sampler, num_workers=args.workers, pin_memory=True) # Evaluation Dataloader eval_loaders = [] if args.eval_ilists is not None: for eval_ilist in args.eval_ilists: eval_idata = IDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, args.data_indicator) eval_idata.load_list(eval_ilist, args.num_pts, args.boxindicator, args.normalizeL, True) eval_iloader = torch.utils.data.DataLoader(eval_idata, batch_size=args.i_batch_size+args.v_batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) eval_loaders.append((eval_iloader, False)) if args.eval_vlists is not None: for eval_vlist in args.eval_vlists: eval_vdata = IDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, args.data_indicator) eval_vdata.load_list(eval_vlist, args.num_pts, args.boxindicator, args.normalizeL, True) eval_vloader = torch.utils.data.DataLoader(eval_vdata, batch_size=args.i_batch_size+args.v_batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) eval_loaders.append((eval_vloader, True)) # from 68 points to 49 points, removing the face contour if args.x68to49: assert args.num_pts == 68, 'args.num_pts is not 68 vs. {:}'.format(args.num_pts) if train_data is not None: train_data = convert68to49( train_data ) for eval_loader, is_video in eval_loaders: convert68to49( eval_loader.dataset ) args.num_pts = 49 # define the temporal model (accelerated SBR) net = obtain_pro_temporal(model_config, sbr_config, args.num_pts, args.sigma, args.use_gray) assert model_config.downsample == net.downsample, 'downsample is not correct : {:} vs {:}'.format(model_config.downsample, net.downsample) logger.log("=> network :\n {}".format(net)) logger.log('Training-data : {:}'.format(train_data)) for i, eval_loader in enumerate(eval_loaders): eval_loader, is_video = eval_loader logger.log('The [{:2d}/{:2d}]-th testing-data [{:}] = {:}'.format(i, len(eval_loaders), 'video' if is_video else 'image', eval_loader.dataset)) logger.log('arguments : {:}'.format(args)) opt_config = load_configure(args.opt_config, logger) if hasattr(net, 'specify_parameter'): net_param_dict = net.specify_parameter(opt_config.LR, opt_config.weight_decay) else : net_param_dict = net.parameters() optimizer, scheduler, criterion = obtain_optimizer(net_param_dict, opt_config, logger) logger.log('criterion : {:}'.format(criterion)) net, criterion = net.cuda(), criterion.cuda() net = torch.nn.DataParallel(net) last_info = logger.last_info() if last_info.exists(): logger.log("=> loading checkpoint of the last-info '{:}' start".format(last_info)) last_info = torch.load(last_info) start_epoch = last_info['epoch'] + 1 checkpoint = torch.load(last_info['last_checkpoint']) test_accuracies = checkpoint['test_accuracies'] assert last_info['epoch'] == checkpoint['epoch'], 'Last-Info is not right {:} vs {:}'.format(last_info, checkpoint['epoch']) net.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) scheduler.load_state_dict(checkpoint['scheduler']) logger.log("=> load-ok checkpoint '{:}' (epoch {:}) done" .format(logger.last_info(), checkpoint['epoch'])) elif args.init_model is not None: last_checkpoint = load_checkpoint(args.init_model) checkpoint = remove_module_dict(last_checkpoint['state_dict'], False) net.module.detector.load_state_dict( checkpoint ) logger.log("=> initialize the detector : {:}".format(args.init_model)) start_epoch, test_accuracies = 0, {'best': 10000} else: logger.log("=> do not find the last-info file : {:}".format(last_info)) start_epoch, test_accuracies = 0, {'best': 10000} detector = torch.nn.DataParallel(net.module.detector) if args.skip_first_eval == False: logger.log('===>>> First Time Evaluation') eval_results, eval_metas = eval_all(args, eval_loaders, detector, criterion, 'Before-Training', logger, opt_config, None) save_path = save_checkpoint(eval_metas, logger.path('meta') / '{:}-first.pth'.format(model_config.arch), logger) logger.log('===>>> Before Training : {:}'.format(eval_results)) # Main Training and Evaluation Loop start_time = time.time() epoch_time = AverageMeter() for epoch in range(start_epoch, opt_config.epochs): need_time = convert_secs2time(epoch_time.avg * (opt_config.epochs-epoch), True) epoch_str = 'epoch-{:03d}-{:03d}'.format(epoch, opt_config.epochs) LRs = scheduler.get_lr() logger.log('\n==>>{:s} [{:s}], [{:s}], LR : [{:.5f} ~ {:.5f}], Config : {:}'.format(time_string(), epoch_str, need_time, min(LRs), max(LRs), opt_config)) # train for one epoch train_loss, train_nme = temporal_main(args, train_loader, net, criterion, optimizer, epoch_str, logger, opt_config, sbr_config, epoch>=sbr_config.start, 'train') scheduler.step() # log the results logger.log('==>>{:s} Train [{:}] Average Loss = {:.6f}, NME = {:.2f}'.format(time_string(), epoch_str, train_loss, train_nme*100)) save_path = save_checkpoint({ 'epoch': epoch, 'args' : deepcopy(args), 'arch' : model_config.arch, 'detector' : detector.state_dict(), 'test_accuracies': test_accuracies, 'state_dict': net.state_dict(), 'scheduler' : scheduler.state_dict(), 'optimizer' : optimizer.state_dict(), }, logger.path('model') / 'ckp-seed-{:}-last-{:}.pth'.format(args.rand_seed, model_config.arch), logger) last_info = save_checkpoint({ 'epoch': epoch, 'last_checkpoint': save_path, }, logger.last_info(), logger) if (args.eval_freq is None) or (epoch+1 == opt_config.epochs) or (epoch%args.eval_freq == 0): if epoch+1 == opt_config.epochs: _robust_transform = robust_transform else : _robust_transform = None logger.log('') eval_results, eval_metas = eval_all(args, eval_loaders, detector, criterion, epoch_str, logger, opt_config, _robust_transform) # check whether it is the best and save with copyfile(src, dst) try: cur_eval_nme = float( eval_results.split('NME = ')[1].split(' ')[0] ) except: cur_eval_nme = 1e9 test_accuracies[epoch] = cur_eval_nme if test_accuracies['best'] > cur_eval_nme: # find the lowest error dest_path = logger.path('model') / 'ckp-seed-{:}-best-{:}.pth'.format(args.rand_seed, model_config.arch) copyfile(save_path, dest_path) logger.log('==>> find lowest error = {:}, save into {:}'.format(cur_eval_nme, dest_path)) meta_save_path = save_checkpoint(eval_metas, logger.path('meta') / '{:}-{:}.pth'.format(model_config.arch, epoch_str), logger) logger.log('==>> evaluation results : {:}'.format(eval_results)) # measure elapsed time epoch_time.update(time.time() - start_time) start_time = time.time() logger.log('Final checkpoint into {:}'.format(logger.last_info())) logger.close()
def main(): cfg, args = _parse_args() torch.manual_seed(args.seed) output_base = cfg.OUTPUT_DIR if len(cfg.OUTPUT_DIR) > 0 else './output' exp_name = '-'.join([ datetime.now().strftime("%Y%m%d-%H%M%S"), cfg.MODEL.ARCHITECTURE, str(cfg.INPUT.IMG_SIZE) ]) output_dir = get_outdir(output_base, exp_name) with open(os.path.join(output_dir, 'config.yaml'), 'w', encoding='utf-8') as file_writer: # cfg.dump(stream=file_writer, default_flow_style=False, indent=2, allow_unicode=True) file_writer.write(pyaml.dump(cfg)) logger = setup_logger(file_name=os.path.join(output_dir, 'train.log'), control_log=False, log_level='INFO') # create model model = create_model(cfg.MODEL.ARCHITECTURE, num_classes=cfg.MODEL.NUM_CLASSES, pretrained=True, in_chans=cfg.INPUT.IN_CHANNELS, drop_rate=cfg.MODEL.DROP_RATE, drop_connect_rate=cfg.MODEL.DROP_CONNECT, global_pool=cfg.MODEL.GLOBAL_POOL) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu gpu_list = list(map(int, args.gpu.split(','))) device = 'cuda' if len(gpu_list) == 1: model.cuda() torch.backends.cudnn.benchmark = True elif len(gpu_list) > 1: model = nn.DataParallel(model, device_ids=gpu_list) model = convert_model(model).cuda() torch.backends.cudnn.benchmark = True else: device = 'cpu' logger.info('device: {}, gpu_list: {}'.format(device, gpu_list)) optimizer = create_optimizer(cfg, model) # optionally initialize from a checkpoint if args.initial_checkpoint and os.path.isfile(args.initial_checkpoint): load_checkpoint(model, args.initial_checkpoint) # optionally resume from a checkpoint resume_state = None resume_epoch = None if args.resume and os.path.isfile(args.resume): resume_state, resume_epoch = resume_checkpoint(model, args.resume) if resume_state and not args.no_resume_opt: if 'optimizer' in resume_state: optimizer.load_state_dict(resume_state['optimizer']) logger.info('Restoring optimizer state from [{}]'.format( args.resume)) start_epoch = 0 if args.start_epoch is not None: start_epoch = args.start_epoch elif resume_epoch is not None: start_epoch = resume_epoch model_ema = None if cfg.SOLVER.EMA: # Important to create EMA model after cuda() model_ema = ModelEma(model, decay=cfg.SOLVER.EMA_DECAY, device=device, resume=args.resume) lr_scheduler, num_epochs = create_scheduler(cfg, optimizer) if lr_scheduler is not None and start_epoch > 0: lr_scheduler.step(start_epoch) # summary print('=' * 60) print(cfg) print('=' * 60) print(model) print('=' * 60) summary(model, (3, cfg.INPUT.IMG_SIZE, cfg.INPUT.IMG_SIZE)) # dataset dataset_train = Dataset(cfg.DATASETS.TRAIN) dataset_valid = Dataset(cfg.DATASETS.TEST) train_loader = create_loader(dataset_train, cfg, is_training=True) valid_loader = create_loader(dataset_valid, cfg, is_training=False) # loss function if cfg.SOLVER.LABEL_SMOOTHING > 0: train_loss_fn = LabelSmoothingCrossEntropy( smoothing=cfg.SOLVER.LABEL_SMOOTHING).to(device) validate_loss_fn = nn.CrossEntropyLoss().to(device) else: train_loss_fn = nn.CrossEntropyLoss().to(device) validate_loss_fn = train_loss_fn eval_metric = cfg.SOLVER.EVAL_METRIC best_metric = None best_epoch = None saver = CheckpointSaver( checkpoint_dir=output_dir, recovery_dir=output_dir, decreasing=True if eval_metric == 'loss' else False) try: for epoch in range(start_epoch, num_epochs): train_metrics = train_epoch(epoch, model, train_loader, optimizer, train_loss_fn, cfg, logger, lr_scheduler=lr_scheduler, saver=saver, device=device, model_ema=model_ema) eval_metrics = validate(epoch, model, valid_loader, validate_loss_fn, cfg, logger) if model_ema is not None: ema_eval_metrics = validate(epoch, model_ema.ema, valid_loader, validate_loss_fn, cfg, logger) eval_metrics = ema_eval_metrics if lr_scheduler is not None: # step LR for next epoch lr_scheduler.step(epoch + 1, eval_metrics[eval_metric]) update_summary(epoch, train_metrics, eval_metrics, os.path.join(output_dir, 'summary.csv'), write_header=best_metric is None) if saver is not None: # save proper checkpoint with eval metric save_metric = eval_metrics[eval_metric] best_metric, best_epoch = saver.save_checkpoint( model, optimizer, cfg, epoch=epoch, model_ema=model_ema, metric=save_metric) except KeyboardInterrupt: pass if best_metric is not None: logger.info('*** Best metric: {0} (epoch {1})'.format( best_metric, best_epoch))
def main(args): assert torch.cuda.is_available(), 'CUDA is not available.' torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True torch.set_num_threads(args.workers) print('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed)) prepare_seed(args.rand_seed) logger = prepare_logger(args) checkpoint = load_checkpoint(args.init_model) xargs = checkpoint['args'] logger.log('Previous args : {:}'.format(xargs)) # General Data Augmentation if xargs.use_gray == False: mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]]) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) else: mean_fill = (0.5, ) normalize = transforms.Normalize(mean=[mean_fill[0]], std=[0.5]) eval_transform = transforms.Compose2V([transforms.ToTensor(), normalize, \ transforms.PreCrop(xargs.pre_crop_expand), \ transforms.CenterCrop(xargs.crop_max)]) # Model Configure Load model_config = load_configure(xargs.model_config, logger) shape = (xargs.height, xargs.width) logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format( model_config, xargs.sigma, shape)) # Evaluation Dataloader eval_loaders = [] if args.eval_ilists is not None: for eval_ilist in args.eval_ilists: eval_idata = EvalDataset(eval_transform, xargs.sigma, model_config.downsample, xargs.heatmap_type, shape, xargs.use_gray, xargs.data_indicator) eval_idata.load_list(eval_ilist, args.num_pts, xargs.boxindicator, xargs.normalizeL, True) eval_iloader = torch.utils.data.DataLoader( eval_idata, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) eval_loaders.append((eval_iloader, False)) if args.eval_vlists is not None: for eval_vlist in args.eval_vlists: eval_vdata = EvalDataset(eval_transform, xargs.sigma, model_config.downsample, xargs.heatmap_type, shape, xargs.use_gray, xargs.data_indicator) eval_vdata.load_list(eval_vlist, args.num_pts, xargs.boxindicator, xargs.normalizeL, True) eval_vloader = torch.utils.data.DataLoader( eval_vdata, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) eval_loaders.append((eval_vloader, True)) # define the detector detector = obtain_pro_model(model_config, xargs.num_pts, xargs.sigma, xargs.use_gray) assert model_config.downsample == detector.downsample, 'downsample is not correct : {:} vs {:}'.format( model_config.downsample, detector.downsample) logger.log("=> detector :\n {:}".format(detector)) logger.log("=> Net-Parameters : {:} MB".format( count_parameters_in_MB(detector))) logger.log('=> Eval-Transform : {:}'.format(eval_transform)) detector = detector.cuda() net = torch.nn.DataParallel(detector) net.eval() net.load_state_dict(checkpoint['detector']) cpu = torch.device('cpu') assert len(args.use_stable) == 2 for iLOADER, (loader, is_video) in enumerate(eval_loaders): logger.log( '{:} The [{:2d}/{:2d}]-th test set [{:}] = {:} with {:} batches.'. format(time_string(), iLOADER, len(eval_loaders), 'video' if is_video else 'image', loader.dataset, len(loader))) with torch.no_grad(): all_points, all_results, all_image_ps = [], [], [] for i, (inputs, targets, masks, normpoints, transthetas, image_index, nopoints, shapes) in enumerate(loader): image_index = image_index.squeeze(1).tolist() (batch_size, C, H, W), num_pts = inputs.size(), xargs.num_pts # batch_heatmaps is a list for stage-predictions, each element should be [Batch, C, H, W] if xargs.procedure == 'heatmap': batch_features, batch_heatmaps, batch_locs, batch_scos = net( inputs) batch_locs = batch_locs[:, :-1, :] else: batch_locs = net(inputs) batch_locs = batch_locs.detach().to(cpu) # evaluate the training data for ibatch, (imgidx, nopoint) in enumerate(zip(image_index, nopoints)): if xargs.procedure == 'heatmap': norm_locs = normalize_points( (H, W), batch_locs[ibatch].transpose(1, 0)) norm_locs = torch.cat( (norm_locs, torch.ones(1, num_pts)), dim=0) else: norm_locs = torch.cat((batch_locs[ibatch].permute( 1, 0), torch.ones(1, num_pts)), dim=0) transtheta = transthetas[ibatch][:2, :] norm_locs = torch.mm(transtheta, norm_locs) real_locs = denormalize_points(shapes[ibatch].tolist(), norm_locs) #real_locs = torch.cat((real_locs, batch_scos[ibatch].permute(1,0)), dim=0) real_locs = torch.cat((real_locs, torch.ones(1, num_pts)), dim=0) xpoints = loader.dataset.labels[imgidx].get_points().numpy( ) image_path = loader.dataset.datas[imgidx] # put into the list all_points.append(torch.from_numpy(xpoints)) all_results.append(real_locs) all_image_ps.append(image_path) total = len(all_points) logger.log( '{:} The [{:2d}/{:2d}]-th test set finishes evaluation : {:} frames/images' .format(time_string(), iLOADER, len(eval_loaders), total)) """ if args.use_stable[0] > 0: save_dir = Path( osp.join(args.save_path, '{:}-X-{:03d}'.format(args.model_name, iLOADER)) ) save_dir.mkdir(parents=True, exist_ok=True) wrap_parallel = WrapParallel(save_dir, all_image_ps, all_results, all_points, 180, (255, 0, 0)) wrap_loader = torch.utils.data.DataLoader(wrap_parallel, batch_size=args.workers, shuffle=False, num_workers=args.workers, pin_memory=True) for iL, INDEXES in enumerate(wrap_loader): _ = INDEXES cmd = 'ffmpeg -y -i {:}/%06d.png -framerate 30 {:}.avi'.format(save_dir, save_dir) logger.log('{:} possible >>>>> : {:}'.format(time_string(), cmd)) os.system( cmd ) if args.use_stable[1] > 0: save_dir = Path( osp.join(args.save_path, '{:}-Y-{:03d}'.format(args.model_name, iLOADER)) ) save_dir.mkdir(parents=True, exist_ok=True) Xpredictions, Xgts = torch.stack(all_results), torch.stack(all_points) new_preds = fc_solve(Xgts, Xpredictions, is_cuda=True) wrap_parallel = WrapParallel(save_dir, all_image_ps, new_preds, all_points, 180, (0, 0, 255)) wrap_loader = torch.utils.data.DataLoader(wrap_parallel, batch_size=args.workers, shuffle=False, num_workers=args.workers, pin_memory=True) for iL, INDEXES in enumerate(wrap_loader): _ = INDEXES cmd = 'ffmpeg -y -i {:}/%06d.png -framerate 30 {:}.avi'.format(save_dir, save_dir) logger.log('{:} possible >>>>> : {:}'.format(time_string(), cmd)) os.system( cmd ) """ Xpredictions, Xgts = torch.stack(all_results), torch.stack(all_points) save_path = Path( osp.join(args.save_path, '{:}-result-{:03d}.pth'.format(args.model_name, iLOADER))) torch.save( { 'paths': all_image_ps, 'ground-truths': Xgts, 'predictions': all_results }, save_path) logger.log('{:} save into {:}'.format(time_string(), save_path)) if False: new_preds = fc_solve_v2(Xgts, Xpredictions, is_cuda=True) # create the dir save_dir = Path( osp.join(args.save_path, '{:}-T-{:03d}'.format(args.model_name, iLOADER))) save_dir.mkdir(parents=True, exist_ok=True) wrap_parallel = WrapParallelV2(save_dir, all_image_ps, Xgts, all_results, new_preds, all_points, 180, [args.model_name, 'SRT']) wrap_parallel[0] wrap_loader = torch.utils.data.DataLoader(wrap_parallel, batch_size=args.workers, shuffle=False, num_workers=args.workers, pin_memory=True) for iL, INDEXES in enumerate(wrap_loader): _ = INDEXES cmd = 'ffmpeg -y -i {:}/%06d.png -vb 5000k {:}.avi'.format( save_dir, save_dir) logger.log('{:} possible >>>>> : {:}'.format(time_string(), cmd)) os.system(cmd) logger.close() return
def main(args): assert torch.cuda.is_available(), 'CUDA is not available.' torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True torch.set_num_threads(args.workers) print('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed)) prepare_seed(args.rand_seed) basic_main, eval_all = procedures['{:}-train'.format( args.procedure)], procedures['{:}-test'.format(args.procedure)] logger = prepare_logger(args) # General Data Augmentation normalize, train_transform, eval_transform, robust_transform = prepare_data_augmentation( transforms, args) #data_cache = get_path2image( args.shared_img_cache ) data_cache = None recover = transforms.ToPILImage(normalize) args.tensor2imageF = recover assert (args.scale_min + args.scale_max) / 2 == 1, 'The scale is not ok : {:} ~ {:}'.format( args.scale_min, args.scale_max) logger.log('robust_transform : {:}'.format(robust_transform)) # Model Configure Load model_config = load_configure(args.model_config, logger) shape = (args.height, args.width) logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format( model_config, args.sigma, shape)) # Training Dataset if args.train_lists: train_data = Dataset(train_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, args.data_indicator, data_cache) safex_data = Dataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, args.data_indicator, data_cache) train_data.set_cutout(args.cutout_length) safex_data.set_cutout(args.cutout_length) train_data.load_list(args.train_lists, args.num_pts, args.boxindicator, args.normalizeL, True) safex_data.load_list(args.train_lists, args.num_pts, args.boxindicator, args.normalizeL, True) if args.sampler is None: train_loader = torch.utils.data.DataLoader( train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, drop_last=True, pin_memory=True) safex_loader = torch.utils.data.DataLoader( safex_data, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, drop_last=True, pin_memory=True) else: train_sampler = SpecialBatchSampler(train_data, args.batch_size, args.sampler) safex_sampler = SpecialBatchSampler(safex_data, args.batch_size, args.sampler) logger.log('Training-sampler : {:}'.format(train_sampler)) train_loader = torch.utils.data.DataLoader( train_data, batch_sampler=train_sampler, num_workers=args.workers, pin_memory=True) safex_loader = torch.utils.data.DataLoader( safex_data, batch_sampler=safex_sampler, num_workers=args.workers, pin_memory=True) logger.log('Training-data : {:}'.format(train_data)) else: train_data, safex_loader = None, None #train_data[0] # Evaluation Dataloader eval_loaders = [] if args.eval_ilists is not None: for eval_ilist in args.eval_ilists: eval_idata = Dataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, args.data_indicator, data_cache) eval_idata.load_list(eval_ilist, args.num_pts, args.boxindicator, args.normalizeL, True) eval_iloader = torch.utils.data.DataLoader( eval_idata, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) eval_loaders.append((eval_iloader, False)) if args.eval_vlists is not None: for eval_vlist in args.eval_vlists: eval_vdata = Dataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, args.data_indicator, data_cache) eval_vdata.load_list(eval_vlist, args.num_pts, args.boxindicator, args.normalizeL, True) eval_vloader = torch.utils.data.DataLoader( eval_vdata, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) eval_loaders.append((eval_vloader, True)) # from 68 points to 49 points, removing the face contour if args.x68to49: assert args.num_pts == 68, 'args.num_pts is not 68 vs. {:}'.format( args.num_pts) if train_data is not None: train_data = convert68to49(train_data) for eval_loader, is_video in eval_loaders: convert68to49(eval_loader.dataset) args.num_pts = 49 # define the detector detector = obtain_pro_model(model_config, args.num_pts, args.sigma, args.use_gray) assert model_config.downsample == detector.downsample, 'downsample is not correct : {:} vs {:}'.format( model_config.downsample, detector.downsample) logger.log("=> detector :\n {:}".format(detector)) logger.log("=> Net-Parameters : {:} MB".format( count_parameters_in_MB(detector))) for i, eval_loader in enumerate(eval_loaders): eval_loader, is_video = eval_loader logger.log('The [{:2d}/{:2d}]-th testing-data [{:}] = {:}'.format( i, len(eval_loaders), 'video' if is_video else 'image', eval_loader.dataset)) logger.log('arguments : {:}\n'.format(args)) logger.log('train_transform : {:}'.format(train_transform)) logger.log('eval_transform : {:}'.format(eval_transform)) opt_config = load_configure(args.opt_config, logger) if hasattr(detector, 'specify_parameter'): net_param_dict = detector.specify_parameter(opt_config.LR, opt_config.weight_decay) else: net_param_dict = detector.parameters() optimizer, scheduler, criterion = obtain_optimizer(net_param_dict, opt_config, logger) logger.log('criterion : {:}'.format(criterion)) detector, criterion = detector.cuda(), criterion.cuda() net = torch.nn.DataParallel(detector) last_info = logger.last_info() if last_info.exists(): logger.log("=> loading checkpoint of the last-info '{:}' start".format( last_info)) last_info = torch.load(last_info) start_epoch = last_info['epoch'] + 1 checkpoint = torch.load(last_info['last_checkpoint']) assert last_info['epoch'] == checkpoint[ 'epoch'], 'Last-Info is not right {:} vs {:}'.format( last_info, checkpoint['epoch']) net.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) scheduler.load_state_dict(checkpoint['scheduler']) logger.log("=> load-ok checkpoint '{:}' (epoch {:}) done".format( logger.last_info(), checkpoint['epoch'])) elif args.init_model is not None: last_checkpoint = load_checkpoint(args.init_model) net.load_state_dict(last_checkpoint['detector']) logger.log("=> initialize the detector : {:}".format(args.init_model)) start_epoch = 0 else: logger.log("=> do not find the last-info file : {:}".format(last_info)) start_epoch = 0 if args.eval_once is not None: logger.log("=> only evaluate the model once") #if safex_loader is not None: # safe_results, safe_metas = eval_all(args, [(safex_loader, False)], net, criterion, 'eval-once-train', logger, opt_config, robust_transform) # logger.log('-'*50 + ' evaluate the training set') #import pdb; pdb.set_trace() eval_results, eval_metas = eval_all(args, eval_loaders, net, criterion, 'eval-once', logger, opt_config, robust_transform) all_predictions = [eval_meta.predictions for eval_meta in eval_metas] torch.save( all_predictions, osp.join(args.save_path, '{:}-predictions.pth'.format(args.eval_once))) logger.log('==>> evaluation results : {:}'.format(eval_results)) logger.log('==>> configuration : {:}'.format(model_config)) logger.close() return # Main Training and Evaluation Loop start_time = time.time() epoch_time = AverageMeter() for epoch in range(start_epoch, opt_config.epochs): need_time = convert_secs2time( epoch_time.avg * (opt_config.epochs - epoch), True) epoch_str = 'epoch-{:03d}-{:03d}'.format(epoch, opt_config.epochs) LRs = scheduler.get_lr() logger.log( '\n==>>{:s} [{:s}], [{:s}], LR : [{:.5f} ~ {:.5f}], Config : {:}'. format(time_string(), epoch_str, need_time, min(LRs), max(LRs), opt_config)) # train for one epoch train_loss, train_meta, train_nme = basic_main(args, train_loader, net, criterion, optimizer, epoch_str, logger, opt_config, 'train') scheduler.step() # log the results logger.log( '==>>{:s} Train [{:}] Average Loss = {:.6f}, NME = {:.2f}'.format( time_string(), epoch_str, train_loss, train_nme * 100)) save_path = save_checkpoint( { 'epoch': epoch, 'args': deepcopy(args), 'arch': model_config.arch, 'detector': net.state_dict(), 'state_dict': net.state_dict(), 'scheduler': scheduler.state_dict(), 'optimizer': optimizer.state_dict(), }, logger.path('model') / 'seed-{:}-{:}.pth'.format(args.rand_seed, model_config.arch), logger) last_info = save_checkpoint( { 'epoch': epoch, 'args': deepcopy(args), 'last_checkpoint': save_path, }, logger.last_info(), logger) if (args.eval_freq is None) or (epoch + 1 == opt_config.epochs) or ( epoch % args.eval_freq == 0): if epoch + 1 == opt_config.epochs: _robust_transform = robust_transform else: _robust_transform = None logger.log('') eval_results, eval_metas = eval_all(args, eval_loaders, net, criterion, epoch_str, logger, opt_config, _robust_transform) #save_path = save_checkpoint(eval_metas, logger.path('meta') / '{:}-{:}.pth'.format(model_config.arch, epoch_str), logger) save_path = save_checkpoint( eval_metas, logger.path('meta') / 'seed-{:}-{:}.pth'.format(args.rand_seed, model_config.arch), logger) logger.log( '==>> evaluation results : {:}\n==>> save evaluation results into {:}.' .format(eval_results, save_path)) # measure elapsed time epoch_time.update(time.time() - start_time) start_time = time.time() logger.log('Final checkpoint into {:}'.format(logger.last_info())) logger.close()
def main(args): assert torch.cuda.is_available(), 'CUDA is not available.' torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True torch.set_num_threads(args.workers) print('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed)) prepare_seed(args.rand_seed) temporal_main, eval_all = procedures['{:}-train'.format( args.procedure)], procedures['{:}-test'.format(args.procedure)] logger = prepare_logger(args) # General Data Argumentation normalize, train_transform, eval_transform, robust_transform = prepare_data_augmentation( transforms, args) recover = transforms.ToPILImage(normalize) args.tensor2imageF = recover assert (args.scale_min + args.scale_max) / 2 == 1, 'The scale is not ok : {:} ~ {:}'.format( args.scale_min, args.scale_max) # Model Configure Load model_config = load_configure(args.model_config, logger) sbr_config = load_configure(args.sbr_config, logger) shape = (args.height, args.width) logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format( model_config, args.sigma, shape)) logger.log('--> SBR Configuration : {:}\n'.format(sbr_config)) # Training Dataset train_data = VDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, \ args.data_indicator, sbr_config, transforms.ToPILImage(normalize, 'cv2gray')) train_data.load_list(args.train_lists, args.num_pts, args.boxindicator, args.normalizeL, True) if args.x68to49: assert args.num_pts == 68, 'args.num_pts is not 68 vs. {:}'.format( args.num_pts) if train_data is not None: train_data = convert68to49(train_data) args.num_pts = 49 # define the temporal model (accelerated SBR) net = obtain_pro_temporal(model_config, sbr_config, args.num_pts, args.sigma, args.use_gray) assert model_config.downsample == net.downsample, 'downsample is not correct : {:} vs {:}'.format( model_config.downsample, net.downsample) logger.log("=> network :\n {}".format(net)) logger.log('Training-data : {:}'.format(train_data)) logger.log('arguments : {:}'.format(args)) opt_config = load_configure(args.opt_config, logger) optimizer, scheduler, criterion = obtain_optimizer(net.parameters(), opt_config, logger) logger.log('criterion : {:}'.format(criterion)) net, criterion = net.cuda(), criterion.cuda() net = torch.nn.DataParallel(net) last_info = logger.last_info() try: last_checkpoint = load_checkpoint(args.init_model) checkpoint = remove_module_dict(last_checkpoint['state_dict'], False) net.module.detector.load_state_dict(checkpoint) except: last_checkpoint = load_checkpoint(args.init_model) net.load_state_dict(last_checkpoint['state_dict']) detector = torch.nn.DataParallel(net.module.detector) logger.log("=> initialize the detector : {:}".format(args.init_model)) net.eval() detector.eval() logger.log('SBR Config : {:}'.format(sbr_config)) save_xdir = logger.path('meta') random.seed(111) index_list = list(range(len(train_data))) random.shuffle(index_list) #selected_list = index_list[: min(200, len(index_list))] #selected_list = [7260, 11506, 39952, 75196, 51614, 41061, 37747, 41355] #for iidx, i in enumerate(selected_list): index_list.remove(47875) selected_list = [47875] + index_list save_xdir = logger.path('meta') type_error_1, type_error_2, type_error, misses = 0, 0, 0, 0 type_error_pts, total_pts = 0, 0 for iidx, i in enumerate(selected_list): frames, Fflows, Bflows, targets, masks, normpoints, transthetas, meanthetas, image_index, nopoints, shapes, is_images = train_data[ i] frames, Fflows, Bflows, is_images = frames.unsqueeze( 0), Fflows.unsqueeze(0), Bflows.unsqueeze(0), is_images.unsqueeze( 0) # batch_heatmaps is a list for stage-predictions, each element should be [Batch, Sequence, PTS, H/Down, W/Down] with torch.no_grad(): if args.procedure == 'heatmap': batch_heatmaps, batch_locs, batch_scos, batch_past2now, batch_future2now, batch_FBcheck = net( frames, Fflows, Bflows, is_images) else: batch_locs, batch_past2now, batch_future2now, batch_FBcheck = net( frames, Fflows, Bflows, is_images) (batch_size, frame_length, C, H, W), num_pts, annotate_index = frames.size( ), args.num_pts, train_data.video_L batch_locs = batch_locs.cpu()[:, :, :num_pts] video_mask = masks.unsqueeze(0)[:, :num_pts] batch_past2now = batch_past2now.cpu()[:, :, :num_pts] batch_future2now = batch_future2now.cpu()[:, :, :num_pts] batch_FBcheck = batch_FBcheck[:, :num_pts].cpu() FB_check_oks = FB_communication(criterion, batch_locs, batch_past2now, batch_future2now, batch_FBcheck, video_mask, sbr_config) # locations norm_past_det_locs = torch.cat( (batch_locs[0, annotate_index - 1, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) norm_noww_det_locs = torch.cat( (batch_locs[0, annotate_index, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) norm_next_det_locs = torch.cat( (batch_locs[0, annotate_index + 1, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) norm_next_locs = torch.cat( (batch_past2now[0, annotate_index, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) norm_past_locs = torch.cat( (batch_future2now[0, annotate_index - 1, :num_pts].permute( 1, 0), torch.ones(1, num_pts)), dim=0) transtheta = transthetas[:2, :] norm_past_det_locs = torch.mm(transtheta, norm_past_det_locs) norm_noww_det_locs = torch.mm(transtheta, norm_noww_det_locs) norm_next_det_locs = torch.mm(transtheta, norm_next_det_locs) norm_next_locs = torch.mm(transtheta, norm_next_locs) norm_past_locs = torch.mm(transtheta, norm_past_locs) real_past_det_locs = denormalize_points(shapes.tolist(), norm_past_det_locs) real_noww_det_locs = denormalize_points(shapes.tolist(), norm_noww_det_locs) real_next_det_locs = denormalize_points(shapes.tolist(), norm_next_det_locs) real_next_locs = denormalize_points(shapes.tolist(), norm_next_locs) real_past_locs = denormalize_points(shapes.tolist(), norm_past_locs) gt_noww_points = train_data.labels[image_index.item()].get_points() gt_past_points = train_data.find_index( train_data.datas[image_index.item()][annotate_index - 1]) gt_next_points = train_data.find_index( train_data.datas[image_index.item()][annotate_index + 1]) FB_check_oks = FB_check_oks[:num_pts].squeeze() #import pdb; pdb.set_trace() if FB_check_oks.sum().item() > 2: # type 1 error : detection at both (t) and (t-1) is wrong, while pass the check is_type_1, (T_wrong, T_total) = check_is_1st_error( [real_past_det_locs, real_noww_det_locs, real_next_det_locs], [gt_past_points, gt_noww_points, gt_next_points], FB_check_oks, shapes) # type 2 error : detection at frame t is ok, while tracking are wrong and frame at (t-1) is wrong: spec_index, is_type_2 = check_is_2nd_error( real_noww_det_locs, gt_noww_points, [real_past_locs, real_next_locs], [gt_past_points, gt_next_points], FB_check_oks, shapes) type_error_1 += is_type_1 type_error_2 += is_type_2 type_error += is_type_1 or is_type_2 type_error_pts, total_pts = type_error_pts + T_wrong, total_pts + T_total if is_type_2: RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255) [image_past, image_noww, image_next] = train_data.datas[image_index.item()] crop_box = train_data.labels[ image_index.item()].get_box().tolist() point_index = FB_check_oks.nonzero().squeeze().tolist() colors = [ GREEN if _i in point_index else RED for _i in range(num_pts) ] + [BLUE for _i in range(num_pts)] I_past_det = draw_image_by_points( image_past, torch.cat((real_past_det_locs, gt_past_points[:2]), dim=1), 3, colors, crop_box, (400, 500)) I_noww_det = draw_image_by_points( image_noww, torch.cat((real_noww_det_locs, gt_noww_points[:2]), dim=1), 3, colors, crop_box, (400, 500)) I_next_det = draw_image_by_points( image_next, torch.cat((real_next_det_locs, gt_next_points[:2]), dim=1), 3, colors, crop_box, (400, 500)) I_past = draw_image_by_points( image_past, torch.cat((real_past_locs, gt_past_points[:2]), dim=1), 3, colors, crop_box, (400, 500)) I_next = draw_image_by_points( image_next, torch.cat((real_next_locs, gt_next_points[:2]), dim=1), 3, colors, crop_box, (400, 500)) ### I_past.save(str(save_xdir / '{:05d}-v1-a-pastt.png'.format(i))) I_noww_det.save( str(save_xdir / '{:05d}-v1-b-curre.png'.format(i))) I_next.save(str(save_xdir / '{:05d}-v1-c-nextt.png'.format(i))) I_past_det.save( str(save_xdir / '{:05d}-v1-det-a-past.png'.format(i))) I_noww_det.save( str(save_xdir / '{:05d}-v1-det-b-curr.png'.format(i))) I_next_det.save( str(save_xdir / '{:05d}-v1-det-c-next.png'.format(i))) logger.log('TYPE-ERROR : {:}, landmark-index : {:}'.format( i, spec_index)) else: misses += 1 string = 'Handle {:05d}/{:05d} :: {:05d}'.format( iidx, len(selected_list), i) string += ', error-1 : {:} ({:.2f}%), error-2 : {:} ({:.2f}%)'.format( type_error_1, type_error_1 * 100.0 / (iidx + 1), type_error_2, type_error_2 * 100.0 / (iidx + 1)) string += ', error : {:} ({:.2f}%), miss : {:}'.format( type_error, type_error * 100.0 / (iidx + 1), misses) string += ', final-error : {:05d} / {:05d} = {:.2f}%'.format( type_error_pts, total_pts, type_error_pts * 100.0 / total_pts) logger.log(string)
def main(args=None): if args is None: args = sys.argv[1:] args = parse_args(args) print('--------------Arguments----------------') print('data_type : ', args.data_type) print('learning_rate : ', args.learning_rate) print('validation : ', args.validation) print('epochs : ', args.epochs) print('keep_train : ', args.keep_train) print('pretrain_imagenet : ', args.pretrain_imagenet) print('train_batch_size : ', args.train_batch_size) print('val_batch_size : ', args.val_batch_size) print('dropouts : ', args.dropouts) print('weighted_loss : ', args.weighted_loss) print('---------------------------------------') mean = nml_cfg.mean std = nml_cfg.std # Make snapshot directory tools.directoryMake(path_cfg.snapshot_root_path) train_dir = os.path.join(path_cfg.data_root_path, 'train', args.data_type) train_dir = os.path.join(path_cfg.data_root_path, args.data_type) val_dir = os.path.join(path_cfg.data_root_path, 'val', args.data_type) # Make Train data_loader train_data = ds.ImageFolder( train_dir, transforms.Compose([ transforms.Resize(299), transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), #transforms.RandomVerticalFlip(), transforms.ToTensor(), transforms.Normalize(mean, std) ])) num_of_class = len(os.listdir(train_dir)) train_loader = data.DataLoader(train_data, batch_size=args.train_batch_size, shuffle=True, drop_last=False) # Make Validation data_loader if args.validation: val_data = ds.ImageFolder( val_dir, transforms.Compose( [transforms.ToTensor(), transforms.Normalize(mean, std)])) num_of_val_class = len(os.listdir(val_dir)) val_loader = data.DataLoader(val_data, batch_size=args.val_batch_size, shuffle=False, drop_last=False) print('----------------Data-------------------') print('num_of_class : ', num_of_class) print('num_of_images : ', len(train_data)) print('---------------------------------------\n\n') class_list = train_data.classes # Make Weight weight = make_weight(train_dir, class_list, args.weighted_loss) for model_idx, model_name in enumerate(model_name_list): save_model_name = model_name + '_' + args.data_type CNN_model, CNN_optimizer, CNN_criterion, CNN_scheduler = model_setter( model_name, weight, learning_rate=args.learning_rate, output_size=num_of_class, usePretrained=args.pretrain_imagenet, dropouts=args.dropouts) if args.keep_train: CNN_model = models.load_checkpoint(CNN_model, save_model_name) best_prec = 0 for epoch in range(args.epochs): prec = train(train_loader, CNN_model, CNN_criterion, CNN_optimizer, epoch) if args.validation: prec = val(val_loader, CNN_model, CNN_criterion) # Learning rate scheduler CNN_scheduler.step() # Model weight will be saved based on it's validation performance is_best = prec > best_prec best_prec = max(prec, best_prec) models.save_checkpoint( { 'epoch': epoch + 1, 'state_dict': CNN_model.state_dict(), 'best_prec1': best_prec, }, is_best, save_model_name) print('Best Performance : ', best_prec) print('\n\n\n')