Fir2dZddlmZddlZddlZddlZddlmZddlmcm Z ddl m Z m Z ddlmZddlmZmZmZddlmZmZmZdd lmZmZmZmZmZmZmZm Z m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(dd l)m*Z*m+Z+d Z,GddejZZ.Gdde.Z/Gdde/Z0Gdde.Z1Gdde1Z2Gdde.Z3Gdde3Z4GddejZZ5Gdde.Z6Gd d!ejZZ7Gd"d#e.Z8Gd$d%e8Z9Gd&d'e9Z:Gd(d)ejZZ;Gd*d+e.Z>> detect = Detect(nc=80, ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> outputs = detect(x) FN,rcZt|_t|_|_|j dzz_tjj_ td|ddzj dzft|dtjdctjfd|D_jrtjfd|Dntjfd|D_j dkDrt#j ntj$_|rIt)j*j_t)j*j _y y ) acInitialize the YOLO detection layer with specified number of classes and channels. Args: nc (int): Number of classes. reg_max (int): Maximum number of DFL channels. end2end (bool): Whether to use end-to-end NMS-free detection. ch (tuple): Tuple of channel sizes from backbone feature maps. rdc 3K|]S}tjt|dtdtjdjzdUyw)r*r N)nn SequentialrConv2dreg_max).0xc2selfs ]/var/www/pod-logistic/pod-ai/venv/lib/python3.12/site-packages/ultralytics/nn/modules/head.py z"Detect.__init__..^sJ! cdBMM$q"a.$r2q/299RT\\IY[\;] ^! sAAc 3K|]P}tjt|dtdtjjdRywr.r Nr/r0rr1ncr3r4c3r6s r7r8z"Detect.__init__..bsEphi"--QARQSUW[W^W^`aIbcpAAc 32K|]}tjtjt||dt|dtjtdtdtjj dywr:)r/r0rrr1r<r=s r7r8z"Detect.__init__..dsu   MM&Aq/42q>BMM&R"3T"b!_EIIb$''1-sBBr N)super__init__r<lennlr2notorchzerosstridemaxminr/ ModuleListcv2legacycv3rIdentitydflcopydeepcopy one2one_cv2 one2one_cv3)r6r<r2end2endchr5r> __class__s` @@r7rBzDetect.__init__NsE b' t||a''kk$''* b"Q%1*dllQ&678#beSRUEV:WB==! hj!   {{ MMpmop p   )- q(83t||$bkkm #}}TXX6D #}}TXX6D  cDt|j|jS)YReturns the one-to-many head components, here for v3/v5/v8/v9/v11 backward compatibility.box_headcls_head)dictrLrNr6s r7one2manyzDetect.one2manyssTXX99rXcDt|j|jS)'Returns the one-to-one head components.r[)r^rSrTr_s r7one2onezDetect.one2onexsT--8H8HIIrXc8t|ddxr t|dS)zKChecks if the model has one2one for v3/v5/v8/v9/v11 backward compatibility._end2endTrc)getattrhasattrr_s r7rUzDetect.end2end}stZ.K743KKrXc||_y)z'Override the end-to-end detection mode.N)re)r6values r7rUzDetect.end2ends  rXc || tS|djd}tjt |j Dcgc].}||||j |d|jzd0c}d}tjt |j Dcgc]+}||||j ||jd-c}d}t|||Scc}wcc}w)JConcatenates and returns predicted bounding boxes and class probabilities.rr*dimboxesscoresfeats) r^shaperFcatrangerDviewr2r<)r6r4r\r]bsirprqs r7 forward_headzDetect.forward_heads  x/6M qTZZ] UZ[_[b[bUcdPQ;8A;qt,11"a$,,6FKdjlmUSWSZSZ^\KHQK!-222twwC\bde%a88e\s 3C0)0C5c|j|fi|j}|jr?|Dcgc]}|j}}|j|fi|j}||d}|j r|S|j |jr|dn|}|jr"|j|jddd}|jr|S||fScc}w)rk)r`rcrcrr ) ryr`rUdetachrctraining _inference postprocesspermuteexport)r6r4predsxix_detachrcys r7forwardzDetect.forwards"!!!5t}}5 <<./0 0H0'd''ADLLAG!&7;E ==L OO E),% H <<  1a!34AKKq/aZ/1sCcv|j|}tj||djfdS)aDDecode predicted bounding boxes and class probabilities based on multiple-level feature maps. Args: x (dict[str, torch.Tensor]): Dictionary of predictions from detection layers. Returns: (torch.Tensor): Concatenated tensor of decoded bounding boxes and class probabilities. rqr )_get_decode_boxesrFrtsigmoid)r6r4dboxs r7r~zDetect._inferences7%%a(yy$( 3 3 56::rXc^|ddj}|js|j|k7r5dt|d|jdD\|_|_||_|j |j|d|jjd|j z}|S)z/Get decoded boxes based on anchors and strides.rrrc3@K|]}|jddyw)rr N) transpose)r3as r7r8z+Detect._get_decode_boxes..s)p!++a*;)ps?rp) rsdynamicr rHanchorsstrides decode_bboxesrP unsqueeze)r6r4rsrs r7rzDetect._get_decode_boxess' 1 ## <<4::.)p\RST[R\^b^i^iknEo)p &DL$,DJ!!$((1W:"6 8N8Nq8QRUYUaUaa rXctt|jd|jdD]\}\}}d|djjddt j d|jz d|j|z dzz |djjd|j|jrtt|jd|jdD]\}\}}d|djjddt j d|jz d|j|z dzz |djjd|jyy) BInitialize Detect() biases, WARNING: requires stride availability.r\r]@rlNr{ enumeratezipr`biasdatamathlogr<rHrUrc)r6rxrbs r7 bias_initzDetect.bias_inits6"3t}}Z'@$--PZB[#\] IAv1!$AbEJJOOA )-DGG sT[[^399*AbEJJOOIdgg &  <<&s4<< +CT\\R\E]'^_  6Aq%(" "-1XXK3Q#7A"==."  $''*  rXc\t|||xr|j xr |j dS)z'Decode bounding boxes from predictions.r )xywhrn)rrUxyxy)r6bboxesrrs r7rzDetect.decode_bboxess2  yy%.B77rXcf|j\}}}|jr|n t||}|jrC|j dd\}}|j |d\}}|j d|}|||fS|j ddj |djd} |j d| jdd|}|jdj |\}} | tj|d| |zf} |d| |zdj| fS) aNGet top-k indices from scores. Args: scores (torch.Tensor): Scores tensor with shape (batch_size, num_anchors, num_classes). max_det (int): Maximum detections per image. Returns: (torch.Tensor, torch.Tensor, torch.Tensor): Top scores, class indices, and filtered indices. rlT)rnkeepdimr rmrr).N) rsrrJ agnostic_nmsrItopkrrrflattenrFarangefloat) r6rqr batch_sizerr<klabelsindices ori_indexrrs r7rzDetect.get_topk_indexs/#),, GR{{GGW(=   #ZZBZ=NFF$kk!k3OFG]]1g.F67* *JJ2J&q)..q1!4>>rB 1I,<, 9Q` 9  90#0 ^0 ;  8 G2#rXr ceZdZdZd d fd ZedZedZd fd Zd fd Z dfd Z ddZ dd Z xZ S)r#aYOLO Segment head for segmentation models. This class extends the Detect head to include mask prediction capabilities for instance segmentation tasks. Attributes: nm (int): Number of masks. npr (int): Number of protos. proto (Proto): Prototype generation module. cv4 (nn.ModuleList): Convolution layers for mask coefficients. Methods: forward: Return model outputs and mask coefficients. Examples: Create a segmentation head >>> segment = Segment(nc=80, nm=32, npr=256, ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> outputs = segment(x) cjt|||||_|_t |djj_t |ddzjtjfd|D_ |r%tjj_ yy)Initialize the YOLO model attributes such as the number of masks, prototypes, and the convolution layers. Args: nc (int): Number of classes. nm (int): Number of masks. npr (int): Number of protos. reg_max (int): Maximum number of DFL channels. end2end (bool): Whether to use end-to-end NMS-free detection. ch (tuple): Tuple of channel sizes from backbone feature maps. rr*c 3K|]P}tjt|dtdtjjdRywr:r/r0rr1nmr3r4c4r6s r7r8z#Segment.__init__..$H woptAr1~tBAPRPYPYZ\^b^e^eghPi!j wr?N) rArBrnprrprotorIr/rKcv4rQrR one2one_cv4) r6r<rrr2rUrVrrWs ` @r7rBzSegment.__init__s Wgr22a5$((DGG4 A!TWW %== wtv ww #}}TXX6D  rXcZt|j|j|jS)IReturns the one-to-many head components, here for backward compatibility.r\r] mask_headr^rLrNrr_s r7r`zSegment.one2many(TXXDHHMMrXcZt|j|j|jS)rbrr^rSrTrr_s r7rczSegment.one2one-&T--8H8HTXTdTdeerXcFt||}t|tr|dn|}|j |d}t|t r0|j r||dd<|j|dd<n||d<|jr|S|jr||fS|d|f|fSgReturn model outputs and mask coefficients if training, otherwise return outputs and mask coefficients.r rr`rrc rAr isinstancerrr^rUr|r}rr6r4outputsrrrWs r7rzSegment.forward2'/!$(%8 g 1Q4  eT "||-2j!'*,1LLNi )!&g ==L#';;Pgaj%5H%4PPrXcZt||}tj||dgdSz]Decode predicted bounding boxes and class probabilities, concatenated with mask coefficients.mask_coefficientr rmrAr~rFrtr6r4rrWs r7r~zSegment._inferenceA."1%yy%#5!67Q??rXc t||||}|s|djd}tjt |j Dcgc]+}||||j||jd-c}d|d<|Scc}wz^Concatenates and returns predicted bounding boxes, class probabilities, and mask coefficients.rrlr{r rAryrsrFrtrurDrvr) r6r4r\r]rrrwrxrWs r7ryzSegment.forward_headFs$Q(;  1AB(- ejkokrkres2t`a<9Q<!3E3J3J2twwXZ3[2tvw(xE$ % 3u 0B cx|jd|j|jgd\}}}|j||j\}}}|j d|j ddd}|j d|j dd|j}tj||||gdSaPost-process YOLO model predictions. Args: preds (torch.Tensor): Raw predictions with shape (batch_size, num_anchors, 4 + nc + nm) with last dimension format [x1, y1, x2, y2, class_probs, mask_coefficient]. Returns: (torch.Tensor): Processed predictions with shape (batch_size, min(max_det, num_anchors), 6 + nm) and last dimension format [x1, y1, x2, y2, max_class_prob, class_index, mask_coefficient]. r*rlrmr r rr<rrrrrrFrtr6rrprqrrrs r7rzSegment.postprocessP+0++q$''4776KQS+*T'v' // Ec #**Q1*= >+22q 1aQUQXQX@Y2Zyy%/?@bIIrXc.dx|_x|_|_yrrLrNrr_s r7rz Segment.fusea)---48dhrXr r+Frr<rrrrrrVrr4rrz4tuple | list[torch.Tensor] | dict[str, torch.Tensor]r) r4rr\rr]rrrrrrr)rrrrrBrr`rcrr~ryrrrrs@r7r#r#s}(7*NNff Q@ #/>JYfu J".rXr#c:eZdZdZddfd ZddZdfd ZxZS) Segment26aYOLO26 Segment head for segmentation models. This class extends the Segment head with Proto26 for mask prediction in instance segmentation tasks. Attributes: nm (int): Number of masks. npr (int): Number of protos. proto (Proto26): Prototype generation module. cv4 (nn.ModuleList): Convolution layers for mask coefficients. Methods: forward: Return model outputs and mask coefficients. Examples: Create a segmentation head >>> segment = Segment26(nc=80, nm=32, npr=256, ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> outputs = segment(x) c|t|||||||t||j|j||_y)rN)rArBrrrr)r6r<rrr2rUrVrWs r7rBzSegment26.__init__{s6 Rgw;R477B7 rXctj||}t|tr|dn|}|j |}t|t rR|j rA||dd<t|trtd|Dn|j|dd<n||d<|jr|S|jr||fS|d|f|fS)rr r`rc3<K|]}|jywN)r|)r3ps r7r8z$Segment26.forward..s4!((*4srcr) r rrrrr^rUr|r}r)r6r4rrrs r7rzSegment26.forwards..q)(%8 g 1  eT "||-2j!'*8B5%8PE4e44V[VbVbVdi )"'g ==L#';;Pgaj%5H%4PPrXct|t|jdr|jjyy)zSRemove the one2many head and extra part of proto module for inference optimization.rN)rArrgrr6rWs r7rzSegment26.fuses-   4::v & JJOO  'rXr rrr)rrrrrBrrrrs@r7rrfs( 8Q"rXrceZdZdZd d fd ZedZedZd fd Z d fd Z ddZ ddZ dd Z xZ S)raYOLO OBB detection head for detection with rotation models. This class extends the Detect head to include oriented bounding box prediction with rotation angles. Attributes: ne (int): Number of extra parameters. cv4 (nn.ModuleList): Convolution layers for angle prediction. angle (torch.Tensor): Predicted rotation angles. Methods: forward: Concatenate and return predicted bounding boxes and class probabilities. decode_bboxes: Decode rotated bounding boxes. Examples: Create an OBB detection head >>> obb = OBB(nc=80, ne=1, ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> outputs = obb(x) c t|||||_t|ddzjt j fd|D_|r%tjj _ yy)aInitialize OBB with number of classes `nc` and layer channels `ch`. Args: nc (int): Number of classes. ne (int): Number of extra parameters. reg_max (int): Maximum number of DFL channels. end2end (bool): Whether to use end-to-end NMS-free detection. ch (tuple): Tuple of channel sizes from backbone feature maps. rr*c 3K|]P}tjt|dtdtjjdRywr:)r/r0rr1ners r7r8zOBB.__init__..rr?N) rArBrrIr/rKrrQrRr)r6r<rr2rUrVrrWs` @r7rBz OBB.__init__sk Wgr2 A!TWW %== wtv ww #}}TXX6D  rXcZt|j|j|jS)rr\r] angle_headrr_s r7r`z OBB.one2manysTXXTXXNNrXcZt|j|j|jS)rbr rr_s r7rcz OBB.one2ones&T--8H8HUYUeUeffrXcn|d|_t| |}tj||dgdS)z[Decode predicted bounding boxes and class probabilities, concatenated with rotation angles.angler rm)r$rAr~rFrtrs r7r~zOBB._inferences9wZ "1%yy%7,!44rXc jt ||||}||djd}tjt |j Dcgc]+}||||j||jd-c}d}|jdz tjz}||d<|Scc}w)zSConcatenates and returns predicted bounding boxes, class probabilities, and angles.rrlr{g?r$) rAryrsrFrtrurDrvrrrpi) r6r4r\r]r!rrwrxr$rWs r7ryzOBB.forward_heads$Q(;  !1ABIIDI$''NSqAqt$))"dggr:SUVE]]_t+tww6E"E'N Ts 0B0c4t||j|dS)zDecode rotated bounding boxes.r rm)rr$)r6rrs r7rzOBB.decode_bboxessW!< #**Q477*C Dyy%u52>>rXc.dx|_x|_|_yrr r_s r7rzOBB.fuser rX)rr r+Fr)r<rrrrVrr r4rr\rr]rr!rrr)rrrrrrrr)rrrrrBrr`rcr~ryrrrrrs@r7rrsz(7$OOgg5 # /> JY gv   =?".rXrc,eZdZdZ ddZy)OBB26a"YOLO26 OBB detection head for detection with rotation models. This class extends the OBB head with modified angle processing that outputs raw angle predictions without sigmoid transformation, compared to the original OBB class. Attributes: ne (int): Number of extra parameters. cv4 (nn.ModuleList): Convolution layers for angle prediction. angle (torch.Tensor): Predicted rotation angles. Methods: forward_head: Concatenate and return predicted bounding boxes, class probabilities, and raw angles. Examples: Create an OBB26 detection head >>> obb26 = OBB26(nc=80, ne=1, ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> outputs = obb26(x) c .tj||||}|u|djd}tjt |j Dcgc]+}||||j||jd-c}d}||d<|Scc}w)zWConcatenates and returns predicted bounding boxes, class probabilities, and raw angles.rrlr{r$) r ryrsrFrtrurDrvr) r6r4r\r]r!rrwrxr$s r7ryzOBB26.forward_heads##D!Xx@  !1ABIIDI$''NSqAqt$))"dggr:SUVE#E'N Ts0BNr*)rrrrryrrXr7r,r,s4& # /> JY gv   rXr,ceZdZdZd d fd ZedZedZd fd Z d fd Z ddZ ddZ dd Z xZ S)r!aYOLO Pose head for keypoints models. This class extends the Detect head to include keypoint prediction capabilities for pose estimation tasks. Attributes: kpt_shape (tuple): Number of keypoints and dimensions (2 for x,y or 3 for x,y,visible). nk (int): Total number of keypoint values. cv4 (nn.ModuleList): Convolution layers for keypoint prediction. Methods: forward: Perform forward pass through YOLO model and return predictions. kpts_decode: Decode keypoints from predictions. Examples: Create a pose detection head >>> pose = Pose(nc=80, kpt_shape=(17, 3), ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> outputs = pose(x) c*t|||||_|d|dz_t |ddzjt j fd|D_|r%tjj_ yy)Initialize YOLO network with default parameters and Convolutional Layers. Args: nc (int): Number of classes. kpt_shape (tuple): Number of keypoints, number of dims (2 for x,y or 3 for x,y,visible). reg_max (int): Maximum number of DFL channels. end2end (bool): Whether to use end-to-end NMS-free detection. ch (tuple): Tuple of channel sizes from backbone feature maps. rr r*c 3K|]P}tjt|dtdtjjdRywr:)r/r0rr1nkrs r7r8z Pose.__init__..Grr?N) rArB kpt_shaper2rIr/rKrrQrRrr6r<r3r2rUrVrrWs` @r7rBz Pose.__init__8s Wgr2"A,1- A!TWW %== wtv ww #}}TXX6D  rXcZt|j|j|jS)rr\r] pose_headrr_s r7r`z Pose.one2manyKrrXcZt|j|j|jS)rbr6rr_s r7rcz Pose.one2onePrrXcxt||}tj||j |dgdS)zUDecode predicted bounding boxes and class probabilities, concatenated with keypoints.kptsr rm)rAr~rFrt kpts_decoders r7r~zPose._inferenceUs7"1%yy%!1!1!F)!<=1EErXc t||||}|s|djd}tjt |j Dcgc]+}||||j||jd-c}d|d<|Scc}w)VConcatenates and returns predicted bounding boxes, class probabilities, and keypoints.rrlr{r:) rAryrsrFrtrurDrvr2) r6r4r\r]r7rrwrxrWs r7ryzPose.forward_headZs$Q(;  1AB!IIY^_c_f_fYg&hTU|y|AaD'9'>'>r477B'O&hjklE&M 'ircx|jd|j|jgd\}}}|j||j\}}}|j d|j ddd}|j d|j dd|j}tj||||gdS)aPost-process YOLO model predictions. Args: preds (torch.Tensor): Raw predictions with shape (batch_size, num_anchors, 4 + nc + nk) with last dimension format [x1, y1, x2, y2, class_probs, keypoints]. Returns: (torch.Tensor): Processed predictions with shape (batch_size, min(max_det, num_anchors), 6 + self.nk) and last dimension format [x1, y1, x2, y2, max_class_prob, class_index, keypoints]. r*rlrmr r) rr<r2rrrrrFrt)r6rrprqr:rrs r7rzPose.postprocessds$kk1dggtww*?RkHvt // Ec #**Q1*= >{{q 1a(A{Byy%t4"==rXc.dx|_x|_|_yrr r_s r7rz Pose.fuseur rXc4|jd}|jd}|jr|j|g|jd}|ddddddfdz|jdz z|j z}|dk(r2t j||ddddddfjfd}|j||jdS|j}|dk(rEtr|dddd|fjn$|dddd|fj|dddd|f<|dddd|fdz|jddz z|j z|dddd|f<|dddd|fdz|jddz z|j z|dddd|f<|S) "Decode keypoints from predictions.r rrlNr{rrr. r3rsrrvrrrFrtrr2clonersigmoid_r6r:ndimrwrrs r7r;zPose.kpts_decodeys~~a  ZZ] ;; "2t~~2r2A1a!8s"dllS&89T\\IAqyIIq!Aq!A#I,"6"6"891=66"dggr* * AqyaDjM**,$%aDjM$9$9$;AaDjMq!'T'z]S0DLLOc4IJdllZAaDjMq!'T'z]S0DLLOc4IJdllZAaDjMHrXr)r.r+Frr<rr3rrVrr) r4rr\rr]rr7rrrrrr:rrr)rrrrrBrr`rcr~ryrrr;rrs@r7r!r!#s{(7&NNffF #/>JYfu >".rXr!c~eZdZdZdd fd ZedZedZ d dZd fd Z d dZ xZ S) Pose26a!YOLO26 Pose head for keypoints models. This class extends the Pose head with normalizing flow for keypoint prediction in pose estimation tasks. Attributes: kpt_shape (tuple): Number of keypoints and dimensions (2 for x,y or 3 for x,y,visible). nk (int): Total number of keypoint values. cv4 (nn.ModuleList): Convolution layers for keypoint prediction. Methods: forward: Perform forward pass through YOLO model and return predictions. kpts_decode: Decode keypoints from predictions. Examples: Create a pose detection head >>> pose = Pose26(nc=80, kpt_shape=(17, 3), ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> outputs = pose(x) cXt|||||t_t |ddz|d|ddzzt j fd|D_t j fd|D_|ddz_ t j fd|D_ |rmtjj_ tjj_tjj_yy) r0rr*r r{c 3vK|]0}tjt|dtd2yw)r.N)r/r0r)r3r4rs r7r8z"Pose26.__init__..s- \TUtAr1~tBA!O \s69c3`K|]%}tjjd'ywr N)r/r1r2r3_rr6s r7r8z"Pose26.__init__..s"%LAbiiDGGQ&?%L+.c3`K|]%}tjjd'ywrP)r/r1nk_sigmarQs r7r8z"Pose26.__init__..s"&S1ryyT]]A'F&SrSN)rArBr flow_modelrIr/rKrcv4_kptsrU cv4_sigmarQrRrone2one_cv4_kptsone2one_cv4_sigmar4s` @r7rBzPose26.__init__s Y"=!) A!Yq\Yq\A-=> ?== \Y[ \\ %L%LL !! q( &SPR&SS #}}TXX6D $(MM$--$@D !%)]]4>>%BD " rXct|j|j|j|j|j S)rr\r]r7 kpts_headkpts_sigma_head)r^rLrNrrWrXr_s r7r`zPose26.one2manys4XXXXhhmm NN   rXct|j|j|j|j|j S)rbr\)r^rSrTrrYrZr_s r7rczPose26.one2ones>%%%%&&++ 22   rXc vtj||||}||djd}t|jD cgc]} || || } } t j t|jD cgc]+} || | | j||jd-c} d|d<|jrat j t|jD cgc]+} || | | j||jd-c} d|d<|Scc} wcc} wcc} w)r=rrlr{r: kpts_sigma) r ryrsrurDrFrtrvr2r}rU) r6r4r\r]r7r]r^rrwrxfeaturess r7ryzPose26.forward_heads##D!Xx@  1AB49$''NCq ! QqT*CHC!II`efjfmfm`n&o[\|y|HQK'@'E'Eb$''SU'V&oqrsE&M}}&+iiZ_`d`g`gZhiUV'_Q' 499"dmmRPikl'l# D&ojsD,0D1/0D6cZt|dx|_x|_x|_|_yr)rArrWrXrVrZrs r7rz Pose26.fuses)  TXX XX4;QrXc|jd}|jd}|jr|j|g|jd}|ddddddf|jz|j z}|dk(r2t j||ddddddfjfd}|j||jdS|j}|dk(rEtr|dddd|fjn$|dddd|fj|dddd|f<|dddd|f|jdz|j z|dddd|f<|dddd|f|jdz|j z|dddd|f<|S)rAr rrlNr{r.rBrEs r7r;zPose26.kpts_decodes}~~a  ZZ] ;; "2t~~2r2A1a!8t||+t||;AqyIIq!Aq!A#I,"6"6"891=66"dggr* * AqyaDjM**,$%aDjM$9$9$;AaDjMq!'T'z]T\\!_< LAaDjMq!'T'z]T\\!_< LAaDjMHrXrGrI)r4rr\rr]rr7rr]rr^rrrrrJ) rrrrrBrr`rcryrr;rrs@r7rLrLs(C2     ""  #  # ) !*Y rXrLc2eZdZdZdZddfd ZddZxZS)raYOLO classification head, i.e. x(b,c1,20,20) to x(b,c2). This class implements a classification head that transforms feature maps into class predictions. Attributes: export (bool): Export mode flag. conv (Conv): Convolutional layer for feature transformation. pool (nn.AdaptiveAvgPool2d): Global average pooling layer. drop (nn.Dropout): Dropout layer for regularization. linear (nn.Linear): Linear layer for final classification. Methods: forward: Perform forward pass on input feature maps. Examples: Create a classification head >>> classify = Classify(c1=1024, c2=1000) >>> x = torch.randn(1, 1024, 20, 20) >>> output = classify(x) Fct|d}t|||||||_t j d|_t jdd|_t j|||_ y)a\Initialize YOLO classification head to transform input tensor from (b,c1,20,20) to (b,c2) shape. Args: c1 (int): Number of input channels. c2 (int): Number of output classes. k (int): Kernel size. s (int): Stride. p (int, optional): Padding. g (int): Groups. ir T)rinplaceN) rArBrconvr/AdaptiveAvgPool2dpoolDropoutdropLinearlinear) r6c1r5rsrgc_rWs r7rBzClassify.__init__sa  RAq!, ((+ JJd3 iiB' rXc Jt|trtj|d}|j |j |j |j|jd}|jr|S|jd}|jr|S||fS)z+Perform forward pass on input feature maps.r ) rlistrFrtrormrkrirr}softmaxr)r6r4rs r7rzClassify.forward.s| a  !QA KK $))DIIaL"9"A"A!"DE F ==H IIaLKKq+aV+rX)r r Nr ) rprr5rrrrqrrz int | Nonerrr)r4z!list[torch.Tensor] | torch.Tensorrtorch.Tensor | tuple)rrrrrrBrrrs@r7rrs*F($,rXrcVeZdZdZ d dfd ZddZdZxZS) WorldDetectaHead for integrating YOLO detection models with semantic understanding from text embeddings. This class extends the standard Detect head to incorporate text embeddings for enhanced semantic understanding in object detection tasks. Attributes: cv3 (nn.ModuleList): Convolution layers for embedding features. cv4 (nn.ModuleList): Contrastive head layers for text-vision alignment. Methods: forward: Concatenate and return predicted bounding boxes and class probabilities. bias_init: Initialize detection head biases. Examples: Create a WorldDetect head >>> world_detect = WorldDetect(nc=80, embed=512, with_bn=False, ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> text = torch.randn(1, 80, 512) >>> outputs = world_detect(x, text) ct|||||t|dt|jdt j fd|D|_t j fd|D|_y)Initialize YOLO detection layer with nc classes and layer channels ch. Args: nc (int): Number of classes. embed (int): Embedding dimension. with_bn (bool): Whether to use batch normalization in contrastive head. reg_max (int): Maximum number of DFL channels. end2end (bool): Whether to use end-to-end NMS-free detection. ch (tuple): Tuple of channel sizes from backbone feature maps. )r2rUrVrr,c 3K|]F}tjt|dtdtjdHywr:r/r0rr1r3r4r>embeds r7r8z'WorldDetect.__init__..dsB umntAr1~tBAPRPYPYZ\^cefPg!h uA Ac3LK|]}r tn tywrrrr3rRrwith_bns r7r8z'WorldDetect.__init__..e" h`aW!25!9/J[![ h!$N) rArBrIrJr<r/rKrNr r6r<rrr2rUrVr>rWs `` @r7rBzWorldDetect.__init__Osd& Wg"E ADGGS) *== urt uu== heg hhrXc |Dcgc]}|j}}t|jD]]}tj|j ||||j ||j||||fd||<_|j|jdzz|_ |djd}tj|Dcgc]}|j||jd!c}d}|j|jdz|jfd\}} t|| |} |jr| S|j!| } |j"r| S| | fScc}wcc}w)zHConcatenate and return predicted bounding boxes and class probabilities.r r*rrlr{ro)rCrurDrFrtrLrrNr<r2rErsrvrr^r}r~r) r6r4textrrrrxrwx_catrprqrrs r7rzWorldDetect.forwardgsJ&'(((tww [A99kdhhqk!A$/!XXa[1=NPT1UVXYZAaD [''DLL1,, qTZZ] a@2772tww3@!D T\\A%5tww$?C v5u= ==L OOE "KKq/aZ/) As E2$E7c|}t|j|j|jD]"\}}}d|djj dd$y)r?rlN)rrLrNrHrr)r6mrrrqs r7rzWorldDetect.bias_initvsI 155!%%2 %GAq!!$AbEJJOOA  %rXrFr+Fr) r<rrrrrr2rrUrrVr)r4rrrrzdict[str, torch.Tensor] | tuple)rrrrrBrrrrs@r7ryry9sl.i ii i  i  i i0 0%rXryc@eZdZdZddfd ZeddZddZxZS) LRPCHeadaXLightweight Region Proposal and Classification Head for efficient object detection. This head combines region proposal filtering with classification to enable efficient detection with dynamic vocabulary support. Attributes: vocab (nn.Module): Vocabulary/classification layer. pf (nn.Module): Proposal filter module. loc (nn.Module): Localization module. enabled (bool): Whether the head is enabled. Methods: conv2linear: Convert a 1x1 convolutional layer to a linear layer. forward: Process classification and localization features to generate detection proposals. Examples: Create an LRPC head >>> vocab = nn.Conv2d(256, 80, 1) >>> pf = nn.Conv2d(256, 1, 1) >>> loc = nn.Conv2d(256, 4, 1) >>> head = LRPCHead(vocab, pf, loc, enabled=True) ct||r|j|n||_||_||_||_y)aWInitialize LRPCHead with vocabulary, proposal filter, and localization components. Args: vocab (nn.Module): Vocabulary/classification module. pf (nn.Module): Proposal filter module. loc (nn.Module): Localization module. enabled (bool): Whether to enable the head functionality. N)rArB conv2linearvocabpflocenabled)r6rrrrrWs r7rBzLRPCHead.__init__s; 07T%%e,U  rXcxt|tjr|jdk(sJtj|j |j }|jj|j dj|j_ |jj|j_ |S)z4Convert a 1x1 convolutional layer to a linear layer.)r r rl) rr/r1 kernel_sizern in_channels out_channelsweightrvrr)riros r7rzLRPCHead.conv2linears$ *t/?/?6/III4++T->->?![[--d.?.?DII 99>>  rXc|jr|j|djd}|j|kD}|jdj dd}|j |r |dd|fn!||j djz}|j||j dd|fS|j |}|j|}||jdtj|jd|jdz|jtjfS) zQProcess classification and localization features to generate detection proposals.)rrrr{rlNr.)devicedtype)rrrrrrrrrrFonesrsrr)r6cls_featloc_featrpf_scoremasks r7rzLRPCHead.forwards <<wwx(.66q9H##%,D''*44R>!,x~~a/@@`e`j`jk rXr)r nn.Modulerrrrrr)riz nn.Conv2drz nn.Linear)rrrrrrrztuple[tuple, torch.Tensor]) rrrrrB staticmethodrrrrs@r7rrs&. rXrceZdZdZdZ d dfd ZedddZddZddZ ddZ dfd Z dd Z fd Z ed Zed Zd ZdZxZS)r$aHead for integrating YOLO detection models with semantic understanding from text embeddings. This class extends the standard Detect head to support text-guided detection with enhanced semantic understanding through text embeddings and visual prompt embeddings. Attributes: is_fused (bool): Whether the model is fused for inference. cv3 (nn.ModuleList): Convolution layers for embedding features. cv4 (nn.ModuleList): Contrastive head layers for text-vision alignment. reprta (Residual): Residual block for text prompt embeddings. savpe (SAVPE): Spatial-aware visual prompt embeddings module. embed (int): Embedding dimension. Methods: fuse: Fuse text features with model weights for efficient inference. get_tpe: Get text prompt embeddings with normalization. get_vpe: Get visual prompt embeddings with spatial awareness. forward_lrpc: Process features with fused text embeddings for prompt-free model. forward: Process features with class prompt embeddings to generate detections. bias_init: Initialize biases for detection heads. Examples: Create a YOLOEDetect head >>> yoloe_detect = YOLOEDetect(nc=80, embed=512, with_bn=True, ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> cls_pe = torch.randn(1, 80, 512) >>> outputs = yoloe_detect(x, cls_pe) Fclt|||||t|dt|jdksJsJ|j rt jfd|Dnt jfd|D|_t jfd|D|_ |rHtj|j|_ tj|j|_ tt|_t#||_|_y)r{rr,c 3K|]F}tjt|dtdtjdHywr:r}r~s r7r8z'YOLOEDetect.__init__..s?nfg"--QARQSUW\^_I`anrc 3K|]}tjtjt||dt|dtjtdtdtjdywr:)r/r0rrr1r~s r7r8z'YOLOEDetect.__init__..sq   MM&Aq/42q>BMM&R"3T"b!_EIIb%+sB B c3LK|]}r tn tywrrrs r7r8z'YOLOEDetect.__init__..rrN)rArBrIrJr<rMr/rKrNrrQrRrTrrrreprtarsavperrs `` @r7rBzYOLOEDetect.__init__s Wgr2 ADGGS) *U{{w{{ MMnkmn n   == heg hh #}}TXX6D #}}TXX6D y67 2r5)  rXc|dx|_x|_|_y|jry|jrJ|j t jjd}|jr3|jr'|j||j|j|jr'|j||j|j|` tj|_ d|_y)>Fuse text features with model weights for efficient inference.NrT)rLrNris_fusedr}torFfloat32squeeze_fuse_tprUrTrrr/rO)r6 txt_featss r7rzYOLOEDetect.fuses  -1 1DH 1tx$(  == ==  LL/77: 88 MM)TXXtxx 8 << MM)T%5%5t7G7G H Kkkm  rXcHt||D]\}}t|tjsJt|tsJ|d}t|tj sJ|j }|j}|j} ||jz} t|| }|jjjdjd} |jj} | | z} | | jdjdzjd} t!j"| |z}tj |j$| j&ddj)dj+|jj,}|jjj/| jdjd|jjj/| |z||d<|j1y)zGFuse text prompt embeddings with model weights for efficient inference.rlrr )rFN)rrr/r0rr1 logit_scalernormexpr rrrreshaperrF ones_likerrsrequires_grad_rrcopy_r)r6rr]bn_headcls_hbn_hrirrrtwrb1b2s r7rzYOLOEDetect._fuse_tpsx1! KE4eR]]3 33d$56 669DdBII. ..**K99D99DKOO--A.tT:D   ((,44R8A AAAaiim--b11::2>B$t+B $$GGAJ !  &DKK&&'  KK   " "1;;r?#<#5Ia4O&OPAFFKKN  Q << )DLL,dll:.F UgHhi! U 9Aq!&)" "%(" "!%!dgg+t{{1~9MRS8S*S!T A  U rXr)r<rrrrrrVrrrr)rrr]rrrrr)rtorch.Tensor | Nonerr)r4rrrrrr4rrrw)rrrrrrBr rrrrrrrrr`rcryrrrs@r7r$r$s:Hmo$$#&$7;$di$L$#JS" 00UUmm =UrXr$ceZdZdZ d d fd ZedZedZd dZdfd Z dfd Z dfd Z dd Z ddfd Z xZS)r%aVYOLO segmentation head with text embedding capabilities. This class extends YOLOEDetect to include mask prediction capabilities for instance segmentation tasks with text-guided semantic understanding. Attributes: nm (int): Number of masks. npr (int): Number of protos. proto (Proto): Prototype generation module. cv5 (nn.ModuleList): Convolution layers for mask coefficients. Methods: forward: Return model outputs and mask coefficients. Examples: Create a YOLOESegment head >>> yoloe_segment = YOLOESegment(nc=80, nm=32, npr=256, embed=512, with_bn=True, ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> text = torch.randn(1, 80, 512) >>> outputs = yoloe_segment(x, text) c n t |||||||_|_t |djj_t |ddzj tj fd|D_ |r%tjj_ yy)a7Initialize YOLOESegment with class count, mask parameters, and embedding dimensions. Args: nc (int): Number of classes. nm (int): Number of masks. npr (int): Number of protos. embed (int): Embedding dimension. with_bn (bool): Whether to use batch normalization in contrastive head. reg_max (int): Maximum number of DFL channels. end2end (bool): Whether to use end-to-end NMS-free detection. ch (tuple): Tuple of channel sizes from backbone feature maps. rr*c 3K|]P}tjt|dtdtjjdRywr:rr3r4c5r6s r7r8z(YOLOESegment.__init__..rr?N) rArBrrrrrIr/rKcv5rQrR one2one_cv5) r6r<rrrrr2rUrVrrWs ` @r7rBzYOLOESegment.__init__s. UGWgrB2a5$((DGG4 A!TWW %== wtv ww #}}TXX6D  rXcpt|j|j|j|jS)rZr\r]rr)r^rLrNrrr_s r7r`zYOLOESegment.one2manys(TXXDHH_c_g_ghhrXcpt|j|j|j|jS)rbr)r^rSrTrrr_s r7rczYOLOESegment.one2ones5%%%%&&!--   rXc 8ggg}}}|djd}|js |jn |j}|js |jn |j }|js |j n |j}t|jD]} || || } || || } t|j| tsJ|j| | | |jr|jsdn t|dd\} } }|j!| j#||j$dzd|j!| |j!|t'j(t|jD cgc]+} || || j#||j*d-c} d}t'j(|}t-t'j(|dt'j(|d|||jr|js||j/zn|d|f}|j1|}|jr"|j3|j5ddd }|jr|S||fScc} w) rrrrr*rlr{.)rprqrrrrr )rsrUrLrSrNrTrrrurDrrrrrrfrrvr2rFrtrr^rr~rr)r6r4rprqrrwrLrNrrxrrrrrmcrrs r7rzYOLOESegment.forward_lrpcs*!2ruv qTZZ]"lldhh0@0@"lldhh0@0@"lldhh0@0@tww As1vad|Hs1vad|HdiilH5 55*diil[[74QV;WOC LL"dllQ&6; < MM% LL  YYE$''NSqAqt ))"dggr:SUV W % ))E1%99VQ'15T\\R%))+-WYZ]_dZdWe   OOE " <<  1a!34AKKq/aZ/Ts0JcFt||}t|tr|dn|}|j |d}t|t r0|j r||dd<|j|dd<n||d<|jr|S|jr||fS|d|f|fSrrrs r7rzYOLOESegment.forwardrrXcZt||}tj||dgdSrrrs r7r~zYOLOESegment._inferencerrXc  t |||||}|s|djd}tjt |j Dcgc]+}||||j||jd-c}d|d<|Scc}wrr) r6r4r\r]rrrrwrxrWs r7ryzYOLOESegment.forward_heads$Q(.krr?N) r$rBrrrrrIr/rKrrQrRr) r6r<rrrrr2rUrVrs ` @r7rBzYOLOESegment26.__init__Ys T2ugwLR477B7 A!TWW %== wtv ww #}}TXX6D  rXctj||}t|tr|dn|}|j |Dcgc]}|j c}d}t|t r<|jr+t|ds||dd<|j |dd<n||d<|jr|S|jr||fS|d|f|fScc}w) rr F) return_semsegrr`rrcr) r$rrrrr|r^rUrgr}r)r6r4rrrrs r7rzYOLOESegment26.forwardos%%dA.(%8 g !4BBIIK4E J eT "||GD&$9-2j!'*,1LLNi )!&g ==L#';;Pgaj%5H%4PP5sCNrrr)rrrrrBrrrXr7rrAsf27 7 7 7  7  7 7,QrXrcneZdZdZdZgZejdZejdZ dZ dddddd d d d e jd ddddf dfd Z dddZedej ddf ddZddZ d d dZdZxZS)!r"aReal-Time Deformable Transformer Decoder (RTDETRDecoder) module for object detection. This decoder module utilizes Transformer architecture along with deformable convolutions to predict bounding boxes and class labels for objects in an image. It integrates features from multiple layers and runs through a series of Transformer decoder layers to output the final predictions. Attributes: export (bool): Export mode flag. hidden_dim (int): Dimension of hidden layers. nhead (int): Number of heads in multi-head attention. nl (int): Number of feature levels. nc (int): Number of classes. num_queries (int): Number of query points. num_decoder_layers (int): Number of decoder layers. input_proj (nn.ModuleList): Input projection layers for backbone features. decoder (DeformableTransformerDecoder): Transformer decoder module. denoising_class_embed (nn.Embedding): Class embeddings for denoising. num_denoising (int): Number of denoising queries. label_noise_ratio (float): Label noise ratio for training. box_noise_scale (float): Box noise scale for training. learnt_init_query (bool): Whether to learn initial query embeddings. tgt_embed (nn.Embedding): Target embeddings for queries. query_pos_head (MLP): Query position head. enc_output (nn.Sequential): Encoder output layers. enc_score_head (nn.Linear): Encoder score prediction head. enc_bbox_head (MLP): Encoder bbox prediction head. dec_score_head (nn.ModuleList): Decoder score prediction heads. dec_bbox_head (nn.ModuleList): Decoder bbox prediction heads. Methods: forward: Run forward pass and return bounding box and classification scores. Examples: Create an RTDETRDecoder >>> decoder = RTDETRDecoder(nc=80, ch=(512, 1024, 2048), hd=256, nq=300) >>> x = [torch.randn(1, 512, 64, 64), torch.randn(1, 1024, 32, 32), torch.randn(1, 2048, 16, 16)] >>> outputs = decoder(x) Frr)rirr(r*rrgrlr,rrc t||_||_t ||_||_||_||_tjfd|D|_ t||| | |j |}t||| |_tj||_| |_| |_||_||_|rtj||_t-ddzd|_tj0tj2tj4|_tj2||_t-dd|_tjt=|Dcgc]}tj2|c}|_tjt=|Dcgc]}t-ddc}|_ |jCycc}wcc}w)awInitialize the RTDETRDecoder module with the given parameters. Args: nc (int): Number of classes. ch (tuple): Channels in the backbone feature maps. hd (int): Dimension of hidden layers. nq (int): Number of query points. ndp (int): Number of decoder points. nh (int): Number of heads in multi-head attention. ndl (int): Number of decoder layers. d_ffn (int): Dimension of the feed-forward networks. dropout (float): Dropout rate. act (nn.Module): Activation function. eval_idx (int): Evaluation index. nd (int): Number of denoising. label_noise_ratio (float): Label noise ratio. box_noise_scale (float): Box noise scale. learnt_init_query (bool): Whether to learn initial query embeddings. c 3K|]D}tjtj|ddtjFyw)r F)rN)r/r0r1 BatchNorm2d)r3r4hds r7r8z)RTDETRDecoder.__init__..s9'wop bii2qu6UWYWeWefhWi(j'wsA A r*r{) num_layersr.N)"rArB hidden_dimnheadrCrDr< num_queriesnum_decoder_layersr/rK input_projrrdecoder Embeddingdenoising_class_embed num_denoisinglabel_noise_ratiobox_noise_scalelearnt_init_query tgt_embedrquery_pos_headr0rn LayerNorm enc_outputenc_score_head enc_bbox_headrudec_score_head dec_bbox_head_reset_parameters)r6r<rVrnqndpnhndld_ffndropoutacteval_idxndrrr decoder_layerrRrWs ` r7rBzRTDETRDecoder.__init__sL  b'"%--'wtv'ww :"b%RUW[W^W^`cd 3B sHU &(\\"b%9"!2."3 \\"b1DN!!QVRA>-- "b(92<<;KL iiB/ Rq9!mmc ,S1RYYr2->,ST]]RWX[R\+]QCBa,H+]^  -T+]s HH c zddlm}|j|\}}|||j|j|j j |j|j|j|j\}}}} |j||||\} } } } |j| | |||j|j|j|\}}||| | | f}|jr|St!j"|j%d|j%dj'fd}|j(r|S||fS)a!Run the forward pass of the module, returning bounding box and classification scores for the input. Args: x (list[torch.Tensor]): List of feature maps from the backbone. batch (dict, optional): Batch information for training. Returns: outputs (tuple | torch.Tensor): During training, returns a tuple of bounding boxes, scores, and other metadata. During inference, returns a tensor of shape (bs, 300, 4+nc) containing bounding boxes and class scores. r) get_cdn_group) attn_maskrl)ultralytics.models.utils.opsr%_get_encoder_inputr<rr rr rrr}_get_decoder_inputr rrrrFrtrrr)r6r4batchr%rrshapesdn_embeddn_bboxr&dn_metar refer_bbox enc_bboxes enc_scores dec_bboxes dec_scoresrs r7rzRTDETRDecoder.forwardsF ?//2 v1>  GG     & & - -     " "  MM 1 -'9g594K4KESY[cel4m1z:z"&             ". "  J  J G C ==H IIz))!,j.@.@.C.K.K.MNPR SKKq+aV+rXg?cpu{Gz?c.g}t|D]\}\}}tj|||} tj|||} trtj| | dntj| | \} } tj | | gd} tj ||g||}| jddz|z } tj| |||zd|zz}|jtj| |gdjd||zd tj|d }||kD|d |z kzjdd }tj|d |z z }|j|td }||fS)aCGenerate anchor bounding boxes for given shapes with specific grid size and validate them. Args: shapes (list): List of feature map shapes. grid_size (float, optional): Base size of grid cells. dtype (torch.dtype, optional): Data type for tensors. device (str, optional): Device to create tensors on. eps (float, optional): Small value for numerical stability. Returns: anchors (torch.Tensor): Generated anchor boxes. valid_mask (torch.Tensor): Valid mask for anchors. )endrrij)indexingrlrrrrrr*r T)rinf)rrFrr meshgridstacktensorrrrrtrvallr masked_fillr)r+ grid_sizerrepsrrxhrsysxgrid_ygrid_xgrid_xyvalid_WHwh valid_masks r7_generate_anchorszRTDETRDecoder._generate_anchors-s~*"6* LIAv1!5@B!5@BFPU^^BTBV[VdVdegikVlNFFkk66"2B7G||QF%GH((+c1X=GfE QUXZ[U[\B NN599gr]B7<DAq LLa00Aq9 : MM1a& !  " %#f} CsB,c|jd}|js|j|k7r<|j||j|j \|_|_||_|j|j|z}|j|}tj|jdj|jdjj!d}tj"||jj%dj'd|jj!d} || |fj!||jd} |j dd|fj!||jd} |j)| | z} | j+} |tj,|| gd} || |fj!||jd}|j.r6|j0j2j%dj'|ddn| }|j4r,| j7} |j.s|j7}|tj,||gd}|| | |fS)aGenerate and prepare the input required for the decoder from the provided features and shapes. Args: feats (torch.Tensor): Processed features from encoder. shapes (list): List of feature map shapes. dn_embed (torch.Tensor, optional): Denoising embeddings. dn_bbox (torch.Tensor, optional): Denoising bounding boxes. Returns: embeddings (torch.Tensor): Query embeddings for decoder. refer_bbox (torch.Tensor): Reference bounding boxes. enc_bboxes (torch.Tensor): Encoded bounding boxes. enc_scores (torch.Tensor): Encoded scores. rr:rlr rm)r7rN)rsrr+rLrrrrKrrrFrrIvaluesrrrvrrrrrrtrrrr}r|)r6rrr+r,r-rwrbenc_outputs_scorestopk_ind batch_indtop_k_features top_k_anchorsr/r0r1 embeddingss r7r)z RTDETRDecoder._get_decoder_inputns>*[[^ <<4;;&0,0,B,B6QVQ\Q\ejeqeq,B,r )DL$/ DK??4??U#:;!00:::044R8??AQAQWXYaaffgijLLRx~~>HHLSSTUW[WgWghmmnpq ")X"56;;B@P@PRTU Q[166r4;K;KRP ''7-G '')  GZ#8!>r1aHhv ==#**,J))'..0  Hj#91=J:z:==rXctddz |jz}t|jj|t|j j djdt|j j djdt|j|jD]a\}}t|j|t|j djdt|j djdct|jdt|jdj|jrt|jjt|j j djt|j j dj|j"D]}t|djy)zhInitialize or reset the parameters of the model's various components with predefined weights and biases.r5rrlrgrr N)rr<rrrrlayersrrrrrrrrrrr )r6bias_clscls_reg_layers r7rzRTDETRDecoder._reset_parameterss't,r1DGG; $%%**H5$$$++B/66<$$$++B/44c:d1143E3EF 1JD$ dii * dkk"o,,c 2 dkk"o**C 0  1 DOOA&'*112  ! ! DNN11 2++2215<<=++2215<<=__ -E E!HOO , -rX)r<rrVrrrrrrrrrrrrrrrr rr!rr"rrrrrrrr)r4rr*z dict | Nonerztuple | torch.Tensor) r+list[list[int]]rArrz torch.dtyperstrrBrrz!tuple[torch.Tensor, torch.Tensor])r4rrz$tuple[torch.Tensor, list[list[int]]]r) rrrr+r]r,rr-rrz=tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor])rrrrrr+rFrrrKrr/ReLUrBrrrrLr(r)rrrs@r7r"r"s%NF Fekk!nGQJG% #&!$"'#L! L! L!  L!  L!  L! L!L!L!L!L!L! L!!L! !L!" #L!\/,b "]] $#$#$#$# $#  $# + $#$#L<)-'+ 9>9> 9>& 9> % 9> G 9>v-rXr"c0eZdZdZdZddfd ZdZxZS)r&av10 Detection head from https://arxiv.org/pdf/2405.14458. This class implements the YOLOv10 detection head with dual-assignment training and consistent dual predictions for improved efficiency and performance. Attributes: end2end (bool): End-to-end detection mode. max_det (int): Maximum number of detections. cv3 (nn.ModuleList): Light classification head layers. one2one_cv3 (nn.ModuleList): One-to-one classification head layers. Methods: __init__: Initialize the v10Detect object with specified number of classes and input channels. forward: Perform forward pass of the v10Detect module. bias_init: Initialize biases of the Detect module. fuse: Remove the one2many head for inference optimization. Examples: Create a v10Detect head >>> v10_detect = v10Detect(nc=80, ch=(256, 512, 1024)) >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)] >>> outputs = v10_detect(x) Tct|d|t|dtjdt j fd|D_tjj_ y)zInitialize the v10Detect object with the specified number of classes and input channels. Args: nc (int): Number of classes. ch (tuple): Tuple of channel sizes from backbone feature maps. T)rUrVrr,c 3:K|]}tjtjt||d|t|dtjtdtdtjjdyw)r.)rrr Nr;r=s r7r8z%v10Detect.__init__..sz!  MM d1aa0$q"a.A d2r13T"b!_E "dggq) ! sBBN) rArBrIrJr<r/rKrNrQrRrT)r6r<rVr>rWs` @r7rBzv10Detect.__init__sj Tb1 ADGGS) *==!  !   ==2rXc dx|_|_yrrr_s r7rzv10Detect.fuserrX)rrr)rrrrrUrBrrrs@r7r&r&s0G3(#rXr&)=r __future__rrQrrFtorch.nnr/torch.nn.functional functionalr torch.nn.initrrultralytics.utilsrultralytics.utils.talrrr ultralytics.utils.torch_utilsr r r blockrrrrrrrrrrirr transformerrrrutilsrr__all__Moduler r#rrr,r!rLrryrr$r%rr"r&rrXr7rqs1" 4)DD\\ooo]]3 ua#RYYa#He.fe.P88v].&].@CDi6iXrTrj2,ryy2,jC%&C%N?ryy?DVU&VUrc;cL<Q\<Q~-BII-D 1#1#rX