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