def __init__(self, ie, model_path, device='CPU', max_reqs=100): self.max_reqs = max_reqs self.net = load_ie_model(ie, model_path, device, None, num_reqs=self.max_reqs)
def __init__(self, ie, model_path, trg_classes, conf=.6, device='CPU', ext_path='', max_reqs=100): self.trg_classes = trg_classes self.max_reqs = max_reqs self.confidence = conf self.net = load_ie_model(ie, model_path, device, None, ext_path, num_reqs=self.max_reqs) required_input_keys = [{'im_info', 'im_data'}, {'im_data', 'im_info'}] current_input_keys = self.net.input_info.keys() assert current_input_keys in required_input_keys required_output_keys = {'boxes', 'scores', 'classes', 'raw_masks'} assert required_output_keys.issubset(self.net.net.outputs) self.n, self.c, self.h, self.w = self.net.input_info[ 'im_data'].input_data.shape assert self.n == 1, 'Only batch 1 is supported.'
def __init__(self, ie, model_path, trg_classes, conf=.6, device='CPU', ext_path='', max_num_frames=1): self.net = load_ie_model(ie, model_path, device, None, ext_path, num_reqs=max_num_frames) self.trg_classes = trg_classes self.confidence = conf self.expand_ratio = (1., 1.) self.max_num_frames = max_num_frames
def __init__(self, ie, model_path, device='CPU', ext_path='', max_reqs=100): self.max_reqs = max_reqs self.net = load_ie_model(ie, model_path, device, None, 'Object Reidentification', ext_path, num_reqs=self.max_reqs)
def main(): args = parse_args() test_db = load_eye_db(args.data_root) net = load_ie_model(args.model, 'CPU', None) _, _, height, width = net.get_input_shape().shape for sample in test_db: img = cv.imread(sample['filename']) assert not img is None h, w, _ = img.shape out = net.forward(cv.resize(img, (width, height))) is_open = out[0][0][0][0] < out[0][1][0][0] if is_open: cv.rectangle(img, (1, 1), (w - 1, h - 1), (0, 255, 0), 2) else: cv.rectangle(img, (1, 1), (w - 1, h - 1), (0, 0, 255), 2) cv.imshow("Eye", img) cv.waitKey(0)
def __init__(self, ie, model_path, trg_classes, conf=.6, device='CPU', ext_path='', max_reqs=100): self.trg_classes = trg_classes self.max_reqs = max_reqs self.confidence = conf self.net = load_ie_model(ie, model_path, device, None, 'Instance Segmentation', ext_path, num_reqs=self.max_reqs) required_input_keys = {'image'} required_output_keys = {'boxes', 'labels', 'masks'} required_input_keys_segmentoly = {'im_info', 'im_data'} required_output_keys_segmentoly = { 'boxes', 'scores', 'classes', 'raw_masks' } current_input_keys = self.net.inputs_info.keys() assert (current_input_keys == required_input_keys and required_output_keys.issubset(self.net.net.outputs)) or \ (current_input_keys == required_input_keys_segmentoly and required_output_keys_segmentoly.issubset(self.net.net.outputs)) self.segmentoly_type = self.check_segmentoly_type() input_name = 'im_data' if self.segmentoly_type else 'image' self.n, self.c, self.h, self.w = self.net.inputs_info[ input_name].input_data.shape assert self.n == 1, 'Only batch 1 is supported.'
def main(): parser = argparse.ArgumentParser( description='Evaluation script for Face Recognition in PyTorch') parser.add_argument('--devices', type=int, nargs='+', default=[0], help='CUDA devices to use.') parser.add_argument('--embed_size', type=int, default=128, help='Size of the face embedding.') parser.add_argument('--val_data_root', dest='val', required=True, type=str, help='Path to validation data.') parser.add_argument('--val_list', dest='v_list', required=True, type=str, help='Path to train data image list.') parser.add_argument('--val_landmarks', dest='v_land', default='', required=False, type=str, help='Path to landmarks for the test images.') parser.add_argument('--val_batch_size', type=int, default=8, help='Validation batch size.') parser.add_argument('--snap', type=str, required=False, help='Snapshot to evaluate.') parser.add_argument('--roc_fname', type=str, default='', help='ROC file.') parser.add_argument('--dump_embeddings', action='store_true', help='Dump embeddings to summary writer.') parser.add_argument('--dist', choices=['l2', 'cos'], type=str, default='cos', help='Distance.') parser.add_argument('--flipped_emb', action='store_true', help='Flipped embedding concatenation trick.') parser.add_argument('--show_failed', action='store_true', help='Show misclassified pairs.') parser.add_argument('--model', choices=models_backbones.keys(), type=str, default='rmnet', help='Model type.') parser.add_argument('--engine', choices=['pt', 'ie'], type=str, default='pt', help='Framework to use for eval.') # IE-related options parser.add_argument('--fr_model', type=str, required=False) parser.add_argument('--lm_model', type=str, required=False) parser.add_argument('-pp', '--plugin_dir', type=str, default=None, help='Path to a plugin folder') args = parser.parse_args() if args.engine == 'pt': assert args.snap is not None, 'To evaluate PyTorch snapshot, please, specify --snap option.' with torch.cuda.device(args.devices[0]): data, embeddings_fun = load_test_dataset(args) model = models_backbones[args.model]( embedding_size=args.embed_size, feature=True) model = load_model_state(model, args.snap, args.devices[0]) evaluate(args, data, model, embeddings_fun, args.val_batch_size, args.dump_embeddings, args.roc_fname, args.snap, True, args.show_failed) else: from utils.ie_tools import load_ie_model assert args.fr_model is not None, 'To evaluate IE model, please, specify --fr_model option.' fr_model = load_ie_model(args.fr_model, 'CPU', args.plugin_dir) lm_model = None if args.lm_model: lm_model = load_ie_model(args.lm_model, 'CPU', args.plugin_dir) input_size = tuple(fr_model.get_input_shape()[2:]) lfw = LFW(args.val, args.v_list, args.v_land) if not lfw.use_landmarks or lm_model: lfw.transform = t.Compose( [ResizeNumpy(220), CenterCropNumpy(input_size)]) lfw.use_landmarks = False else: log.info('Using landmarks for the LFW images.') lfw.transform = t.Compose([ResizeNumpy(input_size)]) evaluate(args, lfw, fr_model, partial(compute_embeddings_lfw_ie, lm_model=lm_model), val_batch_size=1, dump_embeddings=False, roc_fname='', snap_name='', verbose=True, show_failed=False)
def __init__(self, model_path, device='CPU'): self.net = load_ie_model(model_path, device, None)
def __init__(self, model_path, conf=.6, device='CPU', ext_path=''): self.net = load_ie_model(model_path, device, None, ext_path) self.confidence = conf self.expand_ratio = (1.1, 1.05)
def main(): """Runs the accuracy check""" parser = argparse.ArgumentParser( description='Accuracy check script (pt vs caffe)') parser.add_argument('--embed_size', type=int, default=128, help='Size of the face embedding.') parser.add_argument('--snap', type=str, required=True, help='Snapshot to convert.') parser.add_argument('--device', '-d', default=0, type=int, help='Device for model placement.') parser.add_argument('--model', choices=list(models_backbones.keys()) + list(models_landmarks.keys()), type=str, default='rmnet') # IE-related options parser.add_argument('--ie_model', type=str, required=True) parser.add_argument( "-l", "--cpu_extension", help= "MKLDNN (CPU)-targeted custom layers.Absolute path to a shared library with the kernels " "impl.", type=str, default=None) parser.add_argument("-pp", "--plugin_dir", help="Path to a plugin folder", type=str, default=None) parser.add_argument( "-d_ie", "--device_ie", help= "Specify the target device to infer on; CPU, GPU, FPGA or MYRIAD is acceptable. Sample " "will look for a suitable plugin for device specified (CPU by default)", default="CPU", type=str) args = parser.parse_args() max_err = 0. with torch.cuda.device(args.device): if args.model in models_landmarks.keys(): pt_model = models_landmarks[args.model] else: pt_model = models_backbones[args.model]( embedding_size=args.embed_size, feature=True) pt_model = load_model_state(pt_model, args.snap, args.device) ie_model = load_ie_model(args.ie_model, args.device_ie, args.plugin_dir, args.cpu_extension) np.random.seed(0) for _ in tqdm(range(100)): input_img = np.random.randint(0, high=255, size=(*pt_model.get_input_res(), 3), dtype=np.uint8) input_bgr = cv.cvtColor(input_img, cv.COLOR_BGR2RGB) input_pt = torch.unsqueeze(torch.from_numpy( input_img.transpose(2, 0, 1).astype('float32') / 255.).cuda(), dim=0) pt_output = (pt_model(input_pt)).data.cpu().numpy().reshape(1, -1) ie_output = ie_model.forward(input_bgr).reshape(1, -1) max_err = max(np.linalg.norm(pt_output - ie_output, np.inf), max_err) log.info('Max l_inf error: %e', max_err)