def __init__(self, inplanes, planes, stride=1):
super().__init__()
self.conv1 = nn.Conv2D(inplanes, planes, 1, bias_attr=False)
self.bn1 = nn.BatchNorm2D(planes)
self.conv2 = nn.Conv2D(planes, planes, 3, padding=1, bias_attr=False)
self.bn2 = nn.BatchNorm2D(planes)
self.avgpool = nn.AvgPool2D(stride) if stride > 1 else Identity()
self.conv3 = nn.Conv2D(planes, planes * self.expansion, 1, bias_attr=False)
self.bn3 = nn.BatchNorm2D(planes * self.expansion)
self.relu = nn.ReLU()
self.downsample = None
self.stride = stride
if stride > 1 or inplanes != planes * Bottleneck.expansion:
self.downsample = nn.Sequential(
("-1", nn.AvgPool2D(stride)),
(
"0",
nn.Conv2D(
inplanes, planes * self.expansion, 1, stride=1, bias_attr=False
),
),
("1", nn.BatchNorm2D(planes * self.expansion)),
)
def __init__(
self,
in_channels,
out_channels,
kernel_size,
stride=1,
groups=1,
is_vd_mode=False,
act=None,
name=None, ):
super(ConvBNLayer, self).__init__()
self.is_vd_mode = is_vd_mode
self._pool2d_avg = nn.AvgPool2D(
kernel_size=2, stride=2, padding=0, ceil_mode=True)
self._conv = nn.Conv2D(
in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=(kernel_size - 1) // 2,
groups=groups,
weight_attr=ParamAttr(name=name + "_weights"),
bias_attr=False)
if name == "conv1":
bn_name = "bn_" + name
else:
bn_name = "bn" + name[3:]
self._batch_norm = nn.BatchNorm(
out_channels,
act=act,
param_attr=ParamAttr(name=bn_name + '_scale'),
bias_attr=ParamAttr(bn_name + '_offset'),
moving_mean_name=bn_name + '_mean',
moving_variance_name=bn_name + '_variance')
def __init__(self, in_channels, num_classes, name=None):
super(InceptionAux, self).__init__()
self.num_classes = num_classes
self.pool0 = nn.AvgPool2D(kernel_size=5, stride=3)
self.conv0 = ConvBNLayer(in_channels, 128, 1, name=name + '.conv0')
self.conv1 = ConvBNLayer(128, 768, 5, name=name + '.conv1')
self.pool1 = nn.AdaptiveAvgPool2D(1)
def __init__(self, channels, kernel_size, stride):
super(Involution, self).__init__()
self.kernel_size = kernel_size
self.stride = stride
self.channels = channels
reduction_ratio = 4
self.group_channels = 16
self.groups = self.channels // self.group_channels
self.conv1 = nn.Sequential(
(
"conv",
nn.Conv2D(
in_channels=channels,
out_channels=channels // reduction_ratio,
kernel_size=1,
bias_attr=False,
),
),
("bn", nn.BatchNorm2D(channels // reduction_ratio)),
("activate", nn.ReLU()),
)
self.conv2 = nn.Sequential((
"conv",
nn.Conv2D(
in_channels=channels // reduction_ratio,
out_channels=kernel_size**2 * self.groups,
kernel_size=1,
stride=1,
),
))
if stride > 1:
self.avgpool = nn.AvgPool2D(stride, stride)
def __init__(
self,
in_channels,
out_channels,
kernel_size,
stride=1,
dilation=1,
groups=1,
is_vd_mode=False,
act=None,
):
super(ConvBNLayer, self).__init__()
self.is_vd_mode = is_vd_mode
self._pool2d_avg = nn.AvgPool2D(kernel_size=2,
stride=2,
padding=0,
ceil_mode=True)
self._conv = nn.Conv2D(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=(kernel_size - 1) //
2 if dilation == 1 else 0,
dilation=dilation,
groups=groups,
bias_attr=False)
self._batch_norm = layers.SyncBatchNorm(out_channels)
self._act_op = layers.Activation(act=act)
def __init__(self, num_classes=751):
super(Net, self).__init__()
# 3 128 64
self.conv = nn.Sequential(
nn.Conv2D(3, 64, 3, stride=1, padding=1),
nn.BatchNorm2D(64),
nn.ReLU(),
# nn.Conv2d(32,32,3,stride=1,padding=1),
# nn.BatchNorm2d(32),
# nn.ReLU(inplace=True),
nn.MaxPool2D(3, 2, padding=1),
)
# 32 64 32
self.layer1 = make_layers(64, 64, 2, False)
# 32 64 32
self.layer2 = make_layers(64, 128, 2, True)
# 64 32 16
self.layer3 = make_layers(128, 256, 2, True)
# 128 16 8
self.layer4 = make_layers(256, 512, 2, True)
# 256 8 4
self.avgpool = nn.AvgPool2D((8, 4), 1)
# 256 1 1
self.classifier = nn.Sequential(
nn.Linear(512, 256),
nn.BatchNorm1D(256),
nn.ReLU(),
nn.Dropout(),
nn.Linear(256, num_classes),
)
def __init__(self, num_classes):
super(ResidualAttentionModel_92_32input_update, self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2D(3,
32,
kernel_size=3,
stride=1,
padding=1,
bias_attr=False), nn.BatchNorm2D(32), nn.ReLU()) # 32*32
self.residual_block1 = ResidualBlock(32, 128) # 32*32
self.attention_module1 = AttentionModule_stage1_cifar(
128, 128, size1=(32, 32), size2=(16, 16)) # 32*32
self.residual_block2 = ResidualBlock(128, 256, 2) # 16*16
self.attention_module2 = AttentionModule_stage2_cifar(
256, 256, size=(16, 16)) # 16*16
self.attention_module2_2 = AttentionModule_stage2_cifar(
256, 256, size=(16, 16)) # 16*16 # tbq add
self.residual_block3 = ResidualBlock(256, 512, 2) # 4*4
self.attention_module3 = AttentionModule_stage3_cifar(512, 512) # 8*8
self.attention_module3_2 = AttentionModule_stage3_cifar(
512, 512) # 8*8 # tbq add
self.attention_module3_3 = AttentionModule_stage3_cifar(
512, 512) # 8*8 # tbq add
self.residual_block4 = ResidualBlock(512, 1024) # 8*8
self.residual_block5 = ResidualBlock(1024, 1024) # 8*8
self.residual_block6 = ResidualBlock(1024, 1024) # 8*8
self.mpool2 = nn.Sequential(nn.BatchNorm2D(1024), nn.ReLU(),
nn.AvgPool2D(kernel_size=8))
self.fc = nn.Linear(1024, num_classes)
def __init__(self, num_classes):
super(ResidualAttentionModel_448input, self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2D(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias_attr=False), nn.BatchNorm2D(64), nn.ReLU())
self.mpool1 = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
# tbq add
# 112*112
self.residual_block0 = ResidualBlock(64, 128)
self.attention_module0 = AttentionModule_stage0(128, 128)
# tbq add end
self.residual_block1 = ResidualBlock(128, 256, 2)
# 56*56
self.attention_module1 = AttentionModule_stage1(256, 256)
self.residual_block2 = ResidualBlock(256, 512, 2)
self.attention_module2 = AttentionModule_stage2(512, 512)
self.attention_module2_2 = AttentionModule_stage2(512, 512) # tbq add
self.residual_block3 = ResidualBlock(512, 1024, 2)
self.attention_module3 = AttentionModule_stage3(1024, 1024)
self.attention_module3_2 = AttentionModule_stage3(1024,
1024) # tbq add
self.attention_module3_3 = AttentionModule_stage3(1024,
1024) # tbq add
self.residual_block4 = ResidualBlock(1024, 2048, 2)
self.residual_block5 = ResidualBlock(2048, 2048)
self.residual_block6 = ResidualBlock(2048, 2048)
self.mpool2 = nn.Sequential(nn.BatchNorm2D(2048), nn.ReLU(),
nn.AvgPool2D(kernel_size=7, stride=1))
self.fc = nn.Linear(2048, num_classes)
def __init__(self, layers, output_dim, heads, input_resolution=224, width=64):
super().__init__()
self.output_dim = output_dim
self.input_resolution = input_resolution
self.conv1 = nn.Conv2D(
3, width // 2, kernel_size=3, stride=2, padding=1, bias_attr=False
)
self.bn1 = nn.BatchNorm2D(width // 2)
self.conv2 = nn.Conv2D(
width // 2, width // 2, kernel_size=3, padding=1, bias_attr=False
)
self.bn2 = nn.BatchNorm2D(width // 2)
self.conv3 = nn.Conv2D(
width // 2, width, kernel_size=3, padding=1, bias_attr=False
)
self.bn3 = nn.BatchNorm2D(width)
self.avgpool = nn.AvgPool2D(2)
self.relu = nn.ReLU()
# residual layers
self._inplanes = width
self.layer1 = self._make_layer(width, layers[0])
self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
embed_dim = width * 32
self.attnpool = AttentionPool2D(
input_resolution // 32, embed_dim, heads, output_dim
)
def add_block(
self, i, group_1x1, group_3x3, group_trans, bottleneck, activation, use_se
):
# Check if ith is the last one
last = i == len(self.stages) - 1
block = _SFR_DenseBlock(
num_layers=self.stages[i],
in_channels=self.num_features,
growth_rate=self.growth[i],
group_1x1=group_1x1,
group_3x3=group_3x3,
group_trans=group_trans,
bottleneck=bottleneck,
activation=activation,
use_se=use_se,
)
self.features.add_sublayer("denseblock_%d" % (i + 1), block)
self.num_features += self.stages[i] * self.growth[i]
if not last:
trans = _Transition()
self.features.add_sublayer("transition_%d" % (i + 1), trans)
else:
self.features.add_sublayer("norm_last", nn.BatchNorm2D(self.num_features))
self.features.add_sublayer("relu_last", nn.ReLU())
self.features.add_sublayer("pool_last", nn.AvgPool2D(self.pool_size))
# if useSE:
self.features.add_sublayer(
"se_last", SELayer(self.num_features, reduction=self.last_se_reduction)
)
def __init__(self, inplanes, outplanes, dw_stride, act_layer=nn.GELU,
norm_layer=partial(nn.LayerNorm, epsilon=1e-6)):
super(FCUDown, self).__init__()
self.dw_stride = dw_stride
self.conv_project = nn.Conv2D(inplanes, outplanes, kernel_size=1, stride=1, padding=0)
self.sample_pooling = nn.AvgPool2D(kernel_size=dw_stride, stride=dw_stride)
self.ln = norm_layer(outplanes)
self.act = act_layer()
def __init__(self, in_channels, ds=8, activation=nn.ReLU):
super(BAM, self).__init__()
self.key_channel = in_channels //8
self.activation = activation
self.ds = ds
self.pool = nn.AvgPool2D(self.ds)
self.query_conv = nn.Conv2D(in_channels=in_channels, out_channels=in_channels // 8, kernel_size=1)
self.key_conv = nn.Conv2D(in_channels=in_channels, out_channels=in_channels // 8, kernel_size=1)
self.value_conv = nn.Conv2D(in_channels=in_channels, out_channels=in_channels, kernel_size=1)
self.gamma = nn.ParameterList([paddle.create_parameter(shape=[1], dtype='float32', default_initializer=nn.initializer.Constant(value=0))])
self.softmax = nn.Softmax(axis=-1)
def __init__(self, inplanes, planes, stride=1):
super().__init__()
# all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1
self.conv1 = nn.Conv2D(inplanes, planes, 1, bias_attr=False)
self.bn1 = nn.BatchNorm2D(planes)
self.conv2 = nn.Conv2D(planes, planes, 3, padding=1, bias_attr=False)
self.bn2 = nn.BatchNorm2D(planes)
self.avgpool = nn.AvgPool2D(stride) if stride > 1 else Identity()
self.conv3 = nn.Conv2D(planes,
planes * self.expansion,
1,
bias_attr=False)
self.bn3 = nn.BatchNorm2D(planes * self.expansion)
self.relu = nn.ReLU()
self.downsample = None
self.stride = stride
if stride > 1 or inplanes != planes * Bottleneck.expansion:
# downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1
# self.downsample = nn.Sequential(OrderedDict([
# ("-1", nn.AvgPool2D(stride)),
# ("0", nn.Conv2D(inplanes, planes * self.expansion, 1, stride=1, bias_attr=False)),
# ("1", nn.BatchNorm2D(planes * self.expansion))
# ]))
self.downsample = nn.Sequential(
("-1", nn.AvgPool2D(stride)),
("0",
nn.Conv2D(inplanes,
planes * self.expansion,
1,
stride=1,
bias_attr=False)),
("1", nn.BatchNorm2D(planes * self.expansion)))
def __init__(self,
in_features,
out_features,
kernel_size=3,
padding=1,
groups=1):
super(DownBlock2d, self).__init__()
self.conv = nn.Conv2D(in_channels=in_features,
out_channels=out_features,
kernel_size=kernel_size,
padding=padding,
groups=groups)
self.norm = nn.BatchNorm2D(out_features)
self.pool = nn.AvgPool2D(kernel_size=(2, 2))
def __init__(self, in_channels, key_channels, value_channels, scale=1, ds=1):
super(_PAMBlock, self).__init__()
self.scale = scale
self.ds = ds
self.pool = nn.AvgPool2D(self.ds)
self.in_channels = in_channels
self.key_channels = key_channels
self.value_channels = value_channels
self.f_key = nn.Sequential(
nn.Conv2D(in_channels=self.in_channels, out_channels=self.key_channels, kernel_size=1, stride=1, padding=0),
nn.BatchNorm2D(self.key_channels)
)
self.f_query = nn.Sequential(
nn.Conv2D(in_channels=self.in_channels, out_channels=self.key_channels, kernel_size=1, stride=1, padding=0),
nn.BatchNorm2D(self.key_channels)
)
self.f_value = nn.Conv2D(in_channels=self.in_channels, out_channels=self.value_channels, kernel_size=1, stride=1, padding=0)
def __init__(self, in_channels, c7, name=None):
super(Fid_inceptionC, self).__init__()
self.branch1x1 = ConvBNLayer(in_channels,
192,
1,
name=name + '.branch1x1')
self.branch7x7_1 = ConvBNLayer(in_channels,
c7,
1,
name=name + '.branch7x7_1')
self.branch7x7_2 = ConvBNLayer(c7,
c7, (1, 7),
padding=(0, 3),
name=name + '.branch7x7_2')
self.branch7x7_3 = ConvBNLayer(c7,
192, (7, 1),
padding=(3, 0),
name=name + '.branch7x7_3')
self.branch7x7dbl_1 = ConvBNLayer(in_channels,
c7,
1,
name=name + '.branch7x7dbl_1')
self.branch7x7dbl_2 = ConvBNLayer(c7,
c7, (7, 1),
padding=(3, 0),
name=name + '.branch7x7dbl_2')
self.branch7x7dbl_3 = ConvBNLayer(c7,
c7, (1, 7),
padding=(0, 3),
name=name + '.branch7x7dbl_3')
self.branch7x7dbl_4 = ConvBNLayer(c7,
c7, (7, 1),
padding=(3, 0),
name=name + '.branch7x7dbl_4')
self.branch7x7dbl_5 = ConvBNLayer(c7,
192, (1, 7),
padding=(0, 3),
name=name + '.branch7x7dbl_5')
self.branch_pool0 = nn.AvgPool2D(kernel_size=3, stride=1, padding=1)
self.branch_pool = ConvBNLayer(in_channels,
192,
1,
name=name + '.branch_pool')
def __init__(self, out_dim):
super().__init__()
self.db_branch_keep = nn.Sequential(
layers.DepthwiseConvBN(out_dim, out_dim, 3),
nn.Conv2D(out_dim, out_dim, 1))
self.db_branch_down = nn.Sequential(
layers.ConvBN(out_dim, out_dim, 3, stride=2),
nn.AvgPool2D(kernel_size=3, stride=2, padding=1))
self.sb_branch_keep = nn.Sequential(
layers.DepthwiseConvBN(out_dim, out_dim, 3),
nn.Conv2D(out_dim, out_dim, 1), layers.Activation(act='sigmoid'))
self.sb_branch_up = layers.ConvBN(out_dim, out_dim, 3)
self.conv = layers.ConvBN(out_dim, out_dim, 3)
def __init__(self,
in_channel,
out_channel,
sigma_mapping=None,
kernel_size=7,
stride=1,
groups=1,
reduce_ratio=1,
dilation=1,
padding=3):
"""
Initialization
"""
super(Involution2D, self).__init__()
self.in_channel = in_channel
self.out_channel = out_channel
self.kernel_size = kernel_size
self.stride = stride
self.groups = groups
self.reduce_ratio = reduce_ratio
self.dilation = dilation
self.padding = padding
self.sigma_mapping = nn.Sequential(
nn.BatchNorm2D(num_features=self.out_channel // self.reduce_ratio),
nn.ReLU())
self.initial_mapping = nn.Conv2D(in_channels=self.in_channel,
out_channels=self.out_channel,
kernel_size=1,
stride=1,
padding=0)
self.o_mapping = nn.AvgPool2D(kernel_size=self.stride,
stride=self.stride)
self.reduce_mapping = nn.Conv2D(in_channels=self.in_channel,
out_channels=self.out_channel //
self.reduce_ratio,
kernel_size=1,
stride=1,
padding=0)
self.span_mapping = nn.Conv2D(
in_channels=self.out_channel // self.reduce_ratio,
out_channels=self.kernel_size * self.kernel_size * self.groups,
kernel_size=1,
stride=1,
padding=0)
def __init__(self, in_channels, name=None):
super(Fid_inceptionE_1, self).__init__()
self.branch1x1 = ConvBNLayer(in_channels,
320,
1,
name=name + '.branch1x1')
self.branch3x3_1 = ConvBNLayer(in_channels,
384,
1,
name=name + '.branch3x3_1')
self.branch3x3_2a = ConvBNLayer(384,
384, (1, 3),
padding=(0, 1),
name=name + '.branch3x3_2a')
self.branch3x3_2b = ConvBNLayer(384,
384, (3, 1),
padding=(1, 0),
name=name + '.branch3x3_2b')
self.branch3x3dbl_1 = ConvBNLayer(in_channels,
448,
1,
name=name + '.branch3x3dbl_1')
self.branch3x3dbl_2 = ConvBNLayer(448,
384,
3,
padding=1,
name=name + '.branch3x3dbl_2')
self.branch3x3dbl_3a = ConvBNLayer(384,
384, (1, 3),
padding=(0, 1),
name=name + '.branch3x3dbl_3a')
self.branch3x3dbl_3b = ConvBNLayer(384,
384, (3, 1),
padding=(1, 0),
name=name + '.branch3x3dbl_3b')
self.branch_pool0 = nn.AvgPool2D(kernel_size=3, stride=1, padding=1)
self.branch_pool = ConvBNLayer(in_channels,
192,
1,
name=name + '.branch_pool')
def __init__(self,
ni: int,
nf: int = None,
scale: int = 2,
blur: bool = False,
norm_type='Weight',
leaky: float = None):
super().__init__()
nf = ifnone(nf, ni)
self.conv = conv_layer(ni,
nf * (scale**2),
ks=1,
norm_type=norm_type,
use_activ=False)
self.shuf = PixelShuffle(scale)
self.pad = ReplicationPad2d([1, 0, 1, 0])
self.blur = nn.AvgPool2D(2, stride=1)
self.relu = relu(True, leaky=leaky)
def __init__(self,
ni: int,
nf: int = None,
scale: int = 2,
blur: bool = False,
leaky: float = None,
**kwargs):
super().__init__()
nf = ifnone(nf, ni)
self.conv = custom_conv_layer(ni,
nf * (scale**2),
ks=1,
use_activ=False,
**kwargs)
self.shuf = PixelShuffle(scale)
self.pad = ReplicationPad2d([1, 0, 1, 0])
self.blur = nn.AvgPool2D(2, stride=1)
self.relu = nn.LeakyReLU(
leaky) if leaky is not None else nn.ReLU() #relu(True, leaky=leaky)
def pyramidal_make_layer(self, block, block_depth, stride=1):
downsample = None
if stride != 1: # or self.inplanes != int(round(featuremap_dim_1st)) * block.outchannel_ratio:
downsample = nn.AvgPool2D((2, 2), stride=(2, 2), ceil_mode=True)
layers = []
self.featuremap_dim = self.featuremap_dim + self.addrate
layers.append(
block(self.input_featuremap_dim, int(round(self.featuremap_dim)),
stride, downsample))
for i in range(1, block_depth):
temp_featuremap_dim = self.featuremap_dim + self.addrate
layers.append(
block(
int(round(self.featuremap_dim)) * block.outchannel_ratio,
int(round(temp_featuremap_dim)), 1))
self.featuremap_dim = temp_featuremap_dim
self.input_featuremap_dim = int(round(
self.featuremap_dim)) * block.outchannel_ratio
return nn.Sequential(*layers)
def __init__(self, n_blocks, in_channels, ch_list, gr, grmul, n_layers):
super().__init__()
self.skip_connection_channels = []
self.shortcut_layers = []
self.blks = nn.LayerList()
ch = in_channels
for i in range(n_blocks):
blk = HarDBlock(ch, gr[i], grmul, n_layers[i])
ch = blk.get_out_ch()
self.skip_connection_channels.append(ch)
self.blks.append(blk)
if i < n_blocks - 1:
self.shortcut_layers.append(len(self.blks) - 1)
self.blks.append(
layers.ConvBNReLU(
ch, ch_list[i], kernel_size=1, bias_attr=False))
ch = ch_list[i]
if i < n_blocks - 1:
self.blks.append(nn.AvgPool2D(kernel_size=2, stride=2))
self.out_channels = ch
def __init__(self, classes_num=1000, **kwargs):
super().__init__()
def conv_bn(inp, oup, stride):
return nn.Sequential(
nn.Conv2D(
inp, oup, 3, stride, 1, bias_attr=False),
nn.BatchNorm2D(oup),
nn.ReLU())
def conv_dw(inp, oup, stride):
return nn.Sequential(
nn.Conv2D(
inp, inp, 3, stride, 1, groups=inp, bias_attr=False),
nn.BatchNorm2D(inp),
nn.ReLU(),
nn.Conv2D(
inp, oup, 1, 1, 0, bias_attr=False),
nn.BatchNorm2D(oup),
nn.ReLU(), )
self.model = nn.Sequential(
conv_bn(3, 32, 2),
conv_dw(32, 64, 1),
conv_dw(64, 128, 2),
conv_dw(128, 128, 1),
conv_dw(128, 256, 2),
conv_dw(256, 256, 1),
conv_dw(256, 512, 2),
conv_dw(512, 512, 1),
conv_dw(512, 512, 1),
conv_dw(512, 512, 1),
conv_dw(512, 512, 1),
conv_dw(512, 512, 1),
conv_dw(512, 1024, 2),
conv_dw(1024, 1024, 1),
nn.AvgPool2D(7), )
self.fc = nn.Linear(1024, classes_num)
self.init_params()
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
groups=1,
is_vd_mode=False,
act=None):
super(ConvBNLayer, self).__init__()
self.is_vd_mode = is_vd_mode
self._pool2d_avg = nn.AvgPool2D(kernel_size=2,
stride=2,
padding=0,
ceil_mode=True)
self._conv = nn.Conv2D(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=(kernel_size - 1) // 2,
groups=groups,
bias_attr=False)
self._batch_norm = nn.BatchNorm(out_channels, act=act)
def __init__(self,
in_features,
out_features,
kernel_size=3,
padding=1,
groups=1):
super(MobileDownBlock2d, self).__init__()
self.conv = nn.Conv2D(in_channels=in_features,
out_channels=in_features,
kernel_size=kernel_size,
padding=padding,
groups=in_features,
bias_attr=False)
self.norm = SyncBatchNorm(in_features)
self.pool = nn.AvgPool2D(kernel_size=(2, 2))
self.conv1 = nn.Conv2D(in_features,
out_features,
kernel_size=1,
padding=0,
stride=1,
bias_attr=False)
self.norm1 = SyncBatchNorm(out_features)
def __init__(self, in_channels, pool_features, name=None):
super(Fid_inceptionA, self).__init__()
self.branch1x1 = ConvBNLayer(in_channels,
64,
1,
name=name + '.branch1x1')
self.branch5x5_1 = ConvBNLayer(in_channels,
48,
1,
name=name + '.branch5x5_1')
self.branch5x5_2 = ConvBNLayer(48,
64,
5,
padding=2,
name=name + '.branch5x5_2')
self.branch3x3dbl_1 = ConvBNLayer(in_channels,
64,
1,
name=name + '.branch3x3dbl_1')
self.branch3x3dbl_2 = ConvBNLayer(64,
96,
3,
padding=1,
name=name + '.branch3x3dbl_2')
self.branch3x3dbl_3 = ConvBNLayer(96,
96,
3,
padding=1,
name=name + '.branch3x3dbl_3')
self.branch_pool0 = nn.AvgPool2D(kernel_size=3, stride=1, padding=1)
self.branch_pool = ConvBNLayer(in_channels,
pool_features,
1,
name=name + '.branch_pool')
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
dilation=1,
groups=1,
is_vd_mode=False,
act=None,
data_format='NCHW'):
super(ConvBNLayer, self).__init__()
if dilation != 1 and kernel_size != 3:
raise RuntimeError("When the dilation isn't 1," \
"the kernel_size should be 3.")
self.is_vd_mode = is_vd_mode
self._pool2d_avg = nn.AvgPool2D(kernel_size=2,
stride=2,
padding=0,
ceil_mode=True,
data_format=data_format)
self._conv = nn.Conv2D(
in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=(kernel_size - 1) // 2 \
if dilation == 1 else dilation,
dilation=dilation,
groups=groups,
bias_attr=False,
data_format=data_format)
self._batch_norm = layers.SyncBatchNorm(out_channels,
data_format=data_format)
self._act_op = layers.Activation(act=act)
def __init__(self,
in_channels,
out_channels,
branches=4,
kernel_size_maximum=9,
shortcut=True):
super().__init__()
if out_channels < in_channels:
raise RuntimeError(
"The out_channes for DownSampler should be bigger than in_channels, but got in_channles={}, out_channels={}"
.format(in_channels, out_channels))
self.eesp = EESP(in_channels,
out_channels - in_channels,
stride=2,
branches=branches,
kernel_size_maximum=kernel_size_maximum,
down_method='avg')
self.avg = nn.AvgPool2D(kernel_size=3, padding=1, stride=2)
if shortcut:
self.shortcut_layer = nn.Sequential(
layers.ConvBNPReLU(3, 3, 3, stride=1, bias_attr=False),
layers.ConvBN(3, out_channels, 1, stride=1, bias_attr=False),
)
self._act = nn.PReLU()
def __init__(self,
ch_in,
ch_out,
stride,
shortcut,
variant='b',
groups=1,
base_width=4,
lr=1.0,
norm_type='bn',
norm_decay=0.,
freeze_norm=True,
dcn_v2=False,
std_senet=False):
super(BottleNeck, self).__init__()
if variant == 'a':
stride1, stride2 = stride, 1
else:
stride1, stride2 = 1, stride
# ResNeXt
width = int(ch_out * (base_width / 64.)) * groups
self.shortcut = shortcut
if not shortcut:
if variant == 'd' and stride == 2:
self.short = nn.Sequential()
self.short.add_sublayer(
'pool',
nn.AvgPool2D(kernel_size=2,
stride=2,
padding=0,
ceil_mode=True))
self.short.add_sublayer(
'conv',
ConvNormLayer(ch_in=ch_in,
ch_out=ch_out * self.expansion,
filter_size=1,
stride=1,
norm_type=norm_type,
norm_decay=norm_decay,
freeze_norm=freeze_norm,
lr=lr))
else:
self.short = ConvNormLayer(ch_in=ch_in,
ch_out=ch_out * self.expansion,
filter_size=1,
stride=stride,
norm_type=norm_type,
norm_decay=norm_decay,
freeze_norm=freeze_norm,
lr=lr)
self.branch2a = ConvNormLayer(ch_in=ch_in,
ch_out=width,
filter_size=1,
stride=stride1,
groups=1,
act='relu',
norm_type=norm_type,
norm_decay=norm_decay,
freeze_norm=freeze_norm,
lr=lr)
self.branch2b = ConvNormLayer(ch_in=width,
ch_out=width,
filter_size=3,
stride=stride2,
groups=groups,
act='relu',
norm_type=norm_type,
norm_decay=norm_decay,
freeze_norm=freeze_norm,
lr=lr,
dcn_v2=dcn_v2)
self.branch2c = ConvNormLayer(ch_in=width,
ch_out=ch_out * self.expansion,
filter_size=1,
stride=1,
groups=1,
norm_type=norm_type,
norm_decay=norm_decay,
freeze_norm=freeze_norm,
lr=lr)
self.std_senet = std_senet
if self.std_senet:
self.se = SELayer(ch_out * self.expansion)
