.h6ddlmZddlmZddlZddlmZddlmcmZ ddl m Z ddl m Z mZmZddlmZmZmZmZmZddlmZdd lmZmZdd lmZGd d ej:ZGd dej:ZGddej:Z Gddej:Z!Gdde!Z"Gddej:Z#GddZ$Gdde$Z%Gdde$Z&GddZ'Gdd e$Z(Gd!d"Z)Gd#d$Z*Gd%d&e*Z+y)') annotations)AnyN) OKS_SIGMA) crop_mask xywh2xyxy xyxy2xywh)RotatedTaskAlignedAssignerTaskAlignedAssigner dist2bbox dist2rbox make_anchors)autocast)bbox_iouprobiou) bbox2distc.eZdZdZddfd ZddZxZS) 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>t|||_||_y)zJInitialize the VarifocalLoss class with focusing and balancing parameters.N)super__init__gammaalphaselfrr __class__s T/var/www/html/ai-service/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)zrS)r%rZr?r*rrYexpr))r pred_kptsgt_kptskpt_maskareadkpt_loss_factores rr0zKeypointLoss.forwardsv  0 5 5a 8If$$R+EIIqbM0AX/MNTTVVr)rr3r4re) rr3rr3rr3rr3r4r3r5r;s@rrrs>8 W%W0<WHTW\hW Wrrc2eZdZdZdddZd dZd dZd dZy) v8DetectionLosszJCriterion class for computing training losses for YOLOv8 object detection.ct|jj}|j}|jd}t j d|_||_|j|_ |j|_ |j|jdzz|_ |j|_ ||_|jdkD|_ t||jdd|_t!|jj#||_t'j(|jt&j*| |_y ) zVInitialize v8DetectionLoss with model parameters and task-aligned assignment settings.rSr!r"rr?@topk num_classesrbeta)rErDN)next parametersrDargsmodelnnBCEWithLogitsLossbcehypstridencrPnouse_dflr assignerrhrG bbox_lossr?aranger(proj)rrtal_topkrDhms rrzv8DetectionLoss.__init__se&&()00 JJ KKO''&9hh $$$$Q&yy  yy1} +twwVY`cd !!)),//7LL%++fM rc"|j\}}|dk(r(tj|d|dz |j}|S|dddf}|j d\}} | j tj } tj|| j|dz |j}t|D]*} || k(} | jx} s|| ddf|| d| f<,t|ddd fj||ddd f<|S) zJPreprocess targets by converting to tensor format and scaling coordinates.rrrDNT return_countsrE.) rZr?zerosrDuniquerGint32maxranger*rmul_) rtargets batch_size scale_tensornlneouti_countsjmatchesns r preprocesszv8DetectionLoss.preprocesssB 7++j!R!VDKKHC 1 At4IAvYYU[[Y1F++j&**,Qt{{SC:& 6q& %1%!(!"!5C2A2J 6&c#qs(m&8&8&FGCQqSM rc|jrh|j\}}}|j||d|dzjdj |j j |j}t||dS)zUDecode predicted object bounding box coordinates from anchor points and distribution.rF)rl) rrZrYsoftmaxmatmulrtyperEr )rrrr[bacs r bbox_decodezv8DetectionLoss.bbox_decodesk <<ooGAq!!q!QQ7??BII$))..YbYhYhJijIM>>rc tjd|j}t|tr|dn|}tj |Dcgc]/}|j |djd|jd1c}dj|jdz|jfd\}}|jdddj}|jdddj}|j}|jd} tj|djdd|j| |j dz} t#||j d \} } tj |d j dd|d j dd|d fd} |j%| | | gd} | jdd\}}|j'ddj)d}|j+| |}|j-|j/j1|j/| zj3|j| | z|||\}}}}}t5|j'd}|j7||j9|j'|z |d<|j'r#|j;||| || z |||\|d<|d<|dxx|j<j>zcc<|dxx|j<j@zcc<|dxx|j<jBzcc<|| z|j/fScc}w)LCalculate the sum of the loss for box, cls and dfl multiplied by batch size.rrrrrSrrNrCr batch_idxclsbboxesrrrrrrrTrTrn)"r?rrD isinstancetuplecatrYrZrsplitrPrpermute contiguousrEr@rr rr*gt_rrdetachr$rrrrGrrboxrdfl)rpredsbatchr/featsxi pred_distri pred_scoresrErimgszrr stride_tensorr gt_labels gt_bboxesmask_gtrqrrsrtrvrus rrazv8DetectionLoss.__call__s!{{1T[[1&ue4a%#(99`e-fZ\bggeAhnnQ6GRT.U-fhi#j#p#p \\A tww '$  ["))!Q2==? !))!Q2==? !! &&q)  U1X^^AB/ 5QTXT_T_`aTbb'3E4;;'L$ }))U;/44R;U5\=N=NrST=UW\]eWfgijk//':E,DW/X&}}VQ7 9--4-044S9&&}kB 7;mm    ( ( *    !M 1 7 7  H M )   7 3=-! 1 1 3Q7((; (8(8(?@DDFIZZQ ;;=#~~ -!  DGT!W Q488<< Q488<< Q488<<j $++-//o.gs 4M0N) )rrdrr3rrdrr3r4r3)rrr3r[r3r4r3rrrzdict[str, torch.Tensor]r4r})r6r7r8r9rrrrarrrrsTN("?;0rrceZdZdZfdZddZe ddZ ddZxZ S) v8SegmentationLosszFCriterion class for computing training losses for YOLOv8 segmentation.cZt|||jj|_y)zWInitialize the v8SegmentationLoss class with model parameters and mask overlap setting.N)rrr overlap_maskoverlaprrrs rrzv8SegmentationLoss.__init__6s! zz.. rc : tjd|j}t|dk(r|n|d\}}}|j\}}} } tj |D cgc]/} | j |djd|jd1c} dj|jdz|jfd\} } | jdddj} | jdddj} |jdddj}| j}tj|djdd|j| |jdz}t!||jd \}} |d j dd}tj ||d j dd|d fd}|j#|||gd}|jdd\}}|j%ddj'd}|j-|| }|j/| j1j3|j1|zj5|j||z|||\}}}}}t7|j%d}|j9| |j;|j%|z |d<|j%r|j=| ||||z |||\|d<|d<|dj;|jj?}tA|jdd| | fk7r tCjD|d| | fdd}|jG|||||||||jH |d<n2|dxx|dzj%|dzj%zz cc<|dxx|jJjLzcc<|dxx|jJjLzcc<|dxx|jJjNzcc<|dxx|jJjPzcc<||z|j1fScc} w#t($r}t+d|d}~wwxYw)zFCalculate and return the combined loss for detection and segmentation.rrrrrrSrNrCrrrrrrrTrTrnuERROR ❌ 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))r?rrDlenrZrrYrrrPrrrrEr@rr rr*r RuntimeError TypeErrorrrrr$rrrrGrr(rr& interpolatecalculate_segmentation_lossrrrrr)rrrr/r pred_masksprotorrmask_hmask_wrrrrErrrrrrrrrrrqrsrtrv target_gt_idxrurs rrazv8SegmentationLoss.__call__;sE{{1T[[1,/J!O5q z5(- % Avv#(99`e-fZ\bggeAhnnQ6GRT.U-fhi#j#p#p \\A tww '$  [ "))!Q2==? !))!Q2==? ''1a0;;= !! U1X^^AB/ 5QTXT_T_`aTbb'3E4;;'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[[%&66*:: eDkFF3C)TUVW66 }iPZ\acgcocoDG G (JN+?+?+AA AG Q488<< Q488<< Q488<< Q488<<j $++-//Y.g( _    s4Q;BR R RRctjd||}tj||d}t ||j d|z j S)aX 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)r?einsumr&r'rr)r*)gt_maskrHrxyxyr pred_maskr/s rsingle_mask_lossz#v8SegmentationLoss.single_mask_losssT*LLe< 11)WPVW$%**v*6=BBDDrc |j\} } } } d} ||gdz }t|dddfjd}|tj| | | | g|j z}t t|||||||D]\}}|\}}}}}}}|jrm||}| r*||dzjdddk(}|j}n||jd|k(|}| |j||||||||z } | |dzj|dzjzz } | |jz S) aF 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.rNrrrS) rZrprodr?r@rD enumerateziprFrYr(rr*)rrvrrrsrrrrrrrrr/target_bboxes_normalizedmareamxyxyrsingle_i fg_mask_itarget_gt_idx_i pred_masks_iproto_imxyxy_imarea_imasks_imask_idxr s rrz.v8SegmentationLoss.calculate_segmentation_losssD %{{1ff$153F#F 23CG<AA!D)5<<QW8Xafamam+nn$S-UTY[`bg%hi CKAx[c XI gwQX}}*95%(Q,)<)5E!Hy#(99`e-fZ\bggeAhnnQ6GRT.U-fhi#j#p#p \\A tww '$  [ "))!Q2==? !))!Q2==? %%aA.99; !! U1X^^AB/ 5QTXT_T_`aTbb'3E4;;'L$ }!&&q) +&++B2 ))Ye (9(9"a(@%/RTUV//':E,DW/X&}}VQ7 9--4-044S9&&}kB $$]NINN:r4cTXTbTb4cd BF--    ( ( *    !M 1 7 7  H M )    C ?=-- 1 1 3Q7((; (8(8(?@DDFIZZQ ;;= ] *M#~~[- Whjq  DGT!Wk*--dkk:@@BHHJI f q )  f q ) #<< 9m]\e  DGT!W Q488<< Q488==  Q488==  Q488<< Q488<<j $++-//y.gs4Rc|j}|dddfxxdzcc<|dxx|dddgfdz z cc<|dxx|ddd gfdz z cc<|S) z0Decode predicted keypoints to image coordinates..Nrr1rrrrr)r0)rrrys rr/zv8PoseLoss.kpts_decode9sg OO  #rr' c  & ]1qc6*S00  & ]1qc6*S00 rc |j}t|}tj|ddj } tj || |j d|j df|j} t|D] } ||| k(} | | | d| j df<"|jdjd} | jd| jdd|j d|j d}|d ddfxx|jddddzcc<d}d}|jr||}t||ddddfjdd }||}|j dd k(r|d dk7ntj |d d}|j#||||}|j dd k(r#|j%|d |j'}||fS)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. TrrrrNrrS.rTr).rr)flattenrr?rrrrZrDrrogatherexpandrYrFrr full_liker)r&r()rrrr-rrrsrrmax_kptsbatched_keypointsr keypoints_itarget_gt_idx_expandedselected_keypoints kpts_loss kpts_obj_lossgt_kptrpred_kptrs rr1z#v8PoseLoss.calculate_keypoints_lossBs<%%' Z << >qAEEG"KK 9??1#5yq7I JS\ScSc  z" GA#IN3K;F a!7;#4#4Q#7!77 8 G "/!8!8!>q$>OD 'H.4ll2.>!.Cvf~*Y_`fYgimInH**8VXtLI~~b!Q& $ hv.>@P Q -''rr)rrr3rr3r4r3)rr3rr3r-r3rr3rr3rsr3rr3r4r}) r6r7r8r9rrar r/r1r:r;s@rr"r"sS9@0DG(G($G( G(  G( $ G($G( G( +G(rr"ceZdZdZddZy)v8ClassificationLosszACriterion class for computing training losses for classification.ct|ttfr|dn|}tj||dd}||j fS)zDCompute the classification loss between predictions and true labels.rrr)r")rr.rr&rXr)rrrr/s rrazv8ClassificationLoss.__call__sA&utUm<a%ueElfET[[]""rNr)r6r7r8r9rarrrrErEs K#rrEcJeZdZdZfdZddZddZ ddZxZS) v8OBBLosszdCalculates losses for object detection, classification, and box distribution in rotated YOLO models.ct||td|jdd|_t |j j|j|_ y)z^Initialize v8OBBLoss with model, assigner, and rotated bbox loss; model must be de-paralleled.rrrrN) rrr rrrrPrGrDrrs rrzv8OBBLoss.__init__sG 2WZade (699$++Frc2|jddk(r%tj|dd|j}|S|dddf}|j d\}}|j tj }tj||jd|j}t|D]b}||k(} | jx} s|| ddf} | d dd fj|tj|| d df| gd ||d| f<d|S)z7Preprocess targets for oriented bounding box detection.rrNTrrr.rrrSr) rZr?rrDrrGrrrr*rr) rrrrrrrrrrrrs rrzv8OBBLoss.preprocesss == q ++j!Qt{{CC 1 At4IAvYYU[[Y1F++j&**,$++NC:& Tq& %1%$Wab[1F37O((6!&GGQqSL,A6+JPR!SC2A2J  T  rc tjd|j}t|dtr|n|d\}}|j d}tj |Dcgc]/}|j|dj d|jd1c}dj|jdz|jfd\}} | jdddj} |jdddj}|jdddj}| j} tj|dj dd|j| |j dz} t#||j d \} } |d jdd}tj ||d jdd|d jddfd}|dddf| dj%z|dddf| dj%z}}||dk\|dk\z}|j'||| gd}|jdd\}}|j)ddj+d}|j1| ||}|j3j5}|dddfxx| zcc<|j7| j5j9|j;|j| | z|||\}}}}}t=|j)d}|j?| |jA| j)|z |d<|j)r2|dddfxx| zcc<|jC||| ||||\|d<|d<n|dxx|dzj)z cc<|dxx|jDjFzcc<|dxx|jDjHzcc<|dxx|jDjJzcc<||z|j5fScc}w#t,$r}t/d|d}~wwxYw)zBCalculate and return the loss for oriented bounding box detection.rrrrrSrrNrCrrrrrrr)rrTrTrnuhERROR ❌ 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..)&r?rrDrr.rZrrYrrrPrrrrEr@rr itemrr*rrrrr0rrr$rrrrGrrrrr)rrrr/r pred_anglerrrrrErrrrrrrwrhrrrrrqbboxes_for_assignerrrsrtrvrus rrazv8OBBLoss.__call__s{{1T[[1%/a$%?EU1Xz%%a( #(99`e-fZ\bggeAhnnQ6GRT.U-fhi#j#p#p \\A tww '$  [ "))!Q2==? !))!Q2==? ''1a0;;= !! U1X^^AB/ 5QTXT_T_`aTbb'3E4;;'L$ } k*//A6IiiE%L,=,=b!,DeHoFZFZ[]_`Fa bdefGQT]U1X]]_4gadmeAhmmo6UBrQw2734GoogzlH[o\G#*==#; IymmAtm488=G&&}k:N )//188:C!G$ 5$6:mm    ( ( *  $ $Y__ 5 M )    7 3=-! 1 1 3Q7((; (8(8(?@DDFIZZQ ;;= #rr' "m 3 "#~~[- Whjq  DGT!W G Q++- -G Q488<< Q488<< Q488<<j $++-//C.g, [    s!4P>C,Q Q QQc2|jrh|j\}}}|j||d|dzjdj |j j |j}tjt||||fdS)a 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). rrrSr) rrZrYrrrrrEr?rr )rrrr[rNrrrs rrzv8OBBLoss.bbox_decodes| <<ooGAq!!q!QQ7??BII$))..YbYhYhJijIyy)Iz=I:V\^__rrr)rrr3r[r3rNr3r4r3) r6r7r8r9rrrarr:r;s@rrHrHsBnG "F0P`)`6B`P\` `rrHceZdZdZdZddZy) E2EDetectLosszGCriterion 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)rone2manyone2onerrs rrzE2EDetectLoss.__init__s'; &uq9 rct|tr|dn|}|d}|j||}|d}|j||}|d|dz|d|dzfS)rrrVrWr)rrrVrW)rrrrV loss_one2manyrW loss_one2ones rrazE2EDetectLoss.__call__sr&ue4a%$ h6  "||GU3 Q,q/1=3ClSTo3UUUrNr)r6r7r8r9rrarrrrTrT sQ: VrrTc&eZdZdZdZddZddZy) TVPDetectLosszOCriterion class for computing training losses for text-visual prompt detection.ct||_|jj|_|jj|_|jj |_y)z^Initialize TVPDetectLoss with task-prompt and visual-prompt criteria using the provided model.N)r vp_criterionrori_ncrori_norP ori_reg_maxrXs rrzTVPDetectLoss.__init__!sI+E2''** ''** ,,44rct|tr|dn|}|j|jjk(sJ|jdz|j z|dj dk(r>tjd|jjd}||jfS|j|}|j||}|dd}||dfS)z4Calculate the loss for text-visual prompt detection.rrrrTrD requires_grad) rrrbr_rPr`rZr?rrDr_get_vp_features)rrrrr/vp_featsvp_lossbox_losss rrazTVPDetectLoss.__call__)s&ue4a%4#4#4#<#<<<<   a $++ -q1B B;;q):):)A)AQUVD& &((/##He41:a=##rc |djd|jdzz |jz }||j_||jj dzz|j_||jj_|Dcgc]/}|j|jdz|j|fd1c}Dcgc]\}}}tj||fd!c}}}Scc}wcc}}}w)z5Extract visual-prompt features from the model output.rrrr) rZrbr`r_rrPrrrrr?r)rrvncrrrcls_vps rrfzTVPDetectLoss._get_vp_features7sAhnnQ$"2"2Q"66D""T%6%6%>%>%BB14"".hm"mac288T-=-=-A4;;PS,TZ[8#\"m  Q IIsFm +  "m s 4C/$C4Nr)rlist[torch.Tensor]r4rm)r6r7r8r9rrarfrrrr]r]sY5 $  rr]c*eZdZdZfdZddZxZS)TVPSegmentLosszRCriterion class for computing training losses for text-visual prompt segmentation.cDt||t||_y)z_Initialize TVPSegmentLoss with task-prompt and visual-prompt criteria using the provided model.N)rrrr_rs rrzTVPSegmentLoss.__init__Hs .u5rct|dk(r|n|d\}}}|j|jjk(sJ|jdz|jz|dj dk(r>t jd|jjd}||jfS|j|}|j|||f|}|dd} | |dfS)z7Calculate the loss for text-visual prompt segmentation.rrrrTrdr) rrbr_rPr`rZr?rrDrrf) rrrrrrr/rgrhcls_losss rrazTVPSegmentLoss.__call__Ms,/J!O5q z54#4#4#<#<<<<   a $++ -q1B B;;q):):)A)AQUVD& &((/##Xz5$A5I1:a=##rrrfr;s@rroroEs\6 $rro), __future__rtypingrr?torch.nnrtorch.nn.functional functionalr&ultralytics.utils.metricsrultralytics.utils.opsrrrultralytics.utils.talr r r r r ultralytics.utils.torch_utilsrmetricsrrtalrModulerr=rNrhrrrrr"rErHrTr]rorrrrs# /AAuu2&BIIB!" !"H!RYY!*"ryy"D"h"BW299W&l0l0^t$t$n_(_(D##s`s`lVV$$ $ N$]$r