def train(args, config): # load data print("Loading data") train_dataset = data.get_loader(config.train_file, config.batch_size, config.version) dev_dataset = data.get_loader(config.dev_file, config.val_batch_size, config.version) with open(config.dev_eval_file, "r") as fh: dev_eval_file = json.load(fh) print("loading embeddings") with open(config.word_emb_file, "rb") as fh: word_mat = np.array(json.load(fh), dtype=np.float32) with open(config.char_emb_file, "rb") as fh: char_mat = np.array(json.load(fh), dtype=np.float32) # create model print("creating model") if config.model_type == "model6": Model = model_utils.get_model_func(config.model_type, config.version) # get pretrained model from config # takes a pretrained of QANet model_dict_ = torch.load(config.pretrained_model, pickle_module=dill)["model"] model_dict = {} for key in model_dict_: model_dict[key[7:]] = model_dict_[key] from models import QANet pretrained_model = QANet(word_mat, char_mat, config) # load its state model_data = pretrained_model.state_dict() model_data.update(model_dict) pretrained_model.load_state_dict(model_data) model = Model(pretrained_model, config).to(config.device) model = torch.nn.DataParallel(model) else: Model = model_utils.get_model_func(config.model_type, config.version) model = Model(word_mat, char_mat, config).to(config.device) model = torch.nn.DataParallel(model) print("Training Model") trainer = Trainer(model, train_dataset, dev_dataset, dev_eval_file, config) if args.model_file is not None: trainer.load(args.model_file) trainer.ema.resume(trainer.model) trainer.train()
def get_data_loader(config): if config.dataset.type == 'CIFAR10': dataset = data.get_cifar10(config.dataset) elif config.dataset.type == 'ImageNet': dataset = data.get_image_net(config.dataset) else: raise KeyError('invalid dataset type') train_loader, val_loader = data.get_loader(config.dataset, config.dataset.batch_size, config.distributed.enable, *dataset) max_iter = len(train_loader) * config.training.epoch config.lr_scheduler.max_iter = max_iter if config.get('arch_scheduler', None) is not None: config.arch_scheduler.max_iter = max_iter config.arch.start_train = max_iter // 2 config.arch_scheduler.warmup_step = max_iter // 2 return train_loader, val_loader
def main(): parser = argparse.ArgumentParser() parser.add_argument('--name', type=str, help='saved and resumed file name') parser.add_argument('--resume', action='store_true', help='resumed flag') parser.add_argument('--test', dest='test_only', default=False, action='store_true') parser.add_argument('--detctor', default='2019-03-16_10:28:52{}.pth', help='the name of detector') parser.add_argument('--gpu', default='3', help='the chosen gpu id') args = parser.parse_args() os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu cudnn.benchmark = True ########################################## ARGUMENT SETTING ######################################## if args.test_only: args.resume = True if args.resume and not args.name: raise ValueError('Resuming requires file name!') name = args.name if args.name else datetime.now().strftime( "%Y-%m-%d_%H:%M:%S") if args.resume: target_name = name logs = torch.load(target_name) # hacky way to tell the VQA classes that they should use the vocab without passing more params around data.preloaded_vocab = logs['vocab'] else: target_name = os.path.join('logs', '{}'.format(name)) if not args.test_only: print('will save to {}'.format(target_name)) ######################################### DATASET PREPARATION ####################################### if config.train_set == 'train': train_loader = data.get_loader(train=True) val_loader = data.get_loader(val=True) elif args.test_only: val_loader = data.get_loader(test=True) else: train_loader = data.get_loader(train=True, val=True) val_loader = data.get_loader(test=True) ########################################## MODEL PREPARATION ######################################## embedding = bcolz.open(config.glove_path_filtered)[:] net = model.RelAtt(embedding) net = nn.DataParallel(net).cuda() optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad], lr=config.initial_lr, weight_decay=1e-8) # optimizer = optim.RMSprop( # [p for p in net.parameters() if p.requires_grad], # lr=config.initial_lr, # momentum=0.20, # weight_decay=1e-8 # ) scheduler = lr_scheduler.ExponentialLR(optimizer, 0.5**(1 / 50000)) ######################################### ####################################### acc_val_best = 0.0 start_epoch = 0 if args.resume: net.load_state_dict(logs['model_state']) optimizer.load_state_dict(logs['optim_state']) scheduler.load_state_dict(logs['scheduler_state']) start_epoch = logs['epoch'] acc_val_best = logs['acc_val_best'] tracker = utils.Tracker() r = np.zeros(3) for i in range(start_epoch, config.epochs): if not args.test_only: run(net, train_loader, optimizer, scheduler, tracker, train=True, prefix='train', epoch=i) if not (config.train_set == 'train+val' and i in range(config.epochs - 5)): r = run(net, val_loader, optimizer, scheduler, tracker, train=False, prefix='val', epoch=i, has_answers=(config.train_set == 'train')) if not args.test_only: results = { 'epoch': i, 'acc_val_best': acc_val_best, 'name': name, 'model_state': net.state_dict(), 'optim_state': optimizer.state_dict(), 'scheduler_state': scheduler.state_dict(), 'eval': { 'answers': r[0], 'accuracies': r[1], 'idx': r[2] }, 'vocab': val_loader.dataset.vocab, } if config.train_set == 'train' and r[1].mean() > acc_val_best: acc_val_best = r[1].mean() torch.save(results, target_name + '.pth') if config.train_set == 'train+val': torch.save(results, target_name + '{}.pth') if i in range(config.epochs - 5, config.epochs): saved_for_test(val_loader, r, i) else: saved_for_test(val_loader, r) break
parser.add_argument('--trainsize', type=int, default=352, help='input size') parser.add_argument('--trainset', type=str, default='DUTS-TRAIN', help='training dataset') opt = parser.parse_args() # data preparing, set your own data path here data_path = 'C:\\Users\\RAZER\\Desktop\\SCRN-master\\F-360iSOD' image_root = data_path + '/stimulis/' gt_root = data_path + '/objects/' train_loader = get_loader(image_root, gt_root, batchsize=opt.batchsize, trainsize=opt.trainsize) total_step = len(train_loader) # build models model = SCRN() model.cuda() params = model.parameters() optimizer = torch.optim.SGD(params, opt.lr, momentum=0.9, weight_decay=5e-4) scheduler = lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1) CE = torch.nn.BCEWithLogitsLoss() size_rates = [0.75, 1, 1.25] # multi-scale training
def main(): parser = argparse.ArgumentParser() parser.add_argument('--name', type=str, help='saved and resumed file name') parser.add_argument('--resume', action='store_true', help='resumed flag') parser.add_argument('--test', dest='test_only', action='store_true') parser.add_argument( '--lambd', default=1, type=float, help='trade-off hyperparameters between two types of losses') parser.add_argument('--gpu', default='0', help='the chosen gpu id') global args args = parser.parse_args() os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu cudnn.benchmark = True ########################################## ARGUMENT SETTING ############################### if args.test_only: args.resume = True if args.resume and not args.name: raise ValueError('Resuming requires file name!') name = args.name if args.name else datetime.now().strftime( "%Y-%m-%d_%H:%M:%S") if args.resume: target_name = name logs = torch.load(target_name) else: target_name = os.path.join('logs', '{}'.format(name)) if not args.test_only: print('will save to {}'.format(target_name)) ######################################### DATASET PREPARATION ############################### if config.train_set == 'train': train_loader = data.get_loader(train=True) val_loader = data.get_loader(val=True) elif args.test_only: val_loader = data.get_loader(test=True) else: train_loader = data.get_loader(train=True, val=True) val_loader = data.get_loader(test=True) # load pre-trained word embedding (glove) for embedding answers vocabs = val_loader.dataset.vocab answer_vocab = vocabs['answer'] embedding, _, _ = word2vec.filter_glove_embedding(answer_vocab) embedding = nn.Embedding.from_pretrained(embedding) answer_idx_vocab = vocabs['answer_idx'] answer_idx_vocab = {int(a_idx): a for a_idx, a in answer_idx_vocab.items()} ########################################## MODEL PREPARATION ################################# net = model.Net(val_loader.dataset._num_tokens) net = nn.DataParallel(net).cuda() optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad], lr=config.initial_lr) scheduler = lr_scheduler.StepLR(optimizer, step_size=50000, gamma=0.4) acc_val_best = 0.0 start_epoch = 0 if args.resume: net.load_state_dict(logs['model_state']) optimizer.load_state_dict(logs['optim_state']) scheduler.load_state_dict(logs['scheduler_state']) start_epoch = logs['epoch'] acc_val_best = logs['acc_val_best'] tracker = utils.Tracker() r = np.zeros(3) result_dict = {} for i in range(start_epoch, config.epochs): if not args.test_only: run(net, train_loader, optimizer, scheduler, tracker, train=True, prefix='train', embedding=embedding, epoch=i) if not (config.train_set == 'train+val' and i in range(config.epochs - 5)): r = run(net, val_loader, optimizer, scheduler, tracker, train=False, prefix='val', epoch=i, embedding=embedding, has_answers=(config.train_set == 'train'), answer_idx_vocab=answer_idx_vocab) if not args.test_only: results = { 'epoch': i, 'name': name, 'model_state': net.state_dict(), 'optim_state': optimizer.state_dict(), 'scheduler_state': scheduler.state_dict(), 'eval': { 'answers': r[0], 'accuracies': r[1], }, } result_dict[i] = r[2] if config.train_set == 'train' and r[1].mean() > acc_val_best: acc_val_best = r[1].mean() results['acc_val_best'] = acc_val_best torch.save(results, target_name + '.pth') if config.train_set == 'train+val': torch.save(results, target_name + '.pth') if i in range(config.epochs - 5, config.epochs): saved_for_test(val_loader, r, i) torch.save(results, target_name + '{}.pth'.format(i)) else: saved_for_test(val_loader, r) break if config.train_set == 'train': with open('./results.json', 'w') as fd: json.dump(result_dict, fd)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--name', type=str, help='saved and resumed file name') parser.add_argument('--resume', action='store_true', help='resumed flag') parser.add_argument('--gpu', default='0', help='the chosen gpu id') args = parser.parse_args() os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu cudnn.benchmark = True ########################################## ARGUMENT SETTING ################################# if args.resume and not args.name: raise ValueError('Resuming requires file name!') name = args.name if args.name else datetime.now().strftime( "%Y-%m-%d_%H:%M:%S") if args.resume: target_name = name logs = torch.load(target_name) else: target_name = os.path.join('logs', '{}'.format(name)) print('will save to {}'.format(target_name)) ######################################### DATASET PREPARATION ################################# with open(config.meta_data_path, 'r') as fd: meta_data = json.load(fd) train_loader = data.get_loader('train', meta_data) if config.train_set == 'train': val_loader = data.get_loader('val', meta_data) if config.train_set == 'train+val': val_loader = data.get_loader('test', meta_data) ########################################## MODEL PREPARATION ################################## embeddings = bcolz.open(config.glove_path_filtered)[:] net = model.Net(embeddings).cuda() loss = nn.CrossEntropyLoss() optimizer = optim.Adam( [p for p in net.parameters() if p.requires_grad], lr=config.initial_lr, ) start_epoch = 0 recall_10_val_best = 0.0 if args.resume: net.load_state_dict(logs['model_state']) optimizer.load_state_dict(logs['optim_state']) start_epoch = logs['epoch'] recall_10_val_best = logs['recall_10_val_best'] tracker = utils.Tracker() best_epoch = start_epoch state = 'Valid' if config.train_set == 'train' else 'Test' for i in range(start_epoch, config.epochs): run(net, train_loader, tracker, optimizer, loss_criterion=loss, train=True, prefix='train', epoch=i) results = { 'epoch': i, 'name': name, 'model_state': net.state_dict(), 'optim_state': optimizer.state_dict(), } if not config.train_set == 'all': r = run(net, val_loader, tracker, optimizer, loss_criterion=loss, train=False, prefix='val', epoch=i) print("{} epoch {}: recall@1 is {:.4f}".format(state, i, r[0]), end=", ") print("recall@5 is {:.4f}, recall@10 is {:.4f}".format(r[1], r[2])) if r[2] > recall_10_val_best: recall_10_val_best = r[2] results['recall_10_val_best'] = recall_10_val_best best_epoch = i recall_1_val_best = r[0] recall_5_val_best = r[1] torch.save(results, target_name + '.pth') if not config.train_set == 'all': print("The best performance of {} is on epoch {}".format( state, best_epoch), end=": ") print("recall@1 is {:.4f}, recall@5 is {:.4f}, recall@10 is {:.4f}". format(recall_1_val_best, recall_5_val_best, recall_10_val_best)) else: torch.save(results, target_name + '.pth')
depth_root = trainfolder[trainset]["depth_root"] anno = trainfolder[trainset]["anno"] image_path = os.path.join(data_root, trainset, image_root) gt_path = os.path.join(data_root, trainset, gt_root) depth_path = os.path.join(data_root, trainset, depth_root) if anno: anno_path = os.path.join(data_root, trainset, anno) else: anno_path = None image_paths += [image_path] depth_paths += [depth_path] gt_paths += [gt_path] anno_paths += [anno_path] train_loader = get_loader(image_paths, gt_paths, depth_paths, anno_paths, batchsize=opt.batchsize, trainsize=opt.trainsize) total_step = len(train_loader) # build models model = EFNet().cuda() params = model.parameters() optimizer = torch.optim.SGD(params, opt.lr, momentum=0.9, weight_decay=5e-4) scheduler = lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1) CE = torch.nn.BCEWithLogitsLoss() size_rates = [0.75, 1, 1.25] # multi-scale training # training for epoch in range(0, opt.epoch): scheduler.step()
if opt.load is not None: model.load_state_dict(torch.load(opt.load)) print('load model from ', opt.load) optimizer = torch.optim.Adam(model.parameters(), opt.lr) save_path = opt.save_path if not os.path.exists(save_path): os.makedirs(save_path) # load data print('load data...') train_loader = get_loader(image_root=opt.train_root + 'images/', gt_root=opt.train_root + 'masks/', batchsize=opt.batchsize, trainsize=opt.trainsize, num_workers=8) val_loader = test_dataset(image_root=opt.val_root + 'images/', gt_root=opt.val_root + 'masks/', testsize=opt.trainsize) total_step = len(train_loader) # logging logging.basicConfig( filename=save_path + 'log.log', format='[%(asctime)s-%(filename)s-%(levelname)s:%(message)s]', level=logging.INFO, filemode='a', datefmt='%Y-%m-%d %I:%M:%S %p') logging.info("Network-Train")