def conv(batchNorm, in_planes, out_planes, kernel_size=3, stride=1, dcn=False, padding=-1, dilation=1): if padding == -1: padding = (kernel_size-1)//2 if batchNorm: if dcn: return nn.Sequential( # DCN(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2), DCN(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation), nn.BatchNorm2d(out_planes), nn.LeakyReLU(0.1,inplace=True) ) else: return nn.Sequential( # nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2, bias=False), nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, bias=False), nn.BatchNorm2d(out_planes), nn.LeakyReLU(0.1,inplace=True) ) else: if dcn: return nn.Sequential( # DCN(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2), DCN(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation), nn.LeakyReLU(0.1,inplace=True) ) else: return nn.Sequential( # nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2, bias=True), nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, bias=True), nn.LeakyReLU(0.1,inplace=True) )
def export_dconv_onnx(): input = torch.randn(1, 64, 128, 128).cuda() # wrap all things (offset and mask) in DCN dcn = DCN(64, 64, kernel_size=(3, 3), stride=1, padding=1, deformable_groups=2).cuda() dcn.eval() dynamic = False torch.onnx.export(dcn, input, "dcn.onnx", input_names=["input"], output_names=["output"], dynamic_axes={ "input": { 0: 'batch' }, "output": { 0: 'batch' } } if dynamic else None, opset_version=11, do_constant_folding=True) print("export dcn onnx successfully!")
def __init__(self, a, b, c): super(DUB, self).__init__() self.conv3 = nn.Sequential( nn.BatchNorm2d(a), nn.ReLU(inplace=True), DCN(a, b, kernel_size=3, stride=1, padding=1)) self.conv1 = nn.Sequential( nn.BatchNorm2d(a + b), nn.ReLU(inplace=True), DCN(a + b, c, kernel_size=1, stride=1, padding=0))
def example_dconv_half(): input = torch.randn(2, 64, 128, 128).half().cuda() # wrap all things (offset and mask) in DCN dcn = DCN(64, 64, kernel_size=(3, 3), stride=1, padding=1, deformable_groups=2) dcn=dcn.half().cuda() print(dcn) # print(dcn.weight.shape, input.shape) output = dcn(input) # targert = output.new(*output.size()) # targert.data.uniform_(-0.01, 0.01) # error = (targert - output).mean() # error.backward() print(output.shape)
def __init__(self, c1, c2, k=4, s=2): super(DeConvDCN, self).__init__() self.layers = [] dcn = DCN(c1, c2, kernel_size=(3, 3), stride=1, padding=1, dilation=1, deformable_groups=1) deconv = nn.ConvTranspose2d(in_channels=c2, out_channels=c2, kernel_size=k, stride=s, padding=1, output_padding=0, bias=False) fill_up_weights(deconv) self.layers.append(dcn) self.layers.append(nn.BatchNorm2d(c2)) self.layers.append(nn.SiLU()) self.layers.append(deconv) self.layers.append(nn.BatchNorm2d(c2)) self.layers.append(nn.SiLU()) self.layers = nn.Sequential(*self.layers)
def _make_deconv_layer(self, num_filters, num_kernels): layers = [] kernel, padding, output_padding = \ self._get_deconv_cfg(num_kernels) planes = num_filters fc = DCN(self.inplanes, planes, kernel_size=(3, 3), stride=1, padding=1, dilation=1, deformable_groups=1) # fc = nn.Conv2d(self.inplanes, planes, # kernel_size=3, stride=1, # padding=1, dilation=1, bias=False) # fill_fc_weights(fc) up = nn.ConvTranspose2d( in_channels=planes, out_channels=planes, kernel_size=kernel, stride=2, padding=padding, output_padding=output_padding, bias=self.deconv_with_bias) fill_up_weights(up) layers.append(fc) layers.append(nn.BatchNorm2d(planes, momentum=BN_MOMENTUM)) layers.append(nn.ReLU(inplace=True)) layers.append(up) layers.append(nn.BatchNorm2d(planes, momentum=BN_MOMENTUM)) layers.append(nn.ReLU(inplace=True)) self.inplanes = planes return nn.Sequential(*layers)
def __init__(self, chi, cho): super(DeformConv, self).__init__() self.actf = nn.Sequential( nn.BatchNorm2d(cho, momentum=BN_MOMENTUM), nn.ReLU(inplace=True) ) self.conv = DCN(chi, cho, kernel_size=(3,3), stride=1, padding=1, dilation=1, deformable_groups=1)
def __init__(self, inplanes, planes, stride=1, downsample=None, norm_layer=nn.BatchNorm2d, dilation=1, use_dcn=False): super(BasicBlock, self).__init__() self.conv1 = conv3x3(inplanes, planes, stride) self.bn1 = norm_layer(planes) self.relu = nn.ReLU(inplace=True) if use_dcn: self.conv2 = DCN(planes, planes, kernel_size=3, stride=stride, padding=dilation, dilation=dilation, deformable_groups=1) self.conv2.bias.data.zero_() self.conv2.conv_offset_mask.weight.data.zero_() self.conv2.conv_offset_mask.bias.data.zero_() else: self.conv2 = conv3x3(planes, planes) self.bn2 = norm_layer(planes) self.downsample = downsample self.stride = stride
def __init__(self, chi, cho): super(DeformConv, self).__init__() self.actf = nn.Sequential(nn.BatchNorm2d(cho, momentum=BN_MOMENTUM), nn.ReLU(inplace=True)) self.conv = DCN(chi, cho, kernel_size=(3, 3), stride=1, padding=1, dilation=1, deformable_groups=1) for name, m in self.actf.named_modules(): if isinstance(m, nn.BatchNorm2d): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0)
def i_conv(batchNorm, in_planes, out_planes, kernel_size=3, stride=1, bias=True, dcn=False, modulation=False): if batchNorm: if dcn: return nn.Sequential( DCN(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size - 1) // 2), nn.BatchNorm2d(out_planes), ) else: return nn.Sequential( nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size - 1) // 2, bias=bias), nn.BatchNorm2d(out_planes), ) else: if dcn: return nn.Sequential( DCN(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size - 1) // 2), ) else: return nn.Sequential( nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size - 1) // 2, bias=bias), )
def predict_flow(in_planes, dcn=False, modulation=False): if dcn: return DCN(in_planes, 2, kernel_size=3, stride=1, padding=1) else: return nn.Conv2d(in_planes, 2, kernel_size=3, stride=1, padding=1, bias=True)
def example_dconv(): from dcn_v2 import DCN input = torch.randn(2, 64, 128, 128).cuda() # wrap all things (offset and mask) in DCN dcn = DCN(64, 64, kernel_size=(3,3), stride=1, padding=1, deformable_groups=2).cuda() output = dcn(input) targert = output.new(*output.size()) targert.data.uniform_(-0.01, 0.01) error = (targert - output).mean() error.backward() print(output.shape)
def __init__(self, inplanes, planes, stride=1, downsample=None, norm_layer=nn.BatchNorm2d, dilation=1, use_dcn=False): super(Bottleneck, self).__init__() ##______________________________________ 1 _____________________________________________________## self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False, dilation=dilation) self.bn1 = norm_layer(planes) ##______________________________________ 2 _____________________________________________________## if use_dcn: self.conv2 = DCN(planes, planes, kernel_size=3, stride=stride, padding=dilation, dilation=dilation, deformable_groups=1) self.conv2.bias.data.zero_() self.conv2.conv_offset_mask.weight.data.zero_() self.conv2.conv_offset_mask.bias.data.zero_() else: self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=dilation, bias=False, dilation=dilation) self.bn2 = norm_layer(planes) ##______________________________________ 3 _____________________________________________________## self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False, dilation=dilation) self.bn3 = norm_layer(planes * 4) ##___________________________________________________________________________________________________## self.relu = nn.ReLU(inplace=True) self.downsample = downsample self.stride = stride # -> where is this stride used ??
def _make_deconv_layer(self, num_layers, num_filters, num_kernels): """ :param num_layers: :param num_filters: :param num_kernels: :return: """ assert num_layers == len(num_filters), \ 'ERROR: num_deconv_layers is different len(num_deconv_filters)' assert num_layers == len(num_kernels), \ 'ERROR: num_deconv_layers is different len(num_deconv_filters)' layers = [] for i in range(num_layers): kernel, padding, output_padding = \ self._get_deconv_cfg(num_kernels[i], i) planes = num_filters[i] fc = DCN(self.inplanes, planes, kernel_size=(3, 3), stride=1, padding=1, dilation=1, deformable_groups=1) # fc = nn.Conv2d(self.inplanes, planes, # kernel_size=3, stride=1, # padding=1, dilation=1, bias=False) # fill_fc_weights(fc) up = nn.ConvTranspose2d(in_channels=planes, out_channels=planes, kernel_size=kernel, stride=2, padding=padding, output_padding=output_padding, bias=self.deconv_with_bias) fill_up_weights(up) layers.append(fc) layers.append(nn.BatchNorm2d(planes, momentum=BN_MOMENTUM)) layers.append(nn.ReLU(inplace=True)) layers.append(up) layers.append(nn.BatchNorm2d(planes, momentum=BN_MOMENTUM)) layers.append(nn.ReLU(inplace=True)) self.inplanes = planes return nn.Sequential(*layers)
def __init__(self, inplanes, planes, stride=1, downsample=None, norm_layer=nn.BatchNorm2d, dilation=1, use_dcn=False, activation_func=nn.ReLU(inplace=True)): super(Bottleneck, self).__init__() self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False, dilation=dilation) self.bn1 = norm_layer(planes) if use_dcn: self.conv2 = DCN(planes, planes, kernel_size=3, stride=stride, padding=dilation, dilation=dilation, deformable_groups=1) self.conv2.bias.data.zero_() self.conv2.conv_offset_mask.weight.data.zero_() self.conv2.conv_offset_mask.bias.data.zero_() else: self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=dilation, bias=False, dilation=dilation) self.bn2 = norm_layer(planes) self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False, dilation=dilation) self.bn3 = norm_layer(planes * 4) self.acf = activation_func self.downsample = downsample self.stride = stride
def __init__(self, inplanes, planes, stride=1, downsample=None, norm_layer=nn.BatchNorm, dilation=1, use_dcn=False): super(Bottleneck, self).__init__() self.conv1 = nn.Conv(inplanes, planes, kernel_size=1, bias=False, dilation=dilation) self.bn1 = norm_layer(planes) if use_dcn: self.conv2 = DCN(planes, planes, kernel_size=3, stride=stride, padding=dilation, dilation=dilation, deformable_groups=1) init.constant_(self.conv2.bias, 0.0) init.constant_(self.conv2.conv_offset_mask.weight, 0.0) init.constant_(self.conv2.conv_offset_mask.bias, 0.0) else: self.conv2 = nn.Conv(planes, planes, kernel_size=3, stride=stride, padding=dilation, bias=False, dilation=dilation) self.bn2 = norm_layer(planes) self.conv3 = nn.Conv(planes, planes * 4, kernel_size=1, bias=False, dilation=dilation) self.bn3 = norm_layer(planes * 4) self.relu = nn.ReLU() self.downsample = downsample self.stride = stride
def __init__(self, pretrained=True): super(Net, self).__init__() if (pretrained == True): print("=> loading checkpoint from pretrained dpn92-5k-1k") dpn92 = pretrainedmodels.__dict__['dpn92']( num_classes=1000, pretrained='imagenet+5k').features else: dpn92 = pretrainedmodels.__dict__['dpn92']( num_classes=1000, pretrained=False).features # dx: downsample to factor x # ux: upsample to factor x # Haze Density Map Generate sub-Net self.d64u1 = UNet(input_nc=3, output_nc=3, nf=8) # Encoder Decoder sub-Net self.d8 = dpn92[:5] #out608 self.d16 = dpn92[5:9] #out1096 self.d32 = dpn92[9:29] self.u16 = DUB(2432, 512, 256) self.u8 = DUB(1352, 256, 128) self.u4 = DUB(736, 128, 256) self.u2 = DUB(256, 64, 128) self.u1 = DUB(128, 32, 16) self.in16 = nn.InstanceNorm2d(1096, affine=False) self.in8 = nn.InstanceNorm2d(608, affine=False) # Details Refinement sub-Net self.d4u1 = nn.Sequential(nn.Conv2d(3, 16, 3, 1, 1, bias=True), nn.BatchNorm2d(16), invPixelShuffle(4), nn.Conv2d(256, 16, 3, 1, 1, bias=True), nn.BatchNorm2d(16), nn.Sequential(*[WAB(16) for _ in range(3)]), nn.Conv2d(16, 256, 3, 1, 1, bias=True), nn.PixelShuffle(4), nn.BatchNorm2d(16), nn.Conv2d(16, 13, 3, 1, 1, bias=True)) self.tail = nn.Sequential(nn.BatchNorm2d(32), nn.ReLU(inplace=True), DCN(32, 3, 3, 1, 1))
def __init__(self, filters_in, filters_out, kernel_size, stride, pad, groups=1, norm=None, activate=None): super(Deformable_Convolutional, self).__init__() self.norm = norm self.activate = activate self.__dcn = DCN(filters_in, filters_out, kernel_size=kernel_size, stride=stride, padding=pad, deformable_groups=groups).cuda() if norm: assert norm in norm_name.keys() if norm == "bn": self.__norm = norm_name[norm](num_features=filters_out) if activate: assert activate in activate_name.keys() if activate == "leaky": self.__activate = activate_name[activate](negative_slope=0.1, inplace=True) if activate == "relu": self.__activate = activate_name[activate](inplace=True) if activate == "relu6": self.__activate = activate_name[activate](inplace=True) if activate == "Mish": self.__activate = Mish() if activate == "Swish": self.__activate = Swish() if activate == "MEMish": self.__activate = MemoryEfficientMish() if activate == "MESwish": self.__activate = MemoryEfficientSwish() if activate == "FReLu": self.__activate = FReLU()
def __init__(self, input_dim, filters, filter_size, stride=1, bias_attr=False, bn=0, gn=0, af=0, groups=32, act=None, freeze_norm=False, is_test=False, norm_decay=0., use_dcn=False): super(Conv2dUnit, self).__init__() self.groups = groups self.act = act self.freeze_norm = freeze_norm self.is_test = is_test self.norm_decay = norm_decay self.use_dcn = use_dcn # conv if use_dcn: self.conv = DCN(input_dim, filters, kernel_size=3, stride=stride, padding=1, dilation=1, deformable_groups=1) self.conv.bias.data.zero_() self.conv.conv_offset_mask.weight.data.zero_() self.conv.conv_offset_mask.bias.data.zero_() else: self.conv = torch.nn.Conv2d(input_dim, filters, kernel_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, bias=bias_attr) # norm self.bn = None self.gn = None self.af = None if bn: self.bn = torch.nn.BatchNorm2d(filters) if gn: self.gn = torch.nn.GroupNorm(num_groups=groups, num_channels=filters) if af: self.af = AffineChannel(filters) # act self.act = None if act == 'relu': self.act = torch.nn.ReLU(inplace=True) elif act == 'leaky': self.act = torch.nn.LeakyReLU(0.1) elif act == 'mish': self.act = Mish()
from dcn_v2 import DCN import torch x = torch.randn(5, 3, 40, 40).cuda() net = DCN(x.shape[1], 6, (3, 3), 1, 1).cuda() y = net(x) print("y.shape:", y.shape) torch.onnx.export(net, x, 'dcn.onnx', verbose=False, opset_version=9) x_ = x.view(-1) x_str = "" for i in range(x_.shape[0]): x_str += str(x_[i].item()) + "," x_str = x_str[:-1] x_str += "\n" with open("x_data.txt", "w") as fout: fout.writelines(x_str) x_ = y.view(-1) x_str = "" for i in range(x_.shape[0]): x_str += str(x_[i].item()) + "," x_str = x_str[:-1] x_str += "\n" with open("y_data.txt", "w") as fout: fout.writelines(x_str)
import torch from dcn_v2 import DCN input = torch.randn(2, 64, 128, 128).cuda() # wrap all things (offset and mask) in DCN dcn = DCN(64, 64, kernel_size=(3,3), stride=1, padding=1, deformable_groups=2).cuda() output = dcn(input) print(output.shape)