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 __init__(self):
super(SSH, self).__init__()
# backbone
self.vgg16 = nn.ModuleList(make_layers(vgg_cfgs['D']))
# SSH - M3
self.M3 = M_Module(512, 256, 128)
self.M3_bbox_pred = nn.Conv2d(512, 8, 1, 1, 0)
self.M3_cls_score = nn.Conv2d(512, 4, 1, 1, 0)
self.M3_cls_score_softmax = nn.Softmax(dim=1)
# SSH - M2
self.M2 = M_Module(512, 256, 128)
self.M2_bbox_pred = nn.Conv2d(512, 8, 1, 1, 0)
self.M2_cls_score = nn.Conv2d(512, 4, 1, 1, 0)
self.M2_cls_score_softmax = nn.Softmax(dim=1)
# SSH - M1
self.conv4_128 = nn.Conv2d(512, 128, 1, 1, 0)
self.conv4_128_relu = nn.ReLU(inplace=True)
self.conv5_128 = nn.Conv2d(512, 128, 1, 1, 0)
self.conv5_128_relu = nn.ReLU(inplace=True)
self.conv5_128_up = nn.ConvTranspose2d(128, 128, 4, 2, 1, groups=128, bias=False)
self.eltadd = nn.EltAdd()
self.conv4_fuse_final = nn.Conv2d(128, 128, 3, 1, 1)
self.conv4_fuse_final_relu = nn.ReLU(inplace=True)
self.M1 = M_Module(128, 128, 64)
self.M1_bbox_pred = nn.Conv2d(256, 8, 1, 1, 0)
self.M1_cls_score = nn.Conv2d(256, 4, 1, 1, 0)
self.M1_cls_score_softmax = nn.Softmax(dim=1)
def __init__(self, in_planes, out_planes, stride=1, scale=0.1, map_reduce=8, vision=1, groups=1):
super(BasicRFB, self).__init__()
self.scale = scale
self.out_channels = out_planes
inter_planes = in_planes // map_reduce
self.branch0 = nn.Sequential(
BasicConv(in_planes, inter_planes, kernel_size=1, stride=1, groups=groups, relu=False),
BasicConv(inter_planes, 2 * inter_planes, kernel_size=(3, 3), stride=stride, padding=(1, 1), groups=groups),
BasicConv(2 * inter_planes, 2 * inter_planes, kernel_size=3, stride=1, padding=vision + 1, dilation=vision + 1, relu=False, groups=groups)
)
self.branch1 = nn.Sequential(
BasicConv(in_planes, inter_planes, kernel_size=1, stride=1, groups=groups, relu=False),
BasicConv(inter_planes, 2 * inter_planes, kernel_size=(3, 3), stride=stride, padding=(1, 1), groups=groups),
BasicConv(2 * inter_planes, 2 * inter_planes, kernel_size=3, stride=1, padding=vision + 2, dilation=vision + 2, relu=False, groups=groups)
)
self.branch2 = nn.Sequential(
BasicConv(in_planes, inter_planes, kernel_size=1, stride=1, groups=groups, relu=False),
BasicConv(inter_planes, (inter_planes // 2) * 3, kernel_size=3, stride=1, padding=1, groups=groups),
BasicConv((inter_planes // 2) * 3, 2 * inter_planes, kernel_size=3, stride=stride, padding=1, groups=groups),
BasicConv(2 * inter_planes, 2 * inter_planes, kernel_size=3, stride=1, padding=vision + 4, dilation=vision + 4, relu=False, groups=groups)
)
self.ConvLinear = BasicConv(6 * inter_planes, out_planes, kernel_size=1, stride=1, relu=False)
self.shortcut = BasicConv(in_planes, out_planes, kernel_size=1, stride=stride, relu=False)
self.relu = nn.ReLU(inplace=False)
self.eltadd = nn.EltAdd()
def __init__(self, in_channels_list, out_channels):
super(FPN, self).__init__()
leaky = 0
if (out_channels <= 64):
leaky = 0.1
self.output1 = conv_bn1X1(in_channels_list[0],
out_channels,
stride=1,
leaky=leaky)
self.output2 = conv_bn1X1(in_channels_list[1],
out_channels,
stride=1,
leaky=leaky)
self.output3 = conv_bn1X1(in_channels_list[2],
out_channels,
stride=1,
leaky=leaky)
self.upsample = nn.Upsample(scale_factor=2,
mode='bilinear',
align_corners=False)
self.eltadd = nn.EltAdd()
self.merge1 = conv_bn(out_channels, out_channels, leaky=leaky)
self.merge2 = conv_bn(out_channels, out_channels, leaky=leaky)
def __init__(self, model_type='32'):
super(EXTD, self).__init__()
self.model_type = int(model_type)
self.mobilenet = MobileNetV2(model_type=self.model_type)
if self.model_type == 32:
self.base = nn.ModuleList(self.mobilenet.features)[:8]
elif self.model_type == 48 or self.model_type == 64:
self.base = nn.ModuleList(self.mobilenet.features)[:6]
else:
raise NotImplementedError
self.upsample = nn.Upsample(scale_factor=2,
mode='bilinear',
align_corners=False)
self.eltadd = nn.EltAdd()
self.upfeat = []
for it in range(5):
self.upfeat.append(
upsample(in_channels=self.model_type,
out_channels=self.model_type))
self.upfeat = nn.ModuleList(self.upfeat)
self.loc = []
self.conf = []
self.net_source = [4, 4, 4, 4]
self.feature_dim = []
if self.model_type == 32:
self.feature_dim += [self.base[4].conv[-3].out_channels]
for idx in self.net_source:
self.feature_dim += [self.base[idx].conv[-3].out_channels]
else:
self.feature_dim += [self.base[4].conv[-2].out_channels]
for idx in self.net_source:
self.feature_dim += [self.base[idx].conv[-2].out_channels]
self.loc += [
nn.Conv2d(self.feature_dim[0], 4, kernel_size=3, padding=1)
]
self.conf += [
nn.Conv2d(self.feature_dim[0], 4, kernel_size=3, padding=1)
]
for k, v in enumerate(self.net_source, 1):
self.loc += [
nn.Conv2d(self.feature_dim[k], 4, kernel_size=3, padding=1)
]
self.conf += [
nn.Conv2d(self.feature_dim[k], 2, kernel_size=3, padding=1)
]
self.loc += [nn.Conv2d(self.model_type, 4, kernel_size=3, padding=1)]
self.conf += [nn.Conv2d(self.model_type, 2, kernel_size=3, padding=1)]
self.loc = nn.ModuleList(self.loc)
self.conf = nn.ModuleList(self.conf)
self.softmax = nn.Softmax(dim=-1)
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 __init__(self, name, in_channel, mid_channel, out_channel, downsample=False):
super(ResidualBlock, self).__init__()
stride = 2 if name.startswith('res3a') or name.startswith('res4a') else 1
self.cb1 = ConvBlock(in_channel, mid_channel, 1, stride, 0, add_relu=True)
self.cb2 = ConvBlock(mid_channel, mid_channel, 3, padding=1, add_relu=True)
self.cb3 = ConvBlock(mid_channel, out_channel, 1, padding=0, add_relu=False)
self.branch = None
if downsample:
self.branch = ConvBlock(in_channel, out_channel, 1, stride, 0, add_relu=False)
self.eltadd = nn.EltAdd()
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_channels):
super(CPM, self).__init__()
# residual
self.branch1 = Conv_BN(in_channels, 1024, 1, 1, 0, act=None)
self.branch2a = Conv_BN(in_channels, 256, 1, 1, 0, act='relu')
self.branch2b = Conv_BN(256, 256, 3, 1, 1, act='relu')
self.branch2c = Conv_BN(256, 1024, 1, 1, 0, act=None)
self.eltadd = nn.EltAdd()
self.rescomb_relu = nn.ReLU(inplace=True)
# ssh
self.ssh_1_conv = nn.Conv2d(1024, 256, 3, 1, 1)
self.ssh_dimred_conv = nn.Conv2d(1024, 128, 3, 1, 1)
self.ssh_dimred_relu = nn.ReLU(inplace=True)
self.ssh_2_conv = nn.Conv2d(128, 128, 3, 1, 1)
self.ssh_3a_conv = nn.Conv2d(128, 128, 3, 1, 1)
self.ssh_3a_relu = nn.ReLU(inplace=True)
self.ssh_3b_conv = nn.Conv2d(128, 128, 3, 1, 1)
self.concat_relu = nn.ReLU(inplace=True)
def __init__(self, channels, det_out=False):
super(ResBlock, self).__init__()
self.channels = channels
self.det_out = det_out
self.relu = nn.ReLU()
self.block = nn.Sequential(
nn.Conv2d(in_channels=self.channels,
out_channels=self.channels,
kernel_size=3,
stride=1,
padding=1), nn.ReLU(),
nn.Conv2d(in_channels=self.channels,
out_channels=self.channels,
kernel_size=3,
stride=1,
padding=1))
self.eltadd = nn.EltAdd()
from _utils import test_on
import sys
sys.path.append('.')
from flops_counter import nn
from flops_counter.tensorsize import TensorSize
######
# test on EltAdd
######
eltadd = {
'layers': [
nn.EltAdd() # same shape
],
'ins': [
TensorSize([64, 112, 112])
],
'out_shape': [
TensorSize([64, 112, 112])
],
'out_flops': [
802816
]
}
test_on(eltadd)
######
# test on EltMul
######
eltmul = {
def __init__(self, in_planes=256, out_planes=256):
super(RFE, self).__init__()
self.out_channels = out_planes
self.inter_channels = int(in_planes / 4)
self.branch0 = nn.Sequential(
nn.Conv2d(in_planes,
self.inter_channels,
kernel_size=1,
stride=1,
padding=0), nn.ReLU(inplace=True),
nn.Conv2d(self.inter_channels,
self.inter_channels,
kernel_size=(1, 5),
stride=1,
padding=(0, 2)), nn.ReLU(inplace=True),
nn.Conv2d(self.inter_channels,
self.inter_channels,
kernel_size=1,
stride=1,
padding=0), nn.ReLU(inplace=True))
self.branch1 = nn.Sequential(
nn.Conv2d(in_planes,
self.inter_channels,
kernel_size=1,
stride=1,
padding=0), nn.ReLU(inplace=True),
nn.Conv2d(self.inter_channels,
self.inter_channels,
kernel_size=(5, 1),
stride=1,
padding=(2, 0)), nn.ReLU(inplace=True),
nn.Conv2d(self.inter_channels,
self.inter_channels,
kernel_size=1,
stride=1,
padding=0), nn.ReLU(inplace=True))
self.branch2 = nn.Sequential(
nn.Conv2d(in_planes,
self.inter_channels,
kernel_size=1,
stride=1,
padding=0), nn.ReLU(inplace=True),
nn.Conv2d(self.inter_channels,
self.inter_channels,
kernel_size=(1, 3),
stride=1,
padding=(0, 1)), nn.ReLU(inplace=True),
nn.Conv2d(self.inter_channels,
self.inter_channels,
kernel_size=1,
stride=1,
padding=0), nn.ReLU(inplace=True))
self.branch3 = nn.Sequential(
nn.Conv2d(in_planes,
self.inter_channels,
kernel_size=1,
stride=1,
padding=0), nn.ReLU(inplace=True),
nn.Conv2d(self.inter_channels,
self.inter_channels,
kernel_size=(3, 1),
stride=1,
padding=(1, 0)), nn.ReLU(inplace=True),
nn.Conv2d(self.inter_channels,
self.inter_channels,
kernel_size=1,
stride=1,
padding=0), nn.ReLU(inplace=True))
self.cated_conv = nn.Sequential(
nn.Conv2d(in_planes,
out_planes,
kernel_size=1,
stride=1,
padding=0), nn.ReLU(inplace=True))
self.eltadd = nn.EltAdd()
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()
