a d#@s`ddlmZddlZddlmZddlmZddlmZeeedddZGdd d ej Z dS) )ListN)Tensor)KORNIA_CHECK_SHAPEpredtargetreturncCst|gdt|gd|jddks:td|j|jdd|jddksntd|jd|j|j|jkstd |jd|j||jd |jdd }||jd d }|j\}}}|d}g}tj||jd d d d|d } t |D]} d || k} |dd| f} | |  } tj | ddd\}}|| | d f}| ||}|jddd}||d}|d |d}d ||}|dkr|dddf|ddd f|dddf<||d}||q tj|d d}|S)u$Criterion 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`. 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)r r r z8Invalid 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: r)deviceg?T)dimZ descending)Zkeepdim.)r)rshape ValueErrorrZreshapefloatZsoftmaxtorchZarangerepeatrangeabssortviewsumZcumsumZrelumeanappendstack)rrZ pred_flattenZtarget_flattenr Cr Z pred_softZlossesZ batch_indexcZ foregroundZ class_prederrorsZ errors_sortedZ permutationZ target_sortedZtarget_sorted_sum intersectionunionZgradientZlossZ final_lossr$e/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/kornia/losses/lovasz_softmax.pylovasz_softmax_loss s>+   &      ,r&cs8eZdZdZddfdd ZeeedddZZS) LovaszSoftmaxLossuFCriterion 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`. 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() N)rcstdS)N)super__init__)self __class__r$r%r)szLovaszSoftmaxLoss.__init__rcCs t||dS)N)rr)r&)r*rrr$r$r%forwardszLovaszSoftmaxLoss.forward)__name__ __module__ __qualname____doc__r)rr- __classcell__r$r$r+r%r'es,r') typingrrZtorch.nnnnrZkornia.testingrr&Moduler'r$r$r$r%s    X