a yµÿf~…ã@sRddlZddlmZddlmmZddlmZddlm Z m Z m Z ddl m Z mZmZmZmZddlmZddlmZmZddlmZGd d „d ejƒZGd d „d ejƒZGd d„dejƒZGdd„dejƒZGdd„deƒZGdd„dejƒZGdd„dƒZ Gdd„de ƒZ!Gdd„de ƒZ"Gdd„dƒZ#Gdd„de ƒZ$Gdd „d ƒZ%dS)!éN)Ú OKS_SIGMA)Ú crop_maskÚ xywh2xyxyÚ xyxy2xywh)ÚRotatedTaskAlignedAssignerÚTaskAlignedAssignerÚ dist2bboxÚ dist2rboxÚ make_anchors)Úautocasté)Úbbox_iouÚprobiou)Ú bbox2distcs.eZdZdZ‡fdd„Zeddd„ƒZ‡ZS) Ú VarifocalLosszO Varifocal loss by Zhang et al. https://arxiv.org/abs/2008.13367. cstƒ ¡dS)z#Initialize the VarifocalLoss class.N©ÚsuperÚ__init__©Úself©Ú __class__©úR/var/www/html/django/DPS/env/lib/python3.9/site-packages/ultralytics/utils/loss.pyrszVarifocalLoss.__init__çè?ç@cCsv|| ¡ |¡d|||}tdd6tj| ¡| ¡dd| d¡ ¡}Wdƒn1sh0Y|S)zComputes varfocal loss.r F)ÚenabledÚnone©Z reductionN)ÚsigmoidÚpowr ÚFÚ binary_cross_entropy_with_logitsÚfloatÚmeanÚsum)Z pred_scoreZgt_scoreÚlabelÚalphaÚgammaÚweightÚlossrrrÚforwards" ÿÿ zVarifocalLoss.forward)rr©Ú__name__Ú __module__Ú __qualname__Ú__doc__rÚ staticmethodr+Ú __classcell__rrrrrs rcs.eZdZdZ‡fdd„Zeddd„ƒZ‡ZS) Ú FocalLosszjWraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5).cstƒ ¡dS)z3Initializer for FocalLoss class with no parameters.Nrrrrrr+szFocalLoss.__init__çø?çÐ?c Csztj||dd}| ¡}||d|d|}d||}||9}|dkrl||d|d|}||9}| d¡ ¡S)zRCalculates and updates confusion matrix for object detection/classification tasks.rrr çð?r)r!r"rr$r%) Úpredr&r(r'r*Z pred_probZp_tZmodulating_factorZ alpha_factorrrrr+/s zFocalLoss.forward)r4r5r,rrrrr3(s r3cs0eZdZdZd ddœ‡fdd„ Zdd„Z‡ZS) ÚDFLossz9Criterion class for computing DFL losses during training.éN©Úreturncstƒ ¡||_dS)zInitialize the DFL module.N)rrÚreg_max©rr<rrrrDs zDFLoss.__init__cCs„| d|jdd¡}| ¡}|d}||}d|}tj|| d¡dd |j¡|tj|| d¡dd |j¡|jdddS) z¹ Return sum of left and right DFL losses. Distribution Focal Loss (DFL) proposed in Generalized Focal Loss https://ieeexplore.ieee.org/document/9792391 rr g{®Gáz„?éÿÿÿÿrrT©Zkeepdim)Zclamp_r<Úlongr!Ú cross_entropyÚviewÚshaper$)rÚ pred_distÚtargetÚtlÚtrZwlÚwrrrrÚ__call__Is  ÿÿýzDFLoss.__call__)r9)r-r.r/r0rrIr2rrrrr8Asr8cs*eZdZdZd‡fdd„ Zdd„Z‡ZS)ÚBboxLossú>Criterion class for computing training losses during training.r9cs$tƒ ¡|dkrt|ƒnd|_dS)úLInitialize the BboxLoss module with regularization maximum and DFL settings.r N)rrr8Údfl_lossr=rrrr^s zBboxLoss.__init__c Cs¦| d¡| d¡}t||||ddd} d| | ¡|} |jrŒt|||jjdƒ} | || d|jj¡| |¡|} |  ¡|} nt d¡  |j ¡} | | fS)ú IoU loss.r>FT)ÚxywhZCIoUr6r ç) r%Ú unsqueezer rMrr<rBÚtorchÚtensorÚtoÚdevice© rrDÚ pred_bboxesÚ anchor_pointsÚ target_bboxesÚ target_scoresÚtarget_scores_sumÚfg_maskr)ZiouZloss_iouZ target_ltrbZloss_dflrrrr+cs$zBboxLoss.forward)r9©r-r.r/r0rr+r2rrrrrJ[srJcs(eZdZdZ‡fdd„Zdd„Z‡ZS)ÚRotatedBboxLossrKcstƒ |¡dS)rLNrr=rrrrwszRotatedBboxLoss.__init__c Cs°| d¡| d¡}t||||ƒ} d| | ¡|} |jr–t|t|ddd…fƒ|jjdƒ} | || d|jj¡| |¡|} |  ¡|} nt  d¡  |j ¡} | | fS)rNr>r6.Nér rP) r%rQrrMrrr<rBrRrSrTrUrVrrrr+{s$$zRotatedBboxLoss.forwardr]rrrrr^ts r^cs.eZdZdZddœ‡fdd„ Zdd„Z‡ZS)Ú KeypointLossú.Criterion class for computing training losses.Nr:cstƒ ¡||_dS)z"Initialize the KeypointLoss class.N)rrÚsigmas)rrbrrrrs zKeypointLoss.__init__cCs|d|d d¡|d|d d¡}|jdtj|dkddd}|d|j d¡|dd}| dd¡dt | ¡| ¡S) z_Calculates keypoint loss factor and Euclidean distance loss for predicted and actual keypoints.©.ré©.r r r©Údimg•Ö&è .>r>)r rCrRr%rbrBÚexpr$)rÚ pred_kptsZgt_kptsÚkpt_maskÚareaÚdZkpt_loss_factorÚerrrr+”s,  zKeypointLoss.forwardr]rrrrr`Œsr`c@s2eZdZdZd dd„Zdd„Zdd„Zd d „Zd S) Úv8DetectionLossraé cCs®t| ¡ƒj}|j}|jd}tjdd|_||_|j |_ |j |_ |j |j d|_ |j |_ ||_|j dk|_ t||j ddd|_t|j ƒ |¡|_tj|j tj|d |_d S) zdInitializes v8DetectionLoss with the model, defining model-related properties and BCE loss function.r>rrr_r çà?ç@©ZtopkZ num_classesr'Úbeta)ÚdtyperUN)ÚnextÚ parametersrUÚargsÚmodelÚnnÚBCEWithLogitsLossÚbceÚhypÚstrideÚncr<ÚnoÚuse_dflrÚassignerrJrTÚ bbox_lossrRZaranger#Úproj)rrxÚtal_topkrUÚhÚmrrrr s  zv8DetectionLoss.__init__c CsÞ|j\}}|dkr,tj|d|d|jd}n®|dd…df}|jdd\}} | jtjd} tj||  ¡|d|jd}t|ƒD]4} || k} |   ¡} | r~|| dd…f|| d| …f<q~t |ddd …f  |¡ƒ|ddd …f<|S) úXPreprocesses the target counts and matches with the input batch size to output a tensor.rr ©rUNT©Z return_counts©rt.é) rCrRÚzerosrUÚuniquerTÚint32ÚmaxÚranger%rÚmul_) rÚtargetsÚ batch_sizeÚ scale_tensorÚnlÚneÚoutÚiÚ_ÚcountsÚjÚmatchesÚnrrrÚ preprocess´s  &zv8DetectionLoss.preprocesscCsJ|jr<|j\}}}| ||d|d¡ d¡ |j |j¡¡}t||ddS)zUDecode predicted object bounding box coordinates from anchor points and distribution.r_éF)rO) r€rCrBÚsoftmaxÚmatmulrƒÚtypertr)rrXrDÚbÚaÚcrrrÚ bbox_decodeÆs *zv8DetectionLoss.bbox_decodec s2tjdˆjd}t|tƒr"|dn|‰t ‡‡fdd„ˆDƒd¡ ˆjdˆjfd¡\}}|  ddd¡  ¡}|  ddd¡  ¡}|j }|j d}tj ˆdj dd …ˆj|d ˆjd}tˆˆjd ƒ\} } t |d  d d¡|d d d¡|dfd¡} ˆj|  ˆj¡||gd¢d} |  dd¡\} } | jddd d¡}ˆ | |¡}ˆ | ¡ ¡| ¡|  | j ¡| | | | |¡\}}}}}t| ¡dƒ}ˆ || |¡¡ ¡||d<| ¡râ|| }ˆ ||| ||||¡\|d<|d<|dˆjj9<|dˆjj9<|dˆjj 9<| ¡|| ¡fS)úLCalculate the sum of the loss for box, cls and dfl multiplied by batch size.rŸrˆr cs&g|]}| ˆdjdˆjd¡‘qS©rr>©rBrCr©Ú.0Úxi©ZfeatsrrrÚ Óóz,v8DetectionLoss.__call__..rdr_rN©rUrtrpÚ batch_idxr>ÚclsÚbboxes©r rr r©r”©r r_Tr?rP)!rRrŒrUÚ isinstanceÚtupleÚcatÚsplitr<r~ÚpermuteÚ contiguousrtrCrSr}r rBržrTr%Úgt_r¦rÚdetachrr¢rr{r‚r|Úboxr²Údfl)rÚpredsÚbatchr*Ú pred_distriÚ pred_scoresrtr“ÚimgszrXÚ stride_tensorr’Ú gt_labelsÚ gt_bboxesÚmask_gtrWr™rYrZr\r[rr­rrIÏsFÿ *.   ù  ÿzv8DetectionLoss.__call__N)ro)r-r.r/r0rržr¦rIrrrrrns   rnc s‚eZdZdZ‡fdd„Zdd„Zeejejejejejejdœdd„ƒZ ejejejejejejejeje ejd œ d d „Z ‡Z S) Úv8SegmentationLossracstƒ |¡|jj|_dS)zSInitializes the v8SegmentationLoss class, taking a de-paralleled model as argument.N)rrrwZ overlap_maskÚoverlap©rrxrrrr s zv8SegmentationLoss.__init__c s,tjdˆjd}t|ƒdkr |n|d\‰}}|j\}}}} t ‡‡fdd„ˆDƒd¡ ˆjdˆjfd¡\} } |   ddd¡  ¡} |   ddd¡  ¡} |  ddd¡  ¡}| j } tj ˆdjdd …ˆj| d ˆj d} tˆˆj d ƒ\}}zz|d  d d¡}t ||d d d¡|dfd¡}ˆj| ˆj¡|| gd¢d}| dd¡\}}|jddd d¡}Wn0ty’}ztdƒ|‚WYd }~n d }~00ˆ || ¡}ˆ |  ¡ ¡| ¡| |j ¡|||||¡\}}}}}t| ¡dƒ}ˆ | | | ¡¡ ¡||d<| ¡r¤ˆ | |||||||¡\|d<|d<|d ˆj¡ ¡}t|jdd …ƒ|| fkr‚t j!|d || fddd}ˆ "|||||||| ˆj#¡ |d<n$|d|d ¡|d ¡7<|dˆj$j%9<|dˆj$j%9<|dˆj$j&9<|dˆj$j'9<| ¡|| ¡fS)ú1Calculate and return the loss for the YOLO model.r_rˆrŸr cs&g|]}| ˆdjdˆjd¡‘qSr¨r©rªr­rrr®r¯z/v8SegmentationLoss.__call__..rdrNr°rpr±r>r²r³r´rµr¶Tr?rPu€ERROR ⌠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=yolov8n-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.ÚmaskséþÿÿÿZnearest)Úmode)(rRrŒrUÚlenrCr¹rºr<r~r»r¼rtrSr}r rBržrTr%r½Ú RuntimeErrorÚ TypeErrorr¦rr¾rr¢rr{r‚r#r¸r!Z interpolateÚcalculate_segmentation_lossrËr|r¿r²rÀ)rrÁrÂr*Ú pred_masksÚprotor“r™Úmask_hÚmask_wrÃrÄrtrÅrXrÆr±r’rÇrÈrÉrmrWrYrZr\Ú target_gt_idxr[rÎrr­rrIsrÿ*" ÿú  ú  ù ÿ $zv8SegmentationLoss.__call__)Úgt_maskr7rÖÚxyxyrkr;cCs8t d||¡}tj||dd}t||ƒjdd| ¡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->ihwrr)r rdrf)rRZeinsumr!r"rr$r%)rÚr7rÖrÛrkZ pred_maskr*rrrÚsingle_mask_losscsz#v8SegmentationLoss.single_mask_loss) r\rÎrÙrYr±rÖrÕrÅrËr;c  Cs"|j\} } } } d} ||gd¢}t|ƒddd…f d¡}|tj| | | | g|jd}tt|||||||ƒƒD]¤\}}|\}}}}}}}| ¡rø||}| r¾||d  ddd¡k}|  ¡}n||  d¡|k|}| |  ||||||||¡7} qp| |d  ¡|d  ¡7} qp| |  ¡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´.rdNrˆr r>) rCrÚprodrRrSrUÚ enumerateÚzipÚanyrBr#rÜr%)rr\rÎrÙrYr±rÖrÕrÅrËr™r×rØr*Ztarget_bboxes_normalizedZmareaZmxyxyr˜Zsingle_iZ fg_mask_iZtarget_gt_idx_iZ pred_masks_iZproto_iZmxyxy_iZmarea_iZmasks_iZmask_idxrÚrrrrÔ|s$"  ÿz.v8SegmentationLoss.calculate_segmentation_loss) r-r.r/r0rrIr1rRZTensorrÜÚboolrÔr2rrrrrÊs$ SþõrÊcs<eZdZdZ‡fdd„Zdd„Zedd„ƒZdd „Z‡Z S) Ú v8PoseLossracsvtƒ |¡|jdj|_t ¡|_|jddgk}|jd}|rRt t ¡  |j ¡ntj ||j d|}t |d|_dS)zaInitializes v8PoseLoss with model, sets keypoint variables and declares a keypoint loss instance.r>érŸrrˆ)rbN)rrrxÚ kpt_shaperyrzÚbce_poserRZ from_numpyrrTrUZonesr`Ú keypoint_loss)rrxZis_poseZnkptrbrrrrÂs   *zv8PoseLoss.__init__c søtjdˆjd}t|dtƒr"|n|d\‰}t ‡‡fdd„ˆDƒd¡ ˆjdˆjfd¡\}}|  ddd¡  ¡}|  ddd¡  ¡}|  ddd¡  ¡}|j }tj ˆdj dd …ˆj|d ˆjd}tˆˆjd ƒ\} } |j d} |d  d d¡} t | |d d d¡|dfd¡} ˆj|  ˆj¡| |gd¢d} |  dd¡\}}|jddd d¡}ˆ | |¡}ˆ | |j| d gˆj¢RŽ¡}ˆ | ¡ ¡| ¡|  |j ¡| | |||¡\}}}}}t| ¡dƒ}ˆ || |¡¡ ¡||d<| ¡r€|| }ˆ ||| ||||¡\|d<|d<|d ˆj¡ ¡  ¡}|d|d9<|d|d9<ˆ !|||| | ||¡\|d<|d<|dˆj"j#9<|dˆj"j$9<|dˆj"j%9<|dˆj"j&9<|dˆj"j'9<| ¡| | ¡fS)z'Calculate the total loss and detach it.r‹rˆrr cs&g|]}| ˆdjdˆjd¡‘qSr¨r©rªr­rrr®Ðr¯z'v8PoseLoss.__call__..rdr_Nr°rpr±r>r²r³r´rµr¶Tr?rPrŸÚ keypointsrcre)(rRrŒrUr·Úlistr¹rºr<r~r»r¼rtrSrCr}r rBržrTr%r½r¦Ú kpts_decoderärr¾rr¢rr{r‚r#ÚcloneÚcalculate_keypoints_lossr|r¿ZposeZkobjr²rÀ)rrÁrÂr*rirÃrÄrtrÅrXrÆr“r±r’rÇrÈrÉrWr™rYrZr\rÙr[rçrr­rrIÌs\ÿ* "   ú  ÿÿzv8PoseLoss.__call__cCsh| ¡}|ddd…fd9<|d|dd…dgfd7<|d|dd…d gfd7<|S) z1Decodes predicted keypoints to image coordinates..Nrdrrcrrprer )rê)rXriÚyrrrrés ""zv8PoseLoss.kpts_decodec Csr| ¡}t|ƒ}tj|ddd ¡} tj|| |jd|jdf|jd} t|ƒD]&} ||| k} | | | d| jd…f<qR|  d¡  d¡} |   d|   dd|jd|jd¡¡}||  dddd¡}d}d}|  ¡rj||}t||ƒdd…dd…fjddd }||}|jdd kr&|d dknt |d d¡}| ||||¡}|jdd krj| |d | ¡¡}||fS) aZ 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: (tuple): Returns a tuple containing: - kpts_loss (torch.Tensor): The keypoints loss. - kpts_obj_loss (torch.Tensor): The keypoints object loss. Tr‰r rdrˆNrr>r?rŸ).rdrc)ÚflattenrÑrRrrrŒrCrUrrQÚgatherÚexpandrBràrrÝZ full_likerærår#)rrÎrÙrçr±rÆrYrir“Zmax_kptsZbatched_keypointsr˜Z keypoints_iZtarget_gt_idx_expandedZselected_keypointsZ kpts_lossZ kpts_obj_lossZgt_kptrkZpred_kptrjrrrrës2ÿ  ÿ &,z#v8PoseLoss.calculate_keypoints_loss) r-r.r/r0rrIr1rérër2rrrrrâ¿s  B râc@seZdZdZdd„ZdS)Úv8ClassificationLossracCs$tj||ddd}| ¡}||fS)zDCompute the classification loss between predictions and true labels.r²r$r)r!rAr¾)rrÁrÂr*Z loss_itemsrrrrI^szv8ClassificationLoss.__call__N)r-r.r/r0rIrrrrrð[srðcs8eZdZdZ‡fdd„Zdd„Zdd„Zdd „Z‡ZS) Ú v8OBBLosszdCalculates losses for object detection, classification, and box distribution in rotated YOLO models.cs8tƒ |¡td|jddd|_t|jƒ |j¡|_ dS)zdInitializes v8OBBLoss with model, assigner, and rotated bbox loss; note model must be de-paralleled.rorprqrrN) rrrr~rr^r<rTrUr‚rÌrrrrhs zv8OBBLoss.__init__c Csà|jddkr$tj|dd|jd}n¸|dd…df}|jdd\}}|jtjd}tj|| ¡d|jd}t|ƒD]h}||k} |   ¡} | rr|| dd…f} | d dd …f  |¡tj || d d…f| gd d ||d| …f<qr|S)r‡rérˆNTr‰rŠrd.r_r r>rf) rCrRrŒrUrrTrŽrrr%r‘r¹) rr’r“r”r—r˜r™ršr›rœrr³rrrržns ,zv8OBBLoss.preprocessc s$tjdˆjd}t|dtƒr"|n|d\‰}|jd}t ‡‡fdd„ˆDƒd¡ ˆjdˆj fd¡\}}|  ddd¡  ¡}|  ddd¡  ¡}|  ddd¡  ¡}|j }tj ˆdjdd …ˆj|d ˆjd} tˆˆjd ƒ\} } zÐ|d  d d¡} t | |d d d¡|d d d¡fd¡} | d d …df| d ¡| d d …df| d ¡}}| |dk|dk@} ˆj|  ˆj¡|| gd¢d} |  dd¡\}}|jddd d¡}Wn0tyä}ztdƒ|‚WYd }~n d }~00ˆ | ||¡}| ¡ ¡}|dd d…f| 9<ˆ | ¡ ¡| |j ¡| | |||¡\}}}}}t| ¡dƒ}ˆ || |¡¡ ¡||d<| ¡r¼|dd d…f| <ˆ  ||| ||||¡\|d<|d<n|d|d ¡7<|dˆj!j"9<|dˆj!j#9<|dˆj!j$9<| ¡|| ¡fS)rÍrŸrˆrr cs&g|]}| ˆdjdˆjd¡‘qSr¨r©rªr­rrr®…r¯z&v8OBBLoss.__call__..rdr_Nr°rpr±r>r²r³r‹r´rµ)r r‹Tr?rPuhERROR ⌠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=yolov8n-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..)%rRrŒrUr·rèrCr¹rºr<r~r»r¼rtrSr}r rBÚitemržrTr%r½rÒrÓr¦rêr¾rrr¢rr{r‚r|r¿r²rÀ)rrÁrÂr*Ú pred_angler“rÃrÄrtrÅrXrÆr±r’ÚrwZrhrÇrÈrÉrmrWZbboxes_for_assignerr™rYrZr\r[rr­rrI€sb ÿ**: ÿú    ú  ÿzv8OBBLoss.__call__cCsV|jr<|j\}}}| ||d|d¡ d¡ |j |j¡¡}tj t |||ƒ|fddS)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). r_rŸr>rf) r€rCrBr r¡rƒr¢rtrRr¹r )rrXrDrôr£r¤r¥rrrr¦Ès  *zv8OBBLoss.bbox_decode) r-r.r/r0rržrIr¦r2rrrrrñes  Hrñc@s eZdZdZdd„Zdd„ZdS)Ú E2EDetectLossracCs t|dd|_t|dd|_dS)zcInitialize E2EDetectLoss with one-to-many and one-to-one detection losses using the provided model.ro)r„r N)rnÚone2manyÚone2onerÌrrrrÝszE2EDetectLoss.__init__cCs^t|tƒr|dn|}|d}| ||¡}|d}| ||¡}|d|d|d|dfS)r§r r÷rør)r·r¸r÷rø)rrÁrÂr÷Z loss_one2manyrøZ loss_one2onerrrrIâs   zE2EDetectLoss.__call__N)r-r.r/r0rrIrrrrröÚsrö)&rRZtorch.nnryZtorch.nn.functionalZ functionalr!Zultralytics.utils.metricsrZultralytics.utils.opsrrrZultralytics.utils.talrrrr r Zultralytics.utils.torch_utilsr Zmetricsr rÚtalrÚModulerr3r8rJr^r`rnrÊrârðrñrörrrrÚs,    k8 u