Fi]ddlmZddlZddlmZddlZddlmZddlmcm 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/d0e2Z3y)1) annotationsN)Any) OKS_SIGMA RLE_WEIGHT) crop_mask xywh2xyxy xyxy2xywh)RotatedTaskAlignedAssignerTaskAlignedAssigner dist2bbox dist2rbox make_anchors)autocast)bbox_iouprobiou) bbox2dist rbox2distc.eZdZdZddfd ZddZxZS) 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 c>t|||_||_y)zJInitialize the VarifocalLoss class with focusing and balancing parameters.N)super__init__gammaalphaselfrr __class__s X/var/www/pod-logistic/pod-ai/venv/lib/python3.12/site-packages/ultralytics/utils/loss.pyrzVarifocalLoss.__init__#s   cv|j|jj|jzd|z z||zz}t d5t j |j|jd|zjdj}ddd|S#1swYSxYw)zt|||_||_y)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)rrsmoothr%)rrr%rs rrzMultiChannelDiceLoss.__init__s  "r c|j|jk(sJd|j}||zjd}|jd|jdz}d|z|jz||jzz }d|z }|j d}|j dk(r|j S|j dk(r|jS|S) zBCalculate multi-channel Dice loss between predictions and targets.z-the size of predict and target must be equal.)rorr3rDrr+r,)sizer&r,rr+r%)rrJr^ intersectionuniondice dice_losss rr2zMultiChannelDiceLoss.forwardsyy{fkkm+\-\\+||~v **v*6 V$vzzfz'==l"T[[0UT[[5HI$J NNqN) >>V #>># # ^^u $==? " r )gư>r+)rr*r%strrJr5r^r5r6r5r7r=s@rrrsB #r rc.eZdZdZddfd ZddZxZS) BCEDiceLossz;Criterion class for computing combined BCE and Dice losses.ct|||_||_t j |_td|_y)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) rr weight_bce weight_dicennBCEWithLogitsLossbcerr)rrrrs rrzBCEDiceLoss.__init__%s; $&'')(2 r c|j\}}}}t|jdd||fk7rtj|||fd}|j|j ||z|j |j||zzS)zECalculate combined BCE and Dice loss between predictions and targets.Nnearest)mode)r\tupler( interpolaterrrr)rrJr^_mask_hmask_ws rr2zBCEDiceLoss.forward2s#zz1ff bc" #'7 7]]6FF+;)LF$!77$:J:JTYYW[]cMd:dddr )?r)rr*rr*rr7r=s@rrr"sE 3er rc@eZdZdZdfd Z ddZxZS) KeypointLossz.Criterion class for computing keypoint losses.c0t|||_y)z7Initialize the KeypointLoss class with keypoint sigmas.N)rrsigmas)rrrs rrzKeypointLoss.__init__=s  r c|d|dz jd|d|dz jdz}|jdtj|dk7ddzz }|d|jzjd|dzzdzz }|j dddtj | z |zzjS) zICalculate keypoint loss factor and Euclidean distance loss for keypoints..rro.rrrr& .>rU)r'r\rAr,rr[expr+)r pred_kptsgt_kptskpt_maskareadkpt_loss_factores rr2zKeypointLoss.forwardBsv  0 5 5a 8If$$R+EIIqbM0AX/MNTTVVr )rr5r6rg) rr5rr5rr5rr5r6r5r7r=s@rrr:s>8 W%W0<WHTW\hW Wr rc^eZdZdZd d dZd dZd dZddZ ddZ ddZ dd Z y)v8DetectionLosszJCriterion class for computing training losses for YOLOv8 object detection.Nclt|jj}|j}|jd}t j d|_||_|j|_ |j|_ |j|jdzz|_ |j|_ ||_|jdkD|_ t|dd|_|j1|jj!|j#ddd|_t%||jdd |jj'| |_t+|jj!||_t/j0|jt.j2| |_y) zVInitialize v8DetectionLoss with model parameters and task-aligned assignment settings.rUr#r$rr class_weightsNr@topk num_classesrbetarztopk2rGrF)next parametersrFargsmodelrrrhyprzncrRnouse_dflgetattrrrIr[r tolistassignerri bbox_lossrAaranger*proj)rrtal_topk tal_topk2rFhms rrzv8DetectionLoss.__init__PsHe&&()00 JJ KKO''&9hh $$$$Q&yy  yy1} %UOTB    )!%!3!3!6!6v!>!C!CAq"!MD +;;%%'   "!)),//7LL%++fM r c|j\}}|dk(r(tj|d|dz |j}|S|dddfj }|j d\}} | j tj} tj|| j|dz |j}tj|dztj|j} | jd|dztj|| jd} tj||j| |z } |ddddf||| f<t|d dd fj||d dd f<|S) zJPreprocess targets by converting to tensor format and scaling coordinates.rrrFNT return_countsrGr.r)r\rAzerosrFrYuniquerIint32max scatter_add_ ones_likecumsumrrmul_) rtargets batch_size scale_tensornlneout batch_idxrcountsoffsets within_idxs r preprocesszv8DetectionLoss.preprocesspsRB 7++j!R!VDKKHC  1 **,I!((t(>r c Jtjd|j}|djdddj |djdddj }}t |d|j d \}}|j}|jd} tj|ddjdd |j| |j dz} tj|d jd d|djd d|dfd} |j| j|j| | gd} | jdd\} } | jddj!d}|j#||}|j%|j'j)|j'|zj+| j||z| | |\}}}}}t-|jd}|j/||j|}|j0||j0z}|j|z |d<|jr%|j3|||||z |||| | \|d<|d<|dxx|j4j6zcc<|dxx|j4j8zcc<|dxx|j4j:zcc<|||||f||j'fS)zCalculate the sum of the loss for box, cls and dfl multiplied by batch size and return foreground mask and target indices. rrboxesrrorscoresfeatsrNrErrUclsbboxesrrrrr)rrTrV)rArrFpermute contiguousrrzrGr\rBcatr[rrIsplitr,gt_rrdetachr&rrrrrrboxr dfl)rpredsbatchr1 pred_distri pred_scoresrt stride_tensorrGrryr gt_labels gt_bboxesmask_gtrsrrurvrx target_gt_idxrwbce_losss rget_assigned_targets_and_lossz-v8DetectionLoss.get_assigned_targets_and_losss{{1T[[1 'N " "1a + 6 6 8 (O # #Aq! , 7 7 9! (4E'NDKKQT'U$ }!! &&q)  U7^A.44QR8TYZ]a]h]hij]kk))U;/44R;U5\=N=NrST=UW\]eWfgijk//'**T[["9:TYZfTg/h&}}VQ7 9--4-044S9&&}kB BF--    ( ( *    !M 1 7 7  H M )    C ?=-- 1 1 3Q788K)9)9%)@A    ) ** *H,,.#44Q ;;=#~~ -!  DGT!W Q488<< Q488<< Q488<< m]M= Q  KKM  r c0t|tr|dS|S),Parse model predictions to extract features.r) isinstancerrrs r parse_outputzv8DetectionLoss.parse_outputs&eU3uQx>>r cD|j|j||S)LCalculate the sum of the loss for box, cls and dfl multiplied by batch size.r1r&rrrs rrczv8DetectionLoss.__call__s yy**51599r cd|djd}|j||dd\}}||z|fS)z0Calculate detection loss using assigned targets.rrrN)r\r!)rrrrr1 loss_detachs rr1zv8DetectionLoss.losssD7^))!,  >>ueLQRPkj +--r  Nrrfr int | Nonerr5rrfrr5r6r5)rtr5r]r5r6r5)rdict[str, torch.Tensor]rzdict[str, Any]r6r)rFdict[str, torch.Tensor] | tuple[torch.Tensor, dict[str, torch.Tensor]]r6r5)rr3rr2r6rrr2rr2r6r) r8r9r:r;rrrr!r&rcr1r rrrMsWTN@$?> @?[? ? :U:': + :.r rceZdZdZddfd ZddZe d dZ d dZxZ S) v8SegmentationLosszFCriterion class for computing training losses for YOLOv8 segmentation.ct|||||jj|_t dd|_y)zWInitialize the v8SegmentationLoss class with model parameters and mask overlap setting.r)rrN)rrr overlap_maskoverlapr bcedice_lossrrrrrs rrzv8SegmentationLoss.__init__s4 )4zz.. '3CHr c |djdddj|d}}tjd|j}t |t rt|dk(r|\}}nd}|j||\\}}} } } } } | d| d| dc|d<|d<|d <|j\} } } }|jr |d j|jj}t |jd d| |fk7r&tj||jd dd d }tj|ddjdd|j|j |j"dz}|j%|||| |dj'dd||||d<||dj|j}tj(|j+|j,jdd ddj}|j.r)|dk(}d||j1dj3|<nX|dj'd}t5| D]6}|||k(}t|dk(rd||dd|jddk(f<8|j7|||d<|dxx|j8j:zcc<nR|dxx|dzj|dzjzz cc<||dxx|dzjz cc<|dxx|j8j:zcc<|| z|j=fS)zFCalculate and return the combined loss for detection and segmentation.mask_coefficientrrorprotorrNrmasksrbilinearF)r align_cornersr rErrU sem_masks)rrr)rrrArrFr$rrr!r\r,rIr*r(rrBrGrzcalculate_segmentation_lossr[one_hotrYrr:rp expand_asranger;rrr)rrr pred_masksr?r1 pred_semsegrxrrurdet_lossrrrr@ryrC mask_zeroriinstance_mask_is rr1zv8SegmentationLoss.losssW!"45==aAFQQSUZ[bUcE {{1T[[1 eU #E a!& E;KEIEgEghmotEuB5-1x$,QK!hqk!Qa$q'(- % Avv ;;='N%%dkk288:EU[[%&66*:: eU[[-=J^cd U7^A.44QR8T^TdTdehlhshstuhvv 66k"''A. DG&!+.11$++> IIinn&6DGGLTTUVXY[\^_`ffh << % IMNIi11!4>>yIJ %k 2 7 7 ;I":.M*/ Q*?/14$KL !Q(;(;(;(Ba(G"GH M ++KCQQ488<<' G (JN+?+?+AA AG&QK!O0022 Q488<<j $++-//r ctjd||}tj||d}t ||j d|z j 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$)rror)rAeinsumr(r)rr+r,)gt_maskrJr?xyxyr pred_maskr1s rsingle_mask_lossz#v8SegmentationLoss.single_mask_loss%sT(LLe< 11)WPVW$%**v*6=BBDDr c |j\} } } } d} ||gdz } t| dddfjd}| tj| | | | g|j z}t t|||||||D]\}}|\}}}}}}}|jrw||}|jr*||dzjdddk(}|j}n||jd|k(|}| |j||||||||z } | |dzj|dzjzz } | |jz 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 .roNrrrU)r\r prodrArBrF enumerateziprHr:r[r*rSr,)rrxr@rrurr?rHryrrrr1target_bboxes_normalizedmareamxyxyrLsingle_i fg_mask_itarget_gt_idx_i pred_masks_iproto_imxyxy_imarea_imasks_imask_idxrPs rrDz.v8SegmentationLoss.calculate_segmentation_loss=s> %{{1ff$153F#F 23CG<AA!D)5<<QW8Xafamam+nn$S-UTY[`bg%hi CKAx[c XI gwQX}}*95<<%(Q,)<)qAEEG"KK 9??1#5yq7I JS\ScSc  #)++j1nEJJyGWGWXQ 2EOON4ST..#\\#i.9I9IJWUcMdd 8A.*45"/!8!8!>q$>OD 'H.4ll2.>!.Cvf~*Y_`fYgimInH**8VXtLI~~b!Q& $ hv.>@P Q -''r )r.r.)rrfrrfr4rtr5rr5r6r5) rsr5rr5rr5r@r5r6r5)r@r5rr5rsr5rr5rr5rur5rr5r6r) r8r9r:r;rr1rdrtrrvr<r=s@rrfrf}sS9#0J-"-" -"$ -"  -"  -"^1(1($1( 1(  1( $ 1($1( 1( +1(r rfcpeZdZdZddfd Zd dZed dZd dZ d dZ xZ S) PoseLoss26z_Criterion class for computing training losses for YOLOv8 pose estimation with RLE loss support.c t|||||jddgk(}|jd}d|_t |j ddr|j dj nd|_|j tdj|j|_|r2tjtj|jn tj||j |_yy) zdInitialize PoseLoss26 with model parameters and keypoint-specific loss functions including RLE loss.rhrrNrU flow_modelT)rr)rrrirle_losshasattrrrrrIrFrArkrrltarget_weights)rrrrrnrors rrzPoseLoss26.__init__s )4..RG+~~a  8? BQ]8^%++b/44dh ?? &#d;>>t{{KDM@G  ,//   ;;=k*--dkk:@@BHHJI f q )  f q ) !::k"''A.N%Q'DG$Q'DG}}((+Q Q488==  Q488==  == $ Gtxx|| #Gj $++-//r cz|j}|dxx|dddgfz cc<|dxx|dddgfz cc<|S)rzrNrrrr{r|s rrtzPoseLoss26.kpts_decode^sG OO  & ]1qc6**  & ]1qc6** r c||}||}|ddddf}|ddddf}|ddddf}|jjdj|jdd} | |} |j }||z |dzz } t j | t j| zjd} | js!t jd |j S| | } | jd d } || }| | } |jj| } |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. NrrorrrrUrrrid)rrprepeatr\r&rAisnanisinfrHrBrFclamprlog_probr) rrrrpred_kpt_visiblegt_kpt_visible pred_coordsr gt_coordsrr valid_maskrs rcalculate_rle_losszPoseLoss26.calculate_rle_lossfsL$H-)&q!A#v. %af- "1ac6* ,,66q9@@PQARTUV'1'') y(Z$->?{{5)EKK,>>CCCKK ~~<<HOO< <j! D#& + ' 3//**51}}Z%HHr c |j||||}|dddfxx|jddddzcc<d} d} d} |jr||z}||} t||ddddfj dd} ||}| j dd k(r| d dk7nt j| d d}|j|| || } |jI|j dd k(s|j dd k(r%|j|| |} | jd} |j dd k(s|j dd k(r#|j|d |j} | | | 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. .NrorrUrTrVrrrrr)min)rr[rHr rUr\rArrmrrrrjr*)rr@rrsrrrurrrrrrrrrs rrvz#PoseLoss26.calculate_keypoints_losss>"::9iQ^`ef 37#}'9'9!RA'FF#   99; ] *M'.F]5121ab59>>q$>OD 'H.4ll2.>!.Cvf~*Y_`fYgimInH**8VXtLI}}(hnnR.@A.EXZI[_`I`228VXN#>>a>0~~b!Q&(..*<*A $ hv.>@P Q -11r r-r/r4r)rr5rr5rr5r6r5)r@r5rr5rsr5rr5rr5rur5rr5r6z/tuple[torch.Tensor, torch.Tensor, torch.Tensor]) r8r9r:r;rr1rdrtrrvr<r=s@rrrsi 10f#IJ6262$62 62  62 $ 62$62 62 962r rceZdZdZddZy)v8ClassificationLosszACriterion class for computing training losses for classification.ct|ttfr|dn|}tj||dd}||j fS)zDCompute the classification loss between predictions and true labels.rr r+r$)r$listrr(rZr)rrrr1s rrczv8ClassificationLoss.__call__sA&utUm<a%ueElfET[[]""r Nrrrr2r6r)r8r9r:r;rcr5r rrrs K#r rcVeZdZdZddfd Zd dZd dZ d dZd dZxZ S) v8OBBLosszdCalculates losses for object detection, classification, and box distribution in rotated YOLO models.ct|||t||jdd|jj ||_t|jj|j|_ y)z^Initialize v8OBBLoss with model, assigner, and rotated bbox loss; model must be de-paralleled.rrrrN) rrr rrzrrrrRrIrFrr<s rrzv8OBBLoss.__init__se 22;;%%'   )699$++Fr c|jddk(r%tj|dd|j}|S|dddfj }|j d\}}|j tj}tj||jd|j}|ddddfj}|dddd fj|tj|dztj|j } | jd|dztj|| jd} tjt||j| |z } |||| f<|S) z7Preprocess targets for oriented bounding box detection.rrrNTrrrrr)r\rArrFrYrrIrrrurrrrrr) rrrrrrrrpacked_targetsrrs rrzv8OBBLoss.preprocesssH == q ++j!Qt{{CC  1 **,I!((t(zcc<|dxx|j<j@zcc<|dxx|j<jBzcc<|dxx|j<jDzcc<|| z|j-fS#t$$r}t'd|d }~wwxYw)zBCalculate and return the loss for oriented bounding box detection.rrrrrorrangler rNrErrUr r rr r )rrTrVruhERROR ❌ OBB dataset incorrectly formatted or not a OBB dataset. This error can occur when incorrectly training a 'OBB' model on a 'detect' dataset, i.e. 'yolo train model=yolo26n-obb.pt data=dota8.yaml'. Verify your dataset is a correctly formatted 'OBB' dataset using 'data=dota8.yaml' as an example. See https://docs.ultralytics.com/datasets/obb/ for help..r)#rArrFrrrrzr\rGrBr[rr*rrIrr,r RuntimeError TypeErrorrrurrr&rrrrcalculate_angle_lossrrr rr)rrrr1rr pred_anglertrrrGryrrrwrhrrrrrsbboxes_for_assignerrrurvrxrwr0s rr1zv8OBBLoss.losss{{1T[[1 'N " "1a + 6 6 8 (O # #Aq! , 7 7 9 'N " "1a + 6 6 8#-[ (4E'NDKKQT'U$ }%%a( !! U7^A.44QR8TYZ]a]h]hij]kk k*//A6IiiE%L,=,=b!,DeHoFZFZ[]_`Fa bdefGQT]U58_4gadmeERSHo6UBrQw2734Googjj&=zX]^jXkolG#*==#; IymmAtm488=G&&}k:N )//188:C!G$ 5$6:mm    ( ( *  $ $Y__ 5 M )    7 3=-! 1 1 3Q7((; (8(8(?@DDFIZZQ ;;= #rr' "m 3 "#~~!  DGT!W#&&r*73F//]GV=NDG G Q++- -G Q488<< Q488<< Q488<< Q488>>!j $++-//q [    s C;P P- P((P-c2|jrh|j\}}}|j||d|dzjdj |j j |j}tjt||||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). rrrUr) rr\r[rrrrrGrArr )rrtr]rrrrs rrzv8OBBLoss.bbox_decodeAs| <<ooGAq!!q!QQ7??BII$))..YbYhYhJijIyy)Iz=I:V\^__r c|d}|d}|d} |d} tj|dz|dzz } tj| dz |dzz } | | z } | tj| tj z tj zz }tj d||zdz}| ||z}||z}|j|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).rrro)rArrroundmathpisinr,)rrsrurxr0rw lambda_valw_gth_gt pred_theta target_thetalog_ar scale_weight delta_thetadelta_theta_wrappedang_losss rrzv8OBBLoss.calculate_angle_lossSsV$V$ ( $V, D4KD4K89yy619Q!?@  </ )EKK dgg8M,NQUQXQX,XX99Q!4W!==>!C(83f$||~ 111r r-rr0r1r4)rtr5r]r5rr5r6r5)r) r8r9r:r;rrr1rrr<r=s@rrrsGn G$O0b`)`6B`P\` `$2r rceZdZdZdZddZy) E2EDetectLossGCriterion class for computing training losses for end-to-end detection.cLt|d|_t|d|_y)zcInitialize E2EDetectLoss with one-to-many and one-to-one detection losses using the provided model.r.rrN)rone2manyone2one)rrs rrzE2EDetectLoss.__init__vs'; &uq9 r ct|tr|dn|}|d}|j||}|d}|j||}|d|dz|d|dzfS)r(rrrr)r$rrr)rrrr loss_one2manyr loss_one2ones rrczE2EDetectLoss.__call__{sr&ue4a%$ h6  "||GU3 Q,q/1=3ClSTo3UUUr Nr)r8r9r:r;rrcr5r rrrssQ: Vr rc2eZdZdZefdZddZddZd dZy) E2ELossrc||d|_||dd|_d|_d|_d|_|j|jz |_|j|_d |_y ) z]Initialize E2ELoss with one-to-many and one-to-one detection losses using the provided model.r.rr)rrrrDg?g?N)rrupdatestotalo2mo2oo2m_copy final_o2m)rrloss_fns rrzE2ELoss.__init__s[3 uqA>   ::( r c|jj|}|d|d}}|jj||}|jj||}|d|jz|d|j zz|dfS)r(rrrr)rr&r1rrr)rrrrrrrs rrczE2ELoss.__call__s **51!*-uY/?' **8U; ||((%8 Q$((*\!_txx-GGVWXXr c|xjdz c_|j|j|_t|j|jz d|_y)zUUpdate the weights for one-to-many and one-to-one losses based on the decay schedule.rrN)rdecayrrrr)rs rupdatezE2ELoss.updates?  ::dll+tzzDHH,a0r ctd|t|jjjdz dz z d|j|j z z|j zS)zSCalculate the decayed weight for one-to-many loss based on the current update step.rr)rrrepochsrr)rxs rrz E2ELoss.decaysV1q3t||//66:A>>>BdmmVZVdVdFdehlhvhvvvr Nr)r6rg)r6r*) r8r9r:r;rrrcrrr5r rrrsQ&5 Y1 wr rc:eZdZdZdd dZd dZd dZd dZd dZy) TVPDetectLosszOCriterion class for computing training losses for text-visual prompt detection.Nct||||_|jj|_|jj|_|jj |_|jj|_y)z^Initialize TVPDetectLoss with task-prompt and visual-prompt criteria using the provided model.N) r vp_criterionrrori_ncrori_norR ori_reg_max)rrrrs rrzTVPDetectLoss.__init__s`+E8YG$$((''** ''** ,,44r c8|jj|S)r#)rr&r%s rr&zTVPDetectLoss.parse_outputs  --e44r cD|j|j||S)4Calculate the loss for text-visual prompt detection.r)r*s rrczTVPDetectLoss.__call__yy**51599r c&|j|djdk(r>tjd|jj d}||j fS|j||d<|j ||}|dd}||dfS)rrrrTrF requires_gradrrr\rArrrFr_get_vp_features)rrrr1vp_lossbox_losss rr1zTVPDetectLoss.loss ;;%///2 2;;q):):)A)AQUVD& &//6h##E511:a=##r c|d}|jd}||j_||jjdzz|j_||jj _|S)z5Extract visual-prompt features from the model output.rrr)r\rrrRrrr)rrrvncs rrzTVPDetectLoss._get_vp_featuresscxll1o""T%6%6%>%>%BB14"". r r-r)r6r2rr4)rr2r6zlist[torch.Tensor]) r8r9r:r;rr&rcr1rr5r rrrsY55: $r rc4eZdZdZdfd ZddZddZxZS)TVPSegmentLosszRCriterion class for computing training losses for text-visual prompt segmentation.c|t||t|||_|jj|_y)z_Initialize TVPSegmentLoss with task-prompt and visual-prompt criteria using the provided model.N)rrr7rr)rrrrs rrzTVPSegmentLoss.__init__s2 .uh?$$((r cD|j|j||S)7Calculate the loss for text-visual prompt segmentation.r)r*s rrczTVPSegmentLoss.__call__rr c&|j|djdk(r>tjd|jj d}||j fS|j||d<|j ||}|dd}||dfS)rrrrTrrror)rrrr1rcls_losss rr1zTVPSegmentLoss.lossrr )r.r)r8r9r:r;rrcr1r<r=s@rrrs\) : $r r)4 __future__rrtypingrrAtorch.nnrtorch.nn.functional functionalr(ultralytics.utils.metricsrrultralytics.utils.opsrrr ultralytics.utils.talr r r r rultralytics.utils.torch_utilsrmetricsrrtalrrModulerr?rPrirrrrrrr7rfrrrrrrrr5r rrsM#  ;AAuu2&%BII@ " "F!RYY!*,"ryy,"^3bii3l,"h,"^299Be"))e0W299W&P.P.fZ$Z$z[([(|f2f2R##b2b2JVV$ w wF''T$]$r