def __init__(self, cfg, weight_dict=None, extra_features=0): super(DepthRCNN, self).__init__() # Weight losses if weight_dict is None: self.weight_dict = { 'loss_objectness': cfg.LOSS_WEIGHTS.loss_objectness, 'loss_rpn_box_reg': cfg.LOSS_WEIGHTS.loss_rpn_box_reg, 'loss_classifier': cfg.LOSS_WEIGHTS.loss_classifier, 'loss_box_reg': cfg.LOSS_WEIGHTS.loss_box_reg, 'loss_mask': cfg.LOSS_WEIGHTS.loss_mask } else: self.weight_dict = weight_dict self.image_backbone = build_backbone(cfg) self.freeze_backbone(self.image_backbone, cfg.MODEL.BACKBONE.FREEZE_CONV_BODY_AT) self.roi_heads = None if cfg.MODEL.BACKBONE.DEPTH: self.hha_backbone = build_backbone(cfg) self.freeze_backbone(self.hha_backbone, cfg.MODEL.BACKBONE.FREEZE_CONV_BODY_AT) self.rpn = build_rpn( cfg, self.image_backbone.out_channels * 2 + extra_features) if not cfg.MODEL.RPN_ONLY: self.roi_heads = build_roi_heads( cfg, self.image_backbone.out_channels * 2 + extra_features) else: self.hha_backbone = None self.rpn = build_rpn( cfg, self.image_backbone.out_channels + extra_features) if not cfg.MODEL.RPN_ONLY: self.roi_heads = build_roi_heads( cfg, self.image_backbone.out_channels + extra_features)
def test_build_shufflenet_backbones(self): ''' Make sure backbones run ''' self.assertGreater(len(registry.BACKBONES), 0) name = "ShuffleNetV2" print('Testing {}...'.format(name)) if name in BACKBONE_CFGS: cfg = load_config(BACKBONE_CFGS[name]) else: # Use default config if config file is not specified cfg = copy.deepcopy(g_cfg) backbone = build_backbone(cfg) # make sures the backbone has `out_channels` self.assertIsNotNone( getattr(backbone, 'out_channels', None), 'Need to provide out_channels for backbone {}'.format(name)) N, C_in, H, W = 2, 3, 224, 256 input = torch.rand([N, C_in, H, W], dtype=torch.float32) out = backbone(input) for cur_out in out: self.assertEqual(cur_out.shape[:2], torch.Size([N, backbone.out_channels]))
def __init__(self, exp_dict): super().__init__() cfg_base_path = "./models/configs/" self.n_classes = 21 cfg_path = cfg_base_path + "e2e_mask_rcnn_R_50_FPN_1x.yaml" self.cfg = cfg self.cfg.merge_from_file(cfg_path) self.cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES = self.n_classes # --------------- # build model self.backbone_fpn = backbone.build_backbone(self.cfg) self.rpn = rpn.build_rpn(self.cfg, self.backbone_fpn.out_channels) self.roi_heads = roi_heads.build_roi_heads( self.cfg, self.backbone_fpn.out_channels) # --------------- # load checkpoint checkpoint = _load_file(self.cfg) load_state_dict(self, checkpoint.pop("model")) #-------- # Opt stage self.cfg.SOLVER.BASE_LR = ((0.0025 * 8) / (16 / float(exp_dict["batch_size"]))) optimizer = make_optimizer(self.cfg, self) scheduler = make_lr_scheduler(self.cfg, optimizer) self.opt = optimizer self.scheduler = scheduler
def init_maskrcnn_benchmark(self, args): if 'datasets' in sys.modules: del sys.modules['datasets'] this_dir = os.path.dirname(__file__) lib_path = os.path.join(this_dir, '../../external/maskrcnn-benchmark') sys.path.insert(0, lib_path) # config from maskrcnn_benchmark.utils.env import setup_environment # noqa F401 isort:skip from maskrcnn_benchmark.config import cfg self.cfg = cfg #cfg.MODEL.BACKBONE.OUT_CHANNELS = 832 #cfg.MODEL.RESNETS.RES2_OUT_CHANNELS = 208 cfg.MODEL.RPN.PRE_NMS_TOP_N_TEST = 6000 cfg.MODEL.RPN.POST_NMS_TOP_N_TEST = 1000 cfg.MODEL.ROI_HEADS.SCORE_THRESH = 0 cfg.MODEL.ROI_HEADS.DETECTIONS_PER_IMG = 0 # bind classes/methods from MaskRCNN-Benchmark from maskrcnn_benchmark.modeling.rpn.rpn import build_rpn from maskrcnn_benchmark.modeling.roi_heads.roi_heads import build_roi_heads from maskrcnn_benchmark.structures.image_list import to_image_list from maskrcnn_benchmark.structures.bounding_box import BoxList from maskrcnn_benchmark.modeling.backbone import build_backbone self.basenet = build_backbone(cfg) self.rpn = build_rpn(cfg) self.roi_heads = build_roi_heads(cfg) self.to_image_list = to_image_list self.BoxList = BoxList
def __init__(self, cfg): super(RelationPredictor, self).__init__(cfg) self.cfg = cfg self.device = cfg.MODEL.DEVICE self.detector_pre_calculated = self.cfg.MODEL.ROI_RELATION_HEAD.DETECTOR_PRE_CALCULATED self.detector_force_boxes = self.cfg.MODEL.ROI_BOX_HEAD.FORCE_BOXES self.cfg_check() feature_dim = self.backbone.out_channels if not self.cfg.MODEL.ROI_RELATION_HEAD.SHARE_CONV_BACKBONE: self.rel_backbone = build_backbone(cfg) feature_dim = self.rel_backbone.out_channels self.force_relations = cfg.MODEL.ROI_RELATION_HEAD.FORCE_RELATIONS if cfg.MODEL.RELATION_ON and self.cfg.MODEL.ROI_RELATION_HEAD.ALGORITHM in SCENE_MODEL_DICT: self.relation_head = build_roi_relation_head(cfg, feature_dim) if cfg.MODEL.ATTRIBUTE_ON: self.attribute_head = build_roi_attribute_head(cfg, feature_dim) # self._freeze_components(self.cfg) for p in self.backbone.parameters(): p.requires_grad = False for p in self.rpn.parameters(): p.requires_grad = False for p in self.roi_heads.parameters(): p.requires_grad = False if not self.cfg.MODEL.ROI_RELATION_HEAD.SHARE_BOX_FEATURE_EXTRACTOR: if self.cfg.MODEL.ROI_RELATION_HEAD.SEPERATE_SO_FEATURE_EXTRACTOR: self.subj_feature_extractor = make_roi_relation_box_feature_extractor(cfg, feature_dim) self.obj_feature_extractor = make_roi_relation_box_feature_extractor(cfg, feature_dim) else: self.obj_feature_extractor = make_roi_relation_box_feature_extractor(cfg, feature_dim)
def __init__(self, cfg): super(GeneralizedRCNN, self).__init__() self.backbone = build_backbone(cfg) self.rpn = build_rpn(cfg, self.backbone.out_channels) self.roi_heads = build_roi_heads(cfg, self.backbone.out_channels) self.feature_extractor = make_roi_box_feature_extractor( cfg, self.backbone.out_channels)
def __init__(self, cfg): super(PanopticModel, self).__init__() self.backbone = build_backbone(cfg) self.loss = SegLoss() self.training = True self.rpn = build_rpn(cfg, self.backbone.out_channels) self.roi_heads = build_roi_heads(cfg, self.backbone.out_channels) self.panoptic = PanopticRCNN( cfg, num_classes=cfg.MODEL.PANOPTIC.NUM_CLASSES)
def optimal_bias_init(cfg, bias): device = torch.device(cfg.MODEL.DEVICE) arch = request_arch(cfg) if 'retinanet' in arch: anchor_generator = make_anchor_generator_retinanet(cfg) fg_iou, bg_iou = cfg.MODEL.RETINANET.FG_IOU_THRESHOLD, cfg.MODEL.RETINANET.BG_IOU_THRESHOLD num_classes = cfg.MODEL.RETINANET.NUM_CLASSES - 1 num_anchors = len(cfg.MODEL.RETINANET.ASPECT_RATIOS) \ * cfg.MODEL.RETINANET.SCALES_PER_OCTAVE else: assert 'faster_rcnn' in arch anchor_generator = make_anchor_generator(cfg) fg_iou, bg_iou = cfg.MODEL.RPN.FG_IOU_THRESHOLD, cfg.MODEL.RPN.BG_IOU_THRESHOLD num_classes = 1 num_anchors = anchor_generator.num_anchors_per_location()[0] prior = load_prior(cfg, arch) if prior is not None: nn.init.constant_(bias, -log((1 - prior) / prior)) return data_loader = make_init_data_loader( cfg, is_distributed=True, images_per_batch=cfg.SOLVER.IMS_PER_BATCH) proposal_matcher = Matcher( fg_iou, bg_iou, allow_low_quality_matches=True, ) backbone = build_backbone(cfg).to(device) num_fg, num_all = 0, 0 num_gpus = get_num_gpus() for images, targets, _ in tqdm(data_loader): images = images.to(device) targets = [target.to(device) for target in targets] h, w = images.tensors.shape[-2:] if num_all == 0: features = backbone(images.tensors) n, c = features[0].shape[:2] levels = len(features) stride = int(h / features[0].shape[2]) features = [ torch.zeros(n, c, int(ceil(h / (stride * 2**i))), int(ceil(w / (stride * 2**i))), device=device) for i in range(levels) ] anchors = anchor_generator(images, features) anchors = [ cat_boxlist(anchors_per_image).to(device) for anchors_per_image in anchors ] for anchor, target in zip(anchors, targets): match_quality_matrix = boxlist_iou(target, anchor) matched_idxs = proposal_matcher(match_quality_matrix) num_fg_per_image, num_bg_per_image = (matched_idxs >= 0).sum(), ( matched_idxs == Matcher.BELOW_LOW_THRESHOLD).sum() num_fg += num_fg_per_image num_all += num_fg_per_image + num_bg_per_image fg_all_ratio = reduce_div(num_fg.float(), num_all.float()).item() prior = fg_all_ratio / num_classes nn.init.constant_(bias, -log((1 - prior) / prior)) if torch.cuda.current_device() == 0: save_prior(cfg, prior, arch)
def __init__(self, cfg): super(GeneralizedRCNN, self).__init__() self.backbone = build_backbone(cfg) self.rpn = build_rpn(cfg, self.backbone.out_channels)