o oi*7@sddlmZddlmZddlZddlmZddlmZmZddl m Z m Z m Z ddl mZddlmZ  d$d%ddZGdddejZ    d&d'd d!ZGd"d#d#ejZdS)() annotations)OptionalN)nn)Tensortensor) KORNIA_CHECKKORNIA_CHECK_IS_TENSORKORNIA_CHECK_SHAPE)mask_ignore_pixels)one_hot@nonepredrtargetalphaOptional[float]gammafloat reductionstrweightOptional[Tensor] ignore_index Optional[int]returncCs t|gd|jdf|jdd}t|jd|jdko,|jdd|jddkd|d|jt|j|jkd|jd |jt||\}}t||jd|j|jd } |durh|d| |} |d} t d | | | | } |jd} d gdgt |jdd} |durt d|g|g| d| j| jd }|| }|| } |durt|dt|jd| ko|| kd| d|jt|j|jkd|jd |j|| }|| } |dkr| }|S|dkrt | }|S|dkr t | }|Std|)aCriterion that computes Focal loss. According to :cite:`lin2018focal`, the Focal loss is computed as follows: .. math:: \text{FL}(p_t) = -\alpha_t (1 - p_t)^{\gamma} \, \text{log}(p_t) Where: - :math:`p_t` is the model's estimated probability for each class. Args: pred: logits tensor with shape :math:`(N, C, *)` where C = number of classes. target: labels tensor with shape :math:`(N, *)` where each value is an integer representing correct classification :math:`target[i] \in [0, C)`. alpha: Weighting factor :math:`\alpha \in [0, 1]`. gamma: Focusing parameter :math:`\gamma >= 0`. reduction: Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be applied, ``'mean'``: the sum of the output will be divided by the number of elements in the output, ``'sum'``: the output will be summed. weight: weights for classes with shape :math:`(num\_of\_classes,)`. ignore_index: labels with this value are ignored in the loss computation. Return: the computed loss. Example: >>> C = 5 # num_classes >>> pred = torch.randn(1, C, 3, 5, requires_grad=True) >>> target = torch.randint(C, (1, 3, 5)) >>> kwargs = {"alpha": 0.5, "gamma": 2.0, "reduction": 'mean'} >>> output = focal_loss(pred, target, **kwargs) >>> output.backward() BC*rNExpected target size , got 1pred and target must be in the same device. Got:  and ) num_classesdevicedtype?)r(r'weight must be Tensor or None.)weight shape must be (num_of_classes,): (,), got 1weight and pred must be in the same device. Got: r meansumInvalid reduction mode: )r shaperr'r r r( unsqueeze_ log_softmaxtorchpowexplenrviewrnumelr/r0NotImplementedError)rrrrrrrout_size target_masktarget_one_hot log_pred_softloss_tmpnum_of_classesbroadcast_dims alpha_faclossrEG/home/ubuntu/.local/lib/python3.10/site-packages/kornia/losses/focal.py focal_loss"sZ..    &      rGcs6eZdZdZ    ddfdd ZdddZZS) FocalLossaCriterion that computes Focal loss. According to :cite:`lin2018focal`, the Focal loss is computed as follows: .. math:: \text{FL}(p_t) = -\alpha_t (1 - p_t)^{\gamma} \, \text{log}(p_t) Where: - :math:`p_t` is the model's estimated probability for each class. Args: alpha: Weighting factor :math:`\alpha \in [0, 1]`. gamma: Focusing parameter :math:`\gamma >= 0`. reduction: Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be applied, ``'mean'``: the sum of the output will be divided by the number of elements in the output, ``'sum'``: the output will be summed. weight: weights for classes with shape :math:`(num\_of\_classes,)`. ignore_index: labels with this value are ignored in the loss computation. Shape: - Pred: :math:`(N, C, *)` where C = number of classes. - Target: :math:`(N, *)` where each value is an integer representing correct classification :math:`target[i] \in [0, C)`. Example: >>> C = 5 # num_classes >>> pred = torch.randn(1, C, 3, 5, requires_grad=True) >>> target = torch.randint(C, (1, 3, 5)) >>> kwargs = {"alpha": 0.5, "gamma": 2.0, "reduction": 'mean'} >>> criterion = FocalLoss(**kwargs) >>> output = criterion(pred, target) >>> output.backward() r r NrrrrrrrrrrrrNonecs,t||_||_||_||_||_dSN)super__init__rrrrr)selfrrrrr __class__rErFrLs  zFocalLoss.__init__rrrcCst|||j|j|j|j|jSrJ)rGrrrrrrMrrrErErFforwardszFocalLoss.forwardr r Nr) rrrrrrrrrrrrIrrrrrr__name__ __module__ __qualname____doc__rLrQ __classcell__rErErNrFrHs)rH? pos_weightcCsJt|gdt|j|jkd|jd|jt|j|jkd|jd|jtj|}tj| } t||\}} | durI| | } || }|  | ||} | | d|| } |durq|| } d|| } |jd} d gdgt |jd d}|durt |d t|jd | ko| | kd | d|jt|j|jkd|jd|j| |}|| } | | }|durt |dt|jd | ko| | kd| d|jt|j|jkd|jd|j| |}||}|dkr|}|S|dkrt|}|S|dkrt|}|Std|)aCriterion that computes Binary Focal loss. According to :cite:`lin2018focal`, the Focal loss is computed as follows: .. math:: \text{FL}(p_t) = -\alpha_t (1 - p_t)^{\gamma} \, \text{log}(p_t) where: - :math:`p_t` is the model's estimated probability for each class. Args: pred: logits tensor with shape :math:`(N, C, *)` where C = number of classes. target: labels tensor with the same shape as pred :math:`(N, C, *)` where each value is between 0 and 1. alpha: Weighting factor :math:`\alpha \in [0, 1]`. gamma: Focusing parameter :math:`\gamma >= 0`. reduction: Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be applied, ``'mean'``: the sum of the output will be divided by the number of elements in the output, ``'sum'``: the output will be summed. pos_weight: a weight of positive examples with shape :math:`(num\_of\_classes,)`. It is possible to trade off recall and precision by adding weights to positive examples. weight: weights for classes with shape :math:`(num\_of\_classes,)`. ignore_index: labels with this value are ignored in the loss computation. Returns: the computed loss. Examples: >>> C = 3 # num_classes >>> pred = torch.randn(1, C, 5, requires_grad=True) >>> target = torch.randint(2, (1, C, 5)) >>> kwargs = {"alpha": 0.25, "gamma": 2.0, "reduction": 'mean'} >>> output = binary_focal_loss_with_logits(pred, target, **kwargs) >>> output.backward() rr"r#r$r%Nr)r!r*r z"pos_weight must be Tensor or None.rz-pos_weight shape must be (num_of_classes,): (r-z5pos_weight and pred must be in the same device. Got: r+r,r.r r/r0r1)r rr2r'r functional logsigmoidr r7r6r8rr:r9r5r/r0r;)rrrrrr[rr log_probs_pos log_probs_negr=pos_termneg_termrArBr@rDrErErFbinary_focal_loss_with_logitssl1"             rbcs8eZdZdZ     ddfdd ZdddZZS)BinaryFocalLossWithLogitsa[Criterion that computes Focal loss. According to :cite:`lin2018focal`, the Focal loss is computed as follows: .. math:: \text{FL}(p_t) = -\alpha_t (1 - p_t)^{\gamma} \, \text{log}(p_t) where: - :math:`p_t` is the model's estimated probability for each class. Args: alpha: Weighting factor :math:`\alpha \in [0, 1]`. gamma: Focusing parameter :math:`\gamma >= 0`. reduction: Specifies the reduction to apply to the output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be applied, ``'mean'``: the sum of the output will be divided by the number of elements in the output, ``'sum'``: the output will be summed. pos_weight: a weight of positive examples with shape :math:`(num\_of\_classes,)`. It is possible to trade off recall and precision by adding weights to positive examples. weight: weights for classes with shape :math:`(num\_of\_classes,)`. ignore_index: labels with this value are ignored in the loss computation. Shape: - Pred: :math:`(N, C, *)` where C = number of classes. - Target: the same shape as Pred :math:`(N, C, *)` where each value is between 0 and 1. Examples: >>> C = 3 # num_classes >>> pred = torch.randn(1, C, 5, requires_grad=True) >>> target = torch.randint(2, (1, C, 5)) >>> kwargs = {"alpha": 0.25, "gamma": 2.0, "reduction": 'mean'} >>> criterion = BinaryFocalLossWithLogits(**kwargs) >>> output = criterion(pred, target) >>> output.backward() r r Nrrrrrrrr[rrrrrrIcs2t||_||_||_||_||_||_dSrJ)rKrLrrrr[rr)rMrrrr[rrrNrErFrL`s  z"BinaryFocalLossWithLogits.__init__rrrc Cs"t|||j|j|j|j|j|jSrJ)rbrrrr[rrrPrErErFrQqsz!BinaryFocalLossWithLogits.forward)r r NNr)rrrrrrr[rrrrrrrIrSrTrErErNrFrc7s+rcrR)rrrrrrrrrrrrrrrr)rZr r NNr)rrrrrrrrrrr[rrrrrrr) __future__rtypingrr5r kornia.corerrkornia.core.checkrrr kornia.losses._utilsr kornia.utils.one_hotr rGModulerHrbrcrErErErFs,       i= r