def build_db(): try: os.makedirs(db_path) except: print('Make dirs skipped!') # NpyData_lmdb imdb = ImageData_lmdb(db_path, 'w') cate2imgIDs = {} # from multiprocessing import Pool for cate, synsetID in cate_synsetID: cate_dir = os.path.join(src_img_dir, synsetID) shapeIDs = [x for x in os.listdir(cate_dir) if os.path.isdir(os.path.join(cate_dir,x))] print(cate) for _k, shapeID in enumerate(tqdm(shapeIDs)): sys.stdout.flush() cate_shape_dir = os.path.join(cate_dir, shapeID) imgIDs = [x[:-4] for x in os.listdir(cate_shape_dir) if x.endswith('.png')] for imgID in imgIDs: imgpath = os.path.join(cate_shape_dir,imgID+'.png') cate2imgIDs.setdefault(cate, []).append(imgID) # write to lmdb. #-# img = cv2.imread(imgpath) # , cv2.IMREAD_UNCHANGED) #-# imdb[imgID] = img imdb.put(imgID, imgpath) Open(os.path.join(base_dir,'cate2imgIDs/%s.txt'%cate), 'w').write('\n'.join(cate2imgIDs[cate])+'\n') # exit() pickle.dump(cate2imgIDs, Open(os.path.join(base_dir,'cate2imgIDs.pkl'), 'wb'), protocol) return db_path
def main( collection='train', filter='all', cates=categories, # cates=['aeroplane','boat','car'], # ): out_dir = '../anno_db_v2/data.cache/objId2gtbox' try: os.makedirs(out_dir) except: print('Make dirs skipped!') # from multiprocessing import Pool objId2gtbox = dict() nr_box = 0 for cate in cates: print(' >>> %10s %5s %20s ' % (collection, filter, cate)) objIDs, rcobjs = get_anno(cate, collection=collection, filter=filter) for _k, rcobj in enumerate(rcobjs): # tqdm() gt_box = process(rcobj) # resize_shape cate, _k, len(rcobjs) objId2gtbox[rcobj.obj_id] = gt_box nr_box += 1 outpath = os.path.join( out_dir, 'cate%s_%s.%s.pkl' % (len(cates), collection, filter)) pickle.dump(objId2gtbox, Open(outpath, 'wb'), protocol) print('[outpath]: ', outpath) print('nr_box: ', nr_box)
def test(dataset_test, work_dir, test_model=None, marker='epoch'): out_rslt_path = work_dir + '/temp.out_rslt_path.txt' out_eval_path = work_dir + '/temp.out_eval_path.txt' if test_model is None: test_model = model #---- Load trained weights here.------ assert os.path.exists(work_dir) # iter_nums, net_name = list_models(work_dir, marker=marker) saved_iter_num = iter_nums[-1] pretrained_model = work_dir + '/%s_%s_%s.pth.tar' % ( net_name, marker, saved_iter_num) # select maxmun iter number. print('[pretrained_model] ', pretrained_model) checkpoint = torch.load(pretrained_model) # load weights here. _state_dict = patch_saved_DataParallel_state_dict( checkpoint['state_dict']) test_model.load_state_dict(_state_dict) # switch to train mode test_model.eval() gLoss_redu = reducer_group(*watch_targets) gPred_redu = reducer_group(*['quat']) pre_time = time.time() it = -1 epoch = -1 # keys = dataset_test.keys test_loader = torch.utils.data.DataLoader( dataset_test, batch_size=_cfg.TEST.BATCH_SIZE * nr_GPUs, shuffle=False, num_workers=opt.num_workers * nr_GPUs, pin_memory=opt.pin_memory, sampler=None) with torch.no_grad(): pbar = tqdm(test_loader) for _i_, sample_batched in enumerate(pbar): pbar.set_description("[work_dir] %s " % _short_work_dir) it += 1 # Note: Tensor.cuda() Returns a copy of this object in CUDA memory. label = torch.autograd.Variable( sample_batched['label'].cuda(non_blocking=True)) data = torch.autograd.Variable( sample_batched['data'].cuda(non_blocking=True)) # formulate GT dict _gt_targets = test_model.gt_targets if hasattr( test_model, 'gt_targets') else test_model.targets GT = edict() for tgt in _gt_targets: GT[tgt] = torch.autograd.Variable( sample_batched[tgt].cuda(non_blocking=True)) # compute Pred output Prob = test_model(data, label) # compute Loss for each target and formulate Loss dictionary. Loss = test_model.compute_loss(Prob, GT) total_loss = 0 for tgt in watch_targets: total_loss += Loss[tgt] # predict target angles value Pred = test_model.compute_pred(Prob) gLoss_redu.collect( Loss) # pass in dict of all loss (loss_a, loss_e, loss_t). gPred_redu.collect(Pred, squeeze=False) # print loss info cur_time = time.time() time_consume = cur_time - pre_time pre_time = cur_time print('\r %s [test-iter] %5d / %5d ---------[time_consume] %.2f' % (strftime("%Y-%m-%d %H:%M:%S", gmtime()), it, len(test_loader), time_consume)) for trgt in watch_targets: _loss = Loss[trgt].data.cpu().numpy().copy() print(' %-15s loss=%.3f' % (trgt, _loss)) if np.isnan(_loss): print("[Warning] Weights explode! Stop training ... ") exit(-1) # pbar.set_description("[work_dir] %s " % os.path.abspath(work_dir)[len(os.path.abspath(opt.base_dir))+1:]) # print ("\r[work_dir] %s \r" % os.path.abspath(work_dir)[len(os.path.abspath(opt.base_dir))+1:],end='') sys.stdout.flush() pred_quats = gPred_redu.reduce()['quat'] #-- Write result to file (Format: # {obj_id} {a} {e} {t} ) txtTbl = TxtTable( '{obj_id:<20s} {a:>6.4f} {b:>6.4f} {c:>6.4f} {d:>6.4f}') rslt_lines = [txtTbl.getHeader()] for _k, _quat in zip(keys, pred_quats): _a, _b, _c, _d = _quat rslt_line = txtTbl.format(_k, _a, _b, _c, _d) rslt_lines.append(rslt_line) rslt_lines = '\n'.join(rslt_lines) Open(out_rslt_path, 'w').write(rslt_lines) # print('[out_rslt_path]', out_rslt_path) #-- Do evaluation ('MedError', 'Acc@theta') from numpy_db import npy_table rc_tbl = npy_table(dataset_test.recs) # summary_str = eval_cates( out_rslt_path, rc_tbl, cates=opt.cates, theta_levels_str='pi/6 pi/12 pi/24') # ['aeroplane','boat','car']) Open(out_eval_path, 'w').write(summary_str) print(summary_str) reca = TxtTable().load_as_recarr( out_eval_path, fields=['MedError', 'Acc@pi/6', 'Acc@pi/12', 'Acc@pi/24']) return reca[-1]
work_dir += '.%s' % opt.train_view _short_work_dir = os.path.abspath( work_dir)[len(os.path.abspath(opt.base_dir)) + 1:] # global state variables. start_it = 0 start_epoch = 0 from pytorch_util.libtrain import rm_models, list_models from pytorch_util.libtrain.reducer import reducer, reducer_group # Log file. script_name, _ = os.path.splitext(os.path.basename(__file__)) log_filename = '%s/%s.log' % (work_dir, script_name) if os.path.exists(log_filename): # backup previous content. pre_log_content = open(log_filename).read() logf = Open(log_filename, 'w') def logprint(s): print("\r%s " % s) logf.write(s + "\n") #-- Resume or use pretrained (Note not imagenet pretrain.) assert not (opt.resume and opt.pretrain is not None), 'Only resume or pretrain can exist.' if opt.resume: iter_nums, net_name = list_models(work_dir) # ('snapshots') assert len(iter_nums) > 0, "No models available" latest_model_name = os.path.join( work_dir, '%s_iter_%s.pth.tar' % (net_name, iter_nums[-1]))
def test(dataset_test, work_dir, test_model=None, marker='epoch', save_pred=False, train_epoch=None): out_rslt_path = work_dir + '/temp.out_rslt_path.txt' out_eval_path = work_dir + '/temp.out_eval_path.txt' if test_model is None: test_model = model #---- Load trained weights here.------ assert os.path.exists(work_dir) # iter_nums, net_name = list_models(work_dir, marker=marker) saved_iter_num = iter_nums[-1] pretrained_model = work_dir + '/%s_%s_%s.pth.tar' % ( net_name, marker, saved_iter_num) # select maxmun iter number. print('[pretrained_model] ', pretrained_model) checkpoint = torch.load(pretrained_model) # load weights here. _state_dict = patch_saved_DataParallel_state_dict( checkpoint['state_dict']) test_model.load_state_dict(_state_dict) # switch to train mode test_model.eval() gEval_redu = reducer_group(*['Es']) pre_time = time.time() it = -1 epoch = -1 # keys = dataset_test.keys test_loader = torch.utils.data.DataLoader( dataset_test, batch_size=_cfg.TEST.BATCH_SIZE * nr_GPUs, shuffle=False, num_workers=opt.num_workers * nr_GPUs, pin_memory=opt.pin_memory, sampler=None) if save_pred: from lmdb_util import NpyData_lmdb, ImageData_lmdb pred_db_path = os.path.join(work_dir, 'PredNormal.Rawpng.lmdb') pred_db = ImageData_lmdb(pred_db_path, 'w') for _i_, sample_batched in enumerate(test_loader): # rec_inds = sample_batched['idx'].numpy() # it += 1 # Note: Tensor.cuda() Returns a copy of this object in CUDA memory. data = sample_batched['data'].to(device, non_blocking=True) # formulate GT dict _gt_targets = model.gt_targets if hasattr( model, 'gt_targets') else model.targets GT = edict() GT['mask'] = sample_batched['mask'].to(device, non_blocking=True) for tgt in _gt_targets: GT[tgt] = sample_batched[tgt].to(device, non_blocking=True) # compute Pred output Prob = test_model(data) # compute Loss for each target and formulate Loss dictionary. Loss, _Metric_ = test_model.compute_loss(Prob, GT) total_loss = 0 for tgt in watch_targets: total_loss += Loss[tgt] # * loss_weight if 'norm' in _Metric_.keys(): _Es = _Metric_['norm'].data.cpu().numpy().copy() gEval_redu.collect(dict(Es=_Es), squeeze=False) # predict as images if save_pred: Pred = test_model.compute_pred(Prob, encode_bit=8) # predNormImgs = Pred.norm # NxHxWx3 assert len(rec_inds) == len(predNormImgs) for i, idx in enumerate(rec_inds): key = keys[idx] pred_db[key] = predNormImgs[i] # print loss info cur_time = time.time() time_consume = cur_time - pre_time pre_time = cur_time print('\r %s [test-iter] %5d / %5d ---------[time_consume] %.2f' % (strftime("%Y-%m-%d %H:%M:%S", gmtime()), it, len(test_loader), time_consume)) for trgt in watch_targets: _loss = Loss[trgt].data.cpu().numpy().copy() print(' %-15s loss=%.3f' % (trgt, _loss)) if np.isnan(_loss): print("[Warning] Weights explode! Stop training ... ") exit(-1) _watch_targets = watch_targets + [ 'norm' ] if 'norm' not in watch_targets else watch_targets for tgt in _watch_targets: if tgt == 'sgc_norm': # in metric. logprint(' %-10s [Acc] : %5.1f%%' % (tgt, _Metric_['sgc_norm_acc'] * 100)) else: if tgt in _Metric_.keys(): Es = _Metric_[tgt].data.cpu().numpy().copy() mean = np.mean(Es) median = np.median(Es) rmse = np.sqrt(np.mean(np.power(Es, 2))) acc11 = np.mean(Es < 11.25) * 100 acc22 = np.mean(Es < 22.5) * 100 acc30 = np.mean(Es < 30) * 100 logprint( ' %-10s [mean]: %5.1f [median]: %5.1f [rmse]: %5.1f [acc{11,22,30}]: %5.1f%%, %5.1f%%, %5.1f%%' % (tgt, mean, median, rmse, acc11, acc22, acc30)) print( "\r[work_dir] %s \r" % os.path.abspath(work_dir)[len(os.path.abspath(opt.base_dir)) + 1:], end='', flush=True) Es = gEval_redu.reduce()['Es'] mean = np.mean(Es) median = np.median(Es) rmse = np.sqrt(np.mean(np.power(Es, 2))) acc11 = np.mean(Es < 11.25) * 100 acc22 = np.mean(Es < 22.5) * 100 acc30 = np.mean(Es < 30) * 100 summary_str = '' if train_epoch is not None: summary_str += '[Test at epoch %d]\n' % train_epoch summary_str += ' [mean]: %5.1f [median]: %5.1f [rmse]: %5.1f [acc{11,22,30}]: %5.1f%%, %5.1f%%, %5.1f%%\n' % ( mean, median, rmse, acc11, acc22, acc30) logprint(summary_str) Open(out_eval_path, 'a+').write(summary_str) if save_pred: mean, median, rmse, acc11, acc22, acc30 = eval_all( pred_db_path, use_multiprocess=False) summary_str = '\n--------------------------------------------' summary_str += '[Test] %s \n' % pretrained_model summary_str += ' [mean]: %5.1f [median]: %5.1f [rmse]: %5.1f [acc{11,22,30}]: %5.1f%%, %5.1f%%, %5.1f%%\n' % ( mean, median, rmse, acc11, acc22, acc30) Open(out_eval_path, 'a+').write(summary_str) print(summary_str) return mean, median, rmse, acc11, acc22, acc30
def filter_img_set(img_set, filter='easy', source='pascal', include_coarse_vp_anno=False, MAX_IMAGE_SIDE=None): print('=================[%s_%s] %s' % (source, img_set, filter)) # {'flip':1, 'aug_n':1,'jitter_IoU':1,'difficult':1,'truncated':1,'occluded':1} if filter == 'all': opts = None elif filter == 'easy': # Select option opts: Mark 1 as to be kept, 0: to be filtered. opts = edict({ 'difficult': 0, 'truncated': 0, 'occluded': 0 }) # filter out truncated, occluded but keep difficult elif filter == 'nonOccl': opts = edict({ 'difficult': 1, 'truncated': 0, 'occluded': 0 }) # filter out truncated, occluded but keep difficult elif filter == 'nonDiff': opts = edict({ 'difficult': 0, 'truncated': 1, 'occluded': 1 }) # filter out difficult but keep truncated, occluded else: raise NotImplementedError cnt_image = 0 for cate in categories: obj_list = [] if source == 'pascal': filename = PascalVOC_root + '/VOCdevkit/VOC2012/ImageSets/Main/%s.txt' % img_set all_ids = list(map(str.strip, open(filename).readlines())) elif source == 'imagenet': # /Users/shine/QuvaMnt/working/cvpr17pose/dataset/PASCAL3D+_release1.1/Image_sets/aeroplane_imagenet_val.txt filename = Pascal3D_root + '/Image_sets/%s_imagenet_%s.txt' % ( cate, img_set) all_ids = list(map(str.strip, open(filename).readlines())) else: raise NotImplementedError cnt_obj = 0 for i, id in enumerate(all_ids): anno_filename = os.path.join( py_anno_dir, '%s_%s/%s.pkl' % (cate, source, id)) # aeroplane_pascal/xxx.pkl if not os.path.exists(anno_filename): # print 'File not exists: ', anno_filename continue selected_objs = read_anno_pkl(anno_filename, cate, source, id, img_set, opts, include_coarse_vp_anno, MAX_IMAGE_SIDE) if len(selected_objs) > 0: cnt_obj += len(selected_objs) obj_list += selected_objs # else: # print anno_filename # print "------------------------------------- len(obj_list): ", len(obj_list) obj_rcs = np.vstack(obj_list).reshape( (-1, )) # np.concatenate(obj_list, axis=0) # np.vstack(obj_list) obj_rcs = obj_rcs.view(np.recarray) # cast as np.recarray img_ids = set(obj_rcs.src_img.image_id.tolist()) cnt_image += len(img_ids) print('%-20s img %5s obj %5s' % (cate, len(img_ids), len(obj_rcs))) # print '%-20s img %5s obj %5s' % (cate, len(set(obj_rcs.src_img.image_id.tolist())), len(obj_rcs)) filterStr = filter + '_withCoarseVp' if include_coarse_vp_anno else filter maxSideStr = 'Org' if ( MAX_IMAGE_SIDE is None) else 'Max%s' % MAX_IMAGE_SIDE pickle.dump( obj_rcs, Open( 'working_dump.cache/Catewise_obj_anno/%s.%s/%s_%s.%s.pkl' % (filterStr, maxSideStr, source, img_set, cate), 'wb'), protocol) print('selected: %d / %d images' % (cnt_image, len(all_ids)))
import pickle from basic.util import load_yaml conf = load_yaml('config.yml') # odict Pascal3D_root = os.path.expanduser(conf['Pascal3D_release_root']) protocol = conf[ 'pkl_protocol'] # pickle dump protocol. Change -1 to 2 for python2.x compatibility. mat_anno_dir = os.path.join(Pascal3D_root, 'Annotations') new_anno_dir = os.path.join('./working_dump.cache', 'Imgwise_Annotations.py') try: os.makedirs(new_anno_dir) except: pass all_fos = [ x for x in os.listdir(mat_anno_dir) if os.path.isdir(os.path.join(mat_anno_dir, x)) ] for i, fo in enumerate(all_fos): print('[%2d/%2d] %s ' % (i, len(all_fos), fo)) for f in [ x for x in os.listdir(os.path.join(mat_anno_dir, fo)) if x.endswith('.mat') ]: matfile = os.path.join(mat_anno_dir, fo, f) pklfile = os.path.join(new_anno_dir, fo, f[:-4] + '.pkl') struct_dict = loadmat(matfile) pickle.dump(struct_dict, Open(pklfile, 'wb'), protocol)
def test(): out_rslt_path = os.path.join(opt.work_dir, 'rslt.cache.txt') out_eval_path = os.path.join(opt.work_dir, 'eval.cache.txt') keys = dataset_test.keys # switch to train mode model.eval() # # loss reducer from pytorch_util.libtrain.reducer import reducer, reducer_group gLoss_redu = reducer_group(*watch_targets) gPred_redu = reducer_group(*['a', 'e', 't']) pre_time = time.time() it = -1 epoch = -1 # for _i_, sample_batched in enumerate(test_loader): with torch.no_grad(): pbar = tqdm(test_loader) for _i_, sample_batched in enumerate(pbar): pbar.set_description("[work_dir] %s " % os.path.relpath(opt.work_dir)) it += 1 # prepare input data label = sample_batched['label'].to(device, non_blocking=True) data = sample_batched['data'].to(device, non_blocking=True) # formulate GT dict _gt_targets = model.gt_targets if hasattr( model, 'gt_targets') else model.targets GT = edict() for tgt in _gt_targets: GT[tgt] = sample_batched[tgt].to(device, non_blocking=True) # compute Pred output Prob = model(data, label) # compute Loss for each target and formulate Loss dictionary. Loss = model.compute_loss(Prob, GT) total_loss = 0 for tgt in watch_targets: total_loss += Loss[tgt] # * loss_weight # predict target angles value Pred = model.compute_pred(Prob) gLoss_redu.collect( Loss) # pass in dict of all loss (loss_a, loss_e, loss_t). gPred_redu.collect(Pred) # print loss info cur_time = time.time() time_consume = cur_time - pre_time pre_time = cur_time name2pred = gPred_redu.reduce() # convert prediction back to [0, 360] a, e, t = dataset_test.pred2angle( name2pred['a'], name2pred['e'], name2pred['t']) # or call _dataset_module.pred2angle #-- Write result to file (Format: # {obj_id} {a} {e} {t} ) rslt_lines = '%-40s %5s %5s %5s\n' % ('# obj_id', 'a', 'e', 't') rslt_lines += ''.join([ '%-40s %5.1f %5.1f %5.1f\n' % (_k, _a, _e, _t) for _k, _a, _e, _t in zip(keys, a, e, t) ]) Open(out_rslt_path, 'w').write(rslt_lines) print("[output] ", out_rslt_path) #-- Do evaluation ('MedError', 'Acc@theta') summary_str = eval_cates( out_rslt_path, cates=opt.cates, theta_levels_str='pi/6 pi/12 pi/24') # ['aeroplane','boat','car']) Open(out_eval_path, 'w').write(summary_str) print(summary_str) reca = TxtTable().load_as_recarr( out_eval_path, fields=['MedError', 'Acc@pi/6', 'Acc@pi/12', 'Acc@pi/24']) return reca[-1]