
    FPhG                     6   d Z ddlZddlZddlmZ ddlmZmZ ddlm	Z	m
Z
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 d
Z G d dej2                        Z G d de      Z G d de      Z G d dej2                        Z G d dej2                        Zy)zModel head modules.    N)	constant_xavier_uniform_)
TORCH_1_10	dist2bboxmake_anchors   )DFLProto)Conv)MLPDeformableTransformerDecoder!DeformableTransformerDecoderLayer)bias_init_with_problinear_init_)DetectSegmentPoseClassifyRTDETRDecoderc                        e Zd ZdZdZdZdZ ej                  d      Z	 ej                  d      Z
d fd	Zd Zd Z xZS )	r   z(YOLOv8 Detect head for detection models.FNr   c                 z    t                    | _        t        |       _        d _        | 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               _        t        j                   fd|D               _         j
                  dkD  rt!         j
                         _        yt        j"                          _        y)	zUInitializes the YOLOv8 detection layer with specified number of classes and channels.      r   d   c           
   3      K   | ]S  }t        j                  t        |d       t        d       t        j                  dj                  z  d             U yw)   r   r   N)nn
Sequentialr   Conv2dreg_max).0xc2selfs     fC:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\ultralytics/nn/modules/head.py	<genexpr>z"Detect.__init__.<locals>.<genexpr>%   sL      !lhjcdBMM$q"a.$r2q/299RT\\IY[\;]^hjs   AAc           
   3      K   | ]P  }t        j                  t        |d       t        d       t        j                  j                  d             R ywr   r   N)r   r   r   r   nc)r!   r"   c3r$   s     r%   r&   z"Detect.__init__.<locals>.<genexpr>'   K      wtvoptAr1~tBAPRPYPYZ\^b^e^eghPi!jtv   AAr   N)super__init__r)   lennlr    notorchzerosstridemaxminr   
ModuleListcv2cv3r	   Identitydfl)r$   r)   chr#   r*   	__class__s   `  @@r%   r.   zDetect.__init__   s    b't||a''kk$''*b"Q%1*dllQ&678#beSRUEV:WB== !lhj!l l== wtv ww(,q(83t||$bkkm    c           
         |d   j                   }t        | j                        D ]I  }t        j                   | j
                  |   ||          | j                  |   ||         fd      ||<   K | j                  r|S | j                  s| j                   |k7  r2d t        || j                  d      D        \  | _        | _        || _         t        j                  |D cg c]"  }|j                  |d   | j                  d      $ c}d      }| j                  r?| j                   dv r1|ddd| j"                  d	z  f   }|dd| j"                  d	z  df   }n.|j%                  | j"                  d	z  | j&                  fd      \  }}t)        | j+                  |      | j                  j-                  d      d
d      | j                  z  }| j                  rs| j                   dv re|d   | j                  d   z  }	|d   | j                  d   z  }
t        j.                  |
|	|
|	g|j0                        j3                  dd	d      }||z  }t        j                  ||j5                         fd      }| j                  r|S ||fS c c}w )zJConcatenates and returns predicted bounding boxes and class probabilities.r   r   c              3   @   K   | ]  }|j                  d d        yw)r   r   N)	transpose)r!   r"   s     r%   r&   z!Detect.forward.<locals>.<genexpr>2   s     )gEf!++a*;Efs         ?   )saved_modelpbtfliteedgetputfjsNr   T)xywhdim)rG   rH   r   )device)shaperanger0   r2   catr8   r9   trainingdynamicr   r4   anchorsstridesviewr1   exportformatr    splitr)   r   r;   	unsqueezetensorrL   reshapesigmoid)r$   r"   rM   ixix_catboxclsdboximg_himg_wimg_sizeys                r%   forwardzDetect.forward*   s4   !

twwA99kdhhqk!A$/!QqT1BCQGAaD  ==H\\TZZ50)g\RSUYU`U`beEf)g&DL$,DJ		AFAb27758TWWb9AFJ;;4;;*\\,DLL1,,,-C4<<!+,,-C{{DLL1$4dgg#>BHC#(>(>q(ARSTW[WcWcc;;4;;*?? !Ht{{1~-E!Ht{{1~-E||UE5%$@U]]^_abdefHHDIItS[[]+Q/KKq+aV+% Gs   'Jc                 F   | }t        |j                  |j                  |j                        D ]q  \  }}}d|d   j                  j
                  dd t        j                  d|j                  z  d|z  dz  z        |d   j                  j
                  d|j                   s y)zBInitialize Detect() biases, WARNING: requires stride availability.      ?rC   N   i  rD   )	zipr8   r9   r4   biasdatamathlogr)   )r$   mabss        r%   	bias_initzDetect.bias_initI   s~     155!%%2GAq!!$AbEJJOOA%)XXa!$$h#'a.G%HAbEJJOOEQTT" 3r>   )P    )__name__
__module____qualname____doc__rQ   rU   rM   r2   emptyrR   rS   r.   rf   rs   __classcell__r=   s   @r%   r   r      sD    2GFEekk!nGekk!nGL,>Ir>   r   c                   *     e Zd ZdZd fd	Zd Z xZS )r   z,YOLOv8 Segment head for segmentation models.c                 B    t            ||       | _        | _        t	        |d    j                   j                         _        t        j                   _        t        |d   dz   j                        t        j                   fd|D               _        y)ziInitialize the YOLO model attributes such as the number of masks, prototypes, and the convolution layers.r   r   c           
   3      K   | ]P  }t        j                  t        |d       t        d       t        j                  j                  d             R ywr(   )r   r   r   r   nmr!   r"   c4r$   s     r%   r&   z#Segment.__init__.<locals>.<genexpr>_   r+   r,   N)r-   r.   r   nprr
   protor   rf   detectr5   r   r7   cv4)r$   r)   r   r   r<   r   r=   s   `    @r%   r.   zSegment.__init__V   sv    R 2a5$((DGG4
nnA!TWW%== wtv wwr>   c           
         | j                  |d         }|j                  d   }t        j                  t	        | j
                        D cg c]5  } | j                  |   ||         j                  || j                  d      7 c}d      }| j                  | |      }| j                  r|||fS | j                  rt        j                  ||gd      |fS t        j                  |d   |gd      |d   ||ffS c c}w )zgReturn model outputs and mask coefficients if training, otherwise return outputs and mask coefficients.r   rC   rD   r   )r   rM   r2   rO   rN   r0   r   rT   r   r   rP   rU   )r$   r"   pbsr\   mcs         r%   rf   zSegment.forwarda   s    JJqtWWQZYYtwwXAAaD)..r477B?XZ[\KKa ==b!8O-1[[		1b'1%q)guyy!A$PRUV?WZ[\]Z^`bdeYf>gg	 Ys   
:C8)rt          ru   rv   rw   rx   ry   r.   rf   r{   r|   s   @r%   r   r   S   s    6	x	hr>   r   c                   0     e Zd ZdZd fd	Zd Zd Z xZS )r   z&YOLOv8 Pose head for keypoints models.c                     t            ||       | _        |d   |d   z   _        t        j
                   _        t        |d   dz   j                        t        j                   fd|D               _
        y)zIInitialize YOLO network with default parameters and Convolutional Layers.r   r   r   c           
   3      K   | ]P  }t        j                  t        |d       t        d       t        j                  j                  d             R ywr(   )r   r   r   r   nkr   s     r%   r&   z Pose.__init__.<locals>.<genexpr>x   r+   r,   N)r-   r.   	kpt_shaper   r   rf   r   r5   r   r7   r   )r$   r)   r   r<   r   r=   s   `   @r%   r.   zPose.__init__p   sg    R "A,1-nnA!TWW%== wtv wwr>   c           
         |d   j                   d   }t        j                  t        | j                        D cg c]5  } | j
                  |   ||         j                  || j                  d      7 c}d      }| j                  | |      }| j                  r||fS | j                  ||      }| j                  rt        j                  ||gd      S t        j                  |d   |gd      |d   |ffS c c}w )z?Perform forward pass through YOLO model and return predictions.r   rC   r   )rM   r2   rO   rN   r0   r   rT   r   r   rP   kpts_decoderU   )r$   r"   r   r\   kptpred_kpts         r%   rf   zPose.forwardz   s    qTZZ]ii%PTPWPW.Y.Q!QqT*//DGGR@.Y[]^KKa ==c6M##B,.2kkuyy!X*l		1Q4QYJZ\]@^abcdaegj`k?ll Zs   :C5c                    | j                   d   }| j                  r |j                  |g| j                   d }|ddddddf   dz  | j                  dz
  z   | j                  z  }|dk(  r2t        j                  ||ddddddf   j                         fd      }|j                  || j                  d      S |j                         }|dk(  r|dddddf   j                          |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 )	zDecodes keypoints.r   rC   NrD          @rB   r   r   )r   rU   rT   rR   rS   r2   rO   r[   r   clonesigmoid_)r$   r   kptsndimre   rp   s         r%   r   zPose.kpts_decode   sa   ~~a ;;		"2t~~2r2A1a!8s"dllS&89T\\IAqyIIq!Aq!A#I,"6"6"891=66"dggr**

Aqy!QTT'
##%q!'T'z]S0DLLOc4IJdllZAaDjMq!'T'z]S0DLLOc4IJdllZAaDjMHr>   )rt   )   r   ru   )rv   rw   rx   ry   r.   rf   r   r{   r|   s   @r%   r   r   m   s    0xmr>   r   c                   *     e Zd ZdZd fd	Zd Z xZS )r   z:YOLOv8 classification head, i.e. x(b,c1,20,20) to x(b,c2).c                     t         |           d}t        ||||||      | _        t	        j
                  d      | _        t	        j                  dd      | _        t	        j                  ||      | _
        y)zInitializes YOLOv8 classification head with specified input and output channels, kernel size, stride,
        padding, and groups.
        i   r           T)r   inplaceN)r-   r.   r   convr   AdaptiveAvgPool2dpoolDropoutdropLinearlinear)	r$   c1r#   krr   r   gc_r=   s	           r%   r.   zClassify.__init__   sa     	RAq!,	((+	JJd3	iiB'r>   c           	      &   t        |t              rt        j                  |d      }| j	                  | j                  | j                  | j                  |            j                  d                  }| j                  r|S |j                  d      S )z>Performs a forward pass of the YOLO model on input image data.r   )
isinstancelistr2   rO   r   r   r   r   flattenrP   softmax)r$   r"   s     r%   rf   zClassify.forward   sg    a		!QAKK		$))DIIaL"9"A"A!"DEFMMq3qyy|3r>   )r   r   Nr   r   r|   s   @r%   r   r      s    D	(4r>   r   c                        e Zd ZdZdZddddddd	d
d ej                         dddddf fd	ZddZde	j                  ddfdZd ZddZd Z xZS )r   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.
    Frt   )i      i   r   i,  r         r   r   rC   r   rB   rh   c                    t         |           | _        || _        t	        |      | _        || _        || _        || _        t        j                  fd|D              | _        t        |||	|
| j
                  |      }t        |||      | _        t        j                  |      | _        || _        || _        || _        || _        |rt        j                  |      | _        t-        ddz  d      | _        t        j0                  t        j2                        t        j4                              | _        t        j2                  |      | _        t-        dd      | _        t        j                  t=        |      D cg c]  }t        j2                  |       c}      | _        t        j                  t=        |      D cg c]  }t-        dd       c}      | _         | jC                          yc c}w c c}w )a|  
        Initializes the RTDETRDecoder module with the given parameters.

        Args:
            nc (int): Number of classes. Default is 80.
            ch (tuple): Channels in the backbone feature maps. Default is (512, 1024, 2048).
            hd (int): Dimension of hidden layers. Default is 256.
            nq (int): Number of query points. Default is 300.
            ndp (int): Number of decoder points. Default is 4.
            nh (int): Number of heads in multi-head attention. Default is 8.
            ndl (int): Number of decoder layers. Default is 6.
            d_ffn (int): Dimension of the feed-forward networks. Default is 1024.
            dropout (float): Dropout rate. Default is 0.
            act (nn.Module): Activation function. Default is nn.ReLU.
            eval_idx (int): Evaluation index. Default is -1.
            nd (int): Number of denoising. Default is 100.
            label_noise_ratio (float): Label noise ratio. Default is 0.5.
            box_noise_scale (float): Box noise scale. Default is 1.0.
            learnt_init_query (bool): Whether to learn initial query embeddings. Default is False.
        c           	   3      K   | ]D  }t        j                  t        j                  |d d      t        j                               F yw)r   F)rk   N)r   r   r   BatchNorm2d)r!   r"   hds     r%   r&   z)RTDETRDecoder.__init__.<locals>.<genexpr>   s<     'wtvopbii2qu6UWYWeWefhWi(jtvs   A
Ar   rD   )
num_layersr   N)"r-   r.   
hidden_dimnheadr/   r0   r)   num_queriesnum_decoder_layersr   r7   
input_projr   r   decoder	Embeddingdenoising_class_embednum_denoisinglabel_noise_ratiobox_noise_scalelearnt_init_query	tgt_embedr   query_pos_headr   r   	LayerNorm
enc_outputenc_score_headenc_bbox_headrN   dec_score_headdec_bbox_head_reset_parameters)r$   r)   r<   r   nqndpnhndld_ffndropoutacteval_idxndr   r   r   decoder_layer_r=   s      `              r%   r.   zRTDETRDecoder.__init__   s   L 	
b'"% --'wtv'ww
 :"b%RUW[W^W^`cd3BsHU &(\\"b%9"!2. "3\\"b1DN!!QVRA> --		"b(92<<;KL iiB/ Rq9 !mmc
,S
1RYYr2->
,ST]]RWX[R\+]R\QCBa,HR\+]^  -T+]s   HH
c           
      z   ddl m} | j                  |      \  }} ||| j                  | j                  | j
                  j                  | j                  | j                  | j                  | j                        \  }}}}	| j                  ||||      \  }
}}}| j                  |
|||| j                  | j                  | j                  |      \  }}|||||	f}| j                  r|S t!        j"                  |j%                  d      |j%                  d      j'                         fd      }| j(                  r|S ||fS )zdRuns the forward pass of the module, returning bounding box and classification scores for the input.r   )get_cdn_group)	attn_maskrC   )ultralytics.models.utils.opsr   _get_encoder_inputr)   r   r   weightr   r   r   rP   _get_decoder_inputr   r   r   r   r2   rO   squeezer[   rU   )r$   r"   batchr   featsshapesdn_embeddn_bboxr   dn_metaembed
refer_bbox
enc_bboxes
enc_scores
dec_bboxes
dec_scoresre   s                    r%   rf   zRTDETRDecoder.forward  sD   > //2v %''**44;;,,00..--) 	.'9g ##E68WE 	2z:z "&e.8.3.4.2.@.@.2.A.A.2.A.A8A ". "C
J 
J
GC==HIIz))!,j.@.@.C.K.K.MNPRSKKq+aV+r>   g?cpu{Gz?c                 .   g }t        |      D ]  \  }\  }}	t        j                  |||      }
t        j                  |	||      }t        rt        j                  |
|d      nt        j                  |
|      \  }}t        j
                  ||gd      }t        j                  ||	g||      }|j                  d      dz   |z  }t        j                  |||      |z  d|z  z  }|j                  t        j                  ||gd      j                  d||	z  d	              t        j                  |d
      }||kD  |d
|z
  k  z  j                  dd      }t        j                  |d
|z
  z        }|j                  | t        d            }||fS )z\Generates anchor bounding boxes for given shapes with specific grid size and validates them.)enddtyperL   ij)indexingrC   r   rL   r   rB   r   r   r   T)keepdiminf)	enumerater2   aranger   meshgridstackrY   rX   	ones_likeappendrO   rT   allrn   masked_fillfloat)r$   r   	grid_sizer   rL   epsrR   r\   hwsysxgrid_ygrid_xgrid_xyvalid_WHwh
valid_masks                     r%   _generate_anchorszRTDETRDecoder._generate_anchors)  su   "6*IAv1!5@B!5@BFPU^^BTBV[VdVdegikVlNFFkk66"2B7G||QF%GH((+c1X=GfE	QUX\]U]^BNN599gr]B7<<RQJK + ))GQ'}1s7):;@@T@R
))Gq7{34%%zk5<@
""r>   c                 d   t        |      D cg c]  \  }} | j                  |   |       }}}g }g }|D ]X  }|j                  dd \  }}|j                  |j	                  d      j                  ddd             |j                  ||g       Z t        j                  |d      }||fS c c}}w )zfProcesses and returns encoder inputs by getting projection features from input and concatenating them.rD   Nr   r   )r   r   rM   r   r   permuter2   rO   )r$   r"   r\   featr   r   r  r  s           r%   r   z RTDETRDecoder._get_encoder_input=  s     6?q\B\'!TT__Q%\BD::ab>DAqLLa00Aq9:MM1a&!  		%#f} Cs   B,c                    t        |      }| j                  ||j                  |j                        \  }}| j	                  ||z        }| j                  |      }	t        j                  |	j                  d      j                  | j                  d      j                  j                  d      }
t        j                  ||
j                        j                  d      j                  d| j                        j                  d      }|||
f   j                  || j                  d      }|dd|
f   j                  || j                  d      }| j!                  |      |z   }|j#                         }|t        j$                  ||gd      }|	||
f   j                  || j                  d      }| j&                  r6| j(                  j*                  j                  d      j                  |dd      n|}| j,                  r,|j/                         }| j&                  s|j/                         }|t        j$                  ||gd      }||||fS )z`Generates and prepares the input required for the decoder from the provided features and shapes.r   rC   r   )rK   )r   r   Nr   )r/   r  r   rL   r   r   r2   topkr5   valuesr   indicesrT   r   rX   repeatr   r[   rO   r   r   r   rP   detach)r$   r   r   r   r   r   rR   r  featuresenc_outputs_scorestopk_ind	batch_indtop_k_featurestop_k_anchorsr   r   r   
embeddingss                     r%   r   z RTDETRDecoder._get_decoder_inputO  s   Z"44V5;;W\WcWc4d??:#56!00: ::044R8??AQAQWXYaaffgijLLRx~~>HHLSSTUW[WgWghmmnpq	 ")X"56;;B@P@PRTU8,11"d6F6FK ''7-G
'')
GZ#8!<J'	8(;<AA"dFVFVXZ[
LPLbLbT^^**44Q7>>r1aHhv
==#**,J))'..0
Hj#91=J:z:==r>   c                    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 ]a  \  }}t        |j                  |       t        |j                  d   j                  d       t        |j                  d   j                  d       c t        | 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                          y)zjInitializes or resets the parameters of the model's various components with predefined weights and biases.r   rt   rC   r   r   r   N)r   r)   r   r   rk   r   layersr   rj   r   r   r   r   r   r   r   r   r   )r$   bias_clscls_reg_layers        r%   r   zRTDETRDecoder._reset_parametersv  sw    't,r1DGG; 	$%%**H5$$$++B/66;$$$++B/44b9d1143E3EFJD$dii*dkk"o,,b1dkk"o**B/	 G 	T__Q'(*112!!DNN112++2215<<=++2215<<=__EE!HOO, %r>   )N)NN)rv   rw   rx   ry   rU   r   ReLUr.   rf   r2   float32r  r   r   r   r{   r|   s   @r%   r   r      sy     F  	!##L!\#,J 37emmTY_c #($$>N-r>   r   )ry   rm   r2   torch.nnr   torch.nn.initr   r   ultralytics.utils.talr   r   r   blockr	   r
   r   r   transformerr   r   r   utilsr   r   __all__Moduler   r   r   r   r   ru   r>   r%   <module>r/     s~        4 E E   ] ] 4
B<IRYY <I~hf h4&6 &R4ryy 4,`-BII `-r>   