§
    ­¸j ã                  ó  — d Z ddlmZ ddlZddlmZ ddlmZmZm	Z	 ddl
Z
ddlmc mZ ddl
mZmZ ddlmZ ddlmZmZmZ dd	lmZ dd
lmZ ddlmZ ddlmZmZ edee ef         f         Z!dZ"dZ#dZ$d6d„Z%d7d%„Z& G d&„ d'e¦  «        Z'	 	 d8d9d,„Z(	 	 d8d9d-„Z)	 	 d8d9d.„Z*d:d1„Z+ej,        d2k    re+ne
j-         .                    e+¦  «        Z/d:d3„Z0ej,        d2k    re0ne
j-         .                    e0¦  «        Z1 G d4„ d5ej2        ¦  «        Z3dS );z2Loss functions and criterion for RF-DETR training.é    )ÚannotationsN)ÚCallable)ÚAnyÚ
NamedTupleÚUnion)ÚTensorÚnn)Úcompute_l1_keypoint_loss)Úcalculate_uncertaintyÚ*get_uncertain_point_coords_with_randomnessÚpoint_sample)ÚHungarianMatcher)Úaccuracy)Úbox_ops)Úget_world_sizeÚis_dist_avail_and_initialized.i   é   é   Úlogitsr   ÚboxesÚbatch_indicesÚsource_indicesÚtarget_labelsÚtarget_boxesÚ
valid_maskÚtarget_lengthsÚ	num_boxesÚfocal_alphaÚfloatÚreturnú%tuple[Tensor, Tensor, Tensor, Tensor]c
                ó´  — t          j        | j        d         | j        ¬¦  «        dd…df         }
||
||f         }t	          j        |                     dd¦  «        ¦  «        }t	          j        |                     dd¦  «        ¦  «        }t	          j        |                     ¦   «         |¦  «        \  }}|                     |j        dd…         ¦  «                             ¦   «         }|  	                    ¦   «         }t          j
        | ¦  «        }|                     ¦   «         }|
|||f}t          j        ||                              |	¦  «        |                     d|	z
  ¦  «        z  d¦  «                             ¦   «         }||z                       |j        ¦  «        ||<   t          j        |                     ¦   «         d|z
                       |j        ¦  «        ||         ¦  «        ||<   |                     d¦  «        }|| z  t%          j        | ¦  «        ||z   z  z
  }|                     d	¬
¦  «        |z  }t%          j        ||d¬¦  «        |dd…dd…df         z  }dt	          j        ||¦  «        z
  }|                     |j        dd…         ¦  «        |z  }|                     d¬
¦  «        |z  }|                     d¬
¦  «        |z  }|                     d¦  «        j        dk                         d¦  «        }|                     ¦   «         |                     ¦   «         z
                       ¦   «                              d¦  «        }||||fS )an  Compute layer-batched IA-BCE classification, box, GIoU, and cardinality losses.

    This tensor-only boundary is suitable for one dynamic-shape ``torch.compile`` function; Python target dictionaries,
    matcher results, suffix bookkeeping, and diagnostics stay outside it.

    Args:
        logits: Layer-major class logits with shape ``(layers, batch, queries, classes)``.
        boxes: Layer-major boxes with shape ``(layers, batch, queries, 4)``.
        batch_indices: Matched batch indices with shape ``(layers, matches)``.
        source_indices: Matched query indices with shape ``(layers, matches)``.
        target_labels: Matched class labels with shape ``(layers, matches)``.
        target_boxes: Matched target boxes with shape ``(layers, matches, 4)``.
        valid_mask: Float mask with shape ``(layers, matches)``; all ones for unpadded targets.
        target_lengths: Number of real targets in each batch item.
        num_boxes: Shared loss-normalization denominator.
        focal_alpha: IA-BCE interpolation exponent.

    Returns:
        Per-layer classification, L1 box, GIoU, and cardinality losses.
    r   ©ÚdeviceNéÿÿÿÿé   r   é   ç{®Gáz„?)r'   r   é   ©ÚdimÚnone©Ú	reduction)r'   r   ç      à?)ÚtorchÚarangeÚshaper$   r   Úbox_cxcywh_to_xyxyÚreshapeÚelementwise_box_iouÚdetachÚsigmoidÚ
zeros_likeÚsquareÚclampÚpowÚtoÚdtypeÚwhereÚboolÚFÚ
logsigmoidÚsumÚl1_lossÚelementwise_generalized_box_iouÚmaxÚvaluesr   ÚabsÚmean)r   r   r   r   r   r   r   r   r   r   Úlayer_indicesÚselected_boxesÚflat_selected_xyxyÚflat_target_xyxyÚiou_targetsÚ_ÚprobabilityÚpositive_weightsÚnegative_weightsÚpositive_indicesÚtarget_scoresÚclassificationÚloss_ceÚloss_bbox_valuesÚloss_giou_valuesÚ	loss_bboxÚ	loss_giouÚcardinalityÚcardinality_errors                                úg/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/rfdetr/models/criterion.pyÚ_batched_detection_loss_tensorsr]   /   sA  € õ@ ”L ¤¨a¤¸¼ÐGÑGÔGÈÈÈÈ4ÈÔP€MØ˜=¨-¸ÐGÔH€NÝ Ô3°N×4JÒ4JÈ2ÈqÑ4QÔ4QÑRÔRÐÝÔ1°,×2FÒ2FÀrÈ1Ñ2MÔ2MÑNÔNÐÝÔ0Ð1C×1JÒ1JÑ1LÔ1LÐN^Ñ_Ô_�N€K�Ø×%Ò% nÔ&:¸2¸A¸2Ô&>Ñ?Ô?×FÒFÑHÔH€Kà—.’.Ñ"Ô"€KÝÔ'¨Ñ/Ô/ÐØ"×)Ò)Ñ+Ô+ÐØ% }°nÀmÐTÐÝ”KØÐ$Ô%×)Ò)¨+Ñ6Ô6¸¿ºÈÈ[ÉÑ9YÔ9YÑYÐ[_ñô ç‚f�h„hð ð +8¸*Ñ*D×)HÒ)HÐIYÔI_Ñ)`Ô)`ÐÐ%Ñ&Ý).¬Ø�ŠÑÔØ	
ˆ]Ñ	×ÒÐ/Ô5Ñ6Ô6ØÐ)Ô*ñ*ô *ÐÐ%Ñ&ð ×!Ò! !Ñ$Ô$€IØ%¨Ñ.µ´¸fÑ1EÔ1EÐIYÐ\lÑIlÑ1mÑm€NØ× Ò  YÐ Ñ/Ô/°)Ñ;€Gå”y °ÈÐPÑPÔPÐS]Ð^_Ð^_Ð^_ÐabÐabÐabÐdhÐ^hÔSiÑiÐØ�7ÔBÐCUÐWgÑhÔhÑhÐØ'×/Ò/°Ô0DÀRÀaÀRÔ0HÑIÔIÈJÑVÐØ ×$Ò$¨Ð$Ñ0Ô0°9Ñ<€IØ ×$Ò$¨Ð$Ñ+Ô+¨iÑ7€Ià—?’? 2Ñ&Ô&Ô-°Ò3×8Ò8¸Ñ;Ô;€KØ$×*Ò*Ñ,Ô,¨~×/CÒ/CÑ/EÔ/EÑE×JÒJÑLÔL×QÒQÐRSÑTÔTÐØ�I˜yÐ*;Ð;Ð;ó    Útargetsúlist[dict[str, Tensor]]Úindicesúlist[tuple[Tensor, Tensor]]Úpoint_coordsc           
     ól  ‡ ‡— t          ‰ ¦  «        t          |¦  «        k    o@‰j        j        dk    o0‰j        t          j        k    o‰j        dk    o‰j        d         dk    }d}d}d}d}d}|�r2t          ‰ |¦  «        D �] \  }	\  }
}|	 	                    d¦  «        }t          |t          ¦  «        r%|j        dk    r|j        d         |j        d         fnd}|�^|�\|                     ¦   «         rH|j        ‰j        k    s8|j        j        dk    s(|j        t          j        k    s|j        d	k    s|�
||k    rd
} nd|}|                     ¦   «         }||z  }||d         z  |d	         z  }||z  }|dk    r(|€|nt          ||¦  «        }|€|nt          ||¦  «        }�Œ"‰j        dk    r‰j        d         ‰j        d	         z  nd}|oG|‰j        d         k    o6|t           k    o+|t"          |z  k    o|du p
|t           k    o|du p
|t$          k    }|r't'          d„ t          ‰ |¦  «        D ¦   «         ¦  «        }|�rg }d}t          ‰ |¦  «        D �]ó\  }	\  }
}|	d         }|                     ¦   «         }‰|||z   …         }|j        dd…         \  }}d|z  dz
  }|d         dz   |z  dz
  dz  }|d         dz   |z  dz
  dz  }t	          j        |¦  «                             t          j        ¦  «        }t	          j        |¦  «                             t          j        ¦  «        }|                     d|d	z
  ¦  «         |                     d|d	z
  ¦  «         |                     |j        ¬¦  «        }|dd…df         ||z  z  ||z  z   |z   }|                     d¦  «                             d|                     d¦  «        ¦  «                             |‰j        d	         ¦  «                             ¦   «         }|t	          j        |¦  «        z
  dk    |t	          j        |¦  «        z
  dk    z  }t7          |                     ¦   «         ¦  «        rÖ|                     d¬¦  «        \  } }!|||                   }"|| |!f         }#t=          |"                     d	¦  «                             ¦   «         |#                     d	¦  «        d
d¬¦  «                              d	¦  «                              d	¦  «        }$| !                    ¦   «         }|$                     |j        ¬¦  «        || |!f<   | "                    |¦  «         ||z  }�Œõt	          j#        |d¬¦  «        S ‰j$        �rW‰j        dk    �rKt          ‰ ¦  «        t          |¦  «        cxk    rd	k    �r#n �nt'          ˆˆ fd„t          ‰ |¦  «        D ¦   «         ¦  «        rõtK          d„ |D ¦   «         ¦  «        ‰j        d         cxk    rdk    rÆn nÃg }d}t          ‰ |¦  «        D ]˜\  }	\  }
}|                     ¦   «         }|ru| "                    t=          |	d         |                              d	¦  «                             ¦   «         ‰|||z   …         d
d¬¦  «                              d	¦  «        ¦  «         ||z  }Œ™t	          j#        |d¬¦  «        S t	          j#        d„ t          ‰ |¦  «        D ¦   «         ¦  «        }%t=          |%                     d	¦  «                             ¦   «         ‰d
d¬¦  «                              d	¦  «        S )a#  Sample matched ground-truth masks at normalized point coordinates.

    Large contiguous masks on CPU are indexed directly, avoiding the
    full matched-mask copies created by advanced indexing and concatenation.
    Eligible multi-image CUDA boolean masks are sampled per image with the native
    nearest-neighbor ``point_sample`` path, avoiding a full batch of matched float masks.
    Other inputs retain the existing concatenation and sampling path.

    Args:
        targets: Per-image target dictionaries containing ``masks`` tensors.
        indices: Per-image matched source and target indices.
        point_coords: Normalized coordinates with shape ``[matches, points, 2]``.

    Returns:
        Sampled float labels with shape ``[matches, points]``.

    Examples:
        >>> masks = torch.tensor([[[False, True], [True, False]]])
        >>> matched = torch.tensor([0])
        >>> coords = torch.tensor([[[0.75, 0.25]]])
        >>> _sample_target_masks_at_points([{"masks": masks}], [(matched, matched)], coords)
        tensor([[1.]])
    Úcpur)   r%   r   Nr   Úmaskséþÿÿÿr'   Fc              3  óÜ   K  — | ]g\  }\  }}t          |d k                          ¦   «         ¦  «         o6t          ||d         j        d          k                         ¦   «         ¦  «         V — ŒhdS )r   rf   N)r?   Úanyr2   ©Ú.0ÚtargetrN   Útarget_indicess       r\   ú	<genexpr>z1_sample_target_masks_at_points.<locals>.<genexpr>Ï   sŒ   è è € ð 
ð 
á+�Ñ+˜˜Nõ �n qÒ(×-Ò-Ñ/Ô/Ñ0Ô0Ð0Ðq½¸~ÐQWÐX_ÔQ`ÔQfÐghÔQiÒ?i×>nÒ>nÑ>pÔ>pÑ9qÔ9qÐ5qð
ð 
ð 
ð 
ð 
ð 
r^   g       @ç      ð?).r   ).r'   r#   r/   T)Úas_tupleÚnearest)Úalign_cornersÚmoder*   c              3  óL  •K  — | ]ž\  }\  }}|d          j         dk    o‚|d          j        t          j        k    og|d          j        ‰j        k    oQ|d          j        dd…         ‰d         d          j        dd…         k    o|j         dk    o|j        t          j        k    V — ŒŸdS )rf   r)   r'   Nr   )Úndimr=   r0   r?   r$   r2   Úint64)rk   rl   rN   rm   rc   r_   s       €€r\   rn   z1_sample_target_masks_at_points.<locals>.<genexpr>  sÕ   øè è € ð 
ð 
ñ ,�Ñ+˜˜Nð �7ŒOÔ  AÒ%ð 4Ø�w”Ô%­¬Ò3ð4à�w”Ô&¨,Ô*=Ò=ð4ð �w”Ô% a b bÔ)¨W°Q¬Z¸Ô-@Ô-FÀqÀrÀrÔ-JÒJð4ð Ô# qÒ(ð	4ð
 Ô$­¬Ò3ð
ð 
ð 
ð 
ð 
ð 
r^   c              3  óD   K  — | ]\  }}|                      ¦   «         V — Œd S ©N)Únumel)rk   rN   rm   s      r\   rn   z1_sample_target_masks_at_points.<locals>.<genexpr>  s3   è è € ÐHÐHÑ+<¨1¨n�×$Ò$Ñ&Ô&ÐHÐHÐHÐHÐHÐHr^   c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS )rf   © rj   s       r\   ú
<listcomp>z2_sample_target_masks_at_points.<locals>.<listcomp>0  s+   € ÐwÐwÐwÑB]À&ÑJ]È1Èn˜f Wœo¨nÔ=ÐwÐwÐwr^   )&Úlenr$   Útyper=   r0   Úfloat32ru   r2   ÚzipÚgetÚ
isinstancer   Úis_contiguousrv   ry   ÚminÚ_MIN_DIRECT_MASK_ELEMENTSÚ#_MIN_DIRECT_MASK_ELEMENTS_PER_POINTÚ_MIN_DIRECT_MATCHES_PER_GROUPÚallÚroundr<   Úclamp_r4   Úgatherr   Úfloorr?   ri   Únonzeror   Ú	unsqueezeÚsqueezeÚcloneÚappendÚcatÚis_cudarB   )&r_   ra   rc   Ú
use_directÚ
mask_shapeÚmatched_mask_elementsÚmatched_countÚmin_group_elementsÚmin_group_countrl   rN   rm   rf   Úcurrent_shapeÚgroup_countÚgroup_elementsÚsampled_elementsÚsampled_masksÚoffsetÚcountÚcoordsÚheightÚwidthÚgridÚunnorm_xÚunnorm_yÚx_coordsÚy_coordsÚtarget_indices_deviceÚflat_indicesÚsampledÚis_tieÚtie_rowsÚtie_colsÚ	tie_masksÚ
tie_coordsÚ	correctedÚtarget_maskss&   ` `                                   r\   Ú_sample_target_masks_at_pointsr³   u   s5  øø€ õ: 	ˆG‰Œ�˜G™œÒ$ð 	(ØÔÔ$¨Ò-ð	(àÔ¥%¤-Ò/ð	(ð Ô Ò"ð	(ð Ô˜rÔ" aÒ'ð ð *.€JØÐØ€Mð &*ÐØ"&€Oàñ pÝ+.¨w¸Ñ+@Ô+@ð 	pñ 	pÑ'ˆFÑ'�Q˜Ø—J’J˜wÑ'Ô'ˆEå6@ÀÍÑ6OÔ6OÐmÐTYÔT^ÐbcÒTcÐTc�”˜R” %¤+¨b¤/Ð2Ð2Ðimð ð �Ø Ð(Ø×*Ò*Ñ,Ô,ð )à”< <Ô#6Ò6Ð6Ø!Ô(Ô-°Ò6Ð6Ø!Ô'­5¬;Ò6Ð6Ø!Ô&¨!Ò+Ð+ØÐ*¨}À
Ò/JÐ/Jà"�
Ø�Ø&ˆJØ(×.Ò.Ñ0Ô0ˆKØ˜[Ñ(ˆMØ(¨=¸Ô+;Ñ;¸mÈAÔ>NÑNˆNØ! ^Ñ3Ð!Ø˜QŠˆà&8Ð&@�N�NÅcÐJ\Ð^lÑFmÔFmð #ð 2AÐ1H + +ÍcÐRaÐcnÑNoÔNo�ùàHTÔHYÐ]^ÒH^ÐH^�|Ô)¨!Ô,¨|Ô/AÀ!Ô/DÑDÐDÐdeÐàð 	ZØ˜\Ô/°Ô2Ò2ð	Zà!Õ%>Ò>ð	Zð "Õ%HÐK[Ñ%[Ò[ð	Zð   4Ð'ÐZÐ+=ÕAZÒ+Zð		Zð
  Ð$ÐX¨Õ;XÒ(Xð ð ð 
Ýð 
ð 
å/2°7¸GÑ/DÔ/Dð
ñ 
ô 
ñ 
ô 
ˆ
ð
 ñ 9/ØˆØˆÝ+.¨w¸Ñ+@Ô+@ð 4	ñ 4	Ñ'ˆFÑ'�Q˜Ø˜7”OˆEØ"×(Ò(Ñ*Ô*ˆEØ! &¨6°E©>Ð"9Ô:ˆFØ!œK¨¨¨Ô,‰MˆF�Eð ˜‘< #Ñ%ˆDØ˜fœ¨Ñ+¨uÑ4°sÑ:¸cÑAˆHØ˜fœ¨Ñ+¨vÑ5¸Ñ;¸sÑBˆHÝ”{ 8Ñ,Ô,×/Ò/µ´Ñ<Ô<ˆHÝ”{ 8Ñ,Ô,×/Ò/µ´Ñ<Ô<ˆHØ�OŠO˜A˜u q™yÑ)Ô)Ð)Ø�OŠO˜A˜v¨™zÑ*Ô*Ð*à$2×$5Ò$5¸U¼\Ð$5Ñ$JÔ$JÐ!Ø0°°°°D°Ô9¸VÀe¹^ÑLÈxÐZ_ÑO_Ñ_ÐbjÑjˆLà—’˜bÑ!Ô!×(Ò(¨¨L×,@Ò,@ÀÑ,DÔ,DÑEÔE×MÒMÈeÐUaÔUgÐhiÔUjÑkÔk×qÒqÑsÔsð ð ¥¤¨XÑ!6Ô!6Ñ6¸#Ò=À(ÍUÌ[ÐYaÑMbÔMbÑBbÐfiÒBiÑjˆFÝ�F—J’J‘L”LÑ!Ô!ð RØ%+§^¢^¸T ^Ñ%BÔ%BÑ"�˜(Ø!Ð"7¸Ô"AÔB�	Ø# H¨hÐ$6Ô7�
å Ø!×+Ò+¨AÑ.Ô.×4Ò4Ñ6Ô6Ø"×,Ò,¨QÑ/Ô/Ø&+Ø&ð	ñ ô ÷ ’W˜Q‘Z”Zß’W˜Q‘Z”Zð ð "Ÿ-š-™/œ/�Ø.7¯lªlÀ'Ä.¨lÑ.QÔ.Q�˜ (Ð*Ñ+à× Ò  Ñ)Ô)Ð)Ø�e‰OˆF‰FåŒy˜¨AÐ.Ñ.Ô.Ð.ð 	Ôñ/àÔ Ò"Ñ"Ý�‰LŒL�C ™LœLÐ,Ð,Ò,Ð,¨1Ò,Ñ,Ð,Ð,Ñ,Ýð 
ð 
ð 
ð 
ð 
õ 03°7¸GÑ/DÔ/Dð
ñ 
ô 
ñ 
ô 
ð -õ ÐHÐHÀÐHÑHÔHÑHÔHÈLÔL^Ð_`ÔLaÐeÐeÒeÐeÐdeÒeÐeÐeÐeÐeð ˆØˆÝ+.¨w¸Ñ+@Ô+@ð 	ð 	Ñ'ˆFÑ'�Q˜Ø"×(Ò(Ñ*Ô*ˆEØð Ø×$Ò$Ý Ø˜wœ¨Ô7×AÒAÀ!ÑDÔD×JÒJÑLÔLØ$ V¨f°u©nÐ%<Ô=Ø&+Ø&ð	ñ ô ÷
 ’g˜a‘j”jñô ð ð �e‰OˆFˆFÝŒy˜¨AÐ.Ñ.Ô.Ð.å”9ÐwÐwÕadÐelÐnuÑavÔavÐwÑwÔwÑxÔx€LÝØ×Ò˜qÑ!Ô!×'Ò'Ñ)Ô)ØØØð	ñ ô ÷
 ‚gˆa�j„jðr^   c                  ó2   — e Zd ZU dZded<   ded<   ded<   dS )Ú_MatchedTargetsa3  Indices and target tensors shared by detection losses for one output layer.

    ``loss_labels`` and ``loss_boxes`` consume the same matched labels, boxes, and source indices. Keeping them together
    avoids rebuilding those tensors for each loss without changing their per-layer lifetime or ordering.
    útuple[Tensor, Tensor]r   r   Úlabelsr   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r{   r^   r\   rµ   rµ   9  s:   € € € € € € ðð ð *Ð)Ð)Ñ)Ø€N€N�NØ€M€M�M€M€Mr^   rµ   ç      Ð?ÚinputsÚalphaÚgammac                ó   — |                       ¦   «         }t          j        | |d¬¦  «        }||z  d|z
  d|z
  z  z   }|d|z
  |z  z  }|dk    r||z  d|z
  d|z
  z  z   }	|	|z  }|                     d¦  «                             ¦   «         |z  }
|
S )a´  
    Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002.

    Args:
        inputs: A float tensor of arbitrary shape.
                The predictions for each example.
        targets: A float tensor with the same shape as inputs. Stores the binary
                 classification label for each element in inputs
                (0 for the negative class and 1 for the positive class).
        alpha: (optional) Weighting factor in range (0,1) to balance
                positive vs negative examples. Default = 0.25.
        gamma: Exponent of the modulating factor (1 - p_t) to
               balance easy vs hard examples.

    Returns:
        Loss tensor
    r,   r-   r'   r   )r7   r@   Ú binary_cross_entropy_with_logitsrH   rB   )r¾   r_   r   r¿   rÀ   ÚprobÚce_lossÚp_tÚlossÚalpha_tÚresults              r\   Úsigmoid_focal_lossrÉ   E  sª   € ð0 �>Š>ÑÔ€DÝÔ0°¸ÈFÐSÑSÔS€GØ
�‰.˜A ™H¨¨W©Ñ5Ñ
5€CØ�q˜3‘w 5Ñ(Ñ)€Dà�‚z€zØ˜'‘/ Q¨¡Y°1°w±;Ñ$?Ñ?ˆØ˜‰~ˆà—Y’Y˜q‘\”\×%Ò%Ñ'Ô'¨)Ñ3€FØ€Mr^   c                ó€  — |                       ¦   «         }||dk                         ¦   «         z  d|z
  ||z
                       ¦   «                              |¦  «        z  |dk                         ¦   «         z  z   }t	          j        | |d¬¦  «        }||z  }|                     d¦  «                             ¦   «         |z  S )Nç        r'   r,   r-   )r7   r   rG   r;   r@   rÂ   rH   rB   )	r¾   r_   r   r¿   rÀ   rÃ   Úfocal_weightrÄ   rÆ   s	            r\   Úsigmoid_varifocal_lossrÍ   j  s¹   € ð �>Š>ÑÔ€Dà�7˜S’=×'Ò'Ñ)Ô)Ñ)¨Q°©Y¸4À'¹>×:NÒ:NÑ:PÔ:P×:TÒ:TÐUZÑ:[Ô:[Ñ,[Ð_fÐjmÒ_m×^tÒ^tÑ^vÔ^vÑ,vÑvð õ Ô0°¸ÈFÐSÑSÔS€GØ�\Ñ!€Dà�9Š9�Q‰<Œ<×ÒÑÔ 	Ñ)Ð)r^   c                óp  — |                       ¦   «         }t          j        | |d¬¦  «        }|t          j        ||z
  ¦  «        |z  z  }|dk    r?||dk                         ¦   «         z  d|z
  |dk                         ¦   «         z  z   }||z  }|                     d¦  «                             ¦   «         |z  S )Nr,   r-   r   rË   r'   )r7   r@   rÂ   r0   rG   r   rH   rB   )	r¾   r_   r   r¿   rÀ   rÃ   rÄ   rÆ   rÇ   s	            r\   Úposition_supervised_lossrÏ   {  s²   € ð �>Š>ÑÔ€DÝÔ0°¸ÈFÐSÑSÔS€GØ•e”i ¨$¡Ñ/Ô/°5Ñ8Ñ9€Dà�‚z€zØ˜7 Sš=×/Ò/Ñ1Ô1Ñ1°Q¸±YÀ7ÈcÂ>×BXÒBXÑBZÔBZÑ4ZÑZˆØ˜‰~ˆà�9Š9�Q‰<Œ<×ÒÑÔ 	Ñ)Ð)r^   Ú	num_masksúUnion[Tensor, float, int]c                óâ  — |                       ¦   «         } |                      d¦  «        } d| |z                       d¦  «        z  }|                      d¦  «        |                     d¦  «        z   }d|dz   |dz   z  z
  }t          |t          ¦  «        r|                     ¦   «         |z  }nDt          |t
          ¦  «        r|                     ¦   «         |z  }n|                     ¦   «         |z  }|S )uB  Compute the DICE loss, similar to generalized IOU for masks.

    Args:
        inputs: A float tensor of arbitrary shape.
                The predictions for each example.
        targets: A float tensor with the same shape as inputs. Stores the binary
                 classification label for each element in inputs
                (0 for the negative class and 1 for the positive class).
        num_masks: Normalizing denominator. Pass a Tensor to keep it on-device so the
                 caller never has to sync it to the host (a host read cuts XLA's lazy
                 graph every step). This eager function accepts Python and NumPy scalars.
                 On Python 3.10â€“3.13, the scripted ``dice_loss_jit`` wrapper accepts only
                 Tensor, float, or int; on Python 3.14+, it is this eager function.
    r'   r   r%   )r7   ÚflattenrB   r‚   r   Úint)r¾   r_   rÐ   Ú	numeratorÚdenominatorrÆ   rÈ   s          r\   Ú	dice_lossr×   �  sÛ   € ð& �^Š^ÑÔ€FØ�^Š^˜AÑÔ€FØ�V˜gÑ%×*Ò*¨2Ñ.Ô.Ñ.€IØ—*’*˜R‘.”. 7§;¢;¨r¡?¤?Ñ2€KØ�	˜A‘ +°¡/Ñ2Ñ2€Dõ �)�UÑ#Ô#ð (ØŸš™œ iÑ/ˆˆÝ	�I�sÑ	#Ô	#ð (Ø—’‘”˜iÑ'ˆˆà—’‘”˜iÑ'ˆØ€Mr^   )r)   é   c                óˆ  — t          j        | |d¬¦  «        }t          |t          ¦  «        r+|                     d¦  «                             ¦   «         |z  }njt          |t          ¦  «        r+|                     d¦  «                             ¦   «         |z  }n*|                     d¦  «                             ¦   «         |z  }|S )ue  Compute sigmoid cross-entropy loss for mask predictions.
    Args:
        inputs: A float tensor of arbitrary shape.
                The predictions for each example.
        targets: A float tensor with the same shape as inputs. Stores the binary
                 classification label for each element in inputs
                (0 for the negative class and 1 for the positive class).
        num_masks: Normalizing denominator. Pass a Tensor to keep it on-device so the
                 caller never has to sync it to the host (a host read cuts XLA's lazy
                 graph every step). This eager function accepts Python and NumPy scalars.
                 On Python 3.10â€“3.13, the scripted ``sigmoid_ce_loss_jit`` wrapper accepts
                 only Tensor, float, or int; on Python 3.14+, it is this eager function.

    Returns:
        Loss tensor
    r,   r-   r'   )r@   rÂ   r‚   r   rH   rB   rÔ   )r¾   r_   rÐ   rÆ   rÈ   s        r\   Úsigmoid_ce_lossrÚ   ¸  sª   € õ* Ô-¨f°gÈÐPÑPÔP€Dõ �)�UÑ#Ô#ð 0ØŸš 1™œ×)Ò)Ñ+Ô+¨iÑ7ˆˆÝ	�I�sÑ	#Ô	#ð 0Ø—’˜1‘”×!Ò!Ñ#Ô# iÑ/ˆˆà—’˜1‘”×!Ò!Ñ#Ô# iÑ/ˆØ€Mr^   c                  ó(  ‡ — e Zd ZU dZdZded<   	 	 	 	 	 	 	 dKdLˆ fd„ZedMd!„¦   «         ZdNd%„Z		 	 dOdPd-„Z
 ej        ¦   «         dQd.„¦   «         Z	 dRdSd/„ZdQd0„ZdQd1„ZdTd3„ZdUd5„ZedVd7„¦   «         ZdTd8„ZdWd<„ZdXd?„ZdYd@„ZdZdC„Z	 dRd[dH„Z	 dRd\dJ„Zˆ xZS )]ÚSetCriteriona  This class computes the loss for Conditional DETR.

    The process happens in two steps:
    1) we compute Hungarian assignment between ground truth boxes and the outputs of the model.
    2) we supervise each pair of matched ground-truth / prediction (supervise class and box).
    Tr?   Ú!supports_loss_normalizer_overrider'   Fr   NÚnum_classesrÔ   Úmatcherr   Úweight_dictúdict[str, float]r   r   Úlossesú	list[str]Ú
group_detrÚsum_group_lossesÚuse_varifocal_lossÚuse_position_supervised_lossÚia_bce_lossÚmask_point_sample_ratioÚnum_keypoints_per_classúlist[int] | Noner    ÚNonec                ó  •— t          ¦   «                              ¦   «          || _        || _        || _        || _        || _        || _        || _        || _	        |	| _
        |
| _        || _        |pg | _        d| _        d| _        dS )a4  Create the criterion.

        Parameters:
            num_classes: number of object categories, omitting the special no-object category
            matcher: module able to compute a matching between targets and proposals
            weight_dict: dict containing as key the names of the losses and as values their relative weight.
            losses: list of all the losses to be applied. See get_loss for list of available losses.
            focal_alpha: alpha in Focal Loss
            group_detr: Number of groups to speed detr training. Default is 1.
        FN)ÚsuperÚ__init__rÞ   rß   rà   râ   r   rä   rå   ræ   rç   rè   ré   rê   Ú!_compile_batched_detection_lossesÚ"_compiled_batched_detection_losses)ÚselfrÞ   rß   rà   r   râ   rä   rå   ræ   rç   rè   ré   rê   Ú	__class__s                €r\   rï   zSetCriterion.__init__ì  s“   ø€ õ2 	‰Œ×ÒÑÔÐØ&ˆÔØˆŒØ&ˆÔØˆŒØ&ˆÔØ$ˆŒØ 0ˆÔØ"4ˆÔØ,HˆÔ)Ø&ˆÔØ'>ˆÔ$Ø'>Ð'DÀ"ˆÔ$Ø16ˆÔ.ØosˆÔ/Ð/Ð/r^   Úoutputsúdict[str, Any]útorch.devicec                óˆ   — |                       ¦   «         D ]}t          j        |¦  «        r	|j        c S Œ t	          d¦  «        ‚)a�  Return the device used by tensor outputs.

        Args:
            outputs: Model output dictionary. Top-level values are probed for tensors;
                nested structures (lists, nested dicts) are not traversed.

        Returns:
            Device of the first tensor value found in ``outputs``.

        Raises:
            ValueError: If no tensor output is present.
        zJSetCriterion requires at least one tensor output to infer the loss device.)rF   r0   Ú	is_tensorr$   Ú
ValueError)rô   Úvalues     r\   Ú_output_devicezSetCriterion._output_device  sQ   € ð —^’^Ñ%Ô%ð 	$ð 	$ˆEÝŒ˜uÑ%Ô%ð $Ø”|Ð#Ð#Ð#ð$åÐeÑfÔfÐfr^   r_   r`   r   c                ón  — | j         r| j        nd}|ryd|d         v rot          j        d„ |D ¦   «         ¦  «                             ¦   «                              t          j        |                      |¦  «        ¬¦  «        }| j        s||z  }nYt	          d„ |D ¦   «         ¦  «        }| j        s||z  }t          j	        |t          j        |                      |¦  «        ¬¦  «        }t          ¦   «         rt          j                             |¦  «         t          j        |t          ¦   «         z  d¬¦  «        S )	aë  Compute the distributed target-box denominator for a target batch.

        The denominator is the total number of ground-truth boxes in the batch, multiplied by the active number of
        DETR groups (unless ``sum_group_losses`` collapses them), reduced across all distributed ranks, divided by the
        world size, and finally clamped to be at least ``1.0`` so divide-by-zero never occurs on empty batches.

        Args:
            outputs: Model output dictionary; used only to infer the device for the
                returned scalar tensor.
            targets: Per-image target dictionaries for the current batch. Each must
                contain a ``"labels"`` tensor whose length equals the number of
                ground-truth boxes for that image.

        Returns:
            Scalar tensor on the same device as the model outputs, holding the
            average box-count denominator used to normalize criterion losses.

        Note:
            When ``torch.distributed`` is initialized this method performs an
            in-place ``all_reduce`` collective on the returned tensor. Every rank
            must reach this call together or the program will deadlock.

        Note:
            ``group_detr`` is multiplied in only when ``self.training`` is ``True``.
            During evaluation (``self.training`` is ``False``) the denominator
            collapses to a single group, so train-time and eval-time normalizers
            cannot be compared directly.

        Examples:
            >>> import torch
            >>> from rfdetr.models.criterion import SetCriterion
            >>> criterion = SetCriterion.__new__(SetCriterion)
            >>> criterion.training = False
            >>> criterion.group_detr = 1
            >>> criterion.sum_group_losses = False
            >>> outputs = {"pred_logits": torch.zeros(1, 1, 1)}
            >>> targets = [{"labels": torch.tensor([0, 1, 2])}]
            >>> criterion.num_boxes_for_targets(outputs, targets).item()
            3.0
        r'   Úvalidr   c                óB   — g | ]}|d                                ¦   «         ‘ŒS ©rý   ©rB   ©rk   rl   s     r\   r|   z6SetCriterion.num_boxes_for_targets.<locals>.<listcomp>Z  s(   € ÐIÐIÐI°v˜V Gœ_×0Ò0Ñ2Ô2ÐIÐIÐIr^   ©r=   r$   c              3  ó@   K  — | ]}t          |d          ¦  «        V — ŒdS )r·   N©r}   )rk   Úts     r\   rn   z5SetCriterion.num_boxes_for_targets.<locals>.<genexpr>a  s.   è è € Ð>Ð>°�C  (¤Ñ,Ô,Ð>Ð>Ð>Ð>Ð>Ð>r^   ro   ©r„   )Útrainingrä   r0   ÚstackrB   r<   r   rû   rå   Ú	as_tensorr   ÚdistributedÚ
all_reducer:   r   )rò   rô   r_   rä   Únum_boxes_tensorr   s         r\   Únum_boxes_for_targetsz"SetCriterion.num_boxes_for_targets(  s6  € ðZ )-¬Ð<�T”_�_¸1ˆ
Øð 	r�w '¨!¤*Ð,Ð,õ ”ÐIÐIÀÐIÑIÔIÑJÔJß’‘”ß’�%œ+¨d×.AÒ.AÀ'Ñ.JÔ.J�ÑKÔKð ð
 Ô(ð AØ#3°jÑ#@Ð øåÐ>Ð>°gÐ>Ñ>Ô>Ñ>Ô>ˆIØÔ(ð 3Ø%¨
Ñ2�	Ý$œ¨yÅÄÐTX×TgÒTgÐhoÑTpÔTpÐqÑqÔqÐÝ(Ñ*Ô*ð 	;ÝÔ×(Ò(Ð)9Ñ:Ô:Ð:ÝŒ{Ð+­nÑ.>Ô.>Ñ>ÀCÐHÑHÔHÐHr^   ra   rb   r   ÚlogÚmatched_targetsú_MatchedTargets | Noneúdict[str, Tensor]c                óÔ  — d|v sJ ‚|d         }|                       ||¦  «        }|�| j        st          d¦  «        ‚|€D|                      |¦  «        }	t	          j        d„ t          ||¦  «        D ¦   «         ¦  «        }
d}n|j        }	|j        }
|j	        }| j        �r§|€.t	          j        d„ t          ||¦  «        D ¦   «         d¬¦  «        }| j
        }d}|d	         |	         }t          j        t          j        |                     ¦   «         ¦  «        t          j        |¦  «        ¦  «        \  }}|                     ¦   «                              ¦   «         }|                     ¦   «         }t	          j        |¦  «        }||z  }t%          |	¦  «        }|                     |
¦  «         |t)          |¦  «                                      |¦  «        |                     d
|z
  ¦  «        z  }t	          j        |d¦  «                             ¦   «         }|€X|                     |j        ¦  «        |t)          |¦  «        <   d
|                     |j        ¦  «        z
  |t)          |¦  «        <   n |                     t          j        ¦  «        }||z                       |j        ¦  «        |t)          |¦  «        <   t	          j        |d
|z
                       |j        ¦  «        |t)          |¦  «                 ¦  «        |t)          |¦  «        <   ||z  t7          j        |¦  «        ||z   z  z
  }|                     ¦   «         |z  }�nõ| j        �r¨|€.t	          j        d„ t          ||¦  «        D ¦   «         d¬¦  «        }|d	         |	         }t          j        t          j        |                     ¦   «         ¦  «        t          j        |¦  «        ¦  «        \  }}|                     ¦   «                              ¦   «         }|}t	          j        |j         d         |j         d
         | j!        f|j        |j"        ¬¦  «        }t%          |	¦  «        }|                     |
¦  «         |                     |j        ¦  «        }||t)          |¦  «        <   || #                    |j         d         dd
¦  «         $                    d
d¦  «        dz   z  }tK          |||| j
        d¬¦  «        |j         d
         z  }�nE| j&        �rO|d	         |	         }|€.t	          j        d„ t          ||¦  «        D ¦   «         d¬¦  «        }t          j        t          j        |                     ¦   «         ¦  «        t          j        |¦  «        ¦  «        \  }}|                     ¦   «                              ¦   «         }t	          j        |j         d         |j         d
         | j!        f|j        |j"        ¬¦  «        }t%          |	¦  «        }|                     |
¦  «         ||t)          |¦  «        <   tO          |||| j
        d¬¦  «        |j         d
         z  }nît	          j(        |j         dd…         | j!        t          j)        |j"        ¬¦  «        }|
||	<   t	          j        |j         d         |j         d
         |j         d         d
z   g|j        |j*        |j"        ¬¦  «        }| +                    d| ,                    d¦  «        d
¦  «         |dd…dd…dd…f         }t[          |||| j
        d¬¦  «        |j         d
         z  }d|i}|r¦|€#dt]          ||	         |
¦  «        d         z
  |d<   n�||	          /                    d¬¦  «        |
k                         |j        ¦  «        } dd| |z                       ¦   «         z  |                     ¦   «                              d
¬¦  «        z  z
  |d<   |S )zˆClassification loss (Binary focal loss) targets dicts must contain the key "labels" containing a tensor of
        dim [nb_target_boxes]Úpred_logitsNz÷Fixed-size target padding masks padded pairs only in the IoU-aware BCE classification branch (ia_bce_loss=True, which is the TrainConfig default). The position-supervised, varifocal and plain focal branches would count the padding as real matches.c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS ©r·   r{   )rk   r  rN   ÚJs       r\   r|   z,SetCriterion.loss_labels.<locals>.<listcomp>€  s(   € Ð)`Ð)`Ð)`¹Y¸QÁÀÀA¨!¨H¬+°a¬.Ð)`Ð)`Ð)`r^   c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS ©r   r{   ©rk   r  rN   Úis       r\   r|   z,SetCriterion.loss_labels.<locals>.<listcomp>‰  ó(   € Ð)_Ð)_Ð)_¹I¸A¹vÀÀ1¨!¨G¬*°Q¬-Ð)_Ð)_Ð)_r^   r   r*   r   Ú
pred_boxesr'   r(   c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS r  r{   r  s       r\   r|   z,SetCriterion.loss_labels.<locals>.<listcomp>°  r  r^   r  r%   Tg:Œ0âŽyE>)r¿   rÀ   c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS r  r{   r  s       r\   r|   z,SetCriterion.loss_labels.<locals>.<listcomp>Õ  r  r^   )r=   Úlayoutr$   rU   éd   Úclass_errorr  )0Ú_matched_valid_maskrè   ÚNotImplementedErrorÚ_get_src_permutation_idxr0   r’   r€   r   r·   r   r   r   r5   r3   r6   r�   r7   r8   Úlistr‘   Útupler;   r:   r<   r=   r?   r>   r@   rA   rB   rç   Úzerosr2   rÞ   r$   ÚviewÚamaxrÏ   ræ   rÍ   Úfullrv   r  Úscatter_rŽ   rÉ   r   Úargmax)!rò   rô   r_   ra   r   r  r  Ú
src_logitsr   ÚidxÚtarget_classes_or   r¿   rÀ   Ú	src_boxesrM   rN   Úpos_iousrÃ   Úpos_weightsÚneg_weightsÚpos_indr  ÚkeeprU   Úpos_ious_funcÚcls_iou_func_targetsÚnorm_cls_iou_func_targetsÚcls_iou_targetsÚtarget_classesÚtarget_classes_onehotrâ   Úcorrects!                                    r\   Úloss_labelszSetCriterion.loss_labelsi  sÿ  € ð  Ð'Ð'Ð'Ð'Ø˜]Ô+ˆ
Ø×-Ò-¨g°wÑ?Ô?ˆ
ØÐ!¨$Ô*:Ð!Ý%ð^ñô ð ð Ð"Ø×/Ò/°Ñ8Ô8ˆCÝ$œyÐ)`Ð)`Í#ÈgÐW^ÑJ_ÔJ_Ð)`Ñ)`Ô)`ÑaÔaÐØˆLˆLà!Ô0ˆCØ.Ô5ÐØ*Ô0ˆLàÔñ D	ØÐ#Ý$œyÐ)_Ð)_ÍÈWÐV]ÑI^ÔI^Ð)_Ñ)_Ô)_ÐefÐgÑgÔg�ØÔ$ˆEØˆEØ Ô-¨cÔ2ˆIÝ$Ô8ÝÔ*¨9×+;Ò+;Ñ+=Ô+=Ñ>Ô>ÝÔ*¨<Ñ8Ô8ñô ‰NˆK˜ð #×(Ò(Ñ*Ô*×1Ò1Ñ3Ô3ˆHØ×%Ò%Ñ'Ô'ˆDåÔ*¨:Ñ6Ô6ˆKØ ™+ˆKå˜3‘i”iˆGØ�NŠNÐ+Ñ,Ô,Ð,à•U˜7‘^”^Ô$×(Ò(¨Ñ/Ô/°(·,²,¸qÀ5¹yÑ2IÔ2IÑIˆAÝ”˜A˜tÑ$Ô$×+Ò+Ñ-Ô-ˆAàÐ!Ø./¯dªd°;Ô3DÑ.EÔ.E��E '™NœNÑ+Ø./°!·$²$°{Ô7HÑ2IÔ2IÑ.I��E '™NœNÑ+Ð+ð
 "—}’}¥U¤ZÑ0Ô0�Ø/0°:©~×.AÒ.AÀ+ÔBSÑ.TÔ.T��E '™NœNÑ+Ý.3¬kØ˜1˜q™5Ÿ*š* [Ô%6Ñ7Ô7¸ÅUÈ7Á^Ä^Ô9Tñ/ô /��E '™NœNÑ+ð
 " JÑ.µ´¸jÑ1IÔ1IÈ[Ð[fÑMfÑ1gÑgˆGØ—k’k‘m”m iÑ/ˆG‰GàÔ.ñ ]	ØÐ#Ý$œyÐ)_Ð)_ÍÈWÐV]ÑI^ÔI^Ð)_Ñ)_Ô)_ÐefÐgÑgÔg�Ø Ô-¨cÔ2ˆIÝ$Ô8ÝÔ*¨9×+;Ò+;Ñ+=Ô+=Ñ>Ô>ÝÔ*¨<Ñ8Ô8ñô ‰NˆK˜ð #×(Ò(Ñ*Ô*×1Ò1Ñ3Ô3ˆHà$ˆMå#(¤;ØÔ! !Ô$ jÔ&6°qÔ&9¸4Ô;KÐLØ Ô&Ø!Ô(ð$ñ $ô $Ð õ ˜3‘i”iˆGØ�NŠNÐ+Ñ,Ô,Ð,Ø)×,Ò,Ð-AÔ-GÑHÔHˆMØ3@Ð ¥ w¡¤Ñ0Ø(<Ø$×)Ò)Ð*>Ô*DÀQÔ*GÈÈQÑOÔO×TÒTÐUVÐX\Ñ]Ô]Ð`dÑdñ)Ð%õ )ØØ-ØØÔ*Øðñ ô ð Ô" 1Ô%ñ&ð ‰Gð Ô$ñ 9	Ø Ô-¨cÔ2ˆIØÐ#Ý$œyÐ)_Ð)_ÍÈWÐV]ÑI^ÔI^Ð)_Ñ)_Ô)_ÐefÐgÑgÔg�å$Ô8ÝÔ*¨9×+;Ò+;Ñ+=Ô+=Ñ>Ô>ÝÔ*¨<Ñ8Ô8ñô ‰NˆK˜ð #×(Ò(Ñ*Ô*×1Ò1Ñ3Ô3ˆHå#œkØÔ! !Ô$ jÔ&6°qÔ&9¸4Ô;KÐLØ Ô&Ø!Ô(ðñ ô ˆOõ ˜3‘i”iˆGØ�NŠNÐ+Ñ,Ô,Ð,Ø.6ˆO�E '™NœNÑ+å&ØØ#ØØÔ*Øðñ ô ð Ô" 1Ô%ñ&ð ˆGõ #œZØÔ   ! Ô$ØÔ Ý”kØ!Ô(ð	ñ ô ˆNð #3ˆN˜3Ñå$)¤KØÔ! !Ô$ jÔ&6°qÔ&9¸:Ô;KÈAÔ;NÐQRÑ;RÐSØ Ô&Ø!Ô(Ø!Ô(ð	%ñ %ô %Ð!ð "×*Ò*¨1¨n×.FÒ.FÀrÑ.JÔ.JÈAÑNÔNÐNà$9¸!¸!¸!¸Q¸Q¸QÀÀÀ¸)Ô$DÐ!å"ØØ)ØØÔ*Øðñ ô ð Ô" 1Ô%ñ&ð ð ˜WÐ%ˆàð 		qàÐ!Ø(+­h°zÀ#´ÐHXÑ.YÔ.YÐZ[Ô.\Ñ(\��}Ñ%Ð%ð
 & cœ?×1Ò1°bÐ1Ñ9Ô9Ð=MÒM×QÒQÐR\ÔRbÑcÔc�Ø(+¨c°W¸zÑ5I×4NÒ4NÑ4PÔ4PÑ.PÐS]×SaÒSaÑScÔSc×SiÒSiÐnoÐSiÑSpÔSpÑ.pÑ(p��}Ñ%Øˆr^   c                óâ  — |d         }|j         }|r=d|d         v r3t          j        d„ |D ¦   «         ¦  «                             |¬¦  «        }n t          j        d„ |D ¦   «         |¬¦  «        }|                     ¦   «                              d¦  «        j        dk                         d	¦  «        }t          j
        |                     ¦   «         |                     ¦   «         ¦  «        }	d
|	i}
|
S )zÝCompute the cardinality error, ie the absolute error in the number of predicted non-empty boxes This is not
        really a loss, it is intended for logging purposes only.

        It doesn't propagate gradients
        r  rý   r   c                óB   — g | ]}|d                                ¦   «         ‘ŒS rÿ   r   ©rk   Úvs     r\   r|   z1SetCriterion.loss_cardinality.<locals>.<listcomp>0  s&   € Ð&IÐ&IÐ&I¸A q¨¤z§~¢~Ñ'7Ô'7Ð&IÐ&IÐ&Ir^   r#   c                ó8   — g | ]}t          |d          ¦  «        ‘ŒS r  r  r@  s     r\   r|   z1SetCriterion.loss_cardinality.<locals>.<listcomp>2  s$   € Ð*MÐ*MÐ*MÀ­3¨q°¬{Ñ+;Ô+;Ð*MÐ*MÐ*Mr^   r%   r/   r'   r[   )r$   r0   r  r<   r	  r7   rE   rF   rB   r@   rC   r   )rò   rô   r_   ra   r   r  r$   Útgt_lengthsÚ	card_predÚcard_errrâ   s              r\   Úloss_cardinalityzSetCriterion.loss_cardinality  sð   € ð ˜mÔ,ˆØÔ#ˆØð 		^�w '¨!¤*Ð,Ð,õ  œ+Ð&IÐ&IÀÐ&IÑ&IÔ&IÑJÔJ×MÒMÐU[ÐMÑ\Ô\ˆKˆKåœ/Ð*MÐ*MÀWÐ*MÑ*MÔ*MÐV\Ð]Ñ]Ô]ˆKà ×(Ò(Ñ*Ô*×.Ò.¨rÑ2Ô2Ô9¸CÒ?×DÒDÀQÑGÔGˆ	Ý”9˜YŸ_š_Ñ.Ô.°×0AÒ0AÑ0CÔ0CÑDÔDˆØ% xÐ0ˆØˆr^   c                óF  — d|v sJ ‚|€|                       |¦  «        n|j        }|d         |         }|€.t          j        d„ t	          ||¦  «        D ¦   «         d¬¦  «        n|j        }t          j        ||d¬¦  «        }	|                      ||¦  «        }
|
�|	|
dd…df         z  }	i }|	 	                    ¦   «         |z  |d<   d	t          j        t          j        |¦  «        t          j        |¦  «        ¦  «        z
  }|
�||
z  }| 	                    ¦   «         |z  |d
<   |S )a'  Compute the losses related to the bounding boxes, the L1 regression loss and the GIoU loss targets dicts must
        contain the key "boxes" containing a tensor of dim [nb_target_boxes, 4] The target boxes are expected in format
        (center_x, center_y, w, h), normalized by the image size.r  Nc                ó6   — g | ]\  }\  }}|d          |         ‘ŒS r  r{   r  s       r\   r|   z+SetCriterion.loss_boxes.<locals>.<listcomp>H  s(   € ÐLÐLÐL©¨©F¨Q°�q˜”z !”}ÐLÐLÐLr^   r   r*   r,   r-   rX   r'   rY   )r$  r   r0   r’   r€   r   r@   rC   r"  rB   r   rD   r3   )rò   rô   r_   ra   r   r  r.  r0  r   rX   r   râ   rY   s                r\   Ú
loss_boxeszSetCriterion.loss_boxes9  sR  € ð ˜wÐ&Ð&Ð&Ð&Ø8GÐ8Oˆd×+Ò+¨GÑ4Ô4Ð4ÐUdÔUsˆØ˜LÔ)¨#Ô.ˆ	ð Ð&õ ŒIÐLÐLµc¸'À7Ñ6KÔ6KÐLÑLÔLÐRSÐTÑTÔTÐTà Ô&ð 	õ ”I˜i¨ÀÐHÑHÔHˆ	Ø×-Ò-¨g°wÑ?Ô?ˆ
ØÐ!Ø! J¨q¨q¨q°$¨wÔ$7Ñ7ˆIàˆØ'Ÿmšm™oœo°	Ñ9ˆˆ{Ñà�Ô?ÝÔ& yÑ1Ô1ÝÔ& |Ñ4Ô4ñ
ô 
ñ 
ˆ	ð Ð!Ø! JÑ.ˆIØ'Ÿmšm™oœo°	Ñ9ˆˆ{ÑØˆr^   c                óø  — d|v s
J d¦   «         ‚|rd|d         v rt          d¦  «        ‚|                      |¦  «        }|d         }t          |t          ¦  «        r
||         }�n¾|d         d         }|d         d         }	|d         d         }
|d                              ¦   «         dk    rF|                     ¦   «         |	                     ¦   «         z   |
                     ¦   «         z   d	z  }||d
œS g }|d                              d¬¦  «        d         }t          j        t          j	        |dd…         ¦  «        |fd¬¦  «         
                    d¦  «        }t          |j        d         ¦  «        D ]˜}|d         ||         ||dz            …         }|d         ||         ||dz            …         }|	||f         }||d         ||dz            dz
                    }t          j        d||¦  «        |
z   }|                     |¦  «         Œ™t          j        |¦  «        }|                     ¦   «         dk    r)|                     ¦   «         |                     ¦   «         d
œS |                     d¦  «        }t!          |j        d         |j        d         |j        d         z  | j        z  ¦  «        }t          j        ¦   «         5  t'          |d„ |dd¦  «        }ddd¦  «         n# 1 swxY w Y   t)          ||d¬¦  «                             d¦  «        }t          j        ¦   «         5  t-          |||¦  «        }ddd¦  «         n# 1 swxY w Y   t/          |||¦  «        t1          |||¦  «        d
œ}~|S )z¾Compute BCE-with-logits and Dice losses for segmentation masks on matched pairs.

        Expects outputs to contain 'pred_masks' of shape [B, Q, H, W] and targets with key 'masks'.
        Ú
pred_masksz#pred_masks missing in model outputsrý   r   zÒFixed-size target padding does not cover the mask loss yet: loss_masks point-samples every matched pair, so the filler pairs would contribute real gradient. Leave pad_targets_to unset for segmentation training.Úspatial_featuresÚquery_featuresÚbiasrË   )Úloss_mask_ceÚloss_mask_diceT)Úreturn_countsr'   Nr*   zchw,nc->nhwrg   r%   c                ó    — t          | ¦  «        S rx   )r   )r   s    r\   ú<lambda>z)SetCriterion.loss_masks.<locals>.<lambda>¬  s   € Õ4°VÑ<Ô<€ r^   r)   g      è?F)rr   )r#  r$  r‚   r   ry   rB   Úuniquer0   r’   r8   ÚcumsumÚranger2   Úeinsumr‘   rŽ   rE   ré   Úno_gradr   r   r�   r³   Úsigmoid_ce_loss_jitÚdice_loss_jit)rò   rô   r_   ra   r   r.  rK  Ú	src_masksrL  rM  rN  ÚzeroÚbatched_selected_masksÚper_batch_countsr   r  Úbatch_indicatorÚbox_indicatorÚthis_batch_queriesÚthis_batch_spatial_featuresÚthis_batch_masksÚ
num_pointsrc   Úpoint_logitsÚpoint_labelsrâ   s                             r\   Ú
loss_maskszSetCriterion.loss_masks^  s[  € ð ˜wÐ&Ð&Ð&Ð(MÑ&Ô&Ð&Øð 	�w '¨!¤*Ð,Ð,Ý%ðBñô ð ð
 ×+Ò+¨GÑ4Ô4ˆØ˜\Ô*ˆ
å�j¥&Ñ)Ô)ð %	>ð # 3œˆI‰Ià& |Ô4Ð5GÔHÐØ$ \Ô2Ð3CÔDˆNØ˜<Ô(¨Ô0ˆDð �1Œv�|Š|‰~Œ~ Ò"Ð"Ø(×,Ò,Ñ.Ô.°×1CÒ1CÑ1EÔ1EÑEÈÏÊÉ
Ì
ÑRÐVYÑY�Ø(,ÀÐEÐEÐEà)+Ð&Ø#& q¤6§=¢=¸t =Ñ#DÔ#DÀQÔ#GÐ Ý %¤	­5Ô+;Ð<LÈRÈaÈRÔ<PÑ+QÔ+QÐScÐ*dÐjkÐ lÑ lÔ l× sÒ sÐtuÑ vÔ v�åÐ/Ô5°aÔ8Ñ9Ô9ð Dð D�AØ&)¨!¤f¨]¸1Ô-=ÀÈaÐRSÉeÔ@TÐ-TÔ&U�OØ$'¨¤F¨=¸Ô+;¸mÈAÐPQÉEÔ>RÐ+RÔ$S�Mà)7¸È-Ð8XÔ)YÐ&Ø2BÀ3ÀqÄ6È-ÐXYÐ\]ÑX]ÔJ^ÐabÑJbÔCcÔ2dÐ/õ œØ)Ø7Ø.ñô ð
 ñð %ð +×1Ò1Ð2BÑCÔCÐCÐCå!œIÐ&<Ñ=Ô=�	à�?Š?ÑÔ Ò!Ð!à )§¢¡¤Ø"+§-¢-¡/¤/ðð ð ð ×'Ò'¨Ñ*Ô*ˆ	åØŒO˜BÔØŒO˜BÔ )¤/°"Ô"5Ñ5¸Ô9UÑUñ
ô 
ˆ
õ
 Œ]‰_Œ_ð 	ð 	åEØØ<Ð<ØØØñô ˆLð	ð 	ð 	ñ 	ô 	ð 	ð 	ð 	ð 	ð 	ð 	øøøð 	ð 	ð 	ð 	õ $ØØØð
ñ 
ô 
÷ Š'�!‰*Œ*ð	 	õ Œ]‰_Œ_ð 	Zð 	Zå9¸'À7ÈLÑYÔYˆLð	Zð 	Zð 	Zñ 	Zô 	Zð 	Zð 	Zð 	Zð 	Zð 	Zð 	Zøøøð 	Zð 	Zð 	Zð 	Zõ 0°¸lÈIÑVÔVÝ+¨L¸,È	ÑRÔRð
ð 
ˆð
 Øˆs$   Ë	K*Ë*K.Ë1K.Ì-MÍMÍMc                óR  — d|v sJ ‚|rd|d         v rt          d¦  «        ‚|                      |¦  «        }|d         |         }t          j        d„ t	          ||¦  «        D ¦   «         d¬¦  «        }t          j        d„ t	          ||¦  «        D ¦   «         d¬¦  «        }t          j        d„ t	          ||¦  «        D ¦   «         d¬¦  «        }	|	d	d	…d
f         |	d	d	…df         z  }
t          ||                     |j        ¦  «        |                     |j        ¦  «        |
                     |j        ¦  «        | j        ¬¦  «        \  }}}}| 	                    ¦   «         |z  | 	                    ¦   «         |z  | 	                    ¦   «         |z  | 	                    ¦   «         |z  dœS )z;Compute keypoint losses on matched prediction/target pairs.Úpred_keypointsrý   r   zåFixed-size target padding does not cover the keypoint loss yet: loss_keypoints reads every matched pair with no valid-row mask, so the filler pairs would contribute real gradient. Leave pad_targets_to unset for keypoint training.c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS )Ú	keypointsr{   ©rk   rl   rN   Újs       r\   r|   z/SetCriterion.loss_keypoints.<locals>.<listcomp>Ü  s*   € Ð%iÐ%iÐ%iÁÀÉÈ!ÈQ f¨[Ô&9¸!Ô&<Ð%iÐ%iÐ%ir^   r*   c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS r  r{   rl  s       r\   r|   z/SetCriterion.loss_keypoints.<locals>.<listcomp>Ý  s*   € Ð#dÐ#dÐ#d¹N¸FÁFÀQÈ F¨8Ô$4°QÔ$7Ð#dÐ#dÐ#dr^   c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS r  r{   rl  s       r\   r|   z/SetCriterion.loss_keypoints.<locals>.<listcomp>Þ  s)   € Ð!aÐ!aÐ!a¹¸ÁÀ!ÀQ &¨¤/°!Ô"4Ð!aÐ!aÐ!ar^   Nr   r)   )Úall_pred_keypointsÚtarget_keypointsr:  Útarget_areasrê   )Úloss_keypoints_l1Úloss_keypoints_findableÚloss_keypoints_visibleÚloss_keypoints_nll)
r#  r$  r0   r’   r€   r
   r<   r$   rê   rB   )rò   rô   r_   ra   r   r.  Úsrc_keypointsrq  r:  r   rr  Úloss_l1Úloss_findableÚloss_visibleÚloss_nlls                  r\   Úloss_keypointszSetCriterion.loss_keypointsË  sÖ  € ð   7Ð*Ð*Ð*Ð*Øð 	�w '¨!¤*Ð,Ð,Ý%ð^ñô ð ð
 ×+Ò+¨GÑ4Ô4ˆØÐ 0Ô1°#Ô6ˆÝ œ9Ð%iÐ%iÕSVÐW^Ð`gÑShÔShÐ%iÑ%iÔ%iÐopÐqÑqÔqÐÝœÐ#dÐ#dÍcÐRYÐ[bÑNcÔNcÐ#dÑ#dÔ#dÐjkÐlÑlÔlˆÝ”yÐ!aÐ!aÍ3ÈwÐX_ÑK`ÔK`Ð!aÑ!aÔ!aÐghÐiÑiÔiˆØ# A A A q DÔ)¨L¸¸¸¸A¸Ô,>Ñ>ˆå9QØ,Ø-×0Ò0°Ô1EÑFÔFØ)×,Ò,¨]Ô-AÑBÔBØ%Ÿš¨Ô)=Ñ>Ô>Ø$(Ô$@ð:
ñ :
ô :
Ñ6ˆ� ¨hð ")§¢¡¤°Ñ!:Ø'4×'8Ò'8Ñ':Ô':¸YÑ'FØ&2×&6Ò&6Ñ&8Ô&8¸9Ñ&DØ"*§,¢,¡.¤.°9Ñ"<ð	
ð 
ð 	
r^   r¶   c                óœ   — t          j        d„ t          |¦  «        D ¦   «         ¦  «        }t          j        d„ |D ¦   «         ¦  «        }||fS )Nc                óD   — g | ]\  }\  }}t          j        ||¦  «        ‘ŒS r{   ©r0   Ú	full_like)rk   r  ÚsrcrN   s       r\   r|   z9SetCriterion._get_src_permutation_idx.<locals>.<listcomp>ò  s,   € Ð]Ð]Ð]¹;¸1¹h¸sÀA�uœ¨s°AÑ6Ô6Ð]Ð]Ð]r^   c                ó   — g | ]\  }}|‘ŒS r{   r{   )rk   r�  rN   s      r\   r|   z9SetCriterion._get_src_permutation_idx.<locals>.<listcomp>ó  s   € Ð9Ð9Ð9¡X c¨1˜SÐ9Ð9Ð9r^   ©r0   r’   Ú	enumerate)rò   ra   Ú	batch_idxÚsrc_idxs       r\   r$  z%SetCriterion._get_src_permutation_idxð  óR   € å”IÐ]Ð]Í)ÐT[ÑJ\ÔJ\Ð]Ñ]Ô]Ñ^Ô^ˆ	Ý”)Ð9Ð9°Ð9Ñ9Ô9Ñ:Ô:ˆØ˜'Ð!Ð!r^   rµ   c                óô   — t          |                      |¦  «        t          j        d„ t	          ||¦  «        D ¦   «         ¦  «        t          j        d„ t	          ||¦  «        D ¦   «         ¦  «        ¬¦  «        S )aÌ  Collect matched detection targets for losses sharing one layer's indices.

        Args:
            targets: Per-image target dictionaries in batch order.
            indices: Per-image matcher results, where each pair contains source
                query indices and their corresponding target indices.

        Returns:
            Matched targets containing ``source_indices``, ``labels``, and
            ``boxes``. The tensors are concatenated across images in the same
            order as ``indices`` and ``targets``, so all three fields use the
            same flattened batch-of-matches ordering. Callers must not reorder
            one field without applying the same reordering to the others.
        c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS r  r{   rj   s       r\   r|   z5SetCriterion._get_matched_targets.<locals>.<listcomp>
  s,   € ÐkÐkÐkÑ6Q°fÑ>Q¸qÀ.�˜Ô! .Ô1ÐkÐkÐkr^   c                ó6   — g | ]\  }\  }}|d          |         ‘ŒS r  r{   rj   s       r\   r|   z5SetCriterion._get_matched_targets.<locals>.<listcomp>  s+   € ÐvÐvÐvÑA\ÀÑI\È!È^˜V Gœ_¨^Ô<ÐvÐvÐvr^   )r   r·   r   )rµ   r$  r0   r’   r€   )rò   r_   ra   s      r\   Ú_get_matched_targetsz!SetCriterion._get_matched_targetsö  s„   € õ" Ø×8Ò8¸ÑAÔAÝ”9ØkÐkÕUXÐY`ÐbiÑUjÔUjÐkÑkÔkñô õ ”)ÐvÐvÕ`cÐdkÐmtÑ`uÔ`uÐvÑvÔvÑwÔwð
ñ 
ô 
ð 	
r^   úTensor | Nonec                óš   — | r
d| d         vrdS t          j        d„ t          | |¦  «        D ¦   «         ¦  «                             ¦   «         S )a¼  Per-matched-pair mask marking which pairs point at a real target rather than padding.

        Returns ``None`` when the batch carries no ``valid`` key, which is every batch that did not go
        through fixed-size target padding -- so the unpadded path keeps its exact previous arithmetic.

        Args:
            targets: Per-image target dictionaries in batch order.
            indices: Per-image matcher results, source and target indices.

        Returns:
            A float mask flattened in the same order as the matched tensors, or ``None``.

        Examples:
            >>> SetCriterion._matched_valid_mask([{"labels": torch.zeros(1)}], [(torch.zeros(1), torch.zeros(1))])
        rý   r   Nc                ó6   — g | ]\  }\  }}|d          |         ‘ŒS rÿ   r{   rj   s       r\   r|   z4SetCriterion._matched_valid_mask.<locals>.<listcomp>#  s+   € ÐfÐfÐfÑ1L°Ñ9L¸!¸^ˆV�GŒ_˜^Ô,ÐfÐfÐfr^   )r0   r’   r€   r   )r_   ra   s     r\   r"  z SetCriterion._matched_valid_mask  sZ   € ð" ð 	˜'¨°¬Ð3Ð3Ø�4ÝŒyØfÐfÕPSÐT[Ð]dÑPeÔPeÐfÑfÔfñ
ô 
ç
Š%‰'Œ'ð	r^   c                óœ   — t          j        d„ t          |¦  «        D ¦   «         ¦  «        }t          j        d„ |D ¦   «         ¦  «        }||fS )Nc                óD   — g | ]\  }\  }}t          j        ||¦  «        ‘ŒS r{   r  )rk   r  rN   Útgts       r\   r|   z9SetCriterion._get_tgt_permutation_idx.<locals>.<listcomp>(  s,   € Ð]Ð]Ð]¹;¸1¹h¸qÀ#�uœ¨s°AÑ6Ô6Ð]Ð]Ð]r^   c                ó   — g | ]\  }}|‘ŒS r{   r{   )rk   rN   r‘  s      r\   r|   z9SetCriterion._get_tgt_permutation_idx.<locals>.<listcomp>)  s   € Ð9Ð9Ð9¡X a¨˜SÐ9Ð9Ð9r^   rƒ  )rò   ra   r…  Útgt_idxs       r\   Ú_get_tgt_permutation_idxz%SetCriterion._get_tgt_permutation_idx&  r‡  r^   Úmatched_outputsúlist[dict[str, Any]]úlist[_MatchedTargets]c                ó’  ‡‡‡— t          | ¦  «        t          uslt          | dd¦  «        r[t          | dd¦  «        rJt          | dg ¦  «        g d¢k    s3t          |¦  «        dk     s t          |¦  «        t          |¦  «        k    rdS |d                              d¦  «        Š|d                              d	¦  «        Št          ‰t          ¦  «        r5t          ‰t          ¦  «        r ‰j        j         d
k    s‰j        j         d
k    rdS |d         j        j	        Št          ˆˆˆfd„t          ||d¬¦  «        D ¦   «         ¦  «        S )a˜  Return whether the stock IA-BCE detection losses can share one layer-batched execution.

        Args:
            matched_outputs: Final, auxiliary, and encoder output dictionaries.
            matched_targets: Target tensors already gathered for each output layer.

        Returns:
            Whether every layer satisfies the stock detection fast path's shape, dtype, and ownership constraints.
        rð   Frè   râ   )r·   r   rZ   r   r   r  r  Úcudac              3  óæ  •K  — | ]ë\  }}t          |                     d ¦  «        t          ¦  «        o»t          |                     d¦  «        t          ¦  «        o“|d          j        ‰j        k    o}|d          j        ‰j        k    og|d          j        ‰j        k    oQ|d         j        ‰j        k    o;|d         j        ‰j        k    o%|d         j        ‰j        k    o|j        j        ‰k    V — ŒìdS )r  r  N)r‚   r�   r   r2   r=   r$   r·   )rk   Úlayerr_   r   r   Úmatched_shapes      €€€r\   rn   z;SetCriterion._can_batch_detection_losses.<locals>.<genexpr>M  s  øè è € ð 
ð 
ñ ��wõ �u—y’y Ñ/Ô/µÑ8Ô8ð 6Ý˜5Ÿ9š9 \Ñ2Ô2µFÑ;Ô;ð6à�mÔ$Ô*¨f¬lÒ:ð6ð �mÔ$Ô*¨f¬lÒ:ð6ð �mÔ$Ô+¨v¬}Ò<ð	6ð
 �lÔ#Ô)¨U¬[Ò8ð6ð �lÔ#Ô)¨U¬[Ò8ð6ð �lÔ#Ô*¨e¬lÒ:ð6ð ”Ô$¨Ò5ð
ð 
ð 
ð 
ð 
ð 
r^   T©Ústrict)r~   rÜ   Úgetattrr}   r�   r‚   r   r$   r·   r2   rˆ   r€   )rò   r•  r  r   r   rœ  s      @@@r\   Ú_can_batch_detection_lossesz(SetCriterion._can_batch_detection_losses,  sr  øøø€ õ �‰JŒJ�lÐ*Ð*Ý˜4Ð!DÀeÑLÔLð +å˜4 °Ñ6Ô6ð +õ �t˜X rÑ*Ô*Ð.PÐ.PÐ.PÒPÐPÝ�?Ñ#Ô# aÒ'Ð'Ý�?Ñ#Ô#¥s¨?Ñ';Ô';Ò;Ð;à�5Ø  Ô#×'Ò'¨Ñ6Ô6ˆØ Ô"×&Ò& |Ñ4Ô4ˆå˜6¥6Ñ*Ô*ð	å˜e¥VÑ,Ô,ð	ð Œ}Ô! VÒ+Ð+ØŒ|Ô  FÒ*Ð*à�5Ø'¨Ô*Ô1Ô7ˆÝð 
ð 
ð 
ð 
ð 
ð 
õ #& o°ÈtÐ"TÑ"TÔ"Tð
ñ 
ô 
ñ 
ô 
ð 	
r^   Úall_indicesú!list[list[tuple[Tensor, Tensor]]]c                ó¾  ‡ ‡— t          j        d„ |D ¦   «         ¦  «        }t          j        d„ |D ¦   «         ¦  «        }t          j        d„ |D ¦   «         ¦  «        }t          j        d„ |D ¦   «         ¦  «        }	t          j        d„ |D ¦   «         ¦  «        }
t          j        d„ |D ¦   «         ¦  «        }ˆ ˆfd„|D ¦   «         }|d         €t          j        |
|j        ¬
¦  «        }nt          j        d„ |D ¦   «         ¦  «        }‰rBd‰d         v r8t          j        d„ ‰D ¦   «         ¦  «                             |j        ¬¦  «        }n%t          j        d„ ‰D ¦   «         |j        ¬¦  «        }‰                      |j        ¦  «        } |||||	|
||||‰ j        ¦
  «
        \  }}}}g }t          t          ||d¬¦  «        ¦  «        D �]\  }\  }}||         ||         ||         ||         dœ}|dk    rÎ|d         }|€3dt          |d         |j                 |j        ¦  «        d         z
  |d<   n‘|d         |j                                      d¬¦  «        |j        k                         |j        ¦  «        }dd||z                       ¦   «         z  |                     ¦   «                              d¬¦  «        z  z
  |d<   |                     |¦  «         �Œ|S )a„  Evaluate the default IA-BCE detection losses across output layers in one set of kernels.

        Args:
            matched_outputs: Shape-compatible final, auxiliary, and encoder outputs.
            targets: Per-image target dictionaries shared by every output layer.
            all_indices: Per-layer matcher results in the same order as ``matched_outputs``.
            matched_targets: Per-layer target tensors gathered from ``all_indices``.
            num_boxes: Shared normalization denominator for every layer.

        Returns:
            One unsuffixed loss dictionary per output layer. The caller adds the layer suffixes.
        c                ó   — g | ]
}|d          ‘ŒS )r  r{   ©rk   r›  s     r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>n  s   € ÐPÐPÐP°u˜e MÔ2ÐPÐPÐPr^   c                ó   — g | ]
}|d          ‘ŒS )r  r{   r¥  s     r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>o  s   € ÐNÐNÐN°U˜U <Ô0ÐNÐNÐNr^   c                ó(   — g | ]}|j         d          ‘ŒS )r   ©r   ©rk   Úmatcheds     r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>p  s    € Ð$^Ð$^Ð$^À7 WÔ%;¸AÔ%>Ð$^Ð$^Ð$^r^   c                ó(   — g | ]}|j         d          ‘ŒS )r'   r¨  r©  s     r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>q  s    € Ð%_Ð%_Ð%_ÀG gÔ&<¸QÔ&?Ð%_Ð%_Ð%_r^   c                ó   — g | ]	}|j         ‘Œ
S r{   r  r©  s     r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>r  s   € Ð$SÐ$SÐ$S¸ W¤^Ð$SÐ$SÐ$Sr^   c                ó   — g | ]	}|j         ‘Œ
S r{   r  r©  s     r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>s  s   € Ð#QÐ#QÐ#Q°g G¤MÐ#QÐ#QÐ#Qr^   c                ó<   •— g | ]}‰                      ‰|¦  «        ‘ŒS r{   )r"  ©rk   ra   rò   r_   s     €€r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>t  s)   ø€ Ð]Ð]Ð]Àg�t×/Ò/°¸ÑAÔAÐ]Ð]Ð]r^   r   N)r=   c                ó   — g | ]}|®|‘ŒS rx   r{   )rk   Úmasks     r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>x  s   € Ð-_Ð-_Ð-_°tÈdÐN^¨dÐN^ÐN^ÐN^r^   rý   c                óB   — g | ]}|d                                ¦   «         ‘ŒS rÿ   r   r  s     r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>z  s(   € Ð)VÐ)VÐ)VÀF¨&°¬/×*=Ò*=Ñ*?Ô*?Ð)VÐ)VÐ)Vr^   r#   c                ó8   — g | ]}t          |d          ¦  «        ‘ŒS r  r  r  s     r\   r|   z>SetCriterion._get_batched_detection_losses.<locals>.<listcomp>|  s%   € Ð-ZÐ-ZÐ-ZÈ­c°&¸Ô2BÑ.CÔ.CÐ-ZÐ-ZÐ-Zr^   Tr�  )rU   rX   rY   r[   r   r  r!  r%   r*   r'   r  )r0   r  Ú	ones_liker=   r<   r$   r	  Ú!_resolve_batched_detection_lossesr   r„  r€   r   r   r·   r,  rB   r:   r‘   )rò   r•  r_   r¡  r  r   r   r   r   r   r   r   Úvalid_masksÚstacked_valid_maskr   Úloss_tensor_fnrU   rX   rY   r[   Úlayer_lossesÚlayer_indexÚlayer_outputsrª  râ   r   r<  s   ` `                        r\   Ú_get_batched_detection_lossesz*SetCriterion._get_batched_detection_lossesZ  s@  øø€ õ( ”ÐPÐPÀÐPÑPÔPÑQÔQˆÝ”ÐNÐN¸oÐNÑNÔNÑOÔOˆÝœÐ$^Ð$^ÈoÐ$^Ñ$^Ô$^Ñ_Ô_ˆÝœÐ%_Ð%_ÈÐ%_Ñ%_Ô%_Ñ`Ô`ˆÝœÐ$SÐ$SÀ?Ð$SÑ$SÔ$SÑTÔTˆÝ”{Ð#QÐ#QÀÐ#QÑ#QÔ#QÑRÔRˆØ]Ð]Ð]Ð]Ð]ÐQ\Ð]Ñ]Ô]ˆØ�qŒ>Ð!Ý!&¤°ÀeÄkÐ!RÑ!RÔ!RÐÐå!&¤Ð-_Ð-_¸{Ð-_Ñ-_Ô-_Ñ!`Ô!`ÐØð 	r�w '¨!¤*Ð,Ð,Ý"œ[Ð)VÐ)VÈgÐ)VÑ)VÔ)VÑWÔW×ZÒZÐbhÔboÐZÑpÔpˆNˆNå"œ_Ð-ZÐ-ZÐRYÐ-ZÑ-ZÔ-ZÐciÔcpÐqÑqÔqˆNØ×?Ò?ÀÄÑNÔNˆØ;I¸>ØØØØØØØØØØÔñ<
ô <
Ñ8ˆ�˜IÐ'8ð ˆÝ5>½sÀ?ÐTcÐlpÐ?qÑ?qÔ?qÑ5rÔ5rð 	(ñ 	(Ñ1ˆKÑ1˜-¨à" ;Ô/Ø& {Ô3Ø& {Ô3Ø%6°{Ô%Cð	ð ˆFð ˜aÒÐØ(¨œ^�
ØÐ%à�h }°]Ô'CÀGÔDZÔ'[Ð]dÔ]kÑlÔlÐmnÔoÑoð ˜=Ñ)Ð)ð
 & mÔ4°WÔ5KÔL×SÒSÐXZÐSÑ[Ô[Ð_fÔ_mÒmß’b˜Ô)Ñ*Ô*ð ð -0°#¸À:Ñ9M×8RÒ8RÑ8TÔ8TÑ2TÐWa×WeÒWeÑWgÔWg×WmÒWmÐrsÐWmÑWtÔWtÑ2tÑ,t�F˜=Ñ)Ø×Ò Ñ'Ô'Ð'Ñ'ØÐr^   c                ó   — d| _         dS )z>Enable the CUDA layer-batched loss graph for a compiled model.TN)rð   )rò   s    r\   Ú enable_compiled_detection_lossesz-SetCriterion.enable_compiled_detection_losses¡  s   € à15ˆÔ.Ð.Ð.r^   r$   ú4Callable[..., tuple[Tensor, Tensor, Tensor, Tensor]]c                ó‚   — |j         dk    rt          S | j        € t          j        t          d¬¦  «        | _        | j        S )a  Return the eager tensor kernel off CUDA and a lazily compiled function on CUDA.

        Args:
            device: Device holding the stacked output layers.

        Returns:
            The eager tensor function, or its cached dynamic-shape Inductor wrapper on CUDA.
        r™  NT)Údynamic)r~   r]   rñ   r0   Úcompile)rò   r$   s     r\   rµ  z.SetCriterion._resolve_batched_detection_losses¥  sD   € ð Œ;˜&Ò Ð Ý2Ð2ØÔ2Ð:õ 7<´mÕDcÐmqÐ6rÑ6rÔ6rˆDÔ3ØÔ6Ð6r^   rÆ   ÚstrÚkwargsr   c                ó¢   — | j         | j        | j        | j        | j        dœ}||v sJ d|› d�¦   «         ‚|�	|dv r||d<    ||         ||||fi |¤ŽS )N)r·   rZ   r   rf   rk  zdo you really want to compute z loss?>   r   r·   r  )r=  rF  rI  rg  r|  )	rò   rÆ   rô   r_   ra   r   r  rÄ  Úloss_maps	            r\   Úget_losszSetCriterion.get_loss¹  s‘   € ð Ô&ØÔ0Ø”_Ø”_ØÔ,ð.
ð .
ˆð �xÐÐÐÐ!NÀ$Ð!NÐ!NÐ!NÑÔÐØÐ&¨4Ð3FÐ+FÐ+FØ(7ˆFÐ$Ñ%Øˆx˜Œ~˜g w°¸ÐMÐMÀfÐMÐMÐMr^   úTensor | float | Nonec           	     óè  ‡ ‡‡‡— ‰ j         r‰ j        nd}d„ |                     ¦   «         D ¦   «         }t          ‰ j        dd¦  «        }d|iŠ|�(|                     d¦  «        sd|v r ||‰¦  «        ‰d<   |g}d	g}d|v rZ|                     |d         ¦  «         |                     d
„ t          t          |d         ¦  «        ¦  «        D ¦   «         ¦  «         d|v r0| 	                    |d         ¦  «         | 	                    d¦  «         t          ‰ j        ¦  «        }	t          |	dd¦  «        t          j        u o‰ j        j         o‰ j        j         }
|
rt          |	dd¦  «        nd}|€dn |‰ j        |‰fi ‰¤Ž}|€ˆˆ ˆfd„|D ¦   «         }|€‰                      |‰¦  «        }n}t!          j        |¦  «        s5t!          j        |t           j        ‰                      |¦  «        ¬¦  «        }n4|                     ‰                      |¦  «        t           j        ¬¦  «        }ddht-          ‰ j        ¦  «        k    }|rˆ ˆfd„|D ¦   «         ng }‰                      ||¦  «        rh‰                      |‰|||¦  «        }i }t5          ||d¬¦  «        D ]8\  Š}|                     ˆfd„|                     ¦   «         D ¦   «         ¦  «         Œ9|S i }t9          t5          |||d¬¦  «        ¦  «        D ]y\  }\  Š}}|r||         nd}‰ j        D ]\}‰r
|dk    rddini }|�||d<    ‰ j        ||‰||fi |¤Ž}|                     ˆfd„|                     ¦   «         D ¦   «         ¦  «         Œ]Œz|S )u`  Compute every configured loss for one (outputs, targets) pair.

        Each output layer is matched against the targets. Compatible detection layers are batched through the
        matcher's private fast path; every other matcher and input shape uses the established per-layer calls. Each
        loss is then evaluated on that layer's matched indices and normalized by ``num_boxes``.

        Args:
            outputs: Model output dictionary. Must contain the tensors required by
                every loss in ``self.losses`` (for example ``"pred_logits"``,
                ``"pred_boxes"``, ``"pred_masks"``, ``"pred_keypoints"``). May also
                contain ``"aux_outputs"`` (list of layer-wise outputs) and
                ``"enc_outputs"`` (encoder outputs); both are processed identically
                to the last layer and contribute prefixed keys to the returned dict.
            targets: Per-image target dictionaries; ``len(targets) == batch_size``.
                The expected keys depend on the losses being applied â€” see each
                ``loss_*`` method for its target requirements.
            num_boxes: Optional explicit box-count denominator.

                - ``None`` (default): call :meth:`num_boxes_for_targets` to derive
                  the distributed-reduced normalizer for the current batch.
                - ``float`` / ``int``: cast to a tensor on the model output device
                  and used verbatim. Passing ``1.0`` yields *unnormalized* loss
                  numerators (used by the manual-optimization path so the caller
                  can apply its own accumulated denominator).
                - ``Tensor``: moved to the model output device and used
                  verbatim. The caller is responsible for any cross-rank reduction;
                  no extra all-reduce is performed in this branch.

        Returns:
            Dictionary of named loss tensors. Last-layer losses keep their base
            names (``"loss_ce"``, ``"loss_bbox"``, ``"loss_giou"``,
            ``"loss_mask_ce"``, ``"loss_mask_dice"``, ``"loss_keypoints_*"``).
            Auxiliary-layer losses get a ``"_<i>"`` suffix; encoder-layer losses
            get an ``"_enc"`` suffix.

        Examples:
            >>> import torch
            >>> from unittest.mock import MagicMock
            >>> from rfdetr.models.criterion import SetCriterion
            >>> criterion = SetCriterion.__new__(SetCriterion)
            >>> criterion.training = False
            >>> criterion.group_detr = 1
            >>> criterion.sum_group_losses = False
            >>> criterion.losses = []
            >>> criterion.matcher = MagicMock(return_value=[])
            >>> outputs = {"pred_logits": torch.zeros(1, 1, 1)}
            >>> targets = [{"labels": torch.tensor([0])}]
            >>> criterion.forward(outputs, targets, num_boxes=1.0)
            {}
        r'   c                ó&   — i | ]\  }}|d k    ¯||“ŒS )Úaux_outputsr{   )rk   ÚkrA  s      r\   ú
<dictcomp>z(SetCriterion.forward.<locals>.<dictcomp>  s(   € ÐVÐVÐV©¨¨1À1ÈÒCUÐCU˜q !ÐCUÐCUÐCUr^   Ú_precompute_target_side_safetyNrä   rË  Úenc_outputsÚtarget_side_safetyÚ c              3  ó    K  — | ]	}d |› �V — Œ
dS )rN   Nr{   )rk   Ú	aux_indexs     r\   rn   z'SetCriterion.forward.<locals>.<genexpr>#  s(   è è € Ð!fÐ!f°i / i / /Ð!fÐ!fÐ!fÐ!fÐ!fÐ!fr^   Ú_encÚforwardÚ_match_manyc                ó.   •— g | ]} ‰j         |‰fi ‰¤Ž‘ŒS r{   )rß   )rk   r»  Úmatcher_kwargsrò   r_   s     €€€r\   r|   z(SetCriterion.forward.<locals>.<listcomp>;  s0   ø€ ÐwÐwÐwÐVc˜<˜4œ<¨°wÐQÐQÀ.ÐQÐQÐwÐwÐwr^   r  )r$   r=   r·   r   c                ó<   •— g | ]}‰                      ‰|¦  «        ‘ŒS r{   )r‹  r¯  s     €€r\   r|   z(SetCriterion.forward.<locals>.<listcomp>H  s)   ø€ ÐTÐTÐT¸WˆT×&Ò& w°Ñ8Ô8ÐTÐTÐTr^   Tr�  c                ó"   •— i | ]\  }}|‰z   |“ŒS r{   r{   ©rk   Úkeyrú   Úsuffixs      €r\   rÍ  z(SetCriterion.forward.<locals>.<dictcomp>P  ó#   ø€ ÐZÐZÐZ±z°s¸E˜s V™|¨UÐZÐZÐZr^   r  Fr  c                ó"   •— i | ]\  }}|‰z   |“ŒS r{   r{   rÛ  s      €r\   rÍ  z(SetCriterion.forward.<locals>.<dictcomp>_  rÞ  r^   )r  rä   ÚitemsrŸ  rß   r�   ÚextendrV  r}   r‘   r~   r   rÕ  Ú_forward_pre_hooksÚ_forward_hooksr  r0   rø   r	  r   rû   r<   Úsetrâ   r   r¼  r€   Úupdater„  rÇ  )rò   rô   r_   r   rä   Úoutputs_without_auxÚ
precomputer•  Úlayer_suffixesÚmatcher_typeÚfast_path_safeÚ
match_manyr¡  Úhas_detection_targetsÚmatched_targets_by_layerÚbatched_lossesrâ   r¹  rº  r»  ra   r  rÆ   rÄ  rØ  rÝ  s   ` `                     @@r\   rÕ  zSetCriterion.forwardÏ  si  øøøø€ ðp )-¬Ð<�T”_�_¸1ˆ
ØVÐV°·²±´ÐVÑVÔVÐõ ˜Tœ\Ð+KÈTÑRÔRˆ
Ø*6¸
Ð)CˆØÐ! w§{¢{°=Ñ'AÔ'AÐ!À]ÐV]ÐE]ÐE]Ø3=°:Ð>QÐSZÑ3[Ô3[ˆNÐ/Ñ0ð
 /Ð/ˆØ˜ˆØ˜GÐ#Ð#Ø×"Ò" 7¨=Ô#9Ñ:Ô:Ð:Ø×!Ò!Ð!fÐ!fÅ5ÍÈWÐUbÔMcÑIdÔIdÑCeÔCeÐ!fÑ!fÔ!fÑfÔfÐfØ˜GÐ#Ð#Ø×"Ò" 7¨=Ô#9Ñ:Ô:Ð:Ø×!Ò! &Ñ)Ô)Ð)õ ˜DœLÑ)Ô)ˆå�L )¨TÑ2Ô2Õ6FÔ6NÐNð 0Ø”LÔ3Ð3ð0à”LÔ/Ð/ð 	ð
 DRÐ[•W˜\¨=¸$Ñ?Ô?Ð?ÐW[ˆ
àÐ&ˆDˆD¨J¨J°t´|À_ÐV]Ð,pÐ,pÐaoÐ,pÐ,pð 	ð ÐØwÐwÐwÐwÐwÐwÐgvÐwÑwÔwˆKàÐØ×2Ò2°7¸GÑDÔDˆIˆIÝ” Ñ+Ô+ð 	]Ýœ¨	½¼ÈT×M`ÒM`ÐahÑMiÔMiÐjÑjÔjˆIˆIà!Ÿš¨D×,?Ò,?ÀÑ,HÔ,HÕPUÔP[˜Ñ\Ô\ˆIð "*¨7Ð 3µs¸4¼;Ñ7GÔ7GÒ GÐàXmÐuÐTÐTÐTÐTÐTÈÐTÑTÔTÐTÐsuð 	!ð ×+Ò+¨OÐ=UÑVÔVð 	Ø!×?Ò?Ø ¨+Ð7OÐQZñô ˆNð ˆFÝ(+¨N¸NÐSWÐ(XÑ(XÔ(Xð \ð \Ñ$�˜Ø—’ÐZÐZÐZÐZÀ\×EWÒEWÑEYÔEYÐZÑZÔZÑ[Ô[Ð[Ð[ØˆMàˆÝ=FÝ� °ÀTÐJÑJÔJñ>
ô >
ð 	\ð 	\Ñ9ˆKÑ9˜& -°ð H]ÐfÐ6°{ÔCÐCÐbfˆOØœð \ð \�ð <BÐ)^ÀdÈhÒFVÐFV¨%°¨¨Ð\^�Ø"Ð.Ø0?�FÐ,Ñ-Ø,˜tœ}¨T°=À'È7ÐT]ÐhÐhÐagÐhÐh�Ø—’ÐZÐZÐZÐZÀ\×EWÒEWÑEYÔEYÐZÑZÔZÑ[Ô[Ð[Ð[ð\ð ˆr^   )r'   FFFFr   N)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ö   )rô   rõ   r_   r`   r    r   )TN)rô   rõ   r_   r`   ra   rb   r   r   r  r?   r  r  r    r  )
rô   rõ   r_   r`   ra   rb   r   r   r    r  rx   )rô   rõ   r_   r`   ra   rb   r   r   r  r  r    r  )ra   rb   r    r¶   )r_   r`   ra   rb   r    rµ   )r_   r`   ra   rb   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õ   r_   r`   ra   rb   r   r   r  r  rÄ  r   r    r  )rô   rõ   r_   r`   r   rÈ  r    r  )r¸   r¹   rº   r»   rÝ   r¼   rï   Ústaticmethodrû   r  r=  r0   rX  rF  rI  rg  r|  r$  r‹  r"  r”  r   r¼  r¾  rµ  rÇ  rÕ  Ú__classcell__)ró   s   @r\   rÜ   rÜ   Þ  sW  ø€ € € € € € ðð ð /3Ð%Ð2Ð2Ð2Ñ2ð Ø!&Ø#(Ø-2Ø!Ø')Ø48ð'tð 'tð 'tð 'tð 'tð 'tð 'tðR ðgð gð gñ „\ðgð$?Ið ?Ið ?Ið ?IðN Ø26ðoð oð oð oð oðb €U„]�_„_ðð ð ñ „_ððH 37ð#ð #ð #ð #ð #ðJkð kð kð kðZ#
ð #
ð #
ð #
ðJ"ð "ð "ð "ð
ð 
ð 
ð 
ð2 ðð ð ñ „\ðð,"ð "ð "ð "ð,
ð ,
ð ,
ð ,
ð\Eð Eð Eð EðN6ð 6ð 6ð 6ð7ð 7ð 7ð 7ð6 37ðNð Nð Nð Nð Nð4 ,0ð	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   r   r    r!   )r_   r`   ra   rb   rc   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   )4r»   Ú
__future__r   ÚsysÚcollections.abcr   Útypingr   r   r   r0   Útorch.nn.functionalr	   Ú
functionalr@   r   Úrfdetr.models.heads.keypointsr
   Ú rfdetr.models.heads.segmentationr   r   r   Úrfdetr.models.matcherr   Úrfdetr.models.mathr   Úrfdetr.utilitiesr   Úrfdetr.utilities.distributedr   r   ÚdictrÃ  Ú_LossFunctionr…   r†   r‡   r]   r³   rµ   rÉ   rÍ   rÏ   r×   Úversion_infoÚjitÚscriptrZ  rÚ   rY  ÚModulerÜ   r{   r^   r\   ú<module>r     sÔ  ðð 9Ð 8à "Ð "Ð "Ð "Ð "Ð "à 
€
€
€
Ø $Ð $Ð $Ð $Ð $Ð $Ø )Ð )Ð )Ð )Ð )Ð )Ð )Ð )Ð )Ð )à €€€Ø Ð Ð Ð Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ð Ð à BÐ BÐ BÐ BÐ BÐ Bðð ð ð ð ð ð ð ð ð ð
 3Ð 2Ð 2Ð 2Ð 2Ð 2Ø 'Ð 'Ð 'Ð 'Ð 'Ð 'Ø $Ð $Ð $Ð $Ð $Ð $Ø VÐ VÐ VÐ VÐ VÐ VÐ VÐ Và˜˜d 3¨ ;Ô/Ð/Ô0€ð $Ð ð ')Ð #ð !"Ð ðC<ð C<ð C<ð C<ðLAð Að Að AðH	ð 	ð 	ð 	ð 	�jñ 	ô 	ð 	ð  Øð"ð "ð "ð "ð "ðR Øð*ð *ð *ð *ð *ð* Øð*ð *ð *ð *ð *ð$#ð #ð #ð #ðP !Ô-°Ò8Ð8�	�	¸e¼i×>NÒ>NÈyÑ>YÔ>Y€ðð ð ð ðF *-Ô)9¸WÒ)DÐ)D�o�oÈ%Ì)×JZÒJZÐ[jÑJkÔJkÐ ðCð Cð Cð Cð C�2”9ñ Cô Cð Cð Cð Cr^   