/jL2dZddlmZddlZddlZddlZddlmZddlmcm 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,Gddej-Z.Gdde.Z/Gdde/Z0Gdde.Z1Gdde1Z2Gdde.Z3Gdde3Z4Gddej-Z5Gdde.Z6Gd d!ej-Z7Gd"d#e.Z8Gd$d%e8Z9Gd&d'e9Z:Gd(d)ej-Z;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,rPncintchtuplecbt|_t|_|_|jdzz_tjj_ td|ddzjdzft|dtjdctj fd|D_jr!tj fd|Dn tj fd|D_jdkrt#jntj_|r>t)jj_t)jj_d Sd S) 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. r*rdc 3K|]T}tjt|dtdtjdjzdVUdS)r1r N)nn SequentialrConv2dreg_max).0xc2selfs `/home/longshao/multi-rider-rag/.venv/lib/python3.11/site-packages/ultralytics/nn/modules/head.py z"Detect.__init__..^sl! ! cdBM$q"a..$r2q//29RT\IY[\;];] ^ ^! ! ! ! ! ! c 3K|]Q}tjt|dtdtjjdVRdSr4r Nr5r6rr7r,r9r:c3r<s r=r>z"Detect.__init__..bsZpphi"-QARQSUW[W^`aIbIbccppppppr?c 3:K|]}tjtjt||dt|dtjtdtdtjjdVdSrA)r5r6rrr7r,rCs r=r>z"Detect.__init__..ds   M&Aq//42q>>BBM&R"3"3T"b!__EEIb$'1--r?r N)super__init__r,lennlr8notorchzerosstridemaxminr5 ModuleListcv2legacycv3rIdentitydflcopydeepcopy one2one_cv2 one2one_cv3)r<r,r8end2endr.r;rD __class__s` @@r=rGzDetect.__init__Ns b'' t|a''k$'** b"Q%1*dlQ&6788#beSRUEVEV:W:WB=! ! ! ! ! hj! ! !    { BMpppppmoppp p p p   )- q(8(83t|$$$bkmm  7#}TX66D #}TX66D    7 7r?c8t|j|jS)YReturns the one-to-many head components, here for v3/v5/v8/v9/v11 backward compatibility.box_headcls_head)dictrQrSr<s r=one2manyzDetect.one2manyssTX9999r?c8t|j|jS)'Returns the one-to-one head components.r^)rarXrYrbs r=one2onezDetect.one2onexsT-8HIIIIr?cDt|ddot|dS)zKChecks if the model has one2one for v3/v5/v8/v9/v11 backward compatibility._end2endTrf)getattrhasattrrbs r=rZzDetect.end2end}s%tZ..K743K3KKr?c||_dS)z'Override the end-to-end detection mode.N)rh)r<values r=rZzDetect.end2ends r?r:list[torch.Tensor]r_torch.nn.Moduler`returndict[str, torch.Tensor]cVtSdjdtjfdt jDd}tjfdt jDd}t||S)JConcatenates and returns predicted bounding boxes and class probabilities.Nrcxg|]6}||djzd7Sr1viewr8r9ir_bsr<r:s r= z'Detect.forward_head..EdddPQ;8A;qt,,11"a$,6FKKdddr?rudimcrg|]3}||jd4Sru)rwr,)r9ryrzr`r<r:s r=r{z'Detect.forward_head..s?\\\KHQK!--222twCC\\\r?boxesscoresfeats)rashaperKcatrangerI)r<r:r_r`rrrzs```` @r= forward_headzDetect.forward_heads  x/66M qTZ] dddddddUZ[_[bUcUcdddjlmmm\\\\\\\USWSZ^^\\\bdeee%a8888r?Udict[str, torch.Tensor] | torch.Tensor | tuple[torch.Tensor, dict[str, torch.Tensor]]cT|j|fi|j}|jr$d|D}|j|fi|j}||d}|jr|S||jr|dn|}|jr*||ddd}|jr|n||fS)rrc6g|]}|Sr+detachr9xis r=r{z"Detect.forward..s 000 000r?)rcrfrfrr ) rrcrZrftraining _inference postprocesspermuteexport)r<r:predsx_detachrfys r=forwardzDetect.forwards"!!55t}55 < <00a000H'd'AADLAAG!&7;;E = L OO GE),,% H H < 5  1a!3!344AK/qqaZ/r? torch.Tensorc||}tj||dfdS)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. rr )_get_decode_boxesrKrsigmoid)r<r:dboxs r=rzDetect._inferences>%%a((y$( 3 3 5 56:::r?cb|ddj}|js |j|kr:dt|d|jdD\|_|_||_|||d|jd|jz}|S)z/Get decoded boxes based on anchors and strides.rrc3BK|]}|ddVdS)rr N) transpose)r9as r=r>z+Detect._get_decode_boxes..s0)p)p!++a*;*;)p)p)p)p)p)pr??r) rdynamicr rManchorsstrides decode_bboxesrU unsqueeze)r<r:rrs r=rzDetect._get_decode_boxess' 1 # < 4:..)p)p\RST[R\^b^iknEoEo)p)p)p &DL$,DJ!!$((1W:"6"6 8N8Nq8Q8QRRUYUaa r?ctt|jd|jdD]i\}\}}d|djjdd<t jd|jz d|j|z dzz |djjd|j<j|j rtt|j d|j dD]k\}\}}d|djjdd<t jd|jz d|j|z dzz |djjd|j<jdSdS) BInitialize Detect() biases, WARNING: requires stride availability.r_r`@ruNr enumerateziprcbiasdatamathlogr,rMrZrf)r<ryrbs r= bias_initzDetect.bias_initsH"3t}Z'@$-PZB[#\#\]]  IAv1!$AbEJOAAA )-DG sT[^399**AbEJOIdgI & & < &s4< +CT\R\E]'^'^__   6Aq%(" "-1XK3Q#7A"==.."  $' **    r?TbboxesrxywhboolcHt|||o|j o|j dS)z'Decode bounding boxes from predictions.r )rr~)rrZxyxy)r<rrrs r=rzDetect.decode_bboxess8  >y%.B7777r?rr/tuple[torch.Tensor, torch.Tensor, torch.Tensor]c|j\}}}|jr|nt||}|jrO|dd\}}||d\}}|d|}|||fS|dd|dd} |d| dd|}| d|\}} | tj |d| |zf} |d| |zd | 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. ruT)r~keepdimr r}rr).N) rrrO agnostic_nmsrNtopkrrrflattenrKarangefloat) r<rr batch_sizerr,klabelsindices ori_indexrrs r=rzDetect.get_topk_indexsW#), GR{ =GGGW(=(=   +#ZZBZ==NFF$kk!k33OFG]]1g..F67* *JJ2J&&q)..q11!4>>rBB 1I,<,>> 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) r) r*Fr+r,r-nmnprr.r/ct|||||_|_t |djj_t |ddzjtjfd|D_ |r tj j _ dSdS)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. rr1c 3K|]Q}tjt|dtdtjjdVRdSrAr5r6rr7rr9r:c4r<s r=r>z#Segment.__init__..$\ w woptAr1~~tBAPRPYZ\^b^eghPiPi!j!j w w w w w wr?N) rFrGrrrprotorNr5rPcv4rVrW one2one_cv4) r<r,rrr8rZr.rr[s ` @r=rGzSegment.__init__s Wgr2222a5$(DG44 A!TW % %= w w w w wtv w w www  7#}TX66D    7 7r?cDt|j|j|jS)IReturns the one-to-many head components, here for backward compatibility.r_r` mask_headrarQrSrrbs r=rczSegment.one2many(TXDHMMMMr?cDt|j|j|jS)rerrarXrYrrbs r=rfzSegment.one2one-#T-8HTXTdeeeer?r:rmro4tuple | list[torch.Tensor] | dict[str, torch.Tensor]ct|}t|tr|dn|}||d}t|t r5|jr)||dd<||dd<n||d<|jr|S|j r||fn |d|f|fSgReturn model outputs and mask coefficients if training, otherwise return outputs and mask coefficients.r rrcrrf rFr isinstancer/rrarZrrrr<r:outputsrrr[s r=rzSegment.forward2''//!$$(%88E g 1Q4   eT " " '| '-2j!'*,1LLNNi ))!&g = L#';Pgaj%5H%4PPr?rprct|}tj||dgdSz]Decode predicted bounding boxes and class probabilities, concatenated with mask coefficients.mask_coefficientr r}rFrrKrr<r:rr[s r=rzSegment._inferenceA:""1%%y%#5!67Q????r?r_rnr`rct||}Ldjdtjfdt jDd|d<|S)^Concatenates and returns predicted bounding boxes, class probabilities, and mask coefficients.Nrcrg|]3}||jd4Srrwrr9ryrzrr<r:s r=r{z(Segment.forward_head..MA2t2t2t`a<9Q<!3E3E3J3J2twXZ3[3[2t2t2tr?rr rFrrrKrrrI)r<r:r_r`rrrzr[s`` ` @r=rzSegment.forward_headFs$$Q(;;  1AB(- 2t2t2t2t2t2t2tejkokreses2t2t2tvw(x(xE$ % r?rc~|d|j|jgd\}}}|||j\}}}|d|ddd}|d|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]. r1rur}r r rr,rrrrrrKrr<rrrr rrs r=rzSegment.postprocessP+0++q$'476KQS+*T*T'v' // EEc #**Q1*=*= >>+22q 1aQUQX@Y@Y2ZZy%/?@bIIIIr?rc0dx|_x|_|_dSrrQrSrrbs r=rz Segment.fusea)---48dhhhr?r)rrr*Fr+r,r-rr-rr-r.r/r:rmrorr) r:rmr_rnr`rnrrnrorprr)rrrrrGrrcrfrrrrrrrs@r=r#r#s(7777777*NNXNffXf Q Q Q Q Q Q@@@@@@ JJJJ"........r?r#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) r)rrr*Fr+r,r-rrr.r/ct||||||t||j|j||_dS)rN)rFrGrrrr)r<r,rrr8rZr.r[s r=rGzSegment26.__init__{sD Rgw;;;R47B77 r?r:rmrorct||}t|tr|dn|}||}t|t rc|jrW||dd<t|trtd|Dn||dd<n||d<|jr|S|j r||fn |d|f|fS)rr rcrc3>K|]}|VdSNr)r9ps r=r>z$Segment26.forward..s*44!((**444444r?rfr) r rrr/rrarZrrrr<r:rrrs r=rzSegment26.forwards..q))(%88E g 1  eT " " '| '-2j!'*8B5%8P8PdE44e444444V[VbVbVdVdi ))"'g = L#';Pgaj%5H%4PPr?rctt|jdr|jdSdS)zSRemove the one2many head and extra part of proto module for inference optimization.rN)rFrrjrr<r[s r=rzSegment26.fusesJ   4:v & &  JOO       r?rr r!r)rrrrrGrrrrs@r=r#r#fs( 8 8 8 8 8 8 8QQQQ"r?r#ceZdZdZd!d"fd Zed ZedZd#fd Zd$fd Z d%dZ d&dZ d'd 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) r)r r*Fr+r,r-ner.r/c.t|||||_t|ddzjt jfd|D_|r tjj_ dSdS)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. rr1c 3K|]Q}tjt|dtdtjjdVRdSrA)r5r6rr7r-rs r=r>zOBB.__init__..rr?N) rFrGr-rNr5rPrrVrWr)r<r,r-r8rZr.rr[s` @r=rGz OBB.__init__s Wgr222 A!TW % %= w w w w wtv w w www  7#}TX66D    7 7r?cDt|j|j|jS)rr_r` angle_headrrbs r=rcz OBB.one2manysTXTXNNNNr?cDt|j|j|jS)rer1rrbs r=rfz OBB.one2ones#T-8HUYUeffffr?r:rprorc|d|_t|}tj||dgdS)z[Decode predicted bounding boxes and class probabilities, concatenated with rotation angles.angler r})r5rFrrKrrs r=rzOBB._inferencesEwZ ""1%%y%7,!4444r?rmr_rnr`r2c>t||}rdjdtjfdt jDd}|dz tj z}||d<|S)zSConcatenates and returns predicted bounding boxes, class probabilities, and angles.Nrcrg|]3}||jd4Srrwr-r9ryr2rzr<r:s r=r{z$OBB.forward_head..?SSSqAqt$$))"dgr::SSSr?rg?r5) rFrrrKrrrIrrpi) r<r:r_r`r2rr5rzr[s `` ` @r=rzOBB.forward_heads$$Q(;;  !1ABISSSSSSSE$'NNSSSUVE]]__t+tw6E"E'N r?rrc2t||j|dS)zDecode rotated bounding boxes.r r})rr5)r<rrs r=rzOBB.decode_bboxessW!<<<> #**Q47*C*C DDy%u52>>>>r?rc0dx|_x|_|_dSrrrbs r=rzOBB.fuserr?)r)r r*Fr+)r,r-r-r-r.r/r r:rmr_rnr`rnr2rnrorp)rrrrrorrr)rrrrrGrrcrfrrrrrrrs@r=rrs(7777777$OOXOggXg555555      ====????"........r?rceZdZdZd d Zd S) 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) r:rmr_rnr`r2rorpct||}Ndjdtjfdt jDd}||d<|S)zWConcatenates and returns predicted bounding boxes, class probabilities, and raw angles.Nrcrg|]3}||jd4Srr8r9s r=r{z&OBB26.forward_head..r:r?rr5)r rrrKrrrI)r<r:r_r`r2rr5rzs`` ` @r=rzOBB26.forward_heads##D!Xx@@  !1ABISSSSSSSE$'NNSSSUVE#E'N r?Nr?)rrrrrr+r?r=rArAs2&      r?rAceZdZdZd d!fd Zed ZedZd"fd Zd#fd Z d$dZ d%dZ d&dZ 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) r)r4r*Fr+r,r- kpt_shaper/r.cZt|||||_|d|dz_t |ddzjt jfd|D_|r tj j_ dSdS)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 r1c 3K|]Q}tjt|dtdtjjdVRdSrA)r5r6rr7nkrs r=r>z Pose.__init__..Grr?N) rFrGrGrKrNr5rPrrVrWrr<r,rGr8rZr.rr[s` @r=rGz Pose.__init__8s Wgr222"A,1- A!TW % %= w w w w wtv w w www  7#}TX66D    7 7r?cDt|j|j|jS)rr_r` pose_headrrbs r=rcz Pose.one2manyKrr?cDt|j|j|jS)rerNrrbs r=rfz Pose.one2onePrr?r:rprorct|}tj|||dgdS)zUDecode predicted bounding boxes and class probabilities, concatenated with keypoints.kptsr r})rFrrKr kpts_decoders r=rzPose._inferenceUsF""1%%y%!1!1!F)!.as@&h&h&hTU|y|AaD'9'9'>'>r47B'O'O&h&h&hr?rrRr)r<r:r_r`rOrrzr[s`` ` @r=rzPose.forward_headZs$$Q(;;  1AB!I&h&h&h&h&h&h&hY^_c_fYgYg&h&h&hjkllE&M r?rc~|d|j|jgd\}}}|||j\}}}|d|ddd}|d|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]. r1rur}r r) rr,rKrrrrrKr)r<rrrrRrrs r=rzPose.postprocessds$kk1dgtw*?RkHHvt // EEc #**Q1*=*= >>{{q 1a(A(A{BBy%t4"====r?rc0dx|_x|_|_dSrrrbs r=rz Pose.fuseurr?rRc$|jd}|jd}|jr|j|g|jdR}|ddddddfdz|jdz z|jz}|dkr8t j||ddddddffd}|||j dS| }|dkrTtr"|dddd|f n+|dddd|f|dddd|f<|dddd|fdz|jddz z|jz|dddd|f<|dddd|fdz|jddz z|jz|dddd|f<|S) "Decode keypoints from predictions.r rruNrrrr4 rGrrrwrrrKrrrKclonersigmoid_r<rRndimrzrrs r=rSzPose.kpts_decodeys~a  Z] ;  "2t~2r222A111aaa!8s"dlS&89T\IAqyyIq!AAAqqq!A#I,"6"6"8"891==66"dgr** * Aqyy<aaaDjM**,,,,$%aaaDjM$9$9$;$;AaaaDjMqqq!'T'z]S0DLOc4IJdlZAaaaDjMqqq!'T'z]S0DLOc4IJdlZAaaaDjMHr?r)rEr*Fr+r,r-rGr/r.r/r) r:rmr_rnr`rnrOrnrorprrrRrror)rrrrrGrrcrfrrrrrSrrs@r=r!r!#s(7777777&NNXNffXfFFFFFF >>>>"....r?r!cneZdZdZdd fd Zed ZedZd!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) r)rEr*Fr+r,r-rGr/r.ct|||||t_t |ddz|d|ddzzt jfd|D_t jfd|D_|ddz_ t jfd|D_ |r\tj j_ tj j_tj j _dSdS) rIrr1r rc 3~K|]7}tjt|dtdV8dS)r4N)r5r6r)r9r:rs r=r>z"Pose26.__init__..sD \ \TUtAr1~~tBA!O!O \ \ \ \ \ \r?c3NK|]}tjjdV dSr N)r5r7rKr9_rr<s r=r>z"Pose26.__init__..s3%L%LAbiDGQ&?&?%L%L%L%L%L%Lr?c3NK|]}tjjdV dSri)r5r7nk_sigmarjs r=r>z"Pose26.__init__..s3&S&S1ryT]A'F'F&S&S&S&S&S&Sr?N)rFrGr flow_modelrNr5rPrcv4_kptsrm cv4_sigmarVrWrone2one_cv4_kptsone2one_cv4_sigmarLs` @r=rGzPose26.__init__s< Y"===!)) A!Yq\Yq\A-=> ? ?= \ \ \ \Y[ \ \ \\\ %L%L%L%L%L%L%L%LLL !! q( &S&S&S&S&SPR&S&S&SSS  C#}TX66D $(M$-$@$@D !%)]4>%B%BD " " " C Cr?c\t|j|j|j|j|jS)rr_r`rO kpts_headkpts_sigma_head)rarQrSrrorprbs r=rczPose26.one2manys4XXhm N     r?c\t|j|j|j|j|jS)rert)rarXrYrrqrrrbs r=rfzPose26.one2ones9%%&+ 2     r?r:rmr_rnr`rOrurvrorpc t||}djdfdtjD t j fdtjDd|d<jr9t j fdtjDd|d<|S) rUNrc>g|]}||Sr+r+)r9ryrOr:s r=r{z'Pose26.forward_head..s+CCCq ! QqT**CCCr?crg|]3}||jd4SrrW)r9ryrzfeaturesrur<s r=r{z'Pose26.forward_head..sA&o&o&o[\|y|HQK'@'@'E'Eb$'SU'V'V&o&o&or?rrRcrg|]3}||jd4Sr)rwrm)r9ryrzr{rvr<s r=r{z'Pose26.forward_head..sBiiiUV'_Q' 4499"dmRPPiiir? kpts_sigma)r rrrrIrKrr) r<r:r_r`rOrurvrrzr{s `` ``` @@r=rzPose26.forward_heads##D!Xx@@  1ABCCCCCE$'NNCCCH!I&o&o&o&o&o&o&o`efjfm`n`n&o&o&oqrssE&M} &+iiiiiiiiZ_`d`gZhZhiiikl''l# r?rctdx|_x|_x|_|_dSr)rFrrorprnrrr+s r=rz Pose26.fuses7  TXX XX4;Q;Q;Qr?rRrc|jd}|jd}|jr|j|g|jdR}|ddddddf|jz|jz}|dkr8t j||ddddddffd}|||j dS| }|dkrTtr"|dddd|f n+|dddd|f|dddd|f<|dddd|f|jdz|jz|dddd|f<|dddd|f|jdz|jz|dddd|f<|S)r[r rruNrr4r\r_s r=rSzPose26.kpts_decodes~a  Z] ;  "2t~2r222A111aaa!8t|+t|;AqyyIq!AAAqqq!A#I,"6"6"8"891==66"dgr** * Aqyy<aaaDjM**,,,,$%aaaDjM$9$9$;$;AaaaDjMqqq!'T'z]T\!_< LAaaaDjMqqq!'T'z]T\!_< LAaaaDjMHr?rarb)r:rmr_rnr`rnrOrnrurnrvrnrorprrc) rrrrrGrrcrfrrrSrrs@r=reres(CCCCCCC2  X   X *YYYYYY r?rec2eZdZdZdZddfd 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) Fr Nc1r-r;rsr( int | Nonegctd}t|||||||_t jd|_t jdd|_t j |||_ dS)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)r(inplaceN) rFrGrconvr5AdaptiveAvgPool2dpoolDropoutdropLinearlinear) r<rr;rrr(rc_r[s r=rGzClassify.__init__sx  RAq!,, (++ Jd333 iB'' r?r:!list[torch.Tensor] | torch.Tensorrotorch.Tensor | tuplec nt|trtj|d}|||||d}|j r|S| d}|j r|n||fS)z+Perform forward pass on input feature maps.r ) rlistrKrrrrrrrsoftmaxr)r<r:rs r=rzClassify.forward.s a    !QA KK $))DIIaLL"9"9"A"A!"D"DEE F F = H IIaLLK+qqaV+r?)r r Nr ) rr-r;r-rr-rr-r(rrr-)r:rror)rrrrrrGrrrs@r=rrsg*F((((((($,,,,,,,,r?rc@eZdZdZ ddfd 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) r)Fr*r+r,r-embedwith_bnrr8rZr.r/cBt||||t|dt|jdt jfd|D|_t jfd|D|_dS)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. )r8rZr.rr2c 3K|]L}tjt|dtdtjdVMdSrAr5r6rr7r9r:rDrs r=r>z'WorldDetect.__init__..dsY u umntAr1~~tBAPRPYZ\^cefPgPg!h!h u u u u u ur?c3VK|]#}rtn tV$dSr'rrr9rkrrs r=r>z'WorldDetect.__init__..e= h h`aW![!25!9!9!9/J[J[ h h h h h hr?N) rFrGrNrOr,r5rPrSr r<r,rrr8rZr.rDr[s `` @r=rGzWorldDetect.__init__Os& Wg"EEE ADGS)) * *= u u u u urt u u uuu= h h h h heg h h hhhr?r:rmtextrrodict[str, torch.Tensor] | tuplec t d|D}tjD]e}tjj|||j|j||||fd||<fjjdzz_ |dj d tj fd|Dd}| jdzjfd\}}t|||}j r|S|} jr| n| |fS)zHConcatenate and return predicted bounding boxes and class probabilities.c6g|]}|Sr+)r]rs r=r{z'WorldDetect.forward..is ((((((r?r r1rcHg|]}|jdSr)rwrJ)r9rrzr<s r=r{z'WorldDetect.forward..ns+@@@2772tw33@@@r?rr)rrIrKrrQrrSr,r8rJrrrarrr) r<r:rrryx_catrrrrrzs ` @r=rzWorldDetect.forwardgsC((a(((tw [ [A9kdhqk!A$//!Xa[1=N=NPT1U1UVXYZZAaDD'DL1,, qTZ] @@@@@a@@@!DD T\A%5tw$?CC v5u=== = L OOE " "K/qqaZ/r?c|}t|j|j|jD]\}}}d|djjdd<dS)r?ruN)rrQrSrMrr)r<mrrrs r=rzWorldDetect.bias_initvsS 15!%22 % %GAq!!$AbEJOAAA   % %r?r)rFr*Fr+) r,r-rr-rrr8r-rZrr.r/)r:rmrrror)rrrrrGrrrrs@r=rr9s.iiiiiii0 0 0 0 0%%%%%%%r?rcFeZdZdZddfd 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) Tvocab nn.Modulepflocenabledrct|r||n||_||_||_||_dS)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)rFrG conv2linearrrrr)r<rrrrr[s r=rGzLRPCHead.__init__sS 07BT%%e,,,U  r?r nn.Conv2dro nn.Linearct|tjr |jdksJtj|j|j}|j|jdj |j_ |j j |j _ |S)z4Convert a 1x1 convolutional layer to a linear layer.)r r ru) rr5r7 kernel_sizer in_channels out_channelsweightrwrr)rrs r=rzLRPCHead.conv2linearsu$ **It/?6/I/I/II4+T->??![--d.?DDI 9>  r?cls_featrloc_featrrtuple[tuple, torch.Tensor]c|jr||dd}||k}|ddd}||r |dd|fn)||dz}|||dd|fS||}||}||dtj |j d|j dz|j tj fS) zQProcess classification and localization features to generate detection proposals.)rrrrruNr4)devicedtype)rrrrrrrr-rrKonesrrr)r<rrrpf_scoremasks r=rzLRPCHead.forwardsE < wwx((.66q99H##%%,D''**44R<!,x~a/@@`e`jkkk r?r)rrrrrrrr)rrror)rrrrrrror) rrrrrG staticmethodrrrrs@r=rrs.       \r?rceZdZdZdZ d(d)fd Zed*d+dZd,dZd-dZ d.dZ d/fd! Z d/d"Z fd#Z ed$Zed%Zd&Zd'ZxZS)0r$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) Fr)rr*r+r,r-rrrr.r/ct||||t|dt|jdksJsJ|jr!t jfd|Dn t jfd|D|_t jfd|D|_ |rz'YOLOEDetect.__init__..sWnnfg"-QARQSUW\^_I`I`aannnnnnr?c 30K|]}tjtjt||dt|dtjtdtdtjdVdSrA)r5r6rrr7rs r=r>z'YOLOEDetect.__init__..s   M&Aq//42q>>BBM&R"3"3T"b!__EEIb%++r?c3VK|]#}rtn tV$dSr'rrs r=r>z'YOLOEDetect.__init__..rr?N)rFrGrNrOr,rRr5rPrSrrVrWrYrrrreprtarsavperrs `` @r=rGzYOLOEDetect.__init__se Wgr222 ADGS)) * *U{{{{w{ BMnnnnnkmnnn n n n   = h h h h heg h h hhh  7#}TX66D #}TX66D y6677 2r5))  r?N txt_featsrc|dx|_x|_|_dS|jrdS|jrJ|t jd}| ||j|j|j r!| ||j |j |` tj|_ d|_dS)>Fuse text features with model weights for efficient inference.NrT)rQrSris_fusedrtorKfloat32squeeze_fuse_tprZrYrrr5rT)r<rs r=rzYOLOEDetect.fuses  -1 1DH 1tx$( F =  F=   LL//77::  i48444 < I MM)T%5t7G H H H Kkmm  r?r`rnbn_headrorc:t||D]\}}t|tjsJt|tsJ|d}t|tjsJ|j}|j}|j} || z} t|| }|j j d d} |jj } | | z} | | ddz d} t!j| |z}tj|j| jddd|j j}|j j | dd|jj | |z||d<| dS)zGFuse text prompt embeddings with model weights for efficient inference.rurr )rFN)rrr5r6rr7 logit_scalernormexpr rrrreshaperrK ones_likerrrequires_grad_rrcopy_r)r<rr`rcls_hbn_hrrrrtwrb1b2s r=rzYOLOEDetect._fuse_tpsx11! ! KE4eR]33 3 33d$566 6 669DdBI.. . ..*K9D9DKOO---A.tT::D  ((,,44R88A AAAaiimm--b111::2>>B$$t+B $GAJ !  &&DK&''  K  " "1;;r??#<#.r|r?rur}r cg|]I}|||djdJSr)rr,)r9ryrzr`rr<r:s r=r{z,YOLOEDetect.forward_head..sX l l lXY a !QqT!2!2AbE : : B B2twPR S S l l lr?r4r) rHrarrKrrrIr,r8rJ)r<r:r_r`rrrrzs````` @r=rzYOLOEDetect.forward_head{s(1vv{{{tknopkqkqttt{{{  x/66M qTZ] dddddddUZ[_[bUcUcdddjlmmmB%+a. l l l l l l l l]bcgcj]k]k l l lrt   'DL1,,%ae<<<5Ia4O&OPPAFKNN < U )DL,dl:.F UgHhii!! U U 9Aq!&)" "%(" "!%!dg+t{1~9MRS8S*S!T!T AAA  U U U Ur?r)r,r-rr-rrr.r/r'rr)rrr`rnrrnror)rrror)r:rmrrrorr:rmror)rrrrrrGr rrrrrrrrrcrfrrrrs@r=r$r$sw:Hmo$$$$$$$L"####JSSSS"""""" 00000UUXUmmXm = = =UUUUUUUr?r$ceZdZdZ d*d+fd ZedZedZd,dZd-fd Z d.fd Z d/fd$ Z d0d&Z d1d2fd) Z xZS)3r%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) r)rrrFr*r+r,r-rrrrrr.r/c  t|||||||_|_t |djj_t |ddzj tj fd|D_ |r tj j _ dSdS)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. rr1c 3K|]Q}tjt|dtdtjjdVRdSrArr9r:c5r<s r=r>z(YOLOESegment.__init__..rr?N) rFrGrrrrrNr5rPcv5rVrW one2one_cv5) r<r,rrrrr8rZr.r r[s ` @r=rGzYOLOESegment.__init__s. UGWgrBBB2a5$(DG44 A!TW % %= w w w w wtv w w www  7#}TX66D    7 7r?cPt|j|j|j|jS)r]r_r`rr)rarQrSr rrbs r=rczYOLOESegment.one2manys%TXDH_c_ghhhhr?cPt|j|j|j|jS)rer)rarXrYr rrbs r=rfzYOLOESegment.one2ones3%%&!-     r?r:rmrorc ggg}}}djdjsjnj}jsjnj}jsjnjtj D]}|||}|||} tj |tsJj ||| j r jsdntdd\} } } || jdzd|| || t'jfdtj Dd} t'j|}t+t'j|dt'j|d|j rjs| |zn | d|f }|}jr*|ddd }j r|n||fS) rrrrr1rucrg|]3}||jd4Srr)r9ryrzr r<r:s r=r{z-YOLOESegment.forward_lrpc..s=SSSqAqt ))"dgr::SSSr?r.)rrrrr r )rrZrQrXrSrYr r rrIrrrrrrirrwr8rKrrar-rrr)r<r:rrrrQrSryrrrrrmcrrrzr s`` @@r=rzYOLOESegment.forward_lrpcsY!2ruv qTZ]"l@dhh0@"l@dhh0@"l@dhh0@tw  As1vad||Hs1vad||HdilH55 5 55*dil[WW74QV;W;WOC LL"dlQ&6;; < < < MM% LL     YSSSSSSSE$'NNSSSUV W W %  )E1%%9VQ''15eT\eR%))++--WYZ]_dZdWe     OOE " " < 5  1a!3!344AK/qqaZ/r?rct|}t|tr|dn|}||d}t|t r5|jr)||dd<||dd<n||d<|jr|S|j r||fn |d|f|fSrrrs r=rzYOLOESegment.forwardr r?rprct|}tj||dgdSr r rs r=rzYOLOESegment._inferencerr?r_rnr`rrct|||}Ldjdtjfdt jDd|d<|S)rNrcrg|]3}||jd4Srrrs r=r{z-YOLOESegment.forward_head.."rr?rr r) r<r:r_r`rrrrzr[s `` ` @r=rzYOLOESegment.forward_heads$$Q(z*YOLOESegment26.__init__..jrr?N) r$rGrrrrrNr5rPr rVrWr ) r<r,rrrrr8rZr.r s ` @r=rGzYOLOESegment26.__init__Xs T2ugwLLLR47B77 A!TW % %= w w w w wtv w w www  7#}TX66D    7 7r?r:rmrorct||}t|tr|dn|}|d|Dd}t|t rE|jr9t|ds)||dd<||dd<n||d<|j r|S|j r||fn |d |f|fS) rr c6g|]}|Sr+rrs r=r{z*YOLOESegment26.forward..rs 444BBIIKK444r?F) return_semsegrrcrrfr) r$rrr/rrarZrjrrrr)s r=rzYOLOESegment26.forwardns%%dA..(%88E g 44!444E JJ eT " " '| 'GD&$9$9 '-2j!'*,1LLNNi ))!&g = L#';Pgaj%5H%4PPr?Nrrr!)rrrrrGrr+r?r=rr@sk277777,QQQQQQr?rceZdZdZdZgZejdZejdZ dZ dddddd d d d e j d ddddfdEfd% Z dFdGd-Zed.ejd/d0fdHd:ZdId<Z dJdKdCZdDZxZS)Lr"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(r1r#rrur2rrr,r-r.r/hdnqndpnhndld_ffndropoutractreval_idxndlabel_noise_ratiobox_noise_scalelearnt_init_queryrc t|_||_t ||_|_||_||_tj fd|D|_ t||| | |j|}t||| |_tj|_| |_| |_||_||_|rtj||_t-ddzd|_tjtjtj|_tj|_t-dd|_tj fdt=|D|_tj fdt=|D|_ |!dS) 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|]A}tjtj|ddtjVBdS)r F)rN)r5r6r7 BatchNorm2d)r9r:r&s r=r>z)RTDETRDecoder.__init__..sP'w'wop bi2qu6U6U6UWYWefhWiWi(j(j'w'w'w'w'w'wr?r1r num_layersr4c:g|]}tjSr+)r5r)r9rkr&r,s r=r{z*RTDETRDecoder.__init__..s%,S,S,S1RYr2->->,S,S,Sr?c6g|]}tddS)r1r4r6)r)r9rkr&s r=r{z*RTDETRDecoder.__init__..s*+]+]+]QCBa,H,H,H+]+]+]r?N)"rFrG hidden_dimnheadrHrIr, num_queriesnum_decoder_layersr5rP input_projrrdecoder Embeddingdenoising_class_embed num_denoisingr0r1r2 tgt_embedrquery_pos_headr6r LayerNorm enc_outputenc_score_head enc_bbox_headrdec_score_head dec_bbox_head_reset_parameters)r<r,r.r&r'r(r)r*r+r,r-r.r/r0r1r2 decoder_layerr[s ` ` r=rGzRTDETRDecoder.__init__sL  b''"%-'w'w'w'wtv'w'w'www :"b%RUW[W^`cdd 3B sHUU &(\"b%9%9"!2."3  2\"b11DN!!QVRA>>>- "b(9(92<;K;KLL iB// Rq999!m,S,S,S,S,Sc ,S,S,STT]+]+]+]+]RWX[R\R\+]+]+]^^      r?Nr:rmbatch dict | Nonerotuple | torch.Tensorc ,ddlm}||\}}|||j|j|jj|j|j|j |j \}}}} | ||||\} } } } | | | |||j |j|j|\}}||| | | f}|j r|St!j|d|dfd}|jr|n||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_maskru)ultralytics.models.utils.opsrQ_get_encoder_inputr,r<rArrBr0r1r_get_decoder_inputr?rJrIrDrKrrrr)r<r:rMrQrshapesdn_embeddn_bboxrRdn_metar refer_bbox enc_bboxes enc_scores dec_bboxes dec_scoresrs r=rzRTDETRDecoder.forwardsU ?>>>>>//22 v1>  G    & -    "  M 1 1 -'9g594K4KESY[cel4m4m1z:z"&          ". " "  J  J G C = H Iz))!,,j.@.@.C.C.K.K.M.MNPR S SK+qqaV+r?g?cpu{Gz?rVlist[list[int]] grid_sizer torch.dtyperstreps!tuple[torch.Tensor, torch.Tensor]cTg}t|D]\}\}}tj|||} tj|||} trtj| | dntj| | \} } tj| | gd} tj||g||}| ddz|z } tj| |||zd|zz}| tj | |gd d||zd tj |d }||k|d |z kz dd }tj |d |z z }||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)indexingrurrrrrr1r T)rinf)rrKrr meshgridstacktensorrrrrrwallr masked_fillr)rVrbrrrerryhrsysxgrid_ygrid_xgrid_xyvalid_WHwh valid_masks r=_generate_anchorszRTDETRDecoder._generate_anchors,s*"6** L LIAv1!5@@@B!5@@@BFPlU^BTBBBBV[VdegikVlVlNFFk66"2B77G|QF%GGGH((++c1X=GfEEE QUXZ[U[\B NN59gr]B77<)r9ryfeatr<s r=r{z4RTDETRDecoder._get_encoder_input..^s/ B B B'!T T_Q  % % B B Br?rNrr )rrrrrrKr)r<r:rrVrrrrs` r=rTz RTDETRDecoder._get_encoder_inputSs C B B BYq\\ B B B " "D:abb>DAq LLa00Aq99 : : : MM1a& ! ! ! ! %##f}r?rrrWrrX=tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]c|jd}|js |j|kr6|||j|j\|_|_||_||j|z}| |}tj | dj |jdjd}tj||jdd|jd} || |f||jd} |jdd|f||jd} || | z} | } |tj|| gd} || |f||jd}|jr4|jjd|ddn| }|jr/| } |js|}|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. rrkrur r})rhrN)rrrVr{rrrrzrFrGrKrrNvaluesr<rrwrrrrHrrr2rCrrr)r<rrVrWrXrzr{enc_outputs_scorestopk_ind batch_indtop_k_features top_k_anchorsrZr[r\ embeddingss r=rUz RTDETRDecoder._get_decoder_inputmsc*[^ < !4;&00,0,B,B6QVQ\ejeq,B,r,r )DL$/ DK??4?U#:;;!00:::044R88?AQWXYYYaffgijjLRx~>>>HHLLSSTUW[Wghhmmnpqq ")X"56;;B@PRTUU QQQ[166r4;KRPP ''77-G ''))  GZ#8!<>r1aHHHhv = 1#**,,J) 1'..00  Hj#91==J:z:==r?cvtddz |jz}t|jj|t|jjdjdt|jjdjdt|j |j D]Z\}}t|j|t|jdjdt|jdjd[t|j dt|j dj|jrt|jjt|jjdjt|jjdj|jD]}t|djdS)zhInitialize or reset the parameters of the model's various components with predefined weights and biases.r`r)rurrr N)rr,rrGrrHlayersrrrIrJrrFrr2rCrDr>)r<bias_clscls_reg_layers r=rKzRTDETRDecoder._reset_parameterss't,,r1DG; $%*H555$$+B/6<<<$$+B/4c:::d143EFF 1 1JD$ di * * * dk"o,c 2 2 2 dk"o*C 0 0 0 0DOA&'''*1222  ! 3 DN1 2 2 2+215<===+215<===_ - -E E!HO , , , , - -r?)r,r-r.r/r&r-r'r-r(r-r)r-r*r-r+r-r,rr-rr.r-r/r-r0rr1rr2rr')r:rmrMrNrorO) rVrarbrrrcrrdrerrorf)r:rmror|r) rrrVrarWrrXrror)rrrrrrVrKrrrzrr5ReLUrGrrrr{rTrUrKrrs@r=r"r"sP%%NF Fek!nnGQJG% #&!$"'#L!L!L!L!L!L!L!\/,/,/,/,/,b "] $#$#$#$#\$#L<)-'+ 9>9>9>9>9>v-------r?r"c0eZdZdZdZd d fd Zd ZxZS) 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) Tr)r+r,r-r.r/c.t|d|t|dtjdt jfd|D_tj j_ dS)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)rZr.rr2c 3BK|]}tjtjt||d|t|dtjtdtdtjjdVdS)r4)rr NrBrCs r=r>z%v10Detect.__init__..s! !  M d1aa000$q"a..AA d2r1333T"b!__EE "dgq))  ! ! ! ! ! ! r?N) rFrGrNrOr,r5rPrSrVrWrY)r<r,r.rDr[s` @r=rGzv10Detect.__init__s Tb111 ADGS)) * *=! ! ! ! !  ! ! !    =22r?c"dx|_|_dSrrrbs r=rzv10Detect.fuserr?)r)r+r)rrrrrZrGrrrs@r=r&r&sb0G3333333(#######r?r&)=r __future__rrVrrKtorch.nnr5torch.nn.functional functionalr torch.nn.initrrultralytics.utilsrultralytics.utils.talrrr ultralytics.utils.torch_utilsr r r blockrrrrrrrrrrrr transformerrrrutilsrr__all__Moduler r#r#rrAr!rerrrr$r%rr"r&r+r?r=rsN"""""" 44444444))))))DDDDDDDDDD\\\\\\\\\\oooooooooooooooooooooo]]]]]]]]]]33333333 ua#a#a#a#a#RYa#a#a#He.e.e.e.e.fe.e.e.P88888888v].].].].].&].].].@CDiiiii6iiiXrrrrrTrrrj2,2,2,2,2,ry2,2,2,jC%C%C%C%C%&C%C%C%N?????ry???DUUUUUUUUUU&UUUUUUpccccc;cccL<Q<Q<Q<Q<Q\<Q<Q<Q~-----BI---D 1#1#1#1#1#1#1#1#1#1#r?