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

paddlex/ppdet/modeling/heads/ssd_head.py

@@ -1,175 +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 as nn
-import paddle.nn.functional as F
-from paddlex.ppdet.core.workspace import register
-from paddle.regularizer import L2Decay
-from paddle import ParamAttr
-
-from ..layers import AnchorGeneratorSSD
-
-
-class SepConvLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size=3,
-                 padding=1,
-                 conv_decay=0):
-        super(SepConvLayer, self).__init__()
-        self.dw_conv = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=in_channels,
-            kernel_size=kernel_size,
-            stride=1,
-            padding=padding,
-            groups=in_channels,
-            weight_attr=ParamAttr(regularizer=L2Decay(conv_decay)),
-            bias_attr=False)
-
-        self.bn = nn.BatchNorm2D(
-            in_channels,
-            weight_attr=ParamAttr(regularizer=L2Decay(0.)),
-            bias_attr=ParamAttr(regularizer=L2Decay(0.)))
-
-        self.pw_conv = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            weight_attr=ParamAttr(regularizer=L2Decay(conv_decay)),
-            bias_attr=False)
-
-    def forward(self, x):
-        x = self.dw_conv(x)
-        x = F.relu6(self.bn(x))
-        x = self.pw_conv(x)
-        return x
-
-
-@register
-class SSDHead(nn.Layer):
-    """
-    SSDHead
-
-    Args:
-        num_classes (int): Number of classes
-        in_channels (list): Number of channels per input feature
-        anchor_generator (dict): Configuration of 'AnchorGeneratorSSD' instance
-        kernel_size (int): Conv kernel size
-        padding (int): Conv padding
-        use_sepconv (bool): Use SepConvLayer if true
-        conv_decay (float): Conv regularization coeff
-        loss (object): 'SSDLoss' instance
-    """
-
-    __shared__ = ['num_classes']
-    __inject__ = ['anchor_generator', 'loss']
-
-    def __init__(self,
-                 num_classes=80,
-                 in_channels=(512, 1024, 512, 256, 256, 256),
-                 anchor_generator=AnchorGeneratorSSD().__dict__,
-                 kernel_size=3,
-                 padding=1,
-                 use_sepconv=False,
-                 conv_decay=0.,
-                 loss='SSDLoss'):
-        super(SSDHead, self).__init__()
-        # add background class
-        self.num_classes = num_classes + 1
-        self.in_channels = in_channels
-        self.anchor_generator = anchor_generator
-        self.loss = loss
-
-        if isinstance(anchor_generator, dict):
-            self.anchor_generator = AnchorGeneratorSSD(**anchor_generator)
-
-        self.num_priors = self.anchor_generator.num_priors
-        self.box_convs = []
-        self.score_convs = []
-        for i, num_prior in enumerate(self.num_priors):
-            box_conv_name = "boxes{}".format(i)
-            if not use_sepconv:
-                box_conv = self.add_sublayer(
-                    box_conv_name,
-                    nn.Conv2D(
-                        in_channels=in_channels[i],
-                        out_channels=num_prior * 4,
-                        kernel_size=kernel_size,
-                        padding=padding))
-            else:
-                box_conv = self.add_sublayer(
-                    box_conv_name,
-                    SepConvLayer(
-                        in_channels=in_channels[i],
-                        out_channels=num_prior * 4,
-                        kernel_size=kernel_size,
-                        padding=padding,
-                        conv_decay=conv_decay))
-            self.box_convs.append(box_conv)
-
-            score_conv_name = "scores{}".format(i)
-            if not use_sepconv:
-                score_conv = self.add_sublayer(
-                    score_conv_name,
-                    nn.Conv2D(
-                        in_channels=in_channels[i],
-                        out_channels=num_prior * self.num_classes,
-                        kernel_size=kernel_size,
-                        padding=padding))
-            else:
-                score_conv = self.add_sublayer(
-                    score_conv_name,
-                    SepConvLayer(
-                        in_channels=in_channels[i],
-                        out_channels=num_prior * self.num_classes,
-                        kernel_size=kernel_size,
-                        padding=padding,
-                        conv_decay=conv_decay))
-            self.score_convs.append(score_conv)
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        return {'in_channels': [i.channels for i in input_shape], }
-
-    def forward(self, feats, image, gt_bbox=None, gt_class=None):
-        box_preds = []
-        cls_scores = []
-        prior_boxes = []
-        for feat, box_conv, score_conv in zip(feats, self.box_convs,
-                                              self.score_convs):
-            box_pred = box_conv(feat)
-            box_pred = paddle.transpose(box_pred, [0, 2, 3, 1])
-            box_pred = paddle.reshape(box_pred, [0, -1, 4])
-            box_preds.append(box_pred)
-
-            cls_score = score_conv(feat)
-            cls_score = paddle.transpose(cls_score, [0, 2, 3, 1])
-            cls_score = paddle.reshape(cls_score, [0, -1, self.num_classes])
-            cls_scores.append(cls_score)
-
-        prior_boxes = self.anchor_generator(feats, image)
-
-        if self.training:
-            return self.get_loss(box_preds, cls_scores, gt_bbox, gt_class,
-                                 prior_boxes)
-        else:
-            return (box_preds, cls_scores), prior_boxes
-
-    def get_loss(self, boxes, scores, gt_bbox, gt_class, prior_boxes):
-        return self.loss(boxes, scores, gt_bbox, gt_class, prior_boxes)

paddlex/ppdet/modeling/heads/ttf_head.py

@@ -1,314 +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 as nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-from paddle.nn.initializer import Constant, Uniform, Normal
-from paddle.regularizer import L2Decay
-from paddlex.ppdet.core.workspace import register
-from paddlex.ppdet.modeling.layers import DeformableConvV2, LiteConv
-import numpy as np
-
-
-@register
-class HMHead(nn.Layer):
-    """
-    Args:
-        ch_in (int): The channel number of input Tensor.
-        ch_out (int): The channel number of output Tensor.
-        num_classes (int): Number of classes.
-        conv_num (int): The convolution number of hm_feat.
-        dcn_head(bool): whether use dcn in head. False by default.
-        lite_head(bool): whether use lite version. False by default.
-        norm_type (string): norm type, 'sync_bn', 'bn', 'gn' are optional.
-            bn by default
-
-    Return:
-        Heatmap head output
-    """
-    __shared__ = ['num_classes', 'norm_type']
-
-    def __init__(
-            self,
-            ch_in,
-            ch_out=128,
-            num_classes=80,
-            conv_num=2,
-            dcn_head=False,
-            lite_head=False,
-            norm_type='bn', ):
-        super(HMHead, self).__init__()
-        head_conv = nn.Sequential()
-        for i in range(conv_num):
-            name = 'conv.{}'.format(i)
-            if lite_head:
-                lite_name = 'hm.' + name
-                head_conv.add_sublayer(
-                    lite_name,
-                    LiteConv(
-                        in_channels=ch_in if i == 0 else ch_out,
-                        out_channels=ch_out,
-                        norm_type=norm_type))
-                head_conv.add_sublayer(lite_name + '.act', nn.ReLU6())
-            else:
-                if dcn_head:
-                    head_conv.add_sublayer(
-                        name,
-                        DeformableConvV2(
-                            in_channels=ch_in if i == 0 else ch_out,
-                            out_channels=ch_out,
-                            kernel_size=3,
-                            weight_attr=ParamAttr(initializer=Normal(0,
-                                                                     0.01))))
-                else:
-                    head_conv.add_sublayer(
-                        name,
-                        nn.Conv2D(
-                            in_channels=ch_in if i == 0 else ch_out,
-                            out_channels=ch_out,
-                            kernel_size=3,
-                            padding=1,
-                            weight_attr=ParamAttr(initializer=Normal(0, 0.01)),
-                            bias_attr=ParamAttr(
-                                learning_rate=2., regularizer=L2Decay(0.))))
-                head_conv.add_sublayer(name + '.act', nn.ReLU())
-        self.feat = head_conv
-        bias_init = float(-np.log((1 - 0.01) / 0.01))
-        self.head = nn.Conv2D(
-            in_channels=ch_out,
-            out_channels=num_classes,
-            kernel_size=1,
-            weight_attr=ParamAttr(initializer=Normal(0, 0.01)),
-            bias_attr=ParamAttr(
-                learning_rate=2.,
-                regularizer=L2Decay(0.),
-                initializer=Constant(bias_init)))
-
-    def forward(self, feat):
-        out = self.feat(feat)
-        out = self.head(out)
-        return out
-
-
-@register
-class WHHead(nn.Layer):
-    """
-    Args:
-        ch_in (int): The channel number of input Tensor.
-        ch_out (int): The channel number of output Tensor.
-        conv_num (int): The convolution number of wh_feat.
-        dcn_head(bool): whether use dcn in head. False by default.
-        lite_head(bool): whether use lite version. False by default.
-        norm_type (string): norm type, 'sync_bn', 'bn', 'gn' are optional.
-            bn by default
-    Return:
-        Width & Height head output
-    """
-    __shared__ = ['norm_type']
-
-    def __init__(self,
-                 ch_in,
-                 ch_out=64,
-                 conv_num=2,
-                 dcn_head=False,
-                 lite_head=False,
-                 norm_type='bn'):
-        super(WHHead, self).__init__()
-        head_conv = nn.Sequential()
-        for i in range(conv_num):
-            name = 'conv.{}'.format(i)
-            if lite_head:
-                lite_name = 'wh.' + name
-                head_conv.add_sublayer(
-                    lite_name,
-                    LiteConv(
-                        in_channels=ch_in if i == 0 else ch_out,
-                        out_channels=ch_out,
-                        norm_type=norm_type))
-                head_conv.add_sublayer(lite_name + '.act', nn.ReLU6())
-            else:
-                if dcn_head:
-                    head_conv.add_sublayer(
-                        name,
-                        DeformableConvV2(
-                            in_channels=ch_in if i == 0 else ch_out,
-                            out_channels=ch_out,
-                            kernel_size=3,
-                            weight_attr=ParamAttr(initializer=Normal(0,
-                                                                     0.01))))
-                else:
-                    head_conv.add_sublayer(
-                        name,
-                        nn.Conv2D(
-                            in_channels=ch_in if i == 0 else ch_out,
-                            out_channels=ch_out,
-                            kernel_size=3,
-                            padding=1,
-                            weight_attr=ParamAttr(initializer=Normal(0, 0.01)),
-                            bias_attr=ParamAttr(
-                                learning_rate=2., regularizer=L2Decay(0.))))
-                head_conv.add_sublayer(name + '.act', nn.ReLU())
-
-        self.feat = head_conv
-        self.head = nn.Conv2D(
-            in_channels=ch_out,
-            out_channels=4,
-            kernel_size=1,
-            weight_attr=ParamAttr(initializer=Normal(0, 0.001)),
-            bias_attr=ParamAttr(
-                learning_rate=2., regularizer=L2Decay(0.)))
-
-    def forward(self, feat):
-        out = self.feat(feat)
-        out = self.head(out)
-        out = F.relu(out)
-        return out
-
-
-@register
-class TTFHead(nn.Layer):
-    """
-    TTFHead
-    Args:
-        in_channels (int): the channel number of input to TTFHead.
-        num_classes (int): the number of classes, 80 by default.
-        hm_head_planes (int): the channel number in heatmap head,
-            128 by default.
-        wh_head_planes (int): the channel number in width & height head,
-            64 by default.
-        hm_head_conv_num (int): the number of convolution in heatmap head,
-            2 by default.
-        wh_head_conv_num (int): the number of convolution in width & height
-            head, 2 by default.
-        hm_loss (object): Instance of 'CTFocalLoss'.
-        wh_loss (object): Instance of 'GIoULoss'.
-        wh_offset_base (float): the base offset of width and height,
-            16.0 by default.
-        down_ratio (int): the actual down_ratio is calculated by base_down_ratio
-            (default 16) and the number of upsample layers.
-        lite_head(bool): whether use lite version. False by default.
-        norm_type (string): norm type, 'sync_bn', 'bn', 'gn' are optional.
-            bn by default
-        ags_module(bool): whether use AGS module to reweight location feature.
-            false by default.
-
-    """
-
-    __shared__ = ['num_classes', 'down_ratio', 'norm_type']
-    __inject__ = ['hm_loss', 'wh_loss']
-
-    def __init__(self,
-                 in_channels,
-                 num_classes=80,
-                 hm_head_planes=128,
-                 wh_head_planes=64,
-                 hm_head_conv_num=2,
-                 wh_head_conv_num=2,
-                 hm_loss='CTFocalLoss',
-                 wh_loss='GIoULoss',
-                 wh_offset_base=16.,
-                 down_ratio=4,
-                 dcn_head=False,
-                 lite_head=False,
-                 norm_type='bn',
-                 ags_module=False):
-        super(TTFHead, self).__init__()
-        self.in_channels = in_channels
-        self.hm_head = HMHead(in_channels, hm_head_planes, num_classes,
-                              hm_head_conv_num, dcn_head, lite_head, norm_type)
-        self.wh_head = WHHead(in_channels, wh_head_planes, wh_head_conv_num,
-                              dcn_head, lite_head, norm_type)
-        self.hm_loss = hm_loss
-        self.wh_loss = wh_loss
-
-        self.wh_offset_base = wh_offset_base
-        self.down_ratio = down_ratio
-        self.ags_module = ags_module
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        if isinstance(input_shape, (list, tuple)):
-            input_shape = input_shape[0]
-        return {'in_channels': input_shape.channels, }
-
-    def forward(self, feats):
-        hm = self.hm_head(feats)
-        wh = self.wh_head(feats) * self.wh_offset_base
-        return hm, wh
-
-    def filter_box_by_weight(self, pred, target, weight):
-        """
-        Filter out boxes where ttf_reg_weight is 0, only keep positive samples.
-        """
-        index = paddle.nonzero(weight > 0)
-        index.stop_gradient = True
-        weight = paddle.gather_nd(weight, index)
-        pred = paddle.gather_nd(pred, index)
-        target = paddle.gather_nd(target, index)
-        return pred, target, weight
-
-    def filter_loc_by_weight(self, score, weight):
-        index = paddle.nonzero(weight > 0)
-        index.stop_gradient = True
-        score = paddle.gather_nd(score, index)
-        return score
-
-    def get_loss(self, pred_hm, pred_wh, target_hm, box_target, target_weight):
-        pred_hm = paddle.clip(F.sigmoid(pred_hm), 1e-4, 1 - 1e-4)
-        hm_loss = self.hm_loss(pred_hm, target_hm)
-        H, W = target_hm.shape[2:]
-        mask = paddle.reshape(target_weight, [-1, H, W])
-        avg_factor = paddle.sum(mask) + 1e-4
-
-        base_step = self.down_ratio
-        shifts_x = paddle.arange(0, W * base_step, base_step, dtype='int32')
-        shifts_y = paddle.arange(0, H * base_step, base_step, dtype='int32')
-        shift_y, shift_x = paddle.tensor.meshgrid([shifts_y, shifts_x])
-        base_loc = paddle.stack([shift_x, shift_y], axis=0)
-        base_loc.stop_gradient = True
-
-        pred_boxes = paddle.concat(
-            [
-                0 - pred_wh[:, 0:2, :, :] + base_loc, pred_wh[:, 2:4] +
-                base_loc
-            ],
-            axis=1)
-        pred_boxes = paddle.transpose(pred_boxes, [0, 2, 3, 1])
-        boxes = paddle.transpose(box_target, [0, 2, 3, 1])
-        boxes.stop_gradient = True
-
-        if self.ags_module:
-            pred_hm_max = paddle.max(pred_hm, axis=1, keepdim=True)
-            pred_hm_max_softmax = F.softmax(pred_hm_max, axis=1)
-            pred_hm_max_softmax = paddle.transpose(pred_hm_max_softmax,
-                                                   [0, 2, 3, 1])
-            pred_hm_max_softmax = self.filter_loc_by_weight(
-                pred_hm_max_softmax, mask)
-        else:
-            pred_hm_max_softmax = None
-
-        pred_boxes, boxes, mask = self.filter_box_by_weight(pred_boxes, boxes,
-                                                            mask)
-        mask.stop_gradient = True
-        wh_loss = self.wh_loss(
-            pred_boxes,
-            boxes,
-            iou_weight=mask.unsqueeze(1),
-            loc_reweight=pred_hm_max_softmax)
-        wh_loss = wh_loss / avg_factor
-
-        ttf_loss = {'hm_loss': hm_loss, 'wh_loss': wh_loss}
-        return ttf_loss

paddlex/ppdet/modeling/heads/yolo_head.py

@@ -1,124 +0,0 @@
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-from paddle.regularizer import L2Decay
-from paddlex.ppdet.core.workspace import register
-
-
-def _de_sigmoid(x, eps=1e-7):
-    x = paddle.clip(x, eps, 1. / eps)
-    x = paddle.clip(1. / x - 1., eps, 1. / eps)
-    x = -paddle.log(x)
-    return x
-
-
-@register
-class YOLOv3Head(nn.Layer):
-    __shared__ = ['num_classes', 'data_format']
-    __inject__ = ['loss']
-
-    def __init__(self,
-                 in_channels=[1024, 512, 256],
-                 anchors=[[10, 13], [16, 30], [33, 23], [30, 61], [62, 45],
-                          [59, 119], [116, 90], [156, 198], [373, 326]],
-                 anchor_masks=[[6, 7, 8], [3, 4, 5], [0, 1, 2]],
-                 num_classes=80,
-                 loss='YOLOv3Loss',
-                 iou_aware=False,
-                 iou_aware_factor=0.4,
-                 data_format='NCHW'):
-        """
-        Head for YOLOv3 network
-
-        Args:
-            num_classes (int): number of foreground classes
-            anchors (list): anchors
-            anchor_masks (list): anchor masks
-            loss (object): YOLOv3Loss instance
-            iou_aware (bool): whether to use iou_aware
-            iou_aware_factor (float): iou aware factor
-            data_format (str): data format, NCHW or NHWC
-        """
-        super(YOLOv3Head, self).__init__()
-        assert len(in_channels) > 0, "in_channels length should > 0"
-        self.in_channels = in_channels
-        self.num_classes = num_classes
-        self.loss = loss
-
-        self.iou_aware = iou_aware
-        self.iou_aware_factor = iou_aware_factor
-
-        self.parse_anchor(anchors, anchor_masks)
-        self.num_outputs = len(self.anchors)
-        self.data_format = data_format
-
-        self.yolo_outputs = []
-        for i in range(len(self.anchors)):
-
-            if self.iou_aware:
-                num_filters = len(self.anchors[i]) * (self.num_classes + 6)
-            else:
-                num_filters = len(self.anchors[i]) * (self.num_classes + 5)
-            name = 'yolo_output.{}'.format(i)
-            conv = nn.Conv2D(
-                in_channels=self.in_channels[i],
-                out_channels=num_filters,
-                kernel_size=1,
-                stride=1,
-                padding=0,
-                data_format=data_format,
-                bias_attr=ParamAttr(regularizer=L2Decay(0.)))
-            conv.skip_quant = True
-            yolo_output = self.add_sublayer(name, conv)
-            self.yolo_outputs.append(yolo_output)
-
-    def parse_anchor(self, anchors, anchor_masks):
-        self.anchors = [[anchors[i] for i in mask] for mask in anchor_masks]
-        self.mask_anchors = []
-        anchor_num = len(anchors)
-        for masks in anchor_masks:
-            self.mask_anchors.append([])
-            for mask in masks:
-                assert mask < anchor_num, "anchor mask index overflow"
-                self.mask_anchors[-1].extend(anchors[mask])
-
-    def forward(self, feats, targets=None):
-        assert len(feats) == len(self.anchors)
-        yolo_outputs = []
-        for i, feat in enumerate(feats):
-            yolo_output = self.yolo_outputs[i](feat)
-            if self.data_format == 'NHWC':
-                yolo_output = paddle.transpose(yolo_output, [0, 3, 1, 2])
-            yolo_outputs.append(yolo_output)
-
-        if self.training:
-            return self.loss(yolo_outputs, targets, self.anchors)
-        else:
-            if self.iou_aware:
-                y = []
-                for i, out in enumerate(yolo_outputs):
-                    na = len(self.anchors[i])
-                    ioup, x = out[:, 0:na, :, :], out[:, na:, :, :]
-                    b, c, h, w = x.shape
-                    no = c // na
-                    x = x.reshape((b, na, no, h * w))
-                    ioup = ioup.reshape((b, na, 1, h * w))
-                    obj = x[:, :, 4:5, :]
-                    ioup = F.sigmoid(ioup)
-                    obj = F.sigmoid(obj)
-                    obj_t = (obj**(1 - self.iou_aware_factor)) * (
-                        ioup**self.iou_aware_factor)
-                    obj_t = _de_sigmoid(obj_t)
-                    loc_t = x[:, :, :4, :]
-                    cls_t = x[:, :, 5:, :]
-                    y_t = paddle.concat([loc_t, obj_t, cls_t], axis=2)
-                    y_t = y_t.reshape((b, c, h, w))
-                    y.append(y_t)
-                return y
-            else:
-                return yolo_outputs
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        return {'in_channels': [i.channels for i in input_shape], }