def _test_mdconv(self, dtype=torch.float, device='cuda'):
if not torch.cuda.is_available() and device == 'cuda':
pytest.skip('test requires GPU')
from mmcv.ops import ModulatedDeformConv2dPack
input = torch.tensor(input_t, dtype=dtype, device=device)
input.requires_grad = True
dcn = ModulatedDeformConv2dPack(
1,
1,
kernel_size=(2, 2),
stride=1,
padding=1,
deform_groups=1,
bias=False)
if device == 'cuda':
dcn.cuda()
dcn.weight.data.fill_(1.)
dcn.type(dtype)
output = dcn(input)
output.sum().backward()
assert numpy.allclose(output.cpu().detach().numpy(), output_t, 1e-2)
assert numpy.allclose(input.grad.cpu().detach().numpy(), input_grad,
1e-2)
assert numpy.allclose(dcn.weight.grad.cpu().detach().numpy(),
dcn_w_grad, 1e-2)
assert numpy.allclose(
dcn.conv_offset.weight.grad.cpu().detach().numpy(),
dcn_offset_w_grad, 1e-2)
assert numpy.allclose(dcn.conv_offset.bias.grad.cpu().detach().numpy(),
dcn_offset_b_grad, 1e-2)
def __init__(self, in_planes, out_planes, modulate_deform=True):
super(DeconvLayer, self).__init__()
if modulate_deform:
self.dcn = ModulatedDeformConv2dPack(in_planes,
out_planes,
kernel_size=3,
padding=1,
deform_groups=1)
else:
self.dcn = DeformConv2dPack(in_planes,
out_planes,
kernel_size=3,
padding=1,
deform_groups=1)
self.dcn_bn = nn.BatchNorm2d(out_planes)
self.up_sample = nn.UpsamplingBilinear2d(scale_factor=2)
self.relu = nn.ReLU(inplace=True)
def build_upsample(self, inplanes, planes, norm_cfg=None):
mdcn = ModulatedDeformConv2dPack(inplanes,
planes,
3,
stride=1,
padding=1,
dilation=1,
deform_groups=1)
up = nn.UpsamplingBilinear2d(scale_factor=2)
layers = []
layers.append(mdcn)
if norm_cfg:
layers.append(build_norm_layer(norm_cfg, planes)[1])
layers.append(nn.ReLU(inplace=True))
layers.append(up)
return nn.Sequential(*layers)
def _test_amp_mdconv(self, input_dtype=torch.float):
"""The function to test amp released on pytorch 1.6.0.
The type of input data might be torch.float or torch.half,
so we should test mdconv in both cases. With amp, the data
type of model will NOT be set manually.
Args:
input_dtype: torch.float or torch.half.
"""
if not torch.cuda.is_available():
return
from mmcv.ops import ModulatedDeformConv2dPack
input = torch.tensor(input_t).cuda().type(input_dtype)
input.requires_grad = True
dcn = ModulatedDeformConv2dPack(
1,
1,
kernel_size=(2, 2),
stride=1,
padding=1,
deform_groups=1,
bias=False).cuda()
dcn.weight.data.fill_(1.)
output = dcn(input)
output.sum().backward()
assert numpy.allclose(output.cpu().detach().numpy(), output_t, 1e-2)
assert numpy.allclose(input.grad.cpu().detach().numpy(), input_grad,
1e-2)
assert numpy.allclose(dcn.weight.grad.cpu().detach().numpy(),
dcn_w_grad, 1e-2)
assert numpy.allclose(
dcn.conv_offset.weight.grad.cpu().detach().numpy(),
dcn_offset_w_grad, 1e-2)
assert numpy.allclose(dcn.conv_offset.bias.grad.cpu().detach().numpy(),
dcn_offset_b_grad, 1e-2)
def test_modulated_deform_conv(with_bias):
try:
from mmcv.ops import ModulatedDeformConv2dPack
except (ImportError, ModuleNotFoundError):
pytest.skip('test requires compilation')
input = [[[[1., 2., 3.], [0., 1., 2.], [3., 5., 2.]]]]
x = torch.Tensor(input).cuda()
model = ModulatedDeformConv2dPack(1,
1,
kernel_size=(2, 2),
stride=1,
padding=1,
deform_groups=1,
bias=with_bias)
model.weight.data.fill_(1.)
model.type(torch.float32)
model = model.cuda().eval()
input_names = ['input']
output_names = ['output']
with torch.no_grad():
torch.onnx.export(model, (x.clone(), ),
onnx_file,
export_params=True,
keep_initializers_as_inputs=True,
input_names=input_names,
output_names=output_names,
opset_version=11)
onnx_model = onnx.load(onnx_file)
# create trt engine and wrapper
opt_shape_dict = {
'input': [list(x.shape), list(x.shape),
list(x.shape)],
}
# trt config
fp16_mode = False
max_workspace_size = 1 << 30
trt_engine = onnx2trt(onnx_model,
opt_shape_dict,
fp16_mode=fp16_mode,
max_workspace_size=max_workspace_size)
save_trt_engine(trt_engine, trt_file)
trt_model = TRTWrapper(trt_file, input_names, output_names)
with torch.no_grad():
trt_outputs = trt_model({'input': x.clone()})
trt_results = trt_outputs['output']
# compute pytorch_output
with torch.no_grad():
pytorch_results = model(x.clone())
# allclose
if os.path.exists(onnx_file):
os.remove(onnx_file)
if os.path.exists(trt_file):
os.remove(trt_file)
torch.testing.assert_allclose(pytorch_results, trt_results)
def _init_layers(self):
self.cls_convs = nn.ModuleList()
self.reg_convs = nn.ModuleList()
self.mask_convs = nn.ModuleList()
for i in range(self.stacked_convs):
chn = self.in_channels if i == 0 else self.feat_channels
if not self.use_dcn:
self.cls_convs.append(
ConvModule(
chn,
self.feat_channels,
3,
stride=1,
padding=1,
conv_cfg=self.conv_cfg,
norm_cfg=self.norm_cfg,
bias=self.norm_cfg is None))
self.reg_convs.append(
ConvModule(
chn,
self.feat_channels,
3,
stride=1,
padding=1,
conv_cfg=self.conv_cfg,
norm_cfg=self.norm_cfg,
bias=self.norm_cfg is None))
self.mask_convs.append(
ConvModule(
chn,
self.feat_channels,
3,
stride=1,
padding=1,
conv_cfg=self.conv_cfg,
norm_cfg=self.norm_cfg,
bias=self.norm_cfg is None))
else:
self.cls_convs.append(
ModulatedDeformConv2dPack(
chn,
self.feat_channels,
3,
stride=1,
padding=1,
dilation=1,
deformable_groups=1,
))
if self.norm_cfg:
self.cls_convs.append(build_norm_layer(
self.norm_cfg, self.feat_channels)[1])
self.cls_convs.append(nn.ReLU(inplace=True))
self.reg_convs.append(
ModulatedDeformConv2dPack(
chn,
self.feat_channels,
3,
stride=1,
padding=1,
dilation=1,
deformable_groups=1,
))
if self.norm_cfg:
self.reg_convs.append(build_norm_layer(
self.norm_cfg, self.feat_channels)[1])
self.reg_convs.append(nn.ReLU(inplace=True))
self.mask_convs.append(
ModulatedDeformConv2dPack(
chn,
self.feat_channels,
3,
stride=1,
padding=1,
dilation=1,
deformable_groups=1,
))
if self.norm_cfg:
self.mask_convs.append(build_norm_layer(
self.norm_cfg, self.feat_channels)[1])
self.mask_convs.append(nn.ReLU(inplace=True))
self.polar_cls = nn.Conv2d(
self.feat_channels, self.cls_out_channels, 3, padding=1)
self.polar_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
self.polar_mask = nn.Conv2d(self.feat_channels, 36, 3, padding=1)
self.polar_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1)
self.scales_bbox = nn.ModuleList([Scale(1.0) for _ in self.strides])
self.scales_mask = nn.ModuleList([Scale(1.0) for _ in self.strides])
