a d( @sddlZddlmZddlZddlmZddlmZddlm Z m Z m Z ddl m Z deeeeeeeedd d ZGd d d ejZdeeeeeeeeeedddZGdddejZdS)N)Optional)Tensor) KORNIA_CHECKKORNIA_CHECK_IS_TENSORKORNIA_CHECK_SHAPE)one_hot@none)inputtargetalphagamma reductionepsreturncCsN|dur"tjs"tjdtddt|gd|jd}|f|jdd}t|jdd|jddkd|d | t|j |j kd |j d |j | d}| d} t ||jd|j |jd } t| d |} | | | } td| | f} |dkr| }n:|dkr&t| }n$|dkr= 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. eps: Deprecated: scalar to enforce numerical stabiliy. This is no longer used. Return: the computed loss. Example: >>> N = 5 # num_classes >>> input = torch.randn(1, N, 3, 5, requires_grad=True) >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N) >>> output = focal_loss(input, target, alpha=0.5, gamma=2.0, reduction='mean') >>> output.backward() Nzm`focal_loss` has been reworked for improved numerical stability and the `eps` argument is no longer necessary stacklevelBC*rzExpected target size z, got z2input and target must be in the same device. Got: z and )Z num_classesdevicedtype?zbc...,bc...->b...r meansumInvalid reduction mode: )torchjit is_scriptingwarningswarnDeprecationWarningrshapersizerZsoftmaxZ log_softmaxrrpowZeinsumrrNotImplementedError)r r r r rrnZout_sizeZ input_softZlog_input_softZtarget_one_hotZweightZfocalloss_tmplossr,\/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/kornia/losses/focal.py focal_losss8) 2        r.csFeZdZdZd eeeeeddfdd Zeeedd d Z Z S) FocalLossudCriterion 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. eps: Deprecated: scalar to enforce numerical stability. This is no longer used. Shape: - Input: :math:`(N, C, *)` where C = number of classes. - Target: :math:`(N, *)` where each value is :math:`0 ≤ targets[i] ≤ C−1`. Example: >>> N = 5 # num_classes >>> kwargs = {"alpha": 0.5, "gamma": 2.0, "reduction": 'mean'} >>> criterion = FocalLoss(**kwargs) >>> input = torch.randn(1, N, 3, 5, requires_grad=True) >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N) >>> output = criterion(input, target) >>> output.backward() rr N)r r rrrcs&t||_||_||_||_dSN)super__init__r r rr)selfr r rr __class__r,r-r2s  zFocalLoss.__init__r r rcCst|||j|j|j|jSr0)r.r r rrr3r r r,r,r-forwardszFocalLoss.forward)rr N) __name__ __module__ __qualname____doc__floatstrrr2rr8 __classcell__r,r,r4r-r/cs% r/?)r r r r rr pos_weightrc CsX|dur"tjs"tjdtddt|gdt|jd|jdkd|jdd|jdd |durtj |jd |j |j d }t |t|jd |jdkd | }t | }| ||||| d |t||d|| } |dkr| } n:|dkr0t| } n$|dkrFt| } ntd|| S)uFunction that computes Binary Focal loss. .. 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: input: input data tensor of arbitrary shape. target: the target tensor with shape matching input. alpha: Weighting factor for the rare class :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. eps: Deprecated: scalar for numerically stability when dividing. This is no longer used. pos_weight: a weight of positive examples. It’s possible to trade off recall and precision by adding weights to positive examples. Must be a vector with length equal to the number of classes. Returns: the computed loss. Examples: >>> kwargs = {"alpha": 0.25, "gamma": 2.0, "reduction": 'mean'} >>> logits = torch.tensor([[[6.325]],[[5.26]],[[87.49]]]) >>> labels = torch.tensor([[[1.]],[[1.]],[[0.]]]) >>> binary_focal_loss_with_logits(logits, labels, **kwargs) tensor(21.8725) Nz`binary_focal_loss_with_logits` has been reworked for improved numerical stability and the `eps` argument is no longer necessaryrrrrzExpected input batch_size (z) to match target batch_size (z).)rrz-Expected pos_weight equals number of classes.rrr rrr)rr r!r"r#r$rrr%ZonesrrrZsigmoidr'logrrr() r r r r rrrAZ probs_posZ probs_negr*r+r,r,r-binary_focal_loss_with_logitss:, "(     rDcsFeZdZdZd eeeeeddfdd Zeeedd d Z Z S) BinaryFocalLossWithLogitsuwCriterion 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 for the rare class :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. It’s possible to trade off recall and precision by adding weights to positive examples. Must be a vector with length equal to the number of classes. Shape: - Input: :math:`(N, *)`. - Target: :math:`(N, *)`. Examples: >>> kwargs = {"alpha": 0.25, "gamma": 2.0, "reduction": 'mean'} >>> loss = BinaryFocalLossWithLogits(**kwargs) >>> input = torch.randn(1, 3, 5, requires_grad=True) >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(2) >>> output = loss(input, target) >>> output.backward() rr N)r r rrArcs&t||_||_||_||_dSr0)r1r2r r rrA)r3r r rrAr4r,r-r2 s  z"BinaryFocalLossWithLogits.__init__r6cCst|||j|j|j|jdS)N)rA)rDr r rrAr7r,r,r-r8sz!BinaryFocalLossWithLogits.forward)rr N) r9r:r;r<r=r>rrr2r8r?r,r,r4r-rEs%  rE)rr N)r@rr NN)r"typingrrZtorch.nnnnZ kornia.corerZkornia.testingrrrZkornia.utils.one_hotrr=r>r.Moduler/rDrEr,r,r,r-sF     T4 S