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): 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 cfg.MODEL.RPN.USE_WING_LOSS: wing_loss = WingLoss( width=cfg.MODEL.RPN.WING_LOSS.WIDTH, curvature=cfg.MODEL.RPN.WING_LOSS.SIGMA, ) else: wing_loss = None if cfg.MODEL.RPN.USE_FOCAL_LOSS: focal_loss = SigmoidFocalLoss( cfg.MODEL.RPN.FOCAL_LOSS.GAMMA, cfg.MODEL.RPN.FOCAL_LOSS.ALPHA, ) else: focal_loss = None if cfg.MODEL.RPN.USE_SELF_ADJUST_SMOOTH_L1_LOSS: adjust_smooth_l1_loss = AdjustSmoothL1Loss( 4, beta=cfg.MODEL.RPN.SELF_ADJUST_SMOOTH_L1_LOSS.BBOX_REG_BETA) else: adjust_smooth_l1_loss = None if cfg.MODEL.RPN.USE_COMBINATION_LOSS: combination_weight = cfg.MODEL.RPN.COMBINATION_LOSS.WEIGHT else: combination_weight = 0 if cfg.MODEL.RPN.USE_BALANCE_L1_LOSS: balance_l1_loss = BalancedL1Loss( alpha=cfg.MODEL.RPN.BALANCE_L1_LOSS.ALPHA, beta=cfg.MODEL.RPN.BALANCE_L1_LOSS.BETA, gamma=cfg.MODEL.RPN.BALANCE_L1_LOSS.GAMMA) else: balance_l1_loss = None loss_evaluator = RPNLossComputation( matcher, fg_bg_sampler, box_coder, generate_rpn_labels, wing_loss=wing_loss, adjust_smooth_l1_loss=adjust_smooth_l1_loss, balance_l1_loss=balance_l1_loss, focal_loss=focal_loss, combination_weight=combination_weight) return loss_evaluator
def __init__(self, cfg): self.cls_loss_func = SigmoidFocalLoss(cfg.MODEL.FCOS.LOSS_GAMMA, cfg.MODEL.FCOS.LOSS_ALPHA) self.fpn_strides = cfg.MODEL.FCOS.FPN_STRIDES self.center_sampling_radius = cfg.MODEL.FCOS.CENTER_SAMPLING_RADIUS self.iou_loss_type = cfg.MODEL.FCOS.IOU_LOSS_TYPE self.norm_reg_targets = cfg.MODEL.FCOS.NORM_REG_TARGETS # we make use of IOU Loss for bounding boxes regression, # but we found that L1 in log scale can yield a similar performance self.box_reg_loss_func = IOULoss(self.iou_loss_type) self.centerness_loss_func = nn.BCEWithLogitsLoss(reduction="sum")
def __init__(self, cfg): self.cls_loss_func = SigmoidFocalLoss(cfg.MODEL.FCOS.LOSS_GAMMA, cfg.MODEL.FCOS.LOSS_ALPHA) self.center_sample = cfg.MODEL.FCOS.CENTER_SAMPLE self.strides = cfg.MODEL.FCOS.FPN_STRIDES self.radius = cfg.MODEL.FCOS.POS_RADIUS self.loc_loss_type = cfg.MODEL.FCOS.LOC_LOSS_TYPE # we make use of IOU Loss for bounding boxes regression, # but we found that L1 in log scale can yield a similar performance self.box_reg_loss_func = IOULoss(self.loc_loss_type) self.centerness_loss_func = nn.BCEWithLogitsLoss() self.dense_points = cfg.MODEL.FCOS.DENSE_POINTS
def __init__(self, cfg, proposal_matcher, box_coder): """ Arguments: proposal_matcher (Matcher) box_coder (BoxCoder) """ # self.target_preparator = target_preparator self.proposal_matcher = proposal_matcher self.box_coder = box_coder self.num_classes = cfg.RETINANET.NUM_CLASSES - 1 self.box_cls_loss_func = SigmoidFocalLoss(self.num_classes, cfg.RETINANET.LOSS_GAMMA, cfg.RETINANET.LOSS_ALPHA) self.regression_loss = SmoothL1Loss(beta=cfg.RETINANET.BBOX_REG_BETA)
def __init__(self, cfg): self.cls_loss_func = SigmoidFocalLoss(cfg.MODEL.FCOS.LOSS_GAMMA, cfg.MODEL.FCOS.LOSS_ALPHA) # we make use of IOU Loss for bounding boxes regression, # but we found that L1 in log scale can yield a similar performance self.box_reg_loss_func = IOULoss() self.centerness_loss_func = nn.BCEWithLogitsLoss() # generate sizes of interest soi = [] prev_size = -1 for s in cfg.MODEL.FCOS.SIZES_OF_INTEREST: soi.append([prev_size, s]) prev_size = s soi.append([prev_size, INF]) self.object_sizes_of_interest = soi
def make_retinanet_loss_evaluator(cfg, box_coder): classify_holistic_image = cfg.MODEL.CLASSIFY_HOLISTIC_IMAGE classify_objectness_image = cfg.MODEL.CLASSIFY_OBJECTNESS_IMAGE num_classes = cfg.MODEL.RETINANET.NUM_CLASSES num_holistic_classes = cfg.MODEL.RETINANET.NUM_HOLISTIC_CLASSES 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) fg_bg_sampler = BalancedPositiveNegativeSampler( cfg.MODEL.RPN.BATCH_SIZE_PER_IMAGE, cfg.MODEL.RPN.POSITIVE_FRACTION) 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, use_ignored_bbox=cfg.MODEL.RETINANET.LOSS_USE_IGNORE, classify_holistic_image=classify_holistic_image, num_classes=num_classes, num_holistic_classes=num_holistic_classes, classify_objectness_image=classify_objectness_image, objectness_norm=cfg.MODEL.RETINANET.OBJECTNESS_LOSS_WEIGHT, fg_bg_sampler=fg_bg_sampler, ) if classify_holistic_image: class_weights = cfg.MODEL.RETINANET.HOLISTIC_CLASS_WEIGHT holistic_classify_norm = cfg.MODEL.RETINANET.HOLISTIC_LOSS_WEIGHT use_focal_loss = cfg.MODEL.RETINANET.HOLISTIC_USE_FOCAL_LOSS, alpha = cfg.MODEL.RETINANET.HOLISTIC_ALPHA gamma = cfg.MODEL.RETINANET.HOLISTIC_GAMMA if len(class_weights) == 1: class_weights = class_weights * ( cfg.MODEL.RETINANET.NUM_HOLISTIC_CLASSES - 1) loss_holistic_evaluator = RetinaNetHolisticLossComputation( class_weights, holistic_classify_norm, use_focal_loss, alpha, gamma) else: loss_holistic_evaluator = None return loss_evaluator, loss_holistic_evaluator
def __init__(self, cfg): self.cfg = cfg.clone() resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION scales = cfg.MODEL.ROI_BOX_HEAD.POOLER_SCALES sampling_ratio = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO self.loss_type = cfg.MODEL.DA_HEADS.IMG_LOSS_TYPE pooler = Pooler( output_size=(resolution, resolution), scales=scales, sampling_ratio=sampling_ratio, ) self.pooler = pooler self.avgpool = nn.AvgPool2d(kernel_size=resolution, stride=resolution) self.focal_loss = SigmoidFocalLoss(cfg.MODEL.RETINANET.LOSS_GAMMA, cfg.MODEL.RETINANET.LOSS_ALPHA)
def __init__(self, cfg): self.cls_loss_func = SigmoidFocalLoss(cfg.MODEL.FCOS.LOSS_GAMMA, cfg.MODEL.FCOS.LOSS_ALPHA) # self.cls_loss_func = nn.CrossEntropyLoss() self.cfg = cfg # we make use of IOU Loss for bounding boxes regression, # but we found that L1 in log scale can yield a similar performance # self.box_reg_loss_func = IOULoss() self.centerness_loss_func = nn.BCEWithLogitsLoss() self.num_pts = cfg.MODEL.FCOS.NUM_PTS self.h = lambda x: 1 / (1 + torch.exp(-10 * x)) # 使用exp()是为了得到大于0的值 start1 = nn.Parameter(torch.FloatTensor([-100]).cuda()) deta1 = nn.Parameter(torch.FloatTensor([4.159]).cuda()) #e^4.158=64 start2 = nn.Parameter(torch.FloatTensor([4.159]).cuda()) #e^4.158=64 deta2 = nn.Parameter(torch.FloatTensor([4.159 ]).cuda()) #64+e^4.158=128 start3 = nn.Parameter(torch.FloatTensor([4.852]).cuda()) #e^4.852=128 start3.register_hook(print_grad) deta3 = nn.Parameter(torch.FloatTensor([4.852 ]).cuda()) #128+e^4.852=256 start4 = nn.Parameter(torch.FloatTensor([5.545]).cuda()) #e^5.545=256 deta4 = nn.Parameter(torch.FloatTensor([5.545 ]).cuda()) #256+e^5.545=512 start5 = nn.Parameter(torch.FloatTensor([6.2383 ]).cuda()) #e^6.2383=512 deta5 = nn.Parameter(torch.FloatTensor([100000]).cuda()) #inf # self.object_sizes_of_interest = [ # [-1, deta1], # [start2, deta2], # [start3, deta3], # [start4, deta4], # [start5, deta5], # ] # 每个类别都应该有自己的范围 self.object_sizes_of_interest = nn.ParameterList([ start1, deta1, start2, deta2, start3, deta3, start4, deta4, start5, deta5 ])
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) scheme = "free" if cfg.MODEL.SAMPLING_FREE_ON else "focalloss" loss_evaluator = eval("RetinaNetLossComputation" + scheme.capitalize())( 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 __init__(self, cfg): if cfg.LOSS.FOCAL_LOSS == 'SIGMOID': self.cls_loss_func = SigmoidFocalLoss(cfg.MODEL.FCOS.LOSS_GAMMA, cfg.MODEL.FCOS.LOSS_ALPHA) elif cfg.LOSS.FOCAL_LOSS == 'SOFTMAX': self.cls_loss_func = SoftmaxFocalLoss(cfg.MODEL.FCOS.LOSS_GAMMA, cfg.MODEL.FCOS.LOSS_ALPHA) else: raise Exception('no focal loss type named {}'.format( cfg.LOSS.FOCAL_LOSS)) self.center_sample = cfg.MODEL.FCOS.CENTER_SAMPLE self.strides = cfg.MODEL.FCOS.FPN_STRIDES self.radius = cfg.MODEL.FCOS.POS_RADIUS self.loc_loss_type = cfg.MODEL.FCOS.LOC_LOSS_TYPE # we make use of IOU Loss for bounding boxes regression, # but we found that L1 in log scale can yield a similar performance self.box_reg_loss_func = IOULoss(self.loc_loss_type) self.centerness_loss_func = nn.BCEWithLogitsLoss() self.dense_points = cfg.MODEL.FCOS.DENSE_POINTS