def _conv_dw(in_channels, out_channels, stride):
return nn.Sequential(
nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=3, stride=stride, padding=1, groups=in_channels, bias=False),
nn.BatchNorm2d(in_channels),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0, bias=False),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def conv_dw(inp, oup, stride, leaky=0.1):
return nn.Sequential(
nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=False),
nn.BatchNorm2d(inp),
nn.LeakyReLU(negative_slope=leaky, inplace=True),
nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
nn.LeakyReLU(negative_slope=leaky, inplace=True),
)
def __init__(self, in_channels, out_channels, kernel_size, stride, padding, **kwargs):
super(ConvBNReLU, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=True, **kwargs)
self.bn = nn.BatchNorm2d(out_channels)
self.relu = nn.ReLU(inplace=True)
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
self.bn3 = nn.BatchNorm2d(planes * 4)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
self.eltadd = nn.EltAdd()
def __init__(self, inp, oup, stride, expand_ratio, model_type=32):
super(InvertedResidual_dwc, self).__init__()
self.stride = stride
assert stride in [1, 2]
hidden_dim = int(round(inp * expand_ratio))
self.use_res_connect = self.stride == 1 and inp == oup
self.conv = []
if expand_ratio == 1:
self.conv.append(
nn.Conv2d(inp,
hidden_dim,
kernel_size=(3, 3),
stride=stride,
padding=1,
groups=hidden_dim))
self.conv.append(nn.BatchNorm2d(hidden_dim))
self.conv.append(nn.PReLU())
self.conv.append(nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False))
self.conv.append(nn.BatchNorm2d(oup))
if model_type == 32:
self.conv.append(nn.PReLU())
else:
self.conv.append(nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False))
self.conv.append(nn.BatchNorm2d(hidden_dim))
self.conv.append(nn.PReLU())
self.conv.append(
nn.Conv2d(hidden_dim,
hidden_dim,
kernel_size=(3, 3),
stride=stride,
padding=1,
groups=hidden_dim))
self.conv.append(nn.BatchNorm2d(hidden_dim))
self.conv.append(nn.PReLU())
self.conv.append(nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False))
self.conv.append(nn.BatchNorm2d(oup))
if model_type == 32:
self.conv.append(nn.PReLU())
self.conv = nn.Sequential(*self.conv)
if self.use_res_connect:
self.eltadd = nn.EltAdd()
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1):
super(IdentityBlock, self).__init__()
out_channels_1, out_channels_2, out_channels_3 = out_channels//4, out_channels//4, out_channels
self.conv1 = nn.Conv2d(in_channels, out_channels_1, kernel_size=(1, 1))
self.bn1 = nn.BatchNorm2d(out_channels_1)
self.relu1 = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(out_channels_1, out_channels_2, kernel_size=(kernel_size, kernel_size), padding=(padding, padding), dilation=(dilation, dilation))
self.bn2 = nn.BatchNorm2d(out_channels_2)
self.relu2 = nn.ReLU(inplace=True)
self.conv3 = nn.Conv2d(out_channels_2, out_channels_3, kernel_size=(1, 1))
self.bn3 = nn.BatchNorm2d(out_channels_3)
self.eltadd = nn.EltAdd()
self.relu_f = nn.ReLU(inplace=True)
def __init__(self, in_planes, out_planes, kernel_size, stride=1, padding=0, dilation=1, groups=1, relu=True, bn=True):
super(BasicConv, self).__init__()
self.out_channels = out_planes
if bn:
self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias=False)
self.bn = nn.BatchNorm2d(out_planes, eps=1e-5, momentum=0.01, affine=True)
self.relu = nn.ReLU(inplace=True) if relu else None
else:
self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias=True)
self.bn = None
self.relu = nn.ReLU(inplace=True) if relu else None
def __init__(self, in_channel, out_channel, kernel_size, stride=1, padding=0, bias=False, add_relu=True, add_bn=True, eps=1e-5):
super(ConvBlock, self).__init__()
self.conv = nn.Conv2d(in_channel, out_channel, kernel_size, stride, padding, bias=bias)
self.relu = None
self.bn = None
if add_relu:
self.relu = nn.ReLU()
if add_bn:
self.bn = nn.BatchNorm2d(out_channel, eps=eps)
def make_layers(cfg, batch_norm=False):
layers = []
in_channels = 3
for v in cfg:
if v == 'M':
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
else:
layers += [conv2d, nn.ReLU(inplace=True)]
in_channels = v
return layers
def upsample(in_channels, out_channels): # should use F.inpterpolate
return nn.Sequential(
nn.Conv2d(in_channels=in_channels,
out_channels=in_channels,
kernel_size=(3, 3),
stride=1,
padding=1,
groups=in_channels,
bias=False),
nn.Conv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=1,
stride=1,
padding=0,
bias=False), nn.BatchNorm2d(out_channels), nn.ReLU())
def _make_layer(self, block, planes, blocks, stride=1):
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = nn.Sequential(
nn.Conv2d(self.inplanes,
planes * block.expansion,
kernel_size=1,
stride=stride,
bias=False),
nn.BatchNorm2d(planes * block.expansion),
)
layers = []
layers.append(block(self.inplanes, planes, stride, downsample))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(block(self.inplanes, planes))
return nn.Sequential(*layers)
def __init__(self,
in_channels,
out_channels,
kernel_sizes,
strides=1,
paddings=0,
act='relu',
bias=False):
super(Conv_BN, self).__init__()
self.conv = nn.Conv2d(in_channels,
out_channels,
kernel_sizes,
strides,
paddings,
bias=bias)
self.bn = nn.BatchNorm2d(out_channels, eps=0.001, momentum=0.999)
self.act = None
if act == 'relu':
self.act = nn.ReLU(inplace=True)
def conv_bn_no_relu(inp, oup, stride):
return nn.Sequential(
nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
nn.BatchNorm2d(oup),
)
def __init__(self, in_channels, out_channels, **kwargs):
super(BasicConv2d, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
self.bn = nn.BatchNorm2d(out_channels, eps=1e-5)
self.relu = nn.ReLU()
def __init__(self):
super(DSFD, self).__init__()
self.size = 640
self.num_classes = 2
######
# build backbone
######
resnet152 = vision.models.resnet152()
self.layer1 = nn.Sequential(resnet152.conv1, resnet152.bn1,
resnet152.relu, resnet152.maxpool,
resnet152.layer1)
self.layer2 = nn.Sequential(resnet152.layer2)
self.layer3 = nn.Sequential(resnet152.layer3)
self.layer4 = nn.Sequential(resnet152.layer4)
self.layer5 = nn.Sequential(*[
nn.Conv2d(2048, 512, kernel_size=1),
nn.BatchNorm2d(512),
nn.ReLU(inplace=True),
nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=2),
nn.BatchNorm2d(512),
nn.ReLU(inplace=True)
])
self.layer6 = nn.Sequential(*[
nn.Conv2d(
512,
128,
kernel_size=1,
),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True)
])
######
# dsfd specific layers
######
output_channels = [256, 512, 1024, 2048, 512, 256]
# fpn
fpn_in = output_channels
self.latlayer3 = nn.Conv2d(fpn_in[3],
fpn_in[2],
kernel_size=1,
stride=1,
padding=0)
self.latlayer2 = nn.Conv2d(fpn_in[2],
fpn_in[1],
kernel_size=1,
stride=1,
padding=0)
self.latlayer1 = nn.Conv2d(fpn_in[1],
fpn_in[0],
kernel_size=1,
stride=1,
padding=0)
self.smooth3 = nn.Conv2d(fpn_in[2],
fpn_in[2],
kernel_size=1,
stride=1,
padding=0)
self.smooth2 = nn.Conv2d(fpn_in[1],
fpn_in[1],
kernel_size=1,
stride=1,
padding=0)
self.smooth1 = nn.Conv2d(fpn_in[0],
fpn_in[0],
kernel_size=1,
stride=1,
padding=0)
self.upsample = nn.Upsample(scale_factor=2,
mode='bilinear',
align_corners=False)
self.eltmul = nn.EltMul()
# fem
cpm_in = output_channels
self.cpm3_3 = FEM(cpm_in[0])
self.cpm4_3 = FEM(cpm_in[1])
self.cpm5_3 = FEM(cpm_in[2])
self.cpm7 = FEM(cpm_in[3])
self.cpm6_2 = FEM(cpm_in[4])
self.cpm7_2 = FEM(cpm_in[5])
# pa
cfg_mbox = [1, 1, 1, 1, 1, 1]
head = pa_multibox(output_channels, cfg_mbox, self.num_classes)
# detection head
self.loc = nn.ModuleList(head[0])
self.conf = nn.ModuleList(head[1])
self.softmax = nn.Softmax(dim=-1)
from _utils import test_on
import sys
sys.path.append('.')
from flops_counter import nn
from flops_counter.tensorsize import TensorSize
######
# test on BatchNorm2d
######
bn2d = {
'layers': [
nn.BatchNorm2d(64) # same shape
],
'ins': [TensorSize([1, 64, 112, 112])],
'out_shape': [TensorSize([1, 64, 112, 112])],
'out_flops': [4816896]
}
test_on(bn2d)
######
# test on L2Norm2d
######
l2norm2d = {
'layers': [
nn.L2Norm2d(256) # same shape
],
'ins': [TensorSize([1, 256, 56, 56])],
'out_shape': [TensorSize([1, 256, 56, 56])],
'out_flops': [2408448]
def conv_bn(inp, oup, stride=1, leaky=0):
return nn.Sequential(nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
nn.BatchNorm2d(oup),
nn.LeakyReLU(negative_slope=leaky, inplace=True))
def _conv_bn(in_channels, out_channels, stride):
return nn.Sequential(
nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
nn.BatchNorm2d(num_features=out_channels),
nn.ReLU(inplace=True)
)
def __init__(self):
super(CSP, self).__init__()
#####
# Backbone
#####
# build resnet50
# base
self.base_conv = nn.Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))
self.base_bn = nn.BatchNorm2d(64)
self.base_relu = nn.ReLU(inplace=True)
self.base_maxpooling = nn.MaxPool2d(kernel_size=(3, 3), stride=2, padding=1)
# layer1
l1ic = [64, 256, 256]
l1oc = [256, 256, 256]
self.layer1_bottleneck0 = ConvBlock( in_channels=l1ic[0], out_channels=l1oc[0], kernel_size=3, padding=1)
self.layer1_bottleneck1 = IdentityBlock(in_channels=l1ic[1], out_channels=l1oc[1], kernel_size=3, padding=1)
self.layer1_bottleneck2 = IdentityBlock(in_channels=l1ic[2], out_channels=l1oc[2], kernel_size=3, padding=1)
# layer2
l2ic = [256, 512, 512, 512]
l2oc = [512, 512, 512, 512]
self.layer2_bottleneck0 = ConvBlock( in_channels=l2ic[0], out_channels=l2oc[0], kernel_size=3, stride=2, padding=1)
self.layer2_bottleneck1 = IdentityBlock(in_channels=l2ic[1], out_channels=l2oc[1], kernel_size=3, padding=1)
self.layer2_bottleneck2 = IdentityBlock(in_channels=l2ic[2], out_channels=l2oc[2], kernel_size=3, padding=1)
self.layer2_bottleneck3 = IdentityBlock(in_channels=l2ic[3], out_channels=l2oc[3], kernel_size=3, padding=1)
# layer3
l3ic = [512, 1024, 1024, 1024, 1024, 1024]
l3oc = [1024, 1024, 1024, 1024, 1024, 1024]
self.layer3_bottleneck0 = ConvBlock( in_channels=l3ic[0], out_channels=l3oc[0], kernel_size=3, stride=2, padding=1)
self.layer3_bottleneck1 = IdentityBlock(in_channels=l3ic[1], out_channels=l3oc[1], kernel_size=3, padding=1)
self.layer3_bottleneck2 = IdentityBlock(in_channels=l3ic[2], out_channels=l3oc[2], kernel_size=3, padding=1)
self.layer3_bottleneck3 = IdentityBlock(in_channels=l3ic[3], out_channels=l3oc[3], kernel_size=3, padding=1)
self.layer3_bottleneck4 = IdentityBlock(in_channels=l3ic[4], out_channels=l3oc[4], kernel_size=3, padding=1)
self.layer3_bottleneck5 = IdentityBlock(in_channels=l3ic[5], out_channels=l3oc[5], kernel_size=3, padding=1)
# layer4
l4ic = [1024, 2048, 2048]
l4oc = [2048, 2048, 2048]
self.layer4_bottleneck0 = ConvBlock( in_channels=l4ic[0], out_channels=l4oc[0], kernel_size=3, padding=2, dilation=2)
self.layer4_bottleneck1 = IdentityBlock(in_channels=l4ic[1], out_channels=l4oc[1], kernel_size=3, padding=2, dilation=2)
self.layer4_bottleneck2 = IdentityBlock(in_channels=l4ic[2], out_channels=l4oc[2], kernel_size=3, padding=2, dilation=2)
#####
# CSP specific layers
#####
# p3up
self.p3up_trconv = nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1)
self.p3up_l2norm = nn.L2Norm2d(256, 10)
# p4up
self.p4up_trconv = nn.ConvTranspose2d(1024, 256, kernel_size=4, stride=4, padding=0)
self.p4up_l2norm = nn.L2Norm2d(256, 10)
# p5up
self.p5up_trconv = nn.ConvTranspose2d(2048, 256, kernel_size=4, stride=4, padding=0)
self.p5up_l2norm = nn.L2Norm2d(256, 10)
# detection head - feat
self.feat_conv = nn.Conv2d(768, 256, kernel_size=3, padding=1)
self.feat_bn = nn.BatchNorm2d(256)
self.feat_relu = nn.ReLU(inplace=True)
# detection head - class
self.class_conv = nn.Conv2d(256, 1, kernel_size=1, bias=True)
self.class_sigmoid = nn.Sigmoid()
# detection head - regr
self.regr_conv = nn.Conv2d(256, 2, kernel_size=1)
self.regr_relu = nn.ReLU(inplace=True)
# detection head - offset
self.offset_conv = nn.Conv2d(256, 2, kernel_size=1)
self.offset_relu = nn.ReLU(inplace=True)
def __init__(self, in_channels, out_channels, **kwargs):
super(CRelu, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)
self.bn = nn.BatchNorm2d(out_channels, eps=1e-5)
self.relu = nn.ReLU(inplace=True)
def conv_bn(inp, oup, stride, k_size=3):
return nn.Sequential(nn.Conv2d(inp, oup, k_size, stride, 1, bias=False),
nn.BatchNorm2d(oup), nn.PReLU())
def __init__(self):
super(SRN, self).__init__()
block = Bottleneck
layers = [3, 4, 6, 3]
self.inplanes = 64
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
self.layer5 = nn.Conv2d(2048, 1024, kernel_size=3, stride=2, padding=1)
self.layer6 = nn.Conv2d(1024, 256, kernel_size=3, stride=2, padding=1)
self.c5_lateral = nn.Conv2d(2048,
256,
kernel_size=1,
stride=1,
padding=0)
self.c4_lateral = nn.Conv2d(1024,
256,
kernel_size=1,
stride=1,
padding=0)
self.c3_lateral = nn.Conv2d(512,
256,
kernel_size=1,
stride=1,
padding=0)
self.c2_lateral = nn.Conv2d(256,
256,
kernel_size=1,
stride=1,
padding=0)
self.eltadd = nn.EltAdd()
self.upsample = nn.Upsample(scale_factor=2,
mode='bilinear',
align_corners=False)
self.p7_conv = nn.Conv2d(256, 256, kernel_size=3, stride=2, padding=1)
self.p6_conv = nn.Conv2d(256, 256, kernel_size=3, stride=2, padding=1)
self.p5_conv = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
self.p4_conv = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
self.p3_conv = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
self.p2_conv = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
self.c7_conv = nn.Conv2d(256, 256, kernel_size=1, stride=1, padding=0)
self.c6_conv = nn.Conv2d(1024, 256, kernel_size=1, stride=1, padding=0)
self.c5_conv = nn.Conv2d(2048, 256, kernel_size=1, stride=1, padding=0)
self.c4_conv = nn.Conv2d(1024, 256, kernel_size=1, stride=1, padding=0)
self.c3_conv = nn.Conv2d(512, 256, kernel_size=1, stride=1, padding=0)
self.c2_conv = nn.Conv2d(256, 256, kernel_size=1, stride=1, padding=0)
# subnet_first stage
num_anchors = 2 * 1
self.cls_subnet = nn.Sequential(
nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True),
RFE(256, 256),
nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True),
)
self.box_subnet = nn.Sequential(
nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True),
RFE(256, 256),
nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True),
)
self.cls_subnet_pred = nn.Conv2d(256,
num_anchors * 1,
kernel_size=1,
stride=1,
padding=0)
self.box_subnet_pred = nn.Conv2d(256,
num_anchors * 4,
kernel_size=1,
stride=1,
padding=0)
self.sigmoid = nn.Sigmoid()
def conv_1x1_bn(inp, oup):
return nn.Sequential(nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup), nn.PReLU())
