def __init__(self):
super(light_DSFD, self).__init__()
self.conv1 = CRelu(3, 32, kernel_size=7, stride=4, padding=3)
self.conv3 = CRelu(64, 64, kernel_size=5, stride=2, padding=2)
self.inception1 = Inception2d(64)
self.inception2 = Inception2d(64)
self.inception3 = Inception2d(128)
self.inception4 = Inception2d(128)
self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.conv5_1 = BasicConv2d(128, 128, kernel_size=1, stride=1, padding=0)
self.conv5_2 = BasicConv2d(128, 256, kernel_size=3, stride=2, padding=1)
self.conv6_1 = BasicConv2d(256, 128, kernel_size=1, stride=1, padding=0)
self.conv6_2 = BasicConv2d(128, 256, kernel_size=3, stride=2, padding=1)
fpn_in = [64, 64, 128, 128, 256, 256]
cpm_in = [64, 64, 64, 64, 64, 64]
fpn_channel = 64
cpm_channels = 64
output_channels = cpm_in
# fpn
self.smooth3 = nn.Conv2d( fpn_channel, fpn_channel, kernel_size=1, stride=1, padding=0)
self.smooth2 = nn.Conv2d( fpn_channel, fpn_channel, kernel_size=1, stride=1, padding=0)
self.smooth1 = nn.Conv2d( fpn_channel, fpn_channel, kernel_size=1, stride=1, padding=0)
self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
self.eltmul = nn.EltMul()
self.latlayer6 = nn.Conv2d( fpn_in[5], fpn_channel, kernel_size=1, stride=1, padding=0)
self.latlayer5 = nn.Conv2d( fpn_in[4], fpn_channel, kernel_size=1, stride=1, padding=0)
self.latlayer4 = nn.Conv2d( fpn_in[3], fpn_channel, kernel_size=1, stride=1, padding=0)
self.latlayer3 = nn.Conv2d( fpn_in[2], fpn_channel, kernel_size=1, stride=1, padding=0)
self.latlayer2 = nn.Conv2d( fpn_in[1], fpn_channel, kernel_size=1, stride=1, padding=0)
self.latlayer1 = nn.Conv2d( fpn_in[0], fpn_channel, kernel_size=1, stride=1, padding=0)
# cpm
self.cpm1 = Inception2d(cpm_in[0])
self.cpm2 = Inception2d(cpm_in[1])
self.cpm3 = Inception2d(cpm_in[2])
self.cpm4 = Inception2d(cpm_in[3])
self.cpm5 = Inception2d(cpm_in[4])
self.cpm6 = Inception2d(cpm_in[5])
face_head = face_multibox(output_channels, [1, 1, 1, 1, 1, 1], 2 , cpm_channels)
self.loc = nn.ModuleList(face_head[0])
self.conf = nn.ModuleList(face_head[1])
self.softmax = nn.Softmax(dim=-1)
def __init__(self,
in_channels,
out_channels,
kernel_sizes,
strides=None,
paddings=None,
with_pool=True):
super(Conv_Block, self).__init__()
assert len(in_channels) == len(out_channels)
assert len(out_channels) == len(kernel_sizes)
if strides is not None:
assert len(kernel_sizes) == len(strides)
self.pool = None
if with_pool:
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
groups = len(in_channels)
convs = []
for i in range(groups):
convs.append(
nn.Conv2d(in_channels=in_channels[i],
out_channels=out_channels[i],
kernel_size=kernel_sizes[i],
stride=strides[i],
padding=paddings[i]))
convs.append(nn.ReLU(inplace=True))
self.feature = nn.Sequential(*convs)
def __init__(self):
super(HR, self).__init__()
self.conv = ConvBlock(3, 64, 7, 2, add_relu=True)
self.pool = nn.MaxPool2d(3, 2, 1)
self.res2a = ResidualBlock('res2a', 64, 64, 256, downsample=True)
self.res2b = ResidualBlock('res2b', 256, 64, 256)
self.res2c = ResidualBlock('res2c', 256, 64, 256)
self.res3a = ResidualBlock('res3a', 256, 128, 512, downsample=True)
self.res3b1 = ResidualBlock('res3b1', 512, 128, 512)
self.res3b2 = ResidualBlock('res3b2', 512, 128, 512)
self.res3b3 = ResidualBlock('res3b3', 512, 128, 512)
self.res4a = ResidualBlock('res4a', 512, 256, 1024, downsample=True)
self.res4bX = nn.ModuleList()
for i in range(0, 22):
self.res4bX.append(ResidualBlock('res4bX', 1024, 256, 1024))
# Detection Head
self.score_res4 = ConvBlock(1024, 125, 1, bias=True, add_relu=False, add_bn=False)
self.score4 = ConvTransLayer(125, 125, 4, 2, 0)
self.score_res3 = ConvBlock(512, 125, 1, bias=True, add_relu=False, add_bn=False)
self.eltadd = nn.EltAdd()
def build_conv_block(self,
in_channels: int,
out_channels: int,
kernel_size: int = 3,
stride: int = 1,
padding: int = 1,
n_conv: int = 2,
with_pool: bool = False):
layers = []
if with_pool:
layers.append(nn.MaxPool2d(kernel_size=2, stride=2))
# convx_1
layers += [
nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding),
nn.ReLU()
]
# convx_2 -> convx_(n_conv)
for i in range(1, n_conv):
add_layers = [
nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding),
nn.ReLU()
]
layers += add_layers
# return as sequential
return nn.Sequential(*layers)
def __init__(self):
super(YuFaceDetectNet, self).__init__()
self.num_classes = 2
self.model1 = Conv_2layers(3, 32, 16, 2)
self.model2 = Conv_2layers(16, 32, 32, 1)
self.model3 = Conv_3layers(32, 64, 32, 64, 1)
self.model4 = Conv_3layers(64, 128, 64, 128, 1)
self.model5 = Conv_3layers(128, 256, 128, 256, 1)
self.model6 = Conv_3layers(256, 256, 256, 256, 1)
self.pool1 = nn.MaxPool2d(2, 2)
self.pool2 = nn.MaxPool2d(2, 2)
self.pool3 = nn.MaxPool2d(2, 2)
self.pool4 = nn.MaxPool2d(2, 2)
self.pool5 = nn.MaxPool2d(2, 2)
self.loc, self.conf = self.multibox(self.num_classes)
self.softmax = nn.Softmax(dim=-1)
def __init__(self):
super(SHF, self).__init__()
self.conv1 = self.build_conv_block(3, 64, with_pool=True)
self.conv2 = self.build_conv_block(64, 128, with_pool=True)
self.conv3 = self.build_conv_block(128, 256, n_conv=3, with_pool=True)
self.conv4 = self.build_conv_block(256, 512, n_conv=3)
self.pool4 = nn.MaxPool2d(2, 2)
self.conv5 = self.build_conv_block(512, 512, n_conv=3)
self.conv5_256 = self.build_conv_block(512,
256,
1,
padding=0,
n_conv=1)
self.conv5_256_up = nn.ConvTranspose2d(256,
256,
kernel_size=4,
stride=2,
padding=1,
groups=256,
bias=False)
self.conv4_256 = self.build_conv_block(512,
256,
1,
padding=0,
n_conv=1)
self.conv4_fuse_final = self.build_conv_block(512, 512, n_conv=1)
self.conv4_fuse_final_dim_red = self.build_conv_block(512,
128,
n_conv=1)
self.head1 = self.build_conv_block(128,
128,
padding=1,
dilation=1,
n_conv=1)
self.head2 = self.build_conv_block(128,
128,
padding=2,
dilation=2,
n_conv=1)
self.head4 = self.build_conv_block(128,
128,
padding=4,
dilation=4,
n_conv=1)
self.bbox_head, self.cls_head = self.build_det_head()
self.softmax = nn.Softmax(dim=1)
def __init__(self):
super(FaceBoxes, self).__init__()
self.num_classes = 2
self.conv1 = CRelu(3, 24, kernel_size=7, stride=4, padding=3)
self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.conv2 = CRelu(48, 64, kernel_size=5, stride=2, padding=2)
self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.inception1 = Inception()
self.inception2 = Inception()
self.inception3 = Inception()
self.conv3_1 = BasicConv2d(128,
128,
kernel_size=1,
stride=1,
padding=0)
self.conv3_2 = BasicConv2d(128,
256,
kernel_size=3,
stride=2,
padding=1)
self.conv4_1 = BasicConv2d(256,
128,
kernel_size=1,
stride=1,
padding=0)
self.conv4_2 = BasicConv2d(128,
256,
kernel_size=3,
stride=2,
padding=1)
self.loc, self.conf = self.multibox(self.num_classes)
self.softmax = nn.Softmax(dim=-1)
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 __init__(self):
super(SFA, self).__init__()
# M0, M1, M2, M3
self.ssh_in_channels = [128, 128, 512, 512]
self.ssh_out_channels = [256, 256, 512, 512]
self.conv1 = self.build_conv_block(in_channels=3, out_channels=64, n_conv=2, with_pool=False)
self.conv2 = self.build_conv_block(in_channels=64, out_channels=128, n_conv=2, with_pool=True)
self.conv3 = self.build_conv_block(in_channels=128, out_channels=256, n_conv=3, with_pool=True)
self.conv4 = self.build_conv_block(in_channels=256, out_channels=512, n_conv=3, with_pool=True)
self.conv5 = self.build_conv_block(in_channels=512, out_channels=512, n_conv=3, with_pool=True)
# M3
self.pool6 = nn.MaxPool2d(2, 2)
self.m3 = SSH(self.ssh_in_channels[3], self.ssh_out_channels[3], index=3)
# M2
self.m2 = SSH(self.ssh_in_channels[2], self.ssh_out_channels[2], index=2)
# share by M1 and M2
self.conv4_128 = self.build_conv_block(in_channels=512, out_channels=128, kernel_size=1, padding=0, n_conv=1, with_pool=False)
# M1
self.conv5_128 = self.build_conv_block(in_channels=512, out_channels=128, kernel_size=1, padding=0, n_conv=1, with_pool=False)
self.conv5_128_up = nn.ConvTranspose2d(in_channels=128, out_channels=128, kernel_size=4, stride=2, padding=1, groups=128, bias=False)
self.conv4_fuse = nn.EltAdd()
self.conv4_fuse_final = self.build_conv_block(in_channels=128, out_channels=128, kernel_size=3, padding=1, n_conv=1, with_pool=False)
self.m1 = SSH(self.ssh_in_channels[1], self.ssh_out_channels[1], index=1)
# M0
self.conv3_128 = self.build_conv_block(in_channels=256, out_channels=128, kernel_size=1, padding=0, n_conv=1, with_pool=False)
self.conv4_128_up = nn.ConvTranspose2d(in_channels=128, out_channels=128, kernel_size=4, stride=2, padding=1, groups=128, bias=False)
self.conv3_fuse = nn.EltAdd()
self.conv3_fuse_final = self.build_conv_block(in_channels=128, out_channels=128, kernel_size=3, padding=1, n_conv=1, with_pool=False)
self.m0 = SSH(self.ssh_in_channels[0], self.ssh_out_channels[0], index=0)
# detection heads
self.bbox_head, self.cls_head = self.build_detect_head()
self.softmax = nn.Softmax(dim=-1)
def build_conv_block(self,
in_channels: int,
out_channels: int,
kernel_size: int = 3,
stride: int = 1,
padding: int = 1,
dilation: int = 1,
n_conv: int = 2,
with_pool: bool = False):
layers = [
nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding,
dilation),
nn.ReLU()
]
for i in range(1, n_conv):
layers += [
nn.Conv2d(out_channels, out_channels, kernel_size, stride,
padding),
nn.ReLU()
]
if with_pool:
layers += [nn.MaxPool2d(2, 2)]
return nn.Sequential(*layers)
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)
from _utils import test_on
import sys
sys.path.append('.')
from flops_counter import nn
from flops_counter.tensorsize import TensorSize
######
# test on MaxPool2d
######
mxpool2d = {
'layers': [
nn.MaxPool2d(3, 2, 1) # same shape
],
'ins': [
TensorSize([1, 64, 112, 112])
],
'out_shape': [
TensorSize([1, 64, 56, 56])
],
'out_flops': [
602112
]
}
test_on(mxpool2d)
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()
