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")