|
- # Copyright (c) OpenMMLab. All rights reserved.
- import warnings
-
- import torch
- import torch.nn as nn
- from mmcv.ops import DeformConv2d, MaskedConv2d
- from mmcv.runner import BaseModule, force_fp32
-
- from mmdet.core import (anchor_inside_flags, build_assigner, build_bbox_coder,
- build_prior_generator, build_sampler, calc_region,
- images_to_levels, multi_apply, multiclass_nms, unmap)
- from ..builder import HEADS, build_loss
- from .anchor_head import AnchorHead
-
-
- class FeatureAdaption(BaseModule):
- """Feature Adaption Module.
-
- Feature Adaption Module is implemented based on DCN v1.
- It uses anchor shape prediction rather than feature map to
- predict offsets of deform conv layer.
-
- Args:
- in_channels (int): Number of channels in the input feature map.
- out_channels (int): Number of channels in the output feature map.
- kernel_size (int): Deformable conv kernel size.
- deform_groups (int): Deformable conv group size.
- init_cfg (dict or list[dict], optional): Initialization config dict.
- """
-
- def __init__(self,
- in_channels,
- out_channels,
- kernel_size=3,
- deform_groups=4,
- init_cfg=dict(
- type='Normal',
- layer='Conv2d',
- std=0.1,
- override=dict(
- type='Normal', name='conv_adaption', std=0.01))):
- super(FeatureAdaption, self).__init__(init_cfg)
- offset_channels = kernel_size * kernel_size * 2
- self.conv_offset = nn.Conv2d(
- 2, deform_groups * offset_channels, 1, bias=False)
- self.conv_adaption = DeformConv2d(
- in_channels,
- out_channels,
- kernel_size=kernel_size,
- padding=(kernel_size - 1) // 2,
- deform_groups=deform_groups)
- self.relu = nn.ReLU(inplace=True)
-
- def forward(self, x, shape):
- offset = self.conv_offset(shape.detach())
- x = self.relu(self.conv_adaption(x, offset))
- return x
-
-
- @HEADS.register_module()
- class GuidedAnchorHead(AnchorHead):
- """Guided-Anchor-based head (GA-RPN, GA-RetinaNet, etc.).
-
- This GuidedAnchorHead will predict high-quality feature guided
- anchors and locations where anchors will be kept in inference.
- There are mainly 3 categories of bounding-boxes.
-
- - Sampled 9 pairs for target assignment. (approxes)
- - The square boxes where the predicted anchors are based on. (squares)
- - Guided anchors.
-
- Please refer to https://arxiv.org/abs/1901.03278 for more details.
-
- Args:
- num_classes (int): Number of classes.
- in_channels (int): Number of channels in the input feature map.
- feat_channels (int): Number of hidden channels.
- approx_anchor_generator (dict): Config dict for approx generator
- square_anchor_generator (dict): Config dict for square generator
- anchor_coder (dict): Config dict for anchor coder
- bbox_coder (dict): Config dict for bbox coder
- reg_decoded_bbox (bool): If true, the regression loss would be
- applied directly on decoded bounding boxes, converting both
- the predicted boxes and regression targets to absolute
- coordinates format. Default False. It should be `True` when
- using `IoULoss`, `GIoULoss`, or `DIoULoss` in the bbox head.
- deform_groups: (int): Group number of DCN in
- FeatureAdaption module.
- loc_filter_thr (float): Threshold to filter out unconcerned regions.
- loss_loc (dict): Config of location loss.
- loss_shape (dict): Config of anchor shape loss.
- loss_cls (dict): Config of classification loss.
- loss_bbox (dict): Config of bbox regression loss.
- init_cfg (dict or list[dict], optional): Initialization config dict.
- """
-
- def __init__(
- self,
- num_classes,
- in_channels,
- feat_channels=256,
- approx_anchor_generator=dict(
- type='AnchorGenerator',
- octave_base_scale=8,
- scales_per_octave=3,
- ratios=[0.5, 1.0, 2.0],
- strides=[4, 8, 16, 32, 64]),
- square_anchor_generator=dict(
- type='AnchorGenerator',
- ratios=[1.0],
- scales=[8],
- strides=[4, 8, 16, 32, 64]),
- anchor_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]
- ),
- bbox_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]
- ),
- reg_decoded_bbox=False,
- deform_groups=4,
- loc_filter_thr=0.01,
- train_cfg=None,
- test_cfg=None,
- loss_loc=dict(
- type='FocalLoss',
- use_sigmoid=True,
- gamma=2.0,
- alpha=0.25,
- loss_weight=1.0),
- loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0),
- loss_cls=dict(
- type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
- loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
- loss_weight=1.0),
- init_cfg=dict(type='Normal', layer='Conv2d', std=0.01,
- override=dict(type='Normal',
- name='conv_loc',
- std=0.01,
- bias_prob=0.01))): # yapf: disable
- super(AnchorHead, self).__init__(init_cfg)
- self.in_channels = in_channels
- self.num_classes = num_classes
- self.feat_channels = feat_channels
- self.deform_groups = deform_groups
- self.loc_filter_thr = loc_filter_thr
-
- # build approx_anchor_generator and square_anchor_generator
- assert (approx_anchor_generator['octave_base_scale'] ==
- square_anchor_generator['scales'][0])
- assert (approx_anchor_generator['strides'] ==
- square_anchor_generator['strides'])
- self.approx_anchor_generator = build_prior_generator(
- approx_anchor_generator)
- self.square_anchor_generator = build_prior_generator(
- square_anchor_generator)
- self.approxs_per_octave = self.approx_anchor_generator \
- .num_base_priors[0]
-
- self.reg_decoded_bbox = reg_decoded_bbox
-
- # one anchor per location
- self.num_base_priors = self.square_anchor_generator.num_base_priors[0]
-
- self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False)
- self.loc_focal_loss = loss_loc['type'] in ['FocalLoss']
- self.sampling = loss_cls['type'] not in ['FocalLoss']
- self.ga_sampling = train_cfg is not None and hasattr(
- train_cfg, 'ga_sampler')
- if self.use_sigmoid_cls:
- self.cls_out_channels = self.num_classes
- else:
- self.cls_out_channels = self.num_classes + 1
-
- # build bbox_coder
- self.anchor_coder = build_bbox_coder(anchor_coder)
- self.bbox_coder = build_bbox_coder(bbox_coder)
-
- # build losses
- self.loss_loc = build_loss(loss_loc)
- self.loss_shape = build_loss(loss_shape)
- self.loss_cls = build_loss(loss_cls)
- self.loss_bbox = build_loss(loss_bbox)
-
- self.train_cfg = train_cfg
- self.test_cfg = test_cfg
-
- if self.train_cfg:
- self.assigner = build_assigner(self.train_cfg.assigner)
- # use PseudoSampler when sampling is False
- if self.sampling and hasattr(self.train_cfg, 'sampler'):
- sampler_cfg = self.train_cfg.sampler
- else:
- sampler_cfg = dict(type='PseudoSampler')
- self.sampler = build_sampler(sampler_cfg, context=self)
-
- self.ga_assigner = build_assigner(self.train_cfg.ga_assigner)
- if self.ga_sampling:
- ga_sampler_cfg = self.train_cfg.ga_sampler
- else:
- ga_sampler_cfg = dict(type='PseudoSampler')
- self.ga_sampler = build_sampler(ga_sampler_cfg, context=self)
-
- self.fp16_enabled = False
-
- self._init_layers()
-
- @property
- def num_anchors(self):
- warnings.warn('DeprecationWarning: `num_anchors` is deprecated, '
- 'please use "num_base_priors" instead')
- return self.square_anchor_generator.num_base_priors[0]
-
- def _init_layers(self):
- self.relu = nn.ReLU(inplace=True)
- self.conv_loc = nn.Conv2d(self.in_channels, 1, 1)
- self.conv_shape = nn.Conv2d(self.in_channels, self.num_base_priors * 2,
- 1)
- self.feature_adaption = FeatureAdaption(
- self.in_channels,
- self.feat_channels,
- kernel_size=3,
- deform_groups=self.deform_groups)
- self.conv_cls = MaskedConv2d(
- self.feat_channels, self.num_base_priors * self.cls_out_channels,
- 1)
- self.conv_reg = MaskedConv2d(self.feat_channels,
- self.num_base_priors * 4, 1)
-
- def forward_single(self, x):
- loc_pred = self.conv_loc(x)
- shape_pred = self.conv_shape(x)
- x = self.feature_adaption(x, shape_pred)
- # masked conv is only used during inference for speed-up
- if not self.training:
- mask = loc_pred.sigmoid()[0] >= self.loc_filter_thr
- else:
- mask = None
- cls_score = self.conv_cls(x, mask)
- bbox_pred = self.conv_reg(x, mask)
- return cls_score, bbox_pred, shape_pred, loc_pred
-
- def forward(self, feats):
- return multi_apply(self.forward_single, feats)
-
- def get_sampled_approxs(self, featmap_sizes, img_metas, device='cuda'):
- """Get sampled approxs and inside flags according to feature map sizes.
-
- Args:
- featmap_sizes (list[tuple]): Multi-level feature map sizes.
- img_metas (list[dict]): Image meta info.
- device (torch.device | str): device for returned tensors
-
- Returns:
- tuple: approxes of each image, inside flags of each image
- """
- num_imgs = len(img_metas)
-
- # since feature map sizes of all images are the same, we only compute
- # approxes for one time
- multi_level_approxs = self.approx_anchor_generator.grid_priors(
- featmap_sizes, device=device)
- approxs_list = [multi_level_approxs for _ in range(num_imgs)]
-
- # for each image, we compute inside flags of multi level approxes
- inside_flag_list = []
- for img_id, img_meta in enumerate(img_metas):
- multi_level_flags = []
- multi_level_approxs = approxs_list[img_id]
-
- # obtain valid flags for each approx first
- multi_level_approx_flags = self.approx_anchor_generator \
- .valid_flags(featmap_sizes,
- img_meta['pad_shape'],
- device=device)
-
- for i, flags in enumerate(multi_level_approx_flags):
- approxs = multi_level_approxs[i]
- inside_flags_list = []
- for i in range(self.approxs_per_octave):
- split_valid_flags = flags[i::self.approxs_per_octave]
- split_approxs = approxs[i::self.approxs_per_octave, :]
- inside_flags = anchor_inside_flags(
- split_approxs, split_valid_flags,
- img_meta['img_shape'][:2],
- self.train_cfg.allowed_border)
- inside_flags_list.append(inside_flags)
- # inside_flag for a position is true if any anchor in this
- # position is true
- inside_flags = (
- torch.stack(inside_flags_list, 0).sum(dim=0) > 0)
- multi_level_flags.append(inside_flags)
- inside_flag_list.append(multi_level_flags)
- return approxs_list, inside_flag_list
-
- def get_anchors(self,
- featmap_sizes,
- shape_preds,
- loc_preds,
- img_metas,
- use_loc_filter=False,
- device='cuda'):
- """Get squares according to feature map sizes and guided anchors.
-
- Args:
- featmap_sizes (list[tuple]): Multi-level feature map sizes.
- shape_preds (list[tensor]): Multi-level shape predictions.
- loc_preds (list[tensor]): Multi-level location predictions.
- img_metas (list[dict]): Image meta info.
- use_loc_filter (bool): Use loc filter or not.
- device (torch.device | str): device for returned tensors
-
- Returns:
- tuple: square approxs of each image, guided anchors of each image,
- loc masks of each image
- """
- num_imgs = len(img_metas)
- num_levels = len(featmap_sizes)
-
- # since feature map sizes of all images are the same, we only compute
- # squares for one time
- multi_level_squares = self.square_anchor_generator.grid_priors(
- featmap_sizes, device=device)
- squares_list = [multi_level_squares for _ in range(num_imgs)]
-
- # for each image, we compute multi level guided anchors
- guided_anchors_list = []
- loc_mask_list = []
- for img_id, img_meta in enumerate(img_metas):
- multi_level_guided_anchors = []
- multi_level_loc_mask = []
- for i in range(num_levels):
- squares = squares_list[img_id][i]
- shape_pred = shape_preds[i][img_id]
- loc_pred = loc_preds[i][img_id]
- guided_anchors, loc_mask = self._get_guided_anchors_single(
- squares,
- shape_pred,
- loc_pred,
- use_loc_filter=use_loc_filter)
- multi_level_guided_anchors.append(guided_anchors)
- multi_level_loc_mask.append(loc_mask)
- guided_anchors_list.append(multi_level_guided_anchors)
- loc_mask_list.append(multi_level_loc_mask)
- return squares_list, guided_anchors_list, loc_mask_list
-
- def _get_guided_anchors_single(self,
- squares,
- shape_pred,
- loc_pred,
- use_loc_filter=False):
- """Get guided anchors and loc masks for a single level.
-
- Args:
- square (tensor): Squares of a single level.
- shape_pred (tensor): Shape predictions of a single level.
- loc_pred (tensor): Loc predictions of a single level.
- use_loc_filter (list[tensor]): Use loc filter or not.
-
- Returns:
- tuple: guided anchors, location masks
- """
- # calculate location filtering mask
- loc_pred = loc_pred.sigmoid().detach()
- if use_loc_filter:
- loc_mask = loc_pred >= self.loc_filter_thr
- else:
- loc_mask = loc_pred >= 0.0
- mask = loc_mask.permute(1, 2, 0).expand(-1, -1, self.num_base_priors)
- mask = mask.contiguous().view(-1)
- # calculate guided anchors
- squares = squares[mask]
- anchor_deltas = shape_pred.permute(1, 2, 0).contiguous().view(
- -1, 2).detach()[mask]
- bbox_deltas = anchor_deltas.new_full(squares.size(), 0)
- bbox_deltas[:, 2:] = anchor_deltas
- guided_anchors = self.anchor_coder.decode(
- squares, bbox_deltas, wh_ratio_clip=1e-6)
- return guided_anchors, mask
-
- def ga_loc_targets(self, gt_bboxes_list, featmap_sizes):
- """Compute location targets for guided anchoring.
-
- Each feature map is divided into positive, negative and ignore regions.
- - positive regions: target 1, weight 1
- - ignore regions: target 0, weight 0
- - negative regions: target 0, weight 0.1
-
- Args:
- gt_bboxes_list (list[Tensor]): Gt bboxes of each image.
- featmap_sizes (list[tuple]): Multi level sizes of each feature
- maps.
-
- Returns:
- tuple
- """
- anchor_scale = self.approx_anchor_generator.octave_base_scale
- anchor_strides = self.approx_anchor_generator.strides
- # Currently only supports same stride in x and y direction.
- for stride in anchor_strides:
- assert (stride[0] == stride[1])
- anchor_strides = [stride[0] for stride in anchor_strides]
-
- center_ratio = self.train_cfg.center_ratio
- ignore_ratio = self.train_cfg.ignore_ratio
- img_per_gpu = len(gt_bboxes_list)
- num_lvls = len(featmap_sizes)
- r1 = (1 - center_ratio) / 2
- r2 = (1 - ignore_ratio) / 2
- all_loc_targets = []
- all_loc_weights = []
- all_ignore_map = []
- for lvl_id in range(num_lvls):
- h, w = featmap_sizes[lvl_id]
- loc_targets = torch.zeros(
- img_per_gpu,
- 1,
- h,
- w,
- device=gt_bboxes_list[0].device,
- dtype=torch.float32)
- loc_weights = torch.full_like(loc_targets, -1)
- ignore_map = torch.zeros_like(loc_targets)
- all_loc_targets.append(loc_targets)
- all_loc_weights.append(loc_weights)
- all_ignore_map.append(ignore_map)
- for img_id in range(img_per_gpu):
- gt_bboxes = gt_bboxes_list[img_id]
- scale = torch.sqrt((gt_bboxes[:, 2] - gt_bboxes[:, 0]) *
- (gt_bboxes[:, 3] - gt_bboxes[:, 1]))
- min_anchor_size = scale.new_full(
- (1, ), float(anchor_scale * anchor_strides[0]))
- # assign gt bboxes to different feature levels w.r.t. their scales
- target_lvls = torch.floor(
- torch.log2(scale) - torch.log2(min_anchor_size) + 0.5)
- target_lvls = target_lvls.clamp(min=0, max=num_lvls - 1).long()
- for gt_id in range(gt_bboxes.size(0)):
- lvl = target_lvls[gt_id].item()
- # rescaled to corresponding feature map
- gt_ = gt_bboxes[gt_id, :4] / anchor_strides[lvl]
- # calculate ignore regions
- ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
- gt_, r2, featmap_sizes[lvl])
- # calculate positive (center) regions
- ctr_x1, ctr_y1, ctr_x2, ctr_y2 = calc_region(
- gt_, r1, featmap_sizes[lvl])
- all_loc_targets[lvl][img_id, 0, ctr_y1:ctr_y2 + 1,
- ctr_x1:ctr_x2 + 1] = 1
- all_loc_weights[lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
- ignore_x1:ignore_x2 + 1] = 0
- all_loc_weights[lvl][img_id, 0, ctr_y1:ctr_y2 + 1,
- ctr_x1:ctr_x2 + 1] = 1
- # calculate ignore map on nearby low level feature
- if lvl > 0:
- d_lvl = lvl - 1
- # rescaled to corresponding feature map
- gt_ = gt_bboxes[gt_id, :4] / anchor_strides[d_lvl]
- ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
- gt_, r2, featmap_sizes[d_lvl])
- all_ignore_map[d_lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
- ignore_x1:ignore_x2 + 1] = 1
- # calculate ignore map on nearby high level feature
- if lvl < num_lvls - 1:
- u_lvl = lvl + 1
- # rescaled to corresponding feature map
- gt_ = gt_bboxes[gt_id, :4] / anchor_strides[u_lvl]
- ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
- gt_, r2, featmap_sizes[u_lvl])
- all_ignore_map[u_lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
- ignore_x1:ignore_x2 + 1] = 1
- for lvl_id in range(num_lvls):
- # ignore negative regions w.r.t. ignore map
- all_loc_weights[lvl_id][(all_loc_weights[lvl_id] < 0)
- & (all_ignore_map[lvl_id] > 0)] = 0
- # set negative regions with weight 0.1
- all_loc_weights[lvl_id][all_loc_weights[lvl_id] < 0] = 0.1
- # loc average factor to balance loss
- loc_avg_factor = sum(
- [t.size(0) * t.size(-1) * t.size(-2)
- for t in all_loc_targets]) / 200
- return all_loc_targets, all_loc_weights, loc_avg_factor
-
- def _ga_shape_target_single(self,
- flat_approxs,
- inside_flags,
- flat_squares,
- gt_bboxes,
- gt_bboxes_ignore,
- img_meta,
- unmap_outputs=True):
- """Compute guided anchoring targets.
-
- This function returns sampled anchors and gt bboxes directly
- rather than calculates regression targets.
-
- Args:
- flat_approxs (Tensor): flat approxs of a single image,
- shape (n, 4)
- inside_flags (Tensor): inside flags of a single image,
- shape (n, ).
- flat_squares (Tensor): flat squares of a single image,
- shape (approxs_per_octave * n, 4)
- gt_bboxes (Tensor): Ground truth bboxes of a single image.
- img_meta (dict): Meta info of a single image.
- approxs_per_octave (int): number of approxs per octave
- cfg (dict): RPN train configs.
- unmap_outputs (bool): unmap outputs or not.
-
- Returns:
- tuple
- """
- if not inside_flags.any():
- return (None, ) * 5
- # assign gt and sample anchors
- expand_inside_flags = inside_flags[:, None].expand(
- -1, self.approxs_per_octave).reshape(-1)
- approxs = flat_approxs[expand_inside_flags, :]
- squares = flat_squares[inside_flags, :]
-
- assign_result = self.ga_assigner.assign(approxs, squares,
- self.approxs_per_octave,
- gt_bboxes, gt_bboxes_ignore)
- sampling_result = self.ga_sampler.sample(assign_result, squares,
- gt_bboxes)
-
- bbox_anchors = torch.zeros_like(squares)
- bbox_gts = torch.zeros_like(squares)
- bbox_weights = torch.zeros_like(squares)
-
- pos_inds = sampling_result.pos_inds
- neg_inds = sampling_result.neg_inds
- if len(pos_inds) > 0:
- bbox_anchors[pos_inds, :] = sampling_result.pos_bboxes
- bbox_gts[pos_inds, :] = sampling_result.pos_gt_bboxes
- bbox_weights[pos_inds, :] = 1.0
-
- # map up to original set of anchors
- if unmap_outputs:
- num_total_anchors = flat_squares.size(0)
- bbox_anchors = unmap(bbox_anchors, num_total_anchors, inside_flags)
- bbox_gts = unmap(bbox_gts, num_total_anchors, inside_flags)
- bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
-
- return (bbox_anchors, bbox_gts, bbox_weights, pos_inds, neg_inds)
-
- def ga_shape_targets(self,
- approx_list,
- inside_flag_list,
- square_list,
- gt_bboxes_list,
- img_metas,
- gt_bboxes_ignore_list=None,
- unmap_outputs=True):
- """Compute guided anchoring targets.
-
- Args:
- approx_list (list[list]): Multi level approxs of each image.
- inside_flag_list (list[list]): Multi level inside flags of each
- image.
- square_list (list[list]): Multi level squares of each image.
- gt_bboxes_list (list[Tensor]): Ground truth bboxes of each image.
- img_metas (list[dict]): Meta info of each image.
- gt_bboxes_ignore_list (list[Tensor]): ignore list of gt bboxes.
- unmap_outputs (bool): unmap outputs or not.
-
- Returns:
- tuple
- """
- num_imgs = len(img_metas)
- assert len(approx_list) == len(inside_flag_list) == len(
- square_list) == num_imgs
- # anchor number of multi levels
- num_level_squares = [squares.size(0) for squares in square_list[0]]
- # concat all level anchors and flags to a single tensor
- inside_flag_flat_list = []
- approx_flat_list = []
- square_flat_list = []
- for i in range(num_imgs):
- assert len(square_list[i]) == len(inside_flag_list[i])
- inside_flag_flat_list.append(torch.cat(inside_flag_list[i]))
- approx_flat_list.append(torch.cat(approx_list[i]))
- square_flat_list.append(torch.cat(square_list[i]))
-
- # compute targets for each image
- if gt_bboxes_ignore_list is None:
- gt_bboxes_ignore_list = [None for _ in range(num_imgs)]
- (all_bbox_anchors, all_bbox_gts, all_bbox_weights, pos_inds_list,
- neg_inds_list) = multi_apply(
- self._ga_shape_target_single,
- approx_flat_list,
- inside_flag_flat_list,
- square_flat_list,
- gt_bboxes_list,
- gt_bboxes_ignore_list,
- img_metas,
- unmap_outputs=unmap_outputs)
- # no valid anchors
- if any([bbox_anchors is None for bbox_anchors in all_bbox_anchors]):
- return None
- # sampled anchors of all images
- num_total_pos = sum([max(inds.numel(), 1) for inds in pos_inds_list])
- num_total_neg = sum([max(inds.numel(), 1) for inds in neg_inds_list])
- # split targets to a list w.r.t. multiple levels
- bbox_anchors_list = images_to_levels(all_bbox_anchors,
- num_level_squares)
- bbox_gts_list = images_to_levels(all_bbox_gts, num_level_squares)
- bbox_weights_list = images_to_levels(all_bbox_weights,
- num_level_squares)
- return (bbox_anchors_list, bbox_gts_list, bbox_weights_list,
- num_total_pos, num_total_neg)
-
- def loss_shape_single(self, shape_pred, bbox_anchors, bbox_gts,
- anchor_weights, anchor_total_num):
- shape_pred = shape_pred.permute(0, 2, 3, 1).contiguous().view(-1, 2)
- bbox_anchors = bbox_anchors.contiguous().view(-1, 4)
- bbox_gts = bbox_gts.contiguous().view(-1, 4)
- anchor_weights = anchor_weights.contiguous().view(-1, 4)
- bbox_deltas = bbox_anchors.new_full(bbox_anchors.size(), 0)
- bbox_deltas[:, 2:] += shape_pred
- # filter out negative samples to speed-up weighted_bounded_iou_loss
- inds = torch.nonzero(
- anchor_weights[:, 0] > 0, as_tuple=False).squeeze(1)
- bbox_deltas_ = bbox_deltas[inds]
- bbox_anchors_ = bbox_anchors[inds]
- bbox_gts_ = bbox_gts[inds]
- anchor_weights_ = anchor_weights[inds]
- pred_anchors_ = self.anchor_coder.decode(
- bbox_anchors_, bbox_deltas_, wh_ratio_clip=1e-6)
- loss_shape = self.loss_shape(
- pred_anchors_,
- bbox_gts_,
- anchor_weights_,
- avg_factor=anchor_total_num)
- return loss_shape
-
- def loss_loc_single(self, loc_pred, loc_target, loc_weight,
- loc_avg_factor):
- loss_loc = self.loss_loc(
- loc_pred.reshape(-1, 1),
- loc_target.reshape(-1).long(),
- loc_weight.reshape(-1),
- avg_factor=loc_avg_factor)
- return loss_loc
-
- @force_fp32(
- apply_to=('cls_scores', 'bbox_preds', 'shape_preds', 'loc_preds'))
- def loss(self,
- cls_scores,
- bbox_preds,
- shape_preds,
- loc_preds,
- gt_bboxes,
- gt_labels,
- img_metas,
- gt_bboxes_ignore=None):
- featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
- assert len(featmap_sizes) == self.approx_anchor_generator.num_levels
-
- device = cls_scores[0].device
-
- # get loc targets
- loc_targets, loc_weights, loc_avg_factor = self.ga_loc_targets(
- gt_bboxes, featmap_sizes)
-
- # get sampled approxes
- approxs_list, inside_flag_list = self.get_sampled_approxs(
- featmap_sizes, img_metas, device=device)
- # get squares and guided anchors
- squares_list, guided_anchors_list, _ = self.get_anchors(
- featmap_sizes, shape_preds, loc_preds, img_metas, device=device)
-
- # get shape targets
- shape_targets = self.ga_shape_targets(approxs_list, inside_flag_list,
- squares_list, gt_bboxes,
- img_metas)
- if shape_targets is None:
- return None
- (bbox_anchors_list, bbox_gts_list, anchor_weights_list, anchor_fg_num,
- anchor_bg_num) = shape_targets
- anchor_total_num = (
- anchor_fg_num if not self.ga_sampling else anchor_fg_num +
- anchor_bg_num)
-
- # get anchor targets
- label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1
- cls_reg_targets = self.get_targets(
- guided_anchors_list,
- inside_flag_list,
- gt_bboxes,
- img_metas,
- gt_bboxes_ignore_list=gt_bboxes_ignore,
- gt_labels_list=gt_labels,
- label_channels=label_channels)
- if cls_reg_targets is None:
- return None
- (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
- num_total_pos, num_total_neg) = cls_reg_targets
- num_total_samples = (
- num_total_pos + num_total_neg if self.sampling else num_total_pos)
-
- # anchor number of multi levels
- num_level_anchors = [
- anchors.size(0) for anchors in guided_anchors_list[0]
- ]
- # concat all level anchors to a single tensor
- concat_anchor_list = []
- for i in range(len(guided_anchors_list)):
- concat_anchor_list.append(torch.cat(guided_anchors_list[i]))
- all_anchor_list = images_to_levels(concat_anchor_list,
- num_level_anchors)
-
- # get classification and bbox regression losses
- losses_cls, losses_bbox = multi_apply(
- self.loss_single,
- cls_scores,
- bbox_preds,
- all_anchor_list,
- labels_list,
- label_weights_list,
- bbox_targets_list,
- bbox_weights_list,
- num_total_samples=num_total_samples)
-
- # get anchor location loss
- losses_loc = []
- for i in range(len(loc_preds)):
- loss_loc = self.loss_loc_single(
- loc_preds[i],
- loc_targets[i],
- loc_weights[i],
- loc_avg_factor=loc_avg_factor)
- losses_loc.append(loss_loc)
-
- # get anchor shape loss
- losses_shape = []
- for i in range(len(shape_preds)):
- loss_shape = self.loss_shape_single(
- shape_preds[i],
- bbox_anchors_list[i],
- bbox_gts_list[i],
- anchor_weights_list[i],
- anchor_total_num=anchor_total_num)
- losses_shape.append(loss_shape)
-
- return dict(
- loss_cls=losses_cls,
- loss_bbox=losses_bbox,
- loss_shape=losses_shape,
- loss_loc=losses_loc)
-
- @force_fp32(
- apply_to=('cls_scores', 'bbox_preds', 'shape_preds', 'loc_preds'))
- def get_bboxes(self,
- cls_scores,
- bbox_preds,
- shape_preds,
- loc_preds,
- img_metas,
- cfg=None,
- rescale=False):
- assert len(cls_scores) == len(bbox_preds) == len(shape_preds) == len(
- loc_preds)
- num_levels = len(cls_scores)
- featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
- device = cls_scores[0].device
- # get guided anchors
- _, guided_anchors, loc_masks = self.get_anchors(
- featmap_sizes,
- shape_preds,
- loc_preds,
- img_metas,
- use_loc_filter=not self.training,
- device=device)
- result_list = []
- for img_id in range(len(img_metas)):
- cls_score_list = [
- cls_scores[i][img_id].detach() for i in range(num_levels)
- ]
- bbox_pred_list = [
- bbox_preds[i][img_id].detach() for i in range(num_levels)
- ]
- guided_anchor_list = [
- guided_anchors[img_id][i].detach() for i in range(num_levels)
- ]
- loc_mask_list = [
- loc_masks[img_id][i].detach() for i in range(num_levels)
- ]
- img_shape = img_metas[img_id]['img_shape']
- scale_factor = img_metas[img_id]['scale_factor']
- proposals = self._get_bboxes_single(cls_score_list, bbox_pred_list,
- guided_anchor_list,
- loc_mask_list, img_shape,
- scale_factor, cfg, rescale)
- result_list.append(proposals)
- return result_list
-
- def _get_bboxes_single(self,
- cls_scores,
- bbox_preds,
- mlvl_anchors,
- mlvl_masks,
- img_shape,
- scale_factor,
- cfg,
- rescale=False):
- cfg = self.test_cfg if cfg is None else cfg
- assert len(cls_scores) == len(bbox_preds) == len(mlvl_anchors)
- mlvl_bboxes = []
- mlvl_scores = []
- for cls_score, bbox_pred, anchors, mask in zip(cls_scores, bbox_preds,
- mlvl_anchors,
- mlvl_masks):
- assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
- # if no location is kept, end.
- if mask.sum() == 0:
- continue
- # reshape scores and bbox_pred
- cls_score = cls_score.permute(1, 2,
- 0).reshape(-1, self.cls_out_channels)
- if self.use_sigmoid_cls:
- scores = cls_score.sigmoid()
- else:
- scores = cls_score.softmax(-1)
- bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
- # filter scores, bbox_pred w.r.t. mask.
- # anchors are filtered in get_anchors() beforehand.
- scores = scores[mask, :]
- bbox_pred = bbox_pred[mask, :]
- if scores.dim() == 0:
- anchors = anchors.unsqueeze(0)
- scores = scores.unsqueeze(0)
- bbox_pred = bbox_pred.unsqueeze(0)
- # filter anchors, bbox_pred, scores w.r.t. scores
- nms_pre = cfg.get('nms_pre', -1)
- if nms_pre > 0 and scores.shape[0] > nms_pre:
- if self.use_sigmoid_cls:
- max_scores, _ = scores.max(dim=1)
- else:
- # remind that we set FG labels to [0, num_class-1]
- # since mmdet v2.0
- # BG cat_id: num_class
- max_scores, _ = scores[:, :-1].max(dim=1)
- _, topk_inds = max_scores.topk(nms_pre)
- anchors = anchors[topk_inds, :]
- bbox_pred = bbox_pred[topk_inds, :]
- scores = scores[topk_inds, :]
- bboxes = self.bbox_coder.decode(
- anchors, bbox_pred, max_shape=img_shape)
- mlvl_bboxes.append(bboxes)
- mlvl_scores.append(scores)
- mlvl_bboxes = torch.cat(mlvl_bboxes)
- if rescale:
- mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor)
- mlvl_scores = torch.cat(mlvl_scores)
- if self.use_sigmoid_cls:
- # Add a dummy background class to the backend when using sigmoid
- # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
- # BG cat_id: num_class
- padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1)
- mlvl_scores = torch.cat([mlvl_scores, padding], dim=1)
- # multi class NMS
- det_bboxes, det_labels = multiclass_nms(mlvl_bboxes, mlvl_scores,
- cfg.score_thr, cfg.nms,
- cfg.max_per_img)
- return det_bboxes, det_labels
|