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

paddlex/paddleseg/models/losses/cross_entropy_loss.py

@@ -1,94 +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 CrossEntropyLoss(nn.Layer):
-    """
-    Implements the cross entropy loss function.
-
-    Args:
-        weight (tuple|list|ndarray|Tensor, optional): A manual rescaling weight
-            given to each class. Its length must be equal to the number of classes.
-            Default ``None``.
-        ignore_index (int64, optional): Specifies a target value that is ignored
-            and does not contribute to the input gradient. Default ``255``.
-        top_k_percent_pixels (float, optional): the value lies in [0.0, 1.0]. When its value < 1.0, only compute the loss for
-            the top k percent pixels (e.g., the top 20% pixels). This is useful for hard pixel mining.
-    """
-
-    def __init__(self, weight=None, ignore_index=255,
-                 top_k_percent_pixels=1.0):
-        super(CrossEntropyLoss, self).__init__()
-        if weight is not None:
-            weight = paddle.to_tensor(weight, dtype='float32')
-        self.weight = weight
-        self.ignore_index = ignore_index
-        self.top_k_percent_pixels = top_k_percent_pixels
-        self.EPS = 1e-8
-
-    def forward(self, logit, label, semantic_weights=None):
-        """
-        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 self.weight is not None and logit.shape[1] != len(self.weight):
-            raise ValueError(
-                'The number of weights = {} must be the same as the number of classes = {}.'
-                .format(len(self.weight), logit.shape[1]))
-
-        logit = paddle.transpose(logit, [0, 2, 3, 1])
-        if self.weight is None:
-            loss = F.cross_entropy(
-                logit, label, ignore_index=self.ignore_index, reduction='none')
-        else:
-            label_one_hot = F.one_hot(label, logit.shape[-1])
-            loss = F.cross_entropy(
-                logit,
-                label_one_hot * self.weight,
-                soft_label=True,
-                ignore_index=self.ignore_index,
-                reduction='none')
-            loss = loss.squeeze(-1)
-
-        mask = label != self.ignore_index
-        mask = paddle.cast(mask, 'float32')
-        loss = loss * mask
-        if semantic_weights is not None:
-            loss = loss * semantic_weights
-
-        label.stop_gradient = True
-        mask.stop_gradient = True
-        if self.top_k_percent_pixels == 1.0:
-            avg_loss = paddle.mean(loss) / (paddle.mean(mask) + self.EPS)
-            return avg_loss
-
-        loss = loss.reshape((-1, ))
-        top_k_pixels = int(self.top_k_percent_pixels * loss.numel())
-        loss, _ = paddle.topk(loss, top_k_pixels)
-
-        return loss.mean()

paddlex/paddleseg/models/losses/decoupledsegnet_relax_boundary_loss.py

@@ -1,129 +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
-from paddle import nn
-import paddle.nn.functional as F
-from scipy.ndimage.interpolation import shift
-
-from paddlex.paddleseg.cvlibs import manager
-
-
-@manager.LOSSES.add_component
-class RelaxBoundaryLoss(nn.Layer):
-    """
-    Implements the ohem cross entropy loss function.
-
-    Args:
-        border (int, optional): The value of border to relax. Default: 1.
-        calculate_weights (bool, optional): Whether to calculate weights for every classes. Default: False.
-        upper_bound (float, optional): The upper bound of weights if calculating weights for every classes. Default: 1.0.
-        ignore_index (int64): Specifies a target value that is ignored
-            and does not contribute to the input gradient. Default: 255.
-    """
-
-    def __init__(self,
-                 border=1,
-                 calculate_weights=False,
-                 upper_bound=1.0,
-                 ignore_index=255):
-        super(RelaxBoundaryLoss, self).__init__()
-        self.border = border
-        self.calculate_weights = calculate_weights
-        self.upper_bound = upper_bound
-        self.ignore_index = ignore_index
-        self.EPS = 1e-5
-
-    def relax_onehot(self, label, num_classes):
-        # pad label, and let ignore_index as num_classes
-        if len(label.shape) == 3:
-            label = label.unsqueeze(1)
-        h, w = label.shape[-2], label.shape[-1]
-        label = F.pad(label, [self.border] * 4, value=num_classes)
-        label = label.squeeze(1)
-        ignore_mask = (label == self.ignore_index).astype('int64')
-        label = label * (1 - ignore_mask) + num_classes * ignore_mask
-
-        onehot = 0
-        for i in range(-self.border, self.border + 1):
-            for j in range(-self.border, self.border + 1):
-                h_start, h_end = 1 + i, h + 1 + i
-                w_start, w_end = 1 + j, w + 1 + j
-                label_ = label[:, h_start:h_end, w_start:w_end]
-                onehot_ = F.one_hot(label_, num_classes + 1)
-                onehot += onehot_
-        onehot = (onehot > 0).astype('int64')
-        onehot = paddle.transpose(onehot, (0, 3, 1, 2))
-
-        return onehot
-
-    def calculate_weights(self, label):
-        hist = paddle.sum(label, axis=(1, 2)) * 1.0 / label.sum()
-        hist = ((hist != 0) * self.upper_bound * (1 - hist)) + 1
-
-    def custom_nll(self,
-                   logit,
-                   label,
-                   class_weights=None,
-                   border_weights=None,
-                   ignore_mask=None):
-        soft = F.softmax(logit, axis=1)
-        # calculate the valid soft where label is 1.
-        soft_label = ((soft * label[:, :-1, :, :]).sum(
-            1, keepdim=True)) * (label[:, :-1, :, :].astype('float32'))
-        soft = soft * (1 - label[:, :-1, :, :]) + soft_label
-        logsoft = paddle.log(soft)
-        if class_weights is not None:
-            logsoft = class_weights.unsqueeze((0, 2, 3))
-        logsoft = label[:, :-1, :, :] * logsoft
-        logsoft = logsoft.sum(1)
-        # border loss is divided equally
-        logsoft = -1 / border_weights * logsoft * (1. - ignore_mask)
-        n, _, h, w = label.shape
-        logsoft = logsoft.sum() / (n * h * w - ignore_mask.sum() + 1)
-        return logsoft
-
-    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.
-        """
-        n, c, h, w = logit.shape
-        label.stop_gradient = True
-        label = self.relax_onehot(label, c)
-        weights = label[:, :-1, :, :].sum(1).astype('float32')
-        ignore_mask = (weights == 0).astype('float32')
-        # border is greater than 1, other is 1
-        border_weights = weights + ignore_mask
-
-        loss = 0
-        class_weights = None
-        for i in range(n):
-            if self.calculate_weights:
-                class_weights = self.calculate_weights(label[i])
-            loss = loss + self.custom_nll(
-                logit[i].unsqueeze(0),
-                label[i].unsqueeze(0),
-                class_weights=class_weights,
-                border_weights=border_weights,
-                ignore_mask=ignore_mask[i])
-        return loss

paddlex/paddleseg/models/losses/dice_loss.py

@@ -1,61 +0,0 @@
-# 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 DiceLoss(nn.Layer):
-    """
-    Implements the dice loss function.
-
-    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, smooth=0.):
-        super(DiceLoss, self).__init__()
-        self.ignore_index = ignore_index
-        self.eps = 1e-5
-        self.smooth = smooth  # Laplace smoothing, https://github.com/pytorch/pytorch/issues/1249#issuecomment-337999895
-
-    def forward(self, logits, labels):
-        if len(labels.shape) != len(logits.shape):
-            labels = paddle.unsqueeze(labels, 1)
-        num_classes = logits.shape[1]
-
-        labels = paddle.cast(labels, dtype='int32')
-        single_label_lists = []
-        for c in range(num_classes):
-            single_label = paddle.cast((labels == c), dtype='int32')
-            single_label = paddle.squeeze(single_label, axis=1)
-            if c == self.ignore_index:
-                single_label = paddle.zeros_like(single_label)
-            single_label_lists.append(single_label)
-
-        labels_one_hot = paddle.stack(tuple(single_label_lists), axis=1)
-        logits = F.softmax(logits, axis=1)
-
-        mask = (labels != self.ignore_index)
-        logits = logits * mask
-
-        labels_one_hot = paddle.cast(labels_one_hot, dtype='float32')
-        dims = (0, ) + tuple(range(2, labels.ndimension()))
-        intersection = paddle.sum(logits * labels_one_hot, dims)
-        cardinality = paddle.sum(logits + labels_one_hot, dims)
-        dice_loss = ((2. * intersection + self.smooth) /
-                     (cardinality + self.eps + self.smooth)).mean()
-        return 1 - dice_loss

paddlex/paddleseg/models/losses/edge_attention_loss.py

@@ -1,78 +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 EdgeAttentionLoss(nn.Layer):
-    """
-    Implements the cross entropy loss function. It only compute the edge part.
-
-    Args:
-        edge_threshold (float): The pixels greater edge_threshold as edges.
-        ignore_index (int64): Specifies a target value that is ignored
-            and does not contribute to the input gradient. Default ``255``.
-    """
-
-    def __init__(self, edge_threshold=0.8, ignore_index=255):
-        super().__init__()
-        self.edge_threshold = edge_threshold
-        self.ignore_index = ignore_index
-        self.EPS = 1e-10
-        self.mean_mask = 1
-
-    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))
-
-        filler = paddle.ones_like(label) * self.ignore_index
-        label = paddle.where(edge_logit > self.edge_threshold, label, filler)
-
-        seg_logit = paddle.transpose(seg_logit, [0, 2, 3, 1])
-        label = paddle.transpose(label, [0, 2, 3, 1])
-        loss = F.softmax_with_cross_entropy(
-            seg_logit, label, ignore_index=self.ignore_index, axis=-1)
-
-        mask = label != self.ignore_index
-        mask = paddle.cast(mask, 'float32')
-        loss = loss * mask
-        avg_loss = paddle.mean(loss) / (paddle.mean(mask) + self.EPS)
-        if paddle.mean(mask) < self.mean_mask:
-            self.mean_mask = paddle.mean(mask)
-
-        label.stop_gradient = True
-        mask.stop_gradient = True
-        return avg_loss

paddlex/paddleseg/models/losses/gscnn_dual_task_loss.py

@@ -1,141 +0,0 @@
-# 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.paddleseg.cvlibs import manager
-
-
-@manager.LOSSES.add_component
-class DualTaskLoss(nn.Layer):
-    """
-    The dual task loss implement of GSCNN
-
-    Args:
-        ignore_index (int64): Specifies a target value that is ignored
-            and does not contribute to the input gradient. Default ``255``.
-        tau (float): the tau of gumbel softmax sample.
-    """
-
-    def __init__(self, ignore_index=255, tau=0.5):
-        super().__init__()
-        self.ignore_index = ignore_index
-        self.tau = tau
-
-    def _gumbel_softmax_sample(self, logit, tau=1, eps=1e-10):
-        """
-        Draw a sample from the Gumbel-Softmax distribution
-
-        based on
-        https://github.com/ericjang/gumbel-softmax/blob/3c8584924603869e90ca74ac20a6a03d99a91ef9/Categorical%20VAE.ipynb
-        (MIT license)
-        """
-        gumbel_noise = paddle.rand(logit.shape)
-        gumbel_noise = -paddle.log(eps - paddle.log(gumbel_noise + eps))
-        logit = logit + gumbel_noise
-        return F.softmax(logit / tau, axis=1)
-
-    def compute_grad_mag(self, x):
-        eps = 1e-6
-        n, c, h, w = x.shape
-        if h <= 1 or w <= 1:
-            raise ValueError(
-                'The width and height of tensor to compute grad must be greater than 1, but the shape is {}.'
-                .format(x.shape))
-
-        x = self.conv_tri(x, r=4)
-        kernel = [[-1, 0, 1]]
-        kernel = paddle.to_tensor(kernel).astype('float32')
-        kernel = 0.5 * kernel
-
-        kernel_x = paddle.concat([kernel.unsqueeze((0, 1))] * c, axis=0)
-        grad_x = F.conv2d(x, kernel_x, padding='same', groups=c)
-        kernel_y = paddle.concat([kernel.t().unsqueeze((0, 1))] * c, axis=0)
-        grad_y = F.conv2d(x, kernel_y, padding='same', groups=c)
-        mag = paddle.sqrt(grad_x * grad_x + grad_y * grad_y + eps)
-
-        return mag / mag.max()
-
-    def conv_tri(self, input, r):
-        """
-        Convolves an image by a 2D triangle filter (the 1D triangle filter f is
-        [1:r r+1 r:-1:1]/(r+1)^2, the 2D version is simply conv2(f,f'))
-        """
-        if r <= 1:
-            raise ValueError(
-                '`r` should be greater than 1, but it is {}.'.format(r))
-
-        kernel = [
-            list(range(1, r + 1)) + [r + 1] + list(reversed(range(1, r + 1)))
-        ]
-        kernel = paddle.to_tensor(kernel).astype('float32')
-        kernel = kernel / (r + 1)**2
-        input_ = F.pad(input, [1, 1, 0, 0], mode='replicate')
-        input_ = F.pad(input_, [r, r, 0, 0], mode='reflect')
-        input_ = [input_[:, :, :, :r], input, input_[:, :, :, -r:]]
-        input_ = paddle.concat(input_, axis=3)
-        tem = input_.clone()
-
-        input_ = F.pad(input_, [0, 0, 1, 1], mode='replicate')
-        input_ = F.pad(input_, [0, 0, r, r], mode='reflect')
-        input_ = [input_[:, :, :r, :], tem, input_[:, :, -r:, :]]
-        input_ = paddle.concat(input_, axis=2)
-
-        c = input.shape[1]
-        kernel_x = paddle.concat([kernel.unsqueeze((0, 1))] * c, axis=0)
-        output = F.conv2d(input_, kernel_x, padding=0, groups=c)
-        kernel_y = paddle.concat([kernel.t().unsqueeze((0, 1))] * c, axis=0)
-        output = F.conv2d(output, kernel_y, padding=0, groups=c)
-        return output
-
-    def forward(self, logit, labels):
-        # import pdb; pdb.set_trace()
-        n, c, h, w = logit.shape
-        th = 1e-8
-        eps = 1e-10
-        if len(labels.shape) == 3:
-            labels = labels.unsqueeze(1)
-        mask = (labels != self.ignore_index)
-        mask.stop_gradient = True
-        logit = logit * mask
-
-        labels = labels * mask
-        if len(labels.shape) == 4:
-            labels = labels.squeeze(1)
-        labels.stop_gradient = True
-        labels = F.one_hot(labels, logit.shape[1]).transpose((0, 3, 1, 2))
-        labels.stop_gradient = True
-
-        g = self._gumbel_softmax_sample(logit, tau=self.tau)
-        g = self.compute_grad_mag(g)
-        g_hat = self.compute_grad_mag(labels)
-        loss = F.l1_loss(g, g_hat, reduction='none')
-        loss = loss * mask
-
-        g_mask = (g > th).astype('float32')
-        g_mask.stop_gradient = True
-        g_mask_sum = paddle.sum(g_mask)
-        loss_g = paddle.sum(loss * g_mask)
-        if g_mask_sum > eps:
-            loss_g = loss_g / g_mask_sum
-
-        g_hat_mask = (g_hat > th).astype('float32')
-        g_hat_mask.stop_gradient = True
-        g_hat_mask_sum = paddle.sum(g_hat_mask)
-        loss_g_hat = paddle.sum(loss * g_hat_mask)
-        if g_hat_mask_sum > eps:
-            loss_g_hat = loss_g_hat / g_hat_mask_sum
-
-        total_loss = 0.5 * loss_g + 0.5 * loss_g_hat
-
-        return total_loss

paddlex/paddleseg/models/losses/l1_loss.py

@@ -1,76 +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 L1Loss(nn.MSELoss):
-    r"""
-    This interface is used to construct a callable object of the ``L1Loss`` class.
-    The L1Loss layer calculates the L1 Loss of ``input`` and ``label`` as follows.
-     If `reduction` set to ``'none'``, the loss is:
-    .. math::
-        Out = \lvert input - label\rvert
-    If `reduction` set to ``'mean'``, the loss is:
-    .. math::
-        Out = MEAN(\lvert input - label\rvert)
-    If `reduction` set to ``'sum'``, the loss is:
-    .. math::
-        Out = SUM(\lvert input - label\rvert)
-
-    Args:
-        reduction (str, optional): Indicate the reduction to apply to the loss,
-            the candicates are ``'none'`` | ``'mean'`` | ``'sum'``.
-            If `reduction` is ``'none'``, the unreduced loss is returned;
-            If `reduction` is ``'mean'``, the reduced mean loss is returned.
-            If `reduction` is ``'sum'``, the reduced sum 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): The input tensor. The shapes is [N, *], where N is batch size and `*` means any number of additional dimensions. It's data type should be float32, float64, int32, int64.
-        label (Tensor): label. The shapes is [N, *], same shape as ``input`` . It's data type should be float32, float64, int32, int64.
-        output (Tensor): The L1 Loss of ``input`` and ``label``.
-            If `reduction` is ``'none'``, the shape of output loss is [N, *], the same as ``input`` .
-            If `reduction` is ``'mean'`` or ``'sum'``, the shape of output loss is [1].
-    Examples:
-        .. code-block:: python
-
-            import paddle
-            import numpy as np
-            input_data = np.array([[1.5, 0.8], [0.2, 1.3]]).astype("float32")
-            label_data = np.array([[1.7, 1], [0.4, 0.5]]).astype("float32")
-            input = paddle.to_tensor(input_data)
-            label = paddle.to_tensor(label_data)
-            l1_loss = paddle.nn.L1Loss()
-            output = l1_loss(input, label)
-            print(output.numpy())
-            # [0.35]
-            l1_loss = paddle.nn.L1Loss(reduction='sum')
-            output = l1_loss(input, label)
-            print(output.numpy())
-            # [1.4]
-            l1_loss = paddle.nn.L1Loss(reduction='none')
-            output = l1_loss(input, label)
-            print(output)
-            # [[0.20000005 0.19999999]
-            # [0.2        0.79999995]]
-    """
-
-    def __init__(self, reduction='mean', ignore_index=255):
-        super().__init__(reduction=reduction)