def __init__(self, input_channels, output_channels, groups):
super().__init__()
self.groups = groups
self.conv1 = Conv2D(in_channels=input_channels,
out_channels=output_channels,
kernel_size=3,
stride=1,
padding=1,
bias_attr=False)
if groups == 2 or groups == 3 or groups == 4:
self.conv2 = Conv2D(in_channels=output_channels,
out_channels=output_channels,
kernel_size=3,
stride=1,
padding=1,
bias_attr=False)
if groups == 3 or groups == 4:
self.conv3 = Conv2D(in_channels=output_channels,
out_channels=output_channels,
kernel_size=3,
stride=1,
padding=1,
bias_attr=False)
if groups == 4:
self.conv4 = Conv2D(in_channels=output_channels,
out_channels=output_channels,
kernel_size=3,
stride=1,
padding=1,
bias_attr=False)
self.max_pool = MaxPool2D(kernel_size=2, stride=2, padding=0)
self.relu = nn.ReLU()
def __init__(self,
depth=16,
normalizations=[20., -1, -1, -1, -1, -1],
extra_block_filters=[[256, 512, 1, 2, 3], [128, 256, 1, 2, 3],
[128, 256, 0, 1, 3],
[128, 256, 0, 1, 3]]):
super(VGG, self).__init__()
assert depth in [16, 19], \
"depth as 16/19 supported currently, but got {}".format(depth)
self.depth = depth
self.groups = VGG_cfg[depth]
self.normalizations = normalizations
self.extra_block_filters = extra_block_filters
self.conv_block_0 = ConvBlock(
3, 64, self.groups[0], 2, 2, 0, name="conv1_")
self.conv_block_1 = ConvBlock(
64, 128, self.groups[1], 2, 2, 0, name="conv2_")
self.conv_block_2 = ConvBlock(
128, 256, self.groups[2], 2, 2, 0, name="conv3_")
self.conv_block_3 = ConvBlock(
256, 512, self.groups[3], 2, 2, 0, name="conv4_")
self.conv_block_4 = ConvBlock(
512, 512, self.groups[4], 3, 1, 1, name="conv5_")
self.fc6 = Conv2D(
in_channels=512,
out_channels=1024,
kernel_size=3,
stride=1,
padding=6,
dilation=6)
self.fc7 = Conv2D(
in_channels=1024,
out_channels=1024,
kernel_size=1,
stride=1,
padding=0)
# extra block
self.extra_convs = []
last_channels = 1024
for i, v in enumerate(self.extra_block_filters):
assert len(v) == 5, "extra_block_filters size not fix"
extra_conv = self.add_sublayer("conv{}".format(6 + i),
ExtraBlock(last_channels, v[0], v[1],
v[2], v[3], v[4]))
last_channels = v[1]
self.extra_convs.append(extra_conv)
self.norms = []
for i, n in enumerate(self.normalizations):
if n != -1:
norm = self.add_sublayer("norm{}".format(i),
L2NormScale(
self.extra_block_filters[i][1], n))
else:
norm = None
self.norms.append(norm)
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
groups=1,
act=None):
super(TestLayer, self).__init__()
self._conv = Conv2D(in_channels=num_channels,
out_channels=num_filters,
kernel_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
bias_attr=False)
self._sync_batch_norm = SyncBatchNorm(num_filters)
self._conv2 = Conv2D(in_channels=num_filters,
out_channels=num_filters,
kernel_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
bias_attr=False)
self._sync_batch_norm2 = SyncBatchNorm(num_filters,
weight_attr=False,
bias_attr=False)
def __init__(self,
d_model,
nhead,
dim_feedforward=2048,
attention_dropout_rate=0.0,
residual_dropout_rate=0.1):
super(TransformerDecoderLayer, self).__init__()
self.self_attn = MultiheadAttention(d_model,
nhead,
dropout=attention_dropout_rate)
self.multihead_attn = MultiheadAttention(
d_model, nhead, dropout=attention_dropout_rate)
self.conv1 = Conv2D(in_channels=d_model,
out_channels=dim_feedforward,
kernel_size=(1, 1))
self.conv2 = Conv2D(in_channels=dim_feedforward,
out_channels=d_model,
kernel_size=(1, 1))
self.norm1 = LayerNorm(d_model)
self.norm2 = LayerNorm(d_model)
self.norm3 = LayerNorm(d_model)
self.dropout1 = Dropout(residual_dropout_rate)
self.dropout2 = Dropout(residual_dropout_rate)
self.dropout3 = Dropout(residual_dropout_rate)
def __init__(self, num_classes=59, backbone='resnet50'):
super(PSPNet, self).__init__()
res = ResNet101(pretrained=False)
# stem: res.conv, res.pool2d_max
self.layer0 = Sequential(
res.conv,
res.pool2d_max
)
self.layer1 = res.layer1
self.layer2 = res.layer2
self.layer3 = res.layer3
self.layer4 = res.layer4
num_channels = 2048
# psp: 2048 -> 2048*2
self.pspmoduls = PSPModule(num_channels, [1,2,3,6])
num_channels *= 2
# cls: 2048*2 -> 512 -> num_classes
self.classifier = Sequential(
Conv2D(num_channels,512,kernel_size=3,padding=1),
BatchNorm(512,act='relu'),
Dropout(0.1),
Conv2D(512,num_classes,kernel_size=1)
)
def __init__(self, class_num=1000):
super(AlexNetDY, self).__init__()
stdv = 1.0 / math.sqrt(3 * 11 * 11)
self._conv1 = ConvPoolLayer(
3, 64, 11, 4, 2, stdv, act="relu", name="conv1")
stdv = 1.0 / math.sqrt(64 * 5 * 5)
self._conv2 = ConvPoolLayer(
64, 192, 5, 1, 2, stdv, act="relu", name="conv2")
stdv = 1.0 / math.sqrt(192 * 3 * 3)
self._conv3 = Conv2D(
192,
384,
3,
stride=1,
padding=1,
weight_attr=ParamAttr(
name="conv3_weights", initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(
name="conv3_offset", initializer=Uniform(-stdv, stdv)))
stdv = 1.0 / math.sqrt(384 * 3 * 3)
self._conv4 = Conv2D(
384,
256,
3,
stride=1,
padding=1,
weight_attr=ParamAttr(
name="conv4_weights", initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(
name="conv4_offset", initializer=Uniform(-stdv, stdv)))
stdv = 1.0 / math.sqrt(256 * 3 * 3)
self._conv5 = ConvPoolLayer(
256, 256, 3, 1, 1, stdv, act="relu", name="conv5")
stdv = 1.0 / math.sqrt(256 * 6 * 6)
self._drop1 = Dropout(p=0.5, mode="downscale_in_infer")
self._fc6 = Linear(
in_features=256 * 6 * 6,
out_features=4096,
weight_attr=ParamAttr(
name="fc6_weights", initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(
name="fc6_offset", initializer=Uniform(-stdv, stdv)))
self._drop2 = Dropout(p=0.5, mode="downscale_in_infer")
self._fc7 = Linear(
in_features=4096,
out_features=4096,
weight_attr=ParamAttr(
name="fc7_weights", initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(
name="fc7_offset", initializer=Uniform(-stdv, stdv)))
self._fc8 = Linear(
in_features=4096,
out_features=class_num,
weight_attr=ParamAttr(
name="fc8_weights", initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(
name="fc8_offset", initializer=Uniform(-stdv, stdv)))
def __init__(self, num_classes=10):
super(ImperativeLenetWithSkipQuant, self).__init__()
conv2d_w1_attr = fluid.ParamAttr(name="conv2d_w_1")
conv2d_w2_attr = fluid.ParamAttr(name="conv2d_w_2")
fc_w1_attr = fluid.ParamAttr(name="fc_w_1")
fc_w2_attr = fluid.ParamAttr(name="fc_w_2")
fc_w3_attr = fluid.ParamAttr(name="fc_w_3")
conv2d_b1_attr = fluid.ParamAttr(name="conv2d_b_1")
conv2d_b2_attr = fluid.ParamAttr(name="conv2d_b_2")
fc_b1_attr = fluid.ParamAttr(name="fc_b_1")
fc_b2_attr = fluid.ParamAttr(name="fc_b_2")
fc_b3_attr = fluid.ParamAttr(name="fc_b_3")
self.conv2d_0 = Conv2D(in_channels=1,
out_channels=6,
kernel_size=3,
stride=1,
padding=1,
weight_attr=conv2d_w1_attr,
bias_attr=conv2d_b1_attr)
self.conv2d_0.skip_quant = True
self.batch_norm_0 = BatchNorm2D(6)
self.relu_0 = ReLU()
self.pool2d_0 = MaxPool2D(kernel_size=2, stride=2)
self.conv2d_1 = Conv2D(in_channels=6,
out_channels=16,
kernel_size=5,
stride=1,
padding=0,
weight_attr=conv2d_w2_attr,
bias_attr=conv2d_b2_attr)
self.conv2d_1.skip_quant = False
self.batch_norm_1 = BatchNorm2D(16)
self.relu6_0 = ReLU6()
self.pool2d_1 = MaxPool2D(kernel_size=2, stride=2)
self.linear_0 = Linear(in_features=400,
out_features=120,
weight_attr=fc_w1_attr,
bias_attr=fc_b1_attr)
self.linear_0.skip_quant = True
self.leaky_relu_0 = LeakyReLU()
self.linear_1 = Linear(in_features=120,
out_features=84,
weight_attr=fc_w2_attr,
bias_attr=fc_b2_attr)
self.linear_1.skip_quant = False
self.sigmoid_0 = Sigmoid()
self.linear_2 = Linear(in_features=84,
out_features=num_classes,
weight_attr=fc_w3_attr,
bias_attr=fc_b3_attr)
self.linear_2.skip_quant = False
self.softmax_0 = Softmax()
def __init__(self, num_classes=10):
super(ImperativeLenet, self).__init__()
conv2d_w1_attr = fluid.ParamAttr(name="conv2d_w_1")
conv2d_w2_attr = fluid.ParamAttr(name="conv2d_w_2")
fc_w1_attr = fluid.ParamAttr(name="fc_w_1")
fc_w2_attr = fluid.ParamAttr(name="fc_w_2")
fc_w3_attr = fluid.ParamAttr(name="fc_w_3")
conv2d_b2_attr = fluid.ParamAttr(name="conv2d_b_2")
fc_b1_attr = fluid.ParamAttr(name="fc_b_1")
fc_b2_attr = fluid.ParamAttr(name="fc_b_2")
fc_b3_attr = fluid.ParamAttr(name="fc_b_3")
self.features = Sequential(
Conv2D(
in_channels=1,
out_channels=6,
kernel_size=3,
stride=1,
padding=1,
weight_attr=conv2d_w1_attr,
bias_attr=False),
BatchNorm2D(6),
ReLU(),
MaxPool2D(
kernel_size=2, stride=2),
Conv2D(
in_channels=6,
out_channels=16,
kernel_size=5,
stride=1,
padding=0,
weight_attr=conv2d_w2_attr,
bias_attr=conv2d_b2_attr),
BatchNorm2D(16),
PReLU(),
MaxPool2D(
kernel_size=2, stride=2))
self.fc = Sequential(
Linear(
in_features=400,
out_features=120,
weight_attr=fc_w1_attr,
bias_attr=fc_b1_attr),
LeakyReLU(),
Linear(
in_features=120,
out_features=84,
weight_attr=fc_w2_attr,
bias_attr=fc_b2_attr),
Sigmoid(),
Linear(
in_features=84,
out_features=num_classes,
weight_attr=fc_w3_attr,
bias_attr=fc_b3_attr),
Softmax())
def __init__(self, num_classes=10):
super(LeNetDygraph, self).__init__()
self.num_classes = num_classes
self.features = Sequential(Conv2D(1, 6, 3, stride=1,
padding=1), ReLU(),
paddle.fluid.dygraph.Pool2D(2, 'max', 2),
Conv2D(6, 16, 5, stride=1, padding=0),
ReLU(),
paddle.fluid.dygraph.Pool2D(2, 'max', 2))
if num_classes > 0:
self.fc = Sequential(Linear(400, 120), Linear(120, 84),
Linear(84, 10))
def __init__(self, version, num_classes=1000, with_pool=True):
super(SqueezeNet, self).__init__()
self.version = version
self.num_classes = num_classes
self.with_pool = with_pool
supported_versions = ['1.0', '1.1']
assert version in supported_versions, \
"supported versions are {} but input version is {}".format(
supported_versions, version)
if self.version == "1.0":
self._conv = Conv2D(
3,
96,
7,
stride=2,
weight_attr=ParamAttr(),
bias_attr=ParamAttr())
self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
self._conv1 = MakeFire(96, 16, 64, 64)
self._conv2 = MakeFire(128, 16, 64, 64)
self._conv3 = MakeFire(128, 32, 128, 128)
self._conv4 = MakeFire(256, 32, 128, 128)
self._conv5 = MakeFire(256, 48, 192, 192)
self._conv6 = MakeFire(384, 48, 192, 192)
self._conv7 = MakeFire(384, 64, 256, 256)
self._conv8 = MakeFire(512, 64, 256, 256)
else:
self._conv = Conv2D(
3,
64,
3,
stride=2,
padding=1,
weight_attr=ParamAttr(),
bias_attr=ParamAttr())
self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
self._conv1 = MakeFire(64, 16, 64, 64)
self._conv2 = MakeFire(128, 16, 64, 64)
self._conv3 = MakeFire(128, 32, 128, 128)
self._conv4 = MakeFire(256, 32, 128, 128)
self._conv5 = MakeFire(256, 48, 192, 192)
self._conv6 = MakeFire(384, 48, 192, 192)
self._conv7 = MakeFire(384, 64, 256, 256)
self._conv8 = MakeFire(512, 64, 256, 256)
self._drop = Dropout(p=0.5, mode="downscale_in_infer")
self._conv9 = Conv2D(
512, num_classes, 1, weight_attr=ParamAttr(), bias_attr=ParamAttr())
self._avg_pool = AdaptiveAvgPool2D(1)
def __init__(self, num_classes=10):
super(ImperativeLenet, self).__init__()
conv2d_w1_attr = fluid.ParamAttr(name="conv2d_w_1")
conv2d_w2_attr = fluid.ParamAttr(name="conv2d_w_2")
fc_w1_attr = fluid.ParamAttr(name="fc_w_1")
fc_w2_attr = fluid.ParamAttr(name="fc_w_2")
fc_w3_attr = fluid.ParamAttr(name="fc_w_3")
conv2d_b1_attr = fluid.ParamAttr(name="conv2d_b_1")
conv2d_b2_attr = fluid.ParamAttr(name="conv2d_b_2")
fc_b1_attr = fluid.ParamAttr(name="fc_b_1")
fc_b2_attr = fluid.ParamAttr(name="fc_b_2")
fc_b3_attr = fluid.ParamAttr(name="fc_b_3")
self.features = Sequential(
Conv2D(
in_channels=1,
out_channels=6,
kernel_size=3,
stride=1,
padding=1,
weight_attr=conv2d_w1_attr,
bias_attr=conv2d_b1_attr),
Pool2D(
pool_size=2, pool_type='max', pool_stride=2),
Conv2D(
in_channels=6,
out_channels=16,
kernel_size=5,
stride=1,
padding=0,
weight_attr=conv2d_w2_attr,
bias_attr=conv2d_b2_attr),
Pool2D(
pool_size=2, pool_type='max', pool_stride=2))
self.fc = Sequential(
Linear(
in_features=400,
out_features=120,
weight_attr=fc_w1_attr,
bias_attr=fc_b1_attr),
Linear(
in_features=120,
out_features=84,
weight_attr=fc_w2_attr,
bias_attr=fc_b2_attr),
Linear(
in_features=84,
out_features=num_classes,
weight_attr=fc_w3_attr,
bias_attr=fc_b3_attr),
Softmax())
def __init__(self, num_classes=1):
super(LeNet_PALM, self).__init__()
# 创建卷积和池化层块，每个卷积层使用Sigmoid激活函数，后面跟着一个2x2的池化
self.conv1 = Conv2D(in_channels=3, out_channels=6, kernel_size=5)
self.max_pool1 = MaxPool2D(kernel_size=2, stride=2)
self.conv2 = Conv2D(in_channels=6, out_channels=16, kernel_size=5)
self.max_pool2 = MaxPool2D(kernel_size=2, stride=2)
# 创建第3个卷积层
self.conv3 = Conv2D(in_channels=16, out_channels=120, kernel_size=4)
# 创建全连接层，第一个全连接层的输出神经元个数为64
self.fc1 = Linear(in_features=300000, out_features=64)
# 第二个全连接层输出神经元个数为分类标签的类别数
self.fc2 = Linear(in_features=64, out_features=num_classes)
def __init__(self, in_channel, depth, stride):
super(bottleneck_IR, self).__init__()
if in_channel == depth:
self.shortcut_layer = MaxPool2D(1, stride)
else:
self.shortcut_layer = Sequential(
Conv2D(in_channel, depth, (1, 1), stride, bias_attr=False),
BatchNorm2D(depth))
self.res_layer = Sequential(
BatchNorm2D(in_channel),
Conv2D(in_channel, depth, (3, 3), (1, 1), 1, bias_attr=False),
PReLU(depth),
Conv2D(depth, depth, (3, 3), stride, 1, bias_attr=False),
BatchNorm2D(depth))
def __init__(self, version, class_num=1000):
super(SqueezeNet, self).__init__()
self.version = version
if self.version == "1.0":
self._conv = Conv2D(3,
96,
7,
stride=2,
weight_attr=ParamAttr(name="conv1_weights"),
bias_attr=ParamAttr(name="conv1_offset"))
self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
self._conv1 = MakeFire(96, 16, 64, 64, name="fire2")
self._conv2 = MakeFire(128, 16, 64, 64, name="fire3")
self._conv3 = MakeFire(128, 32, 128, 128, name="fire4")
self._conv4 = MakeFire(256, 32, 128, 128, name="fire5")
self._conv5 = MakeFire(256, 48, 192, 192, name="fire6")
self._conv6 = MakeFire(384, 48, 192, 192, name="fire7")
self._conv7 = MakeFire(384, 64, 256, 256, name="fire8")
self._conv8 = MakeFire(512, 64, 256, 256, name="fire9")
else:
self._conv = Conv2D(3,
64,
3,
stride=2,
padding=1,
weight_attr=ParamAttr(name="conv1_weights"),
bias_attr=ParamAttr(name="conv1_offset"))
self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
self._conv1 = MakeFire(64, 16, 64, 64, name="fire2")
self._conv2 = MakeFire(128, 16, 64, 64, name="fire3")
self._conv3 = MakeFire(128, 32, 128, 128, name="fire4")
self._conv4 = MakeFire(256, 32, 128, 128, name="fire5")
self._conv5 = MakeFire(256, 48, 192, 192, name="fire6")
self._conv6 = MakeFire(384, 48, 192, 192, name="fire7")
self._conv7 = MakeFire(384, 64, 256, 256, name="fire8")
self._conv8 = MakeFire(512, 64, 256, 256, name="fire9")
self._drop = Dropout(p=0.5, mode="downscale_in_infer")
self._conv9 = Conv2D(512,
class_num,
1,
weight_attr=ParamAttr(name="conv10_weights"),
bias_attr=ParamAttr(name="conv10_offset"))
self._avg_pool = AdaptiveAvgPool2D(1)
def __init__(self, num_classes=10):
super(LeNetListInput, self).__init__()
self.num_classes = num_classes
self.cov = Conv2D(1, 6, 3, stride=1, padding=1)
for param in self.cov.parameters():
param.trainable = False
self.features = Sequential(self.cov, ReLU(),
paddle.fluid.dygraph.Pool2D(2, 'max', 2),
Conv2D(6, 16, 5, stride=1, padding=0),
ReLU(),
paddle.fluid.dygraph.Pool2D(2, 'max', 2))
if num_classes > 0:
self.fc = Sequential(Linear(400, 120), Linear(120, 84),
Linear(84, 10))
def __init__(self, channel, reduction=4):
super().__init__()
self.avg_pool = AdaptiveAvgPool2D(1)
self.conv1 = Conv2D(in_channels=channel,
out_channels=channel // reduction,
kernel_size=1,
stride=1,
padding=0)
self.relu = nn.ReLU()
self.conv2 = Conv2D(in_channels=channel // reduction,
out_channels=channel,
kernel_size=1,
stride=1,
padding=0)
self.hardsigmoid = nn.Hardsigmoid()
def __init__(self, channels, reduction):
super(SEModule, self).__init__()
self.avg_pool = AdaptiveAvgPool2D(1)
self.fc1 = Conv2D(channels,
channels // reduction,
kernel_size=1,
padding=0,
bias_attr=False)
self.relu = ReLU()
self.fc2 = Conv2D(channels // reduction,
channels,
kernel_size=1,
padding=0,
bias_attr=False)
self.sigmoid = Sigmoid()
def __init__(self, num_classes=1000):
super(AlexNet, self).__init__()
self.num_classes = num_classes
stdv = 1.0 / math.sqrt(3 * 11 * 11)
self._conv1 = ConvPoolLayer(3, 64, 11, 4, 2, stdv, act="relu")
stdv = 1.0 / math.sqrt(64 * 5 * 5)
self._conv2 = ConvPoolLayer(64, 192, 5, 1, 2, stdv, act="relu")
stdv = 1.0 / math.sqrt(192 * 3 * 3)
self._conv3 = Conv2D(
192,
384,
3,
stride=1,
padding=1,
weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv)))
stdv = 1.0 / math.sqrt(384 * 3 * 3)
self._conv4 = Conv2D(
384,
256,
3,
stride=1,
padding=1,
weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv)))
stdv = 1.0 / math.sqrt(256 * 3 * 3)
self._conv5 = ConvPoolLayer(256, 256, 3, 1, 1, stdv, act="relu")
if self.num_classes > 0:
stdv = 1.0 / math.sqrt(256 * 6 * 6)
self._drop1 = Dropout(p=0.5, mode="downscale_in_infer")
self._fc6 = Linear(
in_features=256 * 6 * 6,
out_features=4096,
weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv)))
self._drop2 = Dropout(p=0.5, mode="downscale_in_infer")
self._fc7 = Linear(
in_features=4096,
out_features=4096,
weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv)))
self._fc8 = Linear(
in_features=4096,
out_features=num_classes,
weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(initializer=Uniform(-stdv, stdv)))
def __init__(self, num_classes=1):
# super(SimpleNet, self).__init__(name_scope)
self.conv1 = Conv2D(in_channels=3,
out_channels=6,
kernel_size=5,
stride=1,
padding=2)
self.max_pool1 = MaxPool2D(kernel_size=2, tride=2)
self.conv2 = Conv2D(in_channels=6,
out_channels=16,
kernel_size=5,
stride=1,
padding=2)
self.max_pool2 = MaxPool2D(kernel_size=2, tride=2)
self.fc1 = Linear(in_features=50176, out_features=64)
self.fc2 = Linear(in_features=64, out_features=num_classes)
def __init__(self,
input_channels,
output_channels,
filter_size,
stride,
padding,
stdv,
groups=1,
act=None,
name=None):
super(ConvPoolLayer, self).__init__()
self.relu = ReLU() if act == "relu" else None
self._conv = Conv2D(
in_channels=input_channels,
out_channels=output_channels,
kernel_size=filter_size,
stride=stride,
padding=padding,
groups=groups,
weight_attr=ParamAttr(
name=name + "_weights", initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(
name=name + "_offset", initializer=Uniform(-stdv, stdv)))
self._pool = MaxPool2D(kernel_size=3, stride=2, padding=0)
def __init__(self,
in_c,
out_c,
filter_size,
stride,
padding,
num_groups=1,
if_act=True,
act=None):
super().__init__()
self.conv = Conv2D(
in_channels=in_c,
out_channels=out_c,
kernel_size=filter_size,
stride=stride,
padding=padding,
groups=num_groups,
bias_attr=False)
self.bn = BatchNorm(
num_channels=out_c,
act=None,
param_attr=ParamAttr(regularizer=L2Decay(0.0)),
bias_attr=ParamAttr(regularizer=L2Decay(0.0)))
self.if_act = if_act
self.act = _create_act(act)
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
groups=1,
act="relu",
name=None):
super(ConvBNLayer, self).__init__()
self._conv = 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(initializer=KaimingNormal(),
name=name + "_weights"),
bias_attr=False)
bn_name = name + "_bn"
self._batch_norm = BatchNorm(
num_channels=out_channels,
act=act,
param_attr=ParamAttr(name=bn_name + "_scale",
regularizer=L2Decay(0.0)),
bias_attr=ParamAttr(name=bn_name + "_offset",
regularizer=L2Decay(0.0)),
moving_mean_name=bn_name + "_mean",
moving_variance_name=bn_name + "_variance")
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
groups=1,
act=None,
name=None,
data_format="NCHW"):
super(ConvBNLayer, self).__init__()
self._conv = Conv2D(in_channels=num_channels,
out_channels=num_filters,
kernel_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
weight_attr=ParamAttr(name=name + "_weights"),
bias_attr=False,
data_format=data_format)
if name == "conv1":
bn_name = "bn_" + name
else:
bn_name = "bn" + name[3:]
self._batch_norm = BatchNorm(
num_filters,
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",
data_layout=data_format)
def __init__(
self,
in_channels,
out_channels,
kernel_size,
stride,
padding,
groups=1,
act=None,
name=None,
):
super(ConvBNLayer, self).__init__()
self._conv = Conv2D(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=padding,
groups=groups,
weight_attr=ParamAttr(initializer=KaimingNormal(),
name=name + "_weights"),
bias_attr=False)
self._batch_norm = BatchNorm(
out_channels,
param_attr=ParamAttr(name=name + "_bn_scale"),
bias_attr=ParamAttr(name=name + "_bn_offset"),
act=act,
moving_mean_name=name + "_bn_mean",
moving_variance_name=name + "_bn_variance")
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride,
padding,
groups=1,
act=None):
super(ConvBNLayer, self).__init__()
self._conv = Conv2D(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=padding,
groups=groups,
weight_attr=ParamAttr(initializer=KaimingNormal()),
bias_attr=False)
self._batch_norm = BatchNorm2D(
out_channels,
weight_attr=ParamAttr(regularizer=L2Decay(0.0)),
bias_attr=ParamAttr(regularizer=L2Decay(0.0)))
if act == "hard_swish":
act = 'hardswish'
self.act = act
def __init__(self,
in_channels: int,
out_channels: int,
kernel_size: int,
stride: int = 1,
dilation: int = 1,
groups: int = 1,
is_vd_mode: bool = False,
act: str = None,
name: str = None):
super(ConvBNLayer, self).__init__()
self.is_vd_mode = is_vd_mode
self._pool2d_avg = AvgPool2D(kernel_size=2, stride=2, padding=0, ceil_mode=True)
self._conv = 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 = SyncBatchNorm(out_channels)
self._act_op = Activation(act=act)
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
groups=1,
act=None,
name=None,
data_format="NCHW"):
super(ConvBNLayer, self).__init__()
self._conv = 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,
data_format=data_format)
if name == "conv1":
bn_name = "bn_" + name
else:
bn_name = "bn" + name[3:]
self._act = act
self._batch_norm = BatchNorm2D(
out_channels,
weight_attr=ParamAttr(name=bn_name + "_scale",
regularizer=L2Decay(0.0)),
bias_attr=ParamAttr(name=bn_name + "_offset",
regularizer=L2Decay(0.0)),
data_format=data_format)
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
groups=1,
act=None,
name=None,
data_format='NCHW'):
super(ConvBNLayer, self).__init__()
self._conv = Conv2D(in_channels=num_channels,
out_channels=num_filters,
kernel_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
weight_attr=ParamAttr(name=name + "_weights"),
bias_attr=False,
data_format=data_format)
bn_name = name + '_bn'
self._batch_norm = BatchNorm(
num_filters,
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',
data_layout=data_format)
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
pad=0,
groups=1,
act="relu",
name=None):
super(BNACConvLayer, self).__init__()
self.num_channels = num_channels
self._batch_norm = BatchNorm(
num_channels,
act=act,
param_attr=ParamAttr(name=name + '_bn_scale'),
bias_attr=ParamAttr(name + '_bn_offset'),
moving_mean_name=name + '_bn_mean',
moving_variance_name=name + '_bn_variance')
self._conv = Conv2D(in_channels=num_channels,
out_channels=num_filters,
kernel_size=filter_size,
stride=stride,
padding=pad,
groups=groups,
weight_attr=ParamAttr(name=name + "_weights"),
bias_attr=False)
def __init__(self,
num_channels,
filter_size,
num_filters,
stride,
padding,
channels=None,
num_groups=1,
name=None,
use_cudnn=True):
super(ConvBNLayer, self).__init__()
self._conv = Conv2D(in_channels=num_channels,
out_channels=num_filters,
kernel_size=filter_size,
stride=stride,
padding=padding,
groups=num_groups,
weight_attr=ParamAttr(name=name + "_weights"),
bias_attr=False)
self._batch_norm = BatchNorm(
num_filters,
param_attr=ParamAttr(name=name + "_bn_scale"),
bias_attr=ParamAttr(name=name + "_bn_offset"),
moving_mean_name=name + "_bn_mean",
moving_variance_name=name + "_bn_variance")
