def __init__(self): self.cfg = rospy.get_param('~cfg', 'e2e_mask_rcnn_R-101-FPN_2x.yaml') self.wts = rospy.get_param('~wts', 'model_final.pkl') self.train_wts = rospy.get_param('~train_wts', 'R-101.pkl') self.confidence = rospy.get_param('~confidence', 0.9) self.sub_img_topic = rospy.get_param('~sub_img_topic', "image_rect_color") self.frame_rate = rospy.get_param('~frame_rate', 30) self.gpu_id = rospy.get_param('~gpu_id', 0) self.mask_on = rospy.get_param('~mask_on', True) merge_cfg_from_file(self.cfg) cfg.NUM_GPUS = 2 cfg.MODEL.MASK_ON = True cfg.TRAIN.WEIGHTS = self.train_wts assert_and_infer_cfg() utils.logging.setup_logging(__name__) self.logger = logging.getLogger(__name__) self.model = infer_engine.initialize_model_from_cfg(self.wts, gpu_id=self.gpu_id) self.model1 = infer_engine.initialize_model_from_cfg(self.wts, gpu_id=1) self.dummy_coco_dataset = dummy_datasets.get_coco_dataset() self.pupil_subscriber = rospy.Subscriber('/scene/left/fit_point', ImagePoint, self.pupil_callback, queue_size=1) self.image_subscriber = rospy.Subscriber(self.sub_img_topic, Image, self.callback, queue_size=1) # self.compressed_image_subscriber = rospy.Subscriber(self.sub_img_topic+"/compressed", CompressedImage, self.compimgcallback, queue_size=1) self.pub_bboxes_topic = rospy.resolve_name( self.sub_img_topic) + '/bboxes' print("Mask RCNN Initialized") self.bboxes_publisher = rospy.Publisher(self.pub_bboxes_topic, BBoxDetArray, queue_size=1) self.pub_img_topic = self.sub_img_topic + "_detection" self.image_publisher = rospy.Publisher(self.pub_img_topic, Image, queue_size=20) self.bridge = CvBridge() self.last_detect = rospy.Time.now() self.fit_point = []
def main(name_scope, gpu_dev, num_images, args): t=args.t model = initialize_model_from_cfg() num_classes = cfg.MODEL.NUM_CLASSES all_boxes, all_segms, all_keyps = empty_results(num_classes, num_images) temp_frame_folder = osp.join(args.out_path,args.vid_name + '_frames/',str(t)) imgs = glob.glob(temp_frame_folder+'/*.jpg') for i in range(len(imgs)): if i%100==0: print('Processing Detection for Frame %d'%(i+1)) im_ = cv2.imread(imgs[i]) assert im_ is not None im_ = np.expand_dims(im_, 0) with core.NameScope(name_scope): with core.DeviceScope(gpu_dev): cls_boxes_i, cls_segms_i, cls_keyps_i = im_detect_all( model, im_, None) #TODO: Parallelize detection extend_results(i, all_boxes, cls_boxes_i) if cls_segms_i is not None: extend_results(i, all_segms, cls_segms_i) if cls_keyps_i is not None: extend_results(i, all_keyps, cls_keyps_i) det_name = args.vid_name + '_' + str(args.t) + '_detections.pkl' det_file = osp.join(args.out_path, det_name) robust_pickle_dump(dict(all_keyps=all_keyps),det_file) shutil.rmtree(osp.join(args.out_path, args.vid_name + '_frames'))
def main(): args = parser.parse_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() 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): #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) hintDataURL = bottle.request.forms.get("hint") hintDataURL = re.sub('^data:image/.+;base64,', '', hintDataURL) hintDataURL = base64.urlsafe_b64decode(hintDataURL.encode("ascii")) hintDataURL = np.fromstring(hintDataURL, dtype=np.uint8) hintDataURL = cv2.imdecode(hintDataURL, -1) hstr = str(np.random.randint(100, 999)) cv2.imwrite('record/' + hstr + '.hint.png', hintDataURL) im = cv2.imread('record/' + hstr + '.hint.png') 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) return 'ok'
def main(args): merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 # get the weight path 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() det_dir = os.path.join(args.input_dir, 'det') if not os.path.exists(det_dir): os.makedirs(det_dir) txt_file = os.path.join(det_dir, "det.txt") fid = open(txt_file, 'w') img_dir = os.path.join(args.input_dir, "img1") img_list = os.listdir(img_dir) img_list = sorted(img_list) for i in range(len(img_list)): print("processing: %d/%d" % (i + 1, len(img_list))) img_name = img_list[i][:-4] img_idx = int(img_name) img_path = os.path.join(img_dir, img_list[i]) frame = cv2.imread(img_path) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, frame, None, None) vis_utils.write_txt(fid, img_idx, cls_boxes) fid.close()
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() dummy_dataset = dummy_datasets.get_cifar100_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 main(args): 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() cap = cv2.VideoCapture(0) while True: ret, frame = cap.read() timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, frame, None, timers=timers) image = vis_utils.vis_one_image_opencv(np.array(frame), cls_boxes, cls_segms, cls_keyps, thresh=0.7, kp_thresh=2, show_box=True, show_class=True) cv2.imshow('camera', image) if cv2.waitKey(1) & 0xFF == ord('q'): break print("Time:", time.time() - t) cap.release() cv2.destroyAllWindows()
def get_rpn_box_proposals(im, args): cfg.immutable(False) """Load a yaml config file and merge it into the global config.""" merge_cfg_from_file(args.rpn_cfg) '''Number of GPUs to use (applies to both training and testing)''' cfg.NUM_GPUS = 1 '''Indicates the model's computation terminates with the production of RPN proposals (i.e., it outputs proposals ONLY, no actual object detections)''' cfg.MODEL.RPN_ONLY = True '''Number of top scoring RPN proposals to keep before applying NMS When FPN is used, this is *per FPN level* (not total)''' cfg.TEST.RPN_PRE_NMS_TOP_N = 10000 '''Number of top scoring RPN proposals to keep after applying NMS his is the total number of RPN proposals produced (for both FPN and non-FPN cases)''' cfg.TEST.RPN_POST_NMS_TOP_N = 2000 '''Call this function in your script after you have finished setting all cfg values that are necessary (e.g., merging a config from a file, merging command line config options, etc.)''' assert_and_infer_cfg() """Initialize a model from the global cfg. Loads test-time weights and creates the networks in the Caffe2 workspace. """ model = model_engine.initialize_model_from_cfg(args.rpn_pkl) with c2_utils.NamedCudaScope(0): """Generate RPN proposals on a single image.""" boxes, scores = rpn_engine.im_proposals(model, im) return boxes, scores
def __init__(self, cfg_path, weights_path): #nms_same_class 0.3 ---- *.yaml/TEST:NMS:0.3 中设置 defalut 0.5 self.gpu_id = 1 #gpu_id default 0 self.score_thresh = 0.4 #score > score_thresh default 0.3 self.per_class_thresh = False #score > class_score_thresh self.autotruck_score_thresh = 0.6 self.forklift_score_thresh = 0.65 self.digger_score_thresh = 0.65 self.car_score_thresh = 0.45 self.bus_score_thresh = 0.0 self.tanker_score_thresh = 0.55 self.person_score_thresh = 0.35 self.minitruck_score_thresh = 0.0 self.minibus_score_thresh = 0.59 self.class_nms_thresh = 0.85 #nms_between_classes IOU > class_nms_thresh default 0.9 merge_cfg_from_file(cfg_path) self.model = infer_engine.initialize_model_from_cfg( weights_path, self.gpu_id) self.dummy_coco_dataset = dummy_datasets.get_steal_oil_class14_dataset( ) print("model is ok")
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() #jasonj #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): 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): #jasonj cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, "infer_res.jpg", 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)')
def build_graph(self): c2_utils.import_detectron_ops() # OpenCL may be enabled by default in OpenCV3; disable it because it's not # thread safe and causes unwanted GPU memory allocations. cv2.ocl.setUseOpenCL(False) merge_cfg_from_file(self.config.args['config_path']) # If this is a CPU kernel, tell Caffe2 that it should not use # any GPUs for its graph operations cpu_only = True for handle in self.config.devices: if handle.type == DeviceType.GPU.value: cpu_only = False if cpu_only: cfg.NUM_GPUS = 0 else: cfg.NUM_GPUS = 1 # TODO: wrap this in "with device" weights_path = cache_url(self.config.args['weights_path'], cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(weights_path) return model
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() dummy_coco_dataset = dummy_datasets.get_coco_dataset() video_frame_length = video_frame(args) #Yunhan Yang pass in a list to save all the frames print ("The video has length " + str(video_frame_length) + " frames") f_image_path = args.im_or_folder+ "frame%d.jpg" % 0 fr = cv2.imread(f_image_path, 0) origin_width, origin_height = fr.shape[:2] for x in range(0,video_frame_length): im_list = [args.im_or_folder+"frame" + str(x) + ".jpg"] #Yunhan Yang have to save frame in real folder and then read in #maybe need need double for loop for list of frames 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)' ) #Yunhan Yang edit if not os.path.exists(args.im_or_folder+ "/video"): os.makedirs(args.im_or_folder+ "/video") #Yunhan Yang edit Detectron/lib/utils/vis.py add make result as jpg than pdf 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.7, kp_thresh=2 )
def _test_std(self): root_dir = osp.join('/private', 'home', 'xinleic', 'pyramid') cfg_file = osp.join(root_dir, 'configs', 'visual_genome', 'e2e_faster_rcnn_R-50-FPN_1x.yaml') merge_cfg_from_file(cfg_file) cfg.NUM_GPUS = 1 cfg.TEST.RPN_PRE_NMS_TOP_N = 100 cfg.TEST.RPN_POST_NMS_TOP_N = 20 assert_and_infer_cfg() test_weight = osp.join(root_dir, 'outputs', 'train', 'visual_genome_train', 'e2e_faster_rcnn_R-50-FPN_1x', 'RNG_SEED#3', 'model_final.pkl') model = test_engine.initialize_model_from_cfg(test_weight, gpu_id=0) dataset = JsonDataset('visual_genome_val') roidb = dataset.get_roidb() num_images = len(roidb) num_classes = cfg.MODEL.NUM_CLASSES entry = roidb[1] im = cv2.imread(entry['image']) max_level = cfg.FPN.RPN_MAX_LEVEL min_level = cfg.FPN.RPN_MIN_LEVEL # input: rpn_cls_probs_fpn2, rpn_bbox_pred_fpn2 # output: rpn_rois_fpn2, rpn_roi_probs_fpn2 with utils.c2.NamedCudaScope(0): # let's manually do the testing here inputs, im_scale = _get_blobs(im, None, cfg.TEST.SCALE, cfg.TEST.MAX_SIZE) for k, v in inputs.items(): workspace.FeedBlob(core.ScopedName(k), v) workspace.RunNet(model.net.Proto().name) cls_probs = [core.ScopedName('rpn_cls_probs_fpn%d' % i) for i in range(min_level, max_level+1)] box_preds = [core.ScopedName('rpn_bbox_pred_fpn%d' % i) for i in range(min_level, max_level+1)] rpn_rois = [core.ScopedName('rpn_rois_fpn%d' % i) for i in range(min_level, max_level+1)] rpn_roi_probs = [core.ScopedName('rpn_roi_probs_fpn%d' % i) for i in range(min_level, max_level+1)] cls_probs = workspace.FetchBlobs(cls_probs) box_preds = workspace.FetchBlobs(box_preds) rpn_rois = workspace.FetchBlobs(rpn_rois) rpn_roi_probs = workspace.FetchBlobs(rpn_roi_probs) rpn_rois = np.vstack(rpn_rois) rpn_roi_probs = np.vstack(rpn_roi_probs) # remove the image dimension rpn_rois = rpn_rois[:, 1:] boxes = np.hstack([rpn_rois, rpn_roi_probs]) im_name = osp.splitext(osp.basename(entry['image']))[0] utils.vis.vis_one_image(im[:, :, ::-1], '{:s}-std-output'.format(im_name), osp.join(root_dir, 'tests'), boxes, segms=None, keypoints=None, thresh=0., box_alpha=0.8, dataset=dataset, show_class=False) workspace.ResetWorkspace() im_info = inputs['im_info'].astype(np.float32) return cls_probs, box_preds, im_info, im, im_name, root_dir, dataset
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 cfg.TRAIN.IMS_PER_BATCH = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() 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): 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, \ cls_refined_segms, cls_refined_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, os.path.join(args.output_dir, 'vis_local'), cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, os.path.join(args.output_dir, 'vis_refined'), cls_boxes, cls_refined_segms, cls_refined_keyps, dataset=dummy_coco_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.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg() 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): 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)') t1 = time.time() im = vis_utils.vis_one_image_opencv(im, cls_boxes, segms=cls_segms, keypoints=cls_keyps, thresh=0.7, kp_thresh=2, show_box=True, dataset=dummy_coco_dataset, show_class=True) # 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.7, # kp_thresh=2 # ) t2 = time.time() - t1 print("vis time %f ms" % (t2 * 1000)) cv2.imwrite( args.output_dir + '/' + im_name.split('/')[-1].split('.')[0] + '.jpg', im)
def get_model(cfg_file, weights_file): merge_cfg_from_file(cfg_file) cfg.TRAIN.WEIGHTS = '' # NOTE: do not download pretrained model weights cfg.TEST.WEIGHTS = weights_file cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() return model
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() 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): # out_name = os.path.join( # args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf') # ) # logger.info('Processing {} -> {}'.format(im_name, out_name)) #set webcam cam = cv2.VideoCapture(0) while True: #Fetch image from camera ret_val, im = cam.read() #uncomment to resize image #im = cv2.resize(im, (1200,1024)) 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 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 "dummy_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 ) cv2.destroyAllWindows()
def __init__(self, config, **kwargs): kwargs['handlers'] = [(r'/analyse', AnalyseHandler)] super(Application, self).__init__(**kwargs) merge_cfg_from_file(config.get('DETECTRON', 'CONFIG')) cfg.TEST.WEIGHTS = config.get('DETECTRON', 'WEIGHTS') cfg.NUM_GPUS = 1 assert_and_infer_cfg() self.model = infer_engine.initialize_model_from_cfg() self.dummy_coco_dataset = dummy_datasets.get_coco_dataset()
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() predict_dataset(args.project, visualize=False, randomize=False)
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) start = timeit.default_timer() 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] ##extract bboxes from bottom-up attention model image_bboxes = {} if args.bbox_file is not None: image_bboxes = extract_bboxes(args.bbox_file) count = 0 if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) for i, im_name in enumerate(im_list): im_base_name = os.path.basename(im_name) image_id = int(im_base_name.split(".")[0].split("_")[-1]) ##for COCO if image_id % args.total_group == args.group_id: bbox = image_bboxes[image_id] if image_id in image_bboxes else None im = cv2.imread(im_name) if im is not None: outfile = os.path.join(args.output_dir, im_base_name.replace('jpg', 'npy')) lock_folder = outfile.replace('npy', 'lock') if not os.path.exists(lock_folder) and os.path.exists(outfile): continue if not os.path.exists(lock_folder): os.makedirs(lock_folder) result = get_detections_from_im(cfg, model, im, image_id, args.feat_name, args.min_bboxes, args.max_bboxes, bboxes=bbox) np.save(outfile, result) os.rmdir(lock_folder) count += 1 if count % 100 == 0: end = timeit.default_timer() epoch_time = end - start print('process {:d} images after {:.1f} s'.format( count, epoch_time))
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 logger.info('about to assert') assert_and_infer_cfg() logger.info('About to initialise model') model = infer_engine.initialize_model_from_cfg() logger.info("Done initialising") 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): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.png')) 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)') segmented_images, classes, scores, segmented_binary_masks = vis_utils.segmented_images_in_original_image_size( im, 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) found = False for index, value in enumerate(segmented_images): if classes[index] == args.class_label and not found: logger.info('Writing output file to: {}'.format(str(i))) bin_mask = vis_utils.vis_binary_mask( im, segmented_binary_masks[index]) cv2.imwrite(out_name, value) cv2.imwrite(out_name.rstrip(".png") + "bin.png", bin_mask) found = True
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() 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] """ Add support for webcam """ # Set and get camera from OpenCV cam = cv2.VideoCapture(0) im_name = 'tmp_im' while True: # Fetch image from camera _, im = cam.read() 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 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, 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, ext='jpg' # default is PDF, but we want JPG. ) cv2.destroyAllWindows()
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() 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) im_list = search(args.im_or_folder, args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): #for i, im_name in im_list: #out_name = os.path.join( # args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf') #) out_name = im_name.replace(args.im_or_folder, args.output_dir) par_path = os.path.dirname(out_name) if not os.path.exists(par_path): os.makedirs(par_path) 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, par_path, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2, ext='png' )
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_vg3k_dataset() if args.use_vg3k else dummy_datasets.get_coco_dataset()) if os.path.isdir(args.im_or_folder): im_list = sorted(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) + '.npz') ) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) if im is None: logger.info('Unable to read image, skipping.') continue 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)' ) boxes, segms, classes = convert(cls_boxes, cls_segms) classes = np.array(classes, dtype=np.uint16) resolution = segms[0]['size'] segms = np.array([x['counts'] for x in segms]) # Run-length encoding valid = boxes[:, 4] >= args.thresh if args.filter_classes: valid &= np.isin(classes, all_classes) boxes = boxes[valid].copy() classes = classes[valid].copy() segms = segms[valid].copy() output_name = os.path.basename(im_name) np.savez(args.output_dir + '/' + output_name, boxes=boxes, segments=segms, classes=classes, resolution=resolution)
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() 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] test_ids = [] rles = [] 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)') new_test_ids, new_rles = vis_utils.make_submission(im[:, :, ::-1], im_name, cls_boxes, cls_segms, cls_keyps, thresh=0.7) test_ids.extend(new_test_ids) rles.extend(new_rles) import pandas as pd sub = pd.DataFrame() sub['ImageId'] = test_ids sub['EncodedPixels'] = pd.Series(rles).apply( lambda x: ' '.join(str(y) for y in x)) sub.to_csv(args.output_dir + '/e2e_mask_rcnn_R-50-FPN_1x-lr3e-3-nuclei-6-new.csv', index=False)
def main(args): logger = logging.getLogger(__name__) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = yaml.load(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 = 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() 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(args.im_file) + '.pdf') ) logger.info('Processing {} -> {}'.format(args.im_file, out_name)) vis_utils.vis_one_image( im[:, :, ::-1], args.im_file, 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 )
def get_rpn_box_proposals(im, args): merge_cfg_from_file(args.rpn_cfg) cfg.TEST.WEIGHTS = args.rpn_pkl cfg.NUM_GPUS = 1 cfg.MODEL.RPN_ONLY = True cfg.TEST.RPN_PRE_NMS_TOP_N = 10000 cfg.TEST.RPN_POST_NMS_TOP_N = 2000 assert_and_infer_cfg() model = model_engine.initialize_model_from_cfg() with c2_utils.NamedCudaScope(0): boxes, scores = rpn_engine.im_proposals(model, im) return boxes, scores
def get_rpn_box_proposals(im, args): merge_cfg_from_file(args.rpn_cfg) cfg.TEST.WEIGHTS = args.rpn_pkl cfg.NUM_GPUS = 1 cfg.MODEL.RPN_ONLY = True cfg.TEST.RPN_PRE_NMS_TOP_N = 10000 cfg.TEST.RPN_POST_NMS_TOP_N = 2000 assert_and_infer_cfg() model = model_engine.initialize_model_from_cfg() with c2_utils.NamedCudaScope(0): boxes, scores = rpn_engine.im_proposals(model, im) return boxes, scores
def __init__(self): c2_utils.import_detectron_ops() # OpenCL may be enabled by default in OpenCV3; disable it because it's not # thread safe and causes unwanted GPU memory allocations. cv2.ocl.setUseOpenCL(False) merge_cfg_from_file( '/home/king/Documents/measurement/detectron/configs/12_2017_baselines/e2e_keypoint_rcnn_X-101-32x8d-FPN_s1x.yaml' ) cfg.NUM_GPUS = 1 weights = '/home/king/Documents/measurement/model_final.pkl' assert_and_infer_cfg(cache_urls=False) self.model = infer_engine.initialize_model_from_cfg(weights)
def main(args): logger = logging.getLogger(__name__) args.cfg = '/detectron/configs/12_2017_baselines/e2e_mask_rcnn_R-101-FPN_2x.yaml' args.weights = '/data/workspace/fbdet/models/mask_rcnn_R_101_FPN_2x/model_final.pkl' 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() 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] im_list = [] im_list.append('/data/workspace/fbdet/test_pic/11.jpg') video = cv2.VideoCapture('/data/pic/valid_video_00.avi') frame = 0 while (True): if frame > 0: break # ret, im = video.read() # if im is None or ret is None: # print("video.read() fail || video.read() is end!") # break im = cv2.imread(im_list[0]) 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)) print('-----------------------------', frame) boxs_list = vis_utils.get_boxes_image(cls_boxes, cls_segms, cls_keyps, thresh=0.7, dataset=dummy_coco_dataset) print(boxs_list) print('-----------------------------') for i in range(len(boxs_list)): box = boxs_list[i] drawBoxOnImg(im, box[1], box[2], box[3], box[4], 0, 0, frame) frame += 1
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() for root_dir_path_1, sub_dir_path_list_1, sub_file_path_list_1 in os.walk( args.im_or_folder): sub_dir_path_list_1 = sorted(sub_dir_path_list_1) for i, sub_dir_path_1 in enumerate(sub_dir_path_list_1): for root_dir_path_2, sub_dir_path_list_2, sub_file_path_list_2 in os.walk( os.path.join(root_dir_path_1, sub_dir_path_1)): sub_file_path_list_2 = sorted(sub_file_path_list_2) out_file = open( os.path.join(args.output_dir, sub_dir_path_1 + "_Det_ffasta.txt"), "wb") for img_idx, sub_file_path_2 in enumerate( sub_file_path_list_2): im = cv2.imread( os.path.join(root_dir_path_2, sub_file_path_2)) timers = defaultdict(Timer) t = time.time() if (img_idx + 1) % 1000 == 0: sys.stdout.write( "\rFinish {} images\n".format(img_idx + 1)) sys.stdout.flush() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) if isinstance(cls_boxes, list): cls_boxes, cls_segms, cls_keyps, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) if cls_boxes is None or cls_boxes.shape[0] == 0: continue obj_idx = 0 for cls_box, cls in zip(cls_boxes, classes): if int(cls) != 3 and int(cls) != 6: continue out_file.write("{},{},{},{},{},{},{}\n".format( img_idx + 1, obj_idx + 1, cls_box[0], cls_box[1], cls_box[2] - cls_box[0], cls_box[3] - cls_box[1], cls_box[4])) obj_idx += 1 out_file.close() print("Finish {} / {} of video sequences".format( i + 1, len(sub_dir_path_list_1))) break
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() 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): 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)' ) 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.7, kp_thresh=2 )
def main(): logger = logging.getLogger(__name__) merge_cfg_from_file('/detectron/e2e_mask_rcnn_R-101-FPN_2x.yaml') cfg.NUM_GPUS = 4 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg('/detectron/models/model_final.pkl') dummy_coco_dataset = dummy_datasets.get_coco_dataset() # cam = cv2.VideoCapture("rtsp://192.168.128.12:554/mpeg4cif") # cam = cv2.VideoCapture("rtsp://192.168.128.11:554/av0_1") # cam = cv2.VideoCapture("http://192.168.128.14/video.cgi") n = 0 tmp_file_name = '/tmp/tmp.jpg' im0 = 0 im1 = 0 while True: # ret_val, im = cam.read() # cv2.imwrite(tmp_file_name, im) im = cv2.imread('/detectron/k2m30/img/' + str(n) + '.jpg') timers = defaultdict(Timer) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) data = vis_utils.vis_one_image_opencv( im, # BGR -> RGB for visualization cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, # box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2, # ext='png' ) # time.sleep(0.1) # if data == None: # logger.info(cls_boxes) # # else: n += 1 n = n % 1000 file_name = '/tmp/' + str(n) + '.jpg' cv2.imwrite(file_name, data) logger.info(str(n) + ' saved') logger.info(os.path.getsize(file_name))
def main(args): dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = yaml.load(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 = 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] merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: cfg.TEST.WEIGHTS = pkl cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = model_engine.initialize_model_from_cfg() 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() vis_utils.vis_one_image( im[:, :, ::-1], args.im_file, 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 )
def load_model(args): model = test_engine.initialize_model_from_cfg() blobs = mutils.get_ws_blobs() return model, blobs