def make_roi_box_loss_evaluator(cfg):
matcher_iou = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_LOW_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
matcher_visible_iog = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOG_VISIBLE_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOG_VISIBLE_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
loss_evaluator = FastRCNNLossComputation(matcher_iou, matcher_visible_iog,
fg_bg_sampler, box_coder,
cls_agnostic_bbox_reg)
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_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
sigmoid_focal_loss = SigmoidFocalLoss(
cfg.MODEL.RETINANET.LOSS_GAMMA,
cfg.MODEL.RETINANET.LOSS_ALPHA
)
loss_evaluator = FastRCNNLossComputation(
matcher,
fg_bg_sampler,
box_coder,
sigmoid_focal_loss,
cls_agnostic_bbox_reg
)
return loss_evaluator
def make_rpn_loss_evaluator(cfg, box_coder, mode=0):
"""mode (int):
0: original_rpn loss
1: contrastive loss
2: triplet loss
"""
matcher = Matcher(
cfg.MODEL.RPN.FG_IOU_THRESHOLD,
cfg.MODEL.RPN.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
)
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.RPN.BATCH_SIZE_PER_IMAGE, cfg.MODEL.RPN.POSITIVE_FRACTION)
if mode == 0:
loss_evaluator = RPNLossComputation(matcher, fg_bg_sampler, box_coder,
generate_rpn_labels)
elif mode == 1:
loss_evaluator = RPNContrastiveLossComputation(matcher, fg_bg_sampler,
box_coder,
generate_rpn_labels)
elif mode == 2:
loss_evaluator = RPNTripletLossComputation(matcher, fg_bg_sampler,
box_coder,
generate_rpn_labels)
else:
raise RuntimeError(
"loss mode should be interger in [0, 2], not available: {}".format(
mode))
return loss_evaluator
def make_vline_loss_evaluator(cfg):
# is_focal = True
# is_focal = False
loss_w = cfg.MODEL.VLINE_HEAD.LOSS_W
is_focal = cfg.MODEL.VLINE_HEAD.USE_FOCAL_LOSS
is_simple_bce = cfg.MODEL.VLINE_HEAD.USE_SIMPLE_BCE
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
print("cfg.MODEL.VLINE_HEAD.NUM_BOUDARY: ", cfg.MODEL.VLINE_HEAD.NUM_BOUDARY)
loss_evaluator = VLineLossComputation(
matcher,
# cfg.MODEL.ROI_MASK_HEAD.RESOLUTION,
cfg.MODEL.VLINE_HEAD.POOLER_RESOLUTION,
cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES,
cfg.MODEL.VLINE_HEAD.BINS,
loss_w,
is_focal,
cfg.MODEL.CLS_AGNOSTIC_VLINE_REG,
is_simple_bce,
cfg.MODEL.VLINE_HEAD.NUM_BOUDARY,
)
return loss_evaluator
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
cls_weight = None
if cfg.MODEL.ROI_BOX_HEAD.CLS_LOSS_WEIGHT:
cls_weight = torch.tensor(
cfg.MODEL.ROI_BOX_HEAD.CLS_LOSS_WEIGHT).cuda()
loss_evaluator = FastRCNNLossComputation(matcher, fg_bg_sampler, box_coder,
cls_agnostic_bbox_reg, cls_weight)
return loss_evaluator
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
scheme = "free" if cfg.MODEL.SAMPLING_FREE_ON else "sampling"
loss_evaluator = eval("FastRCNNLossComputation" + scheme.capitalize())(\
matcher,
fg_bg_sampler,
box_coder,
cls_agnostic_bbox_reg
)
return loss_evaluator
def make_rpn_loss_evaluator(cfg, box_coder):
matcher = Matcher(cfg.MODEL.RPN.FG_IOU_THRESHOLD,
cfg.MODEL.RPN.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
yaw_threshold=cfg.MODEL.RPN.YAW_THRESHOLD)
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.RPN.BATCH_SIZE_PER_IMAGE, cfg.MODEL.RPN.POSITIVE_FRACTION)
ay = cfg.MODEL.RPN.LABEL_AUG_THICKNESS_Y_TAR_ANC
az = cfg.MODEL.RPN.LABEL_AUG_THICKNESS_Z_TAR_ANC
aug_thickness = {
'target_Y': ay[0],
'anchor_Y': ay[1],
'target_Z': az[0],
'anchor_Z': az[1],
}
dset_metas = DSET_METAS(cfg.INPUT.CLASSES)
loss_evaluator = RPNLossComputation(matcher,
fg_bg_sampler,
box_coder,
cfg.MODEL.LOSS.YAW_MODE,
aug_thickness,
dset_metas=dset_metas,
IoU_criteria=cfg.MODEL.IOU_CRITERIA)
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 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
func = registry.ROI_BOX_HEADS_LOSS[cfg.MODEL.ROI_BOX_HEAD.LOSS]
loss_evaluator = func(
matcher,
fg_bg_sampler,
box_coder,
cls_agnostic_bbox_reg
)
return loss_evaluator
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 make_retinanet_loss_evaluator(cfg, box_coder):
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.RPN.BATCH_SIZE_PER_IMAGE, cfg.MODEL.RPN.POSITIVE_FRACTION
)
matcher = Matcher(
cfg.MODEL.RETINANET.FG_IOU_THRESHOLD,
cfg.MODEL.RETINANET.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
)
sigmoid_focal_loss = SigmoidFocalLoss(
cfg.MODEL.RETINANET.LOSS_GAMMA,
cfg.MODEL.RETINANET.LOSS_ALPHA
)
loss_evaluator = RetinaNetLossComputation(
matcher,
box_coder,
generate_retinanet_labels,
sigmoid_focal_loss,
fg_bg_sampler,
bbox_reg_beta = cfg.MODEL.RETINANET.BBOX_REG_BETA,
embed_margin = cfg.MODEL.RETINANET.EMBED_MARGIN,
embedding_loss = cfg.MODEL.RETINANET.EMBED_LOSS,
regress_norm = cfg.MODEL.RETINANET.BBOX_REG_WEIGHT
)
return loss_evaluator
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
reg_angle_relative = cfg.MODEL.ROI_HEADS.BBOX_REG_ANGLE_RELATIVE
box_coder = BoxCoder(weights=bbox_reg_weights, relative_angle=reg_angle_relative)
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 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_shape_class_loss_evaluator(cfg):
matcher = Matcher(cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False)
loss_evaluator = ShapeClassMaskRCNNLossComputation(matcher)
return loss_evaluator
def make_yolact_loss_evaluator(cfg, box_coder):
matcher = Matcher(
cfg.MODEL.RETINANET.FG_IOU_THRESHOLD,
cfg.MODEL.RETINANET.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
)
sigmoid_focal_loss = SigmoidFocalLoss(
cfg.MODEL.RETINANET.LOSS_GAMMA,
cfg.MODEL.RETINANET.LOSS_ALPHA
)
loss_evaluator = YolactLossComputation(
matcher,
box_coder,
generate_retinanet_labels,
sigmoid_focal_loss,
# sigmoid operation is integrated into binary_cross_entropy_with_logits
_ACTIVATION_FUNC[cfg.MODEL.YOLACT.MASK_ACTIVATION],
cfg.MODEL.YOLACT.NUM_PROTOTYPES,
cfg.MODEL.YOLACT.MASK_TO_TRAIN,
bbox_reg_beta = cfg.MODEL.RETINANET.BBOX_REG_BETA,
regress_norm = cfg.MODEL.RETINANET.BBOX_REG_WEIGHT,
mask_norm = cfg.MODEL.YOLACT.MASK_WEIGHT,
mask_with_logits = cfg.MODEL.YOLACT.MASK_WITH_LOGITS
)
return loss_evaluator
def make_rpn_loss_evaluator(cfg, box_coder):
matcher = Matcher(
cfg.MODEL.RPN.FG_IOU_THRESHOLD,
cfg.MODEL.RPN.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
)
fg_bg_sampler = BalancedPositiveNegativeSampler(
cfg.MODEL.RPN.BATCH_SIZE_PER_IMAGE, cfg.MODEL.RPN.POSITIVE_FRACTION)
# #################################### changed by hui ####################################################
ohem_loss = None
if cfg.MODEL.RPN.OHEM == 1:
ohem_loss = OHEMLoss(cfg.MODEL.RPN.OHEM1_NEG_RATE, binary_logits=True)
elif cfg.MODEL.RPN.OHEM == 2:
ohem_loss = OHEM2Loss(cfg.MODEL.RPN.OHEM2_BATCH_SIZE_PER_IM *
cfg.SOLVER.IMS_PER_BATCH // cfg.SOLVER.NUM_GPU,
cfg.MODEL.RPN.OHEM2_POSITIVE_FRACTION,
binary_logits=True,
hard_rate=cfg.MODEL.RPN.OHEM2_HARD_RATE)
loss_evaluator = RPNLossComputation(matcher, fg_bg_sampler, box_coder,
generate_rpn_labels, ohem_loss)
# #######################################################################################################
return loss_evaluator
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 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_retinanet_loss_evaluator(cfg, box_coder):
matcher = Matcher(
cfg.MODEL.RETINANET.FG_IOU_THRESHOLD,
cfg.MODEL.RETINANET.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
)
sigmoid_focal_loss = SigmoidFocalLoss(cfg.MODEL.RETINANET.LOSS_GAMMA,
cfg.MODEL.RETINANET.LOSS_ALPHA)
if cfg.MODEL.SCHEME == "obj":
loss_evaluator = RetinaNetLossComputationObj(
matcher,
box_coder,
generate_retinanet_labels,
bbox_reg_beta=cfg.MODEL.RETINANET.BBOX_REG_BETA,
regress_norm=cfg.MODEL.RETINANET.BBOX_REG_WEIGHT,
scale=cfg.MODEL.SCALE)
else:
loss_evaluator = RetinaNetLossComputation(
matcher,
box_coder,
generate_retinanet_labels,
sigmoid_focal_loss,
bbox_reg_beta=cfg.MODEL.RETINANET.BBOX_REG_BETA,
regress_norm=cfg.MODEL.RETINANET.BBOX_REG_WEIGHT,
)
return loss_evaluator
def build_roi_mask_head(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
return ROIMaskHead(cfg, matcher, (cfg.MODEL.ROI_MASK_HEAD.RESOLUTION_H,
cfg.MODEL.ROI_MASK_HEAD.RESOLUTION_W))
def __init__(self, cfg):
"""
"""
self.loss_weight = cfg.MODEL.ROI_ATTRIBUTE_HEAD.LOSS_WEIGHT
self.proposal_matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
def make_retinanet_loss_evaluator(cfg, box_coder):
matcher = Matcher(
cfg.MODEL.RPN.FG_IOU_THRESHOLD,
cfg.MODEL.RPN.BG_IOU_THRESHOLD,
allow_low_quality_matches=cfg.RETINANET.LOW_QUALITY_MATCHES,
low_quality_threshold=cfg.RETINANET.LOW_QUALITY_THRESHOLD)
loss_evaluator = RetinaNetLossComputation(cfg, matcher, box_coder)
return loss_evaluator
def make_roi_bb8keypoint_offset_loss_evaluator(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
loss_evaluator = BB8KeypointOffsetRCNNLossComputation(matcher)
return loss_evaluator
def make_retinanet_box_subsample(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
return RETINANETBOXComputation(
cfg,
matcher,
)
def make_roi_car_cls_rot_evaluator(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
loss_evaluator = CarClsRotLoss(matcher, cfg)
return loss_evaluator
def make_yolov3_loss_evaluator(cfg, box_coder):
matcher = Matcher(
cfg.MODEL.YOLOV3.FG_IOU_THRESHOLD,
cfg.MODEL.YOLOV3.BG_IOU_THRESHOLD,
allow_low_quality_matches=True,
)
loss_evaluator = YOLOV3LossComputation(matcher, box_coder,
generate_yolo_labels)
return loss_evaluator
def make_roi_trans_evaluator(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
loss_evaluator = TransLoss(matcher, cfg)
return loss_evaluator
def make_cost_volum_loss_evaluator(cfg):
matcher = Matcher(
cfg.MODEL.ROI_HEADS.FG_IOU_THRESHOLD,
cfg.MODEL.ROI_HEADS.BG_IOU_THRESHOLD,
allow_low_quality_matches=False,
)
loss_evaluator = CostLossComputation(matcher)
return 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,
)
