§
    l¬¸jä ã                  ób  — d dl mZ d dlZd dlmZ d dlmZ d dlZd dlm	c m
Z d dlm	Z	 d dlmZmZmZ d dlmZmZmZ d dlmZmZmZmZmZ d d	lmZ d
dlmZmZ d
dlm Z m!Z!  G d„ de	j"        ¦  «        Z# G d„ de	j"        ¦  «        Z$ G d„ de	j"        ¦  «        Z% G d„ de	j"        ¦  «        Z& G d„ de	j"        ¦  «        Z' G d„ de&¦  «        Z( G d„ de	j"        ¦  «        Z) G d„ de	j"        ¦  «        Z* G d„ de	j"        ¦  «        Z+ G d„ d ¦  «        Z, G d!„ d"e,¦  «        Z- G d#„ d$e,¦  «        Z. G d%„ d&e.¦  «        Z/ G d'„ d(¦  «        Z0 G d)„ d*e,¦  «        Z1 G d+„ d,¦  «        Z2 G d-„ d.¦  «        Z3 G d/„ d0¦  «        Z4 G d1„ d2¦  «        Z5 G d3„ d4e5¦  «        Z6 G d5„ d6e	j"        ¦  «        Z7dS )7é    )ÚannotationsN)ÚPath)ÚAny)Únn)ÚCITYSCAPES_WEIGHTÚ	OKS_SIGMAÚ
RLE_WEIGHT)Ú	crop_maskÚ	xywh2xyxyÚ	xyxy2xywh)ÚRotatedTaskAlignedAssignerÚTaskAlignedAssignerÚ	dist2bboxÚ	dist2rboxÚmake_anchors)Úautocasté   )Úbbox_iouÚprobiou)Ú	bbox2distÚ	rbox2distc                  ó.   ‡ — e Zd ZdZddˆ fd„Zdd„Zˆ xZS )ÚVarifocalLossaä  Varifocal loss by Zhang et al.

    Implements the Varifocal Loss function for addressing class imbalance in object detection by focusing on
    hard-to-classify examples and balancing positive/negative samples.

    Attributes:
        gamma (float): The focusing parameter that controls how much the loss focuses on hard-to-classify examples.
        alpha (float): The balancing factor used to address class imbalance.

    References:
        https://arxiv.org/abs/2008.13367
    ç       @ç      è?ÚgammaÚfloatÚalphac                ód   •— t          ¦   «                              ¦   «          || _        || _        dS )zJInitialize the VarifocalLoss class with focusing and balancing parameters.N)ÚsuperÚ__init__r   r   ©Úselfr   r   Ú	__class__s      €úf/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/ultralytics/utils/loss.pyr!   zVarifocalLoss.__init__$   s+   ø€ å‰Œ×ÒÑÔÐØˆŒ
ØˆŒ
ˆ
ˆ
ó    Ú
pred_scoreútorch.TensorÚgt_scoreÚlabelÚreturnc                ó²  — | j         |                     ¦   «                              | j        ¦  «        z  d|z
  z  ||z  z   }t	          d|j        j        ¬¦  «        5  t          j        | 	                    ¦   «         | 	                    ¦   «         d¬¦  «        |z   
                    d¦  «                             ¦   «         }ddd¦  «         n# 1 swxY w Y   |S )z<Compute varifocal loss between predictions and ground truth.r   F)ÚenabledÚdeviceÚnone©Ú	reductionN)r   ÚsigmoidÚpowr   r   r.   ÚtypeÚFÚ binary_cross_entropy_with_logitsr   ÚmeanÚsum)r#   r'   r)   r*   ÚweightÚlosss         r%   ÚforwardzVarifocalLoss.forward*   sÿ   € à”˜j×0Ò0Ñ2Ô2×6Ò6°t´zÑBÔBÑBÀaÈ%ÁiÑPÐS[Ð^cÑScÑcˆÝ˜e¨JÔ,=Ô,BÐCÑCÔCð 	ð 	åÔ3°J×4DÒ4DÑ4FÔ4FÈÏÊÑHXÔHXÐdjÐkÑkÔkÐntÑtß’�a‘”ß’‘”ð ð	ð 	ð 	ñ 	ô 	ð 	ð 	ð 	ð 	ð 	ð 	øøøð 	ð 	ð 	ð 	ð ˆs   ÁA$CÃCÃC)r   r   ©r   r   r   r   )r'   r(   r)   r(   r*   r(   r+   r(   ©Ú__name__Ú
__module__Ú__qualname__Ú__doc__r!   r;   Ú__classcell__©r$   s   @r%   r   r      s`   ø€ € € € € ðð ðð ð ð ð ð ð ð	ð 	ð 	ð 	ð 	ð 	ð 	ð 	r&   r   c                  ó.   ‡ — e Zd ZdZddˆ fd„Zdd„Zˆ xZS )Ú	FocalLossaã  Wraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5).

    Implements the Focal Loss function for addressing class imbalance by down-weighting easy examples and focusing on
    hard negatives during training.

    Attributes:
        gamma (float): The focusing parameter that controls how much the loss focuses on hard-to-classify examples.
        alpha (torch.Tensor): The balancing factor used to address class imbalance.
    ç      ø?ç      Ð?r   r   r   c                óˆ   •— t          ¦   «                              ¦   «          || _        t          j        |¦  «        | _        dS )zBInitialize FocalLoss class with focusing and balancing parameters.N)r    r!   r   ÚtorchÚtensorr   r"   s      €r%   r!   zFocalLoss.__init__A   s5   ø€ å‰Œ×ÒÑÔÐØˆŒ
Ý”\ %Ñ(Ô(ˆŒ
ˆ
ˆ
r&   Úpredr(   r*   r+   c                ó¼  — t          j        ||d¬¦  «        }|                     ¦   «         }||z  d|z
  d|z
  z  z   }d|z
  | j        z  }||z  }| j        dk                         ¦   «         rK| j                             |j        |j        ¬¦  «        | _        || j        z  d|z
  d| j        z
  z  z   }||z  }| 	                    d¦  «         
                    ¦   «         S )zACalculate focal loss with modulating factors for class imbalance.r/   r0   r   ç      ð?r   ©r.   Údtype)r5   r6   r2   r   r   ÚanyÚtor.   rO   r7   r8   )r#   rK   r*   r:   Ú	pred_probÚp_tÚmodulating_factorÚalpha_factors           r%   r;   zFocalLoss.forwardG   sÝ   € åÔ1°$¸ÈÐPÑPÔPˆð
 —L’L‘N”Nˆ	Ø�iÑ 1 u¡9°°Y±Ñ"?Ñ?ˆØ  3™Y¨4¬:Ñ5ÐØÐ!Ñ!ˆØŒJ˜ŠN×ÒÑ!Ô!ð 	!ØœŸš¨d¬kÀÄ˜ÑLÔLˆDŒJØ  4¤:Ñ-°°U±¸qÀ4Ä:¹~Ñ0NÑNˆLØ�LÑ ˆDØ�yŠy˜‰|Œ|×ÒÑ!Ô!Ð!r&   )rF   rG   r<   )rK   r(   r*   r(   r+   r(   r=   rC   s   @r%   rE   rE   6   s`   ø€ € € € € ðð ð)ð )ð )ð )ð )ð )ð )ð"ð "ð "ð "ð "ð "ð "ð "r&   rE   c                  ó.   ‡ — e Zd ZdZddˆ fd„Zdd„Zˆ xZS )ÚDFLossz<Criterion class for computing Distribution Focal Loss (DFL).é   Úreg_maxÚintr+   ÚNonec                óV   •— t          ¦   «                              ¦   «          || _        dS )z6Initialize the DFL module with regularization maximum.N)r    r!   rY   ©r#   rY   r$   s     €r%   r!   zDFLoss.__init__\   s$   ø€ å‰Œ×ÒÑÔÐØˆŒˆˆr&   Ú	pred_distr(   Útargetc                óø  — |                      d| j        dz
  dz
  ¦  «        }|                     ¦   «         }|dz   }||z
  }d|z
  }t          j        |d¬¦  «        }|                     d|                     dd¦  «        ¦  «                             |j        ¦  «        |z  |                     d|                     dd¦  «        ¦  «                             |j        ¦  «        |z  z                        dd¬¦  «         S )zNReturn sum of left and right DFL losses from https://arxiv.org/abs/2006.04388.r   r   ç{®Gáz„?©ÚdiméÿÿÿÿT©Úkeepdim)	Úclamp_rY   Úlongr5   Úlog_softmaxÚgatherÚviewÚshaper7   )r#   r^   r_   ÚtlÚtrÚwlÚwrÚlogps           r%   Ú__call__zDFLoss.__call__a   sè   € à—’˜q $¤,°Ñ"2°TÑ"9Ñ:Ô:ˆØ�[Š[‰]Œ]ˆØ�!‰VˆØ�&‰[ˆØ�‰VˆåŒ}˜Y¨AÐ.Ñ.Ô.ˆà�KŠK˜˜2Ÿ7š7 2 q™>œ>Ñ*Ô*×/Ò/°´Ñ9Ô9¸BÑ>ÀÇÂÈQÐPR×PWÒPWÐXZÐ\]ÑP^ÔP^ÑA_ÔA_×AdÒAdÐegÔemÑAnÔAnÐqsÑAsÑsß
Š$ˆr˜4ˆ$Ñ
 Ô
 ð!ð 	!r&   ©rX   )rY   rZ   r+   r[   )r^   r(   r_   r(   r+   r(   )r>   r?   r@   rA   r!   rr   rB   rC   s   @r%   rW   rW   Y   s\   ø€ € € € € ØFÐFðð ð ð ð ð ð ð
!ð !ð !ð !ð !ð !ð !ð !r&   rW   c                  ó.   ‡ — e Zd ZdZddˆ fd„Zdd„Zˆ xZS )ÚBboxLosszACriterion class for computing training losses for bounding boxes.rX   rY   rZ   c                ó€   •— t          ¦   «                              ¦   «          |dk    rt          |¦  «        nd| _        dS )zLInitialize the BboxLoss module with regularization maximum and DFL settings.r   N)r    r!   rW   Údfl_lossr]   s     €r%   r!   zBboxLoss.__init__r   s6   ø€ å‰Œ×ÒÑÔÐØ+2°Qª;¨;�˜w™œ˜¸DˆŒˆˆr&   r^   r(   Úpred_bboxesÚanchor_pointsÚtarget_bboxesÚtarget_scoresÚtarget_scores_sumÚfg_maskÚimgszÚstrider+   ú!tuple[torch.Tensor, torch.Tensor]c
                ó˜  — |                      d¬¦  «        }||                              dd¬¦  «        }
t          ||         ||         dd¬¦  «        }d|z
  |
z                       ¦   «         |z  }| j        ryt	          ||| j        j        dz
  ¦  «        }|                      ||                              d| j        j        ¦  «        ||         ¦  «        |
z  }|                     ¦   «         |z  }nØt	          ||¦  «        }||	z  }|d	d
dd…fxx         |d         z  cc<   |d	ddd…fxx         |d
         z  cc<   ||	z  }|d	d
dd…fxx         |d         z  cc<   |d	ddd…fxx         |d
         z  cc<   t          j        ||         ||         d¬¦  «         	                    dd¬¦  «        |
z  }|                     ¦   «         |z  }||fS )z.Compute IoU and DFL losses for bounding boxes.T)Úas_tuplerd   re   F)ÚxywhÚCIoUrM   r   .r   Né   r/   r0   )
Únonzeror8   r   rw   r   rY   rk   r5   Úl1_lossr7   ©r#   r^   rx   ry   rz   r{   r|   r}   r~   r   r9   ÚiouÚloss_iouÚtarget_ltrbÚloss_dfls                  r%   r;   zBboxLoss.forwardw   s  € ð —/’/¨4�/Ñ0Ô0ˆØ˜wÔ'×+Ò+¨B¸Ð+Ñ=Ô=ˆÝ�{ 7Ô+¨]¸7Ô-CÈ%ÐVZÐ[Ñ[Ô[ˆØ˜3‘Y &Ñ(×-Ò-Ñ/Ô/Ð2CÑCˆð Œ=ð 	:Ý# M°=À$Ä-ÔBWÐZ[ÑB[Ñ\Ô\ˆKØ—}’} Y¨wÔ%7×%<Ò%<¸RÀÄÔAVÑ%WÔ%WÐYdÐelÔYmÑnÔnÐqwÑwˆHØ—|’|‘~”~Ð(9Ñ9ˆHˆHå# M°=ÑAÔAˆKà%¨Ñ.ˆKØ˜˜Q˜T ˜T˜	Ð"Ð"Ô" e¨A¤hÑ.Ð"Ð"Ñ"Ø˜˜Q˜T ˜T˜	Ð"Ð"Ô" e¨A¤hÑ.Ð"Ð"Ñ"Ø! FÑ*ˆIØ�c˜1˜4˜a˜4�iÐ Ð Ô  E¨!¤HÑ,Ð Ð Ñ Ø�c˜1˜4˜a˜4�iÐ Ð Ô  E¨!¤HÑ,Ð Ð Ñ å”	˜) GÔ,¨k¸'Ô.BÈfÐUÑUÔU×ZÒZÐ[]ÐgkÐZÑlÔlÐouÑuð ð  —|’|‘~”~Ð(9Ñ9ˆHà˜Ð!Ð!r&   rs   ©rY   rZ   ©r^   r(   rx   r(   ry   r(   rz   r(   r{   r(   r|   r(   r}   r(   r~   r(   r   r(   r+   r€   r=   rC   s   @r%   ru   ru   o   sc   ø€ € € € € ØKÐKðAð Að Að Að Að Að Að
%"ð %"ð %"ð %"ð %"ð %"ð %"ð %"r&   ru   c                  ó2   ‡ — e Zd ZdZddˆ fd„Z	 ddd„Zˆ xZS )ÚRLELossaÈ  Residual Log-Likelihood Estimation Loss.

    Attributes:
        size_average (bool): Option to average the loss by the batch_size.
        use_target_weight (bool): Option to use weighted loss.
        residual (bool): Option to add L1 loss and let the flow learn the residual error distribution.

    References:
        https://arxiv.org/abs/2107.11291
        https://github.com/open-mmlab/mmpose/blob/main/mmpose/models/losses/regression_loss.py
    TÚuse_target_weightÚboolÚsize_averageÚresidualc                ór   •— t          ¦   «                              ¦   «          || _        || _        || _        dS )aG  Initialize RLELoss with target weight and residual options.

        Args:
            use_target_weight (bool): Whether to use target weights for loss calculation.
            size_average (bool): Whether to average the loss over elements.
            residual (bool): Whether to include residual log-likelihood term.
        N)r    r!   r“   r‘   r”   )r#   r‘   r“   r”   r$   s       €r%   r!   zRLELoss.__init__¬   s6   ø€ õ 	‰Œ×ÒÑÔÐØ(ˆÔØ!2ˆÔØ ˆŒˆˆr&   NÚsigmar(   Úlog_phiÚerrorÚtarget_weightr+   c                óª  — t          j        |¦  «        }||                     d¦  «        z
  }| j        r/|t          j        |dz  ¦  «        t          j        |¦  «        z   z  }| j        r>|€
J d¦   «         ‚|                     ¦   «         dk    r|                     d¦  «        }||z  }| j        r|t          |¦  «        z  }| 	                    ¦   «         S )a&  
        Args:
            sigma (torch.Tensor): Output sigma, shape (N, D).
            log_phi (torch.Tensor): Output log_phi, shape (N).
            error (torch.Tensor): Error, shape (N, D).
            target_weight (torch.Tensor): Weights across different joint types, shape (N).
        r   r…   NzD'target_weight' should not be None when 'use_target_weight' is True.)
rI   ÚlogÚ	unsqueezer”   Úabsr‘   rc   r“   Úlenr8   )r#   r–   r—   r˜   r™   Ú	log_sigmar:   s          r%   r;   zRLELoss.forward¹   sÙ   € õ ”I˜eÑ$Ô$ˆ	Ø˜7×,Ò,¨QÑ/Ô/Ñ/ˆàŒ=ð 	<Ø•E”I˜e a™iÑ(Ô(­5¬9°UÑ+;Ô+;Ñ;Ñ;ˆDàÔ!ð 	"Ø Ð,Ð,Ð.tÑ,Ô,Ð,Ø× Ò Ñ"Ô" aÒ'Ð'Ø -× 7Ò 7¸Ñ :Ô :�Ø�MÑ!ˆDàÔð 	Ø•C˜‘I”IÑˆDà�xŠx‰zŒzÐr&   )TTT)r‘   r’   r“   r’   r”   r’   )N)
r–   r(   r—   r(   r˜   r(   r™   r(   r+   r(   r=   rC   s   @r%   r�   r�   Ÿ   sl   ø€ € € € € ð
ð 
ð!ð !ð !ð !ð !ð !ð !ð nrðð ð ð ð ð ð ð ð r&   r�   c                  ó0   ‡ — e Zd ZdZdZdˆ fd„Zdd„Zˆ xZS )ÚRotatedBboxLosszICriterion class for computing training losses for rotated bounding boxes.ra   rY   rZ   c                óJ   •— t          ¦   «                              |¦  «         dS )zSInitialize the RotatedBboxLoss module with regularization maximum and DFL settings.N)r    r!   r]   s     €r%   r!   zRotatedBboxLoss.__init__Ú   s!   ø€ å‰Œ×Ò˜Ñ!Ô!Ð!Ð!Ð!r&   r^   r(   rx   ry   rz   r{   r|   r}   r~   r   r+   r€   c
                óÊ  — ||                               dd¬¦  «        }
t          ||         ||         | j        ¬¦  «        }d|z
  |
z                        ¦   «         |z  }| j        r�t	          |ddd…f         ||ddd	…f         | j        j        d
z
  ¬¦  «        }|                      ||                              d| j        j        ¦  «        ||         ¦  «        |
z  }|                      ¦   «         |z  }nít	          |ddd…f         ||ddd	…f         ¦  «        }||	z  }|dddd…fxx         |d
         z  cc<   |dd
dd…fxx         |d         z  cc<   ||	z  }|dddd…fxx         |d
         z  cc<   |dd
dd…fxx         |d         z  cc<   t          j        ||         ||         d¬¦  «         	                    dd¬¦  «        |
z  }|                      ¦   «         |z  }||fS )z6Compute IoU and DFL losses for rotated bounding boxes.rd   Tre   )ÚfloorrM   .Né   é   r   )rY   r   r…   r/   r0   )
r8   r   r¤   rw   r   rY   rk   r5   r‡   r7   rˆ   s                  r%   r;   zRotatedBboxLoss.forwardÞ   sL  € ð ˜wÔ'×+Ò+¨B¸Ð+Ñ=Ô=ˆÝ�k 'Ô*¨M¸'Ô,BÈ$Ì*ÐUÑUÔUˆØ˜3‘Y &Ñ(×-Ò-Ñ/Ô/Ð2CÑCˆð Œ=ð 	:Ý#Ø˜c 2 A 2˜gÔ&¨°}ÀSÈ!ÈAÈ#ÀXÔ7NÐX\ÔXeÔXmÐpqÑXqðñ ô ˆKð —}’} Y¨wÔ%7×%<Ò%<¸RÀÄÔAVÑ%WÔ%WÐYdÐelÔYmÑnÔnÐqwÑwˆHØ—|’|‘~”~Ð(9Ñ9ˆHˆHå# M°#°r¸°r°'Ô$:¸MÈ=ÐY\Ð^_Ð`aÐ^aÐYaÔKbÑcÔcˆKØ%¨Ñ.ˆKØ˜˜Q˜T ˜T˜	Ð"Ð"Ô" e¨A¤hÑ.Ð"Ð"Ñ"Ø˜˜Q˜T ˜T˜	Ð"Ð"Ô" e¨A¤hÑ.Ð"Ð"Ñ"Ø! FÑ*ˆIØ�c˜1˜4˜a˜4�iÐ Ð Ô  E¨!¤HÑ,Ð Ð Ñ Ø�c˜1˜4˜a˜4�iÐ Ð Ô  E¨!¤HÑ,Ð Ð Ñ å”	˜) GÔ,¨k¸'Ô.BÈfÐUÑUÔU×ZÒZÐ[]ÐgkÐZÑlÔlÐouÑuð ð  —|’|‘~”~Ð(9Ñ9ˆHà˜Ð!Ð!r&   r�   rŽ   )r>   r?   r@   rA   r¤   r!   r;   rB   rC   s   @r%   r¡   r¡   Õ   s\   ø€ € € € € ØSÐSà€Eð"ð "ð "ð "ð "ð "ð%"ð %"ð %"ð %"ð %"ð %"ð %"ð %"r&   r¡   c                  ó.   ‡ — e Zd ZdZddˆ fd„Zdd„Zˆ xZS )ÚMultiChannelDiceLossz8Criterion class for computing multi-channel Dice losses.ç�íµ ÷Æ°>r7   Úsmoothr   r1   Ústrc                ód   •— t          ¦   «                              ¦   «          || _        || _        dS )zïInitialize MultiChannelDiceLoss with smoothing and reduction options.

        Args:
            smooth (float): Smoothing factor to avoid division by zero.
            reduction (str): Reduction method ('mean', 'sum', or 'none').
        N)r    r!   rª   r1   )r#   rª   r1   r$   s      €r%   r!   zMultiChannelDiceLoss.__init__	  s-   ø€ õ 	‰Œ×ÒÑÔÐØˆŒØ"ˆŒˆˆr&   rK   r(   r_   r+   c                ó  — |                      ¦   «         |                      ¦   «         k    s
J d¦   «         ‚|                     ¦   «         }||z                       d¬¦  «        }|                     d¬¦  «        |                     d¬¦  «        z   }d|z  | j        z   || j        z   z  }d|z
  }|                     d¬¦  «        }| j        dk    r|                     ¦   «         S | j        dk    r|                     ¦   «         S |S )	zBCalculate multi-channel Dice loss between predictions and targets.z-the size of predict and target must be equal.)r…   é   rb   r   rM   r   r7   r8   )Úsizer2   r8   rª   r7   r1   )r#   rK   r_   ÚintersectionÚunionÚdiceÚ	dice_losss          r%   r;   zMultiChannelDiceLoss.forward  sð   € à�yŠy‰{Œ{˜fŸkšk™mœmÒ+Ð+Ð+Ð-\Ñ+Ô+Ð+à�|Š|‰~Œ~ˆØ˜v™×*Ò*¨vÐ*Ñ6Ô6ˆØ—’˜V�Ñ$Ô$ v§z¢z°f zÑ'=Ô'=Ñ=ˆØ�lÑ" T¤[Ñ0°U¸T¼[Ñ5HÑIˆØ˜$‘Jˆ	Ø—N’N q�NÑ)Ô)ˆ	àŒ>˜VÒ#Ð#Ø—>’>Ñ#Ô#Ð#ØŒ^˜uÒ$Ð$Ø—=’=‘?”?Ð"àÐr&   )r©   r7   )rª   r   r1   r«   ©rK   r(   r_   r(   r+   r(   r=   rC   s   @r%   r¨   r¨     s\   ø€ € € € € ØBÐBð	#ð 	#ð 	#ð 	#ð 	#ð 	#ð 	#ðð ð ð ð ð ð ð r&   r¨   c                  ó.   ‡ — e Zd ZdZddˆ fd„Zdd„Zˆ xZS )ÚBCEDiceLossz;Criterion class for computing combined BCE and Dice losses.ç      à?Ú
weight_bcer   Úweight_dicec                ó¾   •— t          ¦   «                              ¦   «          || _        || _        t	          j        ¦   «         | _        t          d¬¦  «        | _        dS )zÞInitialize BCEDiceLoss with BCE and Dice weight factors.

        Args:
            weight_bce (float): Weight factor for BCE loss component.
            weight_dice (float): Weight factor for Dice loss component.
        r   )rª   N)	r    r!   r¸   r¹   r   ÚBCEWithLogitsLossÚbcer¨   r²   )r#   r¸   r¹   r$   s      €r%   r!   zBCEDiceLoss.__init__*  sP   ø€ õ 	‰Œ×ÒÑÔÐØ$ˆŒØ&ˆÔÝÔ'Ñ)Ô)ˆŒÝ(°Ð2Ñ2Ô2ˆŒ	ˆ	ˆ	r&   rK   r(   r_   r+   c                ó
  — |j         \  }}}}t          |j         dd…         ¦  «        ||fk    rt          j        |||fd¬¦  «        }| j        |                      ||¦  «        z  | j        |                      ||¦  «        z  z   S )zECalculate combined BCE and Dice loss between predictions and targets.éþÿÿÿNÚnearest)Úmode)rl   Útupler5   Úinterpolater¸   r¼   r¹   r²   )r#   rK   r_   Ú_Úmask_hÚmask_ws         r%   r;   zBCEDiceLoss.forward7  sˆ   € à#œzÑˆˆ1ˆf�fÝ�”˜b˜c˜cÔ"Ñ#Ô#¨°Ð'7Ò7Ð7Ý”] 6¨F°FÐ+;À)ÐLÑLÔLˆFØŒ §¢¨$°Ñ!7Ô!7Ñ7¸$Ô:JÈTÏYÊYÐW[Ð]cÑMdÔMdÑ:dÑdÐdr&   )r·   r·   )r¸   r   r¹   r   r´   r=   rC   s   @r%   r¶   r¶   '  sd   ø€ € € € € ØEÐEð3ð 3ð 3ð 3ð 3ð 3ð 3ðeð eð eð eð eð eð eð er&   r¶   c                  ó,   ‡ — e Zd ZdZdˆ fd„Zdd„Zˆ xZS )ÚKeypointLossz.Criterion class for computing keypoint losses.Úsigmasr(   r+   r[   c                óV   •— t          ¦   «                              ¦   «          || _        dS )z7Initialize the KeypointLoss class with keypoint sigmas.N)r    r!   rÈ   )r#   rÈ   r$   s     €r%   r!   zKeypointLoss.__init__B  s$   ø€ å‰Œ×ÒÑÔÐØˆŒˆˆr&   Ú	pred_kptsÚgt_kptsÚkpt_maskÚareac                óÄ  — |d         |d         z
                        d¦  «        |d         |d         z
                        d¦  «        z   }|j        d         t          j        |dk    d¬¦  «        dz   z  }|d| j        z                        d¦  «        |dz   z  dz  z  }|                     dd¦  «        dt          j        | ¦  «        z
  |z  z                       ¦   «         S )	zICalculate keypoint loss factor and Euclidean distance loss for keypoints.©.r   r…   ©.r   r   r   rb   ç•Ö&è.>rd   )r3   rl   rI   r8   rÈ   rk   Úexpr7   )r#   rÊ   rË   rÌ   rÍ   ÚdÚkpt_loss_factorÚes           r%   r;   zKeypointLoss.forwardG  sÛ   € ð �vÔ ¨¤Ñ0×5Ò5°aÑ8Ô8¸IÀfÔ<MÐPWÐX^ÔP_Ñ<_×;dÒ;dÐefÑ;gÔ;gÑgˆØ"œ.¨Ô+­u¬y¸ÀQºÈAÐ/NÑ/NÔ/NÐQUÑ/UÑVˆà�!�d”k‘/×&Ò& qÑ)Ô)¨T°D©[Ñ9¸AÑ=Ñ>ˆØ×$Ò$ R¨Ñ+Ô+°µE´I¸q¸b±M´MÑ0AÀXÑ/MÑN×TÒTÑVÔVÐVr&   )rÈ   r(   r+   r[   )
rÊ   r(   rË   r(   rÌ   r(   rÍ   r(   r+   r(   r=   rC   s   @r%   rÇ   rÇ   ?  s_   ø€ € € € € Ø8Ð8ðð ð ð ð ð ð
Wð Wð Wð Wð Wð Wð Wð Wr&   rÇ   c                  óN   — e Zd ZdZ	 dd d
„Zd!d„Zd"d„Zd#d„Zd$d„Zd%d„Z	d&d„Z
dS )'Úv8DetectionLosszJCriterion class for computing training losses for YOLOv8 object detection.é
   NÚmodelútorch.nn.ModuleÚtal_topkrZ   Ú	tal_topk2ú
int | Nonec                óB  — t          |                     ¦   «         ¦  «        j        }|j        }|j        d         }t          j        d¬¦  «        | _        || _        |j	        | _	        |j
        | _
        |j
        |j        dz  z   | _        |j        | _        || _        |j        dk    | _        dd| j        rdnd	f| _        t          |d
d¦  «        | _        | j        �4| j                             |¦  «                             ddd¦  «        | _        t'          || j
        dd| j	                             ¦   «         |¬¦  «        | _        t-          |j        ¦  «                             |¦  «        | _        t1          j        |j        t0          j        |¬¦  «        | _        dS )zVInitialize v8DetectionLoss with model parameters and task-aligned assignment settings.rd   r/   r0   r¥   r   Úbox_lossÚcls_lossrw   r‡   Úclass_weightsNr·   ç      @©ÚtopkÚnum_classesr   Úbetar   Útopk2©rO   r.   )ÚnextÚ
parametersr.   ÚargsrÙ   r   r»   r¼   Úhypr   ÚncrY   ÚnoÚuse_dflÚ
loss_namesÚgetattrrá   rQ   rk   r   ÚtolistÚassignerru   Ú	bbox_lossrI   Úaranger   Úproj)r#   rÙ   rÛ   rÜ   r.   ÚhÚms          r%   r!   zv8DetectionLoss.__init__U  sn  € õ �e×&Ò&Ñ(Ô(Ñ)Ô)Ô0ˆØŒJˆàŒK˜ŒOˆÝÔ'°&Ð9Ñ9Ô9ˆŒØˆŒØ”hˆŒØ”$ˆŒØ”$˜œ Q™Ñ&ˆŒØ”yˆŒØˆŒà”y 1’}ˆŒØ$ jÀÄÐ2[°*°*ÐR[Ð[ˆŒõ % U¨O¸TÑBÔBˆÔØÔÐ)Ø!%Ô!3×!6Ò!6°vÑ!>Ô!>×!CÒ!CÀAÀqÈ"Ñ!MÔ!MˆDÔå+ØØœØØØ”;×%Ò%Ñ'Ô'Øð
ñ 
ô 
ˆŒõ " !¤)Ñ,Ô,×/Ò/°Ñ7Ô7ˆŒÝ”L ¤µ%´+ÀfÐMÑMÔMˆŒ	ˆ	ˆ	r&   Útargetsr(   Ú
batch_sizeÚscale_tensorr+   c                ó$  — |j         \  }}|dk    r"t          j        |d|dz
  | j        ¬¦  «        }�n]|dd…df                              ¦   «         }|                     d¬¦  «        \  }}	|	                     t          j        ¬¦  «        }	t          j        ||	                     ¦   «         |dz
  | j        ¬¦  «        }t          j        |dz   t          j        | j        ¬¦  «        }
|
 	                    d|dz   t          j
        |¦  «        ¦  «         |
                     d¦  «        }
t          j        || j        ¬¦  «        |
|         z
  }|dd…dd…f         |||f<   t          |d	dd
…f                              |¦  «        ¦  «        |d	dd
…f<   |S )zJPreprocess targets by converting to tensor format and scaling coordinates.r   r   ©r.   NT©Úreturn_counts©rO   rè   .r¦   )rl   rI   Úzerosr.   rh   ÚuniquerQ   Úint32ÚmaxÚscatter_add_Ú	ones_likeÚcumsumrõ   r   Úmul_)r#   rù   rú   rû   ÚnlÚneÚoutÚ	batch_idxrÃ   ÚcountsÚoffsetsÚ
within_idxs               r%   Ú
preprocesszv8DetectionLoss.preprocessx  st  € à”‰ˆˆBØ�Š7ˆ7Ý”+˜j¨!¨R°!©V¸D¼KÐHÑHÔHˆC‰Cà    1 œ×*Ò*Ñ,Ô,ˆIØ!×(Ò(°tÐ(Ñ<Ô<‰IˆAˆvØ—Y’Y¥U¤[�YÑ1Ô1ˆFÝ”+˜j¨&¯*ª*©,¬,¸¸Q¹ÀtÄ{ÐSÑSÔSˆCÝ”k *¨q¡.½¼
È4Ì;ÐWÑWÔWˆGØ× Ò   I°¡Mµ5´?À9Ñ3MÔ3MÑNÔNÐNØ—n’n QÑ'Ô'ˆGÝœ b°´Ð=Ñ=Ô=ÀÈ	Ô@RÑRˆJØ)0°°°°A°B°B°¬ˆC�	˜:Ð%Ñ&Ý% c¨#¨q°¨s¨(¤m×&8Ò&8¸Ñ&FÔ&FÑGÔGˆC��Q�q�S�‰MØˆ
r&   ry   r^   c                ó  — | j         ri|j        \  }}}|                     ||d|dz  ¦  «                             d¦  «                             | j                             |j        ¦  «        ¦  «        }t          ||d¬¦  «        S )zUDecode predicted object bounding box coordinates from anchor points and distribution.r¥   r®   F)rƒ   )	rï   rl   rk   ÚsoftmaxÚmatmulrö   r4   rO   r   )r#   ry   r^   ÚbÚaÚcs         r%   Úbbox_decodezv8DetectionLoss.bbox_decodeŠ  sz   € àŒ<ð 	kØ”o‰GˆAˆq�!Ø!Ÿš q¨!¨Q°°Q±Ñ7Ô7×?Ò?ÀÑBÔB×IÒIÈ$Ì)Ï.Ê.ÐYbÔYhÑJiÔJiÑjÔjˆIõ ˜ M¸Ð>Ñ>Ô>Ð>r&   Úpredsúdict[str, torch.Tensor]Úbatchúdict[str, Any]rÁ   c                óì  — t          j        d| j        ¬¦  «        }|d                              ddd¦  «                             ¦   «         |d                              ddd¦  «                             ¦   «         }}t          |d         | j        d	¦  «        \  }}|j        }|j        d         }	t          j	        |d         d         j        dd
…         | j        |¬¦  «        | j        d         z  }
t          j
        |d                              dd¦  «        |d                              dd¦  «        |d         fd¦  «        }|                      |                     | j        ¦  «        |	|
g d¢         ¬¦  «        }|                     dd¦  «        \  }}|                     dd¬¦  «                             d¦  «        }|                      ||¦  «        }|                      |                     ¦   «                              ¦   «         |                     ¦   «         |z                       |j        ¦  «        ||z  |||¦  «        \  }}}}}|                     ¦   «                              d¬¦  «        }|                      ||                     |¦  «        ¦  «        }| j        �
|| j        z  }|                     ¦   «         |z  |d<   |                      |||||z  ||||
|¦	  «	        \  |d<   |d<   |dxx         | j        j        z  cc<   |dxx         | j        j        z  cc<   |dxx         | j        j        z  cc<   |||||f|t=          t?          | j         |                     ¦   «         ¦  «        ¦  «        fS )z‹Calculate the sum of the loss for box, cls and dfl multiplied by batch size and return foreground mask and
        target indices.
        r®   rý   Úboxesr   r…   r   ÚscoresÚfeatsr·   NrN   r  rd   ÚclsÚbboxes©r   r   r   r   ©rû   )r   r¥   Tre   ç        ©Úmin)!rI   r  r.   ÚpermuteÚ
contiguousr   r   rO   rl   rJ   Úcatrk   r  rQ   Úsplitr8   Úgt_r  ró   Údetachr2   r4   rg   r¼   rá   rô   rì   Úboxr   ÚdflÚdictÚziprð   )r#   r  r  r:   Úpred_distriÚpred_scoresry   Ústride_tensorrO   rú   r~   rù   Ú	gt_labelsÚ	gt_bboxesÚmask_gtrx   rÃ   rz   r{   r}   Útarget_gt_idxr|   Úbce_losss                          r%   Úget_assigned_targets_and_lossz-v8DetectionLoss.get_assigned_targets_and_loss“  s]  € õ Œ{˜1 T¤[Ð1Ñ1Ô1ˆà�'ŒN×"Ò" 1 a¨Ñ+Ô+×6Ò6Ñ8Ô8Ø�(ŒO×#Ò# A q¨!Ñ,Ô,×7Ò7Ñ9Ô9ð !ˆõ (4°E¸'´NÀDÄKÐQTÑ'UÔ'UÑ$ˆ�}àÔ!ˆØ Ô& qÔ)ˆ
Ý”˜U 7œ^¨AÔ.Ô4°Q°R°RÔ8ÀÄÐTYÐZÑZÔZÐ]aÔ]hÐijÔ]kÑkˆõ ”)˜U ;Ô/×4Ò4°R¸Ñ;Ô;¸UÀ5¼\×=NÒ=NÈrÐSTÑ=UÔ=UÐW\Ð]eÔWfÐgÐijÑkÔkˆØ—/’/ '§*¢*¨T¬[Ñ"9Ô"9¸:ÐTYÐZfÐZfÐZfÔTg�/ÑhÔhˆØ&Ÿ}š}¨V°QÑ7Ô7Ñˆ	�9Ø—-’- ¨4�-Ñ0Ô0×4Ò4°SÑ9Ô9ˆð ×&Ò& }°kÑBÔBˆàBFÇ-Â-Ø×ÒÑ Ô ×(Ò(Ñ*Ô*Ø×ÒÑ!Ô! MÑ1×7Ò7¸	¼ÑHÔHØ˜MÑ)ØØØñC
ô C
Ñ?ˆˆ=˜-¨°-ð *×-Ò-Ñ/Ô/×6Ò6¸1Ð6Ñ=Ô=Ðð —8’8˜K¨×)9Ò)9¸%Ñ)@Ô)@ÑAÔAˆØÔÐ)Ø˜Ô*Ñ*ˆHØ—,’,‘.”.Ð#4Ñ4ˆˆQ‰ð  Ÿ>š>ØØØØ˜MÑ)ØØØØØñ

ô 

ÑˆˆQ‰��a‘ð 	ˆQˆˆŒ�4”8”<Ñˆˆ‰ØˆQˆˆŒ�4”8”<Ñˆˆ‰ØˆQˆˆŒ�4”8”<Ñˆˆ‰à�m ]°MÀ=ÐQØÝ•�T”_ d§k¢k¡m¤mÑ4Ô4Ñ5Ô5ð
ð 	
r&   úFdict[str, torch.Tensor] | tuple[torch.Tensor, dict[str, torch.Tensor]]c                ó@   — t          |t          ¦  «        r|d         n|S )ú,Parse model predictions to extract features.r   )Ú
isinstancerÁ   ©r#   r  s     r%   Úparse_outputzv8DetectionLoss.parse_outputÒ  s!   € õ & e­UÑ3Ô3Ð>ˆu�QŒxˆx¸Ð>r&   ú,tuple[torch.Tensor, dict[str, torch.Tensor]]c                óT   — |                       |                      |¦  «        |¦  «        S )úLCalculate the sum of the loss for box, cls and dfl multiplied by batch size.©r:   r?  ©r#   r  r  s      r%   rr   zv8DetectionLoss.__call__Ø  s&   € ð �yŠy˜×*Ò*¨5Ñ1Ô1°5Ñ9Ô9Ð9r&   c                óx   — |d         j         d         }|                      ||¦  «        dd…         \  }}||z  |fS )z0Calculate detection loss using assigned targets.r  r   r   N)rl   r9  )r#   r  r  rú   r:   Úloss_detachs         r%   r:   zv8DetectionLoss.lossà  sH   € ð ˜7”^Ô)¨!Ô,ˆ
Ø ×>Ò>¸uÀeÑLÔLÈQÈRÈRÔPÑˆˆkØ�jÑ  +Ð-Ð-r&   ©rØ   N©rÙ   rÚ   rÛ   rZ   rÜ   rÝ   ©rù   r(   rú   rZ   rû   r(   r+   r(   )ry   r(   r^   r(   r+   r(   )r  r  r  r  r+   rÁ   )r  r:  r+   r(   )r  r:  r  r  r+   r@  ©r  r  r  r  r+   r@  )r>   r?   r@   rA   r!   r  r  r9  r?  rr   r:   © r&   r%   r×   r×   R  s¹   € € € € € ØTÐTð SWð!Nð !Nð !Nð !Nð !NðFð ð ð ð$?ð ?ð ?ð ?ð=
ð =
ð =
ð =
ð~?ð ?ð ?ð ?ð:ð :ð :ð :ð.ð .ð .ð .ð .ð .r&   r×   c                  óP   ‡ — e Zd ZdZ	 d d!ˆ fd
„Zd"d„Zed#d„¦   «         Zd$d„Zˆ xZ	S )%Úv8SegmentationLosszFCriterion class for computing training losses for YOLOv8 segmentation.rØ   NrÙ   rÚ   rÛ   rZ   rÜ   rÝ   c                óÒ   •— t          ¦   «                              |||¦  «         ddg| j        dd…         ¢d‘R | _        |j        j        | _        t          dd¬¦  «        | _        dS )zWInitialize the v8SegmentationLoss class with model parameters and mask overlap setting.rß   Úseg_lossr   NÚsem_lossr·   )r¸   r¹   )r    r!   rð   rë   Úoverlap_maskÚoverlapr¶   Úbcedice_loss©r#   rÙ   rÛ   rÜ   r$   s       €r%   r!   zv8SegmentationLoss.__init__ì  sl   ø€ õ 	‰Œ×Ò˜ ¨)Ñ4Ô4Ð4Ø% zÐT°D´OÀAÀBÀBÔ4GÐTÈÐTÐTˆŒØ”zÔ.ˆŒÝ'°3ÀCÐHÑHÔHˆÔÐÐr&   r  r  r  r+   r@  c           
     óX  — |d                               ddd¦  «                             ¦   «         |d         }}t          j        d| j        ¬¦  «        }t          |t          ¦  «        rt          |¦  «        dk    r|\  }}nd}|                      ||¦  «        \  \  }}}	}
}
}}
|d         |d         |d         c|d<   |d<   |d	<   |j	        \  }}
}}| 
                    ¦   «         �r�|d
                              | j        ¦  «                             ¦   «         }t          |j	        dd…         ¦  «        ||fk    r%t          j        ||j	        dd…         dd¬¦  «        }t          j        |d         d         j	        dd…         | j        |j        ¬¦  «        | j        d         z  }|                      ||||	|d                              dd¦  «        |||¦  «        |d<   |��‘|d                              | j        ¦  «                             ¦   «                              d¦  «        }| j        r|dk    }n—|d                              d¦  «        }t          j        |g|j	        dd…         ¢R t          j        | j        dœŽ}t1          |¦  «        D ]:}|||k             }t          |¦  «        r| 
                    d¬¦  «        dk    ||<   Œ;t          j        |j	        d         | j        g|j	        dd…         ¢R d| j        iŽ}|                     d||                     d¦  «                             ¦   «         ¦  «         |                      ||¦  «        |d<   |dxx         | j        j        z  cc<   nd|dxx         |dz   
                    ¦   «         |dz   
                    ¦   «         z   z  cc<   |�%|dxx         |dz   
                    ¦   «         z  cc<   |dxx         | j        j        z  cc<   ||z  t=          t?          | j         | !                    ¦   «         ¦  «        ¦  «        fS )zFCalculate and return the combined loss for detection and segmentation.Úmask_coefficientr   r…   r   Úprotor¦   rý   Nr®   Úmasksr¾   ÚbilinearF)rÀ   Úalign_cornersr  rN   r  rd   Ú	sem_masksrè   rb   r.   r¥   )"r'  r(  rI   r  r.   r=  rÁ   rž   r9  rl   r8   rQ   r   r5   rÂ   rJ   rO   r   Úcalculate_segmentation_lossrk   rh   rœ   rR  r’   Úrangerí   Úscatter_rS  rì   r-  r/  r0  rð   r,  )r#   r  r  Ú
pred_masksrW  r:   Úpred_semanticr}   r7  rz   rÃ   Údet_lossrú   rÄ   rÅ   rX  r~   Úsem_idxÚpresentr  ÚiÚinstance_mask_ir[  s                          r%   r:   zv8SegmentationLoss.lossõ  s-  € ð "Ð"4Ô5×=Ò=¸aÀÀAÑFÔF×QÒQÑSÔSÐUZÐ[bÔUc�Eˆ
ÝŒ{˜1 T¤[Ð1Ñ1Ô1ˆÝ�e�UÑ#Ô#ð 	!­¨E©
¬
°aª¨Ø#(Ñ ˆE�=�=à ˆMØEI×EgÒEgÐhmÐotÑEuÔEuÑBÑ5ˆ�- °°1°xÀà$,¨Q¤K°¸!´¸hÀq¼kÐ!ˆˆQ‰��a‘˜$˜q™'à(-¬Ñ%ˆ
�A�v˜vØ�;Š;‰=Œ=ñ *	5à˜'”N×%Ò% d¤kÑ2Ô2×8Ò8Ñ:Ô:ˆEÝ�U”[   Ô%Ñ&Ô&¨6°6Ð*:Ò:Ð:åœ e¨U¬[¸¸¸Ô-=ÀJÐ^cÐdÑdÔd�õ ”˜U 7œ^¨AÔ.Ô4°Q°R°RÔ8ÀÄÐT^ÔTdÐeÑeÔeÐhlÔhsÐtuÔhvÑvð ð ×6Ò6ØØØØØ�kÔ"×'Ò'¨¨AÑ.Ô.ØØØñ	ô 	ˆD�‰Gð Ñ(Ø Ô,×/Ò/°´Ñ<Ô<×AÒAÑCÔC×MÒMÈaÑPÔP�Ø”<ð IØ# qšj�G�Gà % kÔ 2× 7Ò 7¸Ñ ;Ô ;�IÝ#œk¨*Ðn°u´{À2À3À3Ô7GÐnÐnÍuÌzÐbfÔbmÐnÐnÐn�GÝ" :Ñ.Ô.ð Ið I˜Ø*/°	¸Q²Ô*?˜Ý˜Ñ/Ô/ð IØ)8×)<Ò)<ÀÐ)<Ñ)CÔ)CÀqÒ)H˜G A™Jøå!œK¨¬°aÔ(8¸$¼'ÐjÀGÄMÐRSÐRTÐRTÔDUÐjÐjÐjÐ^bÔ^iÐjÐj�	Ø×"Ò" 1 g¨w×/@Ò/@ÀÑ/CÔ/C×/IÒ/IÑ/KÔ/KÑLÔLÐLà×+Ò+¨M¸9ÑEÔE��Q‘Ø�Q��”˜4œ8œ<Ñ'��‘øð �ˆGˆGŒG˜ ™	—’Ñ(Ô(¨J¸©N×+?Ò+?Ñ+AÔ+AÑAÑAˆGˆG‰GØÐ(Ø�Q��”˜M¨AÑ-×2Ò2Ñ4Ô4Ñ4��‘àˆQˆˆŒ�4”8”<Ñˆˆ‰Ø�jÑ ¥$¥s¨4¬?¸D¿KºK¹M¼MÑ'JÔ'JÑ"KÔ"KÐKÐKr&   Úgt_maskr(   rK   rW  ÚxyxyrÍ   c                óÎ   — t          j        d||¦  «        }t          j        || d¬¦  «        }t	          ||¦  «                             d¬¦  «        |z                       ¦   «         S )aO  Compute the instance segmentation loss for a single image.

        Args:
            gt_mask (torch.Tensor): Ground truth mask of shape (N, H, W), where N is the number of objects.
            pred (torch.Tensor): Predicted mask coefficients of shape (N, 32).
            proto (torch.Tensor): Prototype masks of shape (32, H, W).
            xyxy (torch.Tensor): Ground truth bounding boxes in xyxy format, normalized to [0, 1], of shape (N, 4).
            area (torch.Tensor): Area of each ground truth bounding box of shape (N,).

        Returns:
            (torch.Tensor): The calculated mask loss for a single image.

        Notes:
            The function uses the equation pred_mask = torch.einsum('in,nhw->ihw', pred, proto) to produce the
            predicted masks from the prototype masks and predicted mask coefficients.
        zin,nhw->ihwr/   r0   )r   r…   rb   )rI   Úeinsumr5   r6   r
   r7   r8   )rf  rK   rW  rg  rÍ   Ú	pred_maskr:   s          r%   Úsingle_mask_lossz#v8SegmentationLoss.single_mask_loss3  sa   € õ( ”L °°eÑ<Ô<ˆ	ÝÔ1°)¸WÐPVÐWÑWÔWˆÝ˜$ Ñ%Ô%×*Ò*¨vÐ*Ñ6Ô6¸Ñ=×BÒBÑDÔDÐDr&   r}   rX  r7  rz   r  r_  r~   c	           
     ó&  — |j         \  }	}	}
}d}||g d¢         z  }t          |¦  «        ddd…f                              d¦  «        }|t          j        ||
||
g|j        ¬¦  «        z  }t          t          ||||||¦  «        ¦  «        D ]ð\  }}|\  }}}}}}|                     ¦   «         rœ||         }| j	        r9||         |dz    
                    ddd¦  «        k    }|                     ¦   «         }n%|| 
                    d¦  «        |k             |         }||                      |||         |||         ||         ¦  «        z  }Œ¾||dz                       ¦   «         |dz                       ¦   «         z   z  }Œñ||                     ¦   «         z  S )	aò  Calculate the loss for instance segmentation.

        Args:
            fg_mask (torch.Tensor): A binary tensor of shape (BS, N_anchors) indicating which anchors are positive.
            masks (torch.Tensor): Ground truth masks, shape (BS, H, W) if `overlap` else (N_instances_in_batch, H, W).
            target_gt_idx (torch.Tensor): Indexes of ground truth objects for each anchor of shape (BS, N_anchors).
            target_bboxes (torch.Tensor): Ground truth bounding boxes for each anchor of shape (BS, N_anchors, 4).
            batch_idx (torch.Tensor): Batch indices of shape (N_labels_in_batch, 1).
            proto (torch.Tensor): Prototype masks of shape (BS, 32, H, W).
            pred_masks (torch.Tensor): Predicted masks for each anchor of shape (BS, N_anchors, 32).
            imgsz (torch.Tensor): Size of the input image as a tensor of shape (2), i.e., (H, W).

        Returns:
            (torch.Tensor): The calculated loss for instance segmentation.

        Notes:
            The batch loss can be computed for improved speed at higher memory usage.
            For example, pred_mask can be computed as follows:
                pred_mask = torch.einsum('in,nhw->ihw', pred, proto)  # (i, 32) @ (32, 160, 160) -> (i, 160, 160)
        r   r"  .r…   Nrý   r   rd   )rl   r   ÚprodrI   rJ   r.   Ú	enumerater0  rP   rR  rk   r   rk  r8   )r#   r}   rX  r7  rz   r  rW  r_  r~   rÃ   rÄ   rÅ   r:   Útarget_bboxes_normalizedÚmareaÚmxyxyrd  Úsingle_iÚ	fg_mask_iÚtarget_gt_idx_iÚpred_masks_iÚproto_iÚmxyxy_iÚmarea_iÚmask_idxrf  s                             r%   r\  z.v8SegmentationLoss.calculate_segmentation_lossK  s½  € ð>  %œ{Ñˆˆ1ˆf�fØˆð $1°5¸¸¸Ô3FÑ#FÐ õ Ð2Ñ3Ô3°C¸¸¸°GÔ<×AÒAÀ!ÑDÔDˆð )­5¬<¸ÀÈÐQWÐ8XÐafÔamÐ+nÑ+nÔ+nÑnˆå$¥S¨°-ÀÈUÐTYÐ[`Ñ%aÔ%aÑbÔbð 	Cð 	C‰KˆAˆxØRZÑOˆI�¨°g¸wÈØ�}Š}‰Œð CØ*¨9Ô5�Ø”<ð GØ# Aœh¨8°a©<×*=Ò*=¸bÀ!ÀQÑ*GÔ*GÒG�GØ%Ÿmšm™oœo�G�Gà# I§N¢N°2Ñ$6Ô$6¸!Ò$;Ô<¸XÔF�Gà˜×-Ò-Ø˜\¨)Ô4°g¸wÀyÔ?QÐSZÐ[dÔSeñô ñ ��ð ˜ ™ŸšÑ)Ô)¨Z¸!©^×,@Ò,@Ñ,BÔ,BÑBÑB��à�g—k’k‘m”mÑ#Ð#r&   rG  rH  rJ  )rf  r(   rK   r(   rW  r(   rg  r(   rÍ   r(   r+   r(   )r}   r(   rX  r(   r7  r(   rz   r(   r  r(   rW  r(   r_  r(   r~   r(   r+   r(   )
r>   r?   r@   rA   r!   r:   Ústaticmethodrk  r\  rB   rC   s   @r%   rM  rM  é  s§   ø€ € € € € ØPÐPð SWðIð Ið Ið Ið Ið Ið Ið<Lð <Lð <Lð <Lð| ðEð Eð Eñ „\ðEð.=$ð =$ð =$ð =$ð =$ð =$ð =$ð =$r&   rM  c                  óV   ‡ — e Zd ZdZddˆ fd„Zdd„Zedd„¦   «         Zd d„Zd!d„Z	ˆ xZ
S )"Ú
v8PoseLosszICriterion class for computing training losses for YOLOv8 pose estimation.rØ   rÙ   rÚ   rÛ   rZ   rÜ   c                ó  •— t          ¦   «                              |||¦  «         dddg| j        dd…         ¢R | _        |j        d         j        | _        t          j        ¦   «         | _        | j        ddgk    }| j        d	         }t          |d
d¦  «        }|€R|r1t          j
        t          ¦  «                             | j        ¦  «        nt          j        || j        ¬¦  «        |z  }nŠt          j        || j        t          j        ¬¦  «                             ¦   «         }t%          |¦  «        |k    st          j        |d	k    ¦  «        s't)          d|› d|                     ¦   «         › �¦  «        ‚t-          |¬¦  «        | _        dS )zQInitialize v8PoseLoss with model parameters and keypoint-specific loss functions.rß   Ú	pose_lossÚ	kobj_lossr   Nrd   é   r®   r   Úkpt_oks_sigmasrý   rN   z'kpt_oks_sigmas' must be z positive values, got )rÈ   )r    r!   rð   rÙ   Ú	kpt_shaper   r»   Úbce_poserñ   rI   Ú
from_numpyr   rQ   r.   ÚonesÚ	as_tensorÚfloat32Úflattenrž   ÚallÚ
ValueErrorrò   rÇ   Úkeypoint_loss)r#   rÙ   rÛ   rÜ   Úis_poseÚnkptrÈ   r$   s          €r%   r!   zv8PoseLoss.__init__Ž  sp  ø€ å‰Œ×Ò˜ ¨)Ñ4Ô4Ð4Ø% {°KÐVÀ$Ä/ÐRSÐRTÐRTÔBUÐVÐVˆŒØœ RœÔ2ˆŒÝÔ,Ñ.Ô.ˆŒØ”. R¨ GÒ+ˆØŒ~˜aÔ ˆå˜Ð 0°$Ñ7Ô7ˆØˆ>à?FÐw•Ô ¥Ñ+Ô+×.Ò.¨t¬{Ñ;Ô;Ð;ÍEÌJÐW[ÐdhÔdoÐLpÑLpÔLpÐswÑLwð ˆFõ ”_ V°D´KÅuÄ}ÐUÑUÔU×]Ò]Ñ_Ô_ˆFÝ�6‰{Œ{˜dÒ"Ð"­%¬)°F¸Q²JÑ*?Ô*?Ð"Ý Ð!j¸TÐ!jÐ!jÐY_×YfÒYfÑYhÔYhÐ!jÐ!jÑkÔkÐkå)°Ð8Ñ8Ô8ˆÔÐÐr&   r  r  r  r+   r@  c           	     óÌ  — |d                               ddd¦  «                             ¦   «         }t          j        d| j        ¬¦  «        }|                      ||¦  «        \  \  }}}}}	}
}|
d         |
d         |
d         c|d<   |d<   |d<   |j        d         }t          j        |d	         d         j        dd
…         | j        |j        ¬¦  «        | j	        d         z  }|  
                    | |j        |dg| j        ¢R Ž ¦  «        }|                     ¦   «         r¯|d                              | j        ¦  «                             ¦   «                              ¦   «         }|dxx         |d         z  cc<   |dxx         |d         z  cc<   |                      ||||d                              dd¦  «        |	||¦  «        \  |d<   |d<   n,|dxx         |dd
d…f                              ¦   «         z  cc<   |dxx         | j        j        z  cc<   |dxx         | j        j        z  cc<   ||z  t+          t-          | j        |                     ¦   «         ¦  «        ¦  «        fS )ú;Calculate the total loss and detach it for pose estimation.Úkptsr   r…   r   r¦   rý   r®   r¥   r  NrN   rd   Ú	keypointsrÏ   rÐ   r  .)r'  r(  rI   r  r.   r9  rl   rJ   rO   r   Úkpts_decoderk   r‚  r8   rQ   r   ÚcloneÚcalculate_keypoints_lossrì   ÚposeÚkobjr/  r0  rð   r,  )r#   r  r  rÊ   r:   r}   r7  rz   ry   r3  ra  rÃ   rú   r~   r‘  s                  r%   r:   zv8PoseLoss.loss£  sv  € ð ˜&”M×)Ò)¨!¨Q°Ñ2Ô2×=Ò=Ñ?Ô?ˆ	ÝŒ{˜1 T¤[Ð1Ñ1Ô1ˆà×.Ò.¨u°eÑ<Ô<ñ 	[ÑMˆ�- °¸}ÈxÐYZð %-¨Q¤K°¸!´¸hÀq¼kÐ!ˆˆQ‰��a‘˜$˜q™'à”_ QÔ'ˆ
Ý”˜U 7œ^¨AÔ.Ô4°Q°R°RÔ8ÀÄÐT]ÔTcÐdÑdÔdÐgkÔgrÐstÔguÑuˆð ×$Ò$ ]°N°I´NÀ:ÈrÐ4cÐTXÔTbÐ4cÐ4cÐ4cÑdÔdˆ	ð �;Š;‰=Œ=ð 	0Ø˜kÔ*×-Ò-¨d¬kÑ:Ô:×@Ò@ÑBÔB×HÒHÑJÔJˆIØ�fÐÐÔ  q¤Ñ)ÐÐÑØ�fÐÐÔ  q¤Ñ)ÐÐÑà#×<Ò<ØØØØ�kÔ"×'Ò'¨¨AÑ.Ô.ØØØñ ô  ÑˆD�‰G�T˜!‘W�Wð �ˆGˆGŒG�y  b q b Ô)×-Ò-Ñ/Ô/Ñ/ˆGˆG‰GàˆQˆˆŒ�4”8”=Ñ ˆˆ‰ØˆQˆˆŒ�4”8”=Ñ ˆˆ‰à�jÑ ¥$¥s¨4¬?¸D¿KºK¹M¼MÑ'JÔ'JÑ"KÔ"KÐKÐKr&   ry   r(   rÊ   c                óÎ   — |                      ¦   «         }|ddd…fxx         dz  cc<   |dxx         | dd…dgf         dz
  z  cc<   |dxx         | dd…d	gf         dz
  z  cc<   |S )
ú0Decode predicted keypoints to image coordinates..Nr…   r   rÏ   r   r·   rÐ   r   ©r“  ©ry   rÊ   Úys      r%   r’  zv8PoseLoss.kpts_decodeÍ  sŠ   € ð �OŠOÑÔˆØ	ˆ#ˆr�ˆrˆ'ˆ
ˆ
Œ
�cÑˆ
ˆ
‰
Ø	ˆ&ˆ	ˆ	Œ	�] 1 1 1 q c 6Ô*¨SÑ0Ñ0ˆ	ˆ	‰	Ø	ˆ&ˆ	ˆ	Œ	�] 1 1 1 q c 6Ô*¨SÑ0Ñ0ˆ	ˆ	‰	Øˆr&   r‘  r  r7  rX  c           
     óR  — |                      ¦   «         }t          |¦  «        }t          j        |d¬¦  «        d                              ¦   «         }t          j        |||j        d         |j        d         f|j        ¬¦  «        }|                     ¦   «         }t          j        |dz   t          j        |j        ¬¦  «        }	|	 	                    d|dz   t          j
        |¦  «        ¦  «         |	                     d¦  «        }	t          j        t          |¦  «        |j        ¬¦  «        |	|         z
  }
||||
f<   |                     d¦  «                             d¦  «        }|                     d|                     dd|j        d         |j        d         ¦  «        ¦  «        }|S )	a§  Select target keypoints for each anchor based on batch index and target ground truth index.

        Args:
            keypoints (torch.Tensor): Ground truth keypoints, shape (N_kpts_in_batch, N_kpts_per_object, kpts_dim).
            batch_idx (torch.Tensor): Batch index tensor for keypoints, shape (N_kpts_in_batch, 1).
            target_gt_idx (torch.Tensor): Index tensor mapping anchors to ground truth objects, shape (BS, N_anchors).
            masks (torch.Tensor): Binary mask tensor indicating object presence, shape (BS, N_anchors).

        Returns:
            (torch.Tensor): Selected keypoints tensor, shape (BS, N_anchors, N_kpts_per_object, kpts_dim).
        Trþ   r   r…   rý   rè   r   rd   )rˆ  rž   rI   r  r  r  rl   r.   rh   r  r  r  rõ   rœ   rj   Úexpand)r#   r‘  r  r7  rX  rú   Úmax_kptsÚbatched_keypointsÚbatch_idx_longr  r  Útarget_gt_idx_expandedÚselected_keypointss                r%   Ú_select_target_keypointsz#v8PoseLoss._select_target_keypointsÖ  s�  € ð$ ×%Ò%Ñ'Ô'ˆ	Ý˜‘Z”Zˆ
õ ”< 	¸Ð>Ñ>Ô>¸qÔA×EÒEÑGÔGˆõ "œKØ˜ 9¤?°1Ô#5°y´ÀqÔ7IÐJÐS\ÔScð
ñ 
ô 
Ðð
 #ŸšÑ)Ô)ˆÝ”+˜j¨1™nµE´JÀyÔGWÐXÑXÔXˆØ×Ò˜Q °Ñ 2µE´OÀNÑ4SÔ4SÑTÔTÐTØ—.’. Ñ#Ô#ˆÝ”\¥# i¡.¤.¸Ô9IÐJÑJÔJÈWÐUcÔMdÑdˆ
Ø8AÐ˜.¨*Ð4Ñ5ð "/×!8Ò!8¸Ñ!<Ô!<×!FÒ!FÀrÑ!JÔ!JÐð /×5Ò5ØÐ%×,Ò,¨R°°Y´_ÀQÔ5GÈÌÐYZÔI[Ñ\Ô\ñ
ô 
Ðð "Ð!r&   r3  rz   r€   c                óÐ  — |                       ||||¦  «        }d}	d}
|                     ¦   «         �r2||z  }||         }|ddd…fxx         |                     dd¦  «                             |j        d         d¦  «        |         dd…ddf         z  cc<   t          ||         ¦  «        dd…dd…f                              dd¬¦  «        }||         }|j        d         d	k    r|d
         dk    nt          j        |d         d¦  «        }|  	                    ||||¦  «        }	|j        d         d	k    r.|  
                    |d
         |                     ¦   «         ¦  «        }
|	|
fS )a  Calculate the keypoints loss for the model.

        This function calculates the keypoints loss and keypoints object loss for a given batch. The keypoints loss is
        based on the difference between the predicted keypoints and ground truth keypoints. The keypoints object loss is
        a binary classification loss that classifies whether a keypoint is present or not.

        Args:
            masks (torch.Tensor): Binary mask tensor indicating object presence, shape (BS, N_anchors).
            target_gt_idx (torch.Tensor): Index tensor mapping anchors to ground truth objects, shape (BS, N_anchors).
            keypoints (torch.Tensor): Ground truth keypoints, shape (N_kpts_in_batch, N_kpts_per_object, kpts_dim).
            batch_idx (torch.Tensor): Batch index tensor for keypoints, shape (N_kpts_in_batch, 1).
            stride_tensor (torch.Tensor): Stride tensor for anchors, shape (N_anchors, 1).
            target_bboxes (torch.Tensor): Ground truth boxes in (x1, y1, x2, y2) format, shape (BS, N_anchors, 4).
            pred_kpts (torch.Tensor): Predicted keypoints, shape (BS, N_anchors, N_kpts_per_object, kpts_dim).

        Returns:
            kpts_loss (torch.Tensor): The keypoints loss.
            kpts_obj_loss (torch.Tensor): The keypoints object loss.
        r   .Nr…   r   rd   Tre   r®   ©.r…   rÏ   )r£  rP   rk   r�  rl   r   rm  rI   Ú	full_liker‹  rƒ  r   )r#   rX  r7  r‘  r  r3  rz   rÊ   r¢  Ú	kpts_lossÚkpts_obj_lossÚgt_kptrÍ   Úpred_kptrÌ   s                  r%   r”  z#v8PoseLoss.calculate_keypoints_loss  s  € ð< "×:Ò:¸9ÀiÐQ^Ð`eÑfÔfÐàˆ	Øˆà�9Š9‰;Œ;ñ 
	RØ˜]Ñ*ˆMØ'¨Ô.ˆFØ�3˜˜˜�7ˆOˆOŒO˜}×1Ò1°!°RÑ8Ô8×?Ò?ÀÄÈAÄÐPRÑSÔSÐTYÔZÐ[\Ð[\Ð[\Ð^bÐdhÐ[hÔiÑiˆOˆO‰OÝ˜]¨5Ô1Ñ2Ô2°1°1°1°a°b°b°5Ô9×>Ò>¸qÈ$Ð>ÑOÔOˆDØ  Ô'ˆHØ.4¬l¸2Ô.>À!Ò.CÐ.C�v˜f”~¨Ò*Ð*ÍÌÐY_Ð`fÔYgÐimÑInÔInˆHØ×*Ò*¨8°V¸XÀtÑLÔLˆIàŒ~˜bÔ! QÒ&Ð&Ø $§¢¨h°vÔ.>ÀÇÂÑ@PÔ@PÑ QÔ Q�à˜-Ð'Ð'r&   )rØ   rØ   )rÙ   rÚ   rÛ   rZ   rÜ   rZ   rJ  ©ry   r(   rÊ   r(   r+   r(   )
r‘  r(   r  r(   r7  r(   rX  r(   r+   r(   )rX  r(   r7  r(   r‘  r(   r  r(   r3  r(   rz   r(   rÊ   r(   r+   r€   )r>   r?   r@   rA   r!   r:   rz  r’  r£  r”  rB   rC   s   @r%   r|  r|  ‹  sª   ø€ € € € € ØSÐSð9ð 9ð 9ð 9ð 9ð 9ð 9ð*(Lð (Lð (Lð (LðT ðð ð ñ „\ðð-"ð -"ð -"ð -"ð^/(ð /(ð /(ð /(ð /(ð /(ð /(ð /(r&   r|  c                  ó`   ‡ — e Zd ZdZ	 d"d#ˆ fd
„Zd$d„Zed%d„¦   «         Zd&d„Zd'd„Z	d(d!„Z
ˆ xZS ))Ú
PoseLoss26z_Criterion class for computing training losses for YOLO26 pose estimation with RLE loss support.rØ   NrÙ   rÚ   rÛ   rZ   rÜ   rÝ   c                ó*  •— t          ¦   «                              |||¦  «         | j        ddgk    }| j        d         }d| _        t	          |j        d         d¦  «        r|j        d         j        nd| _        | j        �’t          d¬¦  «                             | j	        ¦  «        | _        | xj
        d	z  c_
        |r1t          j        t          ¦  «                             | j	        ¦  «        nt          j        || j	        ¬
¦  «        | _        dS dS )zdInitialize PoseLoss26 with model parameters and keypoint-specific loss functions including RLE loss.r€  r®   r   Nrd   Ú
flow_modelT)r‘   )Úrle_lossrý   )r    r!   r‚  r°  ÚhasattrrÙ   r¯  r�   rQ   r.   rð   rI   r„  r	   r…  Útarget_weights)r#   rÙ   rÛ   rÜ   rŒ  r�  r$   s         €r%   r!   zPoseLoss26.__init__:  sü   ø€ õ 	‰Œ×Ò˜ ¨)Ñ4Ô4Ð4Ø”. R¨ GÒ+ˆØŒ~˜aÔ ˆØˆŒÝ8?ÀÄÈBÄÐQ]Ñ8^Ô8^Ðh˜%œ+ bœ/Ô4Ð4ÐdhˆŒØŒ?Ð&Ý#°dÐ;Ñ;Ô;×>Ò>¸t¼{ÑKÔKˆDŒMØˆOŒO˜}Ñ,ˆOŒOà@GÐq•Ô ¥Ñ,Ô,×/Ò/°´Ñ<Ô<Ð<ÍUÌZÐX\ÐeiÔepÐMqÑMqÔMqð ÔÐÐð 'Ð&r&   r  r  r  r+   r@  c           	     óÄ  — |d                               ddd¦  «                             ¦   «         }t          j        | j        rdnd| j        ¬¦  «        }|                      ||¦  «        \  \  }}}}}	}
}|
d         |
d         |
d         c|d<   |d<   |d	<   |j        d         }t          j        |d
         d         j        dd…         | j        |j	        ¬¦  «        | j
        d         z  } |j        |dg| j        ¢R Ž }| j        r€|                     dd¦  «        �j|d                               ddd¦  «                             ¦   «         }|                     |d| j        d         d¦  «        }t          j        ||gd¬¦  «        }|                      ||¦  «        }|                     ¦   «         rÎ|d                              | j        ¦  «                             ¦   «                              ¦   «         }|dxx         |d         z  cc<   |dxx         |d         z  cc<   |                      ||||d                              dd¦  «        |	||¦  «        }|d         |d<   |d         |d<   | j        �|d         |d<   nV|dxx         |ddd…f                              ¦   «         z  cc<   | j        �#|dxx         |                      |¦  «        z  cc<   |dxx         | j        j        z  cc<   |dxx         | j        j        z  cc<   | j        �|dxx         | j        j        z  cc<   ||z  t5          t7          | j        |                     ¦   «         ¦  «        ¦  «        fS )r�  r�  r   r…   r   é   r¦   rý   r®   r¥   r  NrN   rd   Ú
kpts_sigmarb   r‘  rÏ   rÐ   r  .)r'  r(  rI   r  r°  r.   r9  rl   rJ   rO   r   rk   r‚  Úgetr)  r’  r8   rQ   r   r“  r”  Ú	_rle_zerorì   r•  r–  Úrler/  r0  rð   r,  )r#   r  r  rÊ   r:   r}   r7  rz   ry   r3  ra  rÃ   rú   r~   Ú
pred_sigmar‘  Úkeypoints_losss                    r%   r:   zPoseLoss26.lossJ  s|  € ð ˜&”M×)Ò)¨!¨Q°Ñ2Ô2×=Ò=Ñ?Ô?ˆ	ÝŒ{Ø”Ð%ˆAˆA A¨d¬kð
ñ 
ô 
ˆð ×.Ò.¨u°eÑ<Ô<ñ 	[ÑMˆ�- °¸}ÈxÐYZð %-¨Q¤K°¸!´¸hÀq¼kÐ!ˆˆQ‰��a‘˜$˜q™'à”_ QÔ'ˆ
Ý”˜U 7œ^¨AÔ.Ô4°Q°R°RÔ8ÀÄÐT]ÔTcÐdÑdÔdÐgkÔgrÐstÔguÑuˆà"�I”N :¨rÐC°D´NÐCÐCÐCˆ	àŒ=ð 	C˜UŸYšY |°TÑ:Ô:ÐFØ˜|Ô,×4Ò4°Q¸¸1Ñ=Ô=×HÒHÑJÔJˆJØ#Ÿš¨°R¸¼ÈÔ9JÈAÑNÔNˆJÝœ	 9¨jÐ"9¸rÐBÑBÔBˆIà×$Ò$ ]°IÑ>Ô>ˆ	ð �;Š;‰=Œ=ð 	5Ø˜kÔ*×-Ò-¨d¬kÑ:Ô:×@Ò@ÑBÔB×HÒHÑJÔJˆIØ�fÐÐÔ  q¤Ñ)ÐÐÑØ�fÐÐÔ  q¤Ñ)ÐÐÑà!×:Ò:ØØØØ�kÔ"×'Ò'¨¨AÑ.Ô.ØØØñô ˆNð % QÔ'ˆD�‰GØ$ QÔ'ˆD�‰GØŒ}Ð(Ø(¨Ô+��Q‘øð �ˆGˆGŒG�y  b q b Ô)×-Ò-Ñ/Ô/Ñ/ˆGˆG‰GØŒ}Ð(Ø�Q��”˜4Ÿ>š>¨)Ñ4Ô4Ñ4��‘àˆQˆˆŒ�4”8”=Ñ ˆˆ‰ØˆQˆˆŒ�4”8”=Ñ ˆˆ‰ØŒ=Ð$Ø�ˆGˆGŒG�t”x”|Ñ#ˆGˆG‰Gð �jÑ ¥$¥s¨4¬?¸D¿KºK¹M¼MÑ'JÔ'JÑ"KÔ"KÐKÐKr&   ry   r(   rÊ   c                óš   — |                      ¦   «         }|dxx         | dd…dgf         z  cc<   |dxx         | dd…dgf         z  cc<   |S )r˜  rÏ   Nr   rÐ   r   r™  rš  s      r%   r’  zPoseLoss26.kpts_decode…  sb   € ð �OŠOÑÔˆØ	ˆ&ˆ	ˆ	Œ	�] 1 1 1 q c 6Ô*Ñ*ˆ	ˆ	‰	Ø	ˆ&ˆ	ˆ	Œ	�] 1 1 1 q c 6Ô*Ñ*ˆ	ˆ	‰	Øˆr&   rª  c                ó    — |ddd…f                               ¦   «         t          d„ | j                             ¦   «         D ¦   «         ¦  «        z   S )z]Return a zero RLE loss keeping `pred_kpt` and the flow model in the graph, for Multi-GPU DDP..Nr   c              3  óR   K  — | ]"}|d dd…f                               ¦   «         V — Œ#dS ).Nr   )r8   )Ú.0Úps     r%   ú	<genexpr>z'PoseLoss26._rle_zero.<locals>.<genexpr>�  s8   è è € Ð,dÐ,dÀ!¨Q¨s°B°Q°B¨w¬Z¯^ª^Ñ-=Ô-=Ð,dÐ,dÐ,dÐ,dÐ,dÐ,dr&   )r8   r¯  rê   )r#   rª  s     r%   r·  zPoseLoss26._rle_zero�  sK   € à˜˜R˜a˜R˜Ô ×$Ò$Ñ&Ô&­Ð,dÐ,dÀtÄ×GaÒGaÑGcÔGcÐ,dÑ,dÔ,dÑ)dÔ)dÑdÐdr&   r©  rÌ   c                óh  — |                      ¦   «         s|                      |¦  «        S ||         }||         }|dd…dd…f         }|dd…dd…f         }|dd…dd…f         }| j                             d¦  «                             |j        d         d¦  «        }	|	|         }	|                     ¦   «         }||z
  |dz   z  }
|
                     ¦   «         s|                      |¦  «        S t          j	        |
¦  «        t          j
        |
¦  «        z                        d¬¦  «         }|                      ¦   «         s|                      |¦  «        S |
|         }
|
                     d	d
¦  «        }
||         }|	|         }	| j                             |
¦  «        }|                      |||
|	¦  «        S )aÎ  Calculate the RLE (Residual Log-likelihood Estimation) loss for keypoints.

        Args:
            pred_kpt (torch.Tensor): Predicted kpts with sigma, shape (N, num_keypoints, kpts_dim) where kpts_dim >= 4.
            gt_kpt (torch.Tensor): Ground truth keypoints, shape (N, num_keypoints, kpts_dim).
            kpt_mask (torch.Tensor): Mask for valid keypoints, shape (N, num_keypoints).

        Returns:
            (torch.Tensor): The RLE loss.
        Nr   r…   r¾   r   rÑ   rd   rb   iœÿÿÿéd   )rP   r·  r²  rœ   Úrepeatrl   r2   ÚnumelrI   ÚisnanÚisinfÚclampr¯  Úlog_probr°  )r#   rª  r©  rÌ   Úpred_kpt_visibleÚgt_kpt_visibleÚpred_coordsr¹  Ú	gt_coordsr²  r˜   Ú
valid_maskr—   s                r%   Úcalculate_rle_losszPoseLoss26.calculate_rle_loss‘  s³  € ð �|Š|‰~Œ~ð 	,Ø—>’> (Ñ+Ô+Ð+à# HÔ-ÐØ Ô)ˆØ& q q q¨!¨A¨# vÔ.ˆØ% a a a¨¨¨ fÔ-ˆ
Ø" 1 1 1 a¨ c 6Ô*ˆ	àÔ,×6Ò6°qÑ9Ô9×@Ò@ÀÄÐPQÔARÐTUÑVÔVˆØ'¨Ô1ˆà×'Ò'Ñ)Ô)ˆ
Ø˜yÑ(¨Z¸$Ñ->Ñ?ˆØ�{Š{‰}Œ}ð 	,Ø—>’> (Ñ+Ô+Ð+õ ”{ 5Ñ)Ô)­E¬K¸Ñ,>Ô,>Ñ>×CÒCÈÐCÑKÔKÐKˆ
Ø�~Š~ÑÔð 	,Ø—>’> (Ñ+Ô+Ð+à�jÔ!ˆØ—’˜D #Ñ&Ô&ˆØ 
Ô+ˆ
Ø'¨
Ô3ˆà”/×*Ò*¨5Ñ1Ô1ˆà�}Š}˜Z¨°%¸ÑHÔHÐHr&   rX  r7  r‘  r  r3  rz   ú/tuple[torch.Tensor, torch.Tensor, torch.Tensor]c                ó¤  — |                       ||||¦  «        }d}	d}
d}|                     ¦   «         �r™||z  }||         }|ddd…fxx         |                     dd¦  «                             |j        d         d¦  «        |         dd…ddf         z  cc<   t          ||         ¦  «        dd…dd…f                              dd¬¦  «        }||         }|j        d         d	k    r|d
         dk    nt          j        |d         d¦  «        }|  	                    ||||¦  «        }	| j
        �O|j        d         dk    s|j        d         dk    r-|                      |||¦  «        }|                     d¬¦  «        }|j        d         d	k    s|j        d         dk    r.|                      |d
         |                     ¦   «         ¦  «        }
|	|
|fS )aG  Calculate the keypoints loss for the model.

        This function calculates the keypoints loss and keypoints object loss for a given batch. The keypoints loss is
        based on the difference between the predicted keypoints and ground truth keypoints. The keypoints object loss is
        a binary classification loss that classifies whether a keypoint is present or not.

        Args:
            masks (torch.Tensor): Binary mask tensor indicating object presence, shape (BS, N_anchors).
            target_gt_idx (torch.Tensor): Index tensor mapping anchors to ground truth objects, shape (BS, N_anchors).
            keypoints (torch.Tensor): Ground truth keypoints, shape (N_kpts_in_batch, N_kpts_per_object, kpts_dim).
            batch_idx (torch.Tensor): Batch index tensor for keypoints, shape (N_kpts_in_batch, 1).
            stride_tensor (torch.Tensor): Stride tensor for anchors, shape (N_anchors, 1).
            target_bboxes (torch.Tensor): Ground truth boxes in (x1, y1, x2, y2) format, shape (BS, N_anchors, 4).
            pred_kpts (torch.Tensor): Predicted keypoints, shape (BS, N_anchors, N_kpts_per_object, kpts_dim).

        Returns:
            kpts_loss (torch.Tensor): The keypoints loss.
            kpts_obj_loss (torch.Tensor): The keypoints object loss.
            rle_loss (torch.Tensor): The RLE loss.
        r   .Nr…   r   rd   Tre   r®   r¥  rÏ   r¥   r¦   r%  )r£  rP   rk   r�  rl   r   rm  rI   r¦  r‹  r°  rÎ  rÇ  rƒ  r   )r#   rX  r7  r‘  r  r3  rz   rÊ   r¢  r§  r¨  r°  r©  rÍ   rª  rÌ   s                   r%   r”  z#PoseLoss26.calculate_keypoints_loss»  sí  € ð> "×:Ò:¸9ÀiÐQ^Ð`eÑfÔfÐàˆ	ØˆØˆà�9Š9‰;Œ;ñ 	RØ˜]Ñ*ˆMØ'¨Ô.ˆFØ�3˜˜˜�7ˆOˆOŒO˜}×1Ò1°!°RÑ8Ô8×?Ò?ÀÄÈAÄÐPRÑSÔSÐTYÔZÐ[\Ð[\Ð[\Ð^bÐdhÐ[hÔiÑiˆOˆO‰OÝ˜]¨5Ô1Ñ2Ô2°1°1°1°a°b°b°5Ô9×>Ò>¸qÈ$Ð>ÑOÔOˆDØ  Ô'ˆHØ.4¬l¸2Ô.>À!Ò.CÐ.C�v˜f”~¨Ò*Ð*ÍÌÐY_Ð`fÔYgÐimÑInÔInˆHØ×*Ò*¨8°V¸XÀtÑLÔLˆIàŒ}Ð(¨h¬n¸RÔ.@ÀAÒ.EÐ.EÈÌÐXZÔI[Ð_`ÒI`ÐI`Ø×2Ò2°8¸VÀXÑNÔN�Ø#Ÿ>š>¨a˜>Ñ0Ô0�ØŒ~˜bÔ! QÒ&Ð&¨(¬.¸Ô*<ÀÒ*AÐ*AØ $§¢¨h°vÔ.>ÀÇÂÑ@PÔ@PÑ QÔ Q�à˜-¨Ð1Ð1r&   rG  rH  rJ  r«  )rª  r(   r+   r(   )rª  r(   r©  r(   rÌ   r(   r+   r(   )rX  r(   r7  r(   r‘  r(   r  r(   r3  r(   rz   r(   rÊ   r(   r+   rÏ  )r>   r?   r@   rA   r!   r:   rz  r’  r·  rÎ  r”  rB   rC   s   @r%   r­  r­  7  sÍ   ø€ € € € € ØiÐið SWðð ð ð ð ð ð ð 9Lð 9Lð 9Lð 9Lðv ðð ð ñ „\ððeð eð eð eð(Ið (Ið (Ið (IðT42ð 42ð 42ð 42ð 42ð 42ð 42ð 42r&   r­  c                  ó   — e Zd ZdZd
d„Zd	S )Úv8ClassificationLosszACriterion class for computing training losses for classification.r  r   r  r  r+   r@  c                ó¸   — t          |t          t          f¦  «        r|d         n|}t          j        ||d         d¬¦  «        }|d|                     ¦   «         ifS )zDCompute the classification loss between predictions and true labels.r   r   r7   r0   r:   )r=  ÚlistrÁ   r5   Úcross_entropyr,  )r#   r  r  r:   s       r%   rr   zv8ClassificationLoss.__call__õ  sT   € å& u­tµU¨mÑ<Ô<ÐG��a”�À%ˆÝŒ˜u e¨E¤l¸fÐEÑEÔEˆØ�f˜dŸkšk™mœmÐ,Ð,Ð,r&   N©r  r   r  r  r+   r@  )r>   r?   r@   rA   rr   rK  r&   r%   rÒ  rÒ  ò  s.   € € € € € ØKÐKð-ð -ð -ð -ð -ð -r&   rÒ  c                  óF   ‡ — e Zd ZdZddˆ fd„Zdd„Zdd„Zdd„Zd d„Zˆ xZ	S )!Ú	v8OBBLosszdCalculates losses for object detection, classification, and box distribution in rotated YOLO models.rØ   NrÙ   rÚ   rÜ   rÝ   c                ó>  •— t          ¦   «                              ||¬¦  «         g | j        ¢d‘R | _        t          || j        dd| j                             ¦   «         |¬¦  «        | _        t          | j	        ¦  «         
                    | j        ¦  «        | _        dS )z^Initialize v8OBBLoss with model, assigner, and rotated bbox loss; model must be de-paralleled.©rÛ   Ú
angle_lossr·   râ   rã   N)r    r!   rð   r   rí   r   rò   ró   r¡   rY   rQ   r.   rô   rT  s       €r%   r!   zv8OBBLoss.__init__ÿ  s•   ø€ å‰Œ×Ò˜¨ÐÑ2Ô2Ð2Ø:˜DœOÐ:¨\Ð:Ð:ˆŒÝ2ØØœØØØ”;×%Ò%Ñ'Ô'Øð
ñ 
ô 
ˆŒõ )¨¬Ñ6Ô6×9Ò9¸$¼+ÑFÔFˆŒˆˆr&   rù   r(   rú   rZ   rû   r+   c                ó8  — |j         d         dk    rt          j        |dd| j        ¬¦  «        }�ni|dd…df                              ¦   «         }|                     d¬¦  «        \  }}|                     t          j        ¬¦  «        }t          j        ||                     ¦   «         d| j        ¬¦  «        }|dd…dd…f          	                    ¦   «         }|dd…dd	…f          
                    |¦  «         t          j        |dz   t          j        | j        ¬
¦  «        }	|	                     d|dz   t          j        |¦  «        ¦  «         |	                     d¦  «        }	t          j        t          |¦  «        | j        ¬¦  «        |	|         z
  }
||||
f<   |S )z7Preprocess targets for oriented bounding box detection.r   r´  rý   NTrþ   r   r   r¦   rè   )rl   rI   r  r.   rh   r  rQ   r  r  r“  r  r  r  r  rõ   rž   )r#   rù   rú   rû   r  r  rÃ   r  Úpacked_targetsr  r  s              r%   r  zv8OBBLoss.preprocess  st  € àŒ=˜Ô˜qÒ Ð Ý”+˜j¨!¨Q°t´{ÐCÑCÔCˆC‰Cà    1 œ×*Ò*Ñ,Ô,ˆIØ!×(Ò(°tÐ(Ñ<Ô<‰IˆAˆvØ—Y’Y¥U¤[�YÑ1Ô1ˆFÝ”+˜j¨&¯*ª*©,¬,¸À$Ä+ÐNÑNÔNˆCØ$ Q Q Q¨¨¨ Uœ^×1Ò1Ñ3Ô3ˆNØ˜1˜1˜1˜a ˜c˜6Ô"×'Ò'¨Ñ5Ô5Ð5Ý”k *¨q¡.½¼
È4Ì;ÐWÑWÔWˆGØ× Ò   I°¡Mµ5´?À9Ñ3MÔ3MÑNÔNÐNØ—n’n QÑ'Ô'ˆGÝœ¥c¨'¡l¤l¸4¼;ÐGÑGÔGÈ'ÐR[ÔJ\Ñ\ˆJØ)7ˆC�	˜:Ð%Ñ&Øˆ
r&   r  r  r  r@  c                ó
  — t          j        d| j        ¬¦  «        }|d                              ddd¦  «                             ¦   «         |d                              ddd¦  «                             ¦   «         |d                              ddd¦  «                             ¦   «         }}}t          |d	         | j        d
¦  «        \  }}|j        d         }	|j        }
t          j	        |d	         d         j        dd…         | j        |
¬¦  «        | j        d         z  }	 |d          
                    dd¦  «        }t          j        ||d          
                    dd¦  «        |d          
                    dd¦  «        fd¦  «        }|dd…df         t          |d         ¦  «        z  |dd…df         t          |d         ¦  «        z  }}||dk    |dk    z           }|                      |                     | j        ¦  «        |	|g d¢         ¬¦  «        }|                     dd¦  «        \  }}|                     dd¬¦  «                             d¦  «        }n"# t$          $ r}t'          d¦  «        |‚d}~ww xY w|                      |||¦  «        }|                     ¦   «                              ¦   «         }|ddd…fxx         |z  cc<   |                      |                     ¦   «                              ¦   «         |                     |j        ¦  «        ||z  |||¦  «        \  }}}}}t5          |                     ¦   «         d¦  «        }|                      ||                     |
¦  «        ¦  «        }| j        �
|| j        z  }|                     ¦   «         |z  |d<   |                     ¦   «         rr|ddd…fxx         |z  cc<   |                      |||||||||¦	  «	        \  |d<   |d<   ||                              d¦  «        }|                      |||||¦  «        |d<   nD|dxx         |dz                       ¦   «         |ddd…f                              ¦   «         z   z  cc<   |dxx         | j        j         z  cc<   |dxx         | j        j!        z  cc<   |dxx         | j        j"        z  cc<   |dxx         | j        j#        z  cc<   ||	z  tI          tK          | j&        |                     ¦   «         ¦  «        ¦  «        fS )zBCalculate and return the loss for oriented bounding box detection.r¥   rý   r  r   r…   r   r  Úangler  r·   NrN   r  rd   r   r!  r¦   r"  r#  )r   r¦   Tre   r$  ug  ERROR â�Œ OBB dataset incorrectly formatted or not a OBB dataset.
This error can occur when incorrectly training a 'OBB' model on a 'detect' dataset, i.e. 'yolo train model=yolo26n-obb.pt data=coco8.yaml'.
Verify your dataset is a correctly formatted 'OBB' dataset using 'data=dota8.yaml' as an example.
See https://docs.ultralytics.com/datasets/obb for help..r®   )'rI   r  r.   r'  r(  r   r   rl   rO   rJ   rk   r)  r   r  rQ   r*  r8   r+  ÚRuntimeErrorÚ	TypeErrorr  r“  r,  ró   r2   r4   r  r¼   rá   rô   Úcalculate_angle_lossrì   r-  r   r.  rß  r/  r0  rð   )r#   r  r  r:   r1  r2  Ú
pred_anglery   r3  rú   rO   r~   r  rù   ÚrwÚrhr4  r5  r6  rÕ   rx   Úbboxes_for_assignerrÃ   rz   r{   r}   r|   r8  r9   s                                r%   r:   zv8OBBLoss.loss  s  € õ Œ{˜1 T¤[Ð1Ñ1Ô1ˆà�'ŒN×"Ò" 1 a¨Ñ+Ô+×6Ò6Ñ8Ô8Ø�(ŒO×#Ò# A q¨!Ñ,Ô,×7Ò7Ñ9Ô9Ø�'ŒN×"Ò" 1 a¨Ñ+Ô+×6Ò6Ñ8Ô8ð #-�[ˆõ
 (4°E¸'´NÀDÄKÐQTÑ'UÔ'UÑ$ˆ�}ØÔ% aÔ(ˆ
àÔ!ˆÝ”˜U 7œ^¨AÔ.Ô4°Q°R°RÔ8ÀÄÐTYÐZÑZÔZÐ]aÔ]hÐijÔ]kÑkˆð	Ø˜kÔ*×/Ò/°°AÑ6Ô6ˆIÝ”i ¨E°%¬L×,=Ò,=¸bÀ!Ñ,DÔ,DÀeÈHÄo×FZÒFZÐ[]Ð_`ÑFaÔFaÐ bÐdeÑfÔfˆGØ˜Q˜Q˜Q ˜T”]¥U¨5°¬8¡_¤_Ñ4°g¸a¸a¸aÀ¸d´mÅeÈEÐRSÌHÁoÄoÑ6U�ˆBØ˜r Qšw¨2°ª7Ñ3Ô4ˆGØ—o’o g§j¢j°´Ñ&=Ô&=¸zÐX]Ð^jÐ^jÐ^jÔXk�oÑlÔlˆGØ#*§=¢=°¸Ñ#;Ô#;Ñ ˆI�yØ—m’m A¨t�mÑ4Ô4×8Ò8¸Ñ=Ô=ˆGˆGøÝð 	ð 	ð 	ÝðZñô ð ðøøøøð	øøøð ×&Ò& }°kÀ:ÑNÔNˆà)×/Ò/Ñ1Ô1×8Ò8Ñ:Ô:Ðà˜C  ! ˜GÐ$Ð$Ô$¨Ñ5Ð$Ð$Ñ$Ø6:·m²mØ×ÒÑ Ô ×(Ò(Ñ*Ô*Ø×$Ò$ Y¤_Ñ5Ô5Ø˜MÑ)ØØØñ7
ô 7
Ñ3ˆˆ=˜-¨°!õ   × 1Ò 1Ñ 3Ô 3°QÑ7Ô7Ðð —8’8˜K¨×)9Ò)9¸%Ñ)@Ô)@ÑAÔAˆØÔÐ)Ø˜Ô*Ñ*ˆHØ—,’,‘.”.Ð#4Ñ4ˆˆQ‰ð �;Š;‰=Œ=ð 	KØ˜#˜r ˜r˜'Ð"Ð"Ô" mÑ3Ð"Ð"Ñ"Ø#Ÿ~š~ØØØØØØ!ØØØñ
 ô 
 ÑˆD�‰G�T˜!‘Wð # 7Ô+×/Ò/°Ñ3Ô3ˆFØ×/Ò/Ø˜]¨G°VÐ=Nñô ˆD�‰GˆGð �ˆGˆGŒG˜
 Q™×+Ò+Ñ-Ô-°¸CÀÀ!À¸GÔ0D×0HÒ0HÑ0JÔ0JÑJÑJˆGˆG‰GàˆQˆˆŒ�4”8”<Ñˆˆ‰ØˆQˆˆŒ�4”8”<Ñˆˆ‰ØˆQˆˆŒ�4”8”<Ñˆˆ‰ØˆQˆˆŒ�4”8”>Ñ!ˆˆ‰à�jÑ ¥$¥s¨4¬?¸D¿KºK¹M¼MÑ'JÔ'JÑ"KÔ"KÐKÐKs   Ä D:I É
I:É%I5É5I:ry   r^   rã  c                ó0  — | j         ri|j        \  }}}|                     ||d|dz  ¦  «                             d¦  «                             | j                             |j        ¦  «        ¦  «        }t          j	        t          |||¦  «        |fd¬¦  «        S )a°  Decode predicted object bounding box coordinates from anchor points and distribution.

        Args:
            anchor_points (torch.Tensor): Anchor points, (h*w, 2).
            pred_dist (torch.Tensor): Predicted rotated distance, (bs, h*w, 4).
            pred_angle (torch.Tensor): Predicted angle, (bs, h*w, 1).

        Returns:
            (torch.Tensor): Predicted rotated bounding boxes with angles, (bs, h*w, 5).
        r¥   r®   rd   rb   )rï   rl   rk   r  r  rö   r4   rO   rI   r)  r   )r#   ry   r^   rã  r  r  r  s          r%   r  zv8OBBLoss.bbox_decodeu  sŒ   € ð Œ<ð 	kØ”o‰GˆAˆq�!Ø!Ÿš q¨!¨Q°°Q±Ñ7Ô7×?Ò?ÀÑBÔB×IÒIÈ$Ì)Ï.Ê.ÐYbÔYhÑJiÔJiÑjÔjˆIÝŒy�) I¨z¸=ÑIÔIÈ:ÐVÐ\^Ð_Ñ_Ô_Ð_r&   r®   c                ó²  — |d         }|d         }|d         }	|d         }
t          j        |dz   |dz   z  ¦  «        }t          j        |dz   |dz  z  ¦  «        }|	|
z
  }|t          j        |t          j        z  ¦  «        t          j        z  z
  }t          j        d||         z  ¦  «        dz  }||         |z  }||z  }|                     ¦   «         |z  S )aƒ  Calculate oriented angle loss.

        Args:
            pred_bboxes (torch.Tensor): Predicted bounding boxes with shape [N, 5] (x, y, w, h, theta).
            target_bboxes (torch.Tensor): Target bounding boxes with shape [N, 5] (x, y, w, h, theta).
            fg_mask (torch.Tensor): Foreground mask indicating valid predictions.
            weight (torch.Tensor): Loss weights for each prediction.
            target_scores_sum (torch.Tensor): Sum of target scores for normalization.
            lambda_val (int): Controls the sensitivity to aspect ratio.

        Returns:
            (torch.Tensor): The calculated angle loss.
        r¥  ).r®   ).r¥   rÑ   r…   )rI   r›   rÒ   ÚroundÚmathÚpiÚsinr8   )r#   rx   rz   r}   r9   r|   Ú
lambda_valÚw_gtÚh_gtÚ
pred_thetaÚtarget_thetaÚlog_arÚscale_weightÚdelta_thetaÚdelta_theta_wrappedÚang_losss                   r%   râ  zv8OBBLoss.calculate_angle_loss‡  sá   € ð ˜VÔ$ˆØ˜VÔ$ˆØ  Ô(ˆ
Ø$ VÔ,ˆå”˜D 4™K¨D°4©KÑ8Ñ9Ô9ˆÝ”y 6¨1¡9 °¸Q±Ñ!?Ñ@Ô@ˆà  <Ñ/ˆØ)­E¬K¸ÅdÄgÑ8MÑ,NÔ,NÕQUÔQXÑ,XÑXÐÝ”9˜QÐ!4°WÔ!=Ñ=Ñ>Ô>À!ÑCˆà Ô(¨8Ñ3ˆØ˜fÑ$ˆà�|Š|‰~Œ~Ð 1Ñ1Ð1r&   rG  ©rÙ   rÚ   rÜ   rÝ   rI  rJ  )ry   r(   r^   r(   rã  r(   r+   r(   )r®   )
r>   r?   r@   rA   r!   r  r:   r  râ  rB   rC   s   @r%   rØ  rØ  ü  s¬   ø€ € € € € ØnÐnðGð Gð Gð Gð Gð Gð Gðð ð ð ð$TLð TLð TLð TLðl`ð `ð `ð `ð$2ð 2ð 2ð 2ð 2ð 2ð 2ð 2r&   rØ  c                  ó:   — e Zd ZdZdd„Zedd
„¦   «         Zdd„ZdS )ÚDepthLoss26a   Criterion class for computing training losses for YOLO depth estimation.

    Uses scale-invariant log loss (SILog) + gradient-matching loss, following the Depth Anything approach. SILog handles
    scale ambiguity while gradient loss preserves edges.
    rÙ   rÚ   c                óÒ   — t          |                     ¦   «         ¦  «        j        }|| _        |j        }|j        | _        |j        | _        |j        | _	        d| _
        d| _        dS )zInitialize DepthLoss26.r¥   )Ú	dlog_lossÚ
dgrad_lossN)ré   rê   r.   rë   ÚdlogÚsilog_weightÚdgradÚgrad_weightÚdlamÚsilog_lambdaÚgrad_scalesrð   )r#   rÙ   r.   r÷   s       r%   r!   zDepthLoss26.__init__®  s]   € å�e×&Ò&Ñ(Ô(Ñ)Ô)Ô0ˆØˆŒØŒJˆØœFˆÔØœ7ˆÔØœFˆÔØˆÔØ3ˆŒˆˆr&   Úpred_logr(   Úgt_logÚvalid_fr+   c                óð  — | dd…dd…dd…dd…f         | dd…dd…dd…dd…f         z
  |dd…dd…dd…dd…f         z  |dd…dd…dd…dd…f         z  }|dd…dd…dd…dd…f         |dd…dd…dd…dd…f         z
  |dd…dd…dd…dd…f         z  |dd…dd…dd…dd…f         z  }| dd…dd…dd…dd…f         | dd…dd…dd…dd…f         z
  |dd…dd…dd…dd…f         z  |dd…dd…dd…dd…f         z  }|dd…dd…dd…dd…f         |dd…dd…dd…dd…f         z
  |dd…dd…dd…dd…f         z  |dd…dd…dd…dd…f         z  }t          j        ||¦  «        t          j        ||¦  «        z   S )zæL1 between predicted and GT log-depth spatial gradients (dx, dy), gated by the valid mask.

        Each gradient is zeroed unless both contributing pixels are valid, so edges are only
        matched where GT is defined.
        Nr   rd   )r5   r‡   )r  r  r  Úpred_dxÚgt_dxÚpred_dyÚgt_dys          r%   Ú_grad_l1zDepthLoss26._grad_l1¹  s—  € ð ˜A˜A˜A˜q˜q˜q ! ! ! Q R R˜KÔ(¨8°A°A°A°q°q°q¸!¸!¸!¸S¸b¸S°LÔ+AÑAÀWÈQÈQÈQÐPQÐPQÐPQÐSTÐSTÐSTÐVWÐVXÐVXÈ[ÔEYÑYÐ\cÐdeÐdeÐdeÐghÐghÐghÐjkÐjkÐjkÐmpÐnpÐmpÐdpÔ\qÑqˆØ˜˜˜˜1˜1˜1˜a˜a˜a   ˜Ô$ v¨a¨a¨a°°°°A°A°A°s¸°s¨lÔ';Ñ;¸wÀqÀqÀqÈ!È!È!ÈQÈQÈQÐPQÐPRÐPRÀ{Ô?SÑSÐV]Ð^_Ð^_Ð^_ÐabÐabÐabÐdeÐdeÐdeÐgjÐhjÐgjÐ^jÔVkÑkˆØ˜A˜A˜A˜q˜q˜q ! " " a a a˜KÔ(¨8°A°A°A°q°q°q¸#¸2¸#¸q¸q¸q°LÔ+AÑAÀWÈQÈQÈQÐPQÐPQÐPQÐSTÐSUÐSUÐWXÐWXÐWXÈ[ÔEYÑYÐ\cÐdeÐdeÐdeÐghÐghÐghÐjmÐkmÐjmÐopÐopÐopÐdpÔ\qÑqˆØ˜˜˜˜1˜1˜1˜a˜b˜b ! ! !˜Ô$ v¨a¨a¨a°°°°C°R°C¸¸¸¨lÔ';Ñ;¸wÀqÀqÀqÈ!È!È!ÈQÈRÈRÐQRÐQRÐQRÀ{Ô?SÑSÐV]Ð^_Ð^_Ð^_ÐabÐabÐabÐdgÐegÐdgÐijÐijÐijÐ^jÔVkÑkˆÝŒy˜ %Ñ(Ô(­1¬9°W¸eÑ+DÔ+DÑDÐDr&   r  ú&dict[str, torch.Tensor] | torch.Tensorr  r  r@  c                óÌ  — t          j        d| j        ¬¦  «        }t          |t          ¦  «        r|d         n|}|d                              | j        ¦  «        }|j        dk    r|                     d¦  «        }|j        dd…         |j        dd…         k    r%t          j
        ||j        dd…         dd	¬
¦  «        }|dk    }|                     ¦   «         dk     rK|                     ¦   «         dz  t	          t          | j        |                     ¦   «         ¦  «        ¦  «        fS ||         }||         }|                     d¬¦  «        }t          j        |¦  «        t          j        |¦  «        z
  }	|	                     ¦   «         }
t          j        |	|
z
  dz                       ¦   «         d| j        z
  |
dz  z  z   dz   ¦  «        }|| j        z  |d<   t          j        |                     d¬¦  «        ¦  «        }t          j        |                     d¬¦  «        ¦  «        }|                     ¦   «         }|                      |||¦  «        }t/          dt1          | j        d¦  «        ¦  «        D �]}|j        d         dk     s|j        d         dk     r n÷t          j        |d¦  «        }|dk    }|                     d¬¦  «        d|                     d¬¦  «        z  k                         dddd¦  «        }|                     ¦   «         s n|                     d¬¦  «        }t          j        ||z  d¦  «        |z  }t          j        ||z  d¦  «        |z  }|                     ¦   «         |z  }||                      |||¦  «        z   }�Œ|| j        z  |d<   ||j        d         z  t	          t          | j        |                     ¦   «         ¦  «        ¦  «        fS )aÄ  Calculate depth estimation loss.

        Args:
            preds (dict | torch.Tensor): Dict with "depth" key or raw tensor of (B, 1, H, W) predicted depth.
            batch (dict): Dict with "depth" key holding (B, H, W) ground truth depth in meters.

        Returns:
            loss_sum (torch.Tensor): Total loss scaled by batch size.
            loss_items (dict[str, torch.Tensor]): Detached silog/gradient losses keyed by loss_names.
        r…   rý   Údepthr®   r   r¾   NrY  T©r¯   rÀ   rZ  gü©ñÒMbP?rØ   r$  r%  rM   r©   r   rd   r¥   )r   r…   r®   rb   gffffffæ?)rI   r  r.   r=  r/  rQ   Úndimrœ   rl   r5   rÂ   r8   r0  rð   r,  rÇ  r›   r7   Úsqrtr  rþ  r   r  r]  r  r  Ú
avg_pool2drk   rP   r   )r#   r  r  r:   Ú
pred_depthÚgt_depthÚvalidÚ
pred_validÚgt_validÚlog_diffrø   Úsilogr  r  r  Ú	grad_lossrÃ   ÚvpÚoccupiedÚkeepÚdenoms                        r%   rr   zDepthLoss26.__call__Æ  s’  € õ Œ{˜1 T¤[Ð1Ñ1Ô1ˆÝ'1°%½Ñ'>Ô'>ÐI�U˜7”^�^ÀEˆ
Ø˜”>×$Ò$ T¤[Ñ1Ô1ˆàŒ=˜AÒÐØ×)Ò)¨!Ñ,Ô,ˆHàŒ>˜"˜#˜#Ô *Ô"2°2°3°3Ô"7Ò7Ð7Ýœ z¸¼ÀrÀsÀsÔ8KÐR\ÐlpÐqÑqÔqˆJà˜5Ò ˆØ�9Š9‰;Œ;˜ÒÐà—>’>Ñ#Ô# cÑ)­4µ°D´OÀTÇ[Â[Á]Ä]Ñ0SÔ0SÑ+TÔ+TÐTÐTà Ô&ˆ
Ø˜E”?ˆà×%Ò%¨%Ð%Ñ0Ô0ˆ
å”9˜ZÑ(Ô(­5¬9°XÑ+>Ô+>Ñ>ˆà�MŠM‰OŒOˆÝ”
˜X¨™\¨aÑ/×5Ò5Ñ7Ô7¸3ÀÔARÑ;RÐVWÐYZÑVZÑ:ZÑZÐ]aÑaÑbÔbˆØ˜$Ô+Ñ+ˆˆQ‰õ ”9˜Z×-Ò-°%Ð-Ñ8Ô8Ñ9Ô9ˆÝ”˜8Ÿ>š>¨e˜>Ñ4Ô4Ñ5Ô5ˆØ—+’+‘-”-ˆØ—M’M (¨F°GÑ<Ô<ˆ	Ý�q�#˜dÔ.°Ñ2Ô2Ñ3Ô3ð 	Mñ 	MˆAØŒ~˜bÔ! AÒ%Ð%¨¬¸Ô);¸aÒ)?Ð)?Ø�Ý”˜g qÑ)Ô)ˆBØ˜A’vˆHà—F’F˜y�FÑ)Ô)¨C°(·,²,À9°,Ñ2MÔ2MÑ,MÒM×SÒSÐTVÐXYÐ[\Ð^_Ñ`Ô`ˆDØ—8’8‘:”:ð Ø�Ø—H’H �HÑ&Ô&ˆEÝ”| H¨wÑ$6¸Ñ:Ô:¸UÑBˆHÝ”\ &¨7Ñ"2°AÑ6Ô6¸Ñ>ˆFØ—n’nÑ&Ô&¨Ñ-ˆGØ! D§M¢M°(¸FÀGÑ$LÔ$LÑLˆI‰IØ˜dÔ.Ñ.ˆˆQ‰à�jÔ& qÔ)Ñ)­4µ°D´OÀTÇ[Â[Á]Ä]Ñ0SÔ0SÑ+TÔ+TÐTÐTr&   N©rÙ   rÚ   )r  r(   r  r(   r  r(   r+   r(   )r  r  r  r  r+   r@  )r>   r?   r@   rA   r!   rz  r  rr   rK  r&   r%   rù  rù  §  sp   € € € € € ðð ð	4ð 	4ð 	4ð 	4ð ð
Eð 
Eð 
Eñ „\ð
Eð<Uð <Uð <Uð <Uð <Uð <Ur&   rù  c                  ó"   — e Zd ZdZdd„Zdd„ZdS )ÚE2EDetectLossúGCriterion class for computing training losses for end-to-end detection.rÙ   rÚ   c                ó^   — t          |d¬¦  «        | _        t          |d¬¦  «        | _        dS )zcInitialize E2EDetectLoss with one-to-many and one-to-one detection losses using the provided model.rØ   rÚ  r   N)r×   Úone2manyÚone2one)r#   rÙ   s     r%   r!   zE2EDetectLoss.__init__  s.   € å'¨¸Ð;Ñ;Ô;ˆŒÝ& u°qÐ9Ñ9Ô9ˆŒˆˆr&   r  r   r  r  r+   r@  c                ó  ‡‡— t          |t          ¦  «        r|d         n|}|d         }|                      ||¦  «        Š|d         }|                      ||¦  «        Š‰d         ‰d         z   ˆˆfd„‰d         D ¦   «         fS )rB  r   r%  r&  r   c                óL   •— i | ] }|‰d          |         ‰d          |         z   “Œ!S )r   rK  )r¾  ÚkÚloss_one2manyÚloss_one2ones     €€r%   ú
<dictcomp>z*E2EDetectLoss.__call__.<locals>.<dictcomp>  s@   ø€ ð 4
ð 4
ð 4
Ø<=ˆAˆ}˜QÔ Ô" \°!¤_°QÔ%7Ñ7ð4
ð 4
ð 4
r&   )r=  rÁ   r%  r&  ©r#   r  r  r%  r&  r*  r+  s        @@r%   rr   zE2EDetectLoss.__call__  s¥   øø€ å& u­eÑ4Ô4Ð?��a”�¸%ˆØ˜Ô$ˆØŸš h°Ñ6Ô6ˆØ˜	Ô"ˆØ—|’| G¨UÑ3Ô3ˆØ˜QÔ ,¨q¤/Ñ1ð 4
ð 4
ð 4
ð 4
ð 4
ØANÈqÔAQð4
ñ 4
ô 4
ð 
ð 	
r&   Nr   rÖ  )r>   r?   r@   rA   r!   rr   rK  r&   r%   r"  r"    sB   € € € € € ØQÐQð:ð :ð :ð :ð
	
ð 	
ð 	
ð 	
ð 	
ð 	
r&   r"  c                  ó6   — e Zd ZdZefdd„Zdd„Zdd„Zdd„ZdS )ÚE2ELossr#  rÙ   rÚ   c                óÈ   —  ||d¬¦  «        | _          ||dd¬¦  «        | _        d| _        d| _        d| _        | j        | j        z
  | _        | j        | _        d	| _        d
S )z]Initialize E2ELoss with one-to-many and one-to-one detection losses using the provided model.rØ   rÚ  é   r   )rÛ   rÜ   r   rM   gš™™™™™é?gš™™™™™¹?N)r%  r&  ÚupdatesÚtotalÚo2mÚo2oÚo2m_copyÚ	final_o2m)r#   rÙ   Úloss_fns      r%   r!   zE2ELoss.__init__  si   € à˜ °Ð3Ñ3Ô3ˆŒØ�w˜u¨q¸AÐ>Ñ>Ô>ˆŒØˆŒØˆŒ
àˆŒØ”: ¤Ñ(ˆŒØœˆŒàˆŒˆˆr&   r  r   r  r  r+   r@  c                ó  — | j                              |¦  «        }|d         |d         }}| j                              ||¦  «        }| j                             ||¦  «        }|d         | j        z  |d         | j        z  z   |d         fS )rB  r%  r&  r   r   )r%  r?  r:   r&  r4  r5  r-  s          r%   rr   zE2ELoss.__call__)  s„   € à”×*Ò*¨5Ñ1Ô1ˆØ! *Ô-¨u°YÔ/?�'ˆØœ×*Ò*¨8°UÑ;Ô;ˆØ”|×(Ò(¨°%Ñ8Ô8ˆØ˜QÔ $¤(Ñ*¨\¸!¬_¸t¼xÑ-GÑGÈÐVWÌÐXÐXr&   r[   c                ó¨   — | xj         dz  c_         |                      | j         ¦  «        | _        t          | j        | j        z
  d¦  «        | _        dS )zUUpdate the weights for one-to-many and one-to-one losses based on the decay schedule.r   r   N)r2  Údecayr4  r  r3  r5  )r#   s    r%   ÚupdatezE2ELoss.update1  sE   € àˆŒ˜ÑˆŒØ—:’:˜dœlÑ+Ô+ˆŒÝ�t”z D¤HÑ,¨aÑ0Ô0ˆŒˆˆr&   r   c                óž   — t          d|t          | j        j        j        dz
  d¦  «        z  z
  d¦  «        | j        | j        z
  z  | j        z   S )zSCalculate the decayed weight for one-to-many loss based on the current update step.r   r   )r  r&  rì   Úepochsr6  r7  )r#   Úxs     r%   r;  zE2ELoss.decay7  sL   € å�1�q�3˜tœ|Ô/Ô6¸Ñ:¸AÑ>Ô>Ñ>Ñ>ÀÑBÔBÀdÄmÐVZÔVdÑFdÑeÐhlÔhvÑvÐvr&   Nr   rÖ  )r+   r[   )r+   r   )	r>   r?   r@   rA   r×   r!   rr   r<  r;  rK  r&   r%   r/  r/    s|   € € € € € ØQÐQà7Fð ð ð ð ð ðYð Yð Yð Yð1ð 1ð 1ð 1ðwð wð wð wð wð wr&   r/  c                  ó<   — e Zd ZdZddd„Zdd„Zdd„Zdd„Zdd„ZdS )ÚTVPDetectLosszOCriterion class for computing training losses for text-visual prompt detection.rØ   NrÙ   rÚ   rÜ   rÝ   c                ó
  — t          |||¦  «        | _        t          d„ | j        j        D ¦   «         ¦  «        | _        | j        j        | _        | j        j        | _        | j        j        | _        | j        j	        | _
        dS )z^Initialize TVPDetectLoss with task-prompt and visual-prompt criteria using the provided model.c              3  ó*   K  — | ]}|d d…         V — Œd S )NéûÿÿÿrK  ©r¾  r)  s     r%   rÀ  z)TVPDetectLoss.__init__.<locals>.<genexpr>B  s*   è è € ÐMÐM¨1  # 2 #¤ÐMÐMÐMÐMÐMÐMr&   N)r×   Úvp_criterionrÁ   rð   rì   rí   Úori_ncrî   Úori_norY   Úori_reg_max)r#   rÙ   rÛ   rÜ   s       r%   r!   zTVPDetectLoss.__init__?  su   € å+¨E°8¸YÑGÔGˆÔÝÐMÐM°Ô0AÔ0LÐMÑMÔMÑMÔMˆŒàÔ$Ô(ˆŒØÔ'Ô*ˆŒØÔ'Ô*ˆŒØÔ,Ô4ˆÔÐÐr&   r+   r  c                ó6   — | j                              |¦  «        S )r<  )rF  r?  r>  s     r%   r?  zTVPDetectLoss.parse_outputI  s   € àÔ ×-Ò-¨eÑ4Ô4Ð4r&   r  r   r  r@  c                óT   — |                       |                      |¦  «        |¦  «        S )ú4Calculate the loss for text-visual prompt detection.rC  rD  s      r%   rr   zTVPDetectLoss.__call__M  ó$   € à�yŠy˜×*Ò*¨5Ñ1Ô1°5Ñ9Ô9Ð9r&   c                óÔ  — | j         |d         j        d         k    rWt          j        d| j        j        d¬¦  «        }|t          t          | j        | 	                    ¦   «         ¦  «        ¦  «        fS |  
                    |¦  «        |d<   |                      ||¦  «        }|d         d         t          t          | j        |d                              ¦   «         ¦  «        ¦  «        fS )rL  r  r   r®   T©r.   Úrequires_gradr   ©rG  rl   rI   r  rF  r.   r/  r0  rð   r,  Ú_get_vp_featuresÚvalues)r#   r  r  r:   Úvp_losss        r%   r:   zTVPDetectLoss.lossQ  sÄ   € ð Œ;˜% œ/Ô/°Ô2Ò2Ð2Ý”;˜q¨Ô):Ô)AÐQUÐVÑVÔVˆDØ��c $¤/°4·;²;±=´=ÑAÔAÑBÔBÐBÐBà×/Ò/°Ñ6Ô6ˆˆh‰Ø×#Ò# E¨5Ñ1Ô1ˆØ�qŒz˜!Œ}�d¥3 t¤¸À¼
×8IÒ8IÑ8KÔ8KÑ#LÔ#LÑMÔMÐMÐMr&   úlist[torch.Tensor]c                ó¢   — |d         }|j         d         }|| j        _        || j        j        dz  z   | j        _        || j        j        _        |S )z5Extract visual-prompt features from the model output.r  r   r¥   )rl   rF  rí   rY   rî   ró   rå   )r#   r  r  Úvncs       r%   rR  zTVPDetectLoss._get_vp_features]  sO   € à�x”ˆØŒl˜1Œoˆà"ˆÔÔØ" TÔ%6Ô%>ÀÑ%BÑBˆÔÔØ14ˆÔÔ"Ô.Øˆr&   rG  r÷  )r+   r  rÖ  rJ  )r  r  r+   rU  )	r>   r?   r@   rA   r!   r?  rr   r:   rR  rK  r&   r%   rA  rA  <  s‡   € € € € € ØYÐYð5ð 5ð 5ð 5ð 5ð5ð 5ð 5ð 5ð:ð :ð :ð :ð
Nð 
Nð 
Nð 
Nðð ð ð ð ð r&   rA  c                  ó6   ‡ — e Zd ZdZddˆ fd„Zdd„Zdd„Zˆ xZS )ÚTVPSegmentLosszRCriterion class for computing training losses for text-visual prompt segmentation.rØ   NrÙ   rÚ   rÜ   rÝ   c                óè   •— t          ¦   «                              |¦  «         t          |||¦  «        | _        t	          d„ | j        j        D ¦   «         ¦  «        | _        | j        j        | _        dS )z_Initialize TVPSegmentLoss with task-prompt and visual-prompt criteria using the provided model.c              3  ó6   K  — | ]}|d k    ¯|dd…         V — ŒdS )rP  NrD  rK  rE  s     r%   rÀ  z*TVPSegmentLoss.__init__.<locals>.<genexpr>o  s6   è è € Ð`Ð`¨1ÐPQÐU_ÒP_ÐP_  # 2 #¤ÐP_ÐP_ÐP_ÐP_Ð`Ð`r&   N)r    r!   rM  rF  rÁ   rð   rì   rT  s       €r%   r!   zTVPSegmentLoss.__init__k  sd   ø€ å‰Œ×Ò˜ÑÔÐÝ.¨u°hÀ	ÑJÔJˆÔÝÐ`Ð`°Ô0AÔ0LÐ`Ñ`Ô`Ñ`Ô`ˆŒØÔ$Ô(ˆŒˆˆr&   r  r   r  r  r+   r@  c                óT   — |                       |                      |¦  «        |¦  «        S )ú7Calculate the loss for text-visual prompt segmentation.rC  rD  s      r%   rr   zTVPSegmentLoss.__call__r  rM  r&   c                óØ  — | j         |d         j        d         k    rWt          j        d| j        j        d¬¦  «        }|t          t          | j        | 	                    ¦   «         ¦  «        ¦  «        fS |  
                    |¦  «        |d<   |                      ||¦  «        }|d         d         }|t          t          | j        |d                              ¦   «         ¦  «        ¦  «        fS )r]  r  r   r¥   TrO  r   r…   rQ  )r#   r  r  r:   rT  rà   s         r%   r:   zTVPSegmentLoss.lossv  sÇ   € àŒ;˜% œ/Ô/°Ô2Ò2Ð2Ý”;˜q¨Ô):Ô)AÐQUÐVÑVÔVˆDØ��c $¤/°4·;²;±=´=ÑAÔAÑBÔBÐBÐBà×/Ò/°Ñ6Ô6ˆˆh‰Ø×#Ò# E¨5Ñ1Ô1ˆØ˜1”:˜a”=ˆà��c $¤/°7¸1´:×3DÒ3DÑ3FÔ3FÑGÔGÑHÔHÐHÐHr&   rG  r÷  rÖ  )r>   r?   r@   rA   r!   rr   r:   rB   rC   s   @r%   rY  rY  h  sx   ø€ € € € € Ø\Ð\ð)ð )ð )ð )ð )ð )ð )ð:ð :ð :ð :ð
Ið 
Ið 
Ið 
Ið 
Ið 
Ið 
Ið 
Ir&   rY  c                  óB   ‡ — e Zd ZdZd
ˆ fd„Zd„ Zd„ Zd„ Zd„ Zd	„ Z	ˆ xZ
S )ÚSemanticSegmentationLosszÛLoss function for semantic segmentation using cross-entropy and Dice terms.

    Attributes:
        nc (int): Number of semantic classes.
        ce (nn.CrossEntropyLoss): Cross-entropy loss with ignore_index=255.
    rÙ   rÚ   c           	     ó¸  •— t          ¦   «                              ¦   «          |j        d         }|j        | _        t	          |                     ¦   «         ¦  «        j        | _        t	          |                     ¦   «         ¦  «        j        | _        t          t          t          |j        dd¦  «        pd¦  «        ¦  «        j                             ¦   «         }|dv o| j        t          t          ¦  «        k    | _        t          |dd¦  «        }|€ | j        rt#          j        t          ¦  «        }|€dn |                     | j        | j        ¬¦  «        }| j        dk    rt)          j        d	¬
¦  «        | _        dS t)          j        dd	¬¦  «                             | j        | j        ¬¦  «        | _        |�| j                             d|d¬¦  «         dS dS )zŽInitialize semantic segmentation loss.

        Args:
            model (torch.nn.Module): Model containing the SemanticSegment head.
        rd   ÚdataÚ >   Ú
cityscapesÚcityscapes8rá   NrN   r   r8   r0   éÿ   )Úignore_indexr1   r9   F)Ú
persistent)r    r!   rÙ   rí   ré   rê   r.   rO   r   r«   rñ   rë   ÚstemÚlowerrž   r   Úuse_cityscapes_weightrI   r„  rQ   r   r»   ÚceÚCrossEntropyLossÚregister_buffer)r#   rÙ   rø   Ú	data_namer9   r$   s        €r%   r!   z!SemanticSegmentationLoss.__init__‹  s   ø€ õ 	‰Œ×ÒÑÔÐØŒK˜ŒOˆØ”$ˆŒÝ˜5×+Ò+Ñ-Ô-Ñ.Ô.Ô5ˆŒÝ˜%×*Ò*Ñ,Ô,Ñ-Ô-Ô3ˆŒ
Ý��W U¤Z°¸Ñ<Ô<ÐBÀÑCÔCÑDÔDÔI×OÒOÑQÔQˆ	Ø%.Ð2OÐ%OÐ%uÐTXÔT[Õ_bÕctÑ_uÔ_uÒTuˆÔ"Ý˜ °Ñ6Ô6ˆØˆ>˜dÔ8ˆ>ÝÔ%Õ&7Ñ8Ô8ˆFØ˜��¨V¯YªY¸d¼kÐQUÔQ[¨YÑ-\Ô-\ˆØŒ7�aŠ<ˆ<ÝÔ*°UÐ;Ñ;Ô;ˆDŒGˆGˆGåÔ)°sÀeÐLÑLÔL×OÒOÐW[ÔWbÐjnÔjtÐOÑuÔuˆDŒGØÐ!à”×'Ò'¨°&ÀUÐ'ÑKÔKÐKÐKÐKð "Ð!r&   c                ó  — |j         dd…         |k    rlt          j        |                     ¦   «                              d¦  «        |d¬¦  «                             d¦  «                             t          j        ¦  «        S |S )z4Resize masks to match prediction spatial dimensions.r   Nr¿   )r¯   rÀ   )	rl   r5   rÂ   r   rœ   ÚsqueezerQ   rI   r  )r#   rX  Útarget_shapes      r%   Ú_resize_masksz&SemanticSegmentationLoss._resize_masks¤  so   € àŒ;�q�r�rŒ?˜lÒ*Ð*å”˜eŸkšk™mœm×5Ò5°aÑ8Ô8¸|ÐR[Ð\Ñ\Ô\×dÒdÐefÑgÔg×jÒjÕkpÔkvÑwÔwðð ˆr&   c                óL  — |                      d¦  «        }| j        dk    rJ|                      d¦  «        |         }||                              ¦   «         }|                     ¦   «         }n�|                     dddd¦  «                              d| j        ¦  «        }|                     ¦   «         }| j        j        €|                     ¦   «         n)| j        j        ||                                       ¦   «         }|                      ||¦  «        |                     d¦  «        z  S )zLCompute cross-entropy on flattened pixels to avoid the CUDA nll_loss2d path.rd   r   r   r…   r®   )	Úreshaperí   r   r8   r'  rh   rl  r9   Ú	clamp_min)r#   r  rX  r  ÚflatÚlogitsr_   Údenominators           r%   Ú_ce_lossz!SemanticSegmentationLoss._ce_loss¬  së   € à�}Š}˜RÑ Ô ˆØŒ7�aŠ<ˆ<Ø—]’] 2Ñ&Ô& uÔ-ˆFØ˜%”[×&Ò&Ñ(Ô(ˆFØŸ)š)™+œ+ˆKˆKà—]’] 1 a¨¨AÑ.Ô.×6Ò6°r¸4¼7ÑCÔCˆFØ—Y’Y‘[”[ˆFØ)-¬¬Ð)?˜%Ÿ)š)™+œ+˜+ÀTÄWÄ^ÐTZÐ[`ÔTaÔEb×EfÒEfÑEhÔEhˆKØ�wŠw�v˜vÑ&Ô&¨×)>Ò)>¸qÑ)AÔ)AÑAÐAr&   c           
     óR  — | j         dk    r|                      |||¦  «        S |                     d¦  «        }t          j        |d¬¦  «        }||                              ¦   «         }|                     ¦   «                              dddd¦  «                             d| j         ¦  «        |         }t          j	        | j         |j
        t          j        ¬¦  «        }|                     d||                     d|dd…df         ¦  «                             d¦  «        ¦  «         |                     d¬¦  «        }	t          j        |¦  «                             d|t          j        |t          j        ¬	¦  «        ¦  «        }
|	|
z   }d
d|z  d
z   |d
z   z  z
                       ¦   «         S )z*Compute Dice loss excluding ignore pixels.r   rd   rb   r   r…   r®   rN   Nr   rM   r   )rí   Ú_binary_dice_lossru  r5   r  rh   r   r'  rI   r  r.   r‡  r  rj   rq  r8   Ú
zeros_liker  r7   )r#   r  rX  r  Úflat_targetÚ	pred_softr_   Ú	flat_predr°   Úpred_sumÚ
target_sumÚcardinalitys               r%   Ú
_dice_lossz#SemanticSegmentationLoss._dice_loss¹  s{  € àŒ7�aŠ<ˆ<Ø×)Ò)¨%°¸Ñ>Ô>Ð>Ø—m’m BÑ'Ô'ˆÝ”I˜e¨Ð+Ñ+Ô+ˆ	Ø˜UÔ#×(Ò(Ñ*Ô*ˆØ—O’OÑ%Ô%×-Ò-¨a°°A°qÑ9Ô9×AÒAÀ"ÀdÄgÑNÔNÈuÔUˆ	Ý”{ 4¤7°5´<ÅuÄ}ÐUÑUÔUˆØ×!Ò! ! V¨Y×-=Ò-=¸aÀÈÈÈÈ4ÈÄÑ-QÔ-Q×-YÒ-YÐZ[Ñ-\Ô-\Ñ]Ô]Ð]Ø—=’= Q�=Ñ'Ô'ˆÝÔ% lÑ3Ô3×@Ò@Øˆv•u” vµU´]ÐCÑCÔCñ
ô 
ˆ
ð  Ñ+ˆØ�s˜\Ñ)¨CÑ/°KÀ#Ñ4EÑFÑF×LÒLÑNÔNÐNr&   c                óX  — |                      |¦  «                             ¦   «         }|                     d¦  «                             ¦   «         }|dk                         ¦   «         }||z  |z                       ¦   «         }||z   |z                       ¦   «         }dd|z  dz   |dz   z  z
  S )z¢Compute Dice loss for single-class (binary) segmentation.

        Pixels with value 255 are excluded from Dice terms to match BCE valid-pixel filtering.
        r   rM   r   )Ú
reshape_asr   rq  r2   r8   )r#   r  rX  r  r  r_   r°   rƒ  s           r%   r|  z*SemanticSegmentationLoss._binary_dice_lossÊ  sª   € ð
 × Ò  Ñ'Ô'×-Ò-Ñ/Ô/ˆØ—M’M !Ñ$Ô$×,Ò,Ñ.Ô.ˆ	Ø˜1’*×#Ò#Ñ%Ô%ˆØ! FÑ*¨UÑ2×7Ò7Ñ9Ô9ˆØ! FÑ*¨eÑ3×8Ò8Ñ:Ô:ˆØ�c˜LÑ(¨3Ñ.°;ÀÑ3DÑEÑEÐEr&   c                óF  — d}t          |t          ¦  «        r|\  }}|d                              |j        ¦  «        }|                     d¦  «        dk    }|j        dd…         |j        dd…         k    r%t          j        ||j        dd…         dd¬	¦  «        }|                      |||¦  «        }|  	                    |||¦  «        }||z   }t          j        d
|j        |j        ¬¦  «        }	|�d|j        dd…         |j        dd…         k    r%t          j        ||j        dd…         dd¬	¦  «        }|                      |||¦  «        dz  }	||	z  }|                     ¦   «         |                     ¦   «         |	                     ¦   «         dœ}
||j        d         z  |
fS )aÔ  Compute semantic segmentation loss with optional auxiliary loss.

        Args:
            preds (torch.Tensor | tuple): Main logits [B, nc, H', W'], or (main, aux) tuple.
            batch (dict): Batch dict with 'semantic_mask' [B, H, W] containing class IDs (255=ignore).

        Returns:
            (tuple[torch.Tensor, dict[str, torch.Tensor]]): Total loss * batch_size and a dict of detached loss items
                (ce_loss, dice_loss, aux_loss).
        NÚsemantic_maskrd   rf  r…   r   rY  Fr  r$  rN   gš™™™™™Ù?)Úce_lossr³   Úaux_lossr   )r=  rÁ   rQ   r.   ru  rl   r5   rÂ   rz  r„  rI   rJ   rO   r,  )r#   r  r  Ú
aux_logitsrX  r  r‰  r³   r3  rŠ  Ú
loss_itemss              r%   r;   z SemanticSegmentationLoss.forwardÖ  s   € ð ˆ
Ý�e�UÑ#Ô#ð 	&Ø %ÑˆE�:à�oÔ&×)Ò)¨%¬,Ñ7Ô7ˆØ—’˜bÑ!Ô! SÒ(ˆØŒ;�q�r�rŒ?˜eœk¨!¨"¨"œoÒ-Ð-Ý”M %¨e¬k¸!¸"¸"¬oÀJÐ^cÐdÑdÔdˆEð —-’-  u¨eÑ4Ô4ˆØ—O’O E¨5°%Ñ8Ô8ˆ	Ø˜)Ñ#ˆõ ”< ¨E¬LÀÄÐNÑNÔNˆØÐ!ØÔ   Ô# u¤{°1°2°2¤Ò6Ð6Ýœ]¨:¸E¼KÈÈÈ¼OÐR\ÐlqÐrÑrÔr�
Ø—}’} Z°¸Ñ>Ô>ÀÑDˆHØ�XÑˆEà!(§¢Ñ!1Ô!1À	×@PÒ@PÑ@RÔ@RÐ`h×`oÒ`oÑ`qÔ`qÐrÐrˆ
Ø�u”{ 1”~Ñ% zÐ1Ð1r&   r   )r>   r?   r@   rA   r!   rs  rz  r„  r|  r;   rB   rC   s   @r%   r`  r`  ƒ  s¡   ø€ € € € € ðð ðLð Lð Lð Lð Lð Lð2ð ð ðBð Bð BðOð Oð Oð"
Fð 
Fð 
Fð#2ð #2ð #2ð #2ð #2ð #2ð #2r&   r`  )8Ú
__future__r   rê  Úpathlibr   Útypingr   rI   Útorch.nn.functionalr   Ú
functionalr5   Úultralytics.utils.metricsr   r   r	   Úultralytics.utils.opsr
   r   r   Úultralytics.utils.talr   r   r   r   r   Úultralytics.utils.torch_utilsr   Úmetricsr   r   Útalr   r   ÚModuler   rE   rW   ru   r�   r¡   r¨   r¶   rÇ   r×   rM  r|  r­  rÒ  rØ  rù  r"  r/  rA  rY  r`  rK  r&   r%   ú<module>r™     s  ðð #Ð "Ð "Ð "Ð "Ð "à €€€Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð à €€€Ø Ð Ð Ð Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð à NÐ NÐ NÐ NÐ NÐ NÐ NÐ NÐ NÐ NØ AÐ AÐ AÐ AÐ AÐ AÐ AÐ AÐ AÐ AØ uÐ uÐ uÐ uÐ uÐ uÐ uÐ uÐ uÐ uÐ uÐ uÐ uÐ uØ 2Ð 2Ð 2Ð 2Ð 2Ð 2à &Ð &Ð &Ð &Ð &Ð &Ð &Ð &Ø %Ð %Ð %Ð %Ð %Ð %Ð %Ð %ðð ð ð ð �B”Iñ ô ð ð@ "ð  "ð  "ð  "ð  "�”	ñ  "ô  "ð  "ðF!ð !ð !ð !ð !ˆRŒYñ !ô !ð !ð,-"ð -"ð -"ð -"ð -"ˆrŒyñ -"ô -"ð -"ð`3ð 3ð 3ð 3ð 3ˆbŒiñ 3ô 3ð 3ðl."ð ."ð ."ð ."ð ."�hñ ."ô ."ð ."ðbð ð ð ð ˜2œ9ñ ô ð ðBeð eð eð eð e�"”)ñ eô eð eð0Wð Wð Wð Wð W�2”9ñ Wô Wð Wð&T.ð T.ð T.ð T.ð T.ñ T.ô T.ð T.ðn_$ð _$ð _$ð _$ð _$˜ñ _$ô _$ð _$ðDi(ð i(ð i(ð i(ð i(�ñ i(ô i(ð i(ðXx2ð x2ð x2ð x2ð x2�ñ x2ô x2ð x2ðv-ð -ð -ð -ð -ñ -ô -ð -ðh2ð h2ð h2ð h2ð h2�ñ h2ô h2ð h2ðV[Uð [Uð [Uð [Uð [Uñ [Uô [Uð [Uð|
ð 
ð 
ð 
ð 
ñ 
ô 
ð 
ð( wð  wð  wð  wð  wñ  wô  wð  wðF)ð )ð )ð )ð )ñ )ô )ð )ðXIð Ið Ið Ið I�]ñ Iô Ið Ið6v2ð v2ð v2ð v2ð v2˜rœyñ v2ô v2ð v2ð v2ð v2r&   