| import gorilla
|
| from tqdm import tqdm
|
| import argparse
|
| import os
|
| import sys
|
| import os.path as osp
|
| import time
|
| import logging
|
| import numpy as np
|
| import random
|
| import importlib
|
| import pickle as cPickle
|
| import json
|
| import torch
|
|
|
| BASE_DIR = os.path.dirname(os.path.abspath(__file__))
|
| sys.path.append(os.path.join(BASE_DIR, 'provider'))
|
| sys.path.append(os.path.join(BASE_DIR, 'utils'))
|
| sys.path.append(os.path.join(BASE_DIR, 'model'))
|
| sys.path.append(os.path.join(BASE_DIR, 'model', 'pointnet2'))
|
|
|
|
|
| detetion_paths = {
|
| 'ycbv': '../Instance_Segmentation_Model/log/sam/result_ycbv.json',
|
| 'tudl': '../Instance_Segmentation_Model/log/sam/result_tudl.json',
|
| 'tless': '../Instance_Segmentation_Model/log/sam/result_tless.json',
|
| 'lmo': '../Instance_Segmentation_Model/log/sam/result_lmo.json',
|
| 'itodd': '../Instance_Segmentation_Model/log/sam/result_itodd.json',
|
| 'icbin': '../Instance_Segmentation_Model/log/sam/result_icbin.json',
|
| 'hb': '../Instance_Segmentation_Model/log/sam/result_hb.json'
|
| }
|
|
|
|
|
| def get_parser():
|
| parser = argparse.ArgumentParser(
|
| description="Pose Estimation")
|
|
|
| parser.add_argument("--gpus",
|
| type=str,
|
| default="0",
|
| help="index of gpu")
|
| parser.add_argument("--model",
|
| type=str,
|
| default="pose_estimation_model",
|
| help="name of model")
|
| parser.add_argument("--config",
|
| type=str,
|
| default="config/base.yaml",
|
| help="path to config file")
|
| parser.add_argument("--dataset",
|
| type=str,
|
| default="all",
|
| help="")
|
| parser.add_argument("--checkpoint_path",
|
| type=str,
|
| default="none",
|
| help="path to checkpoint file")
|
| parser.add_argument("--iter",
|
| type=int,
|
| default=0,
|
| help="iter num. for testing")
|
| parser.add_argument("--view",
|
| type=int,
|
| default=-1,
|
| help="view number of templates")
|
| parser.add_argument("--exp_id",
|
| type=int,
|
| default=0,
|
| help="experiment id")
|
| args_cfg = parser.parse_args()
|
|
|
| return args_cfg
|
|
|
| def init():
|
| args = get_parser()
|
| exp_name = args.model + '_' + \
|
| osp.splitext(args.config.split("/")[-1])[0] + '_id' + str(args.exp_id)
|
| log_dir = osp.join("log", exp_name)
|
| if not os.path.isdir(log_dir):
|
| os.makedirs(log_dir)
|
|
|
| cfg = gorilla.Config.fromfile(args.config)
|
| cfg.exp_name = exp_name
|
| cfg.gpus = args.gpus
|
| cfg.model_name = args.model
|
| cfg.log_dir = log_dir
|
| cfg.checkpoint_path = args.checkpoint_path
|
| cfg.test_iter = args.iter
|
| cfg.dataset = args.dataset
|
|
|
| if args.view != -1:
|
| cfg.test_dataset.n_template_view = args.view
|
|
|
| gorilla.utils.set_cuda_visible_devices(gpu_ids = cfg.gpus)
|
| return cfg
|
|
|
|
|
|
|
| def test(model, cfg, save_path, dataset_name, detetion_path):
|
| model.eval()
|
| bs = cfg.test_dataloader.bs
|
|
|
|
|
| dataset = importlib.import_module(cfg.test_dataset.name)
|
| dataset = dataset.BOPTestset(cfg.test_dataset, dataset_name, detetion_path)
|
| dataloder = torch.utils.data.DataLoader(
|
| dataset,
|
| batch_size=1,
|
| num_workers=cfg.test_dataloader.num_workers,
|
| shuffle=cfg.test_dataloader.shuffle,
|
| sampler=None,
|
| drop_last=cfg.test_dataloader.drop_last,
|
| pin_memory=cfg.test_dataloader.pin_memory
|
| )
|
|
|
|
|
| all_tem, all_tem_pts, all_tem_choose = dataset.get_templates()
|
| with torch.no_grad():
|
| dense_po, dense_fo = model.feature_extraction.get_obj_feats(all_tem, all_tem_pts, all_tem_choose)
|
|
|
| lines = []
|
| with tqdm(total=len(dataloder)) as t:
|
| for i, data in enumerate(dataloder):
|
| torch.cuda.synchronize()
|
| end = time.time()
|
|
|
| for key in data:
|
| data[key] = data[key].cuda()
|
| n_instance = data['pts'].size(1)
|
| n_batch = int(np.ceil(n_instance/bs))
|
|
|
| pred_Rs = []
|
| pred_Ts = []
|
| pred_scores = []
|
| for j in range(n_batch):
|
| start_idx = j * bs
|
| end_idx = n_instance if j == n_batch-1 else (j+1) * bs
|
| obj = data['obj'][0][start_idx:end_idx].reshape(-1)
|
|
|
|
|
| inputs = {}
|
| inputs['pts'] = data['pts'][0][start_idx:end_idx].contiguous()
|
| inputs['rgb'] = data['rgb'][0][start_idx:end_idx].contiguous()
|
| inputs['rgb_choose'] = data['rgb_choose'][0][start_idx:end_idx].contiguous()
|
| inputs['model'] = data['model'][0][start_idx:end_idx].contiguous()
|
| inputs['dense_po'] = dense_po[obj].contiguous()
|
| inputs['dense_fo'] = dense_fo[obj].contiguous()
|
|
|
|
|
| with torch.no_grad():
|
| end_points = model(inputs)
|
| pred_Rs.append(end_points['pred_R'])
|
| pred_Ts.append(end_points['pred_t'])
|
| pred_scores.append(end_points['pred_pose_score'])
|
|
|
| pred_Rs = torch.cat(pred_Rs, dim=0).reshape(-1, 9).detach().cpu().numpy()
|
| pred_Ts = torch.cat(pred_Ts, dim=0).detach().cpu().numpy() * 1000
|
| pred_scores = torch.cat(pred_scores, dim=0) * data['score'][0,:,0]
|
| pred_scores = pred_scores.detach().cpu().numpy()
|
| image_time = time.time() - end
|
|
|
|
|
| scene_id = data['scene_id'].item()
|
| img_id = data['img_id'].item()
|
| image_time += data['seg_time'].item()
|
| for k in range(n_instance):
|
| line = ','.join((
|
| str(scene_id),
|
| str(img_id),
|
| str(data['obj_id'][0][k].item()),
|
| str(pred_scores[k]),
|
| ' '.join((str(v) for v in pred_Rs[k])),
|
| ' '.join((str(v) for v in pred_Ts[k])),
|
| f'{image_time}\n',
|
| ))
|
| lines.append(line)
|
|
|
|
|
| t.set_description(
|
| "Test [{}/{}]".format(i+1, len(dataloder))
|
| )
|
| t.update(1)
|
|
|
| with open(save_path, 'w+') as f:
|
| f.writelines(lines)
|
|
|
|
|
|
|
|
|
|
|
| if __name__ == "__main__":
|
| cfg = init()
|
|
|
| print("************************ Start Logging ************************")
|
| print(cfg)
|
| print("using gpu: {}".format(cfg.gpus))
|
|
|
| random.seed(cfg.rd_seed)
|
| torch.manual_seed(cfg.rd_seed)
|
|
|
|
|
| print("creating model ...")
|
| MODEL = importlib.import_module(cfg.model_name)
|
| model = MODEL.Net(cfg.model)
|
| if len(cfg.gpus)>1:
|
| model = torch.nn.DataParallel(model, range(len(cfg.gpus.split(","))))
|
| model = model.cuda()
|
| if cfg.checkpoint_path == 'none':
|
| checkpoint = os.path.join(cfg.log_dir, 'checkpoint_iter' + str(cfg.test_iter).zfill(6) + '.pth')
|
| else:
|
| checkpoint = cfg.checkpoint_path
|
| gorilla.solver.load_checkpoint(model=model, filename=checkpoint)
|
|
|
|
|
| if cfg.dataset == 'all':
|
| datasets = ['ycbv', 'tudl', 'lmo', 'icbin', 'tless', 'itodd' , 'hb']
|
| for dataset_name in datasets:
|
| print('begining evaluation on {} ...'.format(dataset_name))
|
|
|
| save_path = os.path.join(cfg.log_dir, dataset_name + '_eval_iter' + str(cfg.test_iter).zfill(6))
|
| if not os.path.isdir(save_path):
|
| os.makedirs(save_path)
|
| save_path = os.path.join(save_path,'result_' + dataset_name +'.csv')
|
| test(model, cfg, save_path, dataset_name, detetion_paths[dataset_name])
|
|
|
| print('saving to {} ...'.format(save_path))
|
| print('finishing evaluation on {} ...'.format(dataset_name))
|
|
|
| else:
|
| dataset_name = cfg.dataset
|
| print('begining evaluation on {} ...'.format(dataset_name))
|
|
|
| save_path = os.path.join(cfg.log_dir, dataset_name + '_eval_iter' + str(cfg.test_iter).zfill(6))
|
| if not os.path.isdir(save_path):
|
| os.makedirs(save_path)
|
| save_path = os.path.join(save_path,'result_' + dataset_name +'.csv')
|
| test(model, cfg, save_path, dataset_name, detetion_paths[dataset_name])
|
|
|
| print('saving to {} ...'.format(save_path))
|
| print('finishing evaluation on {} ...'.format(dataset_name))
|
|
|
|
|
|
|
|
|
|
|
|
|
