^jvjdZddlmZddlmZddlZddlmcmZ ddlmZddl m Z ddl m Z mZmZddlmZdd lmZdd lmZmZddd Zddd Zddd Z ddZej6j9eZ ddZej6j9eZGddej@Z!y)z2Loss functions and criterion for RF-DETR training.) annotations)AnyN)nn)compute_l1_keypoint_loss)calculate_uncertainty*get_uncertain_point_coords_with_randomness point_sample)accuracy)box_ops)get_world_sizeis_dist_avail_and_initializedc|j}tj||d}||zd|z d|z zz}|d|z |zz}|dk\r||zd|z d|z zz} | |z}|jdj |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 = -1 (no weighting). gamma: Exponent of the modulating factor (1 - p_t) to balance easy vs hard examples. Returns: Loss tensor none reductionr)sigmoidF binary_cross_entropy_with_logitsmeansum) inputstargets num_boxesalphagammaprobce_lossp_tlossalpha_ts b/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/rfdetr/models/criterion.pysigmoid_focal_lossr#s$ >> D00FSG .AHW5 5C q3w5( )D z'/QY1w;$??~ 99Q<    ))cF|j}||dkDjzd|z ||z jj|z|dkjzz}t j ||d}||z}|j dj|z S)Nrrr)rfloatabspowrrrr) rrrrrr focal_weightrr s r"sigmoid_varifocal_lossr+=s >> D7S=''))QY4'>:N:N:P:T:TUZ:[,[_fjm_m^t^t^v,vv00FSG \ !D 99Q<    ))r$cF|j}tj||d}|tj||z |zz}|dk\r5||dkDj zd|z |dkj zz}||z}|j dj|z S)Nrrrr&r)rrrtorchr(r'rr) rrrrrrrr r!s r"position_supervised_lossr.Hs >> D00FSG eii$/58 9D z7S=//11QY7c>BXBXBZ4ZZ~ 99Q<    ))r$c|j}|jd}d||zjdz}|jd|jdz}d|dz|dzz z }|j|z S)aCompute 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). r)rflattenr)rr num_masks numerator denominatorr s r" dice_lossr6Tsz^^ F ^^A FVg%**2..I**R.7;;r?2K A +/2 2D 88: !!r$cvtj||d}|jdj|z S)aq 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). Returns: Loss tensor rrr)rrrr)rrr3r s r"sigmoid_ce_lossr8ms4 - -fg PD 99Q<    ))r$ceZdZUdZdZded< d dfd ZeddZ ddZ ddZ e jd Z d Zd Z dd Zd ZdZdZ d ddZxZS) SetCriterionaThis 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). Tbool!supports_loss_normalizer_overridec t |||_||_||_||_||_||_||_||_ | |_ | |_ | |_ | xsg|_ y)a4Create 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. N)super__init__ num_classesmatcher weight_dictlosses focal_alpha group_detrsum_group_lossesuse_varifocal_lossuse_position_supervised_loss ia_bce_lossmask_point_sample_rationum_keypoints_per_class)selfr@rArBrDrCrErFrGrHrIrJrK __class__s r"r?zSetCriterion.__init__sr2 & & &$ 0"4,H)&'>$'>'D"$r$c|jD]%}tj|s|jcSt d)aReturn 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.)valuesr- is_tensordevice ValueError)outputsvalues r"_output_devicezSetCriterion._output_devices>^^% $Eu%||# $effr$c||jr |jnd}td|D}|js||z}t j |tj |j|}trtjj|t j|tz dS)aCompute 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 rc38K|]}t|dyw)labelsN)len).0ts r" z5SetCriterion.num_boxes_for_targets..s:QAhK(:sdtyperQg?)min) trainingrErrFr- as_tensorr'rUr distributed all_reduceclampr )rLrSrrErnum_boxes_tensors r"num_boxes_for_targetsz"SetCriterion.num_boxes_for_targetssZ)- T__1 :':: $$!J.I ??9EKKPTPcPcdkPlm ( *    ( ()9 :{{+n.>>CHHr$c d|vsJ|d}|j|}tjt||D cgc]\}\} } |d| c} } }} |jr|j } d} |d|}tjt||D cgc]\}\} }|d|c}} }d}tj tjtj|jtj|d}|jj}|j}tj|}|| z}|Dcgc]}|}}|j| |t|j!| |j!d| z z}tj"|d j}|j%|j&|t|<d|j%|j&z |t|<||zt)j*|||zzz }|j-|z }n\|j.r|d|}tjt||D cgc]\}\} }|d|c}} }d}tj tjtj|jtj|d}|jj}|}tj0|j2d|j2d|j4f|j&|j6 }|Dcgc]}|}}|j| |j%|j&}||t|<||j9|j2dd dj;dd d zz }t=||||j d|j2dz}n|j>rr|d|}tjt||D cgc]\}\} }|d|c}} }d}tj tjtj|jtj|d}|jj}tj0|j2d|j2d|j4f|j&|j6 }|Dcgc]}|}}|j| ||t|<tA||||j d|j2dz}n tjB|j2dd|j4tjD|j6 }| ||<tj0|j2d|j2d|j2ddzg|j&|jF|j6}|jId|jKd d|dddddd f}tM||||j d|j2dz}d|i}|rdtO||| dz |d<|Scc} } }wcc}} }wcc}wcc}} }wcc}wcc}} }wcc}w)zClassification loss (Binary focal loss) targets dicts must contain the key "labels" containing a tensor of dim [nb_target_boxes] pred_logitsrXr0 pred_boxesboxesrdimrg{Gz?r]r1Tg:0yE>)rrN)r^layoutrQloss_ced class_error)(_get_src_permutation_idxr-catziprIrDdiagr box_ioubox_cxcywh_to_xyxydetachcloner zeros_likeappendtupler)rdtor^r logsigmoidrrHzerosshaper@rQviewamaxr.rGr+fullint64rmscatter_ unsqueezer#r ) rLrSrindicesrlog src_logitsidxr[_Jtarget_classes_orr src_boxesi target_boxes iou_targetspos_iousr pos_weights neg_weightsidpos_indrn pos_ious_funccls_iou_func_targetsnorm_cls_iou_func_targetscls_iou_targetstarget_classestarget_classes_onehotrCs r" loss_labelszSetCriterion.loss_labelss''']+ ++G4 99c'SZF[%\%\FQak!n%\]   $$EE -c2I 99SRYEZ%[%[ 6Aqajm%[abcL**..y/?/?/AB..|<K #((*113H%%'D**:6K+K$'(br(G( NN+ ,U7^$((/(,,q5y2IIA At$++-A*+$${/@/@*AKg '*+add;3D3D.E*EKg '"J.j1I[[fMf1ggGkkmi/G  . . -c2I 99SRYEZ%[%[ 6Aqajm%[abcL**..y/?/?/AB..|<K #((*113H$M#(;;!!!$j&6&6q&94;K;KL &&!(($ %((br(G( NN+ ,),,-A-G-GHM3@ w 0(<$))*>*D*DQ*GQOTTUVX\]`dd) %)-** ""1%&  $ $ -c2I 99SRYEZ%[%[ 6Aqajm%[abcL**..y/?/?/AB..|<K #((*113H#kk!!!$j&6&6q&94;K;KL &&!((O %((br(G( NN+ ,.6OE'N +&#** ""1%& #ZZ  !$  kk!(( N #3N3 $)KK!!!$j&6&6q&9:;K;KA;NQR;RS &&!((!(( % ! " * *1n.F.Fr.JA N$9!Q)$D !")** ""1%& W% $'(:c?DT*UVW*X$XF= ! O&] &\)&\$)(&\ )s)[ [$ ( [+[0 [7'[<  \c f|d}|j}tj|Dcgc]}t|dc}|}|j d|j ddz k7j d} tj| j|j} d| i} | Scc}w)zCompute 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 rhrXrQr1rcardinality_error) rQr-rarYargmaxrrrl1_lossr') rLrSrrrrhrQv tgt_lengths card_predcard_errrCs r"loss_cardinalityzSetCriterion.loss_cardinalitysm, ##oo&IAs1X;'7&IRXY  ''+{/@/@/Dq/HHMMaP 99Y__. 0A0A0CD%x0 'JsB.c d|vsJ|j|}|d|}tjt||D cgc]\}\}} |d| c} }}d} t j || d} i} | j |z | d<dtjtjtj|tj| z } | j |z | d <| Scc} }}w) 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.rirjrrkrr loss_bboxr loss_giou) rqr-rrrsrrrrtr generalized_box_iourv)rLrSrrrrrr[rrrrrCrs r" loss_boxeszSetCriterion.loss_boxessw&&&++G4L)#. yyWgAV!W!WIAv1!G*Q-!W]^_ IIiH 'mmo 9{  ' '**95**<8   (mmo 9{ "XsC9 c vd|vsJd|j|}|d}t|tjr||}nD|dd}|dd} |dd} |dj dk(r$|j } tj g| }ng} |djd d } tjtj| d d | fd jd}t| jdD]j}|d||||d z}|d ||||d z}| ||f}||d||d zd z }tjd ||| z}| j|ltj| }|j dk(r!|j|jdStjt!||Dcgc]\}\}}|d|c}}}d }|j#d }|j#d j%}t'|jd|jd|jdz|j(z}tj*5t-|d|dd}d d d t/|dj1d }tj*5t/||ddj1d }d d d t%|}t3||t5|||d}~~|Scc}}}w#1swYxYw#1swYFxYw)zCompute 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 outputsspatial_featuresquery_featuresbiasrrT) return_countsrNrkz chw,nc->nhw) loss_mask_celoss_mask_dicemasksr1ct|SN)r)logitss r"z)SetCriterion.loss_masks..s 4V<r$g?F) align_cornersnearest)rmode)rq isinstancer-TensornumelrQtensoruniquerrrycumsumrangereinsumrzrrsrr'maxrJno_gradrr squeezesigmoid_ce_loss_jit dice_loss_jit)rLrSrrrrr src_masksrrrrQbatched_selected_masksper_batch_counts batch_indicesrbatch_indicator box_indicatorthis_batch_queriesthis_batch_spatial_featuresthis_batch_masksr[rj target_masks num_points point_coords point_logits point_labelsnum_boxes_scalarrCs r" loss_maskszSetCriterion.loss_maskss w&M(MM&++G4\* j%,, /#3I&|45GH $\23CDN<(0D1v||~")00!LLF; )+&#&q6==t=#DQ#G % 5+;+;R$SM)7-8X)Y&2B3q6-XY\]X]J^abJbCc2d/ )7.  %+112BC!D$"II&<= ??  ! ) "+--/  yyWgAV!W!WIAv1!G*Q-!W]^_ ''* #--a0668  OOB  OOB )//""5 59U9U U ]]_ E< L $    '!*  ]]_ '#  gaj  "!+/ lL\]+L,HXY    k"X     sL L# L/#L,/L8c td|vsJ|j|}|d|}tjt||D cgc]\}\}} |d| c} }}d} tjt||D cgc]\}\}} |d| c} }}d} tjt||D cgc]\}\}} |d| c} }}d} | dddf| ddd fz} t || j |j | j |j | j |j |j \}}}}|j|z |j|z |j|z |j|z d Scc} }}wcc} }}wcc} }}w) z;Compute keypoint losses on matched prediction/target pairs.pred_keypoints keypointsrrkrXrjNr0r)all_pred_keypointstarget_keypointsr target_areasrK)loss_keypoints_l1loss_keypoints_findableloss_keypoints_visibleloss_keypoints_nll) rqr-rrrsrr|rQrKr)rLrSrrrr src_keypointstargetrrrrrrloss_l1 loss_findable loss_visibleloss_nlls r"loss_keypointszSetCriterion.loss_keypoints%s 7***++G4 01#6  99SVW^`gSh%i%i!Qf[&9!&<%iopqcRY[bNc#d#dNFFQF8$4Q$7#djklyy3wX_K`!a!a!Q&/!"4!aghi #AqD)LA,>> 9Q,-001E1EF),,]-A-AB%)=)=>$($@$@ : 6 h")!:'4'8'8':Y'F&2&6&6&89&D"*,,.9"<   &j#d!asF% >F, =F3 c tjt|Dcgc]\}\}}tj|| c}}}}tj|Dcgc]\}}| c}}}||fScc}}}wcc}}wrr-rr enumerate full_like)rLrrsrcr batch_idxsrc_idxs r"rqz%SetCriterion._get_src_permutation_idxDshII)T[J\]];1hsAusA6]^ ))9Xc1S9:'!!^9 #A7  A> c tjt|Dcgc]\}\}}tj|| c}}}}tj|Dcgc]\}}| c}}}||fScc}}}wcc}}wrr)rLrrrtgtrtgt_idxs r"_get_tgt_permutation_idxz%SetCriterion._get_tgt_permutation_idxJshII)T[J\]];1hq#usA6]^ ))9XaS9:'!!^9rc |j|j|j|j|jd}||vs Jd|d||||||fi|S)N)rX cardinalityrjrrzdo you really want to compute z loss?)rrrrr)rLr rSrrrkwargsloss_maps r"get_losszSetCriterion.get_lossPsm&&00____,,  xN#A$v!NNx~gwMfMMr$c |jr |jnd}|jDcic]\}}|dk7s ||}}}|j|||}||j ||}n{t j |s6t j|t j|j|}n0|j|j|t j}i} |jD]&} | j|j| ||||(d|vrt|dD]\} } |j| ||}|jD]^} i} | dk(rddi} |j| | |||fi| }|jDcic]\}}|d | z|}}}| j|`d |vr|d }|j|||}|jD]\} i} | dk(rd| d<|j| ||||fi| }|jDcic] \}}|d z| }}}| j|^| Scc}}wcc}}wcc}}w) u Compute every configured loss for one (outputs, targets) pair. The Hungarian matcher is invoked on the last layer's outputs and reused for the auxiliary intermediate layers and the optional encoder outputs; each loss is then evaluated on the 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). - ``torch.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 ``"_"`` 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 aux_outputs)rEr])rQr^rXrFr enc_outputs_enc)r`rEitemsrArfr-rPrar'rUr|rCupdaterr)rLrSrrrEkroutputs_without_auxrrCr rrrl_dictrs r"forwardzSetCriterion.forward[smp)- T__1 07 V11 CUq!tVV,,2G ,S  227GDI+ TM`M`ahMijI! D,?,?,HPUP[P[ \IKK UD MM$--gwS T U G #"+GM,B"C *;,,{G ,S KK*DFx'"'*T]]4gwPYd]cdF9?HAaAaS'k1nHFHMM&)* * G #!-0Kll;JlOG  &8#$)F5M&t['7I`Y_`4:LLNCDAq!f*a-CC f% & UW6IDs III I)rFFFFN)rJintrKzlist[int] | None)rSdict[str, Any]returnz torch.device)rSr rlist[dict[str, torch.Tensor]]r  torch.Tensor)T) rSdictrlistrrrr'r dict[str, torch.Tensor]r)rSr rr rztorch.Tensor | float | Noner r)__name__ __module__ __qualname____doc__r<__annotations__r? staticmethodrUrfrr-rrrrrrqrrr __classcell__)rMs@r"r:r:s./3%t2 %*')48%E"%%E"2%ENgg$4I4I/4I  4IlN`U]]_  .iV       !  >" " N26 cc/c/ c ! cr$r:)g?r0)rr'rr')rr rr r3r')"r __future__rtypingrr-torch.nn.functionalr functionalrrfdetr.models.heads.keypointsr rfdetr.models.heads.segmentationrrr rfdetr.models.mathr rfdetr.utilitiesr rfdetr.utilities.distributedr r r#r+r.r6jitscriptrr8rModuler:r$r"r%s9" B ($V*<* *" " "",   + * * ***ii&&7y299yr$