3j8 SSKJr SSKJr SSKrSSKJr SSKJrJrJ r SSK J r SSK J r SSSjjr"S S \R5rSSS jjr"S S \R5rg)) annotations)OptionalN)nn) KORNIA_CHECKKORNIA_CHECK_IS_TENSORKORNIA_CHECK_SHAPE)mask_ignore_pixels)one_hotc[U/SQ5 URS4URSS-n[URSURS:H=(a URSSURSS:HSUSUR35 [URUR:HSURS UR35 [ X5up[ XRSURUR S 9n UbURS5 X-n URS5n [R"S U R5- U5*U -U -n URSn S /S/[URSS5--n UbM[R"SU- /U/U S- --U R U RS 9nURU 5nX-n Ub[US5 [URSU :H=(a UR!5U :HSU SUR35 [URUR:HSURS UR35 URU 5nX[-n US:XaU nU$US:Xa[R""U 5nU$US:Xa[R$"U 5nU$['SU35e)avCriterion 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 torch.Tensor with shape :math:`(N, C, *)` where C = number of classes. target: labels torch.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?)rr$weight must be torch.Tensor or None.)weight shape must be (num_of_classes,): (,), got 1weight and pred must be in the same device. Got: nonemeansumInvalid reduction mode: )rshaperrr r r unsqueeze_ log_softmaxtorchpowexplentensorviewrnumelr r!NotImplementedError)predtargetalphagamma reductionweight ignore_indexout_size target_masktarget_one_hot log_pred_softloss_tmpnum_of_classesbroadcast_dims alpha_faclosss M/home/wildlama/miniconda3/lib/python3.13/site-packages/kornia/losses/focal.py focal_lossr?!s\t_- 1 $**QR.0H A&,,q/ ) Pfll12.>$**QR..P z ~> v}}$ ;DKK=fmm_] -VBF$+6zz!}UYU`U`hlhrhr#sNq!'5#'"2"21"5M$iim.?.?.A(A5IIMY\jjHZZ]NTQC#djjn"555N LL YK5'^a%78 8W_WfWf NN>2 ' v'MN \\!_ . S6<<>^3S77GxPVP\P\~ ^   MMT[[ (? eTXT_T_S` a ^,$F K f zz(# K e yy" K"$= 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() c^>[TU]5 XlX lX0lX@lXPlgN)super__init__r0r1r2r3r4)selfr0r1r2r3r4 __class__s r>rGFocalLoss.__init__s* &+ ! '.4 +7r@c [XURURURURUR 5$rE)r?r0r1r2r3r4rHr.r/s r>forwardFocalLoss.forwards1$ DJJPTP[P[]a]n]noor@)r0r1r4r2r3@rN) r0Optional[float]r1floatr2strr3Optional[torch.Tensor]r4 Optional[int]returnNoner. torch.Tensorr/rZrWrZ __name__ __module__ __qualname____firstlineno____doc__rGrM__static_attributes__ __classcell__rIs@r>rBrBsg$R)-&* 8 8 8 8 ' 8 $ 8  8 8ppr@rBc&[U/SQ5 [URUR:HSURSUR35 [URUR:HSURSUR35 [R R U5n[R R U*5n [X5upU bX-n X-nU R5RU5*U-U-n UR5RU5*SU- -U -n Ub X+-n SU- U -n URSn S /S/[URS S5--nUb[US 5 [URS U :H=(a UR5U :HS U SUR35 [URUR:HSURSUR35 URU5nX[-n X-nUb[US5 [URS U :H=(a UR5U :HSU SUR35 [URUR:HSURSUR35 URU5nXo-nUS:XaUnU$US:Xa[R"U5nU$US:Xa[R "U5nU$[#SU35e)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 torch.Tensor with shape :math:`(N, C, *)` where C = number of classes. target: labels torch.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() r rrrrNrrrrz(pos_weight must be torch.Tensor or None.rz-pos_weight shape must be (num_of_classes,): (rz5pos_weight and pred must be in the same device. Got: rrrrr r!r")rrr#rr functional logsigmoidr r(r'r)rr,r+r&r r!r-)r.r/r0r1r2 pos_weightr3r4 log_probs_pos log_probs_negr6pos_termneg_termr:r;r9r=s r>binary_focal_loss_with_logitsrlsbt_-v||+/DTZZLPVW]WcWcVd-ef v}}$ ;DKK=fmm_] #%--":":4"@M"$--":":D5"AM,VBF%3 %3 +//155e<^3S77GxPVP\P\~ ^   MMT[[ (? eTXT_T_S` a ^,$F K f zz(# K e yy" K"$= 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() cj>[TU]5 XlX lX0lX@lXPlX`lgrE)rFrGr0r1r2rgr3r4)rHr0r1r2rgr3r4rIs r>rG"BinaryFocalLossWithLogits.__init__as/ &+ ! '2<.4 +7r@c [XURURURURUR UR 5$rE)rlr0r1r2rgr3r4rLs r>rM!BinaryFocalLossWithLogits.forwardrs<, $**djj$..$//SWS^S^`d`q`q  r@)r0r1r4rgr2r3)rPrNNrQ)r0rRr1rSr2rTrgrUr3rUr4rVrWrXrYr[rcs@r>rnrn8sr&V-1)-&*888 8 + 8 ' 8$8 88"  r@rnrO)r.rZr/rZr0rRr1rSr2rTr3rUr4rVrWrZ)g?rPrNNrQ)r.rZr/rZr0rRr1rSr2rTrgrUr3rUr4rVrWrZ) __future__rtypingrr&rkornia.core.checkrrrkornia.losses._utilsr kornia.losses.one_hotr r?ModulerBrlrnr@r>rzs%$# VV3)%)"&h h h h  h  h # h hhV7p 7pz")-%)"&o o o o  o  o ' o #o ood=  = r@