def benchmark_train(args): cfg = setup(args) model = build_model(cfg) logger.info("Model:\n{}".format(model)) if comm.get_world_size() > 1: model = DistributedDataParallel(model, device_ids=[comm.get_local_rank()], broadcast_buffers=False) optimizer = build_optimizer(cfg, model) checkpointer = DetectionCheckpointer(model, optimizer=optimizer) checkpointer.load(cfg.MODEL.WEIGHTS) cfg.defrost() cfg.DATALOADER.NUM_WORKERS = 2 data_loader = build_detection_train_loader(cfg) dummy_data = list(itertools.islice(data_loader, 100)) def f(): data = DatasetFromList(dummy_data, copy=False, serialize=False) while True: yield from data max_iter = 400 trainer = (AMPTrainer if cfg.SOLVER.AMP.ENABLED else SimpleTrainer)( model, f(), optimizer) trainer.register_hooks([ hooks.IterationTimer(), hooks.PeriodicWriter([CommonMetricPrinter(max_iter)]), hooks.TorchProfiler(lambda trainer: trainer.iter == max_iter - 1, cfg.OUTPUT_DIR, save_tensorboard=True), ]) trainer.train(1, max_iter)
def __init__(self, bgr=True, gpu_device='cuda:0', **kwargs): ''' Params ------ - gpu_device : str, "cpu" or "cuda:0" or "cuda:1" ''' self.__dict__.update(self._defaults) # for portability between keras-yolo3/yolo.py and this if 'model_path' in kwargs: kwargs['weights'] = kwargs['model_path'] if 'score' in kwargs: kwargs['thresh'] = kwargs['score'] self.__dict__.update(kwargs) # if cuda_device is None: # self.device = "cpu" # else: # self.device = "cuda:{}".format(cuda_device) self.device = gpu_device cfg, self.class_names = setup(self.__dict__) self.cfg = cfg.clone() # cfg can be modified by model self.model = build_model(self.cfg) self.model.eval() checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.transform_gen = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST ) # If not specified, input size into network is min 800 and max 1333 self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format print('Model expects images in {} format, but dn worry, this object takes care of that for you, just be init it correctly when you instantiate this object'.format(self.input_format)) self.flip_channels = ( bgr == (self.input_format=='RGB') ) # warm up self._detect([np.zeros((10,10,3), dtype=np.uint8)]) print('Warmed up!')
def __init__(self, cfg, detectron_config, img_height, img_width): """ Initialize the predictor :param cfg: the demo cfg :param detectron_config: a prepared detectron2 config file :param img_height: (int) the image height of the original image :param img_width: (int) the image wight of the original image """ self.cfg = cfg self.detectron_config = detectron_config.clone( ) # detectron_config can be modified by model self.model = build_model(self.detectron_config) self.model.eval() self.metadata = MetadataCatalog.get(detectron_config.DATASETS.TEST[0]) # Load weights checkpointer = DetectionCheckpointer(self.model) checkpointer.load(detectron_config.MODEL.WEIGHTS) # Compute rescaling options once for speed improvement self.original_img_height = img_height self.original_img_width = img_width # The size of the short side and whether rescaling is required self.new_short_side, self.rescale_image = self.calculate_short_side() # used in filter_person_boxes self.cpu_device = torch.device("cpu") self.input_format = detectron_config.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__( self, cfg: CfgNode, n_iter=150, gamma=0.5, nms_thresh=0.9, mapper: Callable = DatasetMapper, ): """Implements the DAG algorithm Parameters ---------- cfg : CfgNode Config object used to train the model n_iter : int, optional Number of iterations to run the algorithm on each image, by default 150 gamma : float, optional Perturbation weight, by default 0.5 nms_thresh : float, optional NMS threshold of RPN; higher it is, more dense set of proposals, by default 0.9 mapper : Callable, optional Can specify own DatasetMapper logic, by default DatasetMapper """ self.n_iter = n_iter self.gamma = gamma # Modify config self.cfg = cfg.clone() # cfg can be modified by model # To generate more dense proposals self.cfg.MODEL.RPN.NMS_THRESH = nms_thresh self.cfg.MODEL.RPN.POST_NMS_TOPK_TEST = 3000 # Init model self.model = build_model(self.cfg) self.model.eval() # Load weights checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.aug = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST) self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format # Init dataloader on training dataset dataset_mapper = mapper(cfg, is_train=False) # self.data_loader = build_detection_test_loader( # cfg, cfg.DATASETS['TRAIN'][0], mapper=dataset_mapper # ) self.data_loader = build_detection_test_loader(cfg, "benign_train", mapper=dataset_mapper) self.device = self.model.device self.n_classes = self.cfg.MODEL.ROI_HEADS.NUM_CLASSES self.metadata = MetadataCatalog.get(self.cfg.DATASETS.TRAIN[0]) # HACK Only specific for this dataset self.metadata.thing_classes = ["box", "logo"]
def benchmark_train(args): cfg = setup(args) model = build_model(cfg) logger.info("Model:\n{}".format(model)) if comm.get_world_size() > 1: model = DistributedDataParallel( model, device_ids=[comm.get_local_rank()], broadcast_buffers=False ) optimizer = build_optimizer(cfg, model) checkpointer = DetectionCheckpointer(model, optimizer=optimizer) checkpointer.load(cfg.MODEL.WEIGHTS) cfg.defrost() cfg.DATALOADER.NUM_WORKERS = 0 data_loader = build_detection_train_loader(cfg) dummy_data = list(itertools.islice(data_loader, 100)) def f(): while True: yield from DatasetFromList(dummy_data, copy=False) max_iter = 400 trainer = SimpleTrainer(model, f(), optimizer) trainer.register_hooks( [hooks.IterationTimer(), hooks.PeriodicWriter([CommonMetricPrinter(max_iter)])] ) trainer.train(1, max_iter)
def test_detectron2_artifact_pack(detectron2_classifier_class): cfg = get_cfg() # add project-specific config (e.g., TensorMask) # here if you're not running a model in detectron2's core library cfg.merge_from_file( model_zoo.get_config_file( "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml" ) ) cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model # Find a model from detectron2's model zoo. # You can use the https://dl.fbaipublicfiles... url as well cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url( "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml" ) clone_cfg = cfg.clone() # cfg can be modified by model clone_cfg.MODEL.DEVICE = "cpu" model = build_model(clone_cfg) model.eval() checkpointer = DetectionCheckpointer(model) checkpointer.load(cfg.MODEL.WEIGHTS) image = imageio.imread('http://images.cocodataset.org/val2017/000000439715.jpg') image = image[:, :, ::-1] svc = detectron2_classifier_class() svc.pack('model', model) response = svc.predict(image) assert response['scores'][0] > 0.9 comparison = np.array(response['classes']) == np.array( [17, 0, 0, 0, 0, 0, 0, 0, 25, 0, 25, 25, 0, 0, 24] ) assert comparison.all()
def __init__(self, cfg, category2id, standard2id, aug=None, output_dir=None): if output_dir is not None: if not os.path.exists(output_dir): os.makedirs(output_dir) self.output_dir = output_dir self.cfg = cfg.clone() self.model = build_model(self.cfg) self.model.eval() self.id2catrgory = {v: k for k, v in category2id.items()} self.id2standard = {v: k for k, v in standard2id.items()} checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) if aug is None: aug = custom_aug.ResizeWithPad( (self.cfg.INPUT.MIN_SIZE_TEST, self.cfg.INPUT.MAX_SIZE_TEST)) self.aug = aug self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format
def get_panoptic_network(opts, cfg_file, net_path): cfg = setup(opts, cfg_file) net = build_model(cfg) checkpointer = DetectionCheckpointer(net) checkpointer.load(net_path) net.train() return net
def __init__(self, cfg): self.hook_output = 0 def hook(module, input, output): self.hook_output = output self.cfg = cfg.clone() # cfg can be modified by model self.model = build_model(self.cfg) self.model.eval() self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0]) # Extract features # print(self.model) roi_head_mod = list(self.model.children())[2] # print("*******1") # print(roi_head_mod) feature = list(roi_head_mod.children())[1] # print("*******2") # print(roi_pooling_mod) feature.register_forward_hook(hook) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.transform_gen = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST) self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format
def get_model(cfg): model = build_model(cfg) model.eval() checkpointer = DetectionCheckpointer(model) checkpointer.load(cfg.MODEL.WEIGHTS) return model
def load_model_for_inference(cfg): print('pytorch_classifier.py: Loading model...') model = build_model(cfg) # returns a torch.nn.Module model.eval() checkpointer = DetectionCheckpointer(model) checkpointer.load(cfg.MODEL.WEIGHTS) # ; suppresses long output return model
def __init__(self, cfg_path, num_obj=37, threshold=0.01): self.cfg = get_cfg() self.cfg.merge_from_file(model_zoo.get_config_file(cfg_path)) self.cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(cfg_path) self.cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = threshold self.cfg.TEST.DETECTIONS_PER_IMAGE = num_obj self.model = build_model(self.cfg) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(self.cfg.MODEL.WEIGHTS)
def main(args): setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) print(cfg) # 构建模型 model = build_model(cfg) print(model) for name, module in model.named_modules(): print(name) # 加载权重 checkpointer = DetectionCheckpointer(model) checkpointer.load(cfg.MODEL.WEIGHTS) # 加载图像 path = os.path.expanduser(args.input) original_image = read_image(path, format="BGR") height, width = original_image.shape[:2] transform_gen = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST ) image = transform_gen.get_transform(original_image).apply_image(original_image) image = torch.as_tensor(image.astype("float32").transpose(2, 0, 1)).requires_grad_(True) inputs = {"image": image, "height": height, "width": width} # Grad-CAM layer_name = args.layer_name grad_cam = GradCAM(model, layer_name) mask, box, class_id = grad_cam(inputs) # cam mask grad_cam.remove_handlers() # image_dict = {} img = original_image[..., ::-1] x1, y1, x2, y2 = box image_dict['predict_box'] = img[y1:y2, x1:x2] image_cam, image_dict['heatmap'] = gen_cam(img[y1:y2, x1:x2], mask[y1:y2, x1:x2]) # Grad-CAM++ grad_cam_plus_plus = GradCamPlusPlus(model, layer_name) mask_plus_plus = grad_cam_plus_plus(inputs) # cam mask _, image_dict['heatmap++'] = gen_cam(img[y1:y2, x1:x2], mask_plus_plus[y1:y2, x1:x2]) grad_cam_plus_plus.remove_handlers() save_image(image_dict, os.path.basename(path), args.layer_name) # 获取类别名称 meta = MetadataCatalog.get( cfg.DATASETS.TEST[0] if len(cfg.DATASETS.TEST) else "__unused" ) label = meta.thing_classes[class_id] print("label:{}".format(label))
def main(cfg): # Build Dataloader dataset = ImageDataset(cfg) loader = torch.utils.data.DataLoader(dataset, batch_size=16, shuffle=False, num_workers=8, pin_memory=True, drop_last=False, collate_fn=collate_fn) # Bulid Model model = build_model(cfg) checkpointer = DetectionCheckpointer(model) checkpointer.load(cfg.MODEL.WEIGHTS) model.eval() box_num, human_num = 0, 0 all_boxes = {} for inputs in tqdm(loader, ncols=80): with torch.no_grad(): result = model(inputs) for bidx in range(len(inputs)): im_path = inputs[bidx]['im_path'] width = inputs[bidx]['width'] height = inputs[bidx]['height'] vid, fid = im_path.split('/')[-2:] fidx = int(fid.replace('.jpg', '')) if vid not in all_boxes: all_boxes[vid] = {} if fidx not in all_boxes[vid]: all_boxes[vid][fidx] = [] pred_class = result[bidx]["instances"].pred_classes.cpu().tolist( ) # 0: human pred_boxes = result[bidx]["instances"].pred_boxes.tensor.cpu( ).tolist() pred_scores = result[bidx]["instances"].scores.cpu().tolist() for cls, box, score in zip(pred_class, pred_boxes, pred_scores): all_boxes[vid][fidx].append({ 'class': cls, 'box': (box[0] / width, box[1] / height, box[2] / width, box[3] / height), 'score': score }) if cls == 0: human_num += 1 box_num += len(pred_class) print('box_num', box_num, 'human_num', human_num) with open(os.path.join(cfg.ANNO_DIR, cfg.SPLIT + '_pred_bboxes.pkl'), 'wb') as f: pickle.dump(all_boxes, f)
def build_model(self, cfg, eval_only=False): # cfg may need to be reused to build trace model again, thus clone model = build_model(cfg.clone()) if eval_only: checkpointer = DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR) checkpointer.load(cfg.MODEL.WEIGHTS) model.eval() return model
def __init__(self, cfg): self.cfg = cfg.clone() # cfg can be modified by model self.model = build_model(self.cfg) self.model.eval() self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0]) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.model = GeneralizedRCNNWithTTA(cfg, self.model) self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format
def initialize_model(): """Initialize the global model variable to the pretrained EfficientDet. This assumes that the EfficientDet model has already been downloaded to a specific path, as done in the Dockerfile for this example. """ #model_dir = '/Developer/MyRepo/mymodels/tfssdresnet50_1024_ckpt100k/saved_model' #model_dir = '/Developer/MyRepo/mymodels/detectron2models' #modelfilename = 'model_0819999.pth' #load saved model global model global config global model_dir cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file(config)) #cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/"+modelname+".yaml" ))#faster_rcnn_X_101_32x8d_FPN_3x #self.cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml"))#faster_rcnn_X_101_32x8d_FPN_3x #cfg.merge_from_file('faster_rcnn_R_101_C4_3x.yaml')#Tridentnet #cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/retinanet_R_101_FPN_3x.yaml")) #cfg.DATASETS.TRAIN = ("myuav1_train",) #cfg.DATASETS.TEST = ("myuav1_val",) cfg.DATALOADER.NUM_WORKERS = 1 #2 #cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml") # Let training initialize from model zoo cfg.MODEL.WEIGHTS = model_dir #os.path.join(model_dir, modelfilename) #model_0159999.pth if os.path.isfile(cfg.MODEL.WEIGHTS) == False: print("load checkpoint from model zoo") cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/"+modelname+".yaml") # Let training initialize from model zoo else: cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512#128 # faster, and good enough for this toy dataset (default: 512) cfg.MODEL.ROI_HEADS.NUM_CLASSES = len(classes) # Kitti has 9 classes (including donot care) #self.cfg.MODEL.WEIGHTS = os.path.join('/home/010796032/PytorchWork/output_uav', "model_0119999.pth") #model_0159999.pth #cfg.MODEL.WEIGHTS = os.path.join('/home/010796032/PytorchWork', "fasterrcnn_x101_fpn_model_final_68b088.pkl")#using the local downloaded model cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.BASE_LR = 0.00025 # pick a good LRgkyjmh, cfg.SOLVER.MAX_ITER = 100000 # you may need to train longer for a practical dataset cfg.TEST.DETECTIONS_PER_IMAGE = 50 #500 #https://github.com/facebookresearch/detectron2/blob/master/detectron2/engine/defaults.py #model = DefaultPredictor(cfg) #runs on single device for a single input image model = build_model(cfg) model.eval() checkpointer = DetectionCheckpointer(model) checkpointer.load(cfg.MODEL.WEIGHTS) print(cfg.INPUT.FORMAT) #BGR, ["RGB", "BGR"] print(cfg.INPUT.MIN_SIZE_TEST)#800 print(cfg.INPUT.MAX_SIZE_TEST)#1333 global aug aug = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST )
def __init__(self, model_params, model_weights): super(InstanceSegmentation, self).__init__() confidence_threshold = 0.05 # overwritten in forward cfg = self.setup_cfg(confidence_threshold, model_params, model_weights) self.model = build_model(cfg) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.transform_gen = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST) self.pixel_mean = torch.Tensor(cfg.MODEL.PIXEL_MEAN).view(-1, 1, 1) self.pixel_std = torch.Tensor(cfg.MODEL.PIXEL_STD).view(-1, 1, 1)
def __init__(self, cfg, gpu): self.cfg = cfg self.gpu = gpu self.model = build_model(cfg).cuda(gpu) self.model.eval() self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0]) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.transform_gen = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST ) self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg): self.cfg = cfg.clone() # cfg can be modified by model self.model = build_model(self.cfg) self.model.eval() checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.aug = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST) self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg): self.cfg = cfg.clone() # cfg can be modified by model self.model = build_model(self.cfg) self.model.eval() self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0]) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) # self.transform_gen = T.ResizeShortestEdge( # [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST # ) self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg): self.cfg = cfg.clone() # cfg can be modified by model self.model = build_model(self.cfg) self.model.eval() self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0]) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.transform_gen = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST ) self.input_format = cfg.INPUT.FORMAT # Jamie assert self.input_format in ["RGB", "BGR", "BGRT", "BGRTTT", 'UVV', 'UVM', 'BGRTUV', 'BGR_only', 'mid_RGB_out', 'BGRTTT_perturb'], self.input_format
def __init__(self, training_out_path: Path = None, cfg_path: Path = None, model_weigths_path: Path = None, threshold=0.9): if training_out_path is not None: cfg_path = training_out_path / 'config.yaml' if cfg_path is None else cfg_path model_weigths_path = training_out_path / 'model_final.pth' if model_weigths_path is None \ else model_weigths_path cfg = load_cfg_from_file(cfg_path) cfg.MODEL.WEIGHTS = str(model_weigths_path) self.cfg = cfg self.model = build_model(self.cfg).eval() checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.threshold = threshold
def __init__(self, config: str, checkpoint: str, conf_threshold: float = 0.5, **kwargs): super(DetectronRCNNPredictor).__init__() detectron2_cfg = get_cfg() detectron2_cfg.merge_from_file(config) if checkpoint is not None: detectron2_cfg.MODEL.WEIGHTS = checkpoint self.model = build_model(detectron2_cfg) self.model.eval() checkpointer = DetectionCheckpointer(self.model) checkpointer.load(detectron2_cfg.MODEL.WEIGHTS) self.transform_gen = T.ResizeShortestEdge( [detectron2_cfg.INPUT.MIN_SIZE_TEST, detectron2_cfg.INPUT.MIN_SIZE_TEST], detectron2_cfg.INPUT.MAX_SIZE_TEST ) self.conf_threshold = conf_threshold
def __init__(self, cfg, use_only_gt=False): self.cfg = cfg.clone() # cfg can be modified by model self.model = build_model(self.cfg) self.model.eval() if len(cfg.DATASETS.TEST): self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0]) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.aug = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST) self.input_format = cfg.INPUT.FORMAT self.use_only_gt = use_only_gt assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg): self.cfg = cfg.clone() # cfg can be modified by model self.model = build_model(self.cfg) self.model.eval() self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0]) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.pixel_means = np.expand_dims(np.expand_dims(cfg.MODEL.PIXEL_MEAN, axis=0), axis=0) self.normalizer = lambda x: (x - self.pixel_means).astype(np.float32) self.transform_gen = T.OpenCVResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST ) self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format
def __init__(self, cfg): self.cfg = cfg.clone() # cfg can be modified by model self.model = build_model(self.cfg) self.model.eval() print('model device: ', self.model.device) self.metadata = MetadataCatalog.get(cfg.DATASETS.TEST[0]) checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.input_format = cfg.INPUT.FORMAT assert self.input_format in ["RGB", "BGR"], self.input_format self.min_size = cfg.INPUT.MIN_SIZE_TEST self.max_size = cfg.INPUT.MAX_SIZE_TEST self.batch_size = int(cfg.IMAGES_PER_BATCH_TEST)
def __init__(self, num_classes=1): cfg = get_cfg() cfg.merge_from_file( "/content/detectron2_repo/configs/Misc/cascade_mask_rcnn_X_152_32x8d_FPN_IN5k_gn_dconv.yaml" ) cfg.MODEL.WEIGHTS = "/content/tracking_wo_bnw/model_final.pth" cfg.MODEL.MASK_ON = False cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.0 self.model = build_model(cfg) self.model.eval() self.model.cuda() self.proposal_generator = self.model.proposal_generator self.test_nms_thresh = cfg.MODEL.ROI_HEADS.NMS_THRESH_TEST checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS)
def predict(fn): cfg = get_cfg() cfg.merge_from_file( model_zoo.get_config_file( "COCO-Keypoints/keypoint_rcnn_R_50_FPN_3x.yaml")) cfg.DATALOADER.NUM_WORKERS = 2 cfg.SOLVER.IMS_PER_BATCH = 2 cfg.MODEL.DEVICE = "cpu" cfg.SOLVER.BASE_LR = 0.00025 # pick a good LR cfg.SOLVER.MAX_ITER = 300 # 300 iterations seems good enough for this toy dataset; you may need to train longer for a practical dataset cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # faster, and good enough for this toy dataset (default: 512) cfg.MODEL.ROI_HEADS.NUM_CLASSES = 2 # only has one class (ballon) cfg.MODEL.WEIGHTS = '/content/keypoints/workdir/savedmodel/model_final.pth' cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.3 # set the testing threshold for this model cfg.MODEL.ROI_KEYPOINT_HEAD.NUM_KEYPOINTS = 10 model = build_model(cfg) model.eval() checkpointer = DetectionCheckpointer(model) checkpointer.load(cfg.MODEL.WEIGHTS) imageori = cv2.imread(fn) # mywidth=600 # img = Image.open(f4) # wpercent = (mywidth/float(img.size[0])) # hsize = int((float(img.size[1])*float(wpercent))) # imageori = np.array(img.resize((mywidth,hsize), PIL.Image.ANTIALIAS)) with torch.no_grad(): original_image = imageori[:, :, ::-1] height, width = imageori.shape[:2] image = torch.as_tensor(imageori.astype("float32").transpose(2, 0, 1)) print('---', imageori.shape, height, width) inputs = {"image": image, "height": height, "width": width} outputs = model([inputs])[0] print(outputs["instances"].pred_classes) # print(outputs["instances"].pred_boxes) # print(outputs["instances"].pred_keypoints) # print(outputs["instances"].pred_keypoints.shape) MetadataCatalog.get("my_dataset_train").set(thing_classes=["table", "r"]) table_metadata = MetadataCatalog.get("my_dataset_train") v = Visualizer(imageori[:, :, ::-1], metadata=table_metadata, scale=0.8) out = v.draw_instance_predictions(outputs["instances"]) plt.figure(figsize=(100, 100)) plt.imshow(out.get_image()[:, :, ::-1])
def __init__(self, cfg_path: str, num_workers: int = 4) -> None: cfg = get_cfg() cfg.merge_from_file(model_zoo.get_config_file(cfg_path)) # NOTE: you may customize cfg settings # cfg.MODEL.DEVICE="cuda" # use gpu by default cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # Find a model from detectron2's model zoo. You can use the https://dl.fbaipublicfiles... url as well # you can also give a path to you checkpoint cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(cfg_path) self.cfg = cfg.clone() self.model = build_model(cfg) self.model.eval() checkpointer = DetectionCheckpointer(self.model) checkpointer.load(cfg.MODEL.WEIGHTS) self.aug = T.ResizeShortestEdge( [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST) self.pool = Pool(num_workers)