def run(): # Load configuration args = load_config() logger.add(os.path.join('logs', '{}.log'.format(args.dataset)), rotation="500 MB", level="INFO") logger.info(args) # Set seed random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) np.random.seed(args.seed) # Load dataset train_data, _, query_data, query_targets, retrieval_data, retrieval_targets = load_data(args.dataset, args.root) # Training for code_length in args.code_length: checkpoint = sh.train( train_data, query_data, query_targets, retrieval_data, retrieval_targets, code_length, args.device, args.topk, ) logger.info('[code_length:{}][map:{:.4f}]'.format(code_length, checkpoint['map'])) torch.save(checkpoint, 'checkpoints/{}_code_{}_map_{:.4f}.pt'.format(args.dataset, code_length, checkpoint['map']))
def run(): # Load configuration args = load_config() logger.add('logs/{}.log'.format(args.dataset), rotation='500 MB', level='INFO') logger.info(args) random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) np.random.seed(args.seed) # Load dataset _, _, query_data, query_targets, retrieval_data, retrieval_targets = load_data(args.dataset, args.root) # Training for code_length in args.code_length: checkpoint = lsh.train( query_data, query_targets, retrieval_data, retrieval_targets, code_length, args.device, args.topk, ) logger.info('[code length:{}][map:{:.4f}]'.format(code_length, checkpoint['map']))
def create_eval_loaders(options, eval_type, keyframes, total_batch_size=8, trajectory=''): """ create the evaluation loader at different keyframes set-up """ eval_loaders = {} if trajectory == '': trajectories = eval_trajectories(options.dataset) else: trajectories = [trajectory] for trajectory in trajectories: for kf in keyframes: np_loader = load_data(options.dataset, [kf], eval_type, trajectory) eval_loaders['{:}_keyframe_{:}'.format( trajectory, kf)] = data.DataLoader(np_loader, batch_size=int(total_batch_size), shuffle=False, num_workers=options.cpu_workers) return eval_loaders
def run_dpsh(opt): """运行DLFH算法 Parameters opt: parser 程序运行参数 Returns None """ # 加载数据 query_dataloader, train_dataloader, database_dataloader = dataloader.load_data( opt) logger.info(opt) # DLFH算法 DPSH.dpsh( opt, train_dataloader, query_dataloader, database_dataloader, )
parameters["save final"] = args.save_final parameters["split threshold"] = args.split_threshold parameters["margin loss"] = args.margin_loss parameters["hallucination_epoch"] = args.hallucination_epoch parameters["data root"] = config['data_root'] parameters["sampler"] = training_opt['sampler'] if not os.path.isdir(training_opt['log_dir']): os.makedirs(training_opt['log_dir']) if not test_mode: data = { x: dataloader.load_data(data_root=config['data_root'], dataset=dataset, phase=x, batch_size=args.batch_size, use_sampler=parameters["sampler"], num_workers=training_opt['num_workers'], gamma=args.gamma) for x in ['train', 'val', 'test'] } training_model = model(config, data, parameters=parameters, test=False) training_model.train() else: warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) print( 'Under testing phase, we load training data simply to calculate training data number for each class.' ) data = {
if k not in ['type', 'def_file']} } else: sampler_dic = None # generated sub-datasets all have test split splits = ['train', 'val'] if dataset not in ['iNaturalist18', 'ImageNet']: splits.append('test') data = { x: dataloader.load_data( data_root=data_root[dataset.rstrip('_LT')], dataset=dataset, phase=x, batch_size=training_opt['batch_size'], sampler_dic=sampler_dic, num_workers=training_opt['num_workers'], top_k_class=training_opt['top_k'] if 'top_k' in training_opt else None, cifar_imb_ratio=training_opt['cifar_imb_ratio'] if 'cifar_imb_ratio' in training_opt else None, ) for x in splits } training_model = model(config, data, test=False) training_model.train() # ============================================================================ # TESTING else: warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data",
if not test_mode: sampler_defs = training_opt['sampler'] if sampler_defs: sampler_dic = { 'sampler': source_import(sampler_defs['def_file']).get_sampler(), 'num_samples_cls': sampler_defs['num_samples_cls'] } else: sampler_dic = None data = { x: dataloader.load_data(data_root=data_root[dataset.rstrip('_LT')], dataset=dataset, phase=x, batch_size=training_opt['batch_size'], sampler_dic=sampler_dic, num_workers=training_opt['num_workers']) for x in (['train', 'val', 'train_plain'] if relatin_opt['init_centroids'] else ['train', 'val']) } training_model = model(config, data, test=False) training_model.train() else: warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning)
default=5000, type=int, help='Compute map of top k (default: 5000)') parser.add_argument('--evaluate-freq', default=1, type=int, help='Frequency of evaluate (default: 1)') return parser.parse_args() if __name__ == '__main__': opt = load_parse() if opt.gpu == -1: opt.device = torch.device("cpu") else: opt.device = torch.device("cuda:%d" % opt.gpu) # Load data query_dataloader, train_dataloader, database_dataloader = load_data(opt) # onehot targets if opt.dataset == 'cifar10': query_targets = torch.FloatTensor( encode_onehot(query_dataloader.dataset.targets)).to(opt.device) train_targets = torch.FloatTensor( encode_onehot(train_dataloader.dataset.targets)).to(opt.device) database_targets = torch.FloatTensor( encode_onehot(database_dataloader.dataset.targets)).to(opt.device) train(opt, query_dataloader, train_dataloader, database_dataloader, query_targets, train_targets, database_targets)
if k not in ['type', 'def_file']} } else: sampler_dic = None # generated sub-datasets all have test split splits = ['train', 'val'] if dataset not in ['iNaturalist18', 'ImageNet']: splits.append('test') data = { x: dataloader.load_data(data_root=data_root, dataset=dataset, phase=x, batch_size=training_opt['batch_size'], sampler_dic=sampler_dic, num_workers=training_opt['num_workers'], top_k_class=training_opt['top_k'] if 'top_k' in training_opt else None, cifar_imb_ratio=training_opt['cifar_imb_ratio'] if 'cifar_imb_ratio' in training_opt else None, reverse=args.train_reverse) for x in splits } training_model = model(config, data, test=False) training_model.train() # ============================================================================ # TESTING else: warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data",
'num_samples_cls': 4, 'type': 'ClassAwareSampler' } sampler_dic_ldam = { 'sampler': source_import(sampler_defs['def_file']).get_sampler(), 'params': { 'num_samples_cls': sampler_defs['num_samples_cls'] } } data = { x: dataloader.load_data( data_root=data_root[dataset.rstrip('_LT')], dataset=dataset, phase=x, batch_size=training_opt['batch_size'], sampler_dic=sampler_dic if x != 'train_drw' else sampler_dic_ldam, num_workers=training_opt['num_workers'], cifar_imb_ratio=training_opt['cifar_imb_ratio'] if 'cifar_imb_ratio' in training_opt else None) for x in (phase_bank) } # if relatin_opt['init_centroids'] else ['train', 'val'])} lbs = data['train'].dataset.labels counts = [] for i in range(len(np.unique(lbs))): counts.append(lbs.count(i)) config['label_counts'] = counts counts = pd.DataFrame(counts) #tail classes
def run_dsdh(opt): """Run DSDH algorithm Parameters opt: parser Configuration Returns None """ # Load data query_dataloader, train_dataloader, database_dataloader = dataloader.load_data( opt) # onehot targets if opt.dataset == 'cifar10': query_targets = torch.FloatTensor( encode_onehot(query_dataloader.dataset.targets)).to(opt.device) train_targets = torch.FloatTensor( encode_onehot(train_dataloader.dataset.targets)).to(opt.device) database_targets = torch.FloatTensor( encode_onehot(database_dataloader.dataset.targets)).to(opt.device) elif opt.dataset == 'nus-wide': query_targets = torch.FloatTensor(query_dataloader.dataset.targets).to( opt.device) train_targets = torch.FloatTensor(train_dataloader.dataset.targets).to( opt.device) database_targets = torch.FloatTensor( database_dataloader.dataset.targets).to(opt.device) cl = [12, 24, 32, 48] for c in cl: opt.code_length = c # DSDH algorithm logger.info(opt) best_model = DSDH.dsdh( train_dataloader, query_dataloader, train_targets, query_targets, opt.code_length, opt.max_iter, opt.dcc_iter, opt.mu, opt.nu, opt.eta, opt.model, opt.multi_gpu, opt.device, opt.lr, opt.evaluate_freq, opt.topk, ) # Evaluate whole dataset model = torch.load(os.path.join('result', best_model)) final_map = evaluate( model, query_dataloader, database_dataloader, query_targets, database_targets, opt.code_length, opt.device, opt.topk, ) logger.info('final_map: {:.4f}'.format(final_map))
def train(): # Load data print('Loading data ...') start_time = time.time() q1_train, q2_train, y_train, q1_dev, q2_dev, y_dev, vocab_size = load_data( data_file=args.train_files, dev_sample_percentage=args.dev_sample_percentage, vocab_path=os.path.join(args.save_dir, "vocab")) time_dif = get_time_dif(start_time) print('Time usage:', time_dif) print('Configuring TensorBoard and Saver ...') tensorboard_dir = args.tensorboard_dir if not os.path.exists(tensorboard_dir): os.makedirs(tensorboard_dir) # MVLSTM model init model = MVLSTM(sequence_length=args.max_q_len, num_classes=args.num_classes, embedding_dim=args.embedding_dim, vocab_size=vocab_size, max_length=args.max_q_len, hidden_dim=args.hidden_size, learning_rate=args.learning_rate) tf.summary.scalar('loss', model.loss) tf.summary.scalar('accuracy', model.accuracy) merged_summary = tf.summary.merge_all() writer = tf.summary.FileWriter(tensorboard_dir) # Configuring Saver saver = tf.train.Saver() if not os.path.exists(args.save_dir): os.makedirs(args.save_dir) # Create Session session = tf.Session() session.run(tf.global_variables_initializer()) writer.add_graph(session.graph) print('Training and Deviation ...') start_time = time.time() total_batch = 0 best_acc_dev = 0.0 last_improved = 0 require_improvement = 30000 # Early stopping tag = False for epoch in range(args.epochs): print('Epoch:', epoch + 1) batch_train = batch_iter_per_epoch(q1_train, q2_train, y_train, args.batch_size) for q1_batch, q2_batch, y_batch in batch_train: feed_dict = feed_data(q1_batch, q2_batch, y_batch, args.dropout_keep_prob, model=model) if total_batch % args.checkpoint_every == 0: # write to tensorboard scalar summary = session.run(merged_summary, feed_dict) writer.add_summary(summary, total_batch) if total_batch % args.evaluate_every == 0: # print performance on train set and dev set feed_dict[model.dropout_keep_prob] = 1.0 loss_train, acc_train = session.run( [model.loss, model.accuracy], feed_dict=feed_dict) loss_dev, acc_dev = evaluate(q1_dev, q2_dev, y_dev, session, model=model) if acc_dev > best_acc_dev: # save best result best_acc_dev = acc_dev last_improved = total_batch saver.save(sess=session, save_path=save_path) improved_str = '*' else: improved_str = '' time_dif = get_time_dif(start_time) print( 'Iter: {0:>6}, Train Loss: {1:>6.2}, Train Acc: {2:7.2%}, Val Loss: {3:>6.2}, Val Acc:' '{4:>7.2%}, Time:{5}{6}'.format(total_batch, loss_train, acc_train, loss_dev, acc_dev, time_dif, improved_str)) session.run(model.optim, feed_dict) total_batch += 1 if total_batch - last_improved > require_improvement: # having no improvement for a long time print('No optimization for a long time, auto-stopping ...') tag = True break if tag: # early stopping break
def train(options): if options.time: timers = Timers() else: timers = None total_batch_size = options.batch_per_gpu * torch.cuda.device_count() checkpoint = train_utils.load_checkpoint_train(options) keyframes = [int(x) for x in options.keyframes.split(',')] train_loader = load_data(options.dataset, keyframes, load_type = 'train') train_loader = data.DataLoader(train_loader, batch_size = total_batch_size, shuffle = True, num_workers = options.cpu_workers) if options.dataset in ['BundleFusion', 'TUM_RGBD']: obj_has_mask = False else: obj_has_mask = True eval_loaders = create_train_eval_loaders(options, 'validation', keyframes, total_batch_size) logfile_name = '_'.join([ options.prefix, # the current test version options.network, options.encoder_name, options.mestimator, options.solver, 'lr', str(options.lr), 'batch', str(total_batch_size), 'kf', options.keyframes]) print("Initialize and train the Deep Trust Region Network") net = ICtracking.LeastSquareTracking( encoder_name = options.encoder_name, max_iter_per_pyr= options.max_iter_per_pyr, mEst_type = options.mestimator, solver_type = options.solver, tr_samples = options.tr_samples, no_weight_sharing = options.no_weight_sharing, timers = timers) if options.no_weight_sharing: logfile_name += '_no_weight_sharing' logger = train_utils.initialize_logger(options, logfile_name) if options.checkpoint: net.load_state_dict(checkpoint['state_dict']) if torch.cuda.is_available(): net.cuda() net.train() if torch.cuda.device_count() > 1: print("Use", torch.cuda.device_count(), "GPUs for training!") # dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs net = nn.DataParallel(net) train_objective = ['EPE3D'] # Note: we don't use RPE for training eval_objectives = ['EPE3D', 'RPE'] num_params = train_utils.count_parameters(net) if num_params < 1: print('There is no learnable parameters in this baseline.') print('No training. Only one iteration of evaluation') no_training = True else: print('There is a total of {:} learnabled parameters'.format(num_params)) no_training = False optim = train_utils.create_optim(options, net) scheduler = torch.optim.lr_scheduler.MultiStepLR(optim, milestones=options.lr_decay_epochs, gamma=options.lr_decay_ratio) freq = options.save_checkpoint_freq for epoch in range(options.start_epoch, options.epochs): if epoch % freq == 0: checkpoint_name = 'checkpoint_epoch{:d}.pth.tar'.format(epoch) print('save {:}'.format(checkpoint_name)) state_info = {'epoch': epoch, 'num_param': num_params} logger.save_checkpoint(net, state_info, filename=checkpoint_name) if options.no_val is False: for k, loader in eval_loaders.items(): eval_name = '{:}_{:}'.format(options.dataset, k) eval_info = eval_utils.evaluate_trust_region( loader, net, eval_objectives, known_mask = obj_has_mask, eval_name = eval_name, timers = timers) display_dict = {"{:}_epe3d".format(eval_name): eval_info['epes'].mean(), "{:}_rpe_angular".format(eval_name): eval_info['angular_error'].mean(), "{:}_rpe_translation".format(eval_name): eval_info['translation_error'].mean()} logger.write_to_tensorboard(display_dict, epoch) if no_training: break train_one_epoch(options, train_loader, net, optim, epoch, logger, train_objective, known_mask=obj_has_mask, timers=timers) scheduler.step()
def run(): # Load configuration args = load_config() logger.add('logs/{}_beta_{}_lamda_{}.log'.format(args.dataset, args.beta, args.lamda), rotation='500 MB', level='INFO') logger.info(args) random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) np.random.seed(args.seed) # Load dataset train_data, train_targets, query_data, query_targets, retrieval_data, retrieval_targets = load_data( args.dataset, args.root) # Training for code_length in args.code_length: checkpoint = lfh.train( train_data, train_targets, query_data, query_targets, retrieval_data, retrieval_targets, code_length, args.num_samples, args.max_iter, args.beta, args.lamda, args.device, args.topk, ) logger.info('[code length:{}][map:{:.4f}]'.format( code_length, checkpoint['map'])) torch.save( checkpoint, 'checkpoints/{}_code_{}_beta_{}_lamda_{}_map_{:.4f}.pt'.format( args.dataset, code_length, args.beta, args.lamda, checkpoint['map']))
args = parser.parse_args() test_mode = args.test test_open = args.test_open if test_open: test_mode = True output_logits = args.output_logits config = source_import(args.config).config training_opt = config['training_opt'] # change relatin_opt = config['memory'] dataset = training_opt['dataset'] data_loader = dataloader.load_data(data_root=data_root[dataset.rstrip('_LT')], dataset=dataset, phase='val', batch_size=1, num_workers=training_opt['num_workers']) baseline_model = model(config, data_loader, test=False) baseline_model.load_model() for model in baseline_model.networks.values(): model.eval() cls_weight = baseline_model.networks['classifier'].module.fc.weight baseline_model.networks['classifier'].module.fc.bias cls_weight = cls_weight.norm(dim=1).tolist() df = pd.read_csv("./analysis/classifier_weight_norm.csv") df[args.col] = cls_weight df.to_csv("./analysis/classifier_weight_norm.csv", index=False)
def run_hcoh(args): """Run HCOH algorithm Parameters args: parser Configuration Returns None """ # Load dataset train_data, train_targets, query_data, query_targets, database_data, database_targets = dataloader.load_data(args) # Preprocess dataset # Normalization train_data = normalization(train_data) query_data = normalization(query_data) database_data = normalization(database_data) # One-hot query_targets = encode_onehot(query_targets, 10) database_targets = encode_onehot(database_targets, 10) # Convert to Tensor train_data = torch.from_numpy(train_data).float().to(args.device) query_data = torch.from_numpy(query_data).float().to(args.device) database_data = torch.from_numpy(database_data).float().to(args.device) train_targets = torch.from_numpy(train_targets).squeeze().to(args.device) query_targets = torch.from_numpy(query_targets).to(args.device) database_targets = torch.from_numpy(database_targets).to(args.device) # HCOH algorithm for code_length in [8, 16, 32, 64, 128]: args.code_length = code_length mAP = 0.0 precision = 0.0 for i in range(10): m, p = HCOH.hcoh( train_data, train_targets, query_data, query_targets, database_data, database_targets, args.code_length, args.lr, args.num_hadamard, args.device, args.topk, ) mAP += m precision += p logger.info('[code_length:{}][map:{:.3f}][precision:{:.3f}]'.format(code_length, mAP / 10, precision / 10))
if __name__ == '__main__': net = models.__dict__['resnet18'](pretrained=True).cuda() net = net.cuda() criterion = nn.CrossEntropyLoss().cuda() optimizer = optim.SGD(net.parameters(), lr=LR, momentum=momentum, weight_decay=weight_decay) cudnn.benchmark = True # data loading code for epoch in range(init_epoch, num_epoch): train_loader, test_loader = load_data(data_path=data_path, batch_size=batch_size, nb_workers=n_workers) print('\nEpoch: %d' % (epoch + 1)) net.train() s1 = time.time() for i, data in enumerate(train_loader): inputs, labels = data inputs, labels = inputs.cuda(), labels.cuda() optimizer.zero_grad() # forward + backward outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step()
def run(): # Load configuration args = load_config() logger.add( 'logs/{}_code_{}_anchor_{}_lamda_{}_nu_{}_sigma_{}_topk_{}.log'.format( args.dataset, '_'.join([str(code_length) for code_length in args.code_length]), args.num_anchor, args.lamda, args.nu, args.sigma, args.topk, ), rotation='500 MB', level='INFO', ) logger.info(args) # Set seed random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) np.random.seed(args.seed) # Load data train_data, train_targets, query_data, query_targets, retrieval_data, retrieval_targets = load_data( args.dataset, args.root) # Training for code_length in args.code_length: checkpoint = sdh.train( train_data, train_targets, query_data, query_targets, retrieval_data, retrieval_targets, code_length, args.num_anchor, args.max_iter, args.lamda, args.nu, args.sigma, args.device, args.topk, ) logger.info('[code length:{}][map:{:.4f}]'.format( code_length, checkpoint['map'])) # Save checkpoint torch.save( checkpoint, 'checkpoints/{}_code_{}_anchor_{}_lamda_{}_nu_{}_sigma_{}_topk_{}_map_{:.4f}.pt' .format( args.dataset, code_length, args.num_anchor, args.lamda, args.nu, args.sigma, args.topk, checkpoint['map'], ))
sal = sal.resize((224, 224), resample=Image.LINEAR) plt.imshow(transform_forshow(image)) plt.imshow(np.array(sal), alpha=0.4, cmap='jet') plt.savefig('test1.jpg') if not test_mode: sampler_defs = training_opt['sampler'] if sampler_defs: sampler_dic = {'sampler': source_import(sampler_defs['def_file']).get_sampler(), 'num_samples_cls': sampler_defs['num_samples_cls']} else: sampler_dic = None data = {x: dataloader.load_data(data_root=data_root[dataset.rstrip('_LT')], dataset=dataset, phase=x, batch_size=128, sampler_dic=sampler_dic, num_workers=training_opt['num_workers'], shuffle=False) for x in ['train', 'val']} baseline_model = model(config, data, test=False) baseline_model.load_model(baseline_path) feature_b = nn.Sequential(*list(baseline_model.networks['feat_model'].module.children())[:-1]) avgpool = [list(baseline_model.networks['feat_model'].module.children())[-1],Flatten()] classifier_b = nn.Sequential(*(avgpool+list(baseline_model.networks['classifier'].module.children()))) mixup_model = model(config, data, test=False) mixup_model.load_model(mixup_only_path) feature_m = nn.Sequential(*list(mixup_model.networks['feat_model'].module.children())[:-1]) avgpool_m = [list(mixup_model.networks['feat_model'].module.children())[-1],Flatten()] classifier_m = nn.Sequential(*(avgpool_m+list(mixup_model.networks['classifier'].module.children())))
'params': { 'meta_learner': learner, 'batch_size': training_opt['batch_size'] } } else: sampler_dic = None splits = ['train', 'train_plain', 'val'] if dataset not in ['iNaturalist18', 'ImageNet']: splits.append('test') data = { x: dataloader.load_data(data_root=data_root[dataset.rstrip('_LT')], dataset=dataset, phase=split2phase(x), batch_size=training_opt['batch_size'], sampler_dic=sampler_dic, num_workers=training_opt['num_workers'], cifar_imb_ratio=training_opt['cifar_imb_ratio'] if 'cifar_imb_ratio' in training_opt else None) for x in splits } if sampler_defs and sampler_defs[ 'type'] == 'MetaSampler': # todo: use meta-sampler cbs_file = './data/ClassAwareSampler.py' cbs_sampler_dic = { 'sampler': source_import(cbs_file).get_sampler(), 'params': { 'is_infinite': True } }
import torch import torch.nn as nn import torchvision import torchvision.transforms as transforms import torch.optim as optim import os from data.dataloader import load_data """ LOAD CIFAR100 """ trainloader, testloader = load_data() """ Define a Loss function """ criterion = nn.CrossEntropyLoss() """ Training on GPU """ net = resnet18() #For retraining, load the previously trained model # PATH = "./models/trained" # net = torch.load(os.path.join(PATH, "resnet18.pth"))