§
    l¬¸jŽG ã                  ó  — d Z ddlmZ ddlZddlZddlZddlmc mZ	 ddlmZ ddl
mZmZ ddlmZ ddlmZmZmZ ddlmZmZmZ d	d
lmZmZmZmZmZmZmZmZm Z  d	dl!m"Z"m#Z# d	dl$m%Z%m&Z&m'Z' d	dl(m)Z) dZ* G d„ dej+        ¦  «        Z, G d„ de,¦  «        Z- G d„ de-¦  «        Z. G d„ de,¦  «        Z/ G d„ de/¦  «        Z0 G d„ de,¦  «        Z1 G d„ de1¦  «        Z2 G d„ dej+        ¦  «        Z3 G d„ d ej+        ¦  «        Z4 G d!„ d"e,¦  «        Z5 G d#„ d$ej+        ¦  «        Z6 G d%„ d&e,¦  «        Z7 G d'„ d(e7¦  «        Z8 G d)„ d*e8¦  «        Z9 G d+„ d,ej+        ¦  «        Z: G d-„ d.e,¦  «        Z; G d/„ d0ej+        ¦  «        Z<dS )1zModel head modules.é    )ÚannotationsN)Únn)Ú	constant_Úxavier_uniform_)ÚLOGGER)Ú	dist2bboxÚ	dist2rboxÚmake_anchors)Ú
TORCH_1_11Úfuse_conv_and_bnÚsmart_inference_modeé   )	ÚDFLÚSAVPEÚBNContrastiveHeadÚContrastiveHeadÚProtoÚProto26ÚRealNVPÚResidualÚ	SwiGLUFFN)ÚConvÚDWConv)ÚMLPÚDeformableTransformerDecoderÚ!DeformableTransformerDecoderLayer)Úbias_init_with_prob)ÚOBBÚClassifyÚDepthÚDetectÚPoseÚRTDETRDecoderÚSegmentÚSemanticSegmentÚYOLOEDetectÚYOLOESegmentÚ	v10Detectc                  óX  ‡ — e Zd ZdZdZdZdZdZdZdZ	 e
j        d¦  «        Z e
j        d¦  «        ZdZdZed4d5d„¦   «         Zd6d„Zd7d8ˆ fd„Zed„ ¦   «         Zed„ ¦   «         Zed„ ¦   «         Zej        d„ ¦   «         Z	 d9d:d!„Zd;d#„Zd<d$„Zd<d%„Zd&„ Z	 d=d>d+„Zd?d-„Zd@d1„Z dAd3„Z!ˆ xZ"S )Br!   aU  YOLO Detect head for object detection models.

    This class implements the detection head used in YOLO models for predicting bounding boxes and class probabilities.
    It supports both training and inference modes, with optional end-to-end detection capabilities.

    Attributes:
        dynamic (bool): Force grid reconstruction.
        export (bool): Export mode flag.
        format (str): Export format.
        end2end (bool): End-to-end detection mode.
        max_det (int): Maximum detections per image.
        shape (tuple): Input shape.
        anchors (torch.Tensor): Anchor points.
        strides (torch.Tensor): Feature map strides.
        legacy (bool): Backward compatibility for v3/v5/v8/v9/v11 models.
        xyxy (bool): Output format, xyxy or xywh.
        nc (int): Number of classes.
        nl (int): Number of detection layers.
        reg_max (int): DFL channels.
        no (int): Number of outputs per anchor.
        stride (torch.Tensor): Strides computed during build.
        cv2 (nn.ModuleList): Convolution layers for box regression.
        cv3 (nn.ModuleList): Convolution layers for classification.
        dfl (nn.Module): Distribution Focal Loss layer.
        one2one_cv2 (nn.ModuleList): One-to-one convolution layers for box regression.
        one2one_cv3 (nn.ModuleList): One-to-one convolution layers for classification.

    Methods:
        forward: Perform forward pass and return predictions.
        bias_init: Initialize detection head biases.
        decode_bboxes: Decode bounding boxes from predictions.
        postprocess: Post-process model predictions.

    Examples:
        Create a detection head for 80 classes
        >>> 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é,  r   é   Úxútorch.TensorÚkÚintÚgroupsÚreturnú!tuple[torch.Tensor, torch.Tensor]c                óð  — | j         d         }|dk    r'||z  s	||z  |k     r|dz  }|dk    r||z  °||z  |k     °|dk    r|                      |d¬¦  «        S ||z  }|                      | j         d         ||¦  «                             |d¬¦  «        \  }}|                     d¦  «                             |d¬¦  «        \  }}|||z  |z  |                     d¦  «                             d|¦  «        z   fS )z=Select exact top-k values through smaller grouped selections.r   é   ©Údimr   éÿÿÿÿ)ÚshapeÚtopkÚreshapeÚflattenÚgather)r,   r.   r0   ÚnÚsizeÚvaluesÚindexÚwinnerss           úk/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/ultralytics/nn/modules/head.pyÚ_grouped_topkzDetect._grouped_topkZ   s  € ð ŒG�AŒJˆØ�qŠjˆj˜a &™jˆj¨A°©K¸!ªO¨OØ�q‰LˆFð �qŠjˆj˜a &™jˆj¨A°©K¸!ªO¨Oà�QŠ;ˆ;Ø—6’6˜! �6Ñ#Ô#Ð#Ø�F‰{ˆØŸ	š	 !¤'¨!¤*¨f°dÑ;Ô;×@Ò@ÀÈÐ@ÑKÔK‰ˆ�Ø Ÿ.š.¨Ñ+Ô+×0Ò0°¸Ð0Ñ:Ô:‰ˆ�Ø�w !‘| dÑ*¨U¯]ª]¸1Ñ-=Ô-=×-DÒ-DÀQÈÑ-PÔ-PÑPÐPÐPó    r@   c           	     ó”   — |                      d|j        dk    r|n'|d                              dd|j        d         ¦  «        ¦  «        S )zCSelect index (batch, k) rows of x (batch, n, channels) along dim 1.r   r4   ©.Nr7   )r<   ÚndimÚexpandr8   ©Úselfr,   r@   s      rB   Ú_gatherzDetect._gatherg   sF   € à�xŠx˜ A¤F¨a¢K K˜5˜5°U¸9Ô5E×5LÒ5LÈRÐQSÐUVÔU\Ð]_ÔU`Ñ5aÔ5aÑbÔbÐbrD   éP   é   © ÚncÚchÚtuplec                ób  •‡ ‡‡— t          ¦   «                              ¦   «          |‰ _        t          |¦  «        ‰ _        |‰ _        |‰ j        dz  z   ‰ _        t          j        ‰ j        ¦  «        ‰ _	        t          d|d         dz  ‰ j        dz  f¦  «        t          |d         t          ‰ j        d¦  «        ¦  «        cŠŠt          j        ˆˆ fd„|D ¦   «         ¦  «        ‰ _        ‰ j        r!t          j        ˆˆ fd„|D ¦   «         ¦  «        n t          j        ˆˆ fd„|D ¦   «         ¦  «        ‰ _        ‰ j        dk    rt#          ‰ j        ¦  «        nt          j        ¦   «         ‰ _        |r>t)          j        ‰ j        ¦  «        ‰ _        t)          j        ‰ j        ¦  «        ‰ _        d	S d	S )
ac  Initialize 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.
        é   rM   r   éd   c           
   3  ó¸   •K  — | ]T}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        t          j        ‰d‰j        z  d¦  «        ¦  «        V — ŒUdS )é   rS   r   N)r   Ú
Sequentialr   ÚConv2dÚreg_max)Ú.0r,   Úc2rJ   s     €€rB   ú	<genexpr>z"Detect.__init__.<locals>.<genexpr>{   sl   øè è € ð !
ð !
Øcd�BŒM�$˜q " a™.œ.­$¨r°2°q©/¬/½2¼9ÀRÈÈTÌ\ÑIYÐ[\Ñ;]Ô;]Ñ^Ô^ð!
ð !
ð !
ð !
ð !
ð !
rD   c           
   3  ó²   •K  — | ]Q}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        t          j        ‰‰j        d¦  «        ¦  «        V — ŒRdS ©rV   r   N©r   rW   r   rX   rO   ©rZ   r,   Úc3rJ   s     €€rB   r\   z"Detect.__init__.<locals>.<genexpr>   sZ   øè è € ÐpÐpÐhi�"œ-­¨Q°°A©¬½¸RÀÀQ¹¼ÍÌÐSUÐW[ÔW^Ð`aÑIbÔIbÑcÔcÐpÐpÐpÐpÐpÐprD   c              3  ó:  •K  — | ]•}t          j        t          j        t          ||d ¦  «        t          |‰d¦  «        ¦  «        t          j        t          ‰‰d ¦  «        t          ‰‰d¦  «        ¦  «        t          j        ‰‰j        d¦  «        ¦  «        V — Œ–dS r^   )r   rW   r   r   rX   rO   r`   s     €€rB   r\   z"Detect.__init__.<locals>.<genexpr>�   s    øè è € ð ð ð õ ”Ý”M¥&¨¨A¨q¡/¤/µ4¸¸2¸q±>´>ÑBÔBÝ”M¥&¨¨R°Ñ"3Ô"3µT¸"¸bÀ!±_´_ÑEÔEÝ”I˜b $¤'¨1Ñ-Ô-ñô ðð ð ð ð ð rD   r   N)ÚsuperÚ__init__rO   ÚlenÚnlrY   ÚnoÚtorchÚzerosÚstrideÚmaxÚminr   Ú
ModuleListÚcv2ÚlegacyÚcv3r   ÚIdentityÚdflÚcopyÚdeepcopyÚone2one_cv2Úone2one_cv3)rJ   rO   rY   Úend2endrP   r[   ra   Ú	__class__s   `    @@€rB   rd   zDetect.__init__k   sÂ  øøøø€ õ 	‰Œ×ÒÑÔÐØˆŒÝ�b‘'”'ˆŒØˆŒØ�t”| aÑ'Ñ'ˆŒÝ”k $¤'Ñ*Ô*ˆŒÝ�b˜"˜Qœ% 1™* d¤l°QÑ&6Ð7Ñ8Ô8½#¸bÀ¼eÅSÈÌÐRUÑEVÔEVÑ:WÔ:WˆˆˆBÝ”=ð !
ð !
ð !
ð !
ð !
Øhjð!
ñ !
ô !
ñ 
ô 
ˆŒð
 Œ{ð	�BŒMÐpÐpÐpÐpÐpÐmoÐpÑpÔpÑpÔpÐpå”ð ð ð ð ð ð ðñ ô ñ ô ð 	Œð )-¬°qÒ(8Ð(8•3�t”|Ñ$Ô$Ð$½b¼k¹m¼mˆŒàð 	7Ý#œ}¨T¬XÑ6Ô6ˆDÔÝ#œ}¨T¬XÑ6Ô6ˆDÔÐÐð	7ð 	7rD   c                ó    — | j         | j        dœS )úYReturns the one-to-many head components, here for v3/v5/v8/v9/v11 backward compatibility.©Úbox_headÚcls_head)rn   rp   ©rJ   s    rB   Úone2manyzDetect.one2many�   s   € ð !œH°$´(Ð;Ð;Ð;rD   c                ó    — | j         | j        dœS )ú'Returns the one-to-one head components.r{   )ru   rv   r~   s    rB   Úone2onezDetect.one2one•   s   € ð !Ô,¸$Ô:JÐKÐKÐKrD   c                ó\   — t          | dd¦  «        duot          | dd¦  «        p| j        du S )z[Select one-to-one inference when requested or when fusion has removed the one-to-many head.ru   NÚ_end2endF)Úgetattrrn   r~   s    rB   rw   zDetect.end2endš   s=   € õ �t˜]¨DÑ1Ô1¸Ð=ÐxÅ7È4ÐQ[Ð]bÑCcÔCcÐCwÐgkÔgoÐswÐgwÐxrD   c                óž   — |r&t          | dd¦  «        €t          j        d¦  «         n|s| j        €t          j        d¦  «         || _        dS )z>Select the inference head without changing dual-head training.ru   Nz=This model has no one-to-one head; using one-to-many outputs.zPThe one-to-many head was removed by fusion; using the remaining one-to-one head.)r…   r   Úwarningrn   r„   )rJ   Úvalues     rB   rw   zDetect.end2endŸ   s^   € ð ð 	o•W˜T =°$Ñ7Ô7Ð?ÝŒNÐZÑ[Ô[Ð[Ð[Øð 	o˜4œ8Ð+ÝŒNÐmÑnÔnÐnØˆŒˆˆrD   úlist[torch.Tensor]r|   útorch.nn.Moduler}   údict[str, torch.Tensor]c                ó&  ‡ ‡‡‡‡— ‰�‰€i S ‰d         j         d         Št          j        ˆˆˆ ˆfd„t          ‰ j        ¦  «        D ¦   «         d¬¦  «        }t          j        ˆˆˆ ˆfd„t          ‰ j        ¦  «        D ¦   «         d¬¦  «        }||‰dœS )úJConcatenates and returns predicted bounding boxes and class probabilities.Nr   c                óx   •— g | ]6} ‰|         ‰|         ¦  «                              ‰d ‰j        z  d¦  «        ‘Œ7S ©rS   r7   ©ÚviewrY   ©rZ   Úir|   ÚbsrJ   r,   s     €€€€rB   ú
<listcomp>z'Detect.forward_head.<locals>.<listcomp>¯   óE   ø€ ÐdÐdÐdÐPQ˜;˜8 Aœ; q¨¤tÑ,Ô,×1Ò1°"°a¸$¼,Ñ6FÈÑKÔKÐdÐdÐdrD   r7   r5   c                ór   •— g | ]3} ‰|         ‰|         ¦  «                              ‰‰j        d ¦  «        ‘Œ4S ©r7   )r‘   rO   )rZ   r“   r”   r}   rJ   r,   s     €€€€rB   r•   z'Detect.forward_head.<locals>.<listcomp>°   s?   ø€ Ð\Ð\Ð\È˜K˜H QœK¨¨!¬Ñ-Ô-×2Ò2°2°t´wÀÑCÔCÐ\Ð\Ð\rD   ©ÚboxesÚscoresÚfeats)r8   rh   ÚcatÚrangerf   )rJ   r,   r|   r}   rš   r›   r”   s   ````  @rB   Úforward_headzDetect.forward_head¨   sµ   øøøøø€ ð Ð˜xÐ/ØˆIØˆqŒTŒZ˜Œ]ˆÝ”	ÐdÐdÐdÐdÐdÐdÐdÕUZÐ[_Ô[bÑUcÔUcÐdÑdÔdÐjlÐmÑmÔmˆÝ”Ð\Ð\Ð\Ð\Ð\Ð\Ð\ÍUÐSWÔSZÉ^Ì^Ð\Ñ\Ô\ÐbdÐeÑeÔeˆØ¨&¸1Ð=Ð=Ð=rD   úUdict[str, torch.Tensor] | torch.Tensor | tuple[torch.Tensor, dict[str, torch.Tensor]]c                ó†  —  | j         |fi | j        ¤Ž}t          | dd¦  «        �-| j        rd„ |D ¦   «         n|} | j         |fi | j        ¤Ž}||dœ}| j        r|S |                      d|v r|| j        rdnd         n|¦  «        }| j        r*|                      |                     ddd	¦  «        ¦  «        }| j	        r|n||fS )
r�   ru   Nc                ó6   — g | ]}|                      ¦   «         ‘ŒS rN   ©Údetach©rZ   Úxis     rB   r•   z"Detect.forward.<locals>.<listcomp>¹   s    € Ð0Ð0Ð0¨˜Ÿ	š	™œÐ0Ð0Ð0rD   )r   r‚   r‚   r   r   r4   r   )
rŸ   r   r…   Útrainingr‚   Ú
_inferencerw   ÚpostprocessÚpermuteÚexport)rJ   r,   ÚpredsÚx_detachr‚   Úys         rB   ÚforwardzDetect.forward³   sÿ   € ð "�Ô! !Ð5Ð5 t¤}Ð5Ð5ˆÝ�4˜¨Ñ-Ô-Ð9Ø48´MÐHÐ0Ð0¨aÐ0Ñ0Ô0Ð0ÀqˆHØ'�dÔ'¨ÐAÐA°D´LÐAÐAˆGØ!&°7Ð;Ð;ˆEØŒ=ð 	ØˆLØ�OŠOÐPYÐ]bÐPbÐPb˜E¨t¬|Ð"K ) )ÀÔLÐLÐhmÑnÔnˆØŒ<ð 	5Ø× Ò  §¢¨1¨a°Ñ!3Ô!3Ñ4Ô4ˆAØ”KÐ/ˆqˆq a¨ ZÐ/rD   c                óŠ   — |                       |¦  «        }t          j        ||d                              ¦   «         fd¦  «        S )aD  Decode 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.
        r›   r   )Ú_get_decode_boxesrh   r�   Úsigmoid)rJ   r,   Údboxs      rB   r¨   zDetect._inferenceÃ   s>   € ð ×%Ò% aÑ(Ô(ˆÝŒy˜$  (¤× 3Ò 3Ñ 5Ô 5Ð6¸Ñ:Ô:Ð:rD   c                óŠ  — |d         d         j         }| j        s| j         |k    r:d„ t          |d         | j        d¦  «        D ¦   «         \  | _        | _        || _         |                      |                      |d         ¦  «        | j                             d¦  «        | 	                    d¦  «        ¦  «        | j        z  }|S )z/Get decoded boxes based on anchors and strides.rœ   r   c              3  óB   K  — | ]}|                      d d¦  «        V — ŒdS )r   r   N)Ú	transpose)rZ   Úas     rB   r\   z+Detect._get_decode_boxes.<locals>.<genexpr>Ô   s0   è è € Ð)pÐ)pÀ¨!¯+ª+°a¸Ñ*;Ô*;Ð)pÐ)pÐ)pÐ)pÐ)pÐ)prD   ç      à?rš   Úangle)
r8   Údynamicr
   rj   ÚanchorsÚstridesÚdecode_bboxesrr   Ú	unsqueezeÚget)rJ   r,   r8   r³   s       rB   r±   zDetect._get_decode_boxesÐ   s¸   € à�'”
˜1”Ô#ˆØŒ<ð 	˜4œ:¨Ò.Ð.Ø)pÐ)pÅ\ÐRSÐT[ÔR\Ð^bÔ^iÐknÑEoÔEoÐ)pÑ)pÔ)pÑ&ˆDŒL˜$œ,ØˆDŒJà×!Ò! $§(¢(¨1¨W¬:Ñ"6Ô"6¸¼×8NÒ8NÈqÑ8QÔ8QÐST×SXÒSXÐY`ÑSaÔSaÑbÔbÐeiÔeqÑqˆØˆrD   c                ó   — t          t          | j        d         | j        d         ¦  «        ¦  «        D ]i\  }\  }}d|d         j        j        dd…<   t          j        d| j        z  d| j        |         z  dz  z  ¦  «        |d         j        j        d| j        …<   Œjt          | d	d¦  «        ��t          t          | j
        d         | j
        d         ¦  «        ¦  «        D ]k\  }\  }}d|d         j        j        dd…<   t          j        d| j        z  d| j        |         z  dz  z  ¦  «        |d         j        j        d| j        …<   ŒjdS dS )
úBInitialize Detect() biases, WARNING: requires stride availability.r|   r}   ç       @r7   Né   é€  r4   ru   ©Ú	enumerateÚzipr   ÚbiasÚdataÚmathÚlogrO   rj   r…   r‚   )rJ   r“   r·   Úbs       rB   Ú	bias_initzDetect.bias_initÚ   sN  € å"¥3 t¤}°ZÔ'@À$Ä-ÐPZÔB[Ñ#\Ô#\Ñ]Ô]ð 	ð 	‰IˆA‰v��1Ø!$ˆAˆbŒEŒJŒO˜A˜A˜AÑÝ)-¬Ø�D”G‘˜s T¤[°¤^Ñ3¸Ñ9Ñ9ñ*ô *ˆAˆbŒEŒJŒO˜I˜dœg˜IÑ&Ð&õ �4˜¨Ñ-Ô-Ð9Ý&¥s¨4¬<¸
Ô+CÀTÄ\ÐR\ÔE]Ñ'^Ô'^Ñ_Ô_ð ð ‘	�‘6�A�qØ%(��"””
”   Ñ"Ý-1¬XØ˜œ‘K 3¨¬°Q¬Ñ#7¸AÑ"=Ñ=ñ.ô .��"””
” 	 $¤' 	Ñ*Ð*ð :Ð9ðð rD   Úbboxesr»   r¹   útorch.Tensor | Nonec                óD   — t          ||| j         o| j         d¬¦  «        S )zKDecode bounding boxes from predictions, angle is only used by the OBB head.r   )Úxywhr6   )r   rw   Úxyxy©rJ   rÎ   r»   r¹   s       rB   r½   zDetect.decode_bboxesè   s*   € õ ˜ °4´<Ð/?Ð/QÈÌ	ÀMÐWXÐYÑYÔYÐYrD   r¬   c                ó@  ‡ ‡— |                      d„ d‰ j        |j        d         dz
  ‰ j        z
  fD ¦   «         d¬¦  «        ^}}}‰                      |‰ j        ¦  «        \  }}Št          j        ‰                      |‰¦  «        ||gˆˆ fd„|D ¦   «         ¢d¬¦  «        S )a`  Post-processes YOLO model predictions.

        Args:
            preds (torch.Tensor): Raw predictions with shape (batch_size, num_anchors, 4 + nc + extra) with last
                dimension format [x1, y1, x2, y2, class_probs, extra], where extra holds the mask coefficients,
                keypoints or angle of the Segment, Pose and OBB heads and is empty for Detect.

        Returns:
            (torch.Tensor): Processed predictions with shape (batch_size, min(max_det, num_anchors), 6 + extra) and last
                dimension format [x1, y1, x2, y2, max_class_prob, class_index, extra].
        c                ó   — g | ]}|¯|‘ŒS rN   rN   )rZ   Úss     rB   r•   z&Detect.postprocess.<locals>.<listcomp>û   s   € Ð,iÐ,iÐ,i°1ÐghÐ,i¨QÐ,iÐ,iÐ,irD   rS   r7   r5   c              3  óD   •K  — | ]}‰                      |‰¦  «        V — Œd S ©N)rK   )rZ   ÚeÚidxrJ   s     €€rB   r\   z%Detect.postprocess.<locals>.<genexpr>ý   s4   øè è € ÐChÐChÐ]^ÀDÇLÂLÐQRÐTWÑDXÔDXÐChÐChÐChÐChÐChÐChrD   )ÚsplitrO   r8   Úget_topk_indexÚmax_detrh   r�   rK   )rJ   r¬   rš   r›   ÚextraÚconfrÚ   s   `     @rB   r©   zDetect.postprocessî   s¸   øø€ ð !&§¢Ð,iÐ,i¸¸D¼GÀUÄ[ÐQSÄ_ÐWXÑEXÐ[_Ô[bÑEbÐ8cÐ,iÑ,iÔ,iÐoq Ñ rÔ rÐˆˆv˜Ø ×/Ò/°¸¼ÑEÔEÑˆ��cÝŒy˜$Ÿ,š, u¨cÑ2Ô2°F¸DÐiÐChÐChÐChÐChÐChÐbgÐChÑChÔChÐiÐoqÐrÑrÔrÐrrD   r›   rÝ   ú/tuple[torch.Tensor, torch.Tensor, torch.Tensor]c                óÐ  — |j         dd…         \  }}t          ||¦  «        }| j        rj|                     d¬¦  «        \  }}|                      ||d¦  «        \  }}|d         |                      |d                              ¦   «         |¦  «        |fS | j        r| j        dk    r	| j	        sdnd}|                      |                     d¬¦  «        d         ||¦  «        d         }	|                      ||	¦  «        }|                      | 
                    d¦  «        ||¦  «        \  }}|d         ||z  d                              ¦   «         |                      |	||z  ¦  «        fS )	aN  Get 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.
        r   Nr7   r5   rF   Úenginer+   r   )r8   rl   Úagnostic_nmsrk   rC   rK   Úfloatr«   Úformatrº   r;   )
rJ   r›   rÝ   r»   rO   r.   Úlabelsr@   r0   Ú	ori_indexs
             rB   rÜ   zDetect.get_topk_indexÿ   sa  € ð ”l 1 2 2Ô&‰ˆ�Ý�˜Ñ!Ô!ˆØÔð 	\Ø#ŸZšZ¨B˜ZÑ/Ô/‰NˆF�FØ ×.Ò.¨v°q¸!Ñ<Ô<‰MˆF�EØ˜)Ô$ d§l¢l°6¸)Ô3D×3JÒ3JÑ3LÔ3LÈeÑ&TÔ&TÐV[Ð[Ð[Ø”kÐY d¤k°XÒ&=Ð&=ÀdÄlÐ&=��ÐXYˆØ×&Ò& v§z¢z°b zÑ'9Ô'9¸!Ô'<¸aÀÑHÔHÈÔKˆ	Ø—’˜f iÑ0Ô0ˆØ×*Ò*¨6¯>ª>¸!Ñ+<Ô+<¸aÀÑHÔH‰ˆ�Ø�iÔ  5¨2¡:¨yÔ"9×"?Ò"?Ñ"AÔ"AÀ4Ç<Â<ÐPYÐ[`ÐdfÑ[fÑCgÔCgÐgÐgrD   ÚNonec                ó¦   — | j         }t          | j        ¦  «        D ]4}|                     d¦  «        rt	          | |r
|dd…         n|d¦  «         Œ5dS )z1Remove the unused detection branch for inference.Úone2one_r+   N)rw   rQ   Ú_modulesÚ
startswithÚsetattr)rJ   rw   Únames      rB   ÚfusezDetect.fuse  si   € à”,ˆÝ˜$œ-Ñ(Ô(ð 	Cð 	CˆDØ�Š˜zÑ*Ô*ð CÝ˜¨'Ð;˜d 1 2 2œh˜h°t¸TÑBÔBÐBøð	Cð 	CrD   )r+   )r,   r-   r.   r/   r0   r/   r1   r2   )r,   r-   r@   r-   r1   r-   )rL   rM   FrN   ©rO   r/   rP   rQ   ©NN)r,   r‰   r|   rŠ   r}   rŠ   r1   r‹   )r,   r‰   r1   r    ©r,   r‹   r1   r-   rØ   )rÎ   r-   r»   r-   r¹   rÏ   r1   r-   )r¬   r-   r1   r-   )r›   r-   rÝ   r/   r1   rà   ©r1   rè   )#Ú__name__Ú
__module__Ú__qualname__Ú__doc__rº   r«   rå   rÝ   rã   r8   rh   Úemptyr»   r¼   ro   rÒ   ÚstaticmethodrC   rK   rd   Úpropertyr   r‚   rw   ÚsetterrŸ   r¯   r¨   r±   rÍ   r½   r©   rÜ   rï   Ú__classcell__©rx   s   @rB   r!   r!   &   s&  ø€ € € € € ð&ð &ðP €GØ€FØ€FØ€GØ€LØ€EØˆeŒk˜!‰nŒn€GØˆeŒk˜!‰nŒn€GØ€FØ€Dàð
Qð 
Qð 
Qð 
Qñ „\ð
Qðcð cð cð cð#7ð #7ð #7ð #7ð #7ð #7ð #7ðJ ð<ð <ñ „Xð<ð ðLð Lñ „XðLð ðyð yñ „Xðyð „^ðð ñ „^ðð dhð	>ð 	>ð 	>ð 	>ð 	>ð0ð 0ð 0ð 0ð ;ð ;ð ;ð ;ðð ð ð ðð ð ð Y]ðZð Zð Zð Zð Zðsð sð sð sð"hð hð hð hð,Cð Cð Cð Cð Cð Cð Cð CrD   r!   c                  óv   ‡ — e Zd ZdZddˆ fd„Zed„ ¦   «         Zed„ ¦   «         Zd ˆ fd„Zd!ˆ fd„Z	d"ˆ fd„Z
ˆ xZS )#r$   aÅ  YOLO 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)
    rL   é    é   rM   FrN   rO   r/   ÚnmÚnprrP   rQ   c                óˆ  •‡ ‡— t          ¦   «                              ||||¦  «         |‰ _        |‰ _        t	          |d         ‰ j        ‰ j        ¦  «        ‰ _        t          |d         dz  ‰ j        ¦  «        Št          j        ˆˆ fd„|D ¦   «         ¦  «        ‰ _	        |r t          j        ‰ j	        ¦  «        ‰ _        dS dS )áÊ  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.
        r   rS   c           
   3  ó²   •K  — | ]Q}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        t          j        ‰‰j        d¦  «        ¦  «        V — ŒRdS r^   ©r   rW   r   rX   r  ©rZ   r,   Úc4rJ   s     €€rB   r\   z#Segment.__init__.<locals>.<genexpr>C  ó\   øè è € Ð wÐ wÐop¥¤­t°A°r¸1©~¬~½tÀBÈÈA¹¼ÕPRÔPYÐZ\Ð^bÔ^eÐghÑPiÔPiÑ!jÔ!jÐ wÐ wÐ wÐ wÐ wÐ wrD   N)rc   rd   r  r  r   Úprotork   r   rm   Úcv4rs   rt   Úone2one_cv4)	rJ   rO   r  r  rY   rw   rP   r  rx   s	   `      @€rB   rd   zSegment.__init__2  s½   øøø€ õ 	‰Œ×Ò˜˜W g¨rÑ2Ô2Ð2ØˆŒØˆŒÝ˜2˜aœ5 $¤(¨D¬GÑ4Ô4ˆŒ
å��A”˜!‘˜TœWÑ%Ô%ˆÝ”=Ð wÐ wÐ wÐ wÐ wÐtvÐ wÑ wÔ wÑwÔwˆŒØð 	7Ý#œ}¨T¬XÑ6Ô6ˆDÔÐÐð	7ð 	7rD   c                ó,   — | j         | j        | j        dœS )úIReturns the one-to-many head components, here for backward compatibility.©r|   r}   Ú	mask_head©rn   rp   r  r~   s    rB   r   zSegment.one2manyG  ó   € ð !œH°$´(ÈÌÐRÐRÐRrD   c                ó,   — | j         | j        | j        dœS )r�   r  ©ru   rv   r  r~   s    rB   r‚   zSegment.one2oneL  ó   € ð !Ô,¸$Ô:JÐY]ÔYiÐjÐjÐjrD   r,   r‰   r1   ú4tuple | list[torch.Tensor] | dict[str, torch.Tensor]c                óˆ  •— t          ¦   «                              |¦  «        }t          |t          ¦  «        r|d         n|}|                      |d         ¦  «        }t          |t
          ¦  «        r2d|v r)||d         d<   |                     ¦   «         |d         d<   n||d<   | j        r|S | j        r||fn|d         |f|fS ©úgReturn model outputs and mask coefficients if training, otherwise return outputs and mask coefficients.r   r   r‚   r   r
  ©	rc   r¯   Ú
isinstancerQ   r
  Údictr¤   r§   r«   ©rJ   r,   Úoutputsr¬   r
  rx   s        €rB   r¯   zSegment.forwardQ  óÌ   ø€ å‘'”'—/’/ !Ñ$Ô$ˆÝ(¨µ%Ñ8Ô8ÐE�˜”
�
¸gˆØ—
’
˜1˜Qœ4Ñ Ô ˆÝ�e�TÑ"Ô"ð 	'Ø˜EÐ!Ð!Ø-2��jÔ! 'Ñ*Ø,1¯LªL©N¬N��iÔ  Ñ)Ð)à!&��g‘ØŒ=ð 	ØˆLØ#'¤;ÐP�˜ÐÐ°g¸a´jÀ%Ð5HÈ%Ð4PÐPrD   r‹   r-   c                ó‚   •— t          ¦   «                              |¦  «        }t          j        ||d         gd¬¦  «        S ©z]Decode predicted bounding boxes and class probabilities, concatenated with mask coefficients.Úmask_coefficientr   r5   ©rc   r¨   rh   r�   ©rJ   r,   r¬   rx   s      €rB   r¨   zSegment._inference`  ó:   ø€ å‘”×"Ò" 1Ñ%Ô%ˆÝŒy˜% Ð#5Ô!6Ð7¸QÐ?Ñ?Ô?Ð?rD   r|   rŠ   r}   r  c                óò   •‡ ‡‡‡— t          ¦   «                              ‰||¦  «        }‰�L‰d         j        d         Št          j        ˆˆˆ ˆfd„t          ‰ j        ¦  «        D ¦   «         d¦  «        |d<   |S )ú^Concatenates and returns predicted bounding boxes, class probabilities, and mask coefficients.Nr   c                ór   •— g | ]3} ‰|         ‰|         ¦  «                              ‰‰j        d ¦  «        ‘Œ4S r˜   ©r‘   r  ©rZ   r“   r”   r  rJ   r,   s     €€€€rB   r•   z(Segment.forward_head.<locals>.<listcomp>l  óA   ø€ Ð2tÐ2tÐ2tÐ`a°<°9¸Q´<ÀÀ!ÄÑ3EÔ3E×3JÒ3JÈ2ÈtÌwÐXZÑ3[Ô3[Ð2tÐ2tÐ2trD   r4   r"  ©rc   rŸ   r8   rh   r�   rž   rf   )rJ   r,   r|   r}   r  r¬   r”   rx   s   ``  ` @€rB   rŸ   zSegment.forward_heade  s�   øøøøø€ õ ‘”×$Ò$ Q¨°(Ñ;Ô;ˆØÐ Ø�1””˜A”ˆBÝ(-¬	Ð2tÐ2tÐ2tÐ2tÐ2tÐ2tÐ2tÕejÐkoÔkrÑesÔesÐ2tÑ2tÔ2tÐvwÑ(xÔ(xˆEÐ$Ñ%ØˆrD   ©rL   rÿ   r   rM   FrN   ©rO   r/   r  r/   r  r/   rP   rQ   ©r,   r‰   r1   r  rò   )
r,   r‰   r|   rŠ   r}   rŠ   r  rŠ   r1   r‹   )rô   rõ   rö   r÷   rd   rú   r   r‚   r¯   r¨   rŸ   rü   rý   s   @rB   r$   r$     sî   ø€ € € € € ðð ð(7ð 7ð 7ð 7ð 7ð 7ð 7ð* ðSð Sñ „XðSð ðkð kñ „XðkðQð Qð Qð Qð Qð Qð@ð @ð @ð @ð @ð @ð
ð ð ð ð ð ð ð ð ð rD   r$   c                  ó:   ‡ — e Zd ZdZddˆ fd„Zdd„Zdˆ fd„Zˆ xZS )Ú	Segment26aÄ  YOLO26 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)
    rL   rÿ   r   rM   FrN   rO   r/   r  r  rP   rQ   c                ó–   •— t          ¦   «                              ||||||¦  «         t          || j        | j        |¦  «        | _        dS )r  N)rc   rd   r   r  r  r
  )rJ   rO   r  r  rY   rw   rP   rx   s          €rB   rd   zSegment26.__init__…  sD   ø€ õ 	‰Œ×Ò˜˜R  g¨w¸Ñ;Ô;Ð;Ý˜R ¤¨4¬7°BÑ7Ô7ˆŒ
ˆ
ˆ
rD   r,   r‰   r1   r  c                óÊ  — t                                | |¦  «        }t          |t          ¦  «        r|d         n|}|                      |¦  «        }t          |t
          ¦  «        r`d|v rW||d         d<   t          |t          ¦  «        rt          d„ |D ¦   «         ¦  «        n|                     ¦   «         |d         d<   n||d<   | j        r|S | j        r||fn|d         |f|fS )r  r   r‚   r   r
  c              3  ó>   K  — | ]}|                      ¦   «         V — Œd S rØ   r£   )rZ   Úps     rB   r\   z$Segment26.forward.<locals>.<genexpr>œ  s*   è è € Ð4Ð4¨˜!Ÿ(š(™*œ*Ð4Ð4Ð4Ð4Ð4Ð4rD   r   )	r!   r¯   r  rQ   r
  r  r¤   r§   r«   ©rJ   r,   r  r¬   r
  s        rB   r¯   zSegment26.forward“  sø   € å—.’.  qÑ)Ô)ˆÝ(¨µ%Ñ8Ô8ÐE�˜”
�
¸gˆØ—
’
˜1‘”ˆÝ�e�TÑ"Ô"ð 	'Ø˜EÐ!Ð!Ø-2��jÔ! 'Ñ*å8BÀ5Í%Ñ8PÔ8PÐd•EÐ4Ð4¨eÐ4Ñ4Ô4Ñ4Ô4Ð4ÐV[×VbÒVbÑVdÔVdð �iÔ  Ñ)Ð)ð "'��g‘ØŒ=ð 	ØˆLØ#'¤;ÐP�˜ÐÐ°g¸a´jÀ%Ð5HÈ%Ð4PÐPrD   rè   c                ó¨   •— t          ¦   «                              ¦   «          t          | j        d¦  «        r| j                             ¦   «          dS dS )zTRemove the unused detection branch and training-only prototype layers for inference.rï   N©rc   rï   Úhasattrr
  ©rJ   rx   s    €rB   rï   zSegment26.fuse¤  sJ   ø€ å‰Œ�Š‰ŒˆÝ�4”:˜vÑ&Ô&ð 	ØŒJ�OŠOÑÔÐÐÐð	ð 	rD   r-  r.  r/  ró   )rô   rõ   rö   r÷   rd   r¯   rï   rü   rý   s   @rB   r1  r1  p  s‚   ø€ € € € € ðð ð(8ð 8ð 8ð 8ð 8ð 8ð 8ðQð Qð Qð Qð"ð ð ð ð ð ð ð ð ð rD   r1  c                  ór   ‡ — e Zd ZdZddˆ fd„Zed„ ¦   «         Zed„ ¦   «         Zd ˆ fd„Zd!ˆ fd„Z	d"d„Z
ˆ xZS )#r   a¿  YOLO 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.

    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)
    rL   r   rM   FrN   rO   r/   ÚnerP   rQ   c                ó.  •‡ ‡— t          ¦   «                              ||||¦  «         |‰ _        t          |d         dz  ‰ j        ¦  «        Št	          j        ˆˆ fd„|D ¦   «         ¦  «        ‰ _        |r t          j        ‰ j        ¦  «        ‰ _	        dS dS )a†  Initialize 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.
        r   rS   c           
   3  ó²   •K  — | ]Q}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        t          j        ‰‰j        d¦  «        ¦  «        V — ŒRdS r^   )r   rW   r   rX   r<  r  s     €€rB   r\   zOBB.__init__.<locals>.<genexpr>Í  r	  rD   N)
rc   rd   r<  rk   r   rm   r  rs   rt   r  )rJ   rO   r<  rY   rw   rP   r  rx   s   `     @€rB   rd   zOBB.__init__¿  s›   øøø€ õ 	‰Œ×Ò˜˜W g¨rÑ2Ô2Ð2ØˆŒå��A”˜!‘˜TœWÑ%Ô%ˆÝ”=Ð wÐ wÐ wÐ wÐ wÐtvÐ wÑ wÔ wÑwÔwˆŒØð 	7Ý#œ}¨T¬XÑ6Ô6ˆDÔÐÐð	7ð 	7rD   c                ó,   — | j         | j        | j        dœS )r  ©r|   r}   Ú
angle_headr  r~   s    rB   r   zOBB.one2manyÑ  s   € ð !œH°$´(È$Ì(ÐSÐSÐSrD   c                ó,   — | j         | j        | j        dœS )r�   r@  r  r~   s    rB   r‚   zOBB.one2oneÖ  s   € ð !Ô,¸$Ô:JÐZ^ÔZjÐkÐkÐkrD   r,   r‹   r1   r-   c                ó‚   •— t          ¦   «                              |¦  «        }t          j        ||d         gd¬¦  «        S )z[Decode predicted bounding boxes and class probabilities, concatenated with rotation angles.r¹   r   r5   r#  r$  s      €rB   r¨   zOBB._inferenceÛ  s8   ø€ å‘”×"Ò" 1Ñ%Ô%ˆÝŒy˜%  7¤Ð,°!Ð4Ñ4Ô4Ð4rD   r‰   r|   rŠ   r}   rA  c                ó>  •‡ ‡‡‡— t          ¦   «                              ‰||¦  «        }‰�r‰d         j        d         Št          j        ˆˆˆ ˆfd„t          ‰ j        ¦  «        D ¦   «         d¦  «        }|                     ¦   «         dz
  t          j	        z  }||d<   |S )zSConcatenates and returns predicted bounding boxes, class probabilities, and angles.Nr   c                ór   •— g | ]3} ‰|         ‰|         ¦  «                              ‰‰j        d ¦  «        ‘Œ4S r˜   ©r‘   r<  ©rZ   r“   rA  r”   rJ   r,   s     €€€€rB   r•   z$OBB.forward_head.<locals>.<listcomp>è  ó?   ø€ ÐSÐSÐS¸q��˜A”˜q œtÑ$Ô$×)Ò)¨"¨d¬g°rÑ:Ô:ÐSÐSÐSrD   r4   g      Ð?r¹   )
rc   rŸ   r8   rh   r�   rž   rf   r²   rÊ   Úpi)	rJ   r,   r|   r}   rA  r¬   r¹   r”   rx   s	   ``  `  @€rB   rŸ   zOBB.forward_headà  sž   øøøøø€ õ ‘”×$Ò$ Q¨°(Ñ;Ô;ˆØÐ!Ø�1””˜A”ˆBÝ”IØSÐSÐSÐSÐSÐSÐSÅEÈ$Ì'ÁNÄNÐSÑSÔSÐUVñô ˆEð —]’]‘_”_ tÑ+­t¬wÑ6ˆEØ"ˆE�'‰NØˆrD   rÎ   r»   r¹   c                ó(   — t          |||d¬¦  «        S )zDecode rotated bounding boxes.r   r5   )r	   rÓ   s       rB   r½   zOBB.decode_bboxesî  s   € å˜ ¨°QÐ7Ñ7Ô7Ð7rD   )rL   r   rM   FrN   )rO   r/   r<  r/   rP   rQ   rò   ©
r,   r‰   r|   rŠ   r}   rŠ   rA  rŠ   r1   r‹   )rÎ   r-   r»   r-   r¹   r-   r1   r-   )rô   rõ   rö   r÷   rd   rú   r   r‚   r¨   rŸ   r½   rü   rý   s   @rB   r   r   «  sØ   ø€ € € € € ðð ð&7ð 7ð 7ð 7ð 7ð 7ð 7ð$ ðTð Tñ „XðTð ðlð lñ „Xðlð5ð 5ð 5ð 5ð 5ð 5ð
ð ð ð ð ð ð8ð 8ð 8ð 8ð 8ð 8ð 8ð 8rD   r   c                  ó   — e Zd ZdZdd
„Zd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.

    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,   r‰   r|   rŠ   r}   rA  r1   r‹   c                óè   ‡ ‡‡‡— t                                ‰ ‰||¦  «        }‰�N‰d         j        d         Št          j        ˆˆˆ ˆfd„t          ‰ j        ¦  «        D ¦   «         d¦  «        }||d<   |S )zWConcatenates and returns predicted bounding boxes, class probabilities, and raw angles.Nr   c                ór   •— g | ]3} ‰|         ‰|         ¦  «                              ‰‰j        d ¦  «        ‘Œ4S r˜   rF  rG  s     €€€€rB   r•   z&OBB26.forward_head.<locals>.<listcomp>  rH  rD   r4   r¹   )r!   rŸ   r8   rh   r�   rž   rf   )rJ   r,   r|   r}   rA  r¬   r¹   r”   s   ``  `  @rB   rŸ   zOBB26.forward_head  s‚   øøøø€ õ ×#Ò# D¨!¨X°xÑ@Ô@ˆØÐ!Ø�1””˜A”ˆBÝ”IØSÐSÐSÐSÐSÐSÐSÅEÈ$Ì'ÁNÄNÐSÑSÔSÐUVñô ˆEð #ˆE�'‰NØˆrD   NrK  )rô   rõ   rö   r÷   rŸ   rN   rD   rB   rM  rM  ó  s2   € € € € € ðð ð$ð ð ð ð ð rD   rM  c                  ór   ‡ — e Zd ZdZddˆ fd„Zed„ ¦   «         Zed„ ¦   «         Zdˆ fd„Zdˆ fd„Z	d d„Z
ˆ xZS )!r"   a  YOLO 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)
    rL   ©é   rV   rM   FrN   rO   r/   Ú	kpt_shaperQ   rP   c                óZ  •‡ ‡— t          ¦   «                              ||||¦  «         |‰ _        |d         |d         z  ‰ _        t	          |d         dz  ‰ j        ¦  «        Št          j        ˆˆ fd„|D ¦   «         ¦  «        ‰ _        |r t          j	        ‰ j        ¦  «        ‰ _
        dS dS )á¿  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.
        r   r   rS   c           
   3  ó²   •K  — | ]Q}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        t          j        ‰‰j        d¦  «        ¦  «        V — ŒRdS r^   )r   rW   r   rX   Únkr  s     €€rB   r\   z Pose.__init__.<locals>.<genexpr>8  r	  rD   N)rc   rd   rS  rW  rk   r   rm   r  rs   rt   r  ©rJ   rO   rS  rY   rw   rP   r  rx   s   `     @€rB   rd   zPose.__init__)  s¯   øøø€ õ 	‰Œ×Ò˜˜W g¨rÑ2Ô2Ð2Ø"ˆŒØ˜A”, ¨1¤Ñ-ˆŒå��A”˜!‘˜TœWÑ%Ô%ˆÝ”=Ð wÐ wÐ wÐ wÐ wÐtvÐ wÑ wÔ wÑwÔwˆŒØð 	7Ý#œ}¨T¬XÑ6Ô6ˆDÔÐÐð	7ð 	7rD   c                ó,   — | j         | j        | j        dœS )r  ©r|   r}   Ú	pose_headr  r~   s    rB   r   zPose.one2many<  r  rD   c                ó,   — | j         | j        | j        dœS )r�   rZ  r  r~   s    rB   r‚   zPose.one2oneA  r  rD   r,   r‹   r1   r-   c                ó¨   •— t          ¦   «                              |¦  «        }t          j        ||                      |d         ¦  «        gd¬¦  «        S )zUDecode predicted bounding boxes and class probabilities, concatenated with keypoints.Úkptsr   r5   )rc   r¨   rh   r�   Úkpts_decoder$  s      €rB   r¨   zPose._inferenceF  sF   ø€ å‘”×"Ò" 1Ñ%Ô%ˆÝŒy˜% ×!1Ò!1°!°F´)Ñ!<Ô!<Ð=À1ÐEÑEÔEÐErD   r‰   r|   rŠ   r}   r[  c                óò   •‡ ‡‡‡— t          ¦   «                              ‰||¦  «        }‰�L‰d         j        d         Št          j        ˆˆˆ ˆfd„t          ‰ j        ¦  «        D ¦   «         d¦  «        |d<   |S )úVConcatenates and returns predicted bounding boxes, class probabilities, and keypoints.Nr   c                ór   •— g | ]3} ‰|         ‰|         ¦  «                              ‰‰j        d ¦  «        ‘Œ4S r˜   ©r‘   rW  )rZ   r“   r”   r[  rJ   r,   s     €€€€rB   r•   z%Pose.forward_head.<locals>.<listcomp>R  s@   ø€ Ð&hÐ&hÐ&hÐTU | y°¤|°A°a´DÑ'9Ô'9×'>Ò'>¸rÀ4Ä7ÈBÑ'OÔ'OÐ&hÐ&hÐ&hrD   r4   r^  r,  )rJ   r,   r|   r}   r[  r¬   r”   rx   s   ``  ` @€rB   rŸ   zPose.forward_headK  s   øøøøø€ õ ‘”×$Ò$ Q¨°(Ñ;Ô;ˆØÐ Ø�1””˜A”ˆBÝ!œIÐ&hÐ&hÐ&hÐ&hÐ&hÐ&hÐ&hÕY^Ð_cÔ_fÑYgÔYgÐ&hÑ&hÔ&hÐjkÑlÔlˆE�&‰MØˆrD   r^  c                óÒ  — | j         d         }|j        d         }| j        r– |j        |g| j         ¢d‘R Ž }|dd…dd…dd…f         dz  | j        dz
  z   | j        z  }|dk    r8t          j        ||dd…dd…dd…f                              ¦   «         fd¦  «        }|                     || j	        d¦  «        S | 
                    ¦   «         }|dk    r+|dd…dd|…f                              ¦   «         |dd…dd|…f<   |dd…dd|…f         dz  | j        d         dz
  z   | j        z  |dd…dd|…f<   |dd…dd|…f         dz  | j        d         dz
  z   | j        z  |dd…dd|…f<   |S )	ú"Decode keypoints from predictions.r   r   r7   Nr4   rÂ   r¸   rV   ©rS  r8   r«   r‘   r»   r¼   rh   r�   r²   rW  Úclone©rJ   r^  rG   r”   r®   r·   s         rB   r_  zPose.kpts_decodeU  s©  € àŒ~˜aÔ ˆØŒZ˜Œ]ˆØŒ;ð 	Ø�”	˜"Ð2˜tœ~Ð2¨rÐ2Ð2Ð2ˆAØ�1�1�1�a�a�a˜˜!˜�8”˜sÑ" d¤l°SÑ&8Ñ9¸T¼\ÑIˆAØ�qŠyˆyÝ”I˜q ! A A A q q q¨!¨A¨# I¤,×"6Ò"6Ñ"8Ô"8Ð9¸1Ñ=Ô=�Ø—6’6˜"˜dœg rÑ*Ô*Ð*à—
’
‘”ˆAØ�qŠyˆyØ ! ! ! ! Q W¨ W *¤× 5Ò 5Ñ 7Ô 7��!�!�!�Q�W˜�W�*‘Ø˜q˜q˜q ! ' T '˜zœ]¨SÑ0°D´LÀ´OÀcÑ4IÑJÈdÌlÑZˆAˆaˆaˆa���D�ˆj‰MØ˜q˜q˜q ! ' T '˜zœ]¨SÑ0°D´LÀ´OÀcÑ4IÑJÈdÌlÑZˆAˆaˆaˆa���D�ˆj‰MØˆHrD   ©rL   rQ  rM   FrN   ©rO   r/   rS  rQ   rP   rQ   rò   )
r,   r‰   r|   rŠ   r}   rŠ   r[  rŠ   r1   r‹   ©r^  r-   r1   r-   )rô   rõ   rö   r÷   rd   rú   r   r‚   r¨   rŸ   r_  rü   rý   s   @rB   r"   r"     sÞ   ø€ € € € € ðð ð(7ð 7ð 7ð 7ð 7ð 7ð 7ð& ðSð Sñ „XðSð ðkð kñ „XðkðFð Fð Fð Fð Fð Fð
ð ð ð ð ð ðð ð ð ð ð ð ð rD   r"   c                  ón   ‡ — e Zd ZdZdd ˆ fd„Zed„ ¦   «         Zed„ ¦   «         Zd!d„Zd"ˆ fd„Z	d#d„Z
ˆ xZ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)
    rL   rQ  rM   FrN   rO   r/   rS  rQ   rP   c                ó�  •‡ ‡— t          ¦   «                              |||||¦  «         t          ¦   «         ‰ _        t	          |d         dz  |d         |d         dz   z  ¦  «        Št          j        ˆfd„|D ¦   «         ¦  «        ‰ _        t          j        ˆˆ fd„|D ¦   «         ¦  «        ‰ _        |d         dz  ‰ _	        t          j        ˆˆ fd„|D ¦   «         ¦  «        ‰ _
        |r\t          j        ‰ j        ¦  «        ‰ _        t          j        ‰ j        ¦  «        ‰ _        t          j        ‰ j
        ¦  «        ‰ _        dS dS )	rU  r   rS   r   r4   c           	   3  ó~   •K  — | ]7}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        ¦  «        V — Œ8dS )rV   N©r   rW   r   )rZ   r,   r  s     €rB   r\   z"Pose26.__init__.<locals>.<genexpr>‹  sD   øè è € Ð \Ð \ÐTU¥¤­t°A°r¸1©~¬~½tÀBÈÈA¹¼Ñ!OÔ!OÐ \Ð \Ð \Ð \Ð \Ð \rD   c              3  óN   •K  — | ]}t          j        ‰‰j        d ¦  «        V — Œ dS ©r   N)r   rX   rW  ©rZ   Ú_r  rJ   s     €€rB   r\   z"Pose26.__init__.<locals>.<genexpr>�  s3   øè è € Ð%LÐ%LÀA¥b¤i°°D´G¸QÑ&?Ô&?Ð%LÐ%LÐ%LÐ%LÐ%LÐ%LrD   c              3  óN   •K  — | ]}t          j        ‰‰j        d ¦  «        V — Œ dS rr  )r   rX   Únk_sigmars  s     €€rB   r\   z"Pose26.__init__.<locals>.<genexpr>�  s3   øè è € Ð&SÐ&SÈ1¥r¤y°°T´]ÀAÑ'FÔ'FÐ&SÐ&SÐ&SÐ&SÐ&SÐ&SrD   N)rc   rd   r   Ú
flow_modelrk   r   rm   r  Úcv4_kptsrv  Ú	cv4_sigmars   rt   r  Úone2one_cv4_kptsÚone2one_cv4_sigmarX  s   `     @€rB   rd   zPose26.__init__}  s<  øøø€ õ 	‰Œ×Ò˜˜Y¨°¸"Ñ=Ô=Ð=Ý!™)œ)ˆŒå��A”˜!‘˜Y qœ\¨Y°q¬\¸AÑ-=Ñ>Ñ?Ô?ˆÝ”=Ð \Ð \Ð \Ð \ÐY[Ð \Ñ \Ô \Ñ\Ô\ˆŒåœÐ%LÐ%LÐ%LÐ%LÐ%LÈÐ%LÑ%LÔ%LÑLÔLˆŒØ! !œ qÑ(ˆŒÝœÐ&SÐ&SÐ&SÐ&SÐ&SÐPRÐ&SÑ&SÔ&SÑSÔSˆŒàð 	CÝ#œ}¨T¬XÑ6Ô6ˆDÔÝ$(¤M°$´-Ñ$@Ô$@ˆDÔ!Ý%)¤]°4´>Ñ%BÔ%BˆDÔ"Ð"Ð"ð	Cð 	CrD   c                óD   — | j         | j        | j        | j        | j        dœS )r  ©r|   r}   r[  Ú	kpts_headÚkpts_sigma_head)rn   rp   r  rx  ry  r~   s    rB   r   zPose26.one2many–  s,   € ð œØœØœØœØ#œ~ð
ð 
ð 	
rD   c                óD   — | j         | j        | j        | j        | j        dœS )r�   r}  )ru   rv   r  rz  r{  r~   s    rB   r‚   zPose26.one2one¡  s1   € ð Ô(ØÔ(ØÔ)ØÔ.Ø#Ô5ð
ð 
ð 	
rD   r,   r‰   r|   rŠ   r}   r[  r~  r  r1   r‹   c                ó¬  ‡ ‡‡‡‡‡‡	— t                                ‰ ‰||¦  «        }‰�­‰d         j        d         Šˆˆfd„t          ‰ j        ¦  «        D ¦   «         Š	t          j        ˆˆ	ˆˆ fd„t          ‰ j        ¦  «        D ¦   «         d¦  «        |d<   ‰ j        r9t          j        ˆˆ	ˆˆ fd„t          ‰ j        ¦  «        D ¦   «         d¦  «        |d<   |S )	ra  Nr   c                ó>   •— g | ]} ‰|         ‰|         ¦  «        ‘ŒS rN   rN   )rZ   r“   r[  r,   s     €€rB   r•   z'Pose26.forward_head.<locals>.<listcomp>¹  s+   ø€ ÐCÐCÐC¨q˜˜	 !œ Q q¤TÑ*Ô*ÐCÐCÐCrD   c                ór   •— g | ]3} ‰|         ‰|         ¦  «                              ‰‰j        d ¦  «        ‘Œ4S r˜   rc  )rZ   r“   r”   Úfeaturesr~  rJ   s     €€€€rB   r•   z'Pose26.forward_head.<locals>.<listcomp>º  sA   ø€ Ð&oÐ&oÐ&oÐ[\ | y°¤|°H¸Q´KÑ'@Ô'@×'EÒ'EÀbÈ$Ì'ÐSUÑ'VÔ'VÐ&oÐ&oÐ&orD   r4   r^  c                ór   •— g | ]3} ‰|         ‰|         ¦  «                              ‰‰j        d ¦  «        ‘Œ4S r˜   )r‘   rv  )rZ   r“   r”   r„  r  rJ   s     €€€€rB   r•   z'Pose26.forward_head.<locals>.<listcomp>½  sB   ø€ ÐiÐiÐiÐUVÐ'�_ QÔ'¨°¬Ñ4Ô4×9Ò9¸"¸d¼mÈRÑPÔPÐiÐiÐirD   Ú
kpts_sigma)r!   rŸ   r8   rž   rf   rh   r�   r§   )
rJ   r,   r|   r}   r[  r~  r  r¬   r”   r„  s
   ``  ``` @@rB   rŸ   zPose26.forward_head¬  sõ   øøøøøøø€ õ ×#Ò# D¨!¨X°xÑ@Ô@ˆØÐ Ø�1””˜A”ˆBØCÐCÐCÐCÐCµE¸$¼'±N´NÐCÑCÔCˆHÝ!œIÐ&oÐ&oÐ&oÐ&oÐ&oÐ&oÐ&oÕ`eÐfjÔfmÑ`nÔ`nÐ&oÑ&oÔ&oÐqrÑsÔsˆE�&‰MØŒ}ð Ý&+¤iØiÐiÐiÐiÐiÐiÐiÕZ_Ð`dÔ`gÑZhÔZhÐiÑiÔiÐklñ'ô '��lÑ#ð ˆrD   rè   c                óŠ   •— t          ¦   «                              ¦   «          d| _        t          | | j        rdndd¦  «         dS )zJRemove the unused detection branch and training-only layers for inference.Nr{  ry  )rc   rï   rw  rí   rw   r:  s    €rB   rï   zPose26.fuseÁ  s@   ø€ å‰Œ�Š‰ŒˆØˆŒÝ�¨T¬\ÐJÐ)Ð)¸{ÈDÑQÔQÐQÐQÐQrD   r^  r-   c                ó®  — | j         d         }|j        d         }| j        r� |j        |g| j         ¢d‘R Ž }|dd…dd…dd…f         | j        z   | j        z  }|dk    r8t          j        ||dd…dd…dd…f                              ¦   «         fd¦  «        }|                     || j	        d¦  «        S | 
                    ¦   «         }|dk    r+|dd…dd|…f                              ¦   «         |dd…dd|…f<   |dd…dd|…f         | j        d         z   | j        z  |dd…dd|…f<   |dd…dd|…f         | j        d         z   | j        z  |dd…dd|…f<   |S )re  r   r   r7   Nr4   rV   rf  rh  s         rB   r_  zPose26.kpts_decodeÇ  s‹  € àŒ~˜aÔ ˆØŒZ˜Œ]ˆØŒ;ð 	Ø�”	˜"Ð2˜tœ~Ð2¨rÐ2Ð2Ð2ˆAà�1�1�1�a�a�a˜˜!˜�8”˜tœ|Ñ+¨t¬|Ñ;ˆAØ�qŠyˆyÝ”I˜q ! A A A q q q¨!¨A¨# I¤,×"6Ò"6Ñ"8Ô"8Ð9¸1Ñ=Ô=�Ø—6’6˜"˜dœg rÑ*Ô*Ð*à—
’
‘”ˆAØ�qŠyˆyØ ! ! ! ! Q W¨ W *¤× 5Ò 5Ñ 7Ô 7��!�!�!�Q�W˜�W�*‘Ø˜q˜q˜q ! ' T '˜zœ]¨T¬\¸!¬_Ñ<ÀÄÑLˆAˆaˆaˆa���D�ˆj‰MØ˜q˜q˜q ! ' T '˜zœ]¨T¬\¸!¬_Ñ<ÀÄÑLˆAˆaˆaˆa���D�ˆj‰MØˆHrD   ri  rj  )r,   r‰   r|   rŠ   r}   rŠ   r[  rŠ   r~  rŠ   r  rŠ   r1   r‹   ró   rk  )rô   rõ   rö   r÷   rd   rú   r   r‚   rŸ   rï   r_  rü   rý   s   @rB   rm  rm  h  sÕ   ø€ € € € € ðð ð(Cð Cð Cð Cð Cð Cð Cð2 ð
ð 
ñ „Xð
ð ð
ð 
ñ „Xð
ðð ð ð ð*Rð Rð Rð Rð Rð Rðð ð ð ð ð ð ð rD   rm  c                  ó2   ‡ — e Zd ZdZdZddˆ fd	„Zdd„Zˆ xZS )r    aÉ  YOLO Depth head for monocular depth estimation.

    A dense prediction head that takes multi-scale backbone features and produces a single-channel depth map via
    progressive upsampling and fusion.

    Attributes:
        nl (int): Number of pyramid levels.
        cal_a (torch.Tensor): Log-affine calibration scale buffer, identity 1.0 by default.
        cal_b (torch.Tensor): Log-affine calibration offset buffer, identity 0.0 by default.

    Examples:
        >>> depth = Depth(ch=(256, 512, 1024))
        >>> x = [torch.randn(1, 256, 80, 80), torch.randn(1, 512, 40, 40), torch.randn(1, 1024, 20, 20)]
        >>> out = depth(x)  # training: {"depth": (1, 1, 160, 160)} at P2 resolution (input/4)
    Fr   rN   Úc_midr/   rP   rQ   c           
     óþ  •‡— t          ¦   «                              ¦   «          t          |¦  «        | _        t	          j        ˆfd„|D ¦   «         ¦  «        | _        t	          j        ˆfd„|dd…         D ¦   «         ¦  «        | _        t	          j        t          ‰‰dz  d¬¦  «        t	          j
        ‰dz  ‰dz  ddd¬	¦  «        t          ‰dz  ‰d
z  d¬¦  «        t	          j        ‰d
z  dd¬¦  «        ¦  «        | _        | j        d         j        j                             d¦  «         |                      dt#          j        d¦  «        ¦  «         |                      dt#          j        d¦  «        ¦  «         dS )zÔInitialize Depth head.

        Args:
            c_mid (int): Number of intermediate channels for the fusion decoder.
            ch (tuple): Input channel sizes from backbone feature maps (P3, P4, P5).
        c              3  ó<   •K  — | ]}t          |‰d ¬¦  «        V — ŒdS )r   ©r.   N)r   )rZ   ÚcrŠ  s     €rB   r\   z!Depth.__init__.<locals>.<genexpr>ù  s2   øè è € Ð!BÐ!B¸!¥$ q¨%°1Ð"5Ñ"5Ô"5Ð!BÐ!BÐ!BÐ!BÐ!BÐ!BrD   c           	   3  ó‚   •K  — | ]9}t          j        t          ‰‰d ¬¦  «        t          ‰‰d ¬¦  «        ¦  «        V — Œ:dS )rV   r�  Nrp  )rZ   rt  rŠ  s     €rB   r\   z!Depth.__init__.<locals>.<genexpr>ü  sQ   øè è € Ð#uÐ#uÐhi¥B¤Mµ$°u¸eÀqÐ2IÑ2IÔ2IÍ4ÐPUÐW\Ð`aÐKbÑKbÔKbÑ$cÔ$cÐ#uÐ#uÐ#uÐ#uÐ#uÐ#urD   Nr7   r4   rV   r�  T)Úkernel_sizerj   rÈ   rS   r   ©r�  g²�ï§ÆKÇ?Úcal_aÚcal_b)rc   rd   re   rf   r   rm   ÚprojÚrefinerW   r   ÚConvTranspose2drX   ÚheadrÈ   rÉ   Úfill_Úregister_bufferrh   Úonesri   )rJ   rŠ  rP   rx   s    ` €rB   rd   zDepth.__init__î  si  øø€ õ 	‰Œ×ÒÑÔÐÝ�b‘'”'ˆŒõ ”MÐ!BÐ!BÐ!BÐ!B¸rÐ!BÑ!BÔ!BÑBÔBˆŒ	õ ”mÐ#uÐ#uÐ#uÐ#uÐmoÐpsÐqsÐpsÔmtÐ#uÑ#uÔ#uÑuÔuˆŒå”MÝ�˜ ™
 aÐ(Ñ(Ô(ÝÔ˜u¨™z¨5°A©:À1ÈQÐUYÐZÑZÔZÝ�˜!‘˜U a™Z¨1Ð-Ñ-Ô-ÝŒI�e˜q‘j !°Ð3Ñ3Ô3ñ	
ô 
ˆŒ	ð 	Œ	�"ŒÔÔ×%Ò% eÑ,Ô,Ð,ð 	×Ò˜W¥e¤j°¡m¤mÑ4Ô4Ð4Ø×Ò˜W¥e¤k°!¡n¤nÑ5Ô5Ð5Ð5Ð5rD   r,   r‰   r1   ú&dict[str, torch.Tensor] | torch.Tensorc                ó<  ‡ ‡— ˆ ˆfd„t          ‰ j        ¦  «        D ¦   «         }|d         }t          ‰ j        dz
  dd¦  «        D ];}t          j        |ddd¬¦  «        }|||         z   } ‰ j        |         |¦  «        }Œ<‰                      |¦  «        }t          j        |                     dd¦  «        ¦  «        }‰ j	        rd	|iS | 
                    ‰ j        ¦  «        ‰ j                             ¦   «         z  }‰ j        rt          j        |d
dd¬¦  «        }|S )aÛ  Fuse multi-scale features and predict depth.

        Args:
            x: List of feature tensors [P3, P4, P5] from the backbone/neck.

        Returns:
            Training: dict {"depth": (B, 1, H/4, W/4)}, the raw head output the loss supervises.
            Eval: (B, 1, H/4, W/4) with calibration applied; the predictor/validator resize to image/GT size.
            Export (self.export=True): (B, 1, H, W), upsampled 4x to the input size. Output is unbounded.
        c                óH   •— g | ]} ‰j         |         ‰|         ¦  «        ‘ŒS rN   )r”  )rZ   r“   rJ   r,   s     €€rB   r•   z!Depth.forward.<locals>.<listcomp>  s-   ø€ Ð<Ð<Ð<¨��”˜1”˜a œdÑ#Ô#Ð<Ð<Ð<rD   r7   r4   ÚbilinearT©Úscale_factorÚmodeÚalign_cornersg      Àg      @Údepthg      @F)rž   rf   ÚFÚinterpolater•  r—  rh   ÚexpÚclampr§   Úpowr’  r“  r«   )rJ   r,   rœ   Úoutr“   r£  s   ``    rB   r¯   zDepth.forward  s!  øø€ ð =Ð<Ð<Ð<Ð<­U°4´7©^¬^Ð<Ñ<Ô<ˆà�BŒiˆÝ�t”w ‘{ B¨Ñ+Ô+ð 	&ð 	&ˆAõ ”- °!¸*ÐTXÐYÑYÔYˆCØ˜˜aœ‘.ˆCØ �$”+˜a”. Ñ%Ô%ˆCˆCà�iŠi˜‰nŒnˆÝ”	˜#Ÿ)š) D¨#Ñ.Ô.Ñ/Ô/ˆàŒ=ð 	$Ø˜UÐ#Ð#à—	’	˜$œ*Ñ%Ô%¨¬
¯ªÑ(8Ô(8Ñ8ˆØŒ;ð 	aÝ”M %°cÀ
ÐZ_Ð`Ñ`Ô`ˆEØˆrD   )r   rN   )rŠ  r/   rP   rQ   )r,   r‰   r1   r›  ©rô   rõ   rö   r÷   r«   rd   r¯   rü   rý   s   @rB   r    r    Û  sg   ø€ € € € € ðð ð  €Fð6ð 6ð 6ð 6ð 6ð 6ð 6ð:ð ð ð ð ð ð ð rD   r    c                  ó2   ‡ — e Zd ZdZdZddˆ fd„Zdd„Zˆ xZS )r   aä  YOLO 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   NÚc1r/   r[   r.   rÖ   r5  ú
int | NoneÚgc                ó  •— t          ¦   «                              ¦   «          d}t          ||||||¦  «        | _        t	          j        d¦  «        | _        t	          j        dd¬¦  «        | _        t	          j	        ||¦  «        | _
        dS )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.
        i   r   ç        T)r5  ÚinplaceN)rc   rd   r   Úconvr   ÚAdaptiveAvgPool2dÚpoolÚDropoutÚdropÚLinearÚlinear)	rJ   r¬  r[   r.   rÖ   r5  r®  Úc_rx   s	           €rB   rd   zClassify.__init__E  sx   ø€ õ 	‰Œ×ÒÑÔÐØˆÝ˜˜R  A q¨!Ñ,Ô,ˆŒ	ÝÔ(¨Ñ+Ô+ˆŒ	Ý”J ¨dÐ3Ñ3Ô3ˆŒ	Ý”i  BÑ'Ô'ˆŒˆˆrD   r,   ú!list[torch.Tensor] | torch.Tensorr1   útorch.Tensor | tuplec           	     ón  — t          |t          ¦  «        rt          j        |d¦  «        }|                      |                      |                      |                      |¦  «        ¦  «                             d¦  «        ¦  «        ¦  «        }| j	        r|S | 
                    d¦  «        }| j        r|n||fS )z+Perform forward pass on input feature maps.r   )r  Úlistrh   r�   r¸  r¶  r´  r²  r;   r§   Úsoftmaxr«   )rJ   r,   r®   s      rB   r¯   zClassify.forwardW  s—   € å�a�ÑÔð 	 Ý”	˜!˜Q‘”ˆAØ�KŠK˜Ÿ	š	 $§)¢)¨D¯IªI°a©L¬LÑ"9Ô"9×"AÒ"AÀ!Ñ"DÔ"DÑEÔEÑFÔFˆØŒ=ð 	ØˆHØ�IŠI�a‰LŒLˆØ”KÐ+ˆqˆq a¨ VÐ+rD   )r   r   Nr   )r¬  r/   r[   r/   r.   r/   rÖ   r/   r5  r­  r®  r/   )r,   rº  r1   r»  rª  rý   s   @rB   r   r   -  sg   ø€ € € € € ðð ð* €Fð(ð (ð (ð (ð (ð (ð (ð$,ð ,ð ,ð ,ð ,ð ,ð ,ð ,rD   r   c                  ó@   ‡ — e Zd ZdZ	 	 	 	 	 	 ddˆ fd„Zdd„Zd„ Zˆ xZS )ÚWorldDetectaˆ  Head 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)
    rL   é   FrM   rN   rO   r/   ÚembedÚwith_bnÚboolrY   rw   rP   rQ   c                óB  •‡‡‡— t          ¦   «                              ||||¬¦  «         t          |d         t          | j        d¦  «        ¦  «        Št          j        ˆˆfd„|D ¦   «         ¦  «        | _        t          j        ˆˆfd„|D ¦   «         ¦  «        | _        dS )áÙ  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.
        )rY   rw   rP   r   rT   c           
   3  ó¨   •K  — | ]L}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        t          j        ‰‰d¦  «        ¦  «        V — ŒMdS r^   ©r   rW   r   rX   ©rZ   r,   ra   rÂ  s     €€rB   r\   z'WorldDetect.__init__.<locals>.<genexpr>�  sY   øè è € Ð uÐ uÐmn¥¤­t°A°r¸1©~¬~½tÀBÈÈA¹¼ÕPRÔPYÐZ\Ð^cÐefÑPgÔPgÑ!hÔ!hÐ uÐ uÐ uÐ uÐ uÐ urD   c              3  óV   •K  — | ]#}‰rt          ‰¦  «        nt          ¦   «         V — Œ$d S rØ   ©r   r   ©rZ   rt  rÂ  rÃ  s     €€rB   r\   z'WorldDetect.__init__.<locals>.<genexpr>Ž  ó=   øè è € Ð hÐ hÐ`a¸WÐ![Õ!2°5Ñ!9Ô!9Ð!9Í/ÑJ[ÔJ[Ð hÐ hÐ hÐ hÐ hÐ hrD   N)	rc   rd   rk   rl   rO   r   rm   rp   r  ©	rJ   rO   rÂ  rÃ  rY   rw   rP   ra   rx   s	     ``   @€rB   rd   zWorldDetect.__init__x  s    øøøø€ õ& 	‰Œ×Ò˜ W°gÀ"ÐÑEÔEÐEÝ��A”�˜DœG SÑ)Ô)Ñ*Ô*ˆÝ”=Ð uÐ uÐ uÐ uÐ uÐrtÐ uÑ uÔ uÑuÔuˆŒÝ”=Ð hÐ hÐ hÐ hÐ hÐegÐ hÑ hÔ hÑhÔhˆŒˆˆrD   r,   r‰   Útextr-   r1   údict[str, torch.Tensor] | tuplec           
     ób  ‡ ‡
— t          |¦  «        }t          ‰ j        ¦  «        D ]e}t          j         ‰ j        |         ||         ¦  «         ‰ j        |          ‰ j        |         ||         ¦  «        |¦  «        fd¦  «        ||<   Œf‰ j        ‰ j	        dz  z   ‰ _
        |d         j        d         Š
t          j        ˆ
ˆ fd„|D ¦   «         d¦  «        }|                     ‰ j	        dz  ‰ j        fd¦  «        \  }}|||dœ}‰ j        r|S ‰                      |¦  «        }	‰ j        r|	n|	|fS )zHConcatenate and return predicted bounding boxes and class probabilities.r   rS   r   c                óH   •— g | ]}|                      ‰‰j        d ¦  «        ‘ŒS r˜   )r‘   rg   )rZ   r¦   r”   rJ   s     €€rB   r•   z'WorldDetect.forward.<locals>.<listcomp>—  s+   ø€ Ð@Ð@Ð@¸˜2Ÿ7š7 2 t¤w°Ñ3Ô3Ð@Ð@Ð@rD   r4   r™   )r½  rž   rf   rh   r�   rn   r  rp   rO   rY   rg   r8   rÛ   r§   r¨   r«   )rJ   r,   rÏ  rœ   r“   Úx_catrš   r›   r¬   r®   r”   s   `         @rB   r¯   zWorldDetect.forward�  s6  øø€ å�Q‘”ˆÝ�t”w‘”ð 	[ð 	[ˆAÝ”9˜k˜dœh qœk¨!¨A¬$Ñ/Ô/°°´¸!´¸[¸T¼XÀa¼[ÈÈ1ÌÑ=NÔ=NÐPTÑ1UÔ1UÐVÐXYÑZÔZˆAˆa‰DˆDØ”'˜DœL¨1Ñ,Ñ,ˆŒØˆqŒTŒZ˜Œ]ˆÝ”	Ð@Ð@Ð@Ð@Ð@¸aÐ@Ñ@Ô@À!ÑDÔDˆØŸš T¤\°AÑ%5°t´wÐ$?ÀÑCÔC‰ˆˆvØ¨6¸EÐBÐBˆØŒ=ð 	ØˆLØ�OŠO˜EÑ"Ô"ˆØ”KÐ/ˆqˆq a¨ ZÐ/rD   c                ó†   — | }t          |j        |j        |j        ¦  «        D ]\  }}}d|d         j        j        dd…<   ŒdS )rÁ   ç      ð?r7   N)rÇ   rn   rp   rj   rÈ   rÉ   )rJ   Úmr·   rÌ   rÖ   s        rB   rÍ   zWorldDetect.bias_initŸ  sS   € àˆõ ˜1œ5 !¤%¨¬Ñ2Ô2ð 	%ð 	%‰GˆAˆq�!Ø!$ˆAˆbŒEŒJŒO˜A˜A˜AÑÐð	%ð 	%rD   ©rL   rÁ  FrM   FrN   )rO   r/   rÂ  r/   rÃ  rÄ  rY   r/   rw   rÄ  rP   rQ   )r,   r‰   rÏ  r-   r1   rÐ  )rô   rõ   rö   r÷   rd   r¯   rÍ   rü   rý   s   @rB   rÀ  rÀ  b  sŠ   ø€ € € € € ðð ð. ØØØØØðið ið ið ið ið ið ið00ð 0ð 0ð 0ð%ð %ð %ð %ð %ð %ð %rD   rÀ  c                  óF   ‡ — e Zd ZdZddˆ fd	„Zedd„¦   «         Zdd„Zˆ xZS )ÚLRPCHeadaX  Lightweight 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)
    TÚvocabú	nn.ModuleÚpfÚlocÚenabledrÄ  c                ó®   •— t          ¦   «                              ¦   «          |r|                      |¦  «        n|| _        || _        || _        || _        dS )aW  Initialize 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)rc   rd   Úconv2linearrÚ  rÜ  rÝ  rÞ  )rJ   rÚ  rÜ  rÝ  rÞ  rx   s        €rB   rd   zLRPCHead.__init__Á  sS   ø€ õ 	‰Œ×ÒÑÔÐØ07ÐB�T×%Ò% eÑ,Ô,Ð,¸UˆŒ
ØˆŒØˆŒØˆŒˆˆrD   r²  ú	nn.Conv2dr1   ú	nn.Linearc                óV  — t          | t          j        ¦  «        r| j        dk    sJ ‚t          j        | j        | j        ¦  «                             | j        j	        ¦  «        }| j         
                    | j        d¦  «        j        |j        _        | j        j        |j        _        |S )z4Convert a 1x1 convolutional layer to a linear layer.)r   r   r7   )r  r   rX   r�  r·  Úin_channelsÚout_channelsÚrequires_grad_ÚweightÚrequires_gradr‘   rÉ   rÈ   )r²  r¸  s     rB   rà  zLRPCHead.conv2linearÐ  sˆ   € õ ˜$¥¤	Ñ*Ô*ÐI¨tÔ/?À6Ò/IÐ/IÐ/IÐIÝ”˜4Ô+¨TÔ->Ñ?Ô?×NÒNÈtÌ{ÔOhÑiÔiˆØ!œ[×-Ò-¨dÔ.?ÀÑDÔDÔIˆŒÔØœ9œ>ˆŒÔØˆrD   Úcls_featr-   Úloc_featrß   rä   útuple[tuple, torch.Tensor]c                ó¦  — | j         �rP|sh|                      |                     d¦  «                             dd¦  «        ¦  «        }|                      |¦  «        |                     dd¦  «        dfS |                      |¦  «        d                              d¦  «        }|                     ¦   «         |k    }|                     d¦  «                             dd¦  «        }|                      |r|dd…|f         n)||                     d¦  «                             ¦   «         z  ¦  «        }|                      |¦  «        |                     dd¦  «        |fS |                      |¦  «        }|                      |¦  «        }||                     d¦  «        | 	                    |j
        d         |j
        d         z  t          j        ¬¦  «        fS )	zQProcess classification and localization features to generate detection proposals.r4   r7   éþÿÿÿN)r   r   r   rV   )Údtype)rÞ  rÚ  r;   r¶   rÝ  rÜ  r²   r¾   r/   Únew_onesr8   rh   rÄ  )rJ   ré  rê  rß   Úpf_scoreÚmasks         rB   r¯   zLRPCHead.forwardÙ  s¤  € àŒ<ñ 	Øð LØŸ:š: h×&6Ò&6°qÑ&9Ô&9×&CÒ&CÀBÈÑ&KÔ&KÑLÔL�Ø—x’x Ñ)Ô)¨8×+=Ò+=¸bÀ"Ñ+EÔ+EÀtÐKÐKØ—w’w˜xÑ(Ô(¨Ô.×6Ò6°qÑ9Ô9ˆHØ×#Ò#Ñ%Ô%¨Ò,ˆDØ×'Ò'¨Ñ*Ô*×4Ò4°R¸Ñ<Ô<ˆHØ—z’z°tÐ"d (¨1¨1¨1¨d¨7Ô"3Ð"3ÀÈDÏNÊNÐ[]ÑL^ÔL^×LbÒLbÑLdÔLdÑAdÑeÔeˆHØ—8’8˜HÑ%Ô% x×'9Ò'9¸"¸bÑ'AÔ'AÀ4ÐGÐGà—z’z (Ñ+Ô+ˆHØ—x’x Ñ)Ô)ˆHàØ× Ò  Ñ#Ô#Ø×!Ò! (¤.°Ô"3°h´nÀQÔ6GÑ"GÍuÌzÐ!ÑZÔZðð rD   )T)rÚ  rÛ  rÜ  rÛ  rÝ  rÛ  rÞ  rÄ  )r²  rá  r1   râ  )ré  r-   rê  r-   rß   rä   r1   rë  )	rô   rõ   rö   r÷   rd   rù   rà  r¯   rü   rý   s   @rB   rÙ  rÙ  ©  s€   ø€ € € € € ðð ð.ð ð ð ð ð ð ð ðð ð ñ „\ððð ð ð ð ð ð ð rD   rÙ  c                  óÒ   ‡ — e Zd ZdZdZ	 d+d,ˆ fd„Z ed¦  «        d-d.ˆ fd„¦   «         Zd/d„Zd0d„Z	d1d„Z
d2ˆ fd!„Zd2d"„Zd3d%„Zˆ fd&„Zed'„ ¦   «         Zed(„ ¦   «         Zd)„ Zd*„ Zˆ xZS )4r&   aÓ  Head 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])
    FrL   rÁ  rM   rN   rO   r/   rÂ  rÃ  rÄ  rP   rQ   c                ó¢  •‡‡‡— t          ¦   «                              ||||¦  «         t          |d         t          | j        d¦  «        ¦  «        Š‰‰k    sJ ‚‰sJ ‚| j        r!t          j        ˆˆfd„|D ¦   «         ¦  «        n t          j        ˆˆfd„|D ¦   «         ¦  «        | _        t          j        ˆˆfd„|D ¦   «         ¦  «        | _	        |r<t          j        | j        ¦  «        | _        t          j        | j	        ¦  «        | _        t          t          ‰‰¦  «        ¦  «        | _        t#          |‰‰¦  «        | _        ‰| _        dS )rÆ  r   rT   c           
   3  ó¨   •K  — | ]L}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        t          j        ‰‰d¦  «        ¦  «        V — ŒMdS r^   rÈ  rÉ  s     €€rB   r\   z'YOLOEDetect.__init__.<locals>.<genexpr>   sW   øè è € ÐnÐnÐfg�"œ-­¨Q°°A©¬½¸RÀÀQ¹¼ÍÌÐSUÐW\Ð^_ÑI`ÔI`ÑaÔaÐnÐnÐnÐnÐnÐnrD   c              3  ó0  •K  — | ]�}t          j        t          j        t          ||d ¦  «        t          |‰d¦  «        ¦  «        t          j        t          ‰‰d ¦  «        t          ‰‰d¦  «        ¦  «        t          j        ‰‰d¦  «        ¦  «        V — Œ‘dS r^   )r   rW   r   r   rX   rÉ  s     €€rB   r\   z'YOLOEDetect.__init__.<locals>.<genexpr>"  sž   øè è € ð ð ð õ ”Ý”M¥&¨¨A¨q¡/¤/µ4¸¸2¸q±>´>ÑBÔBÝ”M¥&¨¨R°Ñ"3Ô"3µT¸"¸bÀ!±_´_ÑEÔEÝ”I˜b %¨Ñ+Ô+ñô ðð ð ð ð ð rD   c              3  óV   •K  — | ]#}‰rt          ‰¦  «        nt          ¦   «         V — Œ$d S rØ   rË  rÌ  s     €€rB   r\   z'YOLOEDetect.__init__.<locals>.<genexpr>+  rÍ  rD   N)rc   rd   rk   rl   rO   ro   r   rm   rp   r  rs   rt   rv   r  r   r   Úreprtar   ÚsavperÂ  rÎ  s	     ``   @€rB   rd   zYOLOEDetect.__init__  se  øøøø€ õ 	‰Œ×Ò˜˜W g¨rÑ2Ô2Ð2Ý��A”�˜DœG SÑ)Ô)Ñ*Ô*ˆØ�UŠ{ˆ{ˆ{ˆ{Øˆˆˆwð Œ{ð	�BŒMÐnÐnÐnÐnÐnÐkmÐnÑnÔnÑnÔnÐnå”ð ð ð ð ð ð ðñ ô ñ ô ð 	Œõ ”=Ð hÐ hÐ hÐ hÐ hÐegÐ hÑ hÔ hÑhÔhˆŒØð 	7Ý#œ}¨T¬XÑ6Ô6ˆDÔÝ#œ}¨T¬XÑ6Ô6ˆDÔå�y¨°Ñ6Ô6Ñ7Ô7ˆŒÝ˜2˜r 5Ñ)Ô)ˆŒ
ØˆŒ
ˆ
ˆ
rD   NÚ	txt_featsr-   c                ó  •— |€"t          ¦   «                              ¦   «          dS | j        rdS | j        rJ ‚|                     t          |                      ¦   «         ¦  «        j        ¦  «                             d¦  «        }| j	        r(| j
        r!|                      || j	        | j
        ¦  «         t          | dd¦  «        �!|                      || j        | j        ¦  «         | `t!          j        ¦   «         | _        d| _        dS )ú>Fuse text features with model weights for efficient inference.Nr   ru   T)rc   rï   Úis_fusedr§   ÚtoÚnextÚ
parametersrî  Úsqueezerp   r  Ú_fuse_tpr…   rv   r  r÷  r   rq   ©rJ   rù  rx   s     €rB   rï   zYOLOEDetect.fuse4  sê   ø€ ð ÐÝ‰GŒG�LŠL‰NŒNˆNØˆFØŒ=ð 	ØˆFà”=Ð Ð Ð Ø—L’L¥ d§o¢oÑ&7Ô&7Ñ!8Ô!8Ô!>Ñ?Ô?×GÒGÈÑJÔJˆ	ØŒ8ð 	9˜œð 	9Ø�MŠM˜) T¤X¨t¬xÑ8Ô8Ð8Ý�4˜¨Ñ-Ô-Ð9Ø�MŠM˜) TÔ%5°tÔ7GÑHÔHÐHØˆKÝ”k‘m”mˆŒØˆŒˆˆrD   r}   rŠ   Úbn_headr1   rè   c                óP  — t          ||¦  «        D �]\  }}t          |t          j        ¦  «        sJ ‚t          |t          ¦  «        sJ ‚|d         }t          |t          j        ¦  «        sJ ‚|j        }|j        }|j        }	|| 	                    ¦   «         z  }
t          ||	¦  «        }|j        j                             d¦  «                             d¦  «        }|j        j        }|
|z  }|
|                     d¦  «                             d¦  «        z                       d¦  «        }t!          j        |¦  «        |z  }t          j        |j        |j        d         d¬¦  «                             d¦  «                             |j        j        |j        j        ¦  «        }|j        j                             |                     d¦  «                             d¦  «        ¦  «         |j        j                             ||z   ¦  «         ||d<   |                     ¦   «          �ŒdS )zGFuse text prompt embeddings with model weights for efficient inference.r7   r   r   r‘  FN)rÇ   r  r   rW   r   rX   Úlogit_scalerÈ   Únormr¦  r   rç  rÉ   r   r:   r¾   rh   Ú	ones_likerä  r8   ræ  rý  Údevicerî  Úcopy_rï   )rJ   rù  r}   r  Úcls_hÚbn_hr²  r  rÈ   r  ÚtÚwrÌ   Úb1Úb2s                  rB   r  zYOLOEDetect._fuse_tpG  së  € å˜x¨Ñ1Ô1ð !	ñ !	‰KˆE�4Ý˜e¥R¤]Ñ3Ô3Ð3Ð3Ð3Ý˜dÕ$5Ñ6Ô6Ð6Ð6Ð6Ø˜”9ˆDÝ˜d¥B¤IÑ.Ô.Ð.Ð.Ð.ØÔ*ˆKØ”9ˆDØ”9ˆDà˜KŸOšOÑ-Ô-Ñ-ˆAÝ.¨t°TÑ:Ô:ˆDà”Ô ×(Ò(¨Ñ,Ô,×4Ò4°RÑ8Ô8ˆAØ”	”ˆAà�A‘ˆAØ�a—i’i ‘m”m×-Ò-¨bÑ1Ô1Ñ1×:Ò:¸2Ñ>Ô>ˆBÝ” Ñ$Ô$ tÑ+ˆBõ ”	ØÔ$Ø”G˜A”JØ !ðñ ô ÷
  ’ Ñ&Ô&ß’�D”KÔ&¨¬Ô(9Ñ:Ô:ð ð ŒKÔ×"Ò" 1§;¢;¨r¡?¤?×#<Ò#<¸RÑ#@Ô#@ÑAÔAÐAØŒIŒN× Ò   b¡Ñ)Ô)Ð)ØˆE�"‰Ià�IŠI‰KŒKˆK‰KðC!	ð !	rD   ÚtperÏ   c                ó^   — |€dn)t          j        |                      |¦  «        dd¬¦  «        S )z.Get text prompt embeddings with normalization.Nr7   r4   )r6   r5  )r¤  Ú	normalizer÷  )rJ   r  s     rB   Úget_tpezYOLOEDetect.get_tpel  s.   € à�{ˆtˆt­¬°D·K²KÀÑ4DÔ4DÈ"ÐPQÐ(RÑ(RÔ(RÐRrD   r,   r‰   Úvpec                óö   — |j         d         dk    r9t          j        |d         j         d         d| j        |d         j        ¬¦  «        S |j        dk    r|                      ||¦  «        }|j        dk    sJ ‚|S )z4Get visual prompt embeddings with spatial awareness.r   r   )r  rS   rV   )r8   rh   ri   rÂ  r  rG   rø  )rJ   r,   r  s      rB   Úget_vpezYOLOEDetect.get_vpep  sp   € àŒ9�QŒ<˜1ÒÐÝ”;˜q œtœz¨!œ}¨a°´ÀAÀaÄDÄKÐPÑPÔPÐPØŒ8�qŠ=ˆ=Ø—*’*˜Q Ñ$Ô$ˆCØŒx˜1Š}ˆ}ˆ}ˆ}Øˆ
rD   r»  c                ó    •— t          | d¦  «        r|                      |dd…         ¦  «        S t          ¦   «                              |¦  «        S )zEProcess features with class prompt embeddings to generate detections.ÚlrpcNrV   )r9  Úforward_lrpcrc   r¯   )rJ   r,   rx   s     €rB   r¯   zYOLOEDetect.forwardy  sG   ø€ å�4˜Ñ Ô ð 	,Ø×$Ò$ Q r¨ r¤UÑ+Ô+Ð+Ý‰wŒw�Š˜qÑ!Ô!Ð!rD   c                ó  — g g g }}}|d         j         d         }| j        r| j        n| j        }| j        r| j        n| j        }| j        rt          | d¦  «        r| j        n| j        }| j	        r	| j
        sdnt          | dd¦  «        }	t          | j        ¦  «        D ]À}
 ||
         ||
         ¦  «        } ||
         ||
         ¦  «        }t          ||
         t          ¦  «        sJ ‚ ||
         |||	¦  «        \  }}}|                     |                     || j        dz  d¦  «        ¦  «         |                     |¦  «         |                     |¦  «         ŒÁ|	rt'          j        |¦  «        nd}t'          j        |d¦  «        t'          j        |d¦  «        ||d	œ|                      ||¦  «        ¥}|                      |¦  «        }| j        r*|                      |                     ddd
¦  «        ¦  «        }| j	        r|n||fS )zYProcess features with fused text embeddings to generate detections for prompt-free model.r   Úone2one_lrpcrß   gü©ñÒMbP?rS   r7   Nr4   )rš   r›   rœ   r@   r   )r8   rw   ru   rn   rv   rp   r9  r  r  r«   rº   r…   rž   rf   r  rÙ  Úappendr‘   rY   rh   r�   Úforward_maskr¨   r©   rª   )rJ   r,   rš   r›   r@   r”   rn   rp   r  rß   r“   ré  rê  ÚboxÚscorerÚ   r¬   r®   s                     rB   r  zYOLOEDetect.forward_lrpc  s  € à! 2 r�uˆvˆØˆqŒTŒZ˜Œ]ˆØ"&¤,Ð<ˆdÔÐ°D´HˆØ"&¤,Ð<ˆdÔÐ°D´HˆØ$(¤LÐaµW¸TÀ>Ñ5RÔ5RÐaˆtÔ Ð ÐX\ÔXaˆØ”KÐV¨¬ÐVˆqˆq½'À$ÈÐPUÑ:VÔ:VˆÝ�t”w‘”ð 	ð 	ˆAØ�s˜1”v˜a œd‘|”|ˆHØ�s˜1”v˜a œd‘|”|ˆHÝ˜d 1œg¥xÑ0Ô0Ð0Ð0Ð0Ø%˜d 1œg h°¸$Ñ?Ô?‰OˆC�˜Ø�LŠL˜Ÿš " d¤l°QÑ&6¸Ñ;Ô;Ñ<Ô<Ð<Ø�MŠM˜%Ñ Ô Ð Ø�LŠL˜ÑÔÐÐØ$(Ð2•”	˜%Ñ Ô Ð ¨dˆå”Y˜u aÑ(Ô(Ý”i ¨Ñ*Ô*ØØð	
ð 
ð
 ×Ò  5Ñ)Ô)ð
ˆð �OŠO˜EÑ"Ô"ˆØŒ<ð 	5Ø× Ò  §¢¨1¨a°Ñ!3Ô!3Ñ4Ô4ˆAØ”KÐ/ˆqˆq a¨ ZÐ/rD   r@   r‹   c                ó   — i S )zTReturn the prompt-free mask coefficients, which the detection head does not produce.rN   rI   s      rB   r  zYOLOEDetect.forward_maskœ  s   € àˆ	rD   c                óž   •— t          ¦   «                              |¦  «        }t          | d¦  «        r|d         €|n|d|d         f         }|S )z.Decode predicted bounding boxes for inference.r  r@   N.)rc   r±   r9  )rJ   r,   r³   rx   s      €rB   r±   zYOLOEDetect._get_decode_boxes   sQ   ø€ å‰wŒw×(Ò(¨Ñ+Ô+ˆÝ�4˜Ñ Ô ð 	IØ˜Wœ:Ð-�4�4°4¸¸Q¸w¼Z¸Ô3HˆDØˆrD   c                ó,   — | j         | j        | j        dœS )rz   ©r|   r}   Úcontrastive_headr  r~   s    rB   r   zYOLOEDetect.one2many§  s   € ð !œH°$´(ÐPTÔPXÐYÐYÐYrD   c                ó,   — | j         | j        | j        dœS )r�   r#  r  r~   s    rB   r‚   zYOLOEDetect.one2one¬  s   € ð !Ô,¸$Ô:JÐ`dÔ`pÐqÐqÐqrD   c                óô  ‡ ‡‡‡‡‡— t          ‰¦  «        dk    sJ dt          ‰¦  «        › d�¦   «         ‚‰�‰€i S ‰d         j        d         Št          j        ˆˆˆ ˆfd„t	          ‰ j        ¦  «        D ¦   «         d¬¦  «        }‰d         j        d	         ‰ _        t          j        ˆˆˆˆ ˆfd
„t	          ‰ j        ¦  «        D ¦   «         d¬¦  «        }‰ j        ‰ j        dz  z   ‰ _        ||‰dd…         dœS )z_Concatenates and returns predicted bounding boxes, class probabilities, and contrastive scores.rS   zLExpected 4 features including 3 feature maps and 1 text embeddings, but got ú.Nr   c                óx   •— g | ]6} ‰|         ‰|         ¦  «                              ‰d ‰j        z  d¦  «        ‘Œ7S r�   r�   r’   s     €€€€rB   r•   z,YOLOEDetect.forward_head.<locals>.<listcomp>·  r–   rD   r7   r5   r   c                óž   •— g | ]I} ‰|          ‰|         ‰|         ¦  «        ‰d          ¦  «                              ‰‰j        d ¦  «        ‘ŒJS r˜   )r:   rO   )rZ   r“   r”   r}   r$  rJ   r,   s     €€€€€rB   r•   z,YOLOEDetect.forward_head.<locals>.<listcomp>º  sX   ø€ ÐlÐlÐlÐXYÐ Ð˜aÔ   ¨!¤¨Q¨q¬TÑ!2Ô!2°A°b´EÑ:Ô:×BÒBÀ2ÀtÄwÐPRÑSÔSÐlÐlÐlrD   rV   r™   )	re   r8   rh   r�   rž   rf   rO   rY   rg   )rJ   r,   r|   r}   r$  rš   r›   r”   s   `````  @rB   rŸ   zYOLOEDetect.forward_head±  s  øøøøøø€ å�1‰vŒv˜Š{ˆ{ˆ{ÐtÕknÐopÑkqÔkqÐtÐtÐt‰{Œ{ˆ{ØÐ˜xÐ/ØˆIØˆqŒTŒZ˜Œ]ˆÝ”	ÐdÐdÐdÐdÐdÐdÐdÕUZÐ[_Ô[bÑUcÔUcÐdÑdÔdÐjlÐmÑmÔmˆØ�B”%”+˜a”.ˆŒÝ”ØlÐlÐlÐlÐlÐlÐlÐlÕ]bÐcgÔcjÑ]kÔ]kÐlÑlÔlÐrtð
ñ 
ô 
ˆð ”'˜DœL¨1Ñ,Ñ,ˆŒØ¨&¸1¸R¸a¸R¼5ÐAÐAÐArD   c                ó  — t          t          | j        d         | j        d         | j        d         ¦  «        ¦  «        D ]v\  }\  }}}d|d         j        j        dd…<   d|d         j        j        dd…<   t          j        d| j        z  d	| j        |         z  d
z  z  ¦  «        |j        j        dd…<   Œwt          | dd¦  «        �¶t          t          | j
        d         | j
        d         | j
        d         ¦  «        ¦  «        D ]x\  }\  }}}d|d         j        j        dd…<   d|d         j        j        dd…<   t          j        d| j        z  d	| j        |         z  d
z  z  ¦  «        |j        j        dd…<   ŒwdS dS )rÁ   r|   r}   r$  rÂ   r7   Nr°  rÃ   rÄ   r4   ru   rÅ   )rJ   r“   r·   rÌ   rŽ  s        rB   rÍ   zYOLOEDetect.bias_init¿  s‰  € å%Ý�”˜jÔ)¨4¬=¸Ô+DÀdÄmÐTfÔFgÑhÔhñ
ô 
ð 	Qð 	Q‰LˆA‰y��1�að "%ˆAˆbŒEŒJŒO˜A˜A˜AÑØ!$ˆAˆbŒEŒJŒO˜A˜A˜AÑÝ!œX a¨$¬'¡k°S¸4¼;Àq¼>Ñ5IÈaÑ4OÑ&OÑPÔPˆAŒFŒK˜˜˜‰NˆNÝ�4˜¨Ñ-Ô-Ð9Ý )Ý�D”L Ô,¨d¬l¸:Ô.FÈÌÐUgÔHhÑiÔiñ!ô !ð Uð U‘�‘9�A�q˜!ð &)��"””
”   Ñ"Ø%(��"””
”   Ñ"Ý!%¤¨!¨d¬g©+¸¸t¼{È1¼~Ñ9MÐRSÑ8SÑ*SÑ!TÔ!T�””˜A˜A˜A‘�ð :Ð9ðUð UrD   r×  )rO   r/   rÂ  r/   rÃ  rÄ  rP   rQ   rØ   ©rù  r-   )rù  r-   r}   rŠ   r  rŠ   r1   rè   )r  rÏ   r1   rÏ   )r,   r‰   r  r-   r1   r-   )r,   r‰   r1   r»  ©r,   r‰   r@   rÏ   r1   r‹   )rô   rõ   rö   r÷   rü  rd   r   rï   r  r  r  r¯   r  r  r±   rú   r   r‚   rŸ   rÍ   rü   rý   s   @rB   r&   r&   î  sš  ø€ € € € € ðð ð: €Hð moð$ð $ð $ð $ð $ð $ð $ðL Ð˜%Ñ Ô ðð ð ð ð ð ñ !Ô ðð$#ð #ð #ð #ðJSð Sð Sð Sðð ð ð ð"ð "ð "ð "ð "ð "ð0ð 0ð 0ð 0ð:ð ð ð ðð ð ð ð ð ðZð Zñ „XðZð ðrð rñ „XðrðBð Bð BðUð Uð Uð Uð Uð Uð UrD   r&   c                  óœ   ‡ — e Zd ZdZ	 	 	 	 	 	 	 	 d)d*ˆ fd„Zed„ ¦   «         Zed„ ¦   «         Zd+d„Zd,ˆ fd„Z	d-ˆ fd„Z
d.ˆ fd%„Zd/d0ˆ fd(„Zˆ xZS )1r'   aY  YOLO 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])
    rL   rÿ   r   rÁ  FrM   rN   rO   r/   r  r  rÂ  rÃ  rÄ  rP   rQ   c	                óŒ  •‡ ‡	— t          ¦   «                              ||||||¦  «         |‰ _        |‰ _        t	          |d         ‰ j        ‰ j        ¦  «        ‰ _        t          |d         dz  ‰ j        ¦  «        Š	t          j        ˆ	ˆ fd„|D ¦   «         ¦  «        ‰ _	        |r t          j        ‰ j	        ¦  «        ‰ _        dS dS )a7  Initialize 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.
        r   rS   c           
   3  ó²   •K  — | ]Q}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        t          j        ‰‰j        d¦  «        ¦  «        V — ŒRdS r^   r  ©rZ   r,   Úc5rJ   s     €€rB   r\   z(YOLOESegment.__init__.<locals>.<genexpr>  r	  rD   N)rc   rd   r  r  r   r
  rk   r   rm   Úcv5rs   rt   Úone2one_cv5)rJ   rO   r  r  rÂ  rÃ  rY   rw   rP   r1  rx   s   `        @€rB   rd   zYOLOESegment.__init__ç  sÁ   øøø€ õ. 	‰Œ×Ò˜˜U G¨W°g¸rÑBÔBÐBØˆŒØˆŒÝ˜2˜aœ5 $¤(¨D¬GÑ4Ô4ˆŒ
å��A”˜!‘˜TœWÑ%Ô%ˆÝ”=Ð wÐ wÐ wÐ wÐ wÐtvÐ wÑ wÔ wÑwÔwˆŒØð 	7Ý#œ}¨T¬XÑ6Ô6ˆDÔÐÐð	7ð 	7rD   c                ó8   — | j         | j        | j        | j        dœS )rz   ©r|   r}   r  r$  )rn   rp   r2  r  r~   s    rB   r   zYOLOESegment.one2many  s    € ð !œH°$´(ÈÌÐgkÔgoÐpÐpÐprD   c                ó8   — | j         | j        | j        | j        dœS )r�   r5  )ru   rv   r3  r  r~   s    rB   r‚   zYOLOESegment.one2one  s+   € ð Ô(ØÔ(ØÔ)Ø $Ô 0ð	
ð 
ð 	
rD   r,   r‰   r@   rÏ   r1   r‹   c                ó¼   ‡ ‡‡— ‰ j         r‰ j        n‰ j        Št          j        ˆˆ ˆfd„t          ‰ j        ¦  «        D ¦   «         d¦  «        }d|€|n	|d|f         iS )zQReturn the prompt-free mask coefficients of the anchors the proposal filter kept.c                ó”   •— g | ]D} ‰|         ‰|         ¦  «                              ‰d          j        d          ‰j        d¦  «        ‘ŒES )r   r7   )r‘   r8   r  )rZ   r“   r2  rJ   r,   s     €€€rB   r•   z-YOLOESegment.forward_mask.<locals>.<listcomp>  sG   ø€ Ð^Ð^Ð^È!˜˜˜Aœ˜q œt™œ×)Ò)¨!¨A¬$¬*°Q¬-¸¼À"ÑEÔEÐ^Ð^Ð^rD   r4   r"  N.)rw   r3  r2  rh   r�   rž   rf   )rJ   r,   r@   Úmcr2  s   ``  @rB   r  zYOLOESegment.forward_mask  sm   øøø€ à"&¤,Ð<ˆdÔÐ°D´HˆÝŒYÐ^Ð^Ð^Ð^Ð^Ð^ÍuÐUYÔU\É~Ì~Ð^Ñ^Ô^Ð`aÑbÔbˆØ"¨%¨- B B¸RÀÀUÀ
¼^ÐLÐLrD   r  c                óˆ  •— t          ¦   «                              |¦  «        }t          |t          ¦  «        r|d         n|}|                      |d         ¦  «        }t          |t
          ¦  «        r2d|v r)||d         d<   |                     ¦   «         |d         d<   n||d<   | j        r|S | j        r||fn|d         |f|fS r  r  r  s        €rB   r¯   zYOLOESegment.forward  r  rD   r-   c                ó‚   •— t          ¦   «                              |¦  «        }t          j        ||d         gd¬¦  «        S r!  r#  r$  s      €rB   r¨   zYOLOESegment._inference,  r%  rD   r|   rŠ   r}   r  r$  c                óô   •‡ ‡‡‡— t          ¦   «                              ‰|||¦  «        }‰�L‰d         j        d         Št          j        ˆˆˆ ˆfd„t          ‰ j        ¦  «        D ¦   «         d¦  «        |d<   |S )r'  Nr   c                ór   •— g | ]3} ‰|         ‰|         ¦  «                              ‰‰j        d ¦  «        ‘Œ4S r˜   r)  r*  s     €€€€rB   r•   z-YOLOESegment.forward_head.<locals>.<listcomp>=  r+  rD   r4   r"  r,  )	rJ   r,   r|   r}   r  r$  r¬   r”   rx   s	   ``  `  @€rB   rŸ   zYOLOESegment.forward_head1  s„   øøøøø€ õ ‘”×$Ò$ Q¨°(Ð<LÑMÔMˆØÐ Ø�1””˜A”ˆBÝ(-¬	Ð2tÐ2tÐ2tÐ2tÐ2tÐ2tÐ2tÕejÐkoÔkrÑesÔesÐ2tÑ2tÔ2tÐvwÑ(xÔ(xˆEÐ$Ñ%ØˆrD   Nrù  c                ó®   •— t          ¦   «                              |¦  «         |€0t          | j        d¦  «        r| j                             ¦   «          dS dS )rû  Nrï   r8  r  s     €rB   rï   zYOLOESegment.fuse@  sR   ø€ å‰Œ�Š�YÑÔÐØÐÝ�t”z 6Ñ*Ô*ð "Ø”
—’Ñ!Ô!Ð!ØˆFð ÐrD   ©rL   rÿ   r   rÁ  FrM   FrN   ©rO   r/   r  r/   r  r/   rÂ  r/   rÃ  rÄ  rP   rQ   r,  r/  rò   )r,   r‰   r|   rŠ   r}   rŠ   r  rŠ   r$  rŠ   r1   r‹   rØ   r+  )rô   rõ   rö   r÷   rd   rú   r   r‚   r  r¯   r¨   rŸ   rï   rü   rý   s   @rB   r'   r'   Ð  sA  ø€ € € € € ðð ð0 ØØØØØØØð7ð 7ð 7ð 7ð 7ð 7ð 7ðB ðqð qñ „Xðqð ð
ð 
ñ „Xð
ðMð Mð Mð MðQð Qð Qð Qð Qð Qð@ð @ð @ð @ð @ð @ð
ð ð ð ð ð ðð ð ð ð ð ð ð ð ð ð rD   r'   c                  ó4   — e Zd ZdZ	 	 	 	 	 	 	 	 ddd„Zdd„ZdS )ÚYOLOESegment26a©  YOLOE-style segmentation head module using Proto26 for mask generation.

    This class extends the YOLOESegment functionality to include segmentation capabilities by integrating a Proto26
    generation module and convolutional layers to predict mask coefficients.

    Args:
        nc (int): Number of classes. Defaults to 80.
        nm (int): Number of masks. Defaults to 32.
        npr (int): Number of prototype channels. Defaults to 256.
        embed (int): Embedding dimensionality. Defaults to 512.
        with_bn (bool): Whether to use Batch Normalization. Defaults to False.
        reg_max (int): Maximum number of DFL channels. Defaults to 16.
        end2end (bool): Whether to use end-to-end detection mode. Defaults to False.
        ch (tuple[int, ...]): Input channels for each scale.

    Attributes:
        nm (int): Number of segmentation masks.
        npr (int): Number of prototype channels.
        proto (Proto26): Prototype generation module for segmentation.
        cv5 (nn.ModuleList): Convolutional layers for generating mask coefficients from features.
        one2one_cv5 (nn.ModuleList, optional): Deep copy of cv5 for end-to-end detection branches.
    rL   rÿ   r   rÁ  FrM   rN   rO   r/   r  r  rÂ  rÃ  rÄ  rP   rQ   c	           	     ót  ‡ ‡	— t                                ‰ ||||||¦  «         |‰ _        |‰ _        t	          |‰ j        ‰ j        |¦  «        ‰ _        t          |d         dz  ‰ j        ¦  «        Š	t          j        ˆ	ˆ fd„|D ¦   «         ¦  «        ‰ _	        |r t          j        ‰ j	        ¦  «        ‰ _        dS dS )zVInitialize YOLOESegment26 with class count, mask parameters, and embedding dimensions.r   rS   c           
   3  ó²   •K  — | ]Q}t          j        t          |‰d ¦  «        t          ‰‰d ¦  «        t          j        ‰‰j        d¦  «        ¦  «        V — ŒRdS r^   r  r0  s     €€rB   r\   z*YOLOESegment26.__init__.<locals>.<genexpr>s  r	  rD   N)r&   rd   r  r  r   r
  rk   r   rm   r2  rs   rt   r3  )
rJ   rO   r  r  rÂ  rÃ  rY   rw   rP   r1  s
   `        @rB   rd   zYOLOESegment26.__init__a  s¼   øø€ õ 	×Ò˜T 2 u¨g°wÀÈÑLÔLÐLØˆŒØˆŒÝ˜R ¤¨4¬7°BÑ7Ô7ˆŒ
å��A”˜!‘˜TœWÑ%Ô%ˆÝ”=Ð wÐ wÐ wÐ wÐ wÐtvÐ wÑ wÔ wÑwÔwˆŒØð 	7Ý#œ}¨T¬XÑ6Ô6ˆDÔÐÐð	7ð 	7rD   r,   r‰   r1   r  c                ó†  — t                                | |¦  «        }t          |t          ¦  «        r|d         n|}|                      d„ |D ¦   «         d¬¦  «        }t          |t
          ¦  «        r2d|v r)||d         d<   |                     ¦   «         |d         d<   n||d<   | j        r|S | j        r||fn|d         |f|fS )	r  r   c                ó6   — g | ]}|                      ¦   «         ‘ŒS rN   r£   r¥   s     rB   r•   z*YOLOESegment26.forward.<locals>.<listcomp>{  s    € Ð4Ð4Ð4¨B˜BŸIšI™KœKÐ4Ð4Ð4rD   F)Úreturn_semanticr‚   r   r
  r   )	r&   r¯   r  rQ   r
  r  r¤   r§   r«   r6  s        rB   r¯   zYOLOESegment26.forwardw  sÚ   € å×%Ò% d¨AÑ.Ô.ˆÝ(¨µ%Ñ8Ô8ÐE�˜”
�
¸gˆØ—
’
Ð4Ð4°!Ð4Ñ4Ô4Àe�
ÑLÔLˆå�e�TÑ"Ô"ð 	'Ø˜EÐ!Ð!Ø-2��jÔ! 'Ñ*Ø,1¯LªL©N¬N��iÔ  Ñ)Ð)à!&��g‘ØŒ=ð 	ØˆLØ#'¤;ÐP�˜ÐÐ°g¸a´jÀ%Ð5HÈ%Ð4PÐPrD   Nr?  r@  r/  )rô   rõ   rö   r÷   rd   r¯   rN   rD   rB   rB  rB  I  sk   € € € € € ðð ð2 ØØØØØØØð7ð 7ð 7ð 7ð 7ð,Qð Qð Qð Qð Qð QrD   rB  c                  óà   ‡ — e Zd ZdZdZdZg Z ej        d¦  «        Z	 ej        d¦  «        Z
dZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dCdDˆ fd&„ZdEdFd-„ZdGd1„Ze	 	 dHdId:„¦   «         ZdJd<„Z	 	 dKdLdA„ZdB„ Zˆ xZS )Mr#   a  Real-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)
    Fr*   r   rL   ©rÁ  é   i   r   rS   r+   é   rJ  r°  Nr7   rT   r¸   rÕ  rO   r/   rP   rQ   ÚhdÚnqÚndpÚnhÚndlÚd_ffnÚdropouträ   Úactúnn.Module | NoneÚeval_idxÚndÚlabel_noise_ratioÚbox_noise_scaleÚlearnt_init_queryrÄ  c           	     óB  •‡‡— t          ¦   «                              ¦   «          |
€t          j        ¦   «         n|
}
‰| _        || _        t          |¦  «        | _        ‰| _        || _	        || _
        t          j        ˆfd„|D ¦   «         ¦  «        | _        t          ‰|||	|
| j        |¦  «        }t          ‰|||¦  «        | _        t          j        ‰‰¦  «        | _        || _        || _        || _        || _        |rt          j        |‰¦  «        | _        t/          dd‰z  ‰d¬¦  «        | _        t          j        t          j        ‰‰¦  «        t          j        ‰¦  «        ¦  «        | _        t          j        ‰‰¦  «        | _        t/          ‰‰dd¬¦  «        | _        t          j        ˆˆfd„t?          |¦  «        D ¦   «         ¦  «        | _         t          j        ˆfd„t?          |¦  «        D ¦   «         ¦  «        | _!        |  "                    ¦   «          dS )	aw  Initialize 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.
        Nc           	   3  ó’   •K  — | ]A}t          j        t          j        |‰d d¬¦  «        t          j        ‰¦  «        ¦  «        V — ŒBdS )r   F)rÈ   N)r   rW   rX   ÚBatchNorm2d)rZ   r,   rL  s     €rB   r\   z)RTDETRDecoder.__init__.<locals>.<genexpr>ç  sP   øè è € Ð'wÐ'wÐop­¬µb´iÀÀ2ÀqÈuÐ6UÑ6UÔ6UÕWYÔWeÐfhÑWiÔWiÑ(jÔ(jÐ'wÐ'wÐ'wÐ'wÐ'wÐ'wrD   rS   r4   ©Ú
num_layersrV   c                ó:   •— g | ]}t          j        ‰‰¦  «        ‘ŒS rN   )r   r·  )rZ   rt  rL  rO   s     €€rB   r•   z*RTDETRDecoder.__init__.<locals>.<listcomp>  s%   ø€ Ð,SÐ,SÐ,SÀ1­R¬Y°r¸2Ñ->Ô->Ð,SÐ,SÐ,SrD   c                ó6   •— g | ]}t          ‰‰d d¬¦  «        ‘ŒS )rS   rV   r]  )r   )rZ   rt  rL  s     €rB   r•   z*RTDETRDecoder.__init__.<locals>.<listcomp>  s*   ø€ Ð+]Ð+]Ð+]ÈQ­C°°B¸ÀaÐ,HÑ,HÔ,HÐ+]Ð+]Ð+]rD   )#rc   rd   r   ÚReLUÚ
hidden_dimÚnheadre   rf   rO   Únum_queriesÚnum_decoder_layersrm   Ú
input_projr   r   ÚdecoderÚ	EmbeddingÚdenoising_class_embedÚnum_denoisingrW  rX  rY  Ú	tgt_embedr   Úquery_pos_headrW   r·  Ú	LayerNormÚ
enc_outputÚenc_score_headÚenc_bbox_headrž   Údec_score_headÚdec_bbox_headÚ_reset_parameters)rJ   rO   rP   rL  rM  rN  rO  rP  rQ  rR  rS  rU  rV  rW  rX  rY  Údecoder_layerrx   s    ` `             €rB   rd   zRTDETRDecoder.__init__·  s  øøø€ õL 	‰Œ×ÒÑÔÐØ˜;�bŒg‰iŒiˆi¨CˆØˆŒØˆŒ
Ý�b‘'”'ˆŒØˆŒØˆÔØ"%ˆÔõ œ-Ð'wÐ'wÐ'wÐ'wÐtvÐ'wÑ'wÔ'wÑwÔwˆŒõ
 :¸"¸bÀ%ÈÐRUÐW[ÔW^Ð`cÑdÔdˆÝ3°B¸ÀsÈHÑUÔUˆŒõ &(¤\°"°bÑ%9Ô%9ˆÔ"ØˆÔØ!2ˆÔØ.ˆÔð "3ˆÔØð 	2Ýœ\¨"¨bÑ1Ô1ˆDŒNÝ! ! Q¨¡V¨R¸AÐ>Ñ>Ô>ˆÔõ œ-­¬	°"°bÑ(9Ô(9½2¼<ÈÑ;KÔ;KÑLÔLˆŒÝ œi¨¨BÑ/Ô/ˆÔÝ   R¨°qÐ9Ñ9Ô9ˆÔõ !œmÐ,SÐ,SÐ,SÐ,SÐ,SÍÈcÉ
Ì
Ð,SÑ,SÔ,SÑTÔTˆÔÝœ]Ð+]Ð+]Ð+]Ð+]ÕRWÐX[ÑR\ÔR\Ð+]Ñ+]Ô+]Ñ^Ô^ˆÔà×ÒÑ Ô Ð Ð Ð rD   r,   r‰   Úbatchúdict | Noner1   útuple | torch.Tensorc           
     ó¶  — ddl m} |                      |¦  «        \  }} ||| j        t	          | j        |j        d         ¦  «        | j        j        | j	        | j
        | j        | j        ¦  «        \  }}}}	|                      ||||¦  «        \  }
}}}|                      |
|||| j        | j        | j        |¬¦  «        \  }}| j        r&|	€$|d| j        j                             ¦   «         z  z   }|||||	f}| j        r|S |                      |                     d¦  «        |                     d¦  «                             ¦   «         ¦  «        }| j        r|n||fS )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, num_queries, 6) containing bounding boxes,
                confidence scores, and class labels.
        r   )Úget_cdn_groupr   )Ú	attn_mask)Úultralytics.models.utils.opsry  Ú_get_encoder_inputrO   rl   rd  r8   ri  rç  rj  rW  rX  r§   Ú_get_decoder_inputrg  rr  rq  rl  Úsumr©   r   r²   r«   )rJ   r,   ru  ry  rœ   ÚshapesÚdn_embedÚdn_bboxrz  Údn_metarÂ  Ú
refer_bboxÚ
enc_bboxesÚ
enc_scoresÚ
dec_bboxesÚ
dec_scoresr®   s                    rB   r¯   zRTDETRDecoder.forward  s“  € ð 	?Ð>Ð>Ð>Ð>Ð>ð ×/Ò/°Ñ2Ô2‰ˆˆvð 1>°ØØŒGÝ�Ô  %¤+¨a¤.Ñ1Ô1ØÔ&Ô-ØÔØÔ"ØÔ ØŒMñ	1
ô 	1
Ñ-ˆ�'˜9 gð 59×4KÒ4KÈEÐSYÐ[cÐelÑ4mÔ4mÑ1ˆˆz˜: zð "&§¢ØØØØØÔØÔØÔØð ".ñ 	"
ô 	"
Ñˆ
�Jð Œ=ð 	R˜W˜_à# a¨$Ô*DÔ*K×*OÒ*OÑ*QÔ*QÑ&QÑQˆJØ˜
 J°
¸GÐCˆØŒ=ð 	ØˆHà×Ò˜Z×/Ò/°Ñ2Ô2°J×4FÒ4FÀqÑ4IÔ4I×4QÒ4QÑ4SÔ4SÑTÔTˆØ”KÐ+ˆqˆq a¨ VÐ+rD   rš   r-   r›   c                ó  — | j         rt          | j        | j        ¦  «        n| j        }| j        r6t          j        |¦  «        d         | j        z                       |¬¦  «        n"t          ||j	        d         | j        z  ¦  «        }| j         r| j
        dk    r	| j        sdnd}t                               |                     d¦  «        ||¦  «        \  }}t          j        || j        d¬¦  «        }|                     d|                     d¦  «                             ddd¦  «                             ¦   «         ¬	¦  «        }t          j        ||d
         ||| j        z  z
  d
                              ¦   «         gd¬¦  «        S )aÿ  Post-process predictions to select top-k detections.

        Args:
            boxes (torch.Tensor): Predicted bounding boxes with shape (batch_size, num_queries, 4) in xywh format.
            scores (torch.Tensor): Class scores with shape (batch_size, num_queries, nc).

        Returns:
            (torch.Tensor): Processed predictions with shape (batch_size, num_queries, 6), limited to max_det during
                export, and last dimension format [cx, cy, w, h, max_class_prob, class_index].
        r   ©rk   râ   r+   Úfloor)Úrounding_moder7   rS   )r6   r@   rF   r5   )r«   rl   rd  rÝ   rº   rh   Ú_shape_as_tensorrO   r§  r8   rå   r!   rC   r;   Údivr<   r¾   rH   Úlongr�   rä   )rJ   rš   r›   r.   r0   r@   Ú	query_idxs          rB   r©   zRTDETRDecoder.postprocess:  sf  € ð 48´;ÐT�C�Ô  $¤,Ñ/Ô/Ð/ÀDÔDTˆð Œ|ð3�UÔ# FÑ+Ô+¨AÔ.°´Ñ8×?Ò?ÀAÐ?ÑFÔFÐFå�Q˜œ Qœ¨$¬'Ñ1Ñ2Ô2ð 	
ð
 ”kÐY d¤k°XÒ&=Ð&=ÀdÄlÐ&=��ÐXYˆÝ×,Ò,¨V¯^ª^¸AÑ->Ô->ÀÀ6ÑJÔJ‰ˆ�å”I˜e T¤W¸GÐDÑDÔDˆ	Ø—’ ¨)×*=Ò*=¸bÑ*AÔ*A×*HÒ*HÈÈRÐQRÑ*SÔ*S×*XÒ*XÑ*ZÔ*Z�Ñ[Ô[ˆÝŒy˜% ¨	Ô!2°U¸YÈÌÑ=PÑ5PÐR[Ô4\×4bÒ4bÑ4dÔ4dÐeÐkmÐnÑnÔnÐnrD   çš™™™™™©?ç{®Gáz„?r  úlist[list[int]]rœ   Ú	grid_sizeÚepsr2   c                óF  — g }t          | ¦  «        D �]\  }\  }}t          j        |¦  «                             |¦  «        }t          j        |¦  «                             |¦  «        }	t          rt          j        ||	d¬¦  «        nt          j        ||	¦  «        \  }
}t          j        |dz   |z  |
dz   |z  gd¦  «        d         }t          j        ||d|z  z  ¦  «        }|                     t          j	        ||gd¦  «         
                    d||z  d¦  «        ¦  «         �Œt          j	        |d¦  «        }||k    |d|z
  k     z                       dd	¬
¦  «        }t          j        |d|z
  z  ¦  «        }|                     | t          d¦  «        ¦  «        }||fS )a  Generate anchor bounding boxes for given shapes with specific grid size and validate them.

        Args:
            shapes (list): List of feature map shapes.
            feats (torch.Tensor): Tensor whose dtype and device the anchors inherit.
            grid_size (float, optional): Base size of grid cells.
            eps (float, optional): Small value for numerical stability.

        Returns:
            anchors (torch.Tensor): Generated anchor boxes.
            valid_mask (torch.Tensor): Valid mask for anchors.
        Úij)Úindexingr¸   r7   NrÂ   rS   r   T)ÚkeepdimÚinf)rÆ   rh   ÚarangeÚtype_asr   ÚmeshgridÚstackÚ	full_liker  r�   r‘   ÚallrË   Úmasked_fillrä   )r  rœ   r“  r”  r»   r“   Úhr  ÚsyÚsxÚgrid_yÚgrid_xÚgrid_xyÚwhÚ
valid_masks                  rB   Ú_generate_anchorszRTDETRDecoder._generate_anchorsR  s’  € ð& ˆÝ" 6Ñ*Ô*ð 	Lñ 	L‰IˆA‰v��1Ý”˜a‘”×(Ò(¨Ñ/Ô/ˆBÝ”˜a‘”×(Ò(¨Ñ/Ô/ˆBÝFPÐl�Uœ^¨B°¸TÐBÑBÔBÐBÕV[ÔVdÐegÐikÑVlÔVl‰NˆF�FÝ”k F¨S¡L°AÑ#5¸À¹ÈÑ7IÐ"JÈBÑOÔOÐPTÔUˆGÝ” ¨)°s¸A±vÑ*>Ñ?Ô?ˆBØ�NŠN�5œ9 g¨r ]°BÑ7Ô7×<Ò<¸RÀÀQÁÈÑJÔJÑKÔKÐKÑKå”)˜G QÑ'Ô'ˆØ ’}¨°1°s±7Ò):Ñ;×@Ò@ÀÈTÐ@ÑRÔRˆ
Ý”)˜G q¨7¡{Ñ3Ñ4Ô4ˆØ×%Ò% z kµ5¸±<´<Ñ@Ô@ˆØ˜
Ð"Ð"rD   ú$tuple[torch.Tensor, list[list[int]]]c                óJ  ‡ — ˆ fd„t          |¦  «        D ¦   «         }g }g }|D ]h}|j        dd…         \  }}|                     |                     d¦  «                             ddd¦  «        ¦  «         |                     ||g¦  «         Œit          j        |d¦  «        }||fS )aF  Process and return encoder inputs by getting projection features from input and concatenating them.

        Args:
            x (list[torch.Tensor]): List of feature maps from the backbone.

        Returns:
            feats (torch.Tensor): Processed features.
            shapes (list): List of feature map shapes.
        c                óB   •— g | ]\  }} ‰j         |         |¦  «        ‘ŒS rN   )rf  )rZ   r“   ÚfeatrJ   s      €rB   r•   z4RTDETRDecoder._get_encoder_input.<locals>.<listcomp>  s/   ø€ ÐBÐBÐB©'¨!¨TÐˆTŒ_˜QÔ Ñ%Ô%ÐBÐBÐBrD   r4   Nr   r   )rÆ   r8   r  r;   rª   rh   r�   )rJ   r,   rœ   r  r­  r¡  r  s   `      rB   r|  z RTDETRDecoder._get_encoder_inputt  sµ   ø€ ð CÐBÐBÐBµY¸q±\´\ÐBÑBÔBˆàˆØˆØð 	"ð 	"ˆDØ”:˜a˜b˜b”>‰DˆAˆqà�LŠL˜Ÿš a™œ×0Ò0°°A°qÑ9Ô9Ñ:Ô:Ð:à�MŠM˜1˜a˜&Ñ!Ô!Ð!Ð!õ ”	˜% Ñ#Ô#ˆØ�fˆ}ÐrD   r€  rÏ   r�  ú=tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]c                ó°  — |j         d         }| j        s| j        |k    r*|                      ||¦  «        \  | _        | _        || _        |                      | j        |z  ¦  «        }|                      |¦  «        }| j        r| j	        dk    r	| j        sdnd}| j        r3t          j        |¦  «        d                              | j        ¬¦  «        nt          | j        |j         d         ¦  «        }	t                               |                     d¦  «        j        |	|¦  «        d                              d¦  «        }
t          j        ||
j        ¬¦  «                             d¦  «                             d|	¦  «                             d¦  «        }|||
f                              ||	d¦  «        }| j        dd…|
f                              ||	d¦  «        }|                      |¦  «        |z   }|                     ¦   «         }|�t          j        ||gd¦  «        }|||
f                              ||	d¦  «        }| j        r<| j        j        d|	…                              d¦  «                             |dd¦  «        n|}| j        r/|                     ¦   «         }| j        s|                     ¦   «         }|�t          j        ||gd¦  «        }||||fS )	a‹  Generate 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.
        r   râ   r+   r   r‰  r7   )Úendrî  N) r8   rº   r  r©  r»   r¨  rn  ro  r«   rå   rh   rŒ  r§  rd  rl   r!   rC   rk   r?   r‘   rš  rî  r¾   Úrepeatrp  r²   r�   rY  rk  rç  r§   r¤   )rJ   rœ   r  r€  r�  r”   r„  Úenc_outputs_scoresr0   r.   Útopk_indÚ	batch_indÚtop_k_featuresÚtop_k_anchorsrƒ  r„  r…  Ú
embeddingss                     rB   r}  z RTDETRDecoder._get_decoder_inputŽ  sÕ  € ð* Œ[˜Œ^ˆØŒ<ð 	!˜4œ;¨&Ò0Ð0Ø,0×,BÒ,BÀ6È5Ñ,QÔ,QÑ)ˆDŒL˜$œ/Ø ˆDŒKð —?’? 4¤?°UÑ#:Ñ;Ô;ˆØ!×0Ò0°Ñ:Ô:Ðð ”kÐY d¤k°XÒ&=Ð&=ÀdÄlÐ&=��ÐXYˆð Œ|ðD�EÔ"Ð#5Ñ6Ô6°qÔ9×?Ò?ÀDÔDTÐ?ÑUÔUÐUå�TÔ%Ð'9Ô'?ÀÔ'BÑCÔCð 	
õ
 ×'Ò'Ð(:×(>Ò(>¸rÑ(BÔ(BÔ(IÈ1ÈfÑUÔUÐVWÔX×]Ò]Ð^`ÑaÔaˆå”L R¨x¬~Ð>Ñ>Ô>×HÒHÈÑLÔL×SÒSÐTUÐWXÑYÔY×^Ò^Ð_aÑbÔbˆ	ð " )¨XÐ"5Ô6×;Ò;¸BÀÀ2ÑFÔFˆàœ Q Q Q¨ [Ô1×6Ò6°r¸1¸bÑAÔAˆð ×'Ò'¨Ñ7Ô7¸-ÑGˆ
à×'Ò'Ñ)Ô)ˆ
ØÐÝœ G¨ZÐ#8¸!Ñ<Ô<ˆJØ'¨	°8Ð(;Ô<×AÒAÀ"ÀaÈÑLÔLˆ
ð HLÔG]ÐqˆDŒNÔ! " 1 "Ô%×/Ò/°Ñ2Ô2×9Ò9¸"¸aÀÑCÔCÐCÐcqð 	ð Œ=ð 	1Ø#×*Ò*Ñ,Ô,ˆJØÔ)ð 1Ø'×.Ò.Ñ0Ô0�
ØÐÝœ H¨jÐ#9¸1Ñ=Ô=ˆJà˜: z°:Ð=Ð=rD   c                óB  — t          d¦  «        dz  | j        z  }t          | j        j        |¦  «         t          | j        j        d         j        d¦  «         t          | j        j        d         j        d¦  «         t          | j	        | j
        ¦  «        D ]Z\  }}t          |j        |¦  «         t          |j        d         j        d¦  «         t          |j        d         j        d¦  «         Œ[t          | j        d         j        ¦  «         | j        rt          | j        j        ¦  «         t          | j        j        d         j        ¦  «         t          | j        j        d         j        ¦  «         | j        D ]}t          |d         j        ¦  «         ŒdS )zhInitialize or reset the parameters of the model's various components with predefined weights and biases.r‘  rL   r7   r°  r   r   N)r   rO   r   ro  rÈ   rp  Úlayersrç  rÇ   rq  rr  r   rn  rY  rk  rl  rf  )rJ   Úbias_clsÚcls_Úreg_Úlayers        rB   rs  zRTDETRDecoder._reset_parametersÑ  sy  € õ ' tÑ,Ô,¨rÑ1°D´GÑ;ˆÝ�$Ô%Ô*¨HÑ5Ô5Ð5Ý�$Ô$Ô+¨BÔ/Ô6¸Ñ<Ô<Ð<Ý�$Ô$Ô+¨BÔ/Ô4°cÑ:Ô:Ð:Ý˜dÔ1°4Ô3EÑFÔFð 	1ð 	1‰JˆD�$Ý�d”i Ñ*Ô*Ð*Ý�d”k "”oÔ,¨cÑ2Ô2Ð2Ý�d”k "”oÔ*¨CÑ0Ô0Ð0Ð0å˜œ¨Ô*Ô1Ñ2Ô2Ð2ØÔ!ð 	3Ý˜DœNÔ1Ñ2Ô2Ð2Ý˜Ô+Ô2°1Ô5Ô<Ñ=Ô=Ð=Ý˜Ô+Ô2°1Ô5Ô<Ñ=Ô=Ð=Ø”_ð 	-ð 	-ˆEÝ˜E !œHœOÑ,Ô,Ð,Ð,ð	-ð 	-rD   )rL   rI  r   r*   rS   r+   rK  rJ  r°  Nr7   rT   r¸   rÕ  F)rO   r/   rP   rQ   rL  r/   rM  r/   rN  r/   rO  r/   rP  r/   rQ  r/   rR  rä   rS  rT  rU  r/   rV  r/   rW  rä   rX  rä   rY  rÄ  rØ   )r,   r‰   ru  rv  r1   rw  )rš   r-   r›   r-   r1   r-   )r�  r‘  )
r  r’  rœ   r-   r“  rä   r”  rä   r1   r2   )r,   r‰   r1   rª  rñ   )
rœ   r-   r  r’  r€  rÏ   r�  rÏ   r1   r®  )rô   rõ   rö   r÷   r«   rÝ   r  rh   rø   r»   r¨  rº   rd   r¯   r©   rù   r©  r|  r}  rs  rü   rý   s   @rB   r#   r#   ˆ  sb  ø€ € € € € ð%ð %ðN €FØ€GØ€FØˆeŒk˜!‰nŒn€GØ�”˜Q‘”€JØ€Gð Ø%ØØØØØØØØ $ØàØ#&Ø!$Ø"'ð#M!ð M!ð M!ð M!ð M!ð M!ð M!ð^2,ð 2,ð 2,ð 2,ð 2,ðhoð oð oð oð0 ð  Øð	#ð #ð #ð #ñ „\ð#ðBð ð ð ð< )-Ø'+ðA>ð A>ð A>ð A>ð A>ðF-ð -ð -ð -ð -ð -ð -rD   r#   c                  ó&   ‡ — e Zd ZdZd	d
ˆ fd„Zˆ xZS )r(   a  v10 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 unused detection branch for inference.

    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)
    rL   rN   rO   r/   rP   rQ   c                ó.  •‡ ‡— t          ¦   «                              |d|¬¦  «         t          |d         t          ‰ j        d¦  «        ¦  «        Št          j        ˆˆ fd„|D ¦   «         ¦  «        ‰ _        t          j	        ‰ j        ¦  «        ‰ _
        dS )zäInitialize 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)rw   rP   r   rT   c              3  óB  •K  — | ]™}t          j        t          j        t          ||d |¬¦  «        t          |‰d¦  «        ¦  «        t          j        t          ‰‰d ‰¬¦  «        t          ‰‰d¦  «        ¦  «        t          j        ‰‰j        d¦  «        ¦  «        V — ŒšdS )rV   )r®  r   Nr_   r`   s     €€rB   r\   z%v10Detect.__init__.<locals>.<genexpr>	  s¬   øè è € ð !
ð !
ð õ ŒMÝ”�d 1 a¨¨aÐ0Ñ0Ô0µ$°q¸"¸a±.´.ÑAÔAÝ”�d 2 r¨1°Ð3Ñ3Ô3µT¸"¸bÀ!±_´_ÑEÔEÝ”	˜"˜dœg qÑ)Ô)ñô ð!
ð !
ð !
ð !
ð !
ð !
rD   N)rc   rd   rk   rl   rO   r   rm   rp   rs   rt   rv   )rJ   rO   rP   ra   rx   s   `  @€rB   rd   zv10Detect.__init__ÿ  s¡   øøø€ õ 	‰Œ×Ò˜ T¨bÐÑ1Ô1Ð1Ý��A”�˜DœG SÑ)Ô)Ñ*Ô*ˆå”=ð !
ð !
ð !
ð !
ð !
ð ð!
ñ !
ô !
ñ 
ô 
ˆŒõ  œ=¨¬Ñ2Ô2ˆÔÐÐrD   )rL   rN   rð   )rô   rõ   rö   r÷   rd   rü   rý   s   @rB   r(   r(   æ  sL   ø€ € € € € ðð ð03ð 3ð 3ð 3ð 3ð 3ð 3ð 3ð 3ð 3ð 3rD   r(   c                  ó6   ‡ — e Zd ZdZdZdZdZdˆ fd„	Zd„ Zˆ xZ	S )	r%   ag  YOLO semantic segmentation head for per-pixel classification.

    This head produces dense per-pixel class predictions. Unlike instance segmentation, no bounding boxes or instance
    masks are produced.

    Attributes:
        nc (int): Number of semantic classes.
        nl (int): Number of input feature levels.
        stride (torch.Tensor): Feature map strides.
        export (bool): Export mode flag.
        format (str): Export format.
        classifier (nn.Sequential): Final convolutional classifier head.
        aux_head (nn.Sequential | None): Auxiliary classifier on P4 for deep supervision.
    FNé   rN   c                óô  •— t          ¦   «                              ¦   «          || _        t          |¦  «        | _        t          j        | j        ¦  «        | _        |d         }t          j	        t          ||d¦  «        t          j        ||d¦  «        ¦  «        | _        t          |¦  «        dk    r>t          j	        t          |d         |d¦  «        t          j        ||d¦  «        ¦  «        nd| _        dS )zÄInitialize the semantic segmentation head.

        Args:
            nc (int): Number of semantic classes.
            ch (tuple): Tuple of channel sizes from neck feature maps (P3, P4).
        r   rV   r   N)rc   rd   rO   re   rf   rh   ri   rj   r   rW   r   rX   Ú
classifierÚaux_head)rJ   rO   rP   rŠ  rx   s       €rB   rd   zSemanticSegment.__init__(  sÊ   ø€ õ 	‰Œ×ÒÑÔÐØˆŒÝ�b‘'”'ˆŒÝ”k $¤'Ñ*Ô*ˆŒà�1”ˆåœ-­¨U°E¸1Ñ(=Ô(=½r¼yÈÐPRÐTUÑ?VÔ?VÑWÔWˆŒåY\Ð]_ÑY`ÔY`ÐcdÒYdÐYd�œ¥d¨2¨a¬5°%¸Ñ&;Ô&;½R¼YÀuÈbÐRSÑ=TÔ=TÑUÔUÐUÐjnˆŒˆˆrD   c                óè  — |                       |d         ¦  «        }| j        r&| j        �||                      |d         ¦  «        fS |S | j        r¢t	          j        |ddd¬¦  «        }| j        dv s| j        d	v rv| j        ro| j        dk    r| 	                    d¦  «        n| 
                    d¦  «        dk    }|                     | j        d
k    rt          j        nt          j        ¦  «        S |S |S )aq  Forward pass: fuse multi-scale features and predict per-pixel classes.

        Args:
            x (list[torch.Tensor]): List of feature maps [P3, P4].

        Returns:
            (torch.Tensor | tuple): Logits of shape [B, nc, H/8, W/8] during training (or a (main, aux) tuple when
                aux_head is present) and inference. ONNX, MNN, OpenVINO, TensorRT>=10, and multi-class Hailo-10/15
                export bake in the class reduction and return a compact map of shape [B, H, W] (uint8 when nc <= 256,
                else int32). Other export formats return upsampled logits of shape [B, nc, H, W].
        r   Nr   r+   rž  FrŸ  >   ÚmnnÚonnxÚopenvino>   Úhailorâ   r   )rÄ  r§   rÅ  r«   r¤  r¥  rå   Úbake_argmaxrO   Úargmaxr   rý  rh   Úuint8Úint32)rJ   r,   Úlogitsr®   Úclss        rB   r¯   zSemanticSegment.forward:  sî   € ð —’  1¤Ñ&Ô&ˆØŒ=ð 	ØŒ}Ð(Ø˜tŸ}š}¨Q¨q¬TÑ2Ô2Ð2Ð2ØˆMØŒ;ð 	Ý”˜f°1¸:ÐUZÐ[Ñ[Ô[ˆAð Œ{Ð9Ð9Ð9¸d¼kÐM`Ð>`Ð>`ÐeiÔeuÐ>`Ø%)¤W¨q¢[ [�a—h’h˜q‘k”k�k°a·i²iÀ±l´lÀQÒ6F�Ø—v’v¨T¬W¸ª^¨^�eœk˜kÅÄÑMÔMÐMØˆHØˆrD   )rÂ  rN   )
rô   rõ   rö   r÷   r«   rå   rË  rd   r¯   rü   rý   s   @rB   r%   r%     sm   ø€ € € € € ðð ð €FØ€FØ€Kðoð oð oð oð oð oð$ð ð ð ð ð ð rD   r%   )=r÷   Ú
__future__r   rs   rÊ   rh   Útorch.nn.functionalr   Ú
functionalr¤  Útorch.nn.initr   r   Úultralytics.utilsr   Úultralytics.utils.talr   r	   r
   Úultralytics.utils.torch_utilsr   r   r   Úblockr   r   r   r   r   r   r   r   r   r²  r   r   Útransformerr   r   r   Úutilsr   Ú__all__ÚModuler!   r$   r1  r   rM  r"   rm  r    r   rÀ  rÙ  r&   r'   rB  r#   r(   r%   rN   rD   rB   ú<module>rÝ     sÆ  ðà Ð à "Ð "Ð "Ð "Ð "Ð "à €€€Ø €€€à €€€Ø Ð Ð Ð Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4à $Ð $Ð $Ð $Ð $Ð $Ø DÐ DÐ DÐ DÐ DÐ DÐ DÐ DÐ DÐ DØ \Ð \Ð \Ð \Ð \Ð \Ð \Ð \Ð \Ð \à oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oÐ oØ Ð Ð Ð Ð Ð Ð Ð Ø ]Ð ]Ð ]Ð ]Ð ]Ð ]Ð ]Ð ]Ð ]Ð ]Ø &Ð &Ð &Ð &Ð &Ð &ð€ðtCð tCð tCð tCð tCˆRŒYñ tCô tCð tCðnPð Pð Pð Pð Pˆfñ Pô Pð Pðf8ð 8ð 8ð 8ð 8�ñ 8ô 8ð 8ðvE8ð E8ð E8ð E8ð E8ˆ&ñ E8ô E8ð E8ðPð ð ð ð ˆCñ ô ð ðBQð Qð Qð Qð Qˆ6ñ Qô Qð Qðhpð pð pð pð pˆTñ pô pð pðfOð Oð Oð Oð OˆBŒIñ Oô Oð Oðd2,ð 2,ð 2,ð 2,ð 2,ˆrŒyñ 2,ô 2,ð 2,ðjC%ð C%ð C%ð C%ð C%�&ñ C%ô C%ð C%ðNBð Bð Bð Bð BˆrŒyñ Bô Bð BðJ_Uð _Uð _Uð _Uð _U�&ñ _Uô _Uð _UðDvð vð vð vð v�;ñ vô vð vðr<Qð <Qð <Qð <Qð <Q�\ñ <Qô <Qð <Qð~[-ð [-ð [-ð [-ð [-�B”Iñ [-ô [-ð [-ð|
+3ð +3ð +3ð +3ð +3�ñ +3ô +3ð +3ð\Að Að Að Að A�b”iñ Aô Að Að Að ArD   