o oi@sfddlmZddlmZddlZddlmZmZddlmZm Z m Z ddd d Z Gdddej Z dS)) annotations)OptionalN)Tensornn) KORNIA_CHECKKORNIA_CHECK_IS_TENSORKORNIA_CHECK_SHAPEpredrtargetweightOptional[Tensor]returncCsdt|gdt|gd|jddkstd|j|jdd|jddks7td|jd|j|j|jksItd |jd|j|jd}|durt|d t|jd |kod||kd |d |jt|j|jkd|jd|j||jd |jdd}||jd d}|j\}}}|d} t j j j | t j|dd dd |j} | | } t j| ddd\} } t j||jddd|||}||| f}|jddd}||d}|d|d}d||}|dkr|dddf|dddf|dddf<| |}|dd }|dur,||9}|}|S)unCriterion that computes a surrogate multi-class intersection-over-union (IoU) loss. According to [1], we compute the IoU as follows: .. math:: \text{IoU}(x, class) = \frac{|X \cap Y|}{|X \cup Y|} [1] approximates this fomular with a surrogate, which is fully differentable. Where: - :math:`X` expects to be the scores of each class. - :math:`Y` expects to be the long tensor with the class labels. the loss, is finally computed as: .. math:: \text{loss}(x, class) = 1 - \text{IoU}(x, class) Reference: [1] https://arxiv.org/pdf/1705.08790.pdf .. note:: This loss function only supports multi-class (C > 1) labels. For binary labels please use the Lovasz-Hinge loss. Args: pred: logits tensor with shape :math:`(N, C, H, W)` where C = number of classes > 1. target: labels tensor with shape :math:`(N, H, W)` where each value is :math:`0 ≤ targets[i] ≤ C-1`. weight: weights for classes with shape :math:`(num\_of\_classes,)`. Return: a scalar with the computed loss. Example: >>> N = 5 # num_classes >>> pred = torch.randn(1, N, 3, 5, requires_grad=True) >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N) >>> output = lovasz_softmax_loss(pred, target) >>> output.backward() )BNHW)rrrz8Invalid pred shape, we expect BxNxHxW, with N > 1. Got: Nz.pred and target shapes must be the same. Got: z and z1pred and target must be in the same device. Got: zweight must be Tensor or None.rz)weight shape must be (num_of_classes,): (z,), got z1weight and pred must be in the same device. Got: ) num_classesT)dim descending)device)keepdimg?.)rshape ValueErrorrrrnumelreshapesoftmaxtorchr functionalone_hottoint64permutedtypeabssortarange unsqueezeexpandsumcumsummean)r r r num_of_classes pred_flattentarget_flattenrCr pred_soft foregrounderrors errors_sorted permutations batch_index target_sortedtarget_sorted_sum intersectionuniongradientweighted_errorsloss_per_class final_lossrAP/home/ubuntu/.local/lib/python3.10/site-packages/kornia/losses/lovasz_softmax.pylovasz_softmax_losssR-      * &   , rCcs.eZdZdZddfdd Zdd d ZZS)LovaszSoftmaxLossuCriterion that computes a surrogate multi-class intersection-over-union (IoU) loss. According to [1], we compute the IoU as follows: .. math:: \text{IoU}(x, class) = \frac{|X \cap Y|}{|X \cup Y|} [1] approximates this fomular with a surrogate, which is fully differentable. Where: - :math:`X` expects to be the scores of each class. - :math:`Y` expects to be the binary tensor with the class labels. the loss, is finally computed as: .. math:: \text{loss}(x, class) = 1 - \text{IoU}(x, class) Reference: [1] https://arxiv.org/pdf/1705.08790.pdf .. note:: This loss function only supports multi-class (C > 1) labels. For binary labels please use the Lovasz-Hinge loss. Args: pred: logits tensor with shape :math:`(N, C, H, W)` where C = number of classes > 1. labels: labels tensor with shape :math:`(N, H, W)` where each value is :math:`0 ≤ targets[i] ≤ C-1`. weight: weights for classes with shape :math:`(num\_of\_classes,)`. Return: a scalar with the computed loss. Example: >>> N = 5 # num_classes >>> criterion = LovaszSoftmaxLoss() >>> pred = torch.randn(1, N, 3, 5, requires_grad=True) >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N) >>> output = criterion(pred, target) >>> output.backward() Nr r r Nonecst||_dSN)super__init__r )selfr  __class__rArBrHs  zLovaszSoftmaxLoss.__init__r rr cCst|||jdS)N)r r r )rCr )rIr r rArArBforwardszLovaszSoftmaxLoss.forwardrF)r r r rE)r rr rr r)__name__ __module__ __qualname____doc__rHrL __classcell__rArArJrBrDs.rDrF)r rr rr r r r) __future__rtypingrr rrkornia.core.checkrrrrCModulerDrArArArBs   g