def build_data_parallel_model(model, single_gpu_build_func): """Build a data parallel model given a function that builds the model on a single GPU. """ if model.only_build_forward_pass: single_gpu_build_func(model) elif model.train: all_loss_gradients = _build_forward_graph(model, single_gpu_build_func) # Add backward pass on all GPUs # 添加反向传播操作 model.AddGradientOperators(all_loss_gradients) if cfg.NUM_GPUS > 1: _add_allreduce_graph(model) for gpu_id in range(cfg.NUM_GPUS): # After allreduce, all GPUs perform SGD updates on their identical # params and gradients in parallel # 添加参数更新操作 with c2_utils.NamedCudaScope(gpu_id): add_single_gpu_param_update_ops(model, gpu_id) else: # Test-time network operates on single GPU # Test-time parallelism is implemented through multiprocessing with c2_utils.NamedCudaScope(model.target_gpu_id): single_gpu_build_func(model)
def run_model_cfg(args, im, check_blobs): workspace.ResetWorkspace() model, _ = load_model(args) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = test_engine.im_detect_all( model, im, None, None, ) boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) # sort the results based on score for comparision boxes, segms, keypoints, classes = _sort_results( boxes, segms, keypoints, classes) # write final results back to workspace def _ornone(res): return np.array(res) if res is not None else np.array([], dtype=np.float32) with c2_utils.NamedCudaScope(0): workspace.FeedBlob(core.ScopedName('result_boxes'), _ornone(boxes)) workspace.FeedBlob(core.ScopedName('result_segms'), _ornone(segms)) workspace.FeedBlob(core.ScopedName('result_keypoints'), _ornone(keypoints)) workspace.FeedBlob(core.ScopedName('result_classids'), _ornone(classes)) # get result blobs with c2_utils.NamedCudaScope(0): ret = _get_result_blobs(check_blobs) return ret
def build_data_parallel_model(model, single_gpu_build_func): """Build a data parallel model given a function that builds the model on a single GPU. """ if model.only_build_forward_pass: single_gpu_build_func(model) elif model.train: all_loss_gradients = _build_forward_graph(model, single_gpu_build_func) # Add backward pass on all GPUs grad_map = model.AddGradientOperators(all_loss_gradients) #if cfg.CLIP: # keys = [] # for key in model.TrainableParams(): # k = str(key) # if 'bbox_pred_std' in k: # keys.append(k) # if 'bbox_pred_phi' in k: # keys.append(k) # #bbox_pred_fpn # #if 'bbox_pred' in k: # # keys.append(k) # #grad_map_for_param = {key: grad_map[key] for key in keys} # grad_map_for_param = {str(key): grad_map[str(key)] for key in model.TrainableParams()} # net_modifier = GradientClipping( # grad_clip_method='by_value', # clip_max=1., # clip_min=-1., # #blobs_to_include=None, # ) # #net_modifier = GradientClipping( # # grad_clip_method='by_norm', # # clip_norm_type='l2_norm', # # clip_threshold=0.1, # # #blobs_to_include=None, # #) # net_modifier(model.net, grad_map=grad_map_for_param) if cfg.NUM_GPUS > 1: _add_allreduce_graph(model) for gpu_id in range(cfg.NUM_GPUS): # After allreduce, all GPUs perform SGD updates on their identical # params and gradients in parallel with c2_utils.NamedCudaScope(gpu_id): add_single_gpu_param_update_ops(model, gpu_id) else: # Test-time network operates on single GPU # Test-time parallelism is implemented through multiprocessing with c2_utils.NamedCudaScope(model.target_gpu_id): single_gpu_build_func(model)
def __getitem__(self, idx): im_name = 'DensePoseData/demo_data/xyz.jpg' output_dir = 'DensePoseData/' img_name1 = os.path.join(self.root_dir1, self.landmarks_frame.iloc[idx, 0]) image1 = cv2.imread(img_name1) img_name2 = os.path.join(self.root_dir2, self.landmarks_frame.iloc[idx, 1]) image2 = cv2.imread(img_name2) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( self.model, image1, None, timers=self.timers) im1 = vis_utils.vis_one_image( image1[:, :, ::-1], # BGR -> RGB for visualization im_name, output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( self.model, image2, None, timers=self.timers) im2 = vis_utils.vis_one_image( image2[:, :, ::-1], # BGR -> RGB for visualization im_name, output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) image3 = cv2.merge((image1, im1, im2)) sample = {'image1': image1, 'image2': image2, 'image3': image3} if self.transform: sample = self.transform(sample) return sample
def detect(self, frame): timers = defaultdict(Timer) mask_frame = frame with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.model, mask_frame, None, timers=timers) # verifica se a imagem deve ser descartada boxes, sgms, keypts, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) bbox_list = [] if len(boxes) > 0: indexes_big = box_utils.filter_big_boxes(boxes, 300) indexes_small = box_utils.filter_small_boxes(boxes, 100) for i in range(len(boxes)): if (i in indexes_big and i in indexes_small): if classes[i] in [1, 2, 3] and boxes[i, 4] > 0.7: box = boxes[i] bbox_list.append([ int(box[0]), int(box[1]), int(box[2]) - int(box[0]), int(box[3]) - int(box[1]) ], classes[i]) # mask_frame = vis_utils.vis_one_image_opencv(mask_frame, cls_boxes, cls_segms, cls_keyps, thresh=0.8, kp_thresh=2, # show_box=True, dataset=CocoNames, show_class=True) #, hiden_indexes=True, indexes_shown=[1]) return bbox_list
def hanle_frame(args, frameId, im, logger, model, dataset): #out_name = os.path.join( # args.output_dir, '{}'.format(frameId + '.pdf') #) logger.info('Processing frame: {}'.format(frameId)) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if frameId == 1: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization '{}'.format(frameId), args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2)
def extract_iuv(image_path, model, infer_engine): im = cv2.imread(image_path) dummy_coco_dataset = dummy_datasets.get_coco_dataset() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, im, None ) iuv_out = vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization None, None, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 ) return iuv_out
def process_images( args_weights, args_im_or_folder, args_image_ext ): assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args_weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args_im_or_folder): im_list = glob.iglob(args_im_or_folder + '/*.' + args_image_ext) else: im_list = [args_im_or_folder] for i, im_name in enumerate(im_list): im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) boxes, segms, keyps, classes = vis_utils.convert_from_cls_format(cls_boxes, cls_segms, cls_keyps) if classes is not None: class_strs = [dummy_coco_dataset.classes[c] for c in classes] im_name = im_name.split('/')[-1].split('.'+args_image_ext)[0] yield im_name, boxes, segms, class_strs, im.shape[:2]
def process_image(input_file, output_file): #image = stringToImage(input_img[input_img.find(",")+1:]) #img = cv2.imread('stylegan/narrow/13.test.jpg') #img = cv2.imread('stylegan/curated/231.jpg') img = cv2.imread(input_file) #img = toRGB(image) #logger.info(input_file) timers = defaultdict(Timer) t = time.time() size = img.shape[:2] with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, img, None, timers=timers) t2 = time.time() #logger.info('Inference time: {:.3f}s'.format(t2 - t)) if cls_bodys is not None: (final, num_people) = process_bodies(img, cls_boxes, cls_bodys) if final is not None: if num_people > 4: output_file = output_file + 'X.jpg' else: output_file = output_file + '.jpg' cv2.imwrite(output_file, final) return True else: #print('Skipping') return False else: #print('Skipping') return False
def main(input_img, with_pix2pix=False): image = stringToImage(input_img[input_img.find(",") + 1:]) img = toRGB(image) logger.info('Processing {} -> {}'.format('New Image', 'Output...')) timers = defaultdict(Timer) t = time.time() size = img.shape[:2] with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, img, None, timers=timers) for key, timer in timers.items(): print(key, timer.total_time) t2 = time.time() r = vis_one_image(img, 'testImage', output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) t3 = time.time() if with_pix2pix: r = requests.post(pix2pixURL, data={'data': r}) logger.info('Inference time: {:.3f}s'.format(t2 - t)) logger.info('Visualization time: {:.3f}s'.format(t3 - t2)) logger.info('Pix2pix time: {:.3f}s'.format(time.time() - t3)) return r
def generate_predicitions_from_frames(images, config_file, weights): """Generator yields inferred boxes and keypoints for each image in a provided iterable of images Args: images: iterable images config_file: Detectron configuration file weights: pretrained weights Returns: yields i, im, cls_boxes, cls_segms, cls_keyps """ logger = logging.getLogger(__name__) merge_cfg_from_file(config_file) cfg.NUM_GPUS = 1 weights = cache_url(weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(weights) for i, im in enumerate(images): logger.info("Processing frame {}".format(i)) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info("Inference time: {:.3f}s".format(time.time() - t)) for k, v in timers.items(): logger.info(" | {}: {:.3f}s".format(k, v.average_time)) if i == 0: logger.info( "Note: inference on the first image will be slower than the " "rest (caches and auto-tuning need to warm up)" ) yield i, im, cls_boxes, cls_segms, cls_keyps
def infer(self, im, thresh=0.5): ts = time.time() timers = defaultdict(Timer) with c2_utils.NamedCudaScope(self.gpu_id): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.__model, im, None, timers=timers) te = time.time() print('det time:', te - ts) for k, v in timers.items(): print(' | {}: {:.3f}s'.format(k, v.average_time)) if isinstance(cls_boxes, list): boxes, segms, keypoints, classes = cvt_cls(cls_boxes, cls_segms, cls_keyps) if boxes is None or boxes.shape[0] == 0 or max(boxes[:, 4]) < thresh: return None heads = list() for i in range(len(boxes)): bbox = boxes[i, :4] score = boxes[i, -1] if score < thresh: continue heads.append([int(x) for x in bbox] + [float(score)]) return heads
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg(args.weights) dummy_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): logger.info('Processing {}'.format(im_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_scores, _, _ = infer_engine.im_detect_all(model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) cl = np.argmax(cls_scores) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) logger.info(' | Class is: {}'.format(dummy_dataset.classes[cl])) logger.info(' | Class Confidance is: {:.2f}%'.format( cls_scores[cl] * 100)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)')
def process_image(input_image, num_of_people, num_of_permutations): timers = defaultdict(Timer) t = time.time() image = stringToImage(input_image[input_image.find(",")+1:]) img = toRGB(image) size = img.shape[:2] with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, img, None, timers=timers ) t2 = time.time() #logger.info('Inference time: {:.3f}s'.format(t2 - t)) jpgs = [] if cls_bodys is not None: (finals,num_people) = process_bodies(img, cls_boxes, cls_bodys, num_of_people, num_of_permutations) logger.info('Num of people {}'.format(num_people)) if len(finals) > 0: for final in finals: retval, buffer = cv2.imencode('.jpg', final) jpg_as_text = base64.b64encode(buffer) jpgs.append(jpg_as_text) else: print('Skipping') else: print('Skipping') return jpgs
def add_training_inputs(model, roidb=None): """Create network input ops and blobs used for training. To be called *after* model_builder.create(). """ # Implementation notes: # Typically, one would create the input ops and then the rest of the net. # However, creating the input ops depends on loading the dataset, which # can take a few minutes for COCO. # We prefer to avoid waiting so debugging can fail fast. # Thus, we create the net *without input ops* prior to loading the # dataset, and then add the input ops after loading the dataset. # Since we defer input op creation, we need to do a little bit of surgery # to place the input ops at the start of the network op list. assert model.train, 'Training inputs can only be added to a trainable model' if roidb is not None: # To make debugging easier you can set cfg.DATA_LOADER.NUM_THREADS = 1 model.roi_data_loader = RoIDataLoader( roidb, num_loaders=cfg.DATA_LOADER.NUM_THREADS, minibatch_queue_size=cfg.DATA_LOADER.MINIBATCH_QUEUE_SIZE, blobs_queue_capacity=cfg.DATA_LOADER.BLOBS_QUEUE_CAPACITY) orig_num_op = len(model.net._net.op) blob_names = roi_data_minibatch.get_minibatch_blob_names(is_training=True) for gpu_id in range(cfg.NUM_GPUS): with c2_utils.NamedCudaScope(gpu_id): for blob_name in blob_names: workspace.CreateBlob(core.ScopedName(blob_name)) model.net.DequeueBlobs(model.roi_data_loader._blobs_queue_name, blob_names) # A little op surgery to move input ops to the start of the net diff = len(model.net._net.op) - orig_num_op new_op = model.net._net.op[-diff:] + model.net._net.op[:-diff] del model.net._net.op[:] model.net._net.op.extend(new_op)
def extract_person(image, background_image, model, dataset): timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, image, None, timers=timers) boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps, ) masks = mask_util.decode(segms) masks = np.moveaxis(masks, 2, 0) output_image = np.copy(background_image) for box, mask, c, in zip(boxes, masks, classes): score = box[-1] if score < 0.9: continue if dataset.classes[c] != 'person': continue idx = np.where(mask != 0) output_image[idx[0], idx[1], :] = image[idx[0], idx[1], :] return output_image
def main(input_img): image = stringToImage(input_img[input_img.find(",") + 1:]) img = toRGB(image) logger.info('Processing {} -> {}'.format('New Image', 'Output...')) timers = defaultdict(Timer) t = time.time() size = img.shape[:2] #img = imresize(img, (320, 240), interp='bilinear') with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, img, None, timers=timers) for key, timer in timers.items(): print(key, timer.total_time) t2 = time.time() densepose_img = vis_one_image(img, 'testImage', output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) logger.info('Inference time: {:.3f}s'.format(t2 - t)) return densepose_img
def single_process(args, dummy_coco_dataset, im, im_name, model): timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) # if i == 0: # logger.info( # ' \ Note: inference on the first image will be slower than the ' # 'rest (caches and auto-tuning need to warm up)' # ) print("预测结果:", cls_boxes, cls_segms, cls_keyps) new_img = vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=args.thresh, kp_thresh=args.kp_thresh, ext=args.output_ext, out_when_no_box=args.out_when_no_box) return new_img
def test_net(weights_file, dataset_name, ind_range=None, gpu_id=0): roidb, dataset, start_ind, end_ind, total_num_images = get_roidb_and_dataset( dataset_name, ind_range) model = initialize_model_from_cfg(weights_file, gpu_id=gpu_id) num_images = len(roidb) num_classes = cfg.MODEL.NUM_CLASSES all_boxes = empty_results(num_classes, num_images) timers = defaultdict(Timer) result = {} for i, entry in enumerate(roidb): box_proposals = None im = cv2.imread(entry['image']) # print(entry['image']) # im_name = os.path.splitext(os.path.basename(entry['image']))[0] im_result = {} im_result['fileName'] = entry['file_name'] im_result['imageId'] = str(entry['id']) # print(entry['file_name']) with c2_utils.NamedCudaScope(gpu_id): cls_boxes_i, uc = im_detect_all(model, im, box_proposals, timers) entry['entropy'] = uc # print(uc) # entry['result'] = cls_boxes_i # entropy.append(entropy_i) ## all_boxes cls_box_result = {} for cls_idx in range(1, len(cls_boxes_i)): if (len(cls_boxes_i[cls_idx])) == 0: continue cls_box_result[str(cls_idx)] = [] for box_idx in cls_boxes_i[cls_idx]: box_i = {} box_i['x'] = int(box_idx[0]) box_i['y'] = int(box_idx[1]) box_i['w'] = int(box_idx[2] - box_idx[0]) box_i['h'] = int(box_idx[3] - box_idx[1]) box_i['score'] = float(box_idx[4]) cls_box_result[str(cls_idx)].append(box_i) extend_results(i, all_boxes, cls_boxes_i) im_result['annotation'] = cls_box_result im_result['uncertainty'] = entry['entropy'] result[str(im_result['imageId'])] = im_result if i % 10 == 0: # Reduce log file size ave_total_time = np.sum([t.average_time for t in timers.values()]) eta_seconds = ave_total_time * (num_images - i - 1) eta = str(datetime.timedelta(seconds=int(eta_seconds))) det_time = (timers['im_detect_bbox'].average_time + timers['im_detect_mask'].average_time + timers['im_detect_keypoints'].average_time) misc_time = (timers['misc_bbox'].average_time + timers['misc_mask'].average_time + timers['misc_keypoints'].average_time) logger.info(('im_detect: range [{:d}, {:d}] of {:d}: ' '{:d}/{:d} {:.3f}s + {:.3f}s (eta: {})').format( start_ind + 1, end_ind, total_num_images, start_ind + i + 1, start_ind + num_images, det_time, misc_time, eta)) print(result) return roidb, result
def create(model_type_func, train=False, gpu_id=0): """Generic model creation function that dispatches to specific model building functions. By default, this function will generate a data parallel model configured to run on cfg.NUM_GPUS devices. However, you can restrict it to build a model targeted to a specific GPU by specifying gpu_id. This is used by optimizer.build_data_parallel_model() during test time. """ model = DetectionModelHelper( name=model_type_func, train=train, num_classes=cfg.MODEL.NUM_CLASSES, init_params=(train or cfg.VIS_NET) ) model.only_build_forward_pass = False model.target_gpu_id = gpu_id model = get_func(model_type_func)(model) # Stop gradient at specified nodes if len(cfg.TRAIN.FREEZE_BLOBS): blob_references = [] for gpu_id in range(cfg.NUM_GPUS): with c2_utils.NamedCudaScope(gpu_id): for blob_name in cfg.TRAIN.FREEZE_BLOBS: try: blob_references.append(model.net.GetBlobRef(core.ScopedName(blob_name))) except KeyError, e: logger.warn('Failed to freeze blob. {}'.format(e)) if not cfg.CONTINUE_ON_ERROR: raise for blob_ref in blob_references: logger.info('Freezing blob. {}'.format(blob_ref)) model.StopGradient(blob_ref, blob_ref)
def main(args): logger = logging.getLogger(__name__) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = load_cfg(envu.yaml_dump(cfg)) im = cv2.imread(args.im_file) if args.rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args) workspace.ResetWorkspace() else: proposal_boxes = None cls_boxes, cls_segms, cls_keyps, cls_bodys = None, None, None, None for i in range(0, len(args.models_to_run), 2): pkl = args.models_to_run[i] yml = args.models_to_run[i + 1] cfg.immutable(False) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ , cls_bodys_= \ model_engine.im_detect_all(model, im, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps cls_bodys = cls_bodys_ if cls_bodys_ is not None else cls_bodys workspace.ResetWorkspace() out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(args.im_file) + '.pdf')) logger.info('Processing {} -> {}'.format(args.im_file, out_name)) with open('test_vis.pkl', 'w') as f: pickle.dump( { 'im': im, 'cls_boxes': np.array(cls_boxes), 'cls_bodys': np.array(cls_bodys) }, f) vis_utils.vis_one_image(im[:, :, ::-1], args.im_file, args.output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2)
def getKptByModel(self, image, thresh=0.7): top_labels = [] top_xmin = [] top_ymin = [] top_xmax = [] top_ymax = [] top_scores = [] timers = defaultdict(Timer) # with c2_utils.NamedCudaScope(0): # cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( # self.model, image, None, timers=timers # ) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.model, image, None, timers=timers) # boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(cls_boxes, cls_segms, cls_keyps) image = vis_utils.vis_one_image_opencv(image, cls_boxes, cls_segms, cls_keyps, dataset=None, show_class=True, thresh=0.7, kp_thresh=2) # try: # print (keypoints) # except: # pass return image
def get_detections_from_im(cfg, model, im, image_id, feat_blob_name, MIN_BOXES, MAX_BOXES, conf_thresh=0.2, bboxes=None): with c2_utils.NamedCudaScope(0): scores, cls_boxes, im_scale = infer_engine.im_detect_bbox(model, im, cfg.TEST.SCALE, cfg.TEST.MAX_SIZE, boxes=bboxes) feat_map = workspace.FetchBlob("gpu_0/res5_2_branch2c") box_features = workspace.FetchBlob(feat_blob_name) cls_prob = workspace.FetchBlob("gpu_0/cls_prob") rois = workspace.FetchBlob("gpu_0/rois") max_conf = np.zeros((rois.shape[0])) # unscale back to raw image space cls_boxes = rois[:, 1:5] / im_scale for cls_ind in range(1, cls_prob.shape[1]): cls_scores = scores[:, cls_ind] dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32) keep = np.array(nms(dets, cfg.TEST.NMS)) max_conf[keep] = np.where(cls_scores[keep] > max_conf[keep], cls_scores[keep], max_conf[keep]) keep_boxes = np.where(max_conf >= conf_thresh)[0] if len(keep_boxes) < MIN_BOXES: keep_boxes = np.argsort(max_conf)[::-1][:MIN_BOXES] elif len(keep_boxes) > MAX_BOXES: keep_boxes = np.argsort(max_conf)[::-1][:MAX_BOXES] objects = np.argmax(cls_prob[keep_boxes], axis=1) img_shape = [np.size(im, 0), np.size(im, 1)] return feat_map, box_features[keep_boxes], cls_boxes[keep_boxes], np.array(img_shape)
def find_optimal_bars(image_directory, layer): model = get_model() im_list = glob.iglob(image_directory + '/*.jpg') im_list = [x for x in im_list] # so we can get length max_sd_per_map = [None] * len(im_list) for i, im_name in enumerate(im_list): print('processing {}'.format(im_name)) im = cv2.imread(im_name) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=None) responses = workspace.blobs['gpu_0/{}'.format(layer)] sd = [] for i in range(responses.shape[0]): sd.append(np.std(responses[i, :, :, :])) max_sd_across_boxes = responses[np.argmax(sd), :, :, :] # stimuli aren't processed in order, so get index from file name bar_name = os.path.basename(im_name)[3:-4] bar_num = int(bar_name) max_sd_per_map[bar_num] = np.max(np.max(max_sd_across_boxes, axis=-1), axis=-1) max_sd_per_map = np.array(max_sd_per_map) result = np.argmax(max_sd_per_map, axis=0) print result # TODO: check this return result
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): output_image_dir = os.path.join(args.output_dir, 'images') out_name = os.path.join( output_image_dir, '{}'.format(os.path.basename(im_name) + '.' + args.output_ext)) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') # vis_utils.vis_one_image( # im[:, :, ::-1], # BGR -> RGB for visualization # im_name, # output_image_dir, # cls_boxes, # cls_segms, # cls_keyps, # dataset=dummy_coco_dataset, # box_alpha=0.3, # show_class=True, # thresh=0.7, # kp_thresh=2, # ext=args.output_ext, # out_when_no_box=args.out_when_no_box #) _write_to_txt(cls_boxes, cls_segms, cls_keyps, im_name, dummy_coco_dataset)
def _build_forward_graph(model, single_gpu_build_func): """Construct the forward graph on each GPU.""" all_loss_gradients = {} # Will include loss gradients from all GPUs # Build the model on each GPU with correct name and device scoping for gpu_id in range(cfg.NUM_GPUS): with c2_utils.NamedCudaScope(gpu_id): all_loss_gradients.update(single_gpu_build_func(model)) return all_loss_gradients
def main(args): logger = logging.getLogger(__name__) dummy_nucoco_dataset = dummy_datasets.get_nucoco_dataset() cfg_orig = load_cfg(envu.yaml_dump(cfg)) ## Load image coco = COCO_PLUS(args.ann_file, args.imgs_dir) image_id = coco.dataset['images'][args.im_ind]['id'] img_path = os.path.join(args.imgs_dir, coco.imgs[image_id]["file_name"]) im = cv2.imread(img_path) ## Get the proposals for this image proposals = rrpn_loader(args.rpn_pkl) proposal_boxes = proposals[image_id]['boxes'] _proposal_scores = proposals[image_id]['scores'] workspace.ResetWorkspace() ## run models cls_boxes, cls_segms, cls_keyps = None, None, None for i in range(0, len(args.models_to_run), 2): pkl = args.models_to_run[i] yml = args.models_to_run[i + 1] cfg.immutable(False) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ = \ model_engine.im_detect_all(model, im, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps workspace.ResetWorkspace() out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(img_path) + '.pdf') ) logger.info('Processing {} -> {}'.format(img_path, out_name)) vis_utils.vis_one_image( im[:, :, ::-1], img_path, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_nucoco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 )
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() submit_result = [] result_file_name = 'detectron_val_result.txt' if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') result = vis_utils.vis_one_image_bbox( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) if result: submit_result.extend(result) logger.info('Image {}.'.format(i)) # Write file with open(result_file_name, 'wb') as result_file: for item in submit_result: result_file.write("%s\n" % item) logger.info( 'The result file has been written in {}.'.format(result_file_name))
def main(args): #logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cam = cv2.VideoCapture(0) # Set Texture Tex_Atlas = cv2.imread( 'DensePoseData/demo_data/texture_from_SURREAL.png')[:, :, ::-1] / 255.0 #Tex_Atlas = cv2.imread('DensePoseData/demo_data/texture_atlas_200.png')[:,:,::-1] TextureIm = np.zeros([24, 200, 200, 3]) # for i in range(4): for j in range(6): TextureIm[(6 * i + j), :, :, :] = Tex_Atlas[(200 * j):(200 * j + 200), (200 * i):(200 * i + 200), :] while True: if cv2.waitKey(1) & 0xFF == ord('q'): break retval, im = cam.read() #imsmall = cv2.resize(im, None, fx=0.5, fy=0.5) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, im, None, timers=None) iuvout, indsout = vis_utils.vis_webcam(im, cls_boxes, cls_segms, cls_keyps, cls_bodys, thresh=0.9, kp_thresh=2, dataset=dummy_coco_dataset, show_class=True) iuvout, indsout = vis_utils.vis_webcam( im, boxes=cls_boxes, segms=cls_segms, keypoints=cls_keyps, body_uv=cls_bodys, thresh=0.9, kp_thresh=2, dpi=200, box_alpha=0.3, dataset=dummy_coco_dataset, show_class=True, ) #cv2.imshow('input', im) texout = TransferTexturePure(TextureIm, im, iuvout) cv2.imshow('output', texout)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 4 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) # model = infer_engine.initialize_model_from_cfg(args.weights,gpu_id=3) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] len_str = str(len(os.listdir(args.im_or_folder))) for i, im_name in enumerate(im_list): print('~~~~~~~~~~~~~~~~~' + str(i) + '/' + len_str + "~~~~~~~~~~~~~~~~~~~~~") out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.jpg')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( #此处输出的cls_boxes包含类别信息 model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') # ipdb.set_trace() # print(cls_boxes) # print(cls_segms) # print(cls_keyps) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.5, kp_thresh=2, ext='jpg')