202 lines
6.2 KiB
Python
202 lines
6.2 KiB
Python
# Copyright (c) OpenMMLab. All rights reserved.
|
|
"""pytest tests/test_loss_compatibility.py."""
|
|
import copy
|
|
from os.path import dirname, exists, join
|
|
|
|
import numpy as np
|
|
import pytest
|
|
import torch
|
|
|
|
|
|
def _get_config_directory():
|
|
"""Find the predefined detector config directory."""
|
|
try:
|
|
# Assume we are running in the source mmdetection repo
|
|
repo_dpath = dirname(dirname(dirname(__file__)))
|
|
except NameError:
|
|
# For IPython development when this __file__ is not defined
|
|
import mmdet
|
|
repo_dpath = dirname(dirname(mmdet.__file__))
|
|
config_dpath = join(repo_dpath, 'configs')
|
|
if not exists(config_dpath):
|
|
raise Exception('Cannot find config path')
|
|
return config_dpath
|
|
|
|
|
|
def _get_config_module(fname):
|
|
"""Load a configuration as a python module."""
|
|
from mmcv import Config
|
|
config_dpath = _get_config_directory()
|
|
config_fpath = join(config_dpath, fname)
|
|
config_mod = Config.fromfile(config_fpath)
|
|
return config_mod
|
|
|
|
|
|
def _get_detector_cfg(fname):
|
|
"""Grab configs necessary to create a detector.
|
|
|
|
These are deep copied to allow for safe modification of parameters without
|
|
influencing other tests.
|
|
"""
|
|
config = _get_config_module(fname)
|
|
model = copy.deepcopy(config.model)
|
|
return model
|
|
|
|
|
|
@pytest.mark.parametrize('loss_bbox', [
|
|
dict(type='L1Loss', loss_weight=1.0),
|
|
dict(type='GHMR', mu=0.02, bins=10, momentum=0.7, loss_weight=10.0),
|
|
dict(type='IoULoss', loss_weight=1.0),
|
|
dict(type='BoundedIoULoss', loss_weight=1.0),
|
|
dict(type='GIoULoss', loss_weight=1.0),
|
|
dict(type='DIoULoss', loss_weight=1.0),
|
|
dict(type='CIoULoss', loss_weight=1.0),
|
|
dict(type='MSELoss', loss_weight=1.0),
|
|
dict(type='SmoothL1Loss', loss_weight=1.0),
|
|
dict(type='BalancedL1Loss', loss_weight=1.0)
|
|
])
|
|
def test_bbox_loss_compatibility(loss_bbox):
|
|
"""Test loss_bbox compatibility.
|
|
|
|
Using Faster R-CNN as a sample, modifying the loss function in the config
|
|
file to verify the compatibility of Loss APIS
|
|
"""
|
|
# Faster R-CNN config dict
|
|
config_path = '_base_/models/faster_rcnn_r50_fpn.py'
|
|
cfg_model = _get_detector_cfg(config_path)
|
|
|
|
input_shape = (1, 3, 256, 256)
|
|
mm_inputs = _demo_mm_inputs(input_shape, num_items=[10])
|
|
imgs = mm_inputs.pop('imgs')
|
|
img_metas = mm_inputs.pop('img_metas')
|
|
|
|
if 'IoULoss' in loss_bbox['type']:
|
|
cfg_model.roi_head.bbox_head.reg_decoded_bbox = True
|
|
|
|
cfg_model.roi_head.bbox_head.loss_bbox = loss_bbox
|
|
|
|
from mmdet.models import build_detector
|
|
detector = build_detector(cfg_model)
|
|
|
|
loss = detector.forward(imgs, img_metas, return_loss=True, **mm_inputs)
|
|
assert isinstance(loss, dict)
|
|
loss, _ = detector._parse_losses(loss)
|
|
assert float(loss.item()) > 0
|
|
|
|
|
|
@pytest.mark.parametrize('loss_cls', [
|
|
dict(type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
|
|
dict(
|
|
type='FocalLoss',
|
|
use_sigmoid=True,
|
|
gamma=2.0,
|
|
alpha=0.25,
|
|
loss_weight=1.0),
|
|
dict(
|
|
type='GHMC', bins=30, momentum=0.75, use_sigmoid=True, loss_weight=1.0)
|
|
])
|
|
def test_cls_loss_compatibility(loss_cls):
|
|
"""Test loss_cls compatibility.
|
|
|
|
Using Faster R-CNN as a sample, modifying the loss function in the config
|
|
file to verify the compatibility of Loss APIS
|
|
"""
|
|
# Faster R-CNN config dict
|
|
config_path = '_base_/models/faster_rcnn_r50_fpn.py'
|
|
cfg_model = _get_detector_cfg(config_path)
|
|
|
|
input_shape = (1, 3, 256, 256)
|
|
mm_inputs = _demo_mm_inputs(input_shape, num_items=[10])
|
|
imgs = mm_inputs.pop('imgs')
|
|
img_metas = mm_inputs.pop('img_metas')
|
|
|
|
# verify class loss function compatibility
|
|
# for loss_cls in loss_clses:
|
|
cfg_model.roi_head.bbox_head.loss_cls = loss_cls
|
|
|
|
from mmdet.models import build_detector
|
|
detector = build_detector(cfg_model)
|
|
|
|
loss = detector.forward(imgs, img_metas, return_loss=True, **mm_inputs)
|
|
assert isinstance(loss, dict)
|
|
loss, _ = detector._parse_losses(loss)
|
|
assert float(loss.item()) > 0
|
|
|
|
|
|
def _demo_mm_inputs(input_shape=(1, 3, 300, 300),
|
|
num_items=None, num_classes=10,
|
|
with_semantic=False): # yapf: disable
|
|
"""Create a superset of inputs needed to run test or train batches.
|
|
|
|
Args:
|
|
input_shape (tuple):
|
|
input batch dimensions
|
|
|
|
num_items (None | List[int]):
|
|
specifies the number of boxes in each batch item
|
|
|
|
num_classes (int):
|
|
number of different labels a box might have
|
|
"""
|
|
from mmdet.core import BitmapMasks
|
|
|
|
(N, C, H, W) = input_shape
|
|
|
|
rng = np.random.RandomState(0)
|
|
|
|
imgs = rng.rand(*input_shape)
|
|
|
|
img_metas = [{
|
|
'img_shape': (H, W, C),
|
|
'ori_shape': (H, W, C),
|
|
'pad_shape': (H, W, C),
|
|
'filename': '<demo>.png',
|
|
'scale_factor': np.array([1.1, 1.2, 1.1, 1.2]),
|
|
'flip': False,
|
|
'flip_direction': None,
|
|
} for _ in range(N)]
|
|
|
|
gt_bboxes = []
|
|
gt_labels = []
|
|
gt_masks = []
|
|
|
|
for batch_idx in range(N):
|
|
if num_items is None:
|
|
num_boxes = rng.randint(1, 10)
|
|
else:
|
|
num_boxes = num_items[batch_idx]
|
|
|
|
cx, cy, bw, bh = rng.rand(num_boxes, 4).T
|
|
|
|
tl_x = ((cx * W) - (W * bw / 2)).clip(0, W)
|
|
tl_y = ((cy * H) - (H * bh / 2)).clip(0, H)
|
|
br_x = ((cx * W) + (W * bw / 2)).clip(0, W)
|
|
br_y = ((cy * H) + (H * bh / 2)).clip(0, H)
|
|
|
|
boxes = np.vstack([tl_x, tl_y, br_x, br_y]).T
|
|
class_idxs = rng.randint(1, num_classes, size=num_boxes)
|
|
|
|
gt_bboxes.append(torch.FloatTensor(boxes))
|
|
gt_labels.append(torch.LongTensor(class_idxs))
|
|
|
|
mask = np.random.randint(0, 2, (len(boxes), H, W), dtype=np.uint8)
|
|
gt_masks.append(BitmapMasks(mask, H, W))
|
|
|
|
mm_inputs = {
|
|
'imgs': torch.FloatTensor(imgs).requires_grad_(True),
|
|
'img_metas': img_metas,
|
|
'gt_bboxes': gt_bboxes,
|
|
'gt_labels': gt_labels,
|
|
'gt_bboxes_ignore': None,
|
|
'gt_masks': gt_masks,
|
|
}
|
|
|
|
if with_semantic:
|
|
# assume gt_semantic_seg using scale 1/8 of the img
|
|
gt_semantic_seg = np.random.randint(
|
|
0, num_classes, (1, 1, H // 8, W // 8), dtype=np.uint8)
|
|
mm_inputs.update(
|
|
{'gt_semantic_seg': torch.ByteTensor(gt_semantic_seg)})
|
|
|
|
return mm_inputs
|