#!/usr/bin/env python # -*- coding:utf-8 -*- # Author: Deformable ConvNets v2: More Deformable, Better Results # Modified by: RainbowSecret(yuyua@microsoft.com) # Select Seg Model for img segmentation. import pdb import torch import torch.nn as nn import torch.utils.checkpoint as cp from collections import OrderedDict from lib.models.tools.module_helper import ModuleHelper from lib.extensions.dcn import ModulatedDeformConv, ModulatedDeformRoIPoolingPack, DeformConv def conv3x3(in_planes, out_planes, stride=1, dilation=1): "3x3 convolution with padding" return nn.Conv2d( in_planes, out_planes, kernel_size=3, stride=stride, padding=dilation, dilation=dilation, bias=False) class BasicBlock(nn.Module): expansion = 1 def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None, style='pytorch', with_cp=False, bn_type=None): super(BasicBlock, self).__init__() self.conv1 = conv3x3(inplanes, planes, stride, dilation) self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes) self.relu = nn.ReLU(inplace=False) self.relu_in = nn.ReLU(inplace=True) self.conv2 = conv3x3(planes, planes) self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes) self.downsample = downsample self.stride = stride self.dilation = dilation assert not with_cp def forward(self, x): residual = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) if self.downsample is not None: residual = self.downsample(x) out = out + residual out = self.relu_in(out) return out class Bottleneck(nn.Module): expansion = 4 def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None, style='pytorch', with_cp=False, with_dcn=False, num_deformable_groups=1, dcn_offset_lr_mult=0.1, use_regular_conv_on_stride=False, use_modulated_dcn=False, bn_type=None): """Bottleneck block. If style is "pytorch", the stride-two layer is the 3x3 conv layer, if it is "caffe", the stride-two layer is the first 1x1 conv layer. """ super(Bottleneck, self).__init__() conv1_stride = 1 conv2_stride = stride self.conv1 = nn.Conv2d( inplanes, planes, kernel_size=1, stride=conv1_stride, bias=False) self.with_dcn = with_dcn self.use_modulated_dcn = use_modulated_dcn if use_regular_conv_on_stride and stride > 1: self.with_dcn = False if self.with_dcn: print("--->> use {}dcn in block where c_in={} and c_out={}".format( 'modulated ' if self.use_modulated_dcn else '', planes, inplanes)) if use_modulated_dcn: self.conv_offset_mask = nn.Conv2d( planes, num_deformable_groups * 27, kernel_size=3, stride=conv2_stride, padding=dilation, dilation=dilation) self.conv_offset_mask.lr_mult = dcn_offset_lr_mult self.conv_offset_mask.zero_init = True self.conv2 = ModulatedDeformConv(planes, planes, 3, stride=conv2_stride, padding=dilation, dilation=dilation, deformable_groups=num_deformable_groups, no_bias=True) else: self.conv2_offset = nn.Conv2d( planes, num_deformable_groups * 18, kernel_size=3, stride=conv2_stride, padding=dilation, dilation=dilation) self.conv2_offset.lr_mult = dcn_offset_lr_mult self.conv2_offset.zero_init = True self.conv2 = DeformConv(planes, planes, (3, 3), stride=conv2_stride, padding=dilation, dilation=dilation, num_deformable_groups=num_deformable_groups) else: self.conv2 = nn.Conv2d( planes, planes, kernel_size=3, stride=conv2_stride, padding=dilation, dilation=dilation, bias=False) self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes) self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes) self.conv3 = nn.Conv2d( planes, planes * self.expansion, kernel_size=1, bias=False) self.bn3 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes * self.expansion) self.relu = nn.ReLU(inplace=False) self.relu_in = nn.ReLU(inplace=True) self.downsample = downsample self.stride = stride self.dilation = dilation self.with_cp = with_cp def forward(self, x): def _inner_forward(x): residual = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) if self.with_dcn: if self.use_modulated_dcn: offset_mask = self.conv_offset_mask(out) offset1, offset2, mask_raw = torch.chunk(offset_mask, 3, dim=1) offset = torch.cat((offset1, offset2), dim=1) mask = torch.sigmoid(mask_raw) out = self.conv2(out, offset, mask) else: offset = self.conv2_offset(out) # add bias to the offset to solve the bug of dilation rates within dcn. dilation = self.conv2.dilation[0] bias_w = torch.cuda.FloatTensor([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]) * (dilation - 1) bias_h = bias_w.permute(1, 0) bias_w.requires_grad = False bias_h.requires_grad = False offset += torch.cat([bias_h.reshape(-1), bias_w.reshape(-1)]).view(1, -1, 1, 1) out = self.conv2(out, offset) else: out = self.conv2(out) out = self.bn2(out) out = self.relu(out) out = self.conv3(out) out = self.bn3(out) if self.downsample is not None: residual = self.downsample(x) out = out + residual return out if self.with_cp and x.requires_grad: out = cp.checkpoint(_inner_forward, x) else: out = _inner_forward(x) out = self.relu_in(out) return out def make_res_layer(block, inplanes, planes, blocks, stride=1, dilation=1, style='pytorch', with_cp=False, with_dcn=False, dcn_offset_lr_mult=0.1, use_regular_conv_on_stride=False, use_modulated_dcn=False, bn_type=None): downsample = None if stride != 1 or inplanes != planes * block.expansion: downsample = nn.Sequential( nn.Conv2d( inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False), ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes * block.expansion), ) layers = [] layers.append( block( inplanes, planes, stride, dilation, downsample, style=style, with_cp=with_cp, with_dcn=with_dcn, dcn_offset_lr_mult=dcn_offset_lr_mult, use_regular_conv_on_stride=use_regular_conv_on_stride, use_modulated_dcn=use_modulated_dcn, bn_type=bn_type)) inplanes = planes * block.expansion for i in range(1, blocks): layers.append( block(inplanes, planes, 1, dilation, style=style, with_cp=with_cp, with_dcn=with_dcn, dcn_offset_lr_mult=dcn_offset_lr_mult, use_regular_conv_on_stride=use_regular_conv_on_stride, use_modulated_dcn=use_modulated_dcn, bn_type=bn_type)) return nn.Sequential(*layers) class DCNResNet(nn.Module): """ResNet backbone. Args: depth (int): Depth of resnet, from {18, 34, 50, 101, 152}. num_stages (int): Resnet stages, normally 4. strides (Sequence[int]): Strides of the first block of each stage. dilations (Sequence[int]): Dilation of each stage. out_indices (Sequence[int]): Output from which stages. style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two layer is the 3x3 conv layer, otherwise the stride-two layer is the first 1x1 conv layer. frozen_stages (int): Stages to be frozen (all param fixed). -1 means not freezing any parameters. bn_eval (bool): Whether to set BN layers to eval mode, namely, freeze running stats (mean and var). bn_frozen (bool): Whether to freeze weight and bias of BN layers. with_cp (bool): Use checkpoint or not. Using checkpoint will save some memory while slowing down the training speed. """ def __init__(self, block, layers, deep_base=True, bn_type=None): super(DCNResNet, self).__init__() # if depth not in self.arch_settings: # raise KeyError('invalid depth {} for resnet'.format(depth)) # assert num_stages >= 1 and num_stages <= 4 # block, stage_blocks = self.arch_settings[depth] # stage_blocks = stage_blocks[:num_stages] # assert len(strides) == len(dilations) == num_stages # assert max(out_indices) < num_stages self.style = 'pytorch' self.inplanes = 128 if deep_base else 64 if deep_base: self.resinit = nn.Sequential(OrderedDict([ ('conv1', nn.Conv2d(3, 64, kernel_size=3, stride=2, padding=1, bias=False)), ('bn1', ModuleHelper.BatchNorm2d(bn_type=bn_type)(64)), ('relu1', nn.ReLU(inplace=False)), ('conv2', nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False)), ('bn2', ModuleHelper.BatchNorm2d(bn_type=bn_type)(64)), ('relu2', nn.ReLU(inplace=False)), ('conv3', nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1, bias=False)), ('bn3', ModuleHelper.BatchNorm2d(bn_type=bn_type)(self.inplanes)), ('relu3', nn.ReLU(inplace=False))] )) else: self.resinit = nn.Sequential(OrderedDict([ ('conv1', nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)), ('bn1', ModuleHelper.BatchNorm2d(bn_type=bn_type)(self.inplanes)), ('relu1', nn.ReLU(inplace=False))] )) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = make_res_layer( block, self.inplanes, 64, layers[0], style=self.style, with_dcn=False, use_modulated_dcn=False, bn_type=bn_type) self.layer2 = make_res_layer( block, 256, 128, layers[1], stride=2, style=self.style, with_dcn=False, use_modulated_dcn=False, bn_type=bn_type) self.layer3 = make_res_layer( block, 512, 256, layers[2], stride=2, style=self.style, with_dcn=True, use_modulated_dcn=False, bn_type=bn_type) self.layer4 = make_res_layer( block, 1024, 512, layers[3], stride=2, style=self.style, with_dcn=True, use_modulated_dcn=False, bn_type=bn_type) def forward(self, x): x = self.resinit(x) x = self.maxpool(x) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) x = self.layer4(x) return x class DCNResNetModels(object): def __init__(self, configer): self.configer = configer def deepbase_dcn_resnet50(self, **kwargs): """Constructs a ResNet-50 model. Args: pretrained (bool): If True, returns a model pre-trained on Places """ model = DCNResNet(Bottleneck, [3, 4, 6, 3], deep_base=True, bn_type=self.configer.get('network', 'bn_type'), **kwargs) model = ModuleHelper.load_model(model, all_match=False, pretrained=self.configer.get('network', 'pretrained'), network="dcnet") return model def deepbase_dcn_resnet101(self, **kwargs): """Constructs a ResNet-101 model. Args: pretrained (bool): If True, returns a model pre-trained on Places """ model = DCNResNet(Bottleneck, [3, 4, 23, 3], deep_base=True, bn_type=self.configer.get('network', 'bn_type'), **kwargs) model = ModuleHelper.load_model(model, all_match=False, pretrained=self.configer.get('network', 'pretrained'), network="dcnet") return model