def __init__(self, norm_type='bn', feature_maps=[4, 5], dcn_v2_stages=[], freeze_at=0):
super(Resnet18Vd, self).__init__()
self.norm_type = norm_type
self.feature_maps = feature_maps
assert freeze_at in [0, 1, 2, 3, 4, 5]
self.freeze_at = freeze_at
bn = 0
gn = 0
af = 0
if norm_type == 'bn':
bn = 1
elif norm_type == 'gn':
gn = 1
elif norm_type == 'affine_channel':
af = 1
self.stage1_conv1_1 = Conv2dUnit(3, 32, 3, stride=2, bn=bn, gn=gn, af=af, act='relu')
self.stage1_conv1_2 = Conv2dUnit(32, 32, 3, stride=1, bn=bn, gn=gn, af=af, act='relu')
self.stage1_conv1_3 = Conv2dUnit(32, 64, 3, stride=1, bn=bn, gn=gn, af=af, act='relu')
self.pool = torch.nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
# stage2
self.stage2_0 = BasicBlock(64, [64, 64], bn, gn, af, stride=1, is_first=True)
self.stage2_1 = BasicBlock(64, [64, 64], bn, gn, af, stride=1)
# stage3
self.stage3_0 = BasicBlock(64, [128, 128], bn, gn, af, stride=2)
self.stage3_1 = BasicBlock(128, [128, 128], bn, gn, af, stride=1)
# stage4
self.stage4_0 = BasicBlock(128, [256, 256], bn, gn, af, stride=2)
self.stage4_1 = BasicBlock(256, [256, 256], bn, gn, af, stride=1)
# stage5
self.stage5_0 = BasicBlock(256, [512, 512], bn, gn, af, stride=2)
self.stage5_1 = BasicBlock(512, [512, 512], bn, gn, af, stride=1)
def __init__(self, in_c, filters, bn, gn, af, use_dcn=False):
super(IdentityBlock, self).__init__()
filters1, filters2, filters3 = filters
self.conv1 = Conv2dUnit(in_c,
filters1,
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act='relu')
self.conv2 = Conv2dUnit(filters1,
filters2,
3,
stride=1,
bn=bn,
gn=gn,
af=af,
act='relu',
use_dcn=use_dcn)
self.conv3 = Conv2dUnit(filters2,
filters3,
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act=None)
self.act = torch.nn.ReLU()
def _init_layers(self):
self.cls_convs = paddle.nn.LayerList() # 每个fpn输出特征图 共享的 再进行卷积的卷积层，用于预测类别
self.krn_convs = paddle.nn.LayerList() # 每个fpn输出特征图 共享的 再进行卷积的卷积层，用于预测卷积核
# 每个fpn输出特征图 共享的 卷积层。
for lvl in range(0, self.num_convs):
use_dcn = lvl in self.dcn_v2_stages
# 使用gn，组数是32，而且带激活relu
in_ch = self.in_channels if lvl == 0 else self.seg_feat_channels
cls_conv_layer = Conv2dUnit(in_ch, self.seg_feat_channels, 3, stride=1, bias_attr=False, norm_type='gn', norm_groups=32, act='relu', use_dcn=use_dcn, name='head.cls_convs.%d' % (lvl, ))
self.cls_convs.append(cls_conv_layer)
in_ch = self.in_channels + 2 if lvl == 0 else self.seg_feat_channels
krn_conv_layer = Conv2dUnit(in_ch, self.seg_feat_channels, 3, stride=1, bias_attr=False, norm_type='gn', norm_groups=32, act='relu', use_dcn=use_dcn, name='head.krn_convs.%d' % (lvl, ))
self.krn_convs.append(krn_conv_layer)
if self.drop_block:
drop_block1 = DropBlock(block_size=3, keep_prob=0.9, is_test=False)
drop_block2 = DropBlock(block_size=3, keep_prob=0.9, is_test=False)
self.cls_convs.append(drop_block1)
self.krn_convs.append(drop_block2)
# 类别分支最后的卷积。设置偏移的初始值使得各类别预测概率初始值为self.prior_prob (根据激活函数是sigmoid()时推导出，和RetinaNet中一样)
bias_init_value = -math.log((1 - self.prior_prob) / self.prior_prob)
cls_last_conv_layer = Conv2dUnit(self.seg_feat_channels, self.cate_out_channels, 3, stride=1, bias_attr=True, act=None,
bias_init=Constant(bias_init_value), name='head.cls_convs.%d' % (self.num_convs, ))
# 卷积核分支最后的卷积
krn_last_conv_layer = Conv2dUnit(self.seg_feat_channels, self.kernel_out_channels, 3, stride=1, bias_attr=True, act=None, name='head.krn_convs.%d' % (self.num_convs, ))
self.cls_convs.append(cls_last_conv_layer)
self.krn_convs.append(krn_last_conv_layer)
def __init__(self, filters, use_dcn=False, stride=2):
'''
官方SOLO仓库中，下采样是在中间的3x3卷积层进行，不同于keras的resnet。
'''
super(ConvBlock, self).__init__()
filters1, filters2, filters3 = filters
self.conv1 = Conv2dUnit(filters1,
1,
strides=1,
padding='valid',
use_bias=False,
bn=1,
act='relu')
self.conv2 = Conv3x3(filters2, stride, use_dcn)
self.conv3 = Conv2dUnit(filters3,
1,
strides=1,
padding='valid',
use_bias=False,
bn=1,
act=None)
self.conv4 = Conv2dUnit(filters3,
1,
strides=stride,
padding='valid',
use_bias=False,
bn=1,
act=None)
self.act = layers.advanced_activations.ReLU()
def __init__(self, dcn_v2_stages=[5]):
super(Resnet50Vd, self).__init__()
self.stage1_conv1_1 = Conv2dUnit(32, 3, stride=2, padding=1, bias_attr=False, bn=1, act='relu', name='conv1_1')
self.stage1_conv1_2 = Conv2dUnit(32, 3, stride=1, padding=1, bias_attr=False, bn=1, act='relu', name='conv1_2')
self.stage1_conv1_3 = Conv2dUnit(64, 3, stride=1, padding=1, bias_attr=False, bn=1, act='relu', name='conv1_3')
# stage2
self.stage2_0 = ConvBlock([64, 64, 256], stride=1, block_name='res2a', is_first=True)
self.stage2_1 = IdentityBlock([64, 64, 256], block_name='res2b')
self.stage2_2 = IdentityBlock([64, 64, 256], block_name='res2c')
# stage3
use_dcn = 3 in dcn_v2_stages
self.stage3_0 = ConvBlock([128, 128, 512], block_name='res3a', use_dcn=use_dcn)
self.stage3_1 = IdentityBlock([128, 128, 512], block_name='res3b', use_dcn=use_dcn)
self.stage3_2 = IdentityBlock([128, 128, 512], block_name='res3c', use_dcn=use_dcn)
self.stage3_3 = IdentityBlock([128, 128, 512], block_name='res3d', use_dcn=use_dcn)
# stage4
use_dcn = 4 in dcn_v2_stages
self.stage4_0 = ConvBlock([256, 256, 1024], block_name='res4a', use_dcn=use_dcn)
self.stage4_1 = IdentityBlock([256, 256, 1024], block_name='res4b', use_dcn=use_dcn)
self.stage4_2 = IdentityBlock([256, 256, 1024], block_name='res4c', use_dcn=use_dcn)
self.stage4_3 = IdentityBlock([256, 256, 1024], block_name='res4d', use_dcn=use_dcn)
self.stage4_4 = IdentityBlock([256, 256, 1024], block_name='res4e', use_dcn=use_dcn)
self.stage4_5 = IdentityBlock([256, 256, 1024], block_name='res4f', use_dcn=use_dcn)
# stage5
use_dcn = 5 in dcn_v2_stages
self.stage5_0 = ConvBlock([512, 512, 2048], block_name='res5a', use_dcn=use_dcn)
self.stage5_1 = IdentityBlock([512, 512, 2048], block_name='res5b', use_dcn=use_dcn)
self.stage5_2 = IdentityBlock([512, 512, 2048], block_name='res5c', use_dcn=use_dcn)
def __init__(self,
in_c,
filters,
bn,
gn,
af,
stride=1,
is_first=False,
block_name=''):
super(BasicBlock, self).__init__()
filters1, filters2 = filters
stride1, stride2 = stride, 1
self.is_first = is_first
self.stride = stride
self.conv1 = Conv2dUnit(in_c,
filters1,
3,
stride=stride1,
bn=bn,
gn=gn,
af=af,
act='relu',
name=block_name + '_branch2a')
self.conv2 = Conv2dUnit(filters1,
filters2,
3,
stride=stride2,
bn=bn,
gn=gn,
af=af,
act=None,
name=block_name + '_branch2b')
self.conv3 = None
if self.stride == 2 or self.is_first:
if not self.is_first:
self.avg_pool = keras.layers.AvgPool2D(pool_size=2,
strides=2,
padding='valid')
self.conv3 = Conv2dUnit(in_c,
filters2,
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act=None,
name=block_name + '_branch1')
else:
self.conv3 = Conv2dUnit(in_c,
filters2,
1,
stride=stride,
bn=bn,
gn=gn,
af=af,
act=None,
name=block_name + '_branch1')
self.act = keras.layers.ReLU()
def __init__(self, filters, use_dcn=False, block_name=''):
super(IdentityBlock, self).__init__()
filters1, filters2, filters3 = filters
self.block_name = block_name
self.conv1 = Conv2dUnit(filters1, 1, stride=1, padding=0, bias_attr=False, bn=1, act='relu', name=block_name+'_branch2a')
self.conv2 = Conv2dUnit(filters2, 3, stride=1, padding=1, bias_attr=False, bn=1, act='relu', name=block_name+'_branch2b', use_dcn=use_dcn)
self.conv3 = Conv2dUnit(filters3, 1, stride=1, padding=0, bias_attr=False, bn=1, act=None, name=block_name+'_branch2c')
def __init__(self, norm_type, inplanes, planes, stride=1, name=''):
super(BasicBlock, self).__init__()
bn, gn, af = get_norm(norm_type)
self.conv1 = Conv2dUnit(inplanes, planes, 3, stride=stride, bias_attr=False, bn=bn, gn=gn, af=af, act='relu',
name=name + '.conv1')
self.conv2 = Conv2dUnit(planes, planes, 3, stride=1, bias_attr=False, bn=bn, gn=gn, af=af, act=None,
name=name + '.conv2')
self.stride = stride
def __init__(self,
in_c,
filters,
bn,
gn,
af,
use_dcn=False,
stride=2,
downsample_in3x3=True,
block_name=''):
'''
ResNetVB的下采样是在中间的3x3卷积层进行。
'''
super(ConvBlock, self).__init__()
filters1, filters2, filters3 = filters
if downsample_in3x3 == True:
stride1, stride2 = 1, stride
else:
stride1, stride2 = stride, 1
self.conv1 = Conv2dUnit(in_c,
filters1,
1,
stride=stride1,
bn=bn,
gn=gn,
af=af,
act='relu',
name=block_name + '.conv0')
self.conv2 = Conv2dUnit(filters1,
filters2,
3,
stride=stride2,
bn=bn,
gn=gn,
af=af,
act='relu',
use_dcn=use_dcn,
name=block_name + '.conv1')
self.conv3 = Conv2dUnit(filters2,
filters3,
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act=None,
name=block_name + '.conv2')
self.conv4 = Conv2dUnit(in_c,
filters3,
1,
stride=stride,
bn=bn,
gn=gn,
af=af,
act=None,
name=block_name + '.conv3')
def __init__(self, filters, use_dcn=False, stride=2, block_name='', is_first=False):
super(ConvBlock, self).__init__()
filters1, filters2, filters3 = filters
self.block_name = block_name
self.is_first = is_first
self.conv1 = Conv2dUnit(filters1, 1, stride=1, padding=0, bias_attr=False, bn=1, act='relu', name=block_name+'_branch2a')
self.conv2 = Conv2dUnit(filters2, 3, stride=stride, padding=1, bias_attr=False, bn=1, act='relu', name=block_name+'_branch2b', use_dcn=use_dcn)
self.conv3 = Conv2dUnit(filters3, 1, stride=1, padding=0, bias_attr=False, bn=1, act=None, name=block_name+'_branch2c')
if not self.is_first:
self.conv4 = Conv2dUnit(filters3, 1, stride=1, padding=0, bias_attr=False, bn=1, act=None, name=block_name+'_branch1')
else:
self.conv4 = Conv2dUnit(filters3, 1, stride=stride, padding=0, bias_attr=False, bn=1, act=None, name=block_name+'_branch1')
def __init__(self,
in_channels,
out_channels,
num_outs,
start_level=0,
end_level=-1,
add_extra_convs=False,
extra_convs_on_inputs=True,
relu_before_extra_convs=False,
no_norm_on_lateral=False,
conv_cfg=None,
norm_cfg=None,
activation=None):
super(FPN, self).__init__()
self.num_ins = len(in_channels)
self.num_outs = num_outs
self.start_level = start_level
self.add_extra_convs = add_extra_convs
if end_level == -1:
self.backbone_end_level = self.num_ins
assert num_outs >= self.num_ins - start_level
else:
# if end_level < inputs, no extra level is allowed
self.backbone_end_level = end_level
assert end_level <= len(in_channels)
assert num_outs == end_level - start_level
# FPN部分有8个卷积层
self.lateral_convs = []
self.fpn_convs = []
for i in range(self.start_level, self.backbone_end_level):
l_conv = Conv2dUnit(out_channels,
1,
strides=1,
padding='valid',
use_bias=True,
bn=0,
act=None)
fpn_conv = Conv2dUnit(out_channels,
3,
strides=1,
padding='same',
use_bias=True,
bn=0,
act=None)
self.lateral_convs.append(l_conv)
self.fpn_convs.append(fpn_conv)
def __init__(self, norm_type, levels, block, in_channels, out_channels, stride=1,
level_root=False, root_dim=0, root_kernel_size=1, root_residual=False, name=''):
super(Tree, self).__init__()
if root_dim == 0:
root_dim = 2 * out_channels
if level_root:
root_dim += in_channels
if levels == 1:
self.tree1 = block(norm_type, in_channels, out_channels, stride, name=name + '.tree1')
self.tree2 = block(norm_type, out_channels, out_channels, 1, name=name + '.tree2')
else:
self.tree1 = Tree(norm_type, levels - 1, block, in_channels, out_channels,
stride, root_dim=0,
root_kernel_size=root_kernel_size, root_residual=root_residual, name=name + '.tree1')
self.tree2 = Tree(norm_type, levels - 1, block, out_channels, out_channels,
root_dim=root_dim + out_channels,
root_kernel_size=root_kernel_size, root_residual=root_residual, name=name + '.tree2')
if levels == 1:
self.root = Root(norm_type, root_dim, out_channels, root_kernel_size, root_residual, name=name + '.root')
self.level_root = level_root
self.root_dim = root_dim
self.downsample = False
self.stride = stride
self.project = None
self.levels = levels
if stride > 1:
self.downsample = True
if in_channels != out_channels:
bn, gn, af = get_norm(norm_type)
self.project = Conv2dUnit(in_channels, out_channels, 1, stride=1, bias_attr=False, bn=bn, gn=gn, af=af,
act=None, name=name + '.project')
def __init__(self, norm_type='bn', feature_maps=[3, 4, 5], dcn_v2_stages=[5], downsample_in3x3=True, freeze_at=0):
super(Resnet50Vd, self).__init__()
self.norm_type = norm_type
self.feature_maps = feature_maps
assert freeze_at in [0, 1, 2, 3, 4, 5]
self.freeze_at = freeze_at
bn = 0
gn = 0
af = 0
if norm_type == 'bn':
bn = 1
elif norm_type == 'gn':
gn = 1
elif norm_type == 'affine_channel':
af = 1
self.stage1_conv1_1 = Conv2dUnit(3, 32, 3, stride=2, bn=bn, gn=gn, af=af, act='relu')
self.stage1_conv1_2 = Conv2dUnit(32, 32, 3, stride=1, bn=bn, gn=gn, af=af, act='relu')
self.stage1_conv1_3 = Conv2dUnit(32, 64, 3, stride=1, bn=bn, gn=gn, af=af, act='relu')
self.pool = torch.nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
# stage2
self.stage2_0 = ConvBlock(64, [64, 64, 256], bn, gn, af, stride=1, downsample_in3x3=downsample_in3x3, is_first=True)
self.stage2_1 = IdentityBlock(256, [64, 64, 256], bn, gn, af)
self.stage2_2 = IdentityBlock(256, [64, 64, 256], bn, gn, af)
# stage3
use_dcn = 3 in dcn_v2_stages
self.stage3_0 = ConvBlock(256, [128, 128, 512], bn, gn, af, use_dcn=use_dcn, downsample_in3x3=downsample_in3x3)
self.stage3_1 = IdentityBlock(512, [128, 128, 512], bn, gn, af, use_dcn=use_dcn)
self.stage3_2 = IdentityBlock(512, [128, 128, 512], bn, gn, af, use_dcn=use_dcn)
self.stage3_3 = IdentityBlock(512, [128, 128, 512], bn, gn, af, use_dcn=use_dcn)
# stage4
use_dcn = 4 in dcn_v2_stages
self.stage4_0 = ConvBlock(512, [256, 256, 1024], bn, gn, af, use_dcn=use_dcn, downsample_in3x3=downsample_in3x3)
self.stage4_1 = IdentityBlock(1024, [256, 256, 1024], bn, gn, af, use_dcn=use_dcn)
self.stage4_2 = IdentityBlock(1024, [256, 256, 1024], bn, gn, af, use_dcn=use_dcn)
self.stage4_3 = IdentityBlock(1024, [256, 256, 1024], bn, gn, af, use_dcn=use_dcn)
self.stage4_4 = IdentityBlock(1024, [256, 256, 1024], bn, gn, af, use_dcn=use_dcn)
self.stage4_5 = IdentityBlock(1024, [256, 256, 1024], bn, gn, af, use_dcn=use_dcn)
# stage5
use_dcn = 5 in dcn_v2_stages
self.stage5_0 = ConvBlock(1024, [512, 512, 2048], bn, gn, af, use_dcn=use_dcn, downsample_in3x3=downsample_in3x3)
self.stage5_1 = IdentityBlock(2048, [512, 512, 2048], bn, gn, af, use_dcn=use_dcn)
self.stage5_2 = IdentityBlock(2048, [512, 512, 2048], bn, gn, af, use_dcn=use_dcn)
def _make_conv_level(self, inplanes, planes, convs, stride=1, name=''):
modules = []
for i in range(convs):
bn, gn, af = get_norm(self.norm_type)
modules.append(
Conv2dUnit(inplanes, planes, 3, stride=stride if i == 0 else 1, bias_attr=False, bn=bn, gn=gn, af=af,
act='relu', name=name + '.conv%d' % i))
inplanes = planes
return modules
def __init__(self, in_c, filters, bn, gn, af, stride=1, is_first=False):
super(BasicBlock, self).__init__()
filters1, filters2 = filters
stride1, stride2 = stride, 1
self.is_first = is_first
self.stride = stride
self.conv1 = Conv2dUnit(in_c, filters1, 3, stride=stride1, bn=bn, gn=gn, af=af, act='relu')
self.conv2 = Conv2dUnit(filters1, filters2, 3, stride=stride2, bn=bn, gn=gn, af=af, act=None)
self.conv3 = None
if self.stride == 2 or self.is_first:
if not self.is_first:
self.avg_pool = torch.nn.AvgPool2d(kernel_size=2, stride=2, padding=0)
self.conv3 = Conv2dUnit(in_c, filters2, 1, stride=1, bn=bn, gn=gn, af=af, act=None)
else:
self.conv3 = Conv2dUnit(in_c, filters2, 1, stride=stride, bn=bn, gn=gn, af=af, act=None)
self.act = torch.nn.ReLU(inplace=True)
def __init__(self, in_c, filters, bn, gn, af, use_dcn=False, stride=2, downsample_in3x3=True, is_first=False):
super(ConvBlock, self).__init__()
filters1, filters2, filters3 = filters
if downsample_in3x3 == True:
stride1, stride2 = 1, stride
else:
stride1, stride2 = stride, 1
self.is_first = is_first
self.conv1 = Conv2dUnit(in_c, filters1, 1, stride=stride1, bn=bn, gn=gn, af=af, act='relu')
self.conv2 = Conv2dUnit(filters1, filters2, 3, stride=stride2, bn=bn, gn=gn, af=af, act='relu', use_dcn=use_dcn)
self.conv3 = Conv2dUnit(filters2, filters3, 1, stride=1, bn=bn, gn=gn, af=af, act=None)
if not self.is_first:
self.avg_pool = torch.nn.AvgPool2d(kernel_size=2, stride=2, padding=0)
self.conv4 = Conv2dUnit(in_c, filters3, 1, stride=1, bn=bn, gn=gn, af=af, act=None)
else:
self.conv4 = Conv2dUnit(in_c, filters3, 1, stride=stride, bn=bn, gn=gn, af=af, act=None)
self.act = torch.nn.ReLU(inplace=True)
def __init__(self,
in_c,
filters,
bn,
gn,
af,
use_dcn=False,
block_name=''):
super(IdentityBlock, self).__init__()
filters1, filters2, filters3 = filters
self.conv1 = Conv2dUnit(in_c,
filters1,
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act='relu',
name=block_name + '_branch2a')
self.conv2 = Conv2dUnit(filters1,
filters2,
3,
stride=1,
bn=bn,
gn=gn,
af=af,
act='relu',
use_dcn=use_dcn,
name=block_name + '_branch2b')
self.conv3 = Conv2dUnit(filters2,
filters3,
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act=None,
name=block_name + '_branch2c')
self.act = keras.layers.ReLU()
def __init__(self, filters, use_dcn=False):
super(IdentityBlock, self).__init__()
filters1, filters2, filters3 = filters
self.conv1 = Conv2dUnit(filters1,
1,
strides=1,
padding='valid',
use_bias=False,
bn=1,
act='relu')
self.conv2 = Conv3x3(filters2, 1, use_dcn)
self.conv3 = Conv2dUnit(filters3,
1,
strides=1,
padding='valid',
use_bias=False,
bn=1,
act=None)
self.act = layers.advanced_activations.ReLU()
def __init__(self, input_dim, filters_1, filters_2, bn, gn, af, name=''):
super(ResidualBlock, self).__init__()
self.conv1 = Conv2dUnit(input_dim,
filters_1,
1,
stride=1,
bias_attr=False,
bn=bn,
gn=gn,
af=af,
act='mish',
name=name + '.conv1')
self.conv2 = Conv2dUnit(filters_1,
filters_2,
3,
stride=1,
bias_attr=False,
bn=bn,
gn=gn,
af=af,
act='mish',
name=name + '.conv2')
def __init__(self, norm_type, inplanes, planes, stride=1):
super(BasicBlock, self).__init__()
bn, gn, af = get_norm(norm_type)
self.conv1 = Conv2dUnit(inplanes,
planes,
3,
stride=stride,
bias_attr=False,
bn=bn,
gn=gn,
af=af,
act='relu')
self.conv2 = Conv2dUnit(planes,
planes,
3,
stride=1,
bias_attr=False,
bn=bn,
gn=gn,
af=af,
act=None)
self.relu = nn.ReLU(inplace=True)
self.stride = stride
def __init__(self, norm_type, in_channels, out_channels, kernel_size,
residual):
super(Root, self).__init__()
bn, gn, af = get_norm(norm_type)
self.conv = Conv2dUnit(in_channels,
out_channels,
kernel_size,
stride=1,
bias_attr=False,
bn=bn,
gn=gn,
af=af,
act=None)
self.relu = nn.ReLU(inplace=True)
self.residual = residual
def _make_conv_level(self, inplanes, planes, convs, stride=1):
modules = []
for i in range(convs):
bn, gn, af = get_norm(self.norm_type)
modules.append(
Conv2dUnit(inplanes,
planes,
3,
stride=stride if i == 0 else 1,
bias_attr=False,
bn=bn,
gn=gn,
af=af,
act='relu'))
inplanes = planes
return nn.Sequential(*modules)
def __init__(self, depth, use_dcn=False):
super(Resnet, self).__init__()
assert depth in [50, 101]
self.conv1 = Conv2dUnit(64,
7,
strides=2,
padding='same',
use_bias=False,
bn=1,
act='relu')
self.maxpool = layers.MaxPooling2D(pool_size=3,
strides=2,
padding='same')
# stage2
self.stage2_0 = ConvBlock([64, 64, 256], stride=1)
self.stage2_1 = IdentityBlock([64, 64, 256])
self.stage2_2 = IdentityBlock([64, 64, 256])
# stage3
self.stage3_0 = ConvBlock([128, 128, 512], use_dcn=use_dcn)
self.stage3_1 = IdentityBlock([128, 128, 512], use_dcn=use_dcn)
self.stage3_2 = IdentityBlock([128, 128, 512], use_dcn=use_dcn)
self.stage3_3 = IdentityBlock([128, 128, 512], use_dcn=use_dcn)
# stage4
self.stage4_0 = ConvBlock([256, 256, 1024], use_dcn=use_dcn)
k = 21
if depth == 50:
k = 4
self.stage4_layers = []
for i in range(k):
ly = IdentityBlock([256, 256, 1024], use_dcn=use_dcn)
self.stage4_layers.append(ly)
self.stage4_last_layer = IdentityBlock([256, 256, 1024],
use_dcn=use_dcn)
# stage5
self.stage5_0 = ConvBlock([512, 512, 2048], use_dcn=use_dcn)
self.stage5_1 = IdentityBlock([512, 512, 2048], use_dcn=use_dcn)
self.stage5_2 = IdentityBlock([512, 512, 2048], use_dcn=use_dcn)
def __init__(self,
num_chan=256,
use_p6p7=True,
in_chs=[2048, 1024, 512]):
super(FPN, self).__init__()
self.use_p6p7 = use_p6p7
# 对骨干网络的sxx进行卷积
self.s32_conv = Conv2dUnit(in_chs[0], num_chan, 1, stride=1, bias_attr=True, act=None, name='fpn.s32_conv')
self.s16_conv = Conv2dUnit(in_chs[1], num_chan, 1, stride=1, bias_attr=True, act=None, name='fpn.s16_conv')
self.s8_conv = Conv2dUnit(in_chs[2], num_chan, 1, stride=1, bias_attr=True, act=None, name='fpn.s8_conv')
self.convs = [self.s32_conv, self.s16_conv, self.s8_conv]
# 第二次卷积
self.sc_s32_conv = Conv2dUnit(num_chan, num_chan, 3, stride=1, bias_attr=True, act=None, name='fpn.sc_s32_conv')
self.sc_s16_conv = Conv2dUnit(num_chan, num_chan, 3, stride=1, bias_attr=True, act=None, name='fpn.sc_s16_conv')
self.sc_s8_conv = Conv2dUnit(num_chan, num_chan, 3, stride=1, bias_attr=True, act=None, name='fpn.sc_s8_conv')
self.second_convs = [self.sc_s32_conv, self.sc_s16_conv, self.sc_s8_conv]
# p6p7
if self.use_p6p7:
self.p6_conv = Conv2dUnit(num_chan, num_chan, 3, stride=2, bias_attr=True, act=None, name='fpn.p6_conv')
self.p7_conv = Conv2dUnit(num_chan, num_chan, 3, stride=2, bias_attr=True, act=None, name='fpn.p7_conv')
def __init__(self, norm_type, levels, channels, block=BasicBlock, residual_root=False, feature_maps=[3, 4, 5]):
super(DLA, self).__init__()
self.norm_type = norm_type
self.channels = channels
self.feature_maps = feature_maps
self._out_features = ["level{}".format(i) for i in range(6)] # 每个特征图的名字
self._out_feature_channels = {k: channels[i] for i, k in enumerate(self._out_features)} # 每个特征图的输出通道数
self._out_feature_strides = {k: 2 ** i for i, k in enumerate(self._out_features)} # 每个特征图的下采样倍率
bn, gn, af = get_norm(norm_type)
self.base_layer = Conv2dUnit(3, channels[0], 7, stride=1, bias_attr=False, bn=bn, gn=gn, af=af, act='relu',
name='dla.base_layer')
self.level0 = self._make_conv_level(channels[0], channels[0], levels[0], name='dla.level0')
self.level1 = self._make_conv_level(channels[0], channels[1], levels[1], stride=2, name='dla.level1')
self.level2 = Tree(norm_type, levels[2], block, channels[1], channels[2], 2,
level_root=False, root_residual=residual_root, name='dla.level2')
self.level3 = Tree(norm_type, levels[3], block, channels[2], channels[3], 2,
level_root=True, root_residual=residual_root, name='dla.level3')
self.level4 = Tree(norm_type, levels[4], block, channels[3], channels[4], 2,
level_root=True, root_residual=residual_root, name='dla.level4')
self.level5 = Tree(norm_type, levels[5], block, channels[4], channels[5], 2,
level_root=True, root_residual=residual_root, name='dla.level5')
def __init__(self,
conv_block_num=2,
num_classes=80,
anchors=[[10, 13], [16, 30], [33, 23], [30, 61], [62, 45],
[59, 119], [116, 90], [156, 198], [373, 326]],
anchor_masks=[[6, 7, 8], [3, 4, 5], [0, 1, 2]],
norm_type="bn",
coord_conv=True,
iou_aware=True,
iou_aware_factor=0.4,
block_size=3,
scale_x_y=1.05,
spp=True,
drop_block=True,
keep_prob=0.9,
clip_bbox=True,
yolo_loss=None,
downsample=[32, 16, 8],
in_channels=[2048, 1024, 512],
nms_cfg=None,
is_train=False):
super(YOLOv3Head, self).__init__()
self.conv_block_num = conv_block_num
self.num_classes = num_classes
self.norm_type = norm_type
self.coord_conv = coord_conv
self.iou_aware = iou_aware
self.iou_aware_factor = iou_aware_factor
self.scale_x_y = scale_x_y
self.use_spp = spp
self.drop_block = drop_block
self.keep_prob = keep_prob
self.clip_bbox = clip_bbox
self.anchors = anchors
self.anchor_masks = anchor_masks
self.block_size = block_size
self.downsample = downsample
self.in_channels = in_channels
self.yolo_loss = yolo_loss
self.nms_cfg = nms_cfg
self.is_train = is_train
_anchors = copy.deepcopy(anchors)
_anchors = np.array(_anchors)
_anchors = _anchors.astype(np.float32)
self._anchors = _anchors # [9, 2]
self.mask_anchors = []
for m in anchor_masks:
temp = []
for aid in m:
temp += anchors[aid]
self.mask_anchors.append(temp)
bn = 0
gn = 0
af = 0
if norm_type == 'bn':
bn = 1
elif norm_type == 'gn':
gn = 1
elif norm_type == 'affine_channel':
af = 1
self.detection_blocks = torch.nn.ModuleList()
self.yolo_output_convs = torch.nn.ModuleList()
self.upsample_layers = torch.nn.ModuleList()
out_layer_num = len(downsample)
for i in range(out_layer_num):
in_c = self.in_channels[i]
if i > 0: # perform concat in first 2 detection_block
in_c = self.in_channels[i] + 512 // (2**i)
_detection_block = DetectionBlock(
in_c=in_c,
channel=64 * (2**out_layer_num) // (2**i),
coord_conv=self.coord_conv,
bn=bn,
gn=gn,
af=af,
is_first=i == 0,
conv_block_num=self.conv_block_num,
use_spp=self.use_spp,
drop_block=self.drop_block,
block_size=self.block_size,
keep_prob=self.keep_prob,
is_test=(not self.is_train))
# out channel number = mask_num * (5 + class_num)
if self.iou_aware:
num_filters = len(
self.anchor_masks[i]) * (self.num_classes + 6)
else:
num_filters = len(
self.anchor_masks[i]) * (self.num_classes + 5)
yolo_output_conv = Conv2dUnit(64 * (2**out_layer_num) // (2**i) *
2,
num_filters,
1,
stride=1,
bias_attr=True,
bn=0,
gn=0,
af=0,
act=None)
self.detection_blocks.append(_detection_block)
self.yolo_output_convs.append(yolo_output_conv)
if i < out_layer_num - 1:
# do not perform upsample in the last detection_block
conv_unit = Conv2dUnit(64 * (2**out_layer_num) // (2**i),
256 // (2**i),
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act='leaky')
# upsample
upsample = torch.nn.Upsample(scale_factor=2, mode='nearest')
self.upsample_layers.append(conv_unit)
self.upsample_layers.append(upsample)
def __init__(self,
depth,
norm_type='affine_channel',
feature_maps=[3, 4, 5],
use_dcn=False,
downsample_in3x3=True,
freeze_at=0):
super(Resnet, self).__init__()
assert depth in [50, 101]
self.depth = depth
self.norm_type = norm_type
self.feature_maps = feature_maps
self.use_dcn = use_dcn
assert freeze_at in [0, 1, 2, 3, 4, 5]
self.freeze_at = freeze_at
bn = 0
gn = 0
af = 0
if norm_type == 'bn':
bn = 1
elif norm_type == 'gn':
gn = 1
elif norm_type == 'affine_channel':
af = 1
self.conv1 = Conv2dUnit(3,
64,
7,
stride=2,
bn=bn,
gn=gn,
af=af,
act='relu')
self.pool = torch.nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
# stage2
self.stage2_0 = ConvBlock(64, [64, 64, 256],
bn,
gn,
af,
stride=1,
downsample_in3x3=downsample_in3x3)
self.stage2_1 = IdentityBlock(256, [64, 64, 256], bn, gn, af)
self.stage2_2 = IdentityBlock(256, [64, 64, 256], bn, gn, af)
# stage3
self.stage3_0 = ConvBlock(256, [128, 128, 512],
bn,
gn,
af,
use_dcn=use_dcn,
downsample_in3x3=downsample_in3x3)
self.stage3_1 = IdentityBlock(512, [128, 128, 512],
bn,
gn,
af,
use_dcn=use_dcn)
self.stage3_2 = IdentityBlock(512, [128, 128, 512],
bn,
gn,
af,
use_dcn=use_dcn)
self.stage3_3 = IdentityBlock(512, [128, 128, 512],
bn,
gn,
af,
use_dcn=use_dcn)
# stage4
self.stage4_0 = ConvBlock(512, [256, 256, 1024],
bn,
gn,
af,
use_dcn=use_dcn,
downsample_in3x3=downsample_in3x3)
k = 21
if depth == 50:
k = 4
self.stage4_layers = torch.nn.ModuleList()
for i in range(k):
ly = IdentityBlock(1024, [256, 256, 1024],
bn,
gn,
af,
use_dcn=use_dcn)
self.stage4_layers.append(ly)
self.stage4_last_layer = IdentityBlock(1024, [256, 256, 1024],
bn,
gn,
af,
use_dcn=use_dcn)
# stage5
self.stage5_0 = ConvBlock(1024, [512, 512, 2048],
bn,
gn,
af,
use_dcn=use_dcn,
downsample_in3x3=downsample_in3x3)
self.stage5_1 = IdentityBlock(2048, [512, 512, 2048],
bn,
gn,
af,
use_dcn=use_dcn)
self.stage5_2 = IdentityBlock(2048, [512, 512, 2048],
bn,
gn,
af,
use_dcn=use_dcn)
def __init__(self,
norm_type,
levels,
channels,
block=BasicBlock,
residual_root=False,
feature_maps=[3, 4, 5],
freeze_at=0):
super(DLA, self).__init__()
self.norm_type = norm_type
self.channels = channels
self.feature_maps = feature_maps
assert freeze_at in [0, 1, 2, 3, 4, 5, 6, 7]
self.freeze_at = freeze_at
self._out_features = ["level{}".format(i)
for i in range(6)] # 每个特征图的名字
self._out_feature_channels = {
k: channels[i]
for i, k in enumerate(self._out_features)
} # 每个特征图的输出通道数
self._out_feature_strides = {
k: 2**i
for i, k in enumerate(self._out_features)
} # 每个特征图的下采样倍率
bn, gn, af = get_norm(norm_type)
self.base_layer = Conv2dUnit(3,
channels[0],
7,
stride=1,
bias_attr=False,
bn=bn,
gn=gn,
af=af,
act='relu')
self.level0 = self._make_conv_level(channels[0], channels[0],
levels[0])
self.level1 = self._make_conv_level(channels[0],
channels[1],
levels[1],
stride=2)
self.level2 = Tree(norm_type,
levels[2],
block,
channels[1],
channels[2],
2,
level_root=False,
root_residual=residual_root)
self.level3 = Tree(norm_type,
levels[3],
block,
channels[2],
channels[3],
2,
level_root=True,
root_residual=residual_root)
self.level4 = Tree(norm_type,
levels[4],
block,
channels[3],
channels[4],
2,
level_root=True,
root_residual=residual_root)
self.level5 = Tree(norm_type,
levels[5],
block,
channels[4],
channels[5],
2,
level_root=True,
root_residual=residual_root)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
def __init__(self,
num_classes,
fpn_stride=[8, 16, 32, 64, 128],
thresh_with_ctr=True,
prior_prob=0.01,
num_convs=4,
batch_size=1,
norm_type="gn",
fcos_loss=None,
norm_reg_targets=True,
centerness_on_reg=True,
use_dcn_in_tower=False,
nms_cfg=None):
super(FCOSSharedHead, self).__init__()
self.num_classes = num_classes
self.fpn_stride = fpn_stride[::-1]
self.thresh_with_ctr = thresh_with_ctr
self.prior_prob = prior_prob
self.num_convs = num_convs
self.norm_reg_targets = norm_reg_targets
self.centerness_on_reg = centerness_on_reg
self.use_dcn_in_tower = use_dcn_in_tower
self.norm_type = norm_type
self.fcos_loss = fcos_loss
self.batch_size = batch_size
self.nms_cfg = nms_cfg
self.scales_on_reg = [] # 回归分支（预测框坐标）的系数
self.cls_convs = [] # 每个fpn输出特征图 共享的 再进行卷积的卷积层，用于预测类别
self.reg_convs = [] # 每个fpn输出特征图 共享的 再进行卷积的卷积层，用于预测坐标
self.ctn_conv = Conv2dUnit(256,
1,
3,
stride=1,
bias_attr=True,
act=None,
name='head.ctn_conv') # 用于预测centerness
# 每个fpn输出特征图 共享的 卷积层。
for lvl in range(0, self.num_convs):
# 使用gn，组数是32，而且带激活relu
cls_conv_layer = Conv2dUnit(256,
256,
3,
stride=1,
bias_attr=True,
gn=1,
groups=32,
act='relu',
name='head.cls_convs.%d' % (lvl, ))
self.cls_convs.append(cls_conv_layer)
reg_conv_layer = Conv2dUnit(256,
256,
3,
stride=1,
bias_attr=True,
gn=1,
groups=32,
act='relu',
name='head.reg_convs.%d' % (lvl, ))
self.reg_convs.append(reg_conv_layer)
# 类别分支最后的卷积。设置偏移的初始值使得各类别预测概率初始值为self.prior_prob (根据激活函数是sigmoid()时推导出，和RetinaNet中一样)
bias_init_value = -math.log((1 - self.prior_prob) / self.prior_prob)
cls_last_conv_layer = Conv2dUnit(256,
self.num_classes,
3,
stride=1,
bias_attr=True,
act=None,
bias_init_value=bias_init_value,
name='head.cls_convs.%d' %
(self.num_convs, ))
# 坐标分支最后的卷积
reg_last_conv_layer = Conv2dUnit(256,
4,
3,
stride=1,
bias_attr=True,
act=None,
name='head.reg_convs.%d' %
(self.num_convs, ))
self.cls_convs.append(cls_last_conv_layer)
self.reg_convs.append(reg_last_conv_layer)
n = len(self.fpn_stride) # 有n个输出层
for i in range(n): # 遍历每个输出层
scale = fluid.layers.create_parameter(
shape=[
1,
],
dtype="float32",
name="head.scale_%d" % i,
default_initializer=fluid.initializer.Constant(1.))
self.scales_on_reg.append(scale)
def __init__(self,
in_c,
channel,
coord_conv=True,
bn=0,
gn=0,
af=0,
conv_block_num=2,
is_first=False,
use_spp=True,
drop_block=True,
block_size=3,
keep_prob=0.9,
is_test=True):
super(DetectionBlock, self).__init__()
assert channel % 2 == 0, \
"channel {} cannot be divided by 2".format(channel)
self.use_spp = use_spp
self.coord_conv = coord_conv
self.is_first = is_first
self.is_test = is_test
self.drop_block = drop_block
self.block_size = block_size
self.keep_prob = keep_prob
self.layers = torch.nn.ModuleList()
self.tip_layers = torch.nn.ModuleList()
for j in range(conv_block_num):
coordConv = CoordConv(coord_conv)
input_c = in_c + 2 if coord_conv else in_c
conv_unit1 = Conv2dUnit(input_c,
channel,
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act='leaky')
self.layers.append(coordConv)
self.layers.append(conv_unit1)
if self.use_spp and is_first and j == 1:
spp = SPP()
conv_unit2 = Conv2dUnit(channel * 4,
512,
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act='leaky')
conv_unit3 = Conv2dUnit(512,
channel * 2,
3,
stride=1,
bn=bn,
gn=gn,
af=af,
act='leaky')
self.layers.append(spp)
self.layers.append(conv_unit2)
self.layers.append(conv_unit3)
else:
conv_unit3 = Conv2dUnit(channel,
channel * 2,
3,
stride=1,
bn=bn,
gn=gn,
af=af,
act='leaky')
self.layers.append(conv_unit3)
if self.drop_block and j == 0 and not is_first:
dropBlock = DropBlock(block_size=self.block_size,
keep_prob=self.keep_prob,
is_test=is_test)
self.layers.append(dropBlock)
in_c = channel * 2
if self.drop_block and is_first:
dropBlock = DropBlock(block_size=self.block_size,
keep_prob=self.keep_prob,
is_test=is_test)
self.layers.append(dropBlock)
coordConv = CoordConv(coord_conv)
if conv_block_num == 0:
input_c = in_c + 2 if coord_conv else in_c
else:
input_c = channel * 2 + 2 if coord_conv else channel * 2
conv_unit = Conv2dUnit(input_c,
channel,
1,
stride=1,
bn=bn,
gn=gn,
af=af,
act='leaky')
self.layers.append(coordConv)
self.layers.append(conv_unit)
coordConv = CoordConv(coord_conv)
input_c = channel + 2 if coord_conv else channel
conv_unit = Conv2dUnit(input_c,
channel * 2,
3,
stride=1,
bn=bn,
gn=gn,
af=af,
act='leaky')
self.tip_layers.append(coordConv)
self.tip_layers.append(conv_unit)
