def __init__(self, proposal_matcher, discretization_size, use_mil_loss,
use_aff, use_box_mask):
"""
Arguments:
proposal_matcher (Matcher)
discretization_size (int)
"""
self.proposal_matcher = proposal_matcher
self.discretization_size = discretization_size
center_weight = torch.zeros((3, 3))
center_weight[1][1] = 1.
aff_weights = []
for i in range(3):
for j in range(3):
if i == 1 and j == 1:
continue
weight = torch.zeros((3, 3))
weight[i][j] = 1.
aff_weights.append(center_weight - weight)
aff_weights = [w.view(1, 1, 3, 3).to("cuda") for w in aff_weights]
self.aff_weights = torch.cat(aff_weights, 0)
self.box_coder = BoxCoder(weights=(10., 10., 5., 5.))
self.use_mil_loss = use_mil_loss
self.use_aff = use_aff
if use_box_mask:
assert not use_mil_loss
self.use_box_mask = use_box_mask
def __init__(self, cfg, in_channels):
super(GARPNModule, self).__init__()
self.cfg = cfg.clone()
anchor_generator = make_ga_anchor_generator(cfg)
rpn_head = registry.RPN_HEADS[cfg.MODEL.RPN.RPN_HEAD]
head = rpn_head(cfg, in_channels, 1)
#rpn_box_coder = BoxCoder(weights=(1.0, 1.0, 1.0, 1.0))
rpn_box_coder = BoxCoder(weights=cfg.MODEL.RPN.GA.TARGET_WEIGHTS)
anchor_box_coder = BoxCoder(weights=cfg.MODEL.RPN.GA.ANCHOR_WEIGHTS)
box_selector_train = make_rpn_postprocessor(cfg,
rpn_box_coder,
is_train=True)
box_selector_test = make_rpn_postprocessor(cfg,
rpn_box_coder,
is_train=False)
loss_evaluator = make_ga_rpn_loss_evaluator(cfg, rpn_box_coder,
anchor_box_coder)
self.anchor_generator = anchor_generator
self.head = head
self.box_selector_train = box_selector_train
self.box_selector_test = box_selector_test
self.loss_evaluator = loss_evaluator
def __init__(self, cfg):
self._proposals = None
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
self.box_coder = BoxCoder(weights=bbox_reg_weights)
self.proposal_matcher = Matcher(
cfg.MODEL.VG.FG_IOU_THRESHOLD,
cfg.MODEL.VG.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
def __init__(self, cfg, in_channels):
super(ROIBoxHead, self).__init__()
self.feature_extractor = make_roi_box_feature_extractor(
cfg, in_channels)
self.predictor = make_roi_box_predictor(
cfg, self.feature_extractor.out_channels)
self.post_processor = make_roi_box_post_processor(cfg)
self.loss_evaluator = make_roi_box_loss_evaluator(cfg)
self.box_coder = BoxCoder(weights=(10., 10., 5., 5.))
self.cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG
def __init__(
self,
cfg,
is_teacher=False,
):
super(DuplicationRemovalNetwork, self).__init__()
self.cfg = cfg.clone()
# if reg_iou = True, then this network is used to regress
# the iou to the GT. if not True, this predict
# true-object/duplicate
self.reg_iou = self.cfg.MODEL.RELATION_NMS.REG_IOU
self.first_n = cfg.MODEL.RELATION_NMS.FIRST_N
self.NMS_thread = cfg.MODEL.RELATION_NMS.THREAD
self.nms_rank_fc = nn.Linear(
cfg.MODEL.RELATION_NMS.ROI_FEAT_DIM,
cfg.MODEL.RELATION_NMS.APPEARANCE_FEAT_DIM,
bias=True)
self.roi_feat_embedding_fc = nn.Linear(
cfg.MODEL.RELATION_NMS.ROI_FEAT_DIM,
cfg.MODEL.RELATION_NMS.APPEARANCE_FEAT_DIM,
bias=True)
self.target_thresh = cfg.MODEL.RELATION_NMS.THREAD
self.geo_feature_dim = cfg.MODEL.RELATION_NMS.GEO_FEAT_DIM
if cfg.MODEL.RELATION_NMS.USE_IOU:
self.geo_feature_dim = int(self.geo_feature_dim / 4 * 5)
self.relation_module = RelationModule(
cfg.MODEL.RELATION_NMS.APPEARANCE_FEAT_DIM,
geo_feature_dim=self.geo_feature_dim,
fc_dim=(self.geo_feature_dim, 16),
group=cfg.MODEL.RELATION_NMS.GROUP,
dim=cfg.MODEL.RELATION_NMS.HID_DIM,
topk=cfg.MODEL.RELATION_NMS.TOPK,
iou_method=cfg.MODEL.RELATION_NMS.IOU_METHOD)
self.nms_fg_weight = torch.tensor([1., cfg.MODEL.RELATION_NMS.WEIGHT])
self.mt_fg_weight = torch.tensor([1., 10.])
self.alpha = cfg.MODEL.RELATION_NMS.ALPHA
self.gamma = cfg.MODEL.RELATION_NMS.GAMMA
self.boxcoder = BoxCoder(weights=(10., 10., 5., 5.))
self.class_agnostic = cfg.MODEL.RELATION_NMS.CLASS_AGNOSTIC
self.fg_class = cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES - 1
self.classifier = nn.Linear(128, len(self.target_thresh), bias=True)
self.relu1 = nn.ReLU(inplace=True)
self.fg_thread = cfg.MODEL.RELATION_NMS.FG_THREAD
self.detections_per_img = cfg.MODEL.ROI_HEADS.DETECTIONS_PER_IMG
self.nms = cfg.MODEL.RELATION_NMS.POS_NMS
self.nms_loss_type = cfg.MT.NMS_LOSS_TYPE
self.mode = None
def __init__(self,
score_thresh=0.05,
nms=0.5,
post_nms_per_cls_topn=300,
nms_filter_duplicates=True,
detections_per_img=100,
box_coder=None,
cls_agnostic_bbox_reg=False,
bbox_aug_enabled=False,
save_proposals=False):
"""
Arguments:
score_thresh (float)
nms (float)
detections_per_img (int)
box_coder (BoxCoder)
"""
super(PostProcessor, self).__init__()
self.score_thresh = score_thresh
self.nms = nms
self.post_nms_per_cls_topn = post_nms_per_cls_topn
self.nms_filter_duplicates = nms_filter_duplicates
self.detections_per_img = detections_per_img
if box_coder is None:
box_coder = BoxCoder(weights=(10., 10., 5., 5.))
self.box_coder = box_coder
self.cls_agnostic_bbox_reg = cls_agnostic_bbox_reg
self.bbox_aug_enabled = bbox_aug_enabled
self.save_proposals = save_proposals
def make_roi_box_loss_evaluator(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
box_coder = BoxCoder(weights=bbox_reg_weights)
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE, cfg.MODEL.ROI_HEADS.POSITIVE_FRACTION
)
cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG
attribute_on = cfg.MODEL.ATTRIBUTE_ON
loss_evaluator = FastRCNNLossComputation(
matcher,
fg_bg_sampler,
box_coder,
cls_agnostic_bbox_reg,
attribute_on
)
return loss_evaluator
def make_roi_box_loss_evaluator(cfg, stage=None):
if stage is None or stage == 1:
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
elif stage == 1:
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
elif stage == 2:
matcher = Matcher(
cfg.MODEL.ROI_HEADS.STAGE2.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.STAGE2.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.STAGE2.BBOX_REG_WEIGHTS
elif stage == 3:
matcher = Matcher(
cfg.MODEL.ROI_HEADS.STAGE3.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.STAGE3.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.STAGE3.BBOX_REG_WEIGHTS
box_coder = BoxCoder(weights=bbox_reg_weights)
sampling = cfg.MODEL.SAMPLING
if sampling == "random":
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE, cfg.MODEL.ROI_HEADS.POSITIVE_FRACTION
)
elif sampling == "balanced":
fg_bg_sampler = IOUBalancedPositiveNegativeSampler(
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE, cfg.MODEL.ROI_HEADS.POSITIVE_FRACTION
)
cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG
bbox_loss_type = cfg.MODEL.BBOX_LOSS_TYPE
label_smoothing = cfg.MODEL.LABEL_SMOOTHING
num_classes = cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES
loss_evaluator = FastRCNNLossComputation(
matcher,
fg_bg_sampler,
box_coder,
cls_agnostic_bbox_reg,
bbox_loss_type,
sampling,
label_smoothing,
num_classes
)
return loss_evaluator
def make_roi_box3d_post_processor(cfg):
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
box_coder = BoxCoder(weights=bbox_reg_weights)
depth_post_processor = Box3dPostProcessor(cfg, box_coder)
return depth_post_processor
def __init__(
self,
pre_nms_top_n,
post_nms_top_n,
nms_thresh,
min_size,
box_coder=None,
fpn_post_nms_top_n=None,
):
"""
Arguments:
pre_nms_top_n (int)
post_nms_top_n (int)
nms_thresh (float)
min_size (int)
box_coder (BoxCoder)
fpn_post_nms_top_n (int)
"""
super(RPNPostProcessor, self).__init__()
self.pre_nms_top_n = pre_nms_top_n
self.post_nms_top_n = post_nms_top_n
self.nms_thresh = nms_thresh
self.min_size = min_size
if box_coder is None:
box_coder = BoxCoder(weights=(1.0, 1.0, 1.0, 1.0))
self.box_coder = box_coder
if fpn_post_nms_top_n is None:
fpn_post_nms_top_n = post_nms_top_n
self.fpn_post_nms_top_n = fpn_post_nms_top_n
def __init__(
self,
pre_nms_thresh,
pre_nms_top_n,
nms_thresh,
fpn_post_nms_top_n,
min_size,
num_classes,
box_coder=None,
):
"""
Arguments:
pre_nms_thresh (float)
pre_nms_top_n (int)
nms_thresh (float)
fpn_post_nms_top_n (int)
min_size (int)
num_classes (int)
box_coder (BoxCoder)
"""
super(RetinaNetPostProcessor, self).__init__(pre_nms_thresh, 0,
nms_thresh, min_size)
self.pre_nms_thresh = pre_nms_thresh
self.pre_nms_top_n = pre_nms_top_n
self.nms_thresh = nms_thresh
self.fpn_post_nms_top_n = fpn_post_nms_top_n
self.min_size = min_size
self.num_classes = num_classes
if box_coder is None:
# Q: How are the weights chosen?
# A: cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS.
box_coder = BoxCoder(weights=(10., 10., 5., 5.))
self.box_coder = box_coder
def __init__(
self,
pre_nms_thresh,
pre_nms_top_n,
nms_thresh,
fpn_post_nms_top_n,
min_size,
num_classes,
box_coder=None,
imbalanced_decider=None,
):
"""
Arguments:
pre_nms_thresh (float)
pre_nms_top_n (int)
nms_thresh (float)
fpn_post_nms_top_n (int)
min_size (int)
num_classes (int)
box_coder (BoxCoder)
"""
super(RetinaNetPostProcessor, self).__init__(pre_nms_thresh, 0,
nms_thresh, min_size)
self.pre_nms_thresh = pre_nms_thresh
self.pre_nms_top_n = pre_nms_top_n
self.nms_thresh = nms_thresh
self.fpn_post_nms_top_n = fpn_post_nms_top_n
self.min_size = min_size
self.num_classes = num_classes
if box_coder is None:
box_coder = BoxCoder(weights=(10., 10., 5., 5.))
self.box_coder = box_coder
self.imbalanced_decider = imbalanced_decider
def make_roi_box_loss_evaluator(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
box_coder = BoxCoder(weights=bbox_reg_weights)
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE, cfg.MODEL.ROI_HEADS.POSITIVE_FRACTION
)
cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG
# ######################## add by hui ########################################################
ohem_loss = None
if cfg.MODEL.ROI_HEADS.OHEM == 1:
ohem_loss = OHEMLoss(cfg.MODEL.ROI_HEADS.OHEM1_NEG_RATE)
elif cfg.MODEL.ROI_HEADS.OHEM == 2:
ohem_loss = OHEM2Loss(cfg.MODEL.ROI_HEADS.OHEM2_BATCH_SIZE_PER_IM * cfg.SOLVER.IMS_PER_BATCH // cfg.SOLVER.NUM_GPU,
cfg.MODEL.ROI_HEADS.OHEM2_POSITIVE_FRACTION,
hard_rate=cfg.MODEL.ROI_HEADS.OHEM2_HARD_RATE)
loss_evaluator = FastRCNNLossComputation(matcher, fg_bg_sampler, box_coder, cls_agnostic_bbox_reg, ohem_loss)
# ################################################################################################################
return loss_evaluator
def __init__(self,
data_dir,
split,
temporal_saved_path,
use_difficult=False,
transforms=None):
self.root = data_dir
self.image_set = split
self.keep_difficult = use_difficult
self.transforms = transforms
self._annopath = os.path.join(self.root, "Annotations", "%s.xml")
self._imgpath = os.path.join(self.root, "JPEGImages", "%s.jpg")
self._imgsetpath = os.path.join(self.root, "ImageSets", "Main",
"%s.txt")
with open(self._imgsetpath % self.image_set) as f:
self.ids = f.readlines()
self.ids = [x.strip("\n") for x in self.ids]
self.id_to_img_map = {k: v for k, v in enumerate(self.ids)}
cls = PascalVOCDataset.CLASSES
self.class_to_ind = dict(zip(cls, range(len(cls))))
self.categories = dict(zip(range(len(cls)), cls))
self.temporal_saved_path = temporal_saved_path
self.postprocessor = PostProcessor(
score_thresh=0.05,
nms=0.5,
detections_per_img=100,
box_coder=BoxCoder(weights=(10.0, 10.0, 5.0, 5.0)),
cls_agnostic_bbox_reg=False,
bbox_aug_enabled=False)
self.__getitem__(0)
self.get_img_info(0)
def make_roi_box_loss_evaluator(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD, # 0.5，前面RPN出来的都是0.7了这里是0.5真的好吗：
# 为了划分出一部分背景，这里的正样本阈值被降低,也可能是留出一些阈值给训练前期容错
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD, # 0.5
allow_low_quality_matches=False,
)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
box_coder = BoxCoder(weights=bbox_reg_weights)
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE, cfg.MODEL.ROI_HEADS.POSITIVE_FRACTION
)
cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG
loss_evaluator = FastRCNNLossComputation(
matcher,
fg_bg_sampler,
box_coder,
cls_agnostic_bbox_reg
)
return loss_evaluator
def __init__(self, cfg, in_channels):
super(RPNModule, self).__init__()
self.cfg = cfg.clone()
try:
self.save_features = self.cfg.SAVE_FEATURES_RPN
except:
self.save_features = False
anchor_generator = make_anchor_generator(self.cfg)
rpn_head = registry.RPN_HEADS[self.cfg.MODEL.RPN.RPN_HEAD]
head = rpn_head(self.cfg, in_channels,
anchor_generator.num_anchors_per_location()[0])
rpn_box_coder = BoxCoder(weights=(1.0, 1.0, 1.0, 1.0))
box_selector_train = make_rpn_postprocessor(self.cfg,
rpn_box_coder,
is_train=True)
box_selector_test = make_rpn_postprocessor(self.cfg,
rpn_box_coder,
is_train=False)
loss_evaluator = make_rpn_loss_evaluator(self.cfg, rpn_box_coder)
self.anchor_generator = anchor_generator
self.head = head
self.box_selector_train = box_selector_train
self.box_selector_test = box_selector_test
self.loss_evaluator = loss_evaluator
self.initialize_online_rpn_params()
def __init__(
self,
cfg,
box_coder=None,
):
"""
Arguments:
box_coder (BoxCoder)
"""
super(PostProcessor, self).__init__()
self.cfg = cfg
self.score_thresh = cfg.MODEL.ROI_HEADS.SCORE_THRESH
self.nms = cfg.MODEL.ROI_HEADS.NMS
self.detections_per_img = cfg.MODEL.ROI_HEADS.DETECTIONS_PER_IMG
self.min_detections_per_img = cfg.MODEL.ROI_HEADS.MIN_DETECTIONS_PER_IMG
if box_coder is None:
box_coder = BoxCoder(weights=(10., 10., 5., 5.))
self.box_coder = box_coder
self.cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG
self.bbox_aug_enabled = cfg.TEST.BBOX_AUG.ENABLED
self.output_feature = cfg.TEST.OUTPUT_FEATURE
if self.output_feature:
# needed to extract features when they have not been pooled yet
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.force_boxes = cfg.MODEL.ROI_BOX_HEAD.FORCE_BOXES
self.ignore_box_regression = cfg.TEST.IGNORE_BOX_REGRESSION
self.filter_method = self.filter_results
if self.cfg.MODEL.ROI_HEADS.NMS_FILTER == 1:
self.filter_method = self.filter_results_peter
elif self.cfg.MODEL.ROI_HEADS.NMS_FILTER == 2:
self.filter_method = self.filter_results_fast
def __init__(self, cfg, in_channels):
super(RPNModule, self).__init__()
self.cfg = cfg.clone()
anchor_generator = make_anchor_generator(cfg) # 创建AnchorGenerator类
rpn_head = registry.RPN_HEADS[cfg.MODEL.RPN.RPN_HEAD] # 链接到rpn_head类
head = rpn_head(
cfg, in_channels,
anchor_generator.num_anchors_per_location()[0]) # 创建rpn_head类
rpn_box_coder = BoxCoder(weights=(1.0, 1.0, 1.0, 1.0))
box_selector_train = make_rpn_postprocessor(
cfg, rpn_box_coder, is_train=True) # 创建RPNPostProcessor类
box_selector_test = make_rpn_postprocessor(cfg,
rpn_box_coder,
is_train=False)
loss_evaluator = make_rpn_loss_evaluator(
cfg, rpn_box_coder) # 创建RPNLossComputation类
self.anchor_generator = anchor_generator
self.head = head
self.box_selector_train = box_selector_train
self.box_selector_test = box_selector_test
self.loss_evaluator = loss_evaluator
def make_roi_box_post_processor(cfg):
use_fpn = cfg.MODEL.ROI_HEADS.USE_FPN
# Default weights on (dx, dy, dw, dh) for normalizing bbox regression targets
# These are empirically chosen to approximately lead to unit variance targets
# _C.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS = (10., 10., 5., 5.)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
box_coder = BoxCoder(weights=bbox_reg_weights)
# Only used on test mode
# Minimum score threshold (assuming scores in a [0, 1] range); a value chosen to
# balance obtaining high recall with not having too many low precision
# detections that will slow down inference post processing steps (like NMS)
score_thresh = cfg.MODEL.ROI_HEADS.SCORE_THRESH # 0.05
nms_thresh = cfg.MODEL.ROI_HEADS.NMS # 0.5
# Maximum number of detections to return per image (100 is based on the limit
# established for the COCO dataset)
detections_per_img = cfg.MODEL.ROI_HEADS.DETECTIONS_PER_IMG # 100
cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG # False
postprocessor = PostProcessor(score_thresh, nms_thresh, detections_per_img,
box_coder, cls_agnostic_bbox_reg)
return postprocessor
def __init__(
self,
pre_nms_top_n,
post_nms_top_n,
nms_thresh,
min_size,
box_coder=None,
fpn_post_nms_top_n=None,
):
"""
Arguments:
two nms operation
pre_nms_top_n (int) for single feature level
post_nms_top_n (int) for all feature level, image wise nms
nms_thresh (float)
min_size (int)
box_coder (BoxCoder)
fpn_post_nms_top_n (int)
"""
super(RPNPostProcessor, self).__init__()
self.pre_nms_top_n = pre_nms_top_n
self.post_nms_top_n = post_nms_top_n
self.nms_thresh = nms_thresh
self.min_size = min_size
if box_coder is None:
box_coder = BoxCoder(weights=(1.0, 1.0, 1.0, 1.0))
self.box_coder = box_coder
if fpn_post_nms_top_n is None:
fpn_post_nms_top_n = post_nms_top_n
self.fpn_post_nms_top_n = fpn_post_nms_top_n
def make_roi_box_loss_evaluator(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
box_coder = BoxCoder(weights=bbox_reg_weights)
class_weights = cfg.MODEL.ROI_BOX_HEAD.CLASS_WEIGHT
class_compete = cfg.MODEL.ROI_BOX_HEAD.CLASS_COMPETE
if len(class_weights) == 1:
class_weights = class_weights * cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE,
cfg.MODEL.ROI_HEADS.POSITIVE_FRACTION)
cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG
use_focal_loss = cfg.MODEL.ROI_BOX_HEAD.USE_FOCAL_LOSS
sigmoid_focal_loss = SigmoidFocalLoss(cfg.MODEL.RETINANET.LOSS_GAMMA,
cfg.MODEL.RETINANET.LOSS_ALPHA)
loss_evaluator = FastRCNNLossComputation(matcher, fg_bg_sampler, box_coder,
class_weights, class_compete,
cls_agnostic_bbox_reg,
use_focal_loss,
sigmoid_focal_loss)
return loss_evaluator
def make_roi_box_loss_evaluator(cfg):
matcher = Matcher(
# Overlap threshold for an RoI to be considered foreground (if >= FG_IOU_THRESHOLD)
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD, # 0.5
# Overlap threshold for an RoI to be considered background
# (class = 0 if overlap in [0, BG_IOU_THRESHOLD))
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD, # 0.5
allow_low_quality_matches=False,
)
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS # (10., 10., 5., 5.)
box_coder = BoxCoder(weights=bbox_reg_weights)
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE, # 512
cfg.MODEL.ROI_HEADS.POSITIVE_FRACTION # 0.25
)
cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG # False
loss_evaluator = FastRCNNLossComputation(
matcher,
fg_bg_sampler,
box_coder,
cls_agnostic_bbox_reg
)
return loss_evaluator
def __init__(self, cfg):
super(RetinaNetModule, self).__init__()
self.cfg = cfg.clone()
anchor_generator = make_anchor_generator_retinanet(cfg)
head = RetinaNetHead(cfg)
box_coder = BoxCoder(weights=(10., 10., 5., 5.))
if self.cfg.MODEL.SPARSE_MASK_ON:
box_selector_test = make_retinanet_detail_postprocessor(
cfg, 100, box_coder)
else:
box_selector_test = make_retinanet_postprocessor(
cfg, 100, box_coder)
box_selector_train = None
if self.cfg.MODEL.MASK_ON or self.cfg.MODEL.SPARSE_MASK_ON:
box_selector_train = make_retinanet_postprocessor(
cfg, 100, box_coder)
loss_evaluator = make_free_anchor_loss_evaluator(cfg, box_coder) if cfg.FREEANCHOR.FREEANCHOR_ON \
else make_retinanet_loss_evaluator(cfg, box_coder)
self.anchor_generator = anchor_generator
self.head = head
self.box_selector_test = box_selector_test
self.box_selector_train = box_selector_train
self.loss_evaluator = loss_evaluator
def make_roi_box_post_processor(cfg):
use_fpn = cfg.MODEL.ROI_HEADS.USE_FPN
bbox_reg_weights = cfg.MODEL.ROI_HEADS.BBOX_REG_WEIGHTS
box_coder = BoxCoder(weights=bbox_reg_weights)
score_thresh = cfg.MODEL.ROI_HEADS.SCORE_THRESH
nms_thresh = cfg.MODEL.ROI_HEADS.NMS_THRESH
nms_method = cfg.MODEL.ROI_HEADS.NMS_METHOD
nms_extra_argv = {}
if nms_method == "soft_nms":
nms_extra_argv["sigma"] = cfg.MODEL.ROI_HEADS.NMS_SIGMA
nms_extra_argv["min_score"] = cfg.MODEL.ROI_HEADS.NMS_MIN_SCORE
detections_per_img = cfg.MODEL.ROI_HEADS.DETECTIONS_PER_IMG
cls_agnostic_bbox_reg = cfg.MODEL.CLS_AGNOSTIC_BBOX_REG
post_process_on = cfg.MODEL.ROI_HEADS.POST_PROCESS_ON
postprocessor = PostProcessor(
score_thresh,
nms_thresh,
detections_per_img,
box_coder,
cls_agnostic_bbox_reg,
post_process_on,
nms_method,
nms_extra_argv,
)
return postprocessor
def __init__(
self,
cfg,
score_thresh=0.05,
nms=0.5,
detections_per_img=10000,
box_coder=None,
cls_agnostic_bbox_reg=False
):
"""
Arguments:
score_thresh (float)
nms (float)
detections_per_img (int)
box_coder (BoxCoder)
"""
super(PostProcessor, self).__init__()
self.score_thresh = score_thresh
self.nms = nms
self.cfg=cfg
self.detections_per_img = detections_per_img
if box_coder is None:
box_coder = BoxCoder(weights=(10., 10., 5., 5.))
self.box_coder = box_coder
self.cls_agnostic_bbox_reg = cls_agnostic_bbox_reg
def __init__(
self,
score_thresh=0.05,
nms=0.5,
detections_per_img=100,
box_coder=None,
cls_agnostic_bbox_reg=False,
post_process_on=True,
nms_method='vanilla',
nms_sigma=0.3,
nms_min_score=0.1,
):
"""
Arguments:
score_thresh (float)
nms (float)
detections_per_img (int)
box_coder (BoxCoder)
"""
super(PostProcessor, self).__init__()
self.score_thresh = score_thresh
self.nms = nms
self.detections_per_img = detections_per_img
if box_coder is None:
box_coder = BoxCoder(weights=(10., 10., 5., 5.))
self.box_coder = box_coder
self.cls_agnostic_bbox_reg = cls_agnostic_bbox_reg
self.post_process_on = post_process_on
self.nms_method = nms_method
self.nms_sigma = nms_sigma
self.nms_min_score = nms_min_score
def __init__(
self,
pre_nms_thresh,
pre_nms_top_n,
nms_thresh,
fpn_post_nms_top_n,
min_size,
box_coder=None,
):
"""
Arguments:
pre_nms_thresh (float)
pre_nms_top_n (int)
nms_thresh (float)
fpn_post_nms_top_n (int)
min_size (int)
box_coder (BoxCoder)
"""
super(RetinaNetPostProcessor, self).__init__()
self.pre_nms_thresh = pre_nms_thresh
self.pre_nms_top_n = pre_nms_top_n
self.nms_thresh = nms_thresh
self.fpn_post_nms_top_n = fpn_post_nms_top_n
self.min_size = min_size
if box_coder is None:
box_coder = BoxCoder(weights=(10., 10., 5., 5.))
self.box_coder = box_coder
def __init__(self, cfg, in_channels):
super(RPNModule, self).__init__()
self.cfg = cfg.clone()
RPN_HEADS={'SingleConvRPNHead':RPNHead}
anchor_generator = make_anchor_generator(cfg)
print(cfg.MODEL.RPN.RPN_HEAD)
# rpn_head = registry.RPN_HEADS[cfg.MODEL.RPN.RPN_HEAD]
rpn_head=RPN_HEADS[cfg.MODEL.RPN.RPN_HEAD]
head = rpn_head(
cfg, in_channels, anchor_generator.num_anchors_per_location()[0]
)
rpn_box_coder = BoxCoder(weights=(1.0, 1.0, 1.0, 1.0))
box_selector_train = make_rpn_postprocessor(cfg, rpn_box_coder, is_train=True)
box_selector_test = make_rpn_postprocessor(cfg, rpn_box_coder, is_train=False)
loss_evaluator = make_rpn_loss_evaluator(cfg, rpn_box_coder)
self.anchor_generator = anchor_generator
self.head = head
self.box_selector_train = box_selector_train
self.box_selector_test = box_selector_test
self.loss_evaluator = loss_evaluator
def __init__(self, cfg):
super(RPNModule, self).__init__()
self.cfg = cfg.clone()
anchor_generator = make_anchor_generator(cfg)
in_channels = cfg.MODEL.BACKBONE.OUT_CHANNELS
rpn_head = registry.RPN_HEADS[cfg.MODEL.RPN.RPN_HEAD]
head = rpn_head(
cfg, in_channels, anchor_generator.num_anchors_per_location()[0]
)
rpn_box_coder = BoxCoder(weights=(1.0, 1.0, 1.0, 1.0))
box_selector_train = make_rpn_postprocessor(cfg, rpn_box_coder, is_train=True)
box_selector_test = make_rpn_postprocessor(cfg, rpn_box_coder, is_train=False)
loss_evaluator = make_rpn_loss_evaluator(cfg, rpn_box_coder)
self.anchor_generator = anchor_generator
self.head = head
self.box_selector_train = box_selector_train
self.box_selector_test = box_selector_test
self.loss_evaluator = loss_evaluator
def __init__(self, cfg, in_channels):
super(RPNModule, self).__init__()
self.cfg = cfg.clone()
anchor_generator = make_anchor_generator(cfg)
rpn_head = registry.RPN_HEADS[cfg.MODEL.RPN.RPN_HEAD]
head = rpn_head(cfg, in_channels,
anchor_generator.num_anchors_per_location()[0])
if self.cfg.MODEL.RPN.FREEZE_WEIGHT:
for p in head.parameters():
p.requires_grad = False
rpn_box_coder = BoxCoder(weights=(1.0, 1.0, 1.0, 1.0))
box_selector_train = make_rpn_postprocessor(cfg,
rpn_box_coder,
is_train=True)
box_selector_test = make_rpn_postprocessor(cfg,
rpn_box_coder,
is_train=False)
loss_evaluator = make_rpn_loss_evaluator(cfg, rpn_box_coder)
self.anchor_generator = anchor_generator
self.head = head
self.box_selector_train = box_selector_train
self.box_selector_test = box_selector_test
self.loss_evaluator = loss_evaluator
