h6SSKJr SSKJr SSKrSSKJr SSKJs Jr SSK J r SSK J r JrJr SSKJrJrJrJrJr SSKJr SS KJrJr SS KJr "S S \R:5r"S S\R:5r"SS\R:5r "SS\R:5r!"SS\!5r""SS\R:5r#"SS5r$"SS\$5r%"SS\$5r&"SS5r'"SS \$5r("S!S"5r)"S#S$5r*"S%S&\*5r+g)') annotations)AnyN) OKS_SIGMA) crop_mask xywh2xyxy xyxy2xywh)RotatedTaskAlignedAssignerTaskAlignedAssigner dist2bbox dist2rbox make_anchors)autocast)bbox_iouprobiou) bbox2distc>^\rSrSrSrSSU4SjjjrSSjrSrU=r$) VarifocalLossa Varifocal loss by Zhang et al. Implements the Varifocal Loss function for addressing class imbalance in object detection by focusing on hard-to-classify examples and balancing positive/negative samples. Attributes: gamma (float): The focusing parameter that controls how much the loss focuses on hard-to-classify examples. alpha (float): The balancing factor used to address class imbalance. References: https://arxiv.org/abs/2008.13367 c:>[TU]5 XlX lg)zJInitialize the VarifocalLoss class with focusing and balancing parameters.N)super__init__gammaalphaselfrr __class__s P/home/james-whalen/.local/lib/python3.13/site-packages/ultralytics/utils/loss.pyrVarifocalLoss.__init__#s   ctURUR5RUR5-SU- -X#--n[ SS9 [ R "UR5UR5SS9U-RS5R5nSSS5 U$!,(df  W$=f)z^\rSrSrSrSSU4SjjjrSSjrSrU=r$) FocalLoss5a Wraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5). Implements the Focal Loss function for addressing class imbalance by down-weighting easy examples and focusing on hard negatives during training. Attributes: gamma (float): The focusing parameter that controls how much the loss focuses on hard-to-classify examples. alpha (torch.Tensor): The balancing factor used to address class imbalance. cd>[TU]5 Xl[R"U5Ulg)zBInitialize FocalLoss class with focusing and balancing parameters.N)rrrtorchtensorrrs rrFocalLoss.__init__As#  \\%( r c[R"XSS9nUR5nX$-SU- SU- --nSU- UR-nX6-nURS:R 5(a[URR URURS9UlX R-SU- SUR- --nX7-nURS5R5$)zACalculate focal loss with modulating factors for class imbalance.r#r$r?rdevicedtype) r(r)r&rranytorLrMr+r,)rpredr/r1 pred_probp_tmodulating_factor alpha_factors rr2FocalLoss.forwardGs11$P LLN 1u9Y"?? 3Y4::5 ! JJN   ! !dkkLDJ ::-Uq4::~0NNL  Dyy|!!r r4)g?g?r6)rPr7r/r7r8r7r9rAs@rrCrC5s )) ""r rCc>^\rSrSrSrSSU4SjjjrSSjrSrU=r$) DFLossYz[TU]5 Xlg)z6Initialize the DFL module with regularization maximum.N)rrreg_maxrrZrs rrDFLoss.__init__\s  r cURSURS- S- 5nUR5nUS-nXB- nSU- n[R"XR S5SS9R UR 5U-[R"XR S5SS9R UR 5U--RSSS9$) zZReturn sum of left and right DFL losses from https://ieeexplore.ieee.org/document/9792391.rrg{Gz?r#r$Tkeepdim)clamp_rZlongr( cross_entropyviewshaper+)r pred_disttargettltrwlwrs r__call__DFLoss.__call__asq$,,"2T"9: [[] !V [ V OOIwwr{f E J J288 TWY YooiGLLRXXVY[[ \ $r4$  !r )rZ)rZintr8None)rfr7rgr7r8r7 r:r;r<r=r>rrlr?r@rAs@rrWrWYsF ! !r rWc^^\rSrSrSrSSU4SjjjrSSjrSrU=r$) BboxLossnzACriterion class for computing training losses for bounding boxes.c^>[TU]5 US:a[U5UlgSUlg)zLInitialize the BboxLoss module with regularization maximum and DFL settings.rN)rrrWdfl_lossr[s rrBboxLoss.__init__qs% +2Q;w D r c URS5URS5n[X'XGSSS9n SU - U-R5U- n UR(av[ X4URR S- 5n URXR SURR 5X5U-n U R5U- n X4$[R"S5RUR5n X4$)z.Compute IoU and DFL losses for bounding boxes.r^FT)xywhCIoUrJr) r, unsqueezerrwrrZrdrFrGrOrL rrf pred_bboxes anchor_points target_bboxes target_scorestarget_scores_sumfg_maskr0iouloss_iou target_ltrbloss_dfls rr2BboxLoss.forwardvs""2&w/99"={+]-C%VZ[3Y&(--/2CC ==#M$--BWBWZ[B[\K}}Y%7%<%[TU]U5 g)zSInitialize the RotatedBboxLoss module with regularization maximum and DFL settings.N)rrr[s rrRotatedBboxLoss.__init__s !r c .URS5URS5n[X'XG5n SU - U-R5U- n UR(a[ U[ USSS245URR S- 5n URXRSURR 5X5U-n U R5U- n X4$[R"S5RUR5n X4$)z6Compute IoU and DFL losses for rotated bounding boxes.r^rJ.Nrr|) r,r}rrwrrrZrdrFrGrOrLr~s rr2RotatedBboxLoss.forwards ""2&w/99"=k*M,BC3Y&(--/2CC ==#M9]3PRQRPR7=S3TVZVcVcVkVknoVopK}}Y%7%<%[TU]5 Xlg)z7Initialize the KeypointLoss class with keypoint sigmas.N)rrsigmas)rrrs rrKeypointLoss.__init__s  r cUSUS- RS5USUS- RS5-nURS[R"US:gSS9S-- nUSUR-RS5US--S-- nUR SS5S[R "U*5- U--R5$) zICalculate keypoint loss factor and Euclidean distance loss for keypoints..r.rrrdimg& .>r^)r'rerFr,rrdexpr+)r pred_kptsgt_kptskpt_maskareadkpt_loss_factores rr2KeypointLoss.forwardsv  0 5 5a 8If$$R+EIIqbM0AX/MNTTVVr r)rr7r8rq) rr7rr7rr7rr7r8r7r9rAs@rrrsD8 W%W0<WHTW\hW WWr rcD\rSrSrSrS S SjjrS SjrS SjrS SjrSr g)v8DetectionLosszJCriterion class for computing training losses for YOLOv8 object detection.c[UR55RnURnURSn[ R "SS9UlX@lURUl URUl URURS--Ul URUl X0lURS:Ul [X RSSS9Ul[!UR5R#U5Ul[&R("UR[&R*US 9Ulg ) zVInitialize v8DetectionLoss with model parameters and task-aligned assignment settings.r^r#r$rr?@topk num_classesrbeta)rMrLN)next parametersrLargsmodelnnBCEWithLogitsLossbcehypstridencrZnouse_dflr assignerrtrO bbox_lossrFaranger*proj)rrtal_topkrLhms rrv8DetectionLoss.__init__se&&()00 JJ KKO''&9hh $$$$Q&yy  yy1} +wwVY`cd !!)),//7LL%++fM r cURupEUS:Xa&[R"USUS- URS9nU$USS2S4nUR SS9upU R [R S9n [R"X)R5US- URS9n[U5H.n Xz:Hn U R5=n (dM XSS24XjSU 24'M0 [USSS 24RU55USSS 24'U$) zJPreprocess targets by converting to tensor format and scaling coordinates.rrrLNT return_countsrM.) rerFzerosrLuniquerOint32maxranger,rmul_) rtargets batch_size scale_tensornlneouti_countsjmatchesns r preprocessv8DetectionLoss.preprocesss 7++j!R!VDKKHC 1 At4IAYYU[[Y1F++j**,Qt{{SC:&& %1%!(!"!5C2A2J'&c#qs(m&8&8&FGCQqSM r cUR(afURup4nURX4SUS-5RS5R UR R UR55n[X!SS9$)zUDecode predicted object bounding box coordinates from anchor points and distribution.rF)rz) rrerdsoftmaxmatmulrtyperMr )rrrfbacs r bbox_decodev8DetectionLoss.bbox_decodese <<ooGA!!qQQ7??BII$))..YbYhYhJijI>>r c [R"SURS9n[U[5(aUSOUn[R "UVs/sH/oUR USRSURS5PM1 snS5RURS-UR4S5upgURSSS5R5nURSSS5R5nURnURSn [R"USRSSURUS 9UR S-n [#X@R S 5up[R "US R SS5US R SS5US 4S5n UR%XU /SQS9n U RSS5upUR'SSS9R)S5nUR+X5nUR-UR/5R15UR/5U -R3UR5X-UUU5unnnnn[5UR'5S5nUR7UUR9U55R'5U- US'UR'5(a#UR;UUU UU - UUU5uUS'US'US==UR<R>-ss'US==UR<R@-ss'US==UR<RB-ss'X9-UR/54$s snf)LCalculate the sum of the loss for box, cls and dfl multiplied by batch size.rrrrr^rrNrKr batch_idxclsbboxesrrrrrrrTr_r|)"rFrrL isinstancetuplecatrdrersplitrZrpermute contiguousrMrGrr rr,gt_rrdetachr&rrrrOrrboxrdfl)rpredsbatchr1featsxi pred_distri pred_scoresrMrimgszr stride_tensorr gt_labels gt_bboxesmask_gtrrrrrrs rrlv8DetectionLoss.__call__s{{1T[[1&ue44a%#(99`e-f`eZ\ggeAhnnQ6GRT.U`e-fhi#j#p#p \\A tww '$  "))!Q2==? !))!Q2==? !! &&q)  U1X^^AB/ 5QTXT_T_`aTbb'3E;;'L$ ))U;/44R;U5\=N=NrST=UW\]eWfgijk//'E,DW/X&}}VQ7 --4-044S9&&}B 7;mm    ( ( *    !M 1 7 7  H  )   7 3=-! 1 1 3Q7((; (8(8(?@DDFIZZQ ;;==#~~ -!  DGT!W Q488<< Q488<< Q488<< $++-//o.gs6M,) rrrrLrrrrrZrrN) )rrprr7rrprr7r8r7)rr7rfr7r8r7rrrzdict[str, torch.Tensor]r8r) r:r;r<r=r>rrrrlr?rr rrrsTN("?;0r rc^\rSrSrSrU4SjrSSjr\S Sj5rS Sjr Sr U=r $) v8SegmentationLossi3zFCriterion class for computing training losses for YOLOv8 segmentation.cZ>[TU]U5 URRUlg)zWInitialize the v8SegmentationLoss class with model parameters and mask overlap setting.N)rrr overlap_maskoverlaprrrs rrv8SegmentationLoss.__init__6s! zz.. r c $ [R"SURS9n[U5S:XaUOUSupEnURupxp[R "UV s/sH/oR USRSURS5PM1 sn S5RURS-UR4S5upU RSSS5R5n U RSSS5R5n URSSS5R5nU Rn[R"USRSSURUS 9URS-n[!X@RS 5unnUS R SS5n[R "UUS R SS5US 4S5nUR#UX/SQS9nURSS5unnUR%SSS9R'S5nUR-UU 5nUR/U R15R35UR15U-R5UR5UU-UUU5unnnnn[7UR%5S5nUR9U UR;U55R%5U- US'UR%5(aUR=U UUUU- UUU5uUS'US'USR;UR5R?5n[AURSS5X4:wa[BRD"USX4SS9SnURGUUUUUXeXRH5 US'O2US==US-R%5US-R%5-- ss'US==URJRL-ss'US==URJRL-ss'US==URJRN-ss'US==URJRP-ss'X7-UR154$s sn f![(an[+S5UeSnAff=f)zFCalculate and return the combined loss for detection and segmentation.rrrrrr^rNrKrrrrrrrTr_r|uERROR ❌ segment dataset incorrectly formatted or not a segment dataset. This error can occur when incorrectly training a 'segment' model on a 'detect' dataset, i.e. 'yolo train model=yolo11n-seg.pt data=coco8.yaml'. Verify your dataset is a correctly formatted 'segment' dataset using 'data=coco8-seg.yaml' as an example. See https://docs.ultralytics.com/datasets/segment/ for help.masksnearest)mode))rFrrLlenrerrdrrrZrrrrMrGrr rr,r RuntimeError TypeErrorrrrr&rrrrOrr*rr( interpolatecalculate_segmentation_lossrrrrr)rrrr1r pred_masksprotorrmask_hmask_wrrrrMrrrrrrr r rrrrr target_gt_idxrrs rrlv8SegmentationLoss.__call__;s3{{1T[[1,/J!O5q 5(- % v#(99`e-f`eZ\ggeAhnnQ6GRT.U`e-fhi#j#p#p \\A tww '$  "))!Q2==? !))!Q2==? ''1a0;;= !! U1X^^AB/ 5QTXT_T_`aTbb'3E;;'L$ } k*//A6IiiE%L,=,=b!,DeHo VXYZGoogzlH[o\G#*==#; IymmAtm488=G&&}kB BF--    ( ( *    !M 1 7 7  H M )    C ?=-- 1 1 3Q7((; (8(8(?@DDFIZZQ ;;==#~~ -!  DGT!W'N%%dkk288:EU[[%&6*:: eDkF3C)TUVW66 }i\acocoDG G (JN+?+?+AA AG Q488<< Q488<< Q488<< Q488<< $++-//Y.g( _    s6Q/BQ44 R> R  Rc[R"SX5n[R"XPSS9n[ Xc5R SS9U- R 5$)a Compute the instance segmentation loss for a single image. Args: gt_mask (torch.Tensor): Ground truth mask of shape (N, H, W), where N is the number of objects. pred (torch.Tensor): Predicted mask coefficients of shape (N, 32). proto (torch.Tensor): Prototype masks of shape (32, H, W). xyxy (torch.Tensor): Ground truth bounding boxes in xyxy format, normalized to [0, 1], of shape (N, 4). area (torch.Tensor): Area of each ground truth bounding box of shape (N,). Returns: (torch.Tensor): The calculated mask loss for a single image. Notes: The function uses the equation pred_mask = torch.einsum('in,nhw->ihw', pred, proto) to produce the predicted masks from the prototype masks and predicted mask coefficients. z in,nhw->ihwr#r$)rrr)rFeinsumr(r)rr+r,)gt_maskrPr!xyxyr pred_maskr1s rsingle_mask_loss#v8SegmentationLoss.single_mask_losssN*LL< 11)PVW$%**v*6=BBDDr c URu pn Sn XH/SQ- n[U5SSS24RS5nU[R"XX/UR S9-n[ [XXvUX55HunnUunnnnnnnUR5(aqUUnU (a*UUS-RSSS5:HnUR5nOX%RS5U:HUnXRUUUUUUUU5- n MXS-R5US-R5-- n M XR5- $) a Calculate the loss for instance segmentation. Args: fg_mask (torch.Tensor): A binary tensor of shape (BS, N_anchors) indicating which anchors are positive. masks (torch.Tensor): Ground truth masks 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). overlap (bool): Whether the masks in `masks` tensor overlap. 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.rNrrr^) rerprodrFrGrL enumerateziprNrdr*r+r,)rrrr$rrr!r rrrr"r#r1target_bboxes_normalizedmareamxyxyrsingle_i fg_mask_itarget_gt_idx_i pred_masks_iproto_imxyxy_imarea_imasks_imask_idxr(s rr.v8SegmentationLoss.calculate_segmentation_losssjD %{{1f$13F#F 23CG<AA!D)5<<8Xafamam+nn$STY[`%hiKAx[c XI gwQX}}*95%(Q,)<)rrl staticmethodr+rr?r@rAs@rrr3sP/ Q0fEE%1E:FENZEbnE EE0@$@$@$$ @$ $ @$  @$@$!@$@$@$ @$@$r rct^\rSrSrSrU4SjrSSjr\S Sj5rS Sjr Sr U=r $) v8PoseLossizICriterion class for computing training losses for YOLOv8 pose estimation.c>[TU]U5 URSRUl[R "5UlURSS/:HnURSnU(a3[R"[5RUR5O [R"X0RS9U- n[US9Ulg)zQInitialize v8PoseLoss with model parameters and keypoint-specific loss functions.r^rrrrN)rrr kpt_shaperrbce_poserF from_numpyrrOrLonesr keypoint_loss)rris_posenkptrrs rrv8PoseLoss.__init__s R22,,. ..RG+~~a @G!!),// $>5E!H#(99`e-f`eZ\ggeAhnnQ6GRT.U`e-fhi#j#p#p \\A tww '$  "))!Q2==? !))!Q2==? %%aA.99; !! U1X^^AB/ 5QTXT_T_`aTbb'3E;;'L$ !&&q) +&++B2 ))Ye (9(9"a(@%/RTUV//'E,DW/X&}}VQ7 9--4-044S9&&}B $$]NN:r4cTXTbTb4cd BF--    ( ( *    !M 1 7 7  H  )    C ?=-- 1 1 3Q7((; (8(8(?@DDFIZZQ ;;== ] *M#~~[- Whjq  DGT!Wk*--dkk:@@BHHJI f q )  f q ) #<< 9]\e  DGT!W Q488<< Q488==  Q488==  Q488<< Q488<< $++-//y.gs6Q>cUR5nUSSS24==S-ss'US==USS2S/4S- - ss'US==USS2S /4S- - ss'U$) z0Decode predicted keypoints to image coordinates..Nrr5rrrrr)rP)rrys rrOv8PoseLoss.kpts_decode9sg OO  #rr' c  & ]1qc6*S00  & ]1qc6*S00 r c UR5n[U5n[R"USS9SR 5n [R "XUR SUR S4URS9n [U5Hn X4U :Hn XU SU R S24'M! URS5RS5n U RSU RSSUR SUR S55nUS SS24==URSSSS5-ss'SnSnUR5(aXn[Xa5SS2SS24RSSS 9nXqnUR SS :XaUS S:gO[R "US S5nUR#UUUU5nUR SS :Xa#UR%US UR'55nUU4$)a Calculate the keypoints loss for the model. This function calculates the keypoints loss and keypoints object loss for a given batch. The keypoints loss is based on the difference between the predicted keypoints and ground truth keypoints. The keypoints object loss is a binary classification loss that classifies whether a keypoint is present or not. Args: masks (torch.Tensor): Binary mask tensor indicating object presence, shape (BS, N_anchors). target_gt_idx (torch.Tensor): Index tensor mapping anchors to ground truth objects, shape (BS, N_anchors). keypoints (torch.Tensor): Ground truth keypoints, shape (N_kpts_in_batch, N_kpts_per_object, kpts_dim). batch_idx (torch.Tensor): Batch index tensor for keypoints, shape (N_kpts_in_batch, 1). stride_tensor (torch.Tensor): Stride tensor for anchors, shape (N_anchors, 1). target_bboxes (torch.Tensor): Ground truth boxes in (x1, y1, x2, y2) format, shape (BS, N_anchors, 4). pred_kpts (torch.Tensor): Predicted keypoints, shape (BS, N_anchors, N_kpts_per_object, kpts_dim). Returns: kpts_loss (torch.Tensor): The keypoints loss. kpts_obj_loss (torch.Tensor): The keypoints object loss. TrrrrNrr^.r_r).rr)flattenrrFrrrrerLrr}gatherexpandrdrNrr. full_likerHrEr*)rrr$rMrrrrrmax_kptsbatched_keypointsr keypoints_itarget_gt_idx_expandedselected_keypoints kpts_loss kpts_obj_lossgt_kptrpred_kptrs rrQ#v8PoseLoss.calculate_keypoints_lossBs<%%' Z << >qAEEG"KK 9??1#5yq7I JS\ScSc  z"A#N3K;Fa!7;#4#4Q#7!77 8# "/!8!8!>q$>OD 'H.4ll2.>!.Cvf~*Y_`fYgimInH**8VXtLI~~b!Q& $ hv.>@P Q -''r )rErHrDr)rr7rr7r8r7)rr7r$r7rMr7rr7rr7rr7rr7r8r) r:r;r<r=r>rrlr?rOrQr?r@rAs@rrArAsS9@0DG(G($G( G(  G( $ G($G( G( +G(G(r rAc"\rSrSrSrSSjrSrg)v8ClassificationLossizACriterion class for computing training losses for classification.c[U[[45(aUSOUn[R"XSSS9nX3R 54$)zDCompute the classification loss between predictions and true labels.rrr+r$)rrNrr(rcr)rrrr1s rrlv8ClassificationLoss.__call__s@&utUm<<a%uElfE[[]""r rNr)r:r;r<r=r>rlr?rr rrhrhs K#r rhcZ^\rSrSrSrU4SjrSSjrS SjrS SjrSr U=r $) v8OBBLossizdCalculates losses for object detection, classification, and box distribution in rotated YOLO models.c>[TU]U5 [SURSSS9Ul[ UR 5RUR5Ul g)z^Initialize v8OBBLoss with model, assigner, and rotated bbox loss; model must be de-paralleled.r rrrN) rrr rrrrZrOrLrrs rrv8OBBLoss.__init__sG 2WZade (699$++Fr c URSS:Xa#[R"USSURS9nU$USS2S4nUR SS9upgUR [R S9n[R"X'R5SURS9n[U5HcnXX:Hn U R5=n (dM XSS24n U S SS 24RU5 [R"XS S24U /S S 9XHSU 24'Me U$)z7Preprocess targets for oriented bounding box detection.rrNTrrr.rrr^r) rerFrrLrrOrrrr,rr) rrrrrrrrrrrrs rrv8OBBLoss.preprocesss == q ++j!Qt{{CC 1 At4IAYYU[[Y1F++j**,$++NC:&& %1%$ab[1F37O((6!&GQqSL,A6+JPR!SC2A2J '  r c [R"SURS9n[US[5(aUOUSupEUR Sn[R "UVs/sH/owRUSR SURS5PM1 snS5RURS-UR4S5upU RSSS5R5n URSSS5R5nURSSS5R5nU Rn [R"USR SSURU S 9UR S-n [#X@R S 5upUS RSS5n[R "XS RSS5US RSS54S5nUSS2S4U SR%5-USS2S4U SR%5-nnUUS:US:-nUR'XU /SQS9nURSS5unnUR)SSS9R+S5nUR1XU5nUR35R55nUSSS24==U -ss'UR7U R55R95UR;UR5X-UUU5unnnnn[=UR)5S5nUR?U URAU 55R)5U- US'UR)5(a2USSS24==U -ss'URCUUU UUUU5uUS'US'OUS==US-R)5- ss'US==URDRF-ss'US==URDRH-ss'US==URDRJ-ss'X6-UR554$s snf![,an[/S5UeSnAff=f)zBCalculate and return the loss for oriented bounding box detection.rrrrr^rrNrKrrrrrrr)rrTr_r|uhERROR ❌ 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=yolo11n-obb.pt data=coco8.yaml'. Verify your dataset is a correctly formatted 'OBB' dataset using 'data=dota8.yaml' as an example. See https://docs.ultralytics.com/datasets/obb/ for help..)&rFrrLrrNrerrdrrrZrrrrMrGrr itemrr,rrrrrPrrr&rrrrOrrrrr)rrrr1r pred_anglerrrrrMrrrrrrwrhrr r rrbboxes_for_assignerrrrrrs rrlv8OBBLoss.__call__s{{1T[[1%/a$%?%?EU1X%%a( #(99`e-f`eZ\ggeAhnnQ6GRT.U`e-fhi#j#p#p \\A tww '$  "))!Q2==? !))!Q2==? ''1a0;;= !! U1X^^AB/ 5QTXT_T_`aTbb'3E;;'L$  k*//A6Iii%L,=,=b!,DeHoFZFZ[]_`Fa bdefGQT]U1X]]_4gadmeAhmmo6UBrQw2734GooglH[o\G#*==#; IymmAtm488=G&&}:N )//188:C!G$ 5$6:mm    ( ( *  $ $Y__ 5  )    7 3=-! 1 1 3Q7((; (8(8(?@DDFIZZQ ;;== #rr' "m 3 "#~~[- Whjq  DGT!W G Q++- -G Q488<< Q488<< Q488<< $++-//C.g, [    s$6P9C%P>> Q QQc2UR(afURupEnURXESUS-5RS5R UR R UR55n[R"[X#U5U4SS9$)ay Decode predicted object bounding box coordinates from anchor points and distribution. Args: anchor_points (torch.Tensor): Anchor points, (h*w, 2). pred_dist (torch.Tensor): Predicted rotated distance, (bs, h*w, 4). pred_angle (torch.Tensor): Predicted angle, (bs, h*w, 1). Returns: (torch.Tensor): Predicted rotated bounding boxes with angles, (bs, h*w, 5). rrr^r) rrerdrrrrrMrFrr )rrrfrtrrrs rrv8OBBLoss.bbox_decodesv <<ooGA!!qQQ7??BII$))..YbYhYhJijIyy)I=I:V\^__r )rrr r)rr7rfr7rtr7r8r7) r:r;r<r=r>rrrlrr?r@rAs@rrlrlsHnG "F0P`)`6B`P\` ``r rlc(\rSrSrSrSrSSjrSrg) E2EDetectLossi zGCriterion class for computing training losses for end-to-end detection.c@[USS9Ul[USS9Ulg)zcInitialize E2EDetectLoss with one-to-many and one-to-one detection losses using the provided model.r )rrN)rone2manyone2onerrs rrE2EDetectLoss.__init__s'; &uq9 r c[U[5(aUSOUnUSnURX25nUSnURXR5nUSUS-USUS-4$)rrr~rr)rrr~r)rrrr~ loss_one2manyr loss_one2ones rrlE2EDetectLoss.__call__sq&ue44a%$ h6  "||G3 Q,q/1=3ClSTo3UUUr )r~rNr)r:r;r<r=r>rrlr?rr rr|r| sQ: Vr r|c2\rSrSrSrSrSSjrS SjrSrg) TVPDetectLossizOCriterion class for computing training losses for text-visual prompt detection.c[U5UlURRUlURRUlURR Ulg)z^Initialize TVPDetectLoss with task-prompt and visual-prompt criteria using the provided model.N)r vp_criterionrori_ncrori_norZ ori_reg_maxrs rrTVPDetectLoss.__init__!sI+E2''** ''** ,,44r c[U[5(aUSOUnURURR:XdeURS-UR -USR S:Xa;[R"SURRSS9nXDR54$URU5nURXR5nUSSnXvS4$)z4Calculate the loss for text-visual prompt detection.rrrrTrL requires_grad) rrrrrZrrerFrrLr_get_vp_features)rrrrr1vp_featsvp_lossbox_losss rrlTVPDetectLoss.__call__)s&ue44a%4#4#4#<#<<<<   a $++ -q1B B;;q):):)A)AQUVD& &((/##H41:a=##r c USRSURS-- UR- nX RlX RR S--URlX RRlUVs/sH,o3RURS-URU4SS9PM. snVVVs/sHupEn[R"XF4SS9PM snnn$s snfs snnnf)z5Extract visual-prompt features from the model output.rrrr) rerrrrrZrrrrrFr)rrvncrrrcls_vps rrTVPDetectLoss._get_vp_features7sAhnnQ$"2"2Q"66D""%6%6%>%>%BB14"".hm"mglac88T-=-=-A4;;PS,TZ[8#\gl"m "m IIsm +"m  "m s 3C*#C/)rrrrNr)rlist[torch.Tensor]r8r) r:r;r<r=r>rrlrr?rr rrrsY5 $  r rc6^\rSrSrSrU4SjrSSjrSrU=r$)TVPSegmentLossiEzRCriterion class for computing training losses for text-visual prompt segmentation.cD>[TU]U5 [U5Ulg)z_Initialize TVPSegmentLoss with task-prompt and visual-prompt criteria using the provided model.N)rrrrrs rrTVPSegmentLoss.__init__Hs .u5r c[U5S:XaUOUSup4nURURR:XdeURS-UR-USR S:Xa;[ R"SURRSS9nXfR54$URU5nURXtU4U5nUSSn XS4$)z7Calculate the loss for text-visual prompt segmentation.rrrrTrr) rrrrZrrerFrrLrr) rrrrr r!r1rrcls_losss rrlTVPSegmentLoss.__call__Ms,/J!O5q 54#4#4#<#<<<<   a $++ -q1B B;;q):):)A)AQUVD& &((/##X5$A5I1:a=##r )rrrrrAs@rrrEs\6 $ $r r), __future__rtypingrrFtorch.nnrtorch.nn.functional functionalr(ultralytics.utils.metricsrultralytics.utils.opsrrrultralytics.utils.talr r r r r ultralytics.utils.torch_utilsrmetricsrrtalrModulerrCrWrtrrrrrArhrlr|rrrr rrs# /AAuu2&BIIB!" !"H!RYY!*"ryy"D"h"BW299W&l0l0^t$t$n_(_(D##s`s`lVV$$ $ N$]$r