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

paddlex/paddleseg/models/losses/lovasz_loss.py

@@ -1,222 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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.
-"""Lovasz-Softmax and Jaccard hinge loss in PaddlePaddle"""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import paddle
-from paddle import nn
-import paddle.nn.functional as F
-
-from paddlex.paddleseg.cvlibs import manager
-
-
-@manager.LOSSES.add_component
-class LovaszSoftmaxLoss(nn.Layer):
-    """
-    Multi-class Lovasz-Softmax loss.
-
-    Args:
-        ignore_index (int64): Specifies a target value that is ignored and does not contribute to the input gradient. Default ``255``.
-        classes (str|list): 'all' for all, 'present' for classes present in labels, or a list of classes to average.
-    """
-
-    def __init__(self, ignore_index=255, classes='present'):
-        super(LovaszSoftmaxLoss, self).__init__()
-        self.ignore_index = ignore_index
-        self.classes = classes
-
-    def forward(self, logits, labels):
-        r"""
-        Forward computation.
-
-        Args:
-            logits (Tensor): Shape is [N, C, H, W], logits at each prediction (between -\infty and +\infty).
-            labels (Tensor): Shape is [N, 1, H, W] or [N, H, W], ground truth labels (between 0 and C - 1).
-        """
-        probas = F.softmax(logits, axis=1)
-        vprobas, vlabels = flatten_probas(probas, labels, self.ignore_index)
-        loss = lovasz_softmax_flat(vprobas, vlabels, classes=self.classes)
-        return loss
-
-
-@manager.LOSSES.add_component
-class LovaszHingeLoss(nn.Layer):
-    """
-    Binary Lovasz hinge loss.
-
-    Args:
-        ignore_index (int64): Specifies a target value that is ignored and does not contribute to the input gradient. Default ``255``.
-    """
-
-    def __init__(self, ignore_index=255):
-        super(LovaszHingeLoss, self).__init__()
-        self.ignore_index = ignore_index
-
-    def forward(self, logits, labels):
-        r"""
-        Forward computation.
-
-        Args:
-            logits (Tensor): Shape is [N, 1, H, W] or [N, 2, H, W], logits at each pixel (between -\infty and +\infty).
-            labels (Tensor): Shape is [N, 1, H, W] or [N, H, W], binary ground truth masks (0 or 1).
-        """
-        if logits.shape[1] == 2:
-            logits = binary_channel_to_unary(logits)
-        loss = lovasz_hinge_flat(*flatten_binary_scores(logits, labels,
-                                                        self.ignore_index))
-        return loss
-
-
-def lovasz_grad(gt_sorted):
-    """
-    Computes gradient of the Lovasz extension w.r.t sorted errors.
-    See Alg. 1 in paper.
-    """
-    gts = paddle.sum(gt_sorted)
-    p = len(gt_sorted)
-
-    intersection = gts - paddle.cumsum(gt_sorted, axis=0)
-    union = gts + paddle.cumsum(1 - gt_sorted, axis=0)
-    jaccard = 1.0 - intersection.cast('float32') / union.cast('float32')
-
-    if p > 1:  # cover 1-pixel case
-        jaccard[1:p] = jaccard[1:p] - jaccard[0:-1]
-    return jaccard
-
-
-def binary_channel_to_unary(logits, eps=1e-9):
-    """
-    Converts binary channel logits to unary channel logits for lovasz hinge loss.
-    """
-    probas = F.softmax(logits, axis=1)
-    probas = probas[:, 1, :, :]
-    logits = paddle.log(probas + eps / (1 - probas + eps))
-    logits = logits.unsqueeze(1)
-    return logits
-
-
-def lovasz_hinge_flat(logits, labels):
-    r"""
-    Binary Lovasz hinge loss.
-
-    Args:
-        logits (Tensor): Shape is [P], logits at each prediction (between -\infty and +\infty).
-        labels (Tensor): Shape is [P], binary ground truth labels (0 or 1).
-    """
-    if len(labels) == 0:
-        # only void pixels, the gradients should be 0
-        return logits.sum() * 0.
-    signs = 2. * labels - 1.
-    signs.stop_gradient = True
-    errors = 1. - logits * signs
-    errors_sorted, perm = paddle.fluid.core.ops.argsort(errors, 'axis', 0,
-                                                        'descending', True)
-    errors_sorted.stop_gradient = False
-    gt_sorted = paddle.gather(labels, perm)
-    grad = lovasz_grad(gt_sorted)
-    grad.stop_gradient = True
-    loss = paddle.sum(F.relu(errors_sorted) * grad)
-    return loss
-
-
-def flatten_binary_scores(scores, labels, ignore=None):
-    """
-    Flattens predictions in the batch (binary case).
-    Remove labels according to 'ignore'.
-    """
-    scores = paddle.reshape(scores, [-1])
-    labels = paddle.reshape(labels, [-1])
-    labels.stop_gradient = True
-    if ignore is None:
-        return scores, labels
-    valid = labels != ignore
-    valid_mask = paddle.reshape(valid, (-1, 1))
-    indexs = paddle.nonzero(valid_mask)
-    indexs.stop_gradient = True
-    vscores = paddle.gather(scores, indexs[:, 0])
-    vlabels = paddle.gather(labels, indexs[:, 0])
-    return vscores, vlabels
-
-
-def lovasz_softmax_flat(probas, labels, classes='present'):
-    """
-    Multi-class Lovasz-Softmax loss.
-
-    Args:
-        probas (Tensor): Shape is [P, C], class probabilities at each prediction (between 0 and 1).
-        labels (Tensor): Shape is [P], ground truth labels (between 0 and C - 1).
-        classes (str|list): 'all' for all, 'present' for classes present in labels, or a list of classes to average.
-    """
-    if probas.numel() == 0:
-        # only void pixels, the gradients should be 0
-        return probas * 0.
-    C = probas.shape[1]
-    losses = []
-    classes_to_sum = list(range(C)) if classes in ['all', 'present'
-                                                   ] else classes
-    for c in classes_to_sum:
-        fg = paddle.cast(labels == c, probas.dtype)  # foreground for class c
-        if classes == 'present' and fg.sum() == 0:
-            continue
-        fg.stop_gradient = True
-        if C == 1:
-            if len(classes_to_sum) > 1:
-                raise ValueError('Sigmoid output possible only with 1 class')
-            class_pred = probas[:, 0]
-        else:
-            class_pred = probas[:, c]
-        errors = paddle.abs(fg - class_pred)
-        errors_sorted, perm = paddle.fluid.core.ops.argsort(errors, 'axis', 0,
-                                                            'descending', True)
-        errors_sorted.stop_gradient = False
-
-        fg_sorted = paddle.gather(fg, perm)
-        fg_sorted.stop_gradient = True
-
-        grad = lovasz_grad(fg_sorted)
-        grad.stop_gradient = True
-        loss = paddle.sum(errors_sorted * grad)
-        losses.append(loss)
-
-    if len(classes_to_sum) == 1:
-        return losses[0]
-
-    losses_tensor = paddle.stack(losses)
-    mean_loss = paddle.mean(losses_tensor)
-    return mean_loss
-
-
-def flatten_probas(probas, labels, ignore=None):
-    """
-    Flattens predictions in the batch.
-    """
-    if len(probas.shape) == 3:
-        probas = paddle.unsqueeze(probas, axis=1)
-    C = probas.shape[1]
-    probas = paddle.transpose(probas, [0, 2, 3, 1])
-    probas = paddle.reshape(probas, [-1, C])
-    labels = paddle.reshape(labels, [-1])
-    if ignore is None:
-        return probas, labels
-    valid = labels != ignore
-    valid_mask = paddle.reshape(valid, [-1, 1])
-    indexs = paddle.nonzero(valid_mask)
-    indexs.stop_gradient = True
-    vprobas = paddle.gather(probas, indexs[:, 0])
-    vlabels = paddle.gather(labels, indexs[:, 0])
-    return vprobas, vlabels

paddlex/paddleseg/models/losses/mean_square_error_loss.py

@@ -1,65 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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
-from paddle import nn
-import paddle.nn.functional as F
-
-from paddlex.paddleseg.cvlibs import manager
-
-
-@manager.LOSSES.add_component
-class MSELoss(nn.MSELoss):
-    r"""
-    **Mean Square Error Loss**
-    Computes the mean square error (squared L2 norm) of given input and label.
-    If :attr:`reduction` is set to ``'none'``, loss is calculated as:
-    .. math::
-        Out = (input - label)^2
-    If :attr:`reduction` is set to ``'mean'``, loss is calculated as:
-    .. math::
-        Out = \operatorname{mean}((input - label)^2)
-    If :attr:`reduction` is set to ``'sum'``, loss is calculated as:
-    .. math::
-        Out = \operatorname{sum}((input - label)^2)
-    where `input` and `label` are `float32` tensors of same shape.
-
-    Args:
-        reduction (string, optional): The reduction method for the output,
-            could be 'none' | 'mean' | 'sum'.
-            If :attr:`reduction` is ``'mean'``, the reduced mean loss is returned.
-            If :attr:`size_average` is ``'sum'``, the reduced sum loss is returned.
-            If :attr:`reduction` is ``'none'``, the unreduced loss is returned.
-            Default is ``'mean'``.
-        ignore_index (int, optional): Specifies a target value that is ignored and does not contribute to the input gradient. Default: 255.
-    Shape:
-        input (Tensor): Input tensor, the data type is float32 or float64
-        label (Tensor): Label tensor, the data type is float32 or float64
-        output (Tensor): output tensor storing the MSE loss of input and label, the data type is same as input.
-    Examples:
-        .. code-block:: python
-            import numpy as np
-            import paddle
-            input_data = np.array([1.5]).astype("float32")
-            label_data = np.array([1.7]).astype("float32")
-            mse_loss = paddle.nn.loss.MSELoss()
-            input = paddle.to_tensor(input_data)
-            label = paddle.to_tensor(label_data)
-            output = mse_loss(input, label)
-            print(output)
-            # [0.04000002]
-    """
-
-    def __init__(self, reduction='mean', ignore_index=255):
-        super().__init__(reduction=reduction)

paddlex/paddleseg/models/losses/mixed_loss.py

@@ -1,58 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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
-from paddle import nn
-import paddle.nn.functional as F
-
-from paddlex.paddleseg.cvlibs import manager
-
-
-@manager.LOSSES.add_component
-class MixedLoss(nn.Layer):
-    """
-    Weighted computations for multiple Loss.
-    The advantage is that mixed loss training can be achieved without changing the networking code.
-
-    Args:
-        losses (list[nn.Layer]): A list consisting of multiple loss classes
-        coef (list[float|int]): Weighting coefficient of multiple loss
-
-    Returns:
-        A callable object of MixedLoss.
-    """
-
-    def __init__(self, losses, coef):
-        super(MixedLoss, self).__init__()
-        if not isinstance(losses, list):
-            raise TypeError('`losses` must be a list!')
-        if not isinstance(coef, list):
-            raise TypeError('`coef` must be a list!')
-        len_losses = len(losses)
-        len_coef = len(coef)
-        if len_losses != len_coef:
-            raise ValueError(
-                'The length of `losses` should equal to `coef`, but they are {} and {}.'
-                .format(len_losses, len_coef))
-
-        self.losses = losses
-        self.coef = coef
-
-    def forward(self, logits, labels):
-        loss_list = []
-        final_output = 0
-        for i, loss in enumerate(self.losses):
-            output = loss(logits, labels)
-            final_output += output * self.coef[i]
-        return final_output

paddlex/paddleseg/models/losses/ohem_cross_entropy_loss.py

@@ -1,99 +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
-from paddle import nn
-import paddle.nn.functional as F
-
-from paddlex.paddleseg.cvlibs import manager
-
-
-@manager.LOSSES.add_component
-class OhemCrossEntropyLoss(nn.Layer):
-    """
-    Implements the ohem cross entropy loss function.
-
-    Args:
-        thresh (float, optional): The threshold of ohem. Default: 0.7.
-        min_kept (int, optional): The min number to keep in loss computation. Default: 10000.
-        ignore_index (int64, optional): Specifies a target value that is ignored
-            and does not contribute to the input gradient. Default ``255``.
-    """
-
-    def __init__(self, thresh=0.7, min_kept=10000, ignore_index=255):
-        super(OhemCrossEntropyLoss, self).__init__()
-        self.thresh = thresh
-        self.min_kept = min_kept
-        self.ignore_index = ignore_index
-        self.EPS = 1e-5
-
-    def forward(self, logit, label):
-        """
-        Forward computation.
-
-        Args:
-            logit (Tensor): Logit tensor, the data type is float32, float64. Shape is
-                (N, C), where C is number of classes, and if shape is more than 2D, this
-                is (N, C, D1, D2,..., Dk), k >= 1.
-            label (Tensor): Label tensor, the data type is int64. Shape is (N), where each
-                value is 0 <= label[i] <= C-1, and if shape is more than 2D, this is
-                (N, D1, D2,..., Dk), k >= 1.
-        """
-        if len(label.shape) != len(logit.shape):
-            label = paddle.unsqueeze(label, 1)
-
-        # get the label after ohem
-        n, c, h, w = logit.shape
-        label = label.reshape((-1, ))
-        valid_mask = (label != self.ignore_index).astype('int64')
-        num_valid = valid_mask.sum()
-        label = label * valid_mask
-
-        prob = F.softmax(logit, axis=1)
-        prob = prob.transpose((1, 0, 2, 3)).reshape((c, -1))
-
-        if self.min_kept < num_valid and num_valid > 0:
-            # let the value which ignored greater than 1
-            prob = prob + (1 - valid_mask)
-
-            # get the prob of relevant label
-            label_onehot = F.one_hot(label, c)
-            label_onehot = label_onehot.transpose((1, 0))
-            prob = prob * label_onehot
-            prob = paddle.sum(prob, axis=0)
-
-            threshold = self.thresh
-            if self.min_kept > 0:
-                index = prob.argsort()
-                threshold_index = index[min(len(index), self.min_kept) - 1]
-                threshold_index = int(threshold_index.numpy()[0])
-                if prob[threshold_index] > self.thresh:
-                    threshold = prob[threshold_index]
-                kept_mask = (prob < threshold).astype('int64')
-                label = label * kept_mask
-                valid_mask = valid_mask * kept_mask
-
-        # make the invalid region as ignore
-        label = label + (1 - valid_mask) * self.ignore_index
-
-        label = label.reshape((n, 1, h, w))
-        valid_mask = valid_mask.reshape((n, 1, h, w)).astype('float32')
-        loss = F.softmax_with_cross_entropy(
-            logit, label, ignore_index=self.ignore_index, axis=1)
-        loss = loss * valid_mask
-        avg_loss = paddle.mean(loss) / (paddle.mean(valid_mask) + self.EPS)
-
-        label.stop_gradient = True
-        valid_mask.stop_gradient = True
-        return avg_loss

paddlex/paddleseg/models/losses/ohem_edge_attention_loss.py

@@ -1,114 +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
-from paddle import nn
-import paddle.nn.functional as F
-
-from paddlex.paddleseg.cvlibs import manager
-from paddlex.paddleseg.models import losses
-
-
-@manager.LOSSES.add_component
-class OhemEdgeAttentionLoss(nn.Layer):
-    """
-    Implements the cross entropy loss function. It only compute the edge part.
-
-    Args:
-        edge_threshold (float, optional): The pixels greater edge_threshold as edges. Default: 0.8.
-        thresh (float, optional): The threshold of ohem. Default: 0.7.
-        min_kept (int, optional): The min number to keep in loss computation. Default: 5000.
-        ignore_index (int64, optional): Specifies a target value that is ignored
-            and does not contribute to the input gradient. Default ``255``.
-    """
-
-    def __init__(self,
-                 edge_threshold=0.8,
-                 thresh=0.7,
-                 min_kept=5000,
-                 ignore_index=255):
-        super().__init__()
-        self.edge_threshold = edge_threshold
-        self.thresh = thresh
-        self.min_kept = min_kept
-        self.ignore_index = ignore_index
-        self.EPS = 1e-10
-
-    def forward(self, logits, label):
-        """
-        Forward computation.
-
-        Args:
-            logits (tuple|list): (seg_logit, edge_logit) Tensor, the data type is float32, float64. Shape is
-                (N, C), where C is number of classes, and if shape is more than 2D, this
-                is (N, C, D1, D2,..., Dk), k >= 1. C =1 of edge_logit .
-            label (Tensor): Label tensor, the data type is int64. Shape is (N, C), where each
-                value is 0 <= label[i] <= C-1, and if shape is more than 2D, this is
-                (N, C, D1, D2,..., Dk), k >= 1.
-        """
-        seg_logit, edge_logit = logits[0], logits[1]
-        if len(label.shape) != len(seg_logit.shape):
-            label = paddle.unsqueeze(label, 1)
-        if edge_logit.shape != label.shape:
-            raise ValueError(
-                'The shape of edge_logit should equal to the label, but they are {} != {}'
-                .format(edge_logit.shape, label.shape))
-
-        # Filter out edge
-        filler = paddle.ones_like(label) * self.ignore_index
-        label = paddle.where(edge_logit > self.edge_threshold, label, filler)
-
-        # ohem
-        n, c, h, w = seg_logit.shape
-        label = label.reshape((-1, ))
-        valid_mask = (label != self.ignore_index).astype('int64')
-        num_valid = valid_mask.sum()
-        label = label * valid_mask
-
-        prob = F.softmax(seg_logit, axis=1)
-        prob = prob.transpose((1, 0, 2, 3)).reshape((c, -1))
-
-        if self.min_kept < num_valid and num_valid > 0:
-            # let the value which ignored greater than 1
-            prob = prob + (1 - valid_mask)
-
-            # get the prob of relevant label
-            label_onehot = F.one_hot(label, c)
-            label_onehot = label_onehot.transpose((1, 0))
-            prob = prob * label_onehot
-            prob = paddle.sum(prob, axis=0)
-
-            threshold = self.thresh
-            if self.min_kept > 0:
-                index = prob.argsort()
-                threshold_index = index[min(len(index), self.min_kept) - 1]
-                threshold_index = int(threshold_index.numpy()[0])
-                if prob[threshold_index] > self.thresh:
-                    threshold = prob[threshold_index]
-                kept_mask = (prob < threshold).astype('int64')
-                label = label * kept_mask
-                valid_mask = valid_mask * kept_mask
-        # make the invalid region as ignore
-        label = label + (1 - valid_mask) * self.ignore_index
-        label = label.reshape((n, 1, h, w))
-        valid_mask = valid_mask.reshape((n, 1, h, w)).astype('float32')
-
-        loss = F.softmax_with_cross_entropy(
-            seg_logit, label, ignore_index=self.ignore_index, axis=1)
-        loss = loss * valid_mask
-        avg_loss = paddle.mean(loss) / (paddle.mean(valid_mask) + self.EPS)
-
-        label.stop_gradient = True
-        valid_mask.stop_gradient = True
-        return avg_loss