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

paddlex/ppdet/modeling/necks/centernet_fpn.py

@@ -1,185 +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 numpy as np
-import math
-import paddle
-import paddle.nn.functional as F
-from paddle import ParamAttr
-import paddle.nn as nn
-from paddle.nn.initializer import KaimingUniform
-from paddlex.ppdet.core.workspace import register, serializable
-from paddlex.ppdet.modeling.layers import ConvNormLayer
-from ..shape_spec import ShapeSpec
-
-
-def fill_up_weights(up):
-    weight = up.weight
-    f = math.ceil(weight.shape[2] / 2)
-    c = (2 * f - 1 - f % 2) / (2. * f)
-    for i in range(weight.shape[2]):
-        for j in range(weight.shape[3]):
-            weight[0, 0, i, j] = \
-                (1 - math.fabs(i / f - c)) * (1 - math.fabs(j / f - c))
-    for c in range(1, weight.shape[0]):
-        weight[c, 0, :, :] = weight[0, 0, :, :]
-
-
-class IDAUp(nn.Layer):
-    def __init__(self, ch_ins, ch_out, up_strides, dcn_v2=True):
-        super(IDAUp, self).__init__()
-        for i in range(1, len(ch_ins)):
-            ch_in = ch_ins[i]
-            up_s = int(up_strides[i])
-            proj = nn.Sequential(
-                ConvNormLayer(
-                    ch_in,
-                    ch_out,
-                    filter_size=3,
-                    stride=1,
-                    use_dcn=dcn_v2,
-                    bias_on=dcn_v2,
-                    norm_decay=None,
-                    dcn_lr_scale=1.,
-                    dcn_regularizer=None),
-                nn.ReLU())
-            node = nn.Sequential(
-                ConvNormLayer(
-                    ch_out,
-                    ch_out,
-                    filter_size=3,
-                    stride=1,
-                    use_dcn=dcn_v2,
-                    bias_on=dcn_v2,
-                    norm_decay=None,
-                    dcn_lr_scale=1.,
-                    dcn_regularizer=None),
-                nn.ReLU())
-
-            param_attr = paddle.ParamAttr(initializer=KaimingUniform())
-            up = nn.Conv2DTranspose(
-                ch_out,
-                ch_out,
-                kernel_size=up_s * 2,
-                weight_attr=param_attr,
-                stride=up_s,
-                padding=up_s // 2,
-                groups=ch_out,
-                bias_attr=False)
-            # TODO: uncomment fill_up_weights
-            #fill_up_weights(up)
-            setattr(self, 'proj_' + str(i), proj)
-            setattr(self, 'up_' + str(i), up)
-            setattr(self, 'node_' + str(i), node)
-
-    def forward(self, inputs, start_level, end_level):
-        for i in range(start_level + 1, end_level):
-            upsample = getattr(self, 'up_' + str(i - start_level))
-            project = getattr(self, 'proj_' + str(i - start_level))
-
-            inputs[i] = project(inputs[i])
-            inputs[i] = upsample(inputs[i])
-            node = getattr(self, 'node_' + str(i - start_level))
-            inputs[i] = node(paddle.add(inputs[i], inputs[i - 1]))
-
-
-class DLAUp(nn.Layer):
-    def __init__(self, start_level, channels, scales, ch_in=None, dcn_v2=True):
-        super(DLAUp, self).__init__()
-        self.start_level = start_level
-        if ch_in is None:
-            ch_in = channels
-        self.channels = channels
-        channels = list(channels)
-        scales = np.array(scales, dtype=int)
-        for i in range(len(channels) - 1):
-            j = -i - 2
-            setattr(
-                self,
-                'ida_{}'.format(i),
-                IDAUp(
-                    ch_in[j:],
-                    channels[j],
-                    scales[j:] // scales[j],
-                    dcn_v2=dcn_v2))
-            scales[j + 1:] = scales[j]
-            ch_in[j + 1:] = [channels[j] for _ in channels[j + 1:]]
-
-    def forward(self, inputs):
-        out = [inputs[-1]]  # start with 32
-        for i in range(len(inputs) - self.start_level - 1):
-            ida = getattr(self, 'ida_{}'.format(i))
-            ida(inputs, len(inputs) - i - 2, len(inputs))
-            out.insert(0, inputs[-1])
-        return out
-
-
-@register
-@serializable
-class CenterNetDLAFPN(nn.Layer):
-    """
-    Args:
-        in_channels (list): number of input feature channels from backbone.
-            [16, 32, 64, 128, 256, 512] by default, means the channels of DLA-34
-        down_ratio (int): the down ratio from images to heatmap, 4 by default
-        last_level (int): the last level of input feature fed into the upsamplng block
-        out_channel (int): the channel of the output feature, 0 by default means
-            the channel of the input feature whose down ratio is `down_ratio`
-        dcn_v2 (bool): whether use the DCNv2, true by default
-
-    """
-
-    def __init__(self,
-                 in_channels,
-                 down_ratio=4,
-                 last_level=5,
-                 out_channel=0,
-                 dcn_v2=True):
-        super(CenterNetDLAFPN, self).__init__()
-        self.first_level = int(np.log2(down_ratio))
-        self.down_ratio = down_ratio
-        self.last_level = last_level
-        scales = [2**i for i in range(len(in_channels[self.first_level:]))]
-        self.dla_up = DLAUp(
-            self.first_level,
-            in_channels[self.first_level:],
-            scales,
-            dcn_v2=dcn_v2)
-        self.out_channel = out_channel
-        if out_channel == 0:
-            self.out_channel = in_channels[self.first_level]
-        self.ida_up = IDAUp(
-            in_channels[self.first_level:self.last_level],
-            self.out_channel,
-            [2**i for i in range(self.last_level - self.first_level)],
-            dcn_v2=dcn_v2)
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        return {'in_channels': [i.channels for i in input_shape]}
-
-    def forward(self, body_feats):
-        dla_up_feats = self.dla_up(body_feats)
-
-        ida_up_feats = []
-        for i in range(self.last_level - self.first_level):
-            ida_up_feats.append(dla_up_feats[i].clone())
-
-        self.ida_up(ida_up_feats, 0, len(ida_up_feats))
-
-        return ida_up_feats[-1]
-
-    @property
-    def out_shape(self):
-        return [ShapeSpec(channels=self.out_channel, stride=self.down_ratio)]

paddlex/ppdet/modeling/necks/fpn.py

@@ -1,233 +0,0 @@
-# Copyright (c) 2020 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 numpy as np
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-from paddle.nn.initializer import XavierUniform
-from paddle.regularizer import L2Decay
-from paddlex.ppdet.core.workspace import register, serializable
-from paddlex.ppdet.modeling.layers import ConvNormLayer
-from ..shape_spec import ShapeSpec
-
-__all__ = ['FPN']
-
-
-@register
-@serializable
-class FPN(nn.Layer):
-    """
-    Feature Pyramid Network, see https://arxiv.org/abs/1612.03144
-
-    Args:
-        in_channels (list[int]): input channels of each level which can be
-            derived from the output shape of backbone by from_config
-        out_channel (list[int]): output channel of each level
-        spatial_scales (list[float]): the spatial scales between input feature
-            maps and original input image which can be derived from the output
-            shape of backbone by from_config
-        has_extra_convs (bool): whether to add extra conv to the last level.
-            default False
-        extra_stage (int): the number of extra stages added to the last level.
-            default 1
-        use_c5 (bool): Whether to use c5 as the input of extra stage,
-            otherwise p5 is used. default True
-        norm_type (string|None): The normalization type in FPN module. If
-            norm_type is None, norm will not be used after conv and if
-            norm_type is string, bn, gn, sync_bn are available. default None
-        norm_decay (float): weight decay for normalization layer weights.
-            default 0.
-        freeze_norm (bool): whether to freeze normalization layer.
-            default False
-        relu_before_extra_convs (bool): whether to add relu before extra convs.
-            default False
-
-    """
-
-    def __init__(self,
-                 in_channels,
-                 out_channel,
-                 spatial_scales=[0.25, 0.125, 0.0625, 0.03125],
-                 has_extra_convs=False,
-                 extra_stage=1,
-                 use_c5=True,
-                 norm_type=None,
-                 norm_decay=0.,
-                 freeze_norm=False,
-                 relu_before_extra_convs=True):
-        super(FPN, self).__init__()
-        self.out_channel = out_channel
-        for s in range(extra_stage):
-            spatial_scales = spatial_scales + [spatial_scales[-1] / 2.]
-        self.spatial_scales = spatial_scales
-        self.has_extra_convs = has_extra_convs
-        self.extra_stage = extra_stage
-        self.use_c5 = use_c5
-        self.relu_before_extra_convs = relu_before_extra_convs
-        self.norm_type = norm_type
-        self.norm_decay = norm_decay
-        self.freeze_norm = freeze_norm
-
-        self.lateral_convs = []
-        self.fpn_convs = []
-        fan = out_channel * 3 * 3
-
-        # stage index 0,1,2,3 stands for res2,res3,res4,res5 on ResNet Backbone
-        # 0 <= st_stage < ed_stage <= 3
-        st_stage = 4 - len(in_channels)
-        ed_stage = st_stage + len(in_channels) - 1
-        for i in range(st_stage, ed_stage + 1):
-            if i == 3:
-                lateral_name = 'fpn_inner_res5_sum'
-            else:
-                lateral_name = 'fpn_inner_res{}_sum_lateral'.format(i + 2)
-            in_c = in_channels[i - st_stage]
-            if self.norm_type is not None:
-                lateral = self.add_sublayer(
-                    lateral_name,
-                    ConvNormLayer(
-                        ch_in=in_c,
-                        ch_out=out_channel,
-                        filter_size=1,
-                        stride=1,
-                        norm_type=self.norm_type,
-                        norm_decay=self.norm_decay,
-                        freeze_norm=self.freeze_norm,
-                        initializer=XavierUniform(fan_out=in_c)))
-            else:
-                lateral = self.add_sublayer(
-                    lateral_name,
-                    nn.Conv2D(
-                        in_channels=in_c,
-                        out_channels=out_channel,
-                        kernel_size=1,
-                        weight_attr=ParamAttr(
-                            initializer=XavierUniform(fan_out=in_c))))
-            self.lateral_convs.append(lateral)
-
-            fpn_name = 'fpn_res{}_sum'.format(i + 2)
-            if self.norm_type is not None:
-                fpn_conv = self.add_sublayer(
-                    fpn_name,
-                    ConvNormLayer(
-                        ch_in=out_channel,
-                        ch_out=out_channel,
-                        filter_size=3,
-                        stride=1,
-                        norm_type=self.norm_type,
-                        norm_decay=self.norm_decay,
-                        freeze_norm=self.freeze_norm,
-                        initializer=XavierUniform(fan_out=fan)))
-            else:
-                fpn_conv = self.add_sublayer(
-                    fpn_name,
-                    nn.Conv2D(
-                        in_channels=out_channel,
-                        out_channels=out_channel,
-                        kernel_size=3,
-                        padding=1,
-                        weight_attr=ParamAttr(
-                            initializer=XavierUniform(fan_out=fan))))
-            self.fpn_convs.append(fpn_conv)
-
-        # add extra conv levels for RetinaNet(use_c5)/FCOS(use_p5)
-        if self.has_extra_convs:
-            for i in range(self.extra_stage):
-                lvl = ed_stage + 1 + i
-                if i == 0 and self.use_c5:
-                    in_c = in_channels[-1]
-                else:
-                    in_c = out_channel
-                extra_fpn_name = 'fpn_{}'.format(lvl + 2)
-                if self.norm_type is not None:
-                    extra_fpn_conv = self.add_sublayer(
-                        extra_fpn_name,
-                        ConvNormLayer(
-                            ch_in=in_c,
-                            ch_out=out_channel,
-                            filter_size=3,
-                            stride=2,
-                            norm_type=self.norm_type,
-                            norm_decay=self.norm_decay,
-                            freeze_norm=self.freeze_norm,
-                            initializer=XavierUniform(fan_out=fan)))
-                else:
-                    extra_fpn_conv = self.add_sublayer(
-                        extra_fpn_name,
-                        nn.Conv2D(
-                            in_channels=in_c,
-                            out_channels=out_channel,
-                            kernel_size=3,
-                            stride=2,
-                            padding=1,
-                            weight_attr=ParamAttr(
-                                initializer=XavierUniform(fan_out=fan))))
-                self.fpn_convs.append(extra_fpn_conv)
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        return {
-            'in_channels': [i.channels for i in input_shape],
-            'spatial_scales': [1.0 / i.stride for i in input_shape],
-        }
-
-    def forward(self, body_feats):
-        laterals = []
-        num_levels = len(body_feats)
-        for i in range(num_levels):
-            laterals.append(self.lateral_convs[i](body_feats[i]))
-
-        for i in range(1, num_levels):
-            lvl = num_levels - i
-            upsample = F.interpolate(
-                laterals[lvl],
-                scale_factor=2.,
-                mode='nearest', )
-            laterals[lvl - 1] += upsample
-
-        fpn_output = []
-        for lvl in range(num_levels):
-            fpn_output.append(self.fpn_convs[lvl](laterals[lvl]))
-
-        if self.extra_stage > 0:
-            # use max pool to get more levels on top of outputs (Faster R-CNN, Mask R-CNN)
-            if not self.has_extra_convs:
-                assert self.extra_stage == 1, 'extra_stage should be 1 if FPN has not extra convs'
-                fpn_output.append(F.max_pool2d(fpn_output[-1], 1, stride=2))
-            # add extra conv levels for RetinaNet(use_c5)/FCOS(use_p5)
-            else:
-                if self.use_c5:
-                    extra_source = body_feats[-1]
-                else:
-                    extra_source = fpn_output[-1]
-                fpn_output.append(self.fpn_convs[num_levels](extra_source))
-
-                for i in range(1, self.extra_stage):
-                    if self.relu_before_extra_convs:
-                        fpn_output.append(self.fpn_convs[num_levels + i](
-                            F.relu(fpn_output[-1])))
-                    else:
-                        fpn_output.append(self.fpn_convs[num_levels + i](
-                            fpn_output[-1]))
-        return fpn_output
-
-    @property
-    def out_shape(self):
-        return [
-            ShapeSpec(
-                channels=self.out_channel, stride=1. / s)
-            for s in self.spatial_scales
-        ]

paddlex/ppdet/modeling/necks/hrfpn.py

@@ -1,131 +0,0 @@
-# Copyright (c) 2020 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.functional as F
-from paddle import ParamAttr
-import paddle.nn as nn
-from paddle.regularizer import L2Decay
-from paddlex.ppdet.core.workspace import register, serializable
-from ..shape_spec import ShapeSpec
-
-__all__ = ['HRFPN']
-
-
-@register
-class HRFPN(nn.Layer):
-    """
-    Args:
-        in_channels (list): number of input feature channels from backbone
-        out_channel (int): number of output feature channels
-        share_conv (bool): whether to share conv for different layers' reduction
-        extra_stage (int): add extra stage for returning HRFPN fpn_feats
-        spatial_scales (list): feature map scaling factor
-    """
-
-    def __init__(self,
-                 in_channels=[18, 36, 72, 144],
-                 out_channel=256,
-                 share_conv=False,
-                 extra_stage=1,
-                 spatial_scales=[1. / 4, 1. / 8, 1. / 16, 1. / 32]):
-        super(HRFPN, self).__init__()
-        in_channel = sum(in_channels)
-        self.in_channel = in_channel
-        self.out_channel = out_channel
-        self.share_conv = share_conv
-        for i in range(extra_stage):
-            spatial_scales = spatial_scales + [spatial_scales[-1] / 2.]
-        self.spatial_scales = spatial_scales
-        self.num_out = len(self.spatial_scales)
-
-        self.reduction = nn.Conv2D(
-            in_channels=in_channel,
-            out_channels=out_channel,
-            kernel_size=1,
-            weight_attr=ParamAttr(name='hrfpn_reduction_weights'),
-            bias_attr=False)
-
-        if share_conv:
-            self.fpn_conv = nn.Conv2D(
-                in_channels=out_channel,
-                out_channels=out_channel,
-                kernel_size=3,
-                padding=1,
-                weight_attr=ParamAttr(name='fpn_conv_weights'),
-                bias_attr=False)
-        else:
-            self.fpn_conv = []
-            for i in range(self.num_out):
-                conv_name = "fpn_conv_" + str(i)
-                conv = self.add_sublayer(
-                    conv_name,
-                    nn.Conv2D(
-                        in_channels=out_channel,
-                        out_channels=out_channel,
-                        kernel_size=3,
-                        padding=1,
-                        weight_attr=ParamAttr(name=conv_name + "_weights"),
-                        bias_attr=False))
-                self.fpn_conv.append(conv)
-
-    def forward(self, body_feats):
-        num_backbone_stages = len(body_feats)
-
-        outs = []
-        outs.append(body_feats[0])
-
-        # resize
-        for i in range(1, num_backbone_stages):
-            resized = F.interpolate(
-                body_feats[i], scale_factor=2**i, mode='bilinear')
-            outs.append(resized)
-
-        # concat
-        out = paddle.concat(outs, axis=1)
-        assert out.shape[
-            1] == self.in_channel, 'in_channel should be {}, be received {}'.format(
-                out.shape[1], self.in_channel)
-
-        # reduction
-        out = self.reduction(out)
-
-        # conv
-        outs = [out]
-        for i in range(1, self.num_out):
-            outs.append(F.avg_pool2d(out, kernel_size=2**i, stride=2**i))
-        outputs = []
-
-        for i in range(self.num_out):
-            conv_func = self.fpn_conv if self.share_conv else self.fpn_conv[i]
-            conv = conv_func(outs[i])
-            outputs.append(conv)
-
-        fpn_feats = [outputs[k] for k in range(self.num_out)]
-        return fpn_feats
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        return {
-            'in_channels': [i.channels for i in input_shape],
-            'spatial_scales': [1.0 / i.stride for i in input_shape],
-        }
-
-    @property
-    def out_shape(self):
-        return [
-            ShapeSpec(
-                channels=self.out_channel, stride=1. / s)
-            for s in self.spatial_scales
-        ]