paddlex 2.1.0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/ppdet/modeling/losses/varifocal_loss.py

@@ -1,152 +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.
-
-# The code is based on:
-# https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/losses/varifocal_loss.py
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-import numpy as np
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddlex.ppdet.core.workspace import register, serializable
-from paddlex.ppdet.modeling import ops
-
-__all__ = ['VarifocalLoss']
-
-
-def varifocal_loss(pred,
-                   target,
-                   alpha=0.75,
-                   gamma=2.0,
-                   iou_weighted=True,
-                   use_sigmoid=True):
-    """`Varifocal Loss <https://arxiv.org/abs/2008.13367>`_
-
-    Args:
-        pred (Tensor): The prediction with shape (N, C), C is the
-            number of classes
-        target (Tensor): The learning target of the iou-aware
-            classification score with shape (N, C), C is the number of classes.
-        alpha (float, optional): A balance factor for the negative part of
-            Varifocal Loss, which is different from the alpha of Focal Loss.
-            Defaults to 0.75.
-        gamma (float, optional): The gamma for calculating the modulating
-            factor. Defaults to 2.0.
-        iou_weighted (bool, optional): Whether to weight the loss of the
-            positive example with the iou target. Defaults to True.
-    """
-    # pred and target should be of the same size
-    assert pred.shape == target.shape
-    if use_sigmoid:
-        pred_new = F.sigmoid(pred)
-    else:
-        pred_new = pred
-    target = target.cast(pred.dtype)
-    if iou_weighted:
-        focal_weight = target * (target > 0.0).cast('float32') + \
-            alpha * (pred_new - target).abs().pow(gamma) * \
-            (target <= 0.0).cast('float32')
-    else:
-        focal_weight = (target > 0.0).cast('float32') + \
-            alpha * (pred_new - target).abs().pow(gamma) * \
-            (target <= 0.0).cast('float32')
-
-    if use_sigmoid:
-        loss = F.binary_cross_entropy_with_logits(
-            pred, target, reduction='none') * focal_weight
-    else:
-        loss = F.binary_cross_entropy(
-            pred, target, reduction='none') * focal_weight
-        loss = loss.sum(axis=1)
-    return loss
-
-
-@register
-@serializable
-class VarifocalLoss(nn.Layer):
-    def __init__(self,
-                 use_sigmoid=True,
-                 alpha=0.75,
-                 gamma=2.0,
-                 iou_weighted=True,
-                 reduction='mean',
-                 loss_weight=1.0):
-        """`Varifocal Loss <https://arxiv.org/abs/2008.13367>`_
-
-        Args:
-            use_sigmoid (bool, optional): Whether the prediction is
-                used for sigmoid or softmax. Defaults to True.
-            alpha (float, optional): A balance factor for the negative part of
-                Varifocal Loss, which is different from the alpha of Focal
-                Loss. Defaults to 0.75.
-            gamma (float, optional): The gamma for calculating the modulating
-                factor. Defaults to 2.0.
-            iou_weighted (bool, optional): Whether to weight the loss of the
-                positive examples with the iou target. Defaults to True.
-            reduction (str, optional): The method used to reduce the loss into
-                a scalar. Defaults to 'mean'. Options are "none", "mean" and
-                "sum".
-            loss_weight (float, optional): Weight of loss. Defaults to 1.0.
-        """
-        super(VarifocalLoss, self).__init__()
-        assert alpha >= 0.0
-        self.use_sigmoid = use_sigmoid
-        self.alpha = alpha
-        self.gamma = gamma
-        self.iou_weighted = iou_weighted
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self, pred, target, weight=None, avg_factor=None):
-        """Forward function.
-
-        Args:
-            pred (Tensor): The prediction.
-            target (Tensor): The learning target of the prediction.
-            weight (Tensor, optional): The weight of loss for each
-                prediction. Defaults to None.
-            avg_factor (int, optional): Average factor that is used to average
-                the loss. Defaults to None.
-        Returns:
-            Tensor: The calculated loss
-        """
-        loss = self.loss_weight * varifocal_loss(
-            pred,
-            target,
-            alpha=self.alpha,
-            gamma=self.gamma,
-            iou_weighted=self.iou_weighted,
-            use_sigmoid=self.use_sigmoid)
-
-        if weight is not None:
-            loss = loss * weight
-        if avg_factor is None:
-            if self.reduction == 'none':
-                return loss
-            elif self.reduction == 'mean':
-                return loss.mean()
-            elif self.reduction == 'sum':
-                return loss.sum()
-        else:
-            # if reduction is mean, then average the loss by avg_factor
-            if self.reduction == 'mean':
-                loss = loss.sum() / avg_factor
-            # if reduction is 'none', then do nothing, otherwise raise an error
-            elif self.reduction != 'none':
-                raise ValueError(
-                    'avg_factor can not be used with reduction="sum"')
-        return loss

paddlex/ppdet/modeling/losses/yolo_loss.py

@@ -1,212 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-from paddlex.ppdet.core.workspace import register
-
-from ..bbox_utils import decode_yolo, xywh2xyxy, iou_similarity
-
-__all__ = ['YOLOv3Loss']
-
-
-def bbox_transform(pbox, anchor, downsample):
-    pbox = decode_yolo(pbox, anchor, downsample)
-    pbox = xywh2xyxy(pbox)
-    return pbox
-
-
-@register
-class YOLOv3Loss(nn.Layer):
-
-    __inject__ = ['iou_loss', 'iou_aware_loss']
-    __shared__ = ['num_classes']
-
-    def __init__(self,
-                 num_classes=80,
-                 ignore_thresh=0.7,
-                 label_smooth=False,
-                 downsample=[32, 16, 8],
-                 scale_x_y=1.,
-                 iou_loss=None,
-                 iou_aware_loss=None):
-        """
-        YOLOv3Loss layer
-
-        Args:
-            num_calsses (int): number of foreground classes
-            ignore_thresh (float): threshold to ignore confidence loss
-            label_smooth (bool): whether to use label smoothing
-            downsample (list): downsample ratio for each detection block
-            scale_x_y (float): scale_x_y factor
-            iou_loss (object): IoULoss instance
-            iou_aware_loss (object): IouAwareLoss instance
-        """
-        super(YOLOv3Loss, self).__init__()
-        self.num_classes = num_classes
-        self.ignore_thresh = ignore_thresh
-        self.label_smooth = label_smooth
-        self.downsample = downsample
-        self.scale_x_y = scale_x_y
-        self.iou_loss = iou_loss
-        self.iou_aware_loss = iou_aware_loss
-        self.distill_pairs = []
-
-    def obj_loss(self, pbox, gbox, pobj, tobj, anchor, downsample):
-        # pbox
-        pbox = decode_yolo(pbox, anchor, downsample)
-        pbox = xywh2xyxy(pbox)
-        pbox = paddle.concat(pbox, axis=-1)
-        b = pbox.shape[0]
-        pbox = pbox.reshape((b, -1, 4))
-        # gbox
-        gxy = gbox[:, :, 0:2] - gbox[:, :, 2:4] * 0.5
-        gwh = gbox[:, :, 0:2] + gbox[:, :, 2:4] * 0.5
-        gbox = paddle.concat([gxy, gwh], axis=-1)
-
-        iou = iou_similarity(pbox, gbox)
-        iou.stop_gradient = True
-        iou_max = iou.max(2)  # [N, M1]
-        iou_mask = paddle.cast(iou_max <= self.ignore_thresh, dtype=pbox.dtype)
-        iou_mask.stop_gradient = True
-
-        pobj = pobj.reshape((b, -1))
-        tobj = tobj.reshape((b, -1))
-        obj_mask = paddle.cast(tobj > 0, dtype=pbox.dtype)
-        obj_mask.stop_gradient = True
-
-        loss_obj = F.binary_cross_entropy_with_logits(
-            pobj, obj_mask, reduction='none')
-        loss_obj_pos = (loss_obj * tobj)
-        loss_obj_neg = (loss_obj * (1 - obj_mask) * iou_mask)
-        return loss_obj_pos + loss_obj_neg
-
-    def cls_loss(self, pcls, tcls):
-        if self.label_smooth:
-            delta = min(1. / self.num_classes, 1. / 40)
-            pos, neg = 1 - delta, delta
-            # 1 for positive, 0 for negative
-            tcls = pos * paddle.cast(
-                tcls > 0., dtype=tcls.dtype) + neg * paddle.cast(
-                    tcls <= 0., dtype=tcls.dtype)
-
-        loss_cls = F.binary_cross_entropy_with_logits(
-            pcls, tcls, reduction='none')
-        return loss_cls
-
-    def yolov3_loss(self,
-                    p,
-                    t,
-                    gt_box,
-                    anchor,
-                    downsample,
-                    scale=1.,
-                    eps=1e-10):
-        na = len(anchor)
-        b, c, h, w = p.shape
-        if self.iou_aware_loss:
-            ioup, p = p[:, 0:na, :, :], p[:, na:, :, :]
-            ioup = ioup.unsqueeze(-1)
-        p = p.reshape((b, na, -1, h, w)).transpose((0, 1, 3, 4, 2))
-        x, y = p[:, :, :, :, 0:1], p[:, :, :, :, 1:2]
-        w, h = p[:, :, :, :, 2:3], p[:, :, :, :, 3:4]
-        obj, pcls = p[:, :, :, :, 4:5], p[:, :, :, :, 5:]
-        self.distill_pairs.append([x, y, w, h, obj, pcls])
-
-        t = t.transpose((0, 1, 3, 4, 2))
-        tx, ty = t[:, :, :, :, 0:1], t[:, :, :, :, 1:2]
-        tw, th = t[:, :, :, :, 2:3], t[:, :, :, :, 3:4]
-        tscale = t[:, :, :, :, 4:5]
-        tobj, tcls = t[:, :, :, :, 5:6], t[:, :, :, :, 6:]
-
-        tscale_obj = tscale * tobj
-        loss = dict()
-
-        x = scale * F.sigmoid(x) - 0.5 * (scale - 1.)
-        y = scale * F.sigmoid(y) - 0.5 * (scale - 1.)
-
-        if abs(scale - 1.) < eps:
-            loss_x = F.binary_cross_entropy(x, tx, reduction='none')
-            loss_y = F.binary_cross_entropy(y, ty, reduction='none')
-            loss_xy = tscale_obj * (loss_x + loss_y)
-        else:
-            loss_x = paddle.abs(x - tx)
-            loss_y = paddle.abs(y - ty)
-            loss_xy = tscale_obj * (loss_x + loss_y)
-
-        loss_xy = loss_xy.sum([1, 2, 3, 4]).mean()
-
-        loss_w = paddle.abs(w - tw)
-        loss_h = paddle.abs(h - th)
-        loss_wh = tscale_obj * (loss_w + loss_h)
-        loss_wh = loss_wh.sum([1, 2, 3, 4]).mean()
-
-        loss['loss_xy'] = loss_xy
-        loss['loss_wh'] = loss_wh
-
-        if self.iou_loss is not None:
-            # warn: do not modify x, y, w, h in place
-            box, tbox = [x, y, w, h], [tx, ty, tw, th]
-            pbox = bbox_transform(box, anchor, downsample)
-            gbox = bbox_transform(tbox, anchor, downsample)
-            loss_iou = self.iou_loss(pbox, gbox)
-            loss_iou = loss_iou * tscale_obj
-            loss_iou = loss_iou.sum([1, 2, 3, 4]).mean()
-            loss['loss_iou'] = loss_iou
-
-        if self.iou_aware_loss is not None:
-            box, tbox = [x, y, w, h], [tx, ty, tw, th]
-            pbox = bbox_transform(box, anchor, downsample)
-            gbox = bbox_transform(tbox, anchor, downsample)
-            loss_iou_aware = self.iou_aware_loss(ioup, pbox, gbox)
-            loss_iou_aware = loss_iou_aware * tobj
-            loss_iou_aware = loss_iou_aware.sum([1, 2, 3, 4]).mean()
-            loss['loss_iou_aware'] = loss_iou_aware
-
-        box = [x, y, w, h]
-        loss_obj = self.obj_loss(box, gt_box, obj, tobj, anchor, downsample)
-        loss_obj = loss_obj.sum(-1).mean()
-        loss['loss_obj'] = loss_obj
-        loss_cls = self.cls_loss(pcls, tcls) * tobj
-        loss_cls = loss_cls.sum([1, 2, 3, 4]).mean()
-        loss['loss_cls'] = loss_cls
-        return loss
-
-    def forward(self, inputs, targets, anchors):
-        np = len(inputs)
-        gt_targets = [targets['target{}'.format(i)] for i in range(np)]
-        gt_box = targets['gt_bbox']
-        yolo_losses = dict()
-        self.distill_pairs.clear()
-        for x, t, anchor, downsample in zip(inputs, gt_targets, anchors,
-                                            self.downsample):
-            yolo_loss = self.yolov3_loss(x, t, gt_box, anchor, downsample,
-                                         self.scale_x_y)
-            for k, v in yolo_loss.items():
-                if k in yolo_losses:
-                    yolo_losses[k] += v
-                else:
-                    yolo_losses[k] = v
-
-        loss = 0
-        for k, v in yolo_losses.items():
-            loss += v
-
-        yolo_losses['loss'] = loss
-        return yolo_losses

paddlex/ppdet/modeling/mot/__init__.py

@@ -1,25 +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.
-
-from . import matching
-from . import tracker
-from . import motion
-from . import visualization
-from . import utils
-
-from .matching import *
-from .tracker import *
-from .motion import *
-from .visualization import *
-from .utils import *

paddlex/ppdet/modeling/mot/matching/__init__.py

@@ -1,19 +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.
-
-from . import jde_matching
-from . import deepsort_matching
-
-from .jde_matching import *
-from .deepsort_matching import *