paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/ppdet/modeling/backbones/senet.py

@@ -1,140 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddlex.ppdet.core.workspace import register, serializable
-from .resnet import ResNet, Blocks, BasicBlock, BottleNeck
-
-__all__ = ['SENet', 'SERes5Head']
-
-
-@register
-@serializable
-class SENet(ResNet):
-    __shared__ = ['norm_type']
-
-    def __init__(self,
-                 depth=50,
-                 variant='b',
-                 lr_mult_list=[1.0, 1.0, 1.0, 1.0],
-                 groups=1,
-                 base_width=64,
-                 norm_type='bn',
-                 norm_decay=0,
-                 freeze_norm=True,
-                 freeze_at=0,
-                 return_idx=[0, 1, 2, 3],
-                 dcn_v2_stages=[-1],
-                 std_senet=True,
-                 num_stages=4):
-        """
-        Squeeze-and-Excitation Networks, see https://arxiv.org/abs/1709.01507
-
-        Args:
-            depth (int): SENet depth, should be 50, 101, 152
-            variant (str): ResNet variant, supports 'a', 'b', 'c', 'd' currently
-            lr_mult_list (list): learning rate ratio of different resnet stages(2,3,4,5),
-                                 lower learning rate ratio is need for pretrained model
-                                 got using distillation(default as [1.0, 1.0, 1.0, 1.0]).
-            groups (int): group convolution cardinality
-            base_width (int): base width of each group convolution
-            norm_type (str): normalization type, 'bn', 'sync_bn' or 'affine_channel'
-            norm_decay (float): weight decay for normalization layer weights
-            freeze_norm (bool): freeze normalization layers
-            freeze_at (int): freeze the backbone at which stage
-            return_idx (list): index of the stages whose feature maps are returned
-            dcn_v2_stages (list): index of stages who select deformable conv v2
-            std_senet (bool): whether use senet, default True
-            num_stages (int): total num of stages
-        """
-
-        super(SENet, self).__init__(
-            depth=depth,
-            variant=variant,
-            lr_mult_list=lr_mult_list,
-            ch_in=128,
-            groups=groups,
-            base_width=base_width,
-            norm_type=norm_type,
-            norm_decay=norm_decay,
-            freeze_norm=freeze_norm,
-            freeze_at=freeze_at,
-            return_idx=return_idx,
-            dcn_v2_stages=dcn_v2_stages,
-            std_senet=std_senet,
-            num_stages=num_stages)
-
-
-@register
-class SERes5Head(nn.Layer):
-    def __init__(self,
-                 depth=50,
-                 variant='b',
-                 lr_mult=1.0,
-                 groups=1,
-                 base_width=64,
-                 norm_type='bn',
-                 norm_decay=0,
-                 dcn_v2=False,
-                 freeze_norm=False,
-                 std_senet=True):
-        """
-        SERes5Head layer
-
-        Args:
-            depth (int): SENet depth, should be 50, 101, 152
-            variant (str): ResNet variant, supports 'a', 'b', 'c', 'd' currently
-            lr_mult (list): learning rate ratio of SERes5Head, default as 1.0.
-            groups (int): group convolution cardinality
-            base_width (int): base width of each group convolution
-            norm_type (str): normalization type, 'bn', 'sync_bn' or 'affine_channel'
-            norm_decay (float): weight decay for normalization layer weights
-            dcn_v2_stages (list): index of stages who select deformable conv v2
-            std_senet (bool): whether use senet, default True
-
-        """
-        super(SERes5Head, self).__init__()
-        ch_out = 512
-        ch_in = 256 if depth < 50 else 1024
-        na = NameAdapter(self)
-        block = BottleNeck if depth >= 50 else BasicBlock
-        self.res5 = Blocks(
-            block,
-            ch_in,
-            ch_out,
-            count=3,
-            name_adapter=na,
-            stage_num=5,
-            variant=variant,
-            groups=groups,
-            base_width=base_width,
-            lr=lr_mult,
-            norm_type=norm_type,
-            norm_decay=norm_decay,
-            freeze_norm=freeze_norm,
-            dcn_v2=dcn_v2,
-            std_senet=std_senet)
-        self.ch_out = ch_out * block.expansion
-
-    @property
-    def out_shape(self):
-        return [ShapeSpec(
-            channels=self.ch_out,
-            stride=16, )]
-
-    def forward(self, roi_feat):
-        y = self.res5(roi_feat)
-        return y

paddlex/ppdet/modeling/backbones/vgg.py

@@ -1,216 +0,0 @@
-from __future__ import division
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-from paddle.regularizer import L2Decay
-from paddle.nn import Conv2D, MaxPool2D
-from paddlex.ppdet.core.workspace import register, serializable
-from ..shape_spec import ShapeSpec
-
-__all__ = ['VGG']
-
-VGG_cfg = {16: [2, 2, 3, 3, 3], 19: [2, 2, 4, 4, 4]}
-
-
-class ConvBlock(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 groups,
-                 pool_size=2,
-                 pool_stride=2,
-                 pool_padding=0,
-                 name=None):
-        super(ConvBlock, self).__init__()
-
-        self.groups = groups
-        self.conv0 = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            weight_attr=ParamAttr(name=name + "1_weights"),
-            bias_attr=ParamAttr(name=name + "1_bias"))
-        self.conv_out_list = []
-        for i in range(1, groups):
-            conv_out = self.add_sublayer(
-                'conv{}'.format(i),
-                Conv2D(
-                    in_channels=out_channels,
-                    out_channels=out_channels,
-                    kernel_size=3,
-                    stride=1,
-                    padding=1,
-                    weight_attr=ParamAttr(
-                        name=name + "{}_weights".format(i + 1)),
-                    bias_attr=ParamAttr(name=name + "{}_bias".format(i + 1))))
-            self.conv_out_list.append(conv_out)
-
-        self.pool = MaxPool2D(
-            kernel_size=pool_size,
-            stride=pool_stride,
-            padding=pool_padding,
-            ceil_mode=True)
-
-    def forward(self, inputs):
-        out = self.conv0(inputs)
-        out = F.relu(out)
-        for conv_i in self.conv_out_list:
-            out = conv_i(out)
-            out = F.relu(out)
-        pool = self.pool(out)
-        return out, pool
-
-
-class ExtraBlock(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 mid_channels,
-                 out_channels,
-                 padding,
-                 stride,
-                 kernel_size,
-                 name=None):
-        super(ExtraBlock, self).__init__()
-
-        self.conv0 = Conv2D(
-            in_channels=in_channels,
-            out_channels=mid_channels,
-            kernel_size=1,
-            stride=1,
-            padding=0)
-        self.conv1 = Conv2D(
-            in_channels=mid_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding)
-
-    def forward(self, inputs):
-        out = self.conv0(inputs)
-        out = F.relu(out)
-        out = self.conv1(out)
-        out = F.relu(out)
-        return out
-
-
-class L2NormScale(nn.Layer):
-    def __init__(self, num_channels, scale=1.0):
-        super(L2NormScale, self).__init__()
-        self.scale = self.create_parameter(
-            attr=ParamAttr(initializer=paddle.nn.initializer.Constant(scale)),
-            shape=[num_channels])
-
-    def forward(self, inputs):
-        out = F.normalize(inputs, axis=1, epsilon=1e-10)
-        # out = self.scale.unsqueeze(0).unsqueeze(2).unsqueeze(3).expand_as(
-        #     out) * out
-        out = self.scale.unsqueeze(0).unsqueeze(2).unsqueeze(3) * out
-        return out
-
-
-@register
-@serializable
-class VGG(nn.Layer):
-    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._out_channels = []
-
-        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._out_channels.append(512)
-
-        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)
-        self._out_channels.append(1024)
-
-        # 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._out_channels.append(last_channels)
-
-        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 forward(self, inputs):
-        outputs = []
-
-        conv, pool = self.conv_block_0(inputs['image'])
-        conv, pool = self.conv_block_1(pool)
-        conv, pool = self.conv_block_2(pool)
-        conv, pool = self.conv_block_3(pool)
-        outputs.append(conv)
-
-        conv, pool = self.conv_block_4(pool)
-        out = self.fc6(pool)
-        out = F.relu(out)
-        out = self.fc7(out)
-        out = F.relu(out)
-        outputs.append(out)
-
-        if not self.extra_block_filters:
-            return outputs
-
-        # extra block
-        for extra_conv in self.extra_convs:
-            out = extra_conv(out)
-            outputs.append(out)
-
-        for i, n in enumerate(self.normalizations):
-            if n != -1:
-                outputs[i] = self.norms[i](outputs[i])
-
-        return outputs
-
-    @property
-    def out_shape(self):
-        return [ShapeSpec(channels=c) for c in self._out_channels]