def main(_): parser = argparse.ArgumentParser( description='Classification model training') parser.add_argument('--config_file', type=str, default=None, help='Optional config file for params') parser.add_argument('opts', help='see config.py for all options', default=None, nargs=argparse.REMAINDER) args = parser.parse_args() if args.config_file is not None: cfg_from_file(args.config_file) if args.opts is not None: cfg_from_list(args.opts) assert_and_infer_cfg() print_cfg() os.environ["CUDA_VISIBLE_DEVICES"] = str(cfg.GPU_ID) logger = utils.setup_custom_logger('root') tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR) tf_config = tf.ConfigProto(device_count=dict( GPU=1), gpu_options=tf.GPUOptions(allow_growth=True)) tf.enable_resource_variables() train(tf_config, logger) test(tf_config, logger)
def main(): global args args = parser.parse_args() if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) files = os.listdir(args.model_dir) cp_files = [f for f in files if f.endswith('.pth.tar')] if args.file_ptn is not None: ptn = re.compile(args.file_ptn) cp_files = [f for f in files if ptn.search(f)] model_info = [] for cp_file in cp_files: file_name = cp_file.rsplit('.', 2)[0] model_group_name, model_name, _ = file_name.split('-') cp_path = os.path.join(args.model_dir, cp_file) model_info.append((model_group_name, model_name, cp_path)) att_query = AttQuery(model_info, args.split, args.model_dir) visualizer = Visualizer() while True: att_query.print_query() command = input('input command: ') if ' ' in command: opt, arg = command.split(' ', 1) else: opt, arg = command, None if opt in ('q', 'question'): att_query.set_question(arg) elif opt in ('a', 'answer'): att_query.set_answer(arg) elif opt in ('c', 'condition'): att_query.set_condition(arg) elif opt in ('x', 'clean'): att_query.set_question(None) att_query.set_answer(None) att_query.set_condition(None) elif opt in ('s', 'save'): if arg is None: inds = range(att_query.get_res_cnt()) else: inds = map(int, arg.split(',')) att_query.save(inds) elif opt in ('r', 'run'): if arg is None: arg = 1 result = att_query.run(int(arg)) visualizer.visualize(result, att_query.model_info) elif opt in ('e', 'exit'): break else: print('wrong command !')
def main(): global args args = parser.parse_args() args_str = json.dumps(vars(args), indent=2) print('[Info] called with: ' + args_str) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) # checkpoint directory cfg.LOG_DIR = os.path.join(cfg.LOG_DIR, args.checkpoint) # select device torch.cuda.set_device(args.gpu_id) print('[Info] use gpu: {}'.format(torch.cuda.current_device())) # data print('[Info] init dataset') model_group_name, model_name = args.model.split('/') val_set = VQADataset('test', model_group_name) val_loader = torch.utils.data.DataLoader(val_set, batch_size=args.bs, shuffle=False, num_workers=args.workers, pin_memory=True) print('sample count: {}'.format(len(val_set))) # model print('[Info] construct model') model_group = import_module('models.' + model_group_name) model = getattr(model_group, model_name)(num_words=val_set.num_words, num_ans=val_set.num_ans, emb_size=get_emb_size()) model.cuda() cudnn.benchmark = True print('[Info] model name: ' + args.model) # predict fnames = [(i, 'checkpoint-{:03}.pth.tar'.format(i)) for i in range(args.start_epoch, args.end_epoch, args.epoch_freq) ] cp_files = [(i, os.path.join(cfg.LOG_DIR, fname)) for i, fname in fnames] for epoch, cp_file in cp_files: if os.path.isfile(cp_file): print("[Info] loading checkpoint '{}'".format(cp_file)) checkpoint = torch.load(cp_file) model.load_state_dict(checkpoint['state_dict']) else: print("[Info] no checkpoint found at '{}'".format(cp_file)) continue results = predict(val_loader, model) result_file = os.path.join(cfg.LOG_DIR, 'result-{:03}.json'.format(epoch)) json.dump(results, open(result_file, 'w'))
net.load(DEFAULT_WEIGHTS) solver = Solver(net) toc = time.clock() print('Time to load model: ' + str(toc - tic)) tic = time.clock() path = './test/' dirs = sorted(os.listdir(path)) time_ims = [] for i in dirs: print(i) time_ims.append(load_demo_images(path + i + '/')) # Run the network voxel_prediction, _ = solver.test_output(np.array(time_ims)) pred_file_name = str(i) + '.obj' # Save the prediction to an OBJ file (mesh file). voxel2obj(pred_file_name, voxel_prediction[0, :, 1, :, :] > 0.4) toc = time.clock() print('Time for each frame: ' + str(float((toc - tic) / len(dirs)))) if __name__ == '__main__': # Set the batch size to 1 cfg_from_list(['CONST.BATCH_SIZE', 1]) main()
dest='cfg_file', help='optional cfg.OPOSE file', default='./cfgs/opose/vgg19s8_cpm6s.yml', type=str) parser.add_argument('--set', dest='set_cfgs', help='set cfg.OPOSE keys', default=None, nargs=argparse.REMAINDER) args = parser.parse_args() print('==> Called with args:') print(args) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) print('==> Using config:') print(cfg.OPOSE) # Use CUDA gpu = [] os.environ['CUDA_VISIBLE_DEVICES'] = cfg.gpu_ids for i in cfg.gpu_ids.split(','): gpu.append(int(i)) USE_CUDA = torch.cuda.is_available() # Random seed if cfg.rng_seed is None: cfg.rng_seed = random.randint(1, 10000) random.seed(cfg.rng_seed) torch.manual_seed(cfg.rng_seed) # Global param NUM_GPUS = len(cfg.gpu_ids.split(','))
def main(): global args args = parser.parse_args() args_str = json.dumps(vars(args), indent=2) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) # use timestamp as log subdirectory timestamp = args.timestamp cfg.LOG_DIR = os.path.join(cfg.LOG_DIR, timestamp) model_group_name, model_name = args.model.split('/') # setting log handlers sh = logging.StreamHandler(sys.stdout) sh.setLevel(logging.DEBUG) logger.addHandler(sh) logger.debug('[Info] called with: ' + args_str) logger.debug('[Info] timestamp: ' + timestamp) # select device torch.cuda.set_device(args.gpu_id) logger.debug('[Info] use gpu: {}'.format(torch.cuda.current_device())) # data assert (len(cfg.TEST.SPLITS) == 1 and cfg.TEST.SPLITS[0] in ('val2014')) logger.debug('[Info] init dataset') val_set = VQADataset('test', model_group_name) RES_DIR = '/home/lyt/code/bert-as-service-test/result' queIds, queFea, _ = load_data(split_name='val2014', RES_DIR=RES_DIR) assert queIds.tolist() == val_set.que_id.tolist() logger.debug('[Info] Clustering using {}, {} clusters'.format( args.cluster_alg, args.n_clusters)) clusfilename = '{}/{}/{}_{}_n{}.pkl'.format(RES_DIR, 'v2', 'train2014', args.cluster_alg, args.n_clusters) logger.debug('[Info] cluster file: {}'.format(clusfilename)) val_qTypeLabels = clustering(queFea, clu_num=args.n_clusters, clu_alg=args.cluster_alg, savefname=clusfilename) # model logger.debug('[Info] construct model') model_group = import_module('models.' + model_group_name) model = getattr(model_group, model_name)(num_words=val_set.num_words, num_ans=val_set.num_ans, emb_size=get_emb_size()) logger.debug('[Info] model name: ' + args.model) total_param = 0 for param in model.parameters(): total_param += param.nelement() logger.debug('[Info] total parameters: {}M'.format( math.ceil(total_param / 2**20))) model.cuda() cudnn.benchmark = True # load best model, predict logger.debug('[Info] load model ...') best_path = os.path.join(cfg.LOG_DIR, 'model-best.pth.tar') #if os.path.isfile(best_path): assert os.path.isfile(best_path) logger.debug("[Info] loading checkpoint '{}'".format(best_path)) cp_state = torch.load(best_path) best_acc = cp_state['best_acc'] logger.debug('[Info] best model with best acc {}'.format(best_acc)) model.load_state_dict(cp_state['state_dict']) #else: # logger.debug("[Info] no checkpoint found at '{}'".format(best_path)) for i in range(args.n_clusters): logger.debug('[Info] choose cluster ID: {}'.format(i)) #sel = val_qTypeLabels == args.clus_id sel = val_qTypeLabels == i val_quesIds = queIds[sel].tolist() logger.debug( '[Info] #Val set before/after clustering and choosing {}/{}'. format(queIds.shape[0], len(val_quesIds))) val_set_sub = select_subset(val_set, sel) val_loader = torch.utils.data.DataLoader(val_set_sub, batch_size=args.bs, shuffle=False, num_workers=args.workers, pin_memory=True) logger.debug('sample count: {}'.format(len(val_set_sub))) acc = validate(val_loader, model, None, None, quesIds=val_quesIds) logger.debug('Evaluate Result:\tAcc {0}'.format(acc))
if __name__ == '__main__': import matplotlib.pyplot as plt # _, axes = plt.subplots(2,2,figsize=(10,15)) # axes = axes.flatten() # from datasets.nyud import nyud # imdb = nyud('train', '2012') # with open('datalayer_test.pt', 'w') as f: # layerStr = '{}'.format(datalayer_test(imdb)) # print layerStr # f.write(layerStr) cfg_from_list(['TRAIN.BATCH_SIZE', '1']) caffe.set_mode_gpu() caffe.set_device(0) # net = caffe.Net('datalayer_test.pt', caffe.TRAIN) solver = caffe.SGDSolver('solver.pt') # layer_ind = list(solver.net._layer_names).index('data') # solver.net.layers[layer_ind].set_imdb(imdb) # conv_filters = solver.net.layers[1].blobs[0].data # print conv_filters print 'Start training..' # plt.ion()
def main(): args = parser.parse_args() if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) # select device torch.cuda.set_device(args.gpu_id) print('[Info] use gpu: {}'.format(torch.cuda.current_device())) # get parameters sys.path.insert(0, args.model_dir) from params import params assert len(params) > 1 last_cfg = params[0][-1] last_cfg() get_data.main() dataset = VQADataset('test', params[0][1]) itoa = dataset.codebook['itoa'] vote_buff = [{} for i in range(len(dataset))] conf_buff = np.zeros((len(dataset), len(itoa))) sm_conf_buff = np.zeros((len(dataset), len(itoa))) l2_conf_buff = np.zeros((len(dataset), len(itoa))) que_ids = dataset.que_id for fpath, mgrp, mname, acc, cfg_func, in params: # data if cfg_func != last_cfg: cfg_func() get_data.main() last_cfg = cfg_func dataset = VQADataset('test', mgrp) itoa = dataset.codebook['itoa'] dataset.reload_obj(mgrp) dataloader = torch.utils.data.DataLoader( dataset, batch_size=args.bs, shuffle=False, num_workers=2, pin_memory=True) # model model_group = import_module('models.' + mgrp) model = getattr(model_group, mname) num_words=dataset.num_words, num_ans=dataset.num_ans, emb_size=get_emb_size()) cp_file = os.path.join(args.model_dir, fpath) checkpoint = torch.load(cp_file, map_location=lambda s, l: s.cuda(0)) model.load_state_dict(checkpoint['state_dict']) model.cuda() model.eval() # predict bar = progressbar.ProgressBar() start = 0 # sample: (que_id, img, que, [obj]) for sample in bar(dataloader): sample_var = [Variable(d).cuda() for d in list(sample)[1:]] score = model(*sample_var) sm_score = torch.nn.functional.softmax(score) l2_score = torch.nn.functional.normalize(score) bs = score.size(0) conf_buff[start:start+bs] += score.data.cpu().numpy() sm_conf_buff[start:start+bs] += sm_score.data.cpu().numpy() l2_conf_buff[start:start+bs] += l2_score.data.cpu().numpy() _, ans_ids = torch.max(score.data, dim=1) for i, ans_id in enumerate(ans_ids): ans = itoa[ans_id] ans_score = acc + vote_buff[start + i].get(ans, 0) vote_buff[start + i][ans] = ans_score start += bs
args = parser.parse_args() return args if __name__ == '__main__': args = parse_args() print('Called with args:') pprint.pprint(args) # set the global cfg variable from the file if args.cfg_file is not None: for cfg_file in args.cfg_file: cfg_from_file(cfg_file) if args.batch_size is not None: cfg_from_list(['BATCH_SIZE', args.batch_size]) if args.no_prefetch: cfg_from_list(['USE_PREFETCH', False]) print('Using config:') pprint.pprint(cfg) if not args.randomize: # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(cfg.RNG_SEED) caffe.set_random_seed(cfg.RNG_SEED) # set up caffe caffe.set_mode_gpu() if args.gpu_id is not None: caffe.set_device(args.gpu_id)
def main(): global args args = parser.parse_args() args_str = json.dumps(vars(args), indent=2) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) # use timestamp as log subdirectory timestamp = datetime.datetime.now().strftime('%Y%m%d%H%M%S') cfg.LOG_DIR = os.path.join(cfg.LOG_DIR, timestamp) os.mkdir(cfg.LOG_DIR) json.dump(cfg, open(cfg.LOG_DIR + '/config.json', 'w'), indent=2) model_group_name, model_name = args.model.split('/') shutil.copy('models/' + model_group_name + '.py', cfg.LOG_DIR) # init ploter ploter = Ploter(timestamp) # setting log handlers fh = logging.FileHandler(os.path.join(cfg.LOG_DIR, 'log')) fh.setLevel(logging.DEBUG) fhc = logging.FileHandler('current.log') fhc.setLevel(logging.DEBUG) sh = logging.StreamHandler(sys.stdout) sh.setLevel(logging.DEBUG) fmt = '[%(asctime)-15s] %(message)s' datefmt = '%Y-%m-%d %H:%M:%S' formatter = logging.Formatter(fmt, datefmt) fh.setFormatter(formatter) fhc.setFormatter(formatter) logger.addHandler(fh) logger.addHandler(fhc) logger.addHandler(sh) logger.debug('[Info] called with: ' + args_str) logger.debug('[Info] timestamp: ' + timestamp) logger.debug('[Info] CPU random seed: {}'.format(torch.initial_seed())) logger.debug('[Info] GPU random seed: {}'.format( torch.cuda.initial_seed())) # select device torch.cuda.set_device(args.gpu_id) logger.debug('[Info] use gpu: {}'.format(torch.cuda.current_device())) # data logger.debug('[Info] init dataset') do_test = (len(cfg.TEST.SPLITS) == 1 and cfg.TEST.SPLITS[0] in ('train2014', 'val2014')) trn_set = VQADataset('train', model_group_name) train_loader = torch.utils.data.DataLoader(trn_set, batch_size=args.bs, shuffle=True, num_workers=args.workers, pin_memory=True) if do_test: val_set = VQADataset('test', model_group_name) val_loader = torch.utils.data.DataLoader(val_set, batch_size=args.bs, shuffle=False, num_workers=args.workers, pin_memory=True) # model emb_size = 300 if cfg.WORD_EMBEDDINGS: word_vec = merge_embeddings(cfg.WORD_EMBEDDINGS) aword = next(iter(word_vec)) emb_size = len(word_vec[aword]) logger.debug('[Info] embedding size: {}'.format(emb_size)) logger.debug('[Info] construct model, criterion and optimizer') model_group = import_module('models.' + model_group_name) model = getattr(model_group, model_name)(num_words=trn_set.num_words, num_ans=trn_set.num_ans, emb_size=emb_size) logger.debug('[Info] model name: ' + args.model) total_param = 0 for param in model.parameters(): total_param += param.nelement() logger.debug('[Info] total parameters: {}M'.format( math.ceil(total_param / 2**20))) # initialize word embedding with pretrained if cfg.WORD_EMBEDDINGS: emb = model.we.weight.data.numpy() words = trn_set.codebook['itow'] assert '<PAD>' not in word_vec fill_cnt = 0 for i, w in enumerate(words): if w in word_vec: emb[i] = word_vec[w] fill_cnt += 1 logger.debug('[debug] word embedding filling count: {}/{}'.format( fill_cnt, len(words))) model.we.weight = nn.Parameter(torch.from_numpy(emb)) if model_group_name in ('onehot_label', 'prob_label'): # initialize object embedding with pretrained obj_emb = model.obj_net[0].weight.data.numpy() if model_group_name == 'prob_label': obj_emb = obj_emb.T fill_cnt = 0 for i, line in enumerate(trn_set.objects_vocab): avail, vec = get_class_embedding(line, word_vec, emb_size) if avail: obj_emb[i] = vec fill_cnt += 1 logger.debug('[debug] class embedding filling count: {}/{}'.format( fill_cnt, len(trn_set.objects_vocab))) if model_group_name == 'prob_label': obj_emb = obj_emb.T model.obj_net[0].weight = nn.Parameter(torch.from_numpy(obj_emb)) model.cuda() if cfg.SOFT_LOSS: criterion = nn.BCEWithLogitsLoss().cuda() else: criterion = nn.CrossEntropyLoss().cuda() logger.debug('[Info] criterion name: ' + criterion.__class__.__name__) optimizer = torch.optim.Adam(model.parameters(), args.lr, weight_decay=args.wd) cudnn.benchmark = True # train logger.debug('[Info] start training...') is_best = False best_acc = 0 best_epoch = -1 for epoch in range(args.start_epoch, args.epochs): lr = adjust_learning_rate(optimizer, epoch) ploter.append(epoch, lr, 'lr') loss = train(train_loader, model, criterion, optimizer, epoch) ploter.append(epoch, loss, 'train-loss') if do_test: acc = validate(val_loader, model, criterion, epoch) ploter.append(epoch, acc, 'val-acc') if acc > best_acc: is_best = True best_acc = acc best_epoch = epoch logger.debug('Evaluate Result:\t' 'Acc {0}\t' 'Best {1} ({2})'.format(acc, best_acc, best_epoch)) # save checkpoint cp_fname = 'checkpoint-{:03}.pth.tar'.format(epoch) cp_path = os.path.join(cfg.LOG_DIR, cp_fname) state = { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'best_acc': best_acc, 'optimizer': optimizer.state_dict() } if epoch % args.save_freq == 0: torch.save(state, cp_path) if is_best: best_path = os.path.join(cfg.LOG_DIR, 'model-best.pth.tar') torch.save(state, best_path)
def main(): args = parse_args() #print('Called with args:') #print(args) # Set main gpu theano.sandbox.cuda.use(args.gpu_id) if args.cfg_files is not None: for cfg_file in args.cfg_files: cfg_from_file(cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) if not args.randomize: np.random.seed(cfg.CONST.RNG_SEED) if args.batch_size is not None: cfg_from_list(['CONST.BATCH_SIZE', args.batch_size]) if args.iter is not None: cfg_from_list(['TRAIN.NUM_ITERATION', args.iter]) if args.net_name is not None: cfg_from_list(['NET_NAME', args.net_name]) if args.model_name is not None: cfg_from_list(['CONST.NETWORK_CLASS', args.model_name]) if args.dataset is not None: cfg_from_list(['DATASET', args.dataset]) if args.exp is not None: cfg_from_list(['TEST.EXP_NAME', args.exp]) if args.out_path is not None: cfg_from_list(['DIR.OUT_PATH', args.out_path]) if args.weights is not None: cfg_from_list(['CONST.WEIGHTS', args.weights, 'TRAIN.RESUME_TRAIN', True, 'TRAIN.INITIAL_ITERATION', int(args.init_iter)]) print('Using config:') pprint.pprint(cfg) if not args.test: train()