/jddlmZddlZddlmZddlZddlmZddlmcm Z ddl m Z m Z ddlmZmZmZddlmZmZmZmZmZddlmZdd lmZmZdd lmZmZGd d ej Z!Gd dej Z"Gddej Z#Gddej Z$Gddej Z%Gdde$Z&Gddej Z'Gddej Z(Gddej Z)GddZ*Gdd e*Z+Gd!d"e*Z,Gd#d$e,Z-Gd%d&Z.Gd'd(e*Z/Gd)d*Z0Gd+d,Z1Gd-d.Z2Gd/d0e2Z3dS)1) annotationsN)Any) OKS_SIGMA RLE_WEIGHT) crop_mask xywh2xyxy xyxy2xywh)RotatedTaskAlignedAssignerTaskAlignedAssigner dist2bbox dist2rbox make_anchors)autocast)bbox_iouprobiou) bbox2dist rbox2distc.eZdZdZddfd Zdd ZxZS) VarifocalLossaVarifocal 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 @?gammafloatalphacdt||_||_dS)zJInitialize the VarifocalLoss class with focusing and balancing parameters.N)super__init__rrselfrr __class__s [/home/longshao/multi-rider-rag/.venv/lib/python3.11/site-packages/ultralytics/utils/loss.pyrzVarifocalLoss.__init__#s+   pred_score torch.Tensorgt_scorelabelreturnc|j||jzd|z z||zz}t d5t j||d|zd }dddn #1swxYwY|S)zs@r"r@r@5s`))))))) """"""""r#r@c.eZdZdZd d fd Zdd ZxZS)DFLosszs@r"rSrSXs\FF ! ! ! ! ! ! ! !r#rSc.eZdZdZddfd ZddZxZS)BboxLosszACriterion class for computing training losses for bounding boxes.rTrUrVct|dkrt|nd|_dS)zLInitialize the BboxLoss module with regularization maximum and DFL settings.rN)rrrSdfl_lossrYs r"rzBboxLoss.__init__ps6 +2Q;;wD r#rZr% pred_bboxes anchor_points target_bboxes target_scorestarget_scores_sumfg_maskimgszstrider(!tuple[torch.Tensor, torch.Tensor]c |d|d} t||||dd} d| z | z|z } |jryt |||jjdz } |||d|jj| || z}||z }nt ||} | | z} | ddd d fxx|dzcc<| ddd d fxx|dzcc<|| z}|ddd d fxx|dzcc<|ddd d fxx|dzcc<tj||| |d  dd | z}||z }| |fS)z.Compute IoU and DFL losses for bounding boxes.r]FT)xywhCIoUrHr.rNr+r,r^) r3 unsqueezerrnrrUrcr0l1_lossr2r rZrorprqrrrsrtrurvr4iouloss_iou target_ltrbloss_dfls r"r6zBboxLoss.forwardus ""2&&w/99"=={7+]7-C%VZ[[[3Y&(--//2CC = :#M=$-BWZ[B[\\K}}Yw%7%<%s@r"rlrlmscKKAAAAAAA $"$"$"$"$"$"$"$"r#rlc2eZdZdZddfd Z dddZxZS)RLELossaResidual 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 Tuse_target_weightbool size_averageresidualcrt||_||_||_dS)aGInitialize 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)rrrrr)r rrrr!s r"rzRLELoss.__init__s6 (!2  r#Nsigmar%log_phierror target_weightr(ctj|}||dz }|jr/|tj|dztj|zz }|jr>| Jd|dkr|d}||z}|jr|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). rr{NzD'target_weight' should not be None when 'use_target_weight' is True.) rDlogr|rabsrdimrlenr3)r rrrr log_sigmar5s r"r6zRLELoss.forwardsIe$$ 7,,Q/// = < EIeai((59U+;+;; ;D  ! " ,,.t,,,  ""a'' - 7 7 : : M !D    CII Dxxzzr#)TTT)rrrrrr)N) rr%rr%rr%rr%r(r%r8r>s@r"rrsl   ! ! ! ! ! ! !nrr#rc,eZdZdZdfd ZddZxZS)RotatedBboxLosszICriterion class for computing training losses for rotated bounding boxes.rUrVcJt|dS)zSInitialize the RotatedBboxLoss module with regularization maximum and DFL settings.N)rrrYs r"rzRotatedBboxLoss.__init__s! !!!!!r#rZr%rorprqrrrsrtrurvr(rwc |d|d} t||||} d| z | z|z } |jrt |dddf||dddf|jjdz } |||d|jj| || z}||z }nt |dddf||dddf} | | z} | dd dd fxx|dzcc<| dddd fxx|d zcc<|| z}|dd dd fxx|dzcc<|dddd fxx|d zcc<tj||| |d  dd | z}||z }| |fS)z6Compute IoU and DFL losses for rotated bounding boxes.r]rH.Nr)rUrr{r+r,Tr^) r3r|rrnrrUrcr0r}r2r~s r"r6zRotatedBboxLoss.forwardsN""2&&w/99"==k'*M',BCC3Y&(--//2CC = :#c2A2g& }S!A#X7NX\XeXmpqXqK}}Yw%7%<%s@r"rrsWSS""""""%"%"%"%"%"%"%"%"r#rc.eZdZdZddfd Zdd ZxZS)MultiChannelDiceLossz8Criterion class for computing multi-channel Dice losses.ư>r2smoothrr-strcdt||_||_dS)zInitialize 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)rrrr-)r rr-r!s r"rzMultiChannelDiceLoss.__init__s-  "r#rFr%r[r(c||ks Jd|}||zd}|d|dz}d|z|jz||jzz }d|z }|d}|jdkr|S|jdkr|S|S) zBCalculate multi-channel Dice loss between predictions and targets.z-the size of predict and target must be equal.)r{rrrHrr2r3)sizer.r3rr2r-)r rFr[ intersectionuniondice dice_losss r"r6zMultiChannelDiceLoss.forwardsyy{{fkkmm+++-\+++||~~v **v*66 V$$vzzfz'='==l"T[0UT[5HI$J NNqN)) >V # #>>## # ^u $ $==?? " r#)rr2)rrr-rrFr%r[r%r(r%r8r>s@r"rrs\BB # # # # # # #r#rc.eZdZdZd d fd Zdd ZxZS) BCEDiceLossz;Criterion class for computing combined BCE and Dice losses.? weight_bcer weight_dicect||_||_t j|_td|_dS)zInitialize 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)rN) rrrrnnBCEWithLogitsLossbcerr)r rrr!s r"rzBCEDiceLoss.__init__%sP $&'))(222 r#rFr%r[r(c |j\}}}}t|jdd||fkrtj|||fd}|j|||z|j|||zzS)zECalculate combined BCE and Dice loss between predictions and targets.Nnearest)mode)rdtupler0 interpolaterrrr)r rFr[_mask_hmask_ws r"r6zBCEDiceLoss.forward2s#z1ff bcc" # #'7 7 7]6FF+;)LLLF$!7!77$:JTYYW[]cMdMd:dddr#)rr)rrrrrr8r>s@r"rr"sdEE 3 3 3 3 3 3 3eeeeeeeer#rc,eZdZdZd fd Zd d ZxZS) KeypointLossz.Criterion class for computing keypoint losses.sigmasr%r(rWcVt||_dS)z7Initialize the KeypointLoss class with keypoint sigmas.N)rrr)r rr!s r"rzKeypointLoss.__init__=s$  r# pred_kptsgt_kptskpt_maskareac|d|dz d|d|dz dz}|jdtj|dkddzz }|d|jzd|dzzdzz }|dddtj| z |zzS) zICalculate keypoint loss factor and Euclidean distance loss for keypoints..rr{.rrrr& .>r])r/rdrDr3rrcexpr2)r rrrrdkpt_loss_factores r"r6zKeypointLoss.forwardBsv  0 5 5a 8 8If$$R++EIqbMM0AX/MNTTVVVr#)rr%r(rW) rr%rr%rr%rr%r(r%r8r>s@r"rr:s_88 WWWWWWWWr#rcLeZdZdZdddZddZd dZd!dZd"dZd#dZ d$dZ dS)%v8DetectionLosszJCriterion class for computing training losses for YOLOv8 object detection. Ntal_topkrV tal_topk2 int | Noneczt|j}|j}|jd}t jd|_||_|j |_ |j |_ |j |j dzz|_ |j |_ ||_|j dk|_ t||j dd|j ||_t#|j ||_t)j|j t(j| |_d S) zVInitialize v8DetectionLoss with model parameters and task-aligned assignment settings.r]r+r,rrr@topk num_classesrbetarvtopk2rKrJN)next parametersrJargsmodelrrrhyprvncrUnouse_dflr tolistassignerrlrM bbox_lossrDarangerproj)r rrrrJhms r"rzv8DetectionLoss.__init__Pse&&(())0 J KO'&999h $$Q&y  y1} +;%%''     "!),,//77L%+fMMM r#targetsr% batch_size scale_tensorr(c$|j\}}|dkr"tj|d|dz |j}n]|dddf}|d\}} | tj} tj|| |dz |j}tj|dztj|j} | d|dztj || d} tj ||j| |z } |ddddf||| f<t|d dd f||d dd f<|S) zJPreprocess targets by converting to tensor format and scaling coordinates.rrrJNT return_countsrKr.r)rdrDzerosrJrauniquerMint32max scatter_add_ ones_likecumsumrrmul_) r rrrnlneout batch_idxrcountsoffsets within_idxs r" preprocesszv8DetectionLoss.preprocesskstB 77+j!R!VDKHHHCC1 **,,I!((t(<>>>r#predsdict[str, torch.Tensor]batchdict[str, Any]rc tjd|j}|dddd|dddd}}t |d|jd \}}|j}|jd} tj |ddjdd |j| |jdz} tj |d  d d|d d d|dfd} | | |j| | gd} | dd\} } | ddd}|||}||||z| j||z| | |\}}}}}t-|d}||| ||z |d<|r)||||||z |||| | \|d<|d<|dxx|jjzcc<|dxx|jjzcc<|dxx|jjzcc<|||||f||fS)zCalculate the sum of the loss for box, cls and dfl multiplied by batch size and return foreground mask and target indices. rrboxesrr{rscoresfeatsrNrIrr]clsbboxesrrrrr)rrTr^)rDrrJpermute contiguousrrvrKrdrEcatrcrrMsplitr3gt_r rdetachr.rrrrrboxrdfl)r r r r5 pred_distri pred_scoresrp stride_tensorrKrrur gt_labels gt_bboxesmask_gtrorrqrrrt target_gt_idxrss r"get_assigned_targets_and_lossz-v8DetectionLoss.get_assigned_targets_and_losss;{1T[111 'N " "1a + + 6 6 8 8 (O # #Aq! , , 7 7 9 9! (4E'NDKQT'U'U$ }! &q)  U7^A.4QRR8TYZZZ]a]hij]kk)U;/44R;;U5\=N=NrST=U=UW\]eWfgijkk//'**T["9"9:TYZfZfZfTg/hh&}}VQ77 9--4-0044S99&&}kBB BF--    ( ( * *    ! !M 1 7 7  H H M )    C C ?=-- 1 1 3 3Q77((; (8(8(?(?@@DDFFIZZQ ;;== #~~ -!   DGT!W Q48< Q48< Q48< m]M= Q  KKMM  r#Fdict[str, torch.Tensor] | tuple[torch.Tensor, dict[str, torch.Tensor]]c@t|tr|dn|S),Parse model predictions to extract features.r) isinstancerr r s r" parse_outputzv8DetectionLoss.parse_outputs!&eU33>uQxx>r#rwcT||||S)LCalculate the sum of the loss for box, cls and dfl multiplied by batch size.r5r,r r r s r"rizv8DetectionLoss.__call__s& yy**5115999r#cx|djd}|||dd\}}||z|fS)z0Calculate detection loss using assigned targets.rrrN)rdr&)r r r rr5 loss_detachs r"r5zv8DetectionLoss.losssF7^)!,  >>ueLLQRRPkj +--r#rNrrVrrrr%rrVrr%r(r%)rpr%rZr%r(r%)r r r r r(r)r r'r(r%)r r'r r r(rwr r r r r(rw) r9r:r;r<rrr r&r,rir5r#r"rrMsTTNNNNN6$????; ; ; ; z???? ::::......r#rcNeZdZdZddfd Zd dZed!dZd"dZxZ S)#v8SegmentationLosszFCriterion class for computing training losses for YOLOv8 segmentation.rNrrVrrct||||jj|_t dd|_dS)zWInitialize the v8SegmentationLoss class with model parameters and mask overlap setting.r)rrN)rrr overlap_maskoverlapr bcedice_lossr rrrr!s r"rzv8SegmentationLoss.__init__sF )444z. '3CHHHr#r r r r(rwc |dddd|d}}tjd|j}t |t rt|dkr|\}}nd}|||\\}}} } } } } | d| d| dc|d<|d<|d <|j \} } } }| rN|d  |j }t |j d d| |fkr%tj||j d dd d }tj|ddj dd|j|j|jdz}||||| |ddd||||d<|P|d |j}tj||jdd dd }|jr2|dk}d||d|<no|dd}t5| D]D}|||k}t|dkr"d||dd| ddkf<E||||d<|dxx|jjzcc<nd|dxx|dz |dz zz cc<|%|dxx|dz z cc<|dxx|jjzcc<|| z|fS)zFCalculate and return the combined loss for detection and segmentation.mask_coefficientrr{rprotorrNrmasksrbilinearF)r align_cornersrrIrr] sem_masks)rrr)rrrDrrJr*rrr&rdr3rMrr0rrErKrvcalculate_segmentation_lossrcone_hotrarr<r| expand_asranger=rrr)r r r  pred_masksrAr5 pred_semsegrtr%rqrdet_lossrrrrBrurE mask_zeroriinstance_mask_is r"r5zv8SegmentationLoss.losss!"45==aAFFQQSSUZ[bUcE {1T[111 eU # # E a!& E;;KEIEgEghmotEuEuB5-1x$,QK!hqk!Qa$q'(- % Avv ;;==* 3'N%%dk2288::EU[%&&66*::: eU[-=J^cddd U7^A.4QRR8T^Tdeeehlhstuhvv 66k"''A..  DG&!+.11$+>> Iinn&6&6DGLLLTTUVXY[\^_``ffhh < M % IMNIi11!44>>yIIJJ %k 2 7 7 ; ;I":..MM*/ Q*?//144$KL !QQQ(;(;(;(B(Ba(G"GHH++KCCQQ48<' GGG ((JN+?+?+A+AA AGGG&QK!O00222 Q48<j $++--//r#gt_maskr%rFrAxyxyrctjd||}tj||d}t ||d|z S)aOCompute 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+r,)rr{r)rDeinsumr0r1rr2r3)rPrFrArQr pred_maskr5s r"single_mask_lossz#v8SegmentationLoss.single_mask_losssa(Le<< 1)WPVWWW$%%**v*66=BBDDDr#rtrBr%rqrrJruc |j\} } } } d} ||gdz } t| dddfd}| tj| | | | g|jz}t t|||||||D]\}}|\}}}}}}}|r||}|j r3||dz dddk}| }n%|| d|k|}| | ||||||||z } | |dz |dz zz } | | z S) aCalculate 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 of shape (BS, H, W) if `overlap` is False, otherwise (BS, ?, 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) rr.r{Nrrr])rdr prodrDrErJ enumerateziprLr<rcrrUr3)r rtrBr%rqrrArJrurrrr5target_bboxes_normalizedmareamxyxyrNsingle_i fg_mask_itarget_gt_idx_i pred_masks_iproto_imxyxy_imarea_imasks_imask_idxrPs r"rFz.v8SegmentationLoss.calculate_segmentation_loss5s> %{1ff$153F#F 233CG<AA!DD)5<QW8Xafam+n+n+nn$S-UTY[`bg%h%hii C CKAx[c XI gwQX}} C*95<G%(Q,)<)s@r"r9r9sPPIIIIIII :0:0:0:0xEEE\E.=$=$=$=$=$=$=$=$r#r9cVeZdZdZddfd Zdd ZeddZddZddZ xZ S) v8PoseLosszICriterion class for computing training losses for YOLOv8 pose estimation.rrrVrct||||jdj|_t j|_|jddgk}|jd}|r1tjt |j ntj ||j |z }t||_dS)zQInitialize v8PoseLoss with model parameters and keypoint-specific loss functions.r]rrr)rN)rrr kpt_shaperrbce_poserD from_numpyrrMrJonesr keypoint_loss)r rrris_posenkptrr!s r"rzv8PoseLoss.__init__xs )444R2,.. .RG+~a @Gx!),,// <<>>qAEEGG"K 9?1#5yq7I JS\Sc    #))+j1nEJyGWXXXQ 2EON4S4STTT..##\#i..9IJJJWUcMdd 8A.*45"/!8!8!>q$>OOD 'H.4l2.>!.C.Cvf~**Y_`fYgimInInH**8VXtLLI~b!Q&& $ hv.>@P@P Q Q -''r#)rr)rrVrrVr6rpr%rr%r(r%) rur%rr%r%r%rBr%r(r%)rBr%r%r%rur%rr%r!r%rqr%rr%r(rw) r9r:r;r<rr5rfrvrrxr=r>s@r"rhrhusSS9999999#0#0#0#0J\-"-"-"-"^1(1(1(1(1(1(1(1(r#rhcVeZdZdZdd fd Zd!dZed"dZd#dZd$dZ xZ S)% PoseLoss26z_Criterion class for computing training losses for YOLOv8 pose estimation with RLE loss support.rNrrVrrc t||||jddgk}|jd}d|_t |jddr|jdjnd|_|jtd|j |_|r1tj t|j ntj ||j |_dSdS) zdInitialize PoseLoss26 with model parameters and keypoint-specific loss functions including RLE loss.rjrrNr] flow_modelT)rr)rrrkrle_losshasattrrrrrMrJrDrmrrntarget_weights)r rrrrprqr!s r"rzPoseLoss26.__init__s )444.RG+~a  8? BQ]8^8^h%+b/44dh ? &#d;;;>>t{KKDM@Gq ,,// <<>  ;;== ,k*--dk::@@BBHHJJI f   q )    f   q )   !::k"''A..N%Q'DG$Q'DG}((+Q Q48=  Q48=  = $ GGGtx| #GGGj $++--//r#rpr%rc|}|dxx|dddgfz cc<|dxx|dddgfz cc<|S)r|rNrrrr}r~s r"rvzPoseLoss26.kpts_decodeVsb OO   & ]111qc6**  & ]111qc6** r#rrrc||}||}|ddddf}|ddddf}|ddddf}|jd|jdd} | |} |}||z |dzz } t j| t j| zd} | st j d |j S| | } | d d } || }| | } |j | } ||| | | S) aCalculate 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. Nrr{rrrr]rrrid)rr|repeatrdr.rDisnanisinfrLrErJclamprlog_probr) r rrrpred_kpt_visiblegt_kpt_visible pred_coordsr gt_coordsrr valid_maskrs r"calculate_rle_losszPoseLoss26.calculate_rle_loss^st$H-)&qqq!A#v. %aaaf- "111ac6* ,66q99@@PQARTUVV'1'')) y(Z$->?{5))EK,>,>>CCCKKK ~~ =<HO<<< <j! D#&& + ' 3/**511}}Z%HHHr#rBr%rurr!rq/tuple[torch.Tensor, torch.Tensor, torch.Tensor]c H|||||}|dddfxx|ddddzcc<d} d} d} |rA||z}||} t||ddddfdd} ||}| jdd kr | d dknt j| d d}||| || } |j O|jdd ks|jdd kr-| || |} | d} |jdd ks|jdd kr.| |d | } | | | fS)aGCalculate 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. .Nr{rr]rTr^rrrrr)min)rrcrLr rWrdrDrrorrrrlr)r rBr%rurr!rqrrrrrrrrrs r"rxz#PoseLoss26.calculate_keypoints_losss>"::9iQ^`eff 37###}'9'9!RA'F'FF###   99;; R ] *M'.F]5122111abb59>>q$>OOD 'H.4l2.>!.C.Cvf~**Y_`fYgimInInH**8VXtLLI}(hnR.@A.E.EXZI[_`I`I`228VXNN#>>a>00~b!Q&&(.*<*A*A $ hv.>@P@P Q Q -11r#r3r4r6r)rr%rr%rr%r(r%)rBr%r%r%rur%rr%r!r%rqr%rr%r(r) r9r:r;r<rr5rfrvrrxr=r>s@r"rrsii       10101010f\#I#I#I#IJ6262626262626262r#rceZdZdZd dZd S) v8ClassificationLosszACriterion class for computing training losses for classification.r rr r r(rwct|ttfr|dn|}tj||dd}||fS)zDCompute the classification loss between predictions and true labels.rrr2r,)r*listrr0rbr)r r r r5s r"rizv8ClassificationLoss.__call__sO&utUm<<Ga%ueElfEEET[[]]""r#Nr rr r r(rw)r9r:r;r<rir7r#r"rrs.KK######r#rcFeZdZdZddfd Zdd ZddZddZddZxZ S) v8OBBLosszdCalculates losses for object detection, classification, and box distribution in rotated YOLO models.rNrrct||t||jdd|j||_t|j |j |_ dS)z^Initialize v8OBBLoss with model, assigner, and rotated bbox loss; model must be de-paralleled.rrrrN) rrr rrvrrrrUrMrJrr>s r"rzv8OBBLoss.__init__s 2222;%%''     )6699$+FFr#rr%rrVrr(c8|jddkrtj|dd|j}ni|dddf}|d\}}|tj}tj||d|j}|ddddf }|dddd f |tj|dztj|j } | d|dztj || d} tjt||j| |z } |||| f<|S) z7Preprocess targets for oriented bounding box detection.rrrNTrrrrr)rdrDrrJrarrMrrrwrrrrrr) r rrrrrrrpacked_targetsrrs r"rzv8OBBLoss.preprocessst = q +j!Qt{CCCCC1 **,,I!((t(<!j $++--//s D:I I:%I55I:rprZrc0|jri|j\}}}|||d|dzd|j|j}tj t||||fdS)aDecode 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). rrr]r) rrdrcrrrrrKrDrr )r rprZrrrrs r"r zv8OBBLoss.bbox_decode9s < koGAq!!q!QQ77??BBII$)..YbYhJiJijjIy)Iz=II:V\^____r#rc|d}|d}|d} |d} tj|dz|dzz } tj| dz |dzz } | | z } | tj| tjz tjzz }tjd||zdz}| ||z}||z}||z S)aCalculate 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).rrr{)rDrrroundmathpisinr3)r rorqrtr4rs lambda_valw_gth_gt pred_theta target_thetalog_ar scale_weight delta_thetadelta_theta_wrappedang_losss r"rzv8OBBLoss.calculate_angle_lossKsV$V$ ( $V, D4KD4K899y619Q!?@@  </ )EK dg8M,N,NQUQX,XX9Q!4W!==>>!C(83f$||~~ 111r#r3rrr5r6)rpr%rZr%rr%r(r%)r) r9r:r;r<rrr5r rr=r>s@r"rrsnn G G G G G G G$O0O0O0O0b````$22222222r#rc eZdZdZdZd d Zd S) E2EDetectLossGCriterion class for computing training losses for end-to-end detection.c^t|d|_t|d|_dS)zcInitialize E2EDetectLoss with one-to-many and one-to-one detection losses using the provided model.rrrN)rone2manyone2one)r rs r"rzE2EDetectLoss.__init__ns.';;; &uq999 r#r rr r r(rwct|tr|dn|}|d}|||}|d}|||}|d|dz|d|dzfS)r.rrrr)r*rrr)r r r r loss_one2manyr loss_one2ones r"rizE2EDetectLoss.__call__ss&ue44?a%$ h66  "||GU33 Q,q/1=3ClSTo3UUUr#Nr)r9r:r;r<rrir7r#r"rrksCQQ::: VVVVVVr#rc4eZdZdZefdZdd Zdd Zdd ZdS)E2ELossrc||d|_||dd|_d|_d|_d|_|j|jz |_|j|_d |_d S) z]Initialize E2ELoss with one-to-many and one-to-one detection losses using the provided model.rrr)rrrrHg?g?N)rrupdatestotalo2mo2oo2m_copy final_o2m)r rloss_fns r"rzE2ELoss.__init__si333 wuqA>>>   :( r#r rr r r(rwc|j|}|d|d}}|j||}|j||}|d|jz|d|jzz|dfS)r.rrrr)rr,r5rrr)r r r rrrrs r"rizE2ELoss.__call__s **511!*-uY/?' **8U;; |((%88 Q$(*\!_tx-GGVWXXr#rWc|xjdz c_||j|_t|j|jz d|_dS)zUUpdate the weights for one-to-many and one-to-one losses based on the decay schedule.rrN)rdecayrrrr)r s r"updatezE2ELoss.updatesE  ::dl++tzDH,a00r#rctd|t|jjjdz dz z d|j|jz z|jzS)zSCalculate the decayed weight for one-to-many loss based on the current update step.rr)rrrepochsrr)r xs r"rz E2ELoss.decaysL1q3t|/6:A>>>>BBdmVZVdFdehlhvvvr#Nr)r(rW)r(r) r9r:r;r<rrrirrr7r#r"rr}swQQ&5    YYYY1111 wwwwwwr#rc<eZdZdZdddZdd ZddZddZddZdS) TVPDetectLosszOCriterion class for computing training losses for text-visual prompt detection.rNrrct||||_|jj|_|jj|_|jj|_|jj|_dS)z^Initialize TVPDetectLoss with task-prompt and visual-prompt criteria using the provided model.N) r vp_criterionrrori_ncrori_norU ori_reg_max)r rrrs r"rzTVPDetectLoss.__init__sQ+E8YGG$('* '* ,4r#r(r c6|j|S)r))rr,r+s r"r,zTVPDetectLoss.parse_outputs --e444r#r rr rwcT||||S)4Calculate the loss for text-visual prompt detection.r/r0s r"rizTVPDetectLoss.__call__$yy**5115999r#c4|j|djdkr7tjd|jjd}||fS|||d<|||}|dd}||dfS)rrrrTrJ requires_gradrrrdrDrrrJr_get_vp_features)r r r r5vp_lossbox_losss r"r5zTVPDetectLoss.loss ;%//2 2 2;q):)AQUVVVD& &//66h##E5111:a=##r#list[torch.Tensor]c|d}|jd}||j_||jjdzz|j_||jj_|S)z5Extract visual-prompt features from the model output.rrr)rdrrrUrrr)r r rvncs r"rzTVPDetectLoss._get_vp_featuressOxl1o""T%6%>%BB14". r#r3r)r(r rr6)r r r(r) r9r:r;r<rr,rir5rr7r#r"rrsYY555555555:::: $ $ $ $r#rc4eZdZdZd fd Zd d Zd d ZxZS)TVPSegmentLosszRCriterion class for computing training losses for text-visual prompt segmentation.rct|t|||_|jj|_dS)z_Initialize TVPSegmentLoss with task-prompt and visual-prompt criteria using the provided model.N)rrr9rr)r rrr!s r"rzTVPSegmentLoss.__init__s> .uh??$(r#r rr r r(rwcT||||S)7Calculate the loss for text-visual prompt segmentation.r/r0s r"rizTVPSegmentLoss.__call__rr#c4|j|djdkr7tjd|jjd}||fS|||d<|||}|dd}||dfS)r rrrTrrr{r)r r r r5rcls_losss r"r5zTVPSegmentLoss.lossrr#)rr)r9r:r;r<rrir5r=r>s@r"rrsk\\)))))) :::: $ $ $ $ $ $ $ $r#r)4 __future__rrtypingrrDtorch.nnrtorch.nn.functional functionalr0ultralytics.utils.metricsrrultralytics.utils.opsrrr ultralytics.utils.talr r r r rultralytics.utils.torch_utilsrmetricsrrtalrrModulerr@rSrlrrrrrrr9rhrrrrrrrr7r#r"rs#"""""  ;;;;;;;;AAAAAAAAAAuuuuuuuuuuuuuu222222&&&&&&&&%%%%%%%%BI@ " " " " " " " "F!!!!!RY!!!*,",",",","ry,",","^33333bi333l,",",",","h,",","^29Beeeee")eee0WWWWW29WWW&H.H.H.H.H.H.H.H.VZ$Z$Z$Z$Z$Z$Z$Z$z[([([([([([([([(|f2f2f2f2f2f2f2f2R########b2b2b2b2b2b2b2b2JVVVVVVVV$ w w w w w w w wF''''''''T$$$$$]$$$$$r#