Ë
    ÛÓ^jk� ã                   óZ  — d dl Z d dlmZ d dlmZ d dlZd dlmZ d dlmc m	Z
 d dlmZ ddlmZ ddlmZ ddlmZ dd	lmZmZ dd
lmZ ddlmZ ddlmZmZ ddlmZ ddlm Z  ddl!m"Z"m#Z#m$Z$m%Z% ddl&m'Z'm(Z( ddl)m*Z*m+Z+ ddl,m-Z-  e#d¬«      e G d„ de«      «       «       Z. e#d¬«      e G d„ de«      «       «       Z/ e#d¬«      e G d„ de«      «       «       Z0 ed«       G d„ d ejb                  «      «       Z2 G d!„ d"ejb                  «      Z3 G d#„ d$ejb                  «      Z4 G d%„ d&ejb                  «      Z5	 d‚d'ed(ed)ed*ed+e6e7   d,efd-„Z8 G d.„ d/ejb                  «      Z9 G d0„ d1ejb                  «      Z: G d2„ d3ejb                  «      Z; G d4„ d5ejb                  «      Z< G d6„ d7ejb                  «      Z= G d8„ d9ejb                  «      Z>	 	 dƒd:ejb                  d;ej                  d<ej                  d'ej                  d=ej                  dz  d>e?dz  d?e?d@ee"   fdA„Z@ G dB„ dCejb                  «      ZA G dD„ dEejb                  «      ZBdFdGdHdej†                  fdIe7dJe7dKe7dLe?dMeDdNejŠ                  dz  dOejŒ                  d,ej                  fdP„ZG G dQ„ dRejb                  «      ZH G dS„ dTejb                  «      ZI G dU„ dVejb                  «      ZJ G dW„ dXejb                  «      ZK G dY„ dZejb                  «      ZL G d[„ d\ejb                  «      ZMe# G d]„ d^e«      «       ZN G d_„ d`ejb                  «      ZOda„ ZP G db„ dceN«      ZQ G dd„ deeN«      ZR G df„ dgeN«      ZSd„dhej                  diej                  djeTd,ej                  fdk„ZU G dl„ dmeN«      ZVd…dn„ZWdoe7dpej                  dqe7d,ej                  fdr„ZXdsej                  dqe?d,ej                  fdt„ZY G du„ dveN«      ZZ	 	 	 d†dw„Z[ e#dx¬«       G dy„ dzeN«      «       Z\ e#d{¬«      e G d|„ d}e«      «       «       Z] e#d~¬«       G d„ d€eN«      «       Z^g d�¢Z_y)‡é    N)ÚCallable)Ú	dataclass)ÚTensoré   )Úinitialization)ÚACT2CLS)Úload_backbone)Úcenter_to_corners_formatÚcorners_to_center_format)Úuse_kernel_forward_from_hub)ÚModelOutput)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)Ú#compile_compatible_method_lru_cache)ÚTransformersKwargsÚauto_docstringÚtorch_compilable_checkÚ	torch_int)Úcan_return_tupleÚmerge_with_config_defaults)ÚOutputRecorderÚcapture_outputsé   )ÚDeimv2Configa&  
    Base class for outputs of the Deimv2Decoder. This class adds two attributes to
    BaseModelOutputWithCrossAttentions, namely:
    - a stacked tensor of intermediate decoder hidden states (i.e. the output of each decoder layer)
    - a stacked tensor of intermediate reference points.
    )Úcustom_introc                   óŒ  — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	ej                  dz  ed<   dZ
ej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZeej                     dz  ed	<   dZeej                     dz  ed
<   dZeej                     dz  ed<   y)ÚDeimv2DecoderOutputa!  
    intermediate_hidden_states (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, hidden_size)`):
        Stacked intermediate hidden states (output of each layer of the decoder).
    intermediate_logits (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, sequence_length, config.num_labels)`):
        Stacked intermediate logits (logits of each layer of the decoder).
    intermediate_reference_points (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, sequence_length, hidden_size)`):
        Stacked intermediate reference points (reference points of each layer of the decoder).
    intermediate_predicted_corners (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, 4)`):
        Stacked intermediate predicted corners (predicted corners of each layer of the decoder).
    initial_reference_points (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, 4)`):
        Stacked initial reference points (initial reference points of each layer of the decoder).
    cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` and `config.add_cross_attention=True` is passed or when `config.output_attentions=True`):
        Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
        sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax,
        used to compute the weighted average in the cross-attention heads.
    NÚlast_hidden_stateÚintermediate_hidden_statesÚintermediate_logitsÚintermediate_reference_pointsÚintermediate_predicted_cornersÚinitial_reference_pointsÚhidden_statesÚ
attentionsÚcross_attentions)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   ÚtorchÚFloatTensorÚ__annotations__r    r!   r"   r#   r$   r%   Útupler&   r'   © ó    úu/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/deimv2/modeling_deimv2.pyr   r   -   sÜ   … ñð" 37Ð�u×(Ñ(¨4Ñ/Ó6Ø;?Ð × 1Ñ 1°DÑ 8Ó?Ø48Ð˜×*Ñ*¨TÑ1Ó8Ø>BÐ! 5×#4Ñ#4°tÑ#;ÓBØ?CÐ" E×$5Ñ$5¸Ñ$<ÓCØ9=Ð˜e×/Ñ/°$Ñ6Ó=Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ó6Ø8<Ð�e˜E×-Ñ-Ñ.°Ñ5Ô<r1   r   zF
    Base class for outputs of the RT-DETR encoder-decoder model.
    c                   óì  — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	ej                  dz  ed<   dZ
ej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZeej                     dz  ed	<   dZeej                     dz  ed
<   dZeej                     dz  ed<   dZej                  dz  ed<   dZeej                     dz  ed<   dZeej                     dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZedz  ed<   y)ÚDeimv2ModelOutputa{
  
    last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`):
        Sequence of hidden-states at the output of the last layer of the decoder of the model.
    intermediate_hidden_states (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, hidden_size)`):
        Stacked intermediate hidden states (output of each layer of the decoder).
    intermediate_logits (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, sequence_length, config.num_labels)`):
        Stacked intermediate logits (logits of each layer of the decoder).
    intermediate_reference_points (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, 4)`):
        Stacked intermediate reference points (reference points of each layer of the decoder).
    intermediate_predicted_corners (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, 4)`):
        Stacked intermediate predicted corners (predicted corners of each layer of the decoder).
    initial_reference_points (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`):
        Initial reference points used for the first decoder layer.
    init_reference_points (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`):
        Initial reference points sent through the Transformer decoder.
    enc_topk_logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_labels)`):
        Predicted bounding boxes scores where the top `config.two_stage_num_proposals` scoring bounding boxes are
        picked as region proposals in the encoder stage. Output of bounding box binary classification (i.e.
        foreground and background).
    enc_topk_bboxes (`torch.FloatTensor` of shape `(batch_size, sequence_length, 4)`):
        Logits of predicted bounding boxes coordinates in the encoder stage.
    enc_outputs_class (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_labels)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
        Predicted bounding boxes scores where the top `config.two_stage_num_proposals` scoring bounding boxes are
        picked as region proposals in the first stage. Output of bounding box binary classification (i.e.
        foreground and background).
    enc_outputs_coord_logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, 4)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
        Logits of predicted bounding boxes coordinates in the first stage.
    denoising_meta_values (`dict`):
        Extra dictionary for the denoising related values.
    Nr   r    r!   r"   r#   r$   Údecoder_hidden_statesÚdecoder_attentionsr'   Úencoder_last_hidden_stateÚencoder_hidden_statesÚencoder_attentionsÚinit_reference_pointsÚenc_topk_logitsÚenc_topk_bboxesÚenc_outputs_classÚenc_outputs_coord_logitsÚdenoising_meta_values)r(   r)   r*   r+   r   r,   r-   r.   r    r!   r"   r#   r$   r5   r/   r6   r'   r7   r8   r9   r:   r;   r<   r=   r>   r?   Údictr0   r1   r2   r4   r4   S   s¥  … ñð> 37Ð�u×(Ñ(¨4Ñ/Ó6Ø;?Ð × 1Ñ 1°DÑ 8Ó?Ø48Ð˜×*Ñ*¨TÑ1Ó8Ø>BÐ! 5×#4Ñ#4°tÑ#;ÓBØ?CÐ" E×$5Ñ$5¸Ñ$<ÓCØ9=Ð˜e×/Ñ/°$Ñ6Ó=Ø=AÐ˜5 ×!2Ñ!2Ñ3°dÑ:ÓAØ:>Ð˜˜e×/Ñ/Ñ0°4Ñ7Ó>Ø8<Ð�e˜E×-Ñ-Ñ.°Ñ5Ó<Ø:>Ð˜u×0Ñ0°4Ñ7Ó>Ø=AÐ˜5 ×!2Ñ!2Ñ3°dÑ:ÓAØ:>Ð˜˜e×/Ñ/Ñ0°4Ñ7Ó>Ø6:Ð˜5×,Ñ,¨tÑ3Ó:Ø04€O�U×&Ñ&¨Ñ-Ó4Ø04€O�U×&Ñ&¨Ñ-Ó4Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø9=Ð˜e×/Ñ/°$Ñ6Ó=Ø)-Ð˜4 $™;Ô-r1   r4   z 
    Output type for DEIMv2 encoder modules (HybridEncoder and LiteEncoder).
    Attentions are only available for HybridEncoder variants with AIFI layers.
    c                   óž   — e Zd ZU dZdZeej                     ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)ÚDeimv2EncoderOutputz…
    feature_maps (`list[torch.FloatTensor]`):
        List of multi-scale feature maps from the encoder, one per feature level.
    NÚfeature_maps.r%   r&   )r(   r)   r*   r+   rC   Úlistr,   r-   r.   r%   r/   r&   r0   r1   r2   rB   rB   �   s\   … ñð
 -1€L�$�u×(Ñ(Ñ)Ó0Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ô;r1   rB   ÚRMSNormc                   óh   ‡ — e Zd Zddeddfˆ fd„Zdej                  dej                  fd„Zd„ Zˆ xZ	S )	ÚDeimv2RMSNormÚepsÚreturnNc                 óŠ   •— t         ‰| �  «        t        j                  t	        j
                  |«      «      | _        || _        y)z<
        Deimv2RMSNorm is equivalent to T5LayerNorm
        N)ÚsuperÚ__init__ÚnnÚ	Parameterr,   ÚonesÚweightÚvariance_epsilon)ÚselfÚhidden_sizerH   Ú	__class__s      €r2   rL   zDeimv2RMSNorm.__init__¡   s1   ø€ ô 	‰ÑÔÜ—l‘l¤5§:¡:¨kÓ#:Ó;ˆŒØ #ˆÕr1   r%   c                 ó"  — |j                   }|j                  t        j                  «      }|j	                  d«      j                  dd¬«      }|t        j                  || j                  z   «      z  }| j                  |j                  |«      z  S )Né   éÿÿÿÿT©Úkeepdim)	ÚdtypeÚtor,   Úfloat32ÚpowÚmeanÚrsqrtrQ   rP   )rR   r%   Úinput_dtypeÚvariances       r2   ÚforwardzDeimv2RMSNorm.forward©   sy   € Ø#×)Ñ)ˆØ%×(Ñ(¬¯©Ó7ˆØ ×$Ñ$ QÓ'×,Ñ,¨R¸Ð,Ó>ˆØ%¬¯©°H¸t×?TÑ?TÑ4TÓ(UÑUˆØ�{‰{˜]×-Ñ-¨kÓ:Ñ:Ð:r1   c                 ó^   — t        | j                  j                  «      › d| j                  › �S )Nz, eps=)r/   rP   ÚshaperQ   )rR   s    r2   Ú
extra_reprzDeimv2RMSNorm.extra_repr°   s*   € Ü˜Ÿ™×)Ñ)Ó*Ð+¨6°$×2GÑ2GÐ1HÐIÐIr1   )g�íµ ÷Æ°>)
r(   r)   r*   ÚfloatrL   r,   r   rb   re   Ú__classcell__©rT   s   @r2   rG   rG   Ÿ   s7   ø„ ñ$¨ð $¸$õ $ð; U§\¡\ð ;°e·l±ló ;öJr1   rG   c                   ó*   ‡ — e Zd Zdefˆ fd„Zd„ Zˆ xZS )ÚDeimv2SwiGLUFFNÚconfigc                 ó\  •— t         ‰| �  «        |j                  dz  }t        j                  |j
                  |d¬«      | _        t        j                  |j
                  |d¬«      | _        t        j                  ||j
                  d¬«      | _        t        j                  «       | _
        y )NrV   T©Úbias)rK   rL   Údecoder_ffn_dimrM   ÚLinearÚd_modelÚ	gate_projÚup_projÚ	down_projÚSiLUÚact_fn)rR   rk   Úhidden_featuresrT   s      €r2   rL   zDeimv2SwiGLUFFN.__init__µ   ss   ø€ Ü‰ÑÔØ ×0Ñ0°AÑ5ˆÜŸ™ 6§>¡>°?ÈÔNˆŒÜ—y‘y §¡°ÀtÔLˆŒÜŸ™ ?°F·N±NÈÔNˆŒÜ—g‘g“iˆ�r1   c                 óˆ   — | j                  | j                  | j                  |«      «      | j                  |«      z  «      }|S ©N)rt   rv   rr   rs   )rR   Úxrt   s      r2   rb   zDeimv2SwiGLUFFN.forward½   s6   € Ø—N‘N 4§;¡;¨t¯~©~¸aÓ/@Ó#AÀDÇLÁLÐQRÃOÑ#SÓTˆ	ØÐr1   )r(   r)   r*   r   rL   rb   rg   rh   s   @r2   rj   rj   ´   s   ø„ ð ˜|õ  ör1   rj   c                   ót   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  dej                  fd„Zˆ xZS )Ú
Deimv2Gaterq   c                 ó„   •— t         ‰| �  «        t        j                  d|z  d|z  «      | _        t        |«      | _        y )NrV   )rK   rL   rM   rp   ÚgaterG   Únorm)rR   rq   rT   s     €r2   rL   zDeimv2Gate.__init__Ã   s4   ø€ Ü‰ÑÔÜ—I‘I˜a '™k¨1¨w©;Ó7ˆŒ	Ü! 'Ó*ˆ�	r1   Úsecond_residualr%   rI   c                 óà   — t        j                  ||gd¬«      }t        j                  | j                  |«      «      }|j	                  dd¬«      \  }}| j                  ||z  ||z  z   «      }|S )NrW   ©ÚdimrV   )r,   ÚcatÚsigmoidr~   Úchunkr   )rR   r€   r%   Ú
gate_inputÚgatesÚgate1Úgate2s          r2   rb   zDeimv2Gate.forwardÈ   sg   € Ü—Y‘Y °Ð?ÀRÔHˆ
Ü—‘˜dŸi™i¨
Ó3Ó4ˆØ—{‘{ 1¨"�{Ó-‰ˆˆuØŸ	™	 %¨/Ñ"9¸EÀMÑ<QÑ"QÓRˆØÐr1   )	r(   r)   r*   ÚintrL   r,   r   rb   rg   rh   s   @r2   r|   r|   Â   s8   ø„ ð+ õ +ð
 u§|¡|ð ÀEÇLÁLð ÐUZ×UaÑUa÷ r1   r|   c                   ón   ‡ — e Zd Zd
dededededef
ˆ fd„Zdej                  dej                  fd	„Zˆ xZ	S )Ú	Deimv2MLPÚ	input_dimÚ
hidden_dimÚ
output_dimÚ
num_layersÚactc                 óÔ   •— t         ‰	| �  «        || _        |g|dz
  z  }|g|z   }||gz   }t        j                  d„ t        ||«      D «       «      | _        t        |   «       | _        y )Nr   c              3   óN   K  — | ]  \  }}t        j                  ||«      –— Œ y ­wry   )rM   rp   )Ú.0Úin_dimÚout_dims      r2   ú	<genexpr>z%Deimv2MLP.__init__.<locals>.<genexpr>×   s   è ø€ Ò#sÁ?À6È7¤B§I¡I¨f°g×$>Ñ#sùs   ‚#%)	rK   rL   r‘   rM   Ú
ModuleListÚzipÚlayersr   r’   )
rR   rŽ   r�   r�   r‘   r’   Úhidden_dimsÚ
input_dimsÚoutput_dimsrT   s
            €r2   rL   zDeimv2MLP.__init__Ñ   sj   ø€ Ü‰ÑÔØ$ˆŒØ!�l j°1¡nÑ5ˆØ�[ ;Ñ.ˆ
Ø! Z LÑ0ˆÜ—m‘mÑ#sÔVYÐZdÐfqÓVrÔ#sÓsˆŒÜ˜3‘<“>ˆ�r1   Ústat_featuresrI   c                 ó¢   — t        | j                  «      D ]6  \  }}|| j                  dz
  k  r| j                   ||«      «      n ||«      }Œ8 |S ©Nr   )Ú	enumerater›   r‘   r’   )rR   rŸ   ÚiÚlayers       r2   rb   zDeimv2MLP.forwardÚ   sS   € Ü! $§+¡+Ó.ò 	p‰HˆAˆuØ>?À$Ç/Á/ÐTUÑBUÒ>U˜DŸH™H¡U¨=Ó%9Ô:Ñ[`ÐanÓ[o‰Mð	pàÐr1   )Úrelu)
r(   r)   r*   r‹   ÚstrrL   r,   r   rb   rg   rh   s   @r2   r�   r�   Ð   sH   ø„ ñ" #ð "°3ð "ÀCð "ÐUXð "Ð_bõ "ð U§\¡\ð °e·l±l÷ r1   r�   ÚvalueÚvalue_spatial_shapesÚsampling_locationsÚattention_weightsÚnum_points_listrI   c                 ó  — | j                   \  }}}}	|j                   \  }}
}}}| j                  dddd«      j                  dd«      j                  |D ��cg c]
  \  }}||z  ‘Œ c}}d¬«      }|dk(  r	d|z  dz
  }n|dk(  r|}j                  ddddd	«      j                  dd«      }|j                  |d
¬«      }g }t	        |«      D �]«  \  }\  }}||   j                  ||z  |	||«      }||   }|dk(  r&t        j                  j                  ||ddd¬«      }�nG|dk(  �rA|t        j                  ||gg| j                  ¬«      z  dz   j                  t        j                  «      }|d   j                  d|dz
  «      }|d   j                  d|dz
  «      }t        j                  ||gd¬«      }|j                  ||z  |
||   z  d«      }t        j                   |j                   d   | j                  ¬«      j#                  d«      j%                  d|j                   d   «      }||d d …|d   |d   f   }|j'                  dd«      j                  ||z  |	|
||   «      }|j)                  «       �Œ® |j                  dddd«      j                  ||z  d|
t+        |«      «      }t        j,                  |d¬«      |z  j+                  d«      j/                  |||	z  |
«      }|j'                  dd«      j1                  «       S c c}}w )Nr   rV   r   r   rW   r‚   ÚdefaultÚdiscreteé   éþÿÿÿÚbilinearÚzerosF)ÚmodeÚpadding_modeÚalign_corners©Údeviceç      à?©.r   ©.r   )rd   ÚpermuteÚflattenÚsplitr¢   ÚreshaperM   Ú
functionalÚgrid_sampler,   Útensorr·   r[   Úint64ÚclampÚstackÚarangeÚ	unsqueezeÚrepeatÚ	transposeÚappendÚsumÚconcatÚviewÚ
contiguous)r§   r¨   r©   rª   r«   ÚmethodÚ
batch_sizeÚ_Ú	num_headsr�   Únum_queriesÚ
num_levelsÚ
num_pointsÚheightÚwidthÚ
value_listÚsampling_gridsÚsampling_value_listÚlevel_idÚvalue_l_Úsampling_grid_l_Úsampling_value_l_Úsampling_coordÚsampling_coord_xÚsampling_coord_yÚsampling_idxÚoutputs                              r2   Ú#multi_scale_deformable_attention_v2rã   à   sQ  € ð ,1¯;©;Ñ(€J��9˜jØ8J×8PÑ8PÑ5€A€{�I˜z¨:à�‰�a˜˜A˜qÓ!ß	‰��A‹ß	‰Ð4H×I¡= 6¨5�˜“ÓIÈrˆÓ	Rð ð �ÒØÐ/Ñ/°!Ñ3‰Ø	�:Ò	Ø+ˆØ#×+Ñ+¨A¨q°!°Q¸Ó:×BÑBÀ1ÀaÓH€NØ#×)Ñ)¨/¸rÐ)ÓB€NØÐÜ%.Ð/CÓ%Dó $6Ñ!ˆ‘/�6˜5ð
 ˜hÑ'×/Ñ/°
¸YÑ0FÈ
ÐTZÐ\aÓbˆð *¨(Ñ3Ðà�YÒÜ "§¡× 9Ñ 9ØÐ*°È'Ðafð !:ó !Òð �zÓ!Ø.´·±ÀÀv¸Ð>OÐX]×XdÑXdÔ1eÑeÐhkÑk×oÑoÜ—‘óˆNð
  .¨fÑ5×;Ñ;¸A¸uÀq¹yÓIÐØ-¨fÑ5×;Ñ;¸A¸vÈ¹zÓJÐô #Ÿ[™[Ð*:Ð<LÐ)MÐSUÔVˆNØ+×3Ñ3°JÀÑ4JÈKÐZiÐjrÑZsÑLsÐuvÓwˆNä—‘˜^×1Ñ1°!Ñ4¸U¿\¹\ÔJß‘˜2“ß‘˜˜>×/Ñ/°Ñ2Ó3ð ð
 !)¨²q¸.ÈÑ:PÐR`ÐagÑRhÐ)hÑ iÐØ 1× ;Ñ ;¸A¸qÓ A× IÑ IØ˜YÑ&¨
°KÀÐQYÑAZó!Ðð 	×"Ñ"Ð#4Ö5ðI$6ðP *×1Ñ1°!°Q¸¸1Ó=×EÑEØ�YÑ  ;´°OÓ0DóÐô 
�‰Ð)¨rÔ	2Ð5FÑ	Fß	‰ˆR‹ß	‰ˆj˜) jÑ0°+Ó	>ð ð
 ×Ñ˜A˜qÓ!×,Ñ,Ó.Ð.ùóu Js   ÁL
c                   ó®   ‡ — e Zd Zdefˆ fd„Z	 	 	 	 	 d	dej                  dej                  dz  dee   de	ej                  ej                  f   fd„Z
ˆ xZS )
Ú#Deimv2MultiscaleDeformableAttentionrk   c                 ó¤  •— t         ‰| �  «        |j                  | _        |j                  | _        |j
                  | _        |j                  | _        |j                  | _	        |j                  | _        t        | j                  t        «      r| j                  }n,t        | j                  «      D �cg c]  }| j                  ‘Œ }}|| _        | j                  D ��cg c]  }t        |«      D ]  }d|z  ‘Œ	 Œ }}}| j!                  dt#        j$                  |t"        j&                  ¬«      «       | j                  t)        | j                  «      z  | _        t-        j.                  | j                  | j*                  dz  «      | _        t-        j.                  | j                  | j*                  «      | _        t4        | _        yc c}w c c}}w )zC
        D-Fine version of multiscale deformable attention
        r   Únum_points_scale©rZ   rV   N)rK   rL   rq   Údecoder_attention_headsÚn_headsÚnum_feature_levelsÚn_levelsÚdecoder_offset_scaleÚoffset_scaleÚdecoder_methodÚdecoder_n_pointsÚn_pointsÚ
isinstancerD   Úranger«   Úregister_bufferr,   rÁ   r\   rÊ   Útotal_pointsrM   rp   Úsampling_offsetsrª   rã   Úms_deformable_attn_core)rR   rk   r«   rÐ   Únrç   rT   s         €r2   rL   z,Deimv2MultiscaleDeformableAttention.__init__+  s^  ø€ ô 	‰ÑÔØ—~‘~ˆŒØ×5Ñ5ˆŒØ×1Ñ1ˆŒØ"×7Ñ7ˆÔØ$×3Ñ3ˆÔØ×/Ñ/ˆŒä�d—m‘m¤TÔ*Ø"Ÿm™m‰Oä6;¸D¿M¹MÓ6JÖK°˜tŸ}›}ÐKˆOÐKà.ˆÔØ+/×+?Ñ+?×R aÌÈqËÒRÀA˜A ›EÐR˜EÐRÐÑRØ×ÑÐ/´·±Ð>NÔV[×VcÑVcÔ1dÔeà ŸL™L¬3¨t×/CÑ/CÓ+DÑDˆÔä "§	¡	¨$¯,©,¸×8IÑ8IÈAÑ8MÓ NˆÔÜ!#§¡¨4¯<©<¸×9JÑ9JÓ!KˆÔä'JˆÕ$ùò Lùó Ss   Â4GÃGNr%   Úattention_maskÚkwargsrI   c                 ó  — |j                   \  }}	}
|j                   \  }}}
t        |d d …df   |d d …df   z  j                  «       |k(  d«       |j                  ||| j                  | j
                  | j                  z  «      }|�|j                  |d    t        d«      «      }| j                  |«      }|j                  ||	| j                  t        | j                  «      d«      }| j                  |«      j                  ||	| j                  t        | j                  «      «      }t        j                  |d¬«      }|j                   d   dk(  rlt        j                  |«      }|j                  dg«      j                  ddd| j                   dd«      }|j                  ||d| j                   dd«      ||z  z   }nž|j                   d   dk(  rp| j"                  j%                  |j&                  ¬	«      j)                  d«      }||z  |d d …d d …d d d …dd …f   z  | j*                  z  }|d d …d d …d d d …d d…f   |z   }nt-        d
|j                   d   › d�«      ‚| j/                  ||||| j                  | j0                  «      }||fS )Nr   r   z[Make sure to align the spatial shapes with the sequence length of the encoder hidden states).NrV   rW   r‚   r¯   rè   z5Last dim of reference_points must be 2 or 4, but get z	 instead.)rd   r   rÊ   r¾   rê   rq   Úmasked_fillrf   rö   r«   rª   ÚFÚsoftmaxr,   rÁ   Úfliprì   rç   r[   rZ   rÆ   rî   Ú
ValueErrorr÷   rï   )rR   r%   rù   Úreference_pointsr8   Úspatial_shapesÚspatial_shapes_listrú   rÏ   rÒ   rÐ   Úsequence_lengthr§   rö   rª   Úoffset_normalizerr©   rç   Úoffsetrâ   s                       r2   rb   z+Deimv2MultiscaleDeformableAttention.forwardG  s°  € ð &3×%8Ñ%8Ñ"ˆ
�K Ø)>×)DÑ)DÑ&ˆ
�O QäØšA˜q˜DÑ! N²1°a°4Ñ$8Ñ8×=Ñ=Ó?À?ÑRØiô	
ð &×-Ñ-¨j¸/È4Ï<É<ÐY]×YeÑYeÐim×iuÑiuÑYuÓvˆØÐ%Ø×%Ñ% ~°iÑ'@Ð&@Ä%ÈÃ(ÓKˆEà)-×)>Ñ)>¸}Ó)MÐØ+×3Ñ3Ø˜ T§\¡\´3°t×7KÑ7KÓ3LÈaó
Ðð !×2Ñ2°=ÓA×IÑIØ˜ T§\¡\´3°t×7KÑ7KÓ3Ló
Ðô ŸI™IÐ&7¸RÔ@Ðà×!Ñ! "Ñ%¨Ò*Ü %§¡¨^Ó <ÐØ 1× 6Ñ 6¸°sÓ ;× CÑ CÀAÀqÈ!ÈTÏ]É]Ð\]Ð_`Ó aÐà ×(Ñ(¨°_ÀaÈÏÉÐXYÐ[\Ó]Ø"Ð%6Ñ6ñ7ñ ð ×#Ñ# BÑ'¨1Ò,ð  $×4Ñ4×7Ñ7¸m×>QÑ>QÐ7ÓR×\Ñ\Ð]_Ó`ÐØ%Ð(8Ñ8Ð;KÊAÊqÐRVÒXYÐ[\Ñ[]ÐL]Ñ;^Ñ^Ðae×arÑarÑrˆFØ!1²!²Q¸ºaÀÀ!ÀÐ2CÑ!DÀvÑ!MÑäØGÐHX×H^ÑH^Ð_aÑHbÐGcÐclÐmóð ð ×-Ñ-ØØØØØ× Ñ Ø×Ñó
ˆð Ð(Ð(Ð(r1   ©NNNNN)r(   r)   r*   r   rL   r,   r   r   r   r/   rb   rg   rh   s   @r2   rå   rå   *  sr   ø„ ðK˜|õ Kð> /3ØØ"ØØ ñ<)à—|‘|ð<)ð Ÿ™ tÑ+ð<)ð Ð+Ñ,ð<)ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷<)r1   rå   c                   óZ   ‡ — e Zd Z	 	 	 ddedededededededz  d	edz  fˆ fd
„Zd„ Zˆ xZS )ÚDeimv2ConvNormLayerNrk   Úin_channelsÚout_channelsÚkernel_sizeÚstrideÚgroupsÚpaddingÚ
activationc	           	      ó  •— t         ‰	| �  «        t        j                  ||||||€|dz
  dz  n|d¬«      | _        t        j
                  ||j                  «      | _        |€t        j                  «       | _
        y t        |   «       | _
        y )Nr   rV   F)r  r  rn   )rK   rL   rM   ÚConv2dÚconvÚBatchNorm2dÚbatch_norm_epsr   ÚIdentityr   r  )
rR   rk   r
  r  r  r  r  r  r  rT   s
            €r2   rL   zDeimv2ConvNormLayer.__init__‡  s~   ø€ ô 	‰ÑÔÜ—I‘IØØØØØØ.5¨o�[ 1‘_¨Ò*À7Øô
ˆŒ	ô —N‘N <°×1FÑ1FÓGˆŒ	Ø+5Ð+=œ"Ÿ+™+›-ˆ�Ä7È:ÑCVÓCXˆ�r1   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S ry   )r  r   r  )rR   Úhidden_states     r2   rb   zDeimv2ConvNormLayer.forwardŸ  s2   € Ø—y‘y Ó.ˆØ—y‘y Ó.ˆØ—‘ |Ó4ˆØÐr1   )r   NN)	r(   r)   r*   r   r‹   r¦   rL   rb   rg   rh   s   @r2   r	  r	  †  sw   ø„ ð Ø"Ø!%ñYàðYð ðYð ð	Yð
 ðYð ðYð ðYð �t‘ðYð ˜$‘JõYö0r1   r	  c                   ó6   ‡ — e Zd ZdZdededefˆ fd„Zd„ Zˆ xZS )ÚDeimv2RepVggBlockzk
    RepVGG architecture block introduced by the work "RepVGG: Making VGG-style ConvNets Great Again".
    rk   r
  r  c                 óò   •— t         ‰| �  «        |j                  }|}t        |||ddd¬«      | _        t        |||ddd¬«      | _        |€t        j                  «       | _	        y t        |   «       | _	        y )Nr   r   )r  r   )
rK   rL   Úactivation_functionr	  Úconv1Úconv2rM   r  r   r  )rR   rk   r
  r  r  Úhidden_channelsrT   s         €r2   rL   zDeimv2RepVggBlock.__init__«  sp   ø€ Ü‰ÑÔà×/Ñ/ˆ
Ø%ˆÜ(¨°À,ÐPQÐSTÐ^_Ô`ˆŒ
Ü(¨°À,ÐPQÐSTÐ^_Ô`ˆŒ
Ø+5Ð+=œ"Ÿ+™+›-ˆ�Ä7È:ÑCVÓCXˆ�r1   c                 ój   — | j                  |«      | j                  |«      z   }| j                  |«      S ry   )r  r  r  )rR   rz   Úys      r2   rb   zDeimv2RepVggBlock.forward´  s+   € Ø�J‰J�q‹M˜DŸJ™J q›MÑ)ˆØ�‰˜qÓ!Ð!r1   )	r(   r)   r*   r+   r   r‹   rL   rb   rg   rh   s   @r2   r  r  ¦  s+   ø„ ñðY˜|ð Y¸#ð YÈSõ Yö"r1   r  c                   ót   ‡ — e Zd ZdZ	 ddededededef
ˆ fd„Zdej                  d	ej                  fd
„Z
ˆ xZS )ÚDeimv2CSPRepLayera  
    Cross Stage Partial (CSP) network layer with RepVGG blocks.
    Differs from DFineCSPRepLayer: uses a single conv that splits into residual + processing path
    (instead of two separate convs), and has an optional trailing conv controlled by `encoder_has_trailing_conv`.
    rk   r
  r  Ú
num_blocksÚ	expansionc           
      ó‚  •— t         ‰	| �  «        |j                  }t        ||z  «      }t	        |||dz  dd|¬«      | _        t        j                  t        |«      D �cg c]  }t        |||«      ‘Œ c}«      | _
        |j                  rt	        |||dd|¬«      | _        y t        j                  «       | _        y c c}w )NrV   r   ©r  r   )rK   rL   r  r‹   r	  r  rM   r™   ró   r  ÚbottlenecksÚencoder_has_trailing_convr  r  )
rR   rk   r
  r  r$  r%  r  r  rÐ   rT   s
            €r2   rL   zDeimv2CSPRepLayer.__init__À  s·   ø€ ô 	‰ÑÔØ×/Ñ/ˆ
Ü˜l¨YÑ6Ó7ˆÜ(¨°¸oÐPQÑ>QÐSTÐVWÐdnÔoˆŒ
ÜŸ=™=ÜRWÐXbÓRcÖdÈQÔ˜v ¸ÕHÒdó
ˆÔð
 ×/Ò/ô   ¨¸ÀqÈ!ÐXbÔcð 	�
ô —‘“ð 	�
ùò es   ÁB<r%   rI   c                 ó¦   — | j                  |«      j                  dd¬«      \  }}| j                  D ]
  } ||«      }Œ | j                  ||z   «      S ©NrV   r   r‚   )r  r†   r(  r  )rR   r%   ÚresidualÚ
bottlenecks       r2   rb   zDeimv2CSPRepLayer.forwardÐ  sX   € Ø"&§*¡*¨]Ó";×"AÑ"AÀ!ÈÐ"AÓ"KÑˆ�-Ø×*Ñ*ò 	6ˆJÙ& }Ó5‰Mð	6à�z‰z˜( ]Ñ2Ó3Ð3r1   )ç      ð?)r(   r)   r*   r+   r   r‹   rf   rL   r,   r   rb   rg   rh   s   @r2   r#  r#  ¹  sW   ø„ ñð nqñ
Ø"ð
Ø14ð
ØDGð
ØUXð
Øejõ
ð 4 U§\¡\ð 4°e·l±l÷ 4r1   r#  c                   óf   ‡ — e Zd ZdZddedefˆ fd„Zdej                  dej                  fd„Z	ˆ xZ
S )	ÚDeimv2RepNCSPELAN5a]  
    Rep(VGG) N(etwork) CSP (Cross Stage Partial) ELAN (Efficient Layer Aggregation Network) block.
    Similar to DFineRepNCSPELAN4 but without intermediate convolutions between CSP branches,
    resulting in a simpler 4-way concatenation (2 split halves + 2 CSP branches) instead of D-FINE's
    4-branch design with interleaved convolutions.
    rk   Únumb_blocksc                 óŒ  •— t         ‰| �  «        |j                  }|j                  }|j                  }|j                  dz  }t	        |j
                  |j                  z  dz  «      }t        |||dd|¬«      | _        t        ||dz  ||¬«      | _	        t        ||||¬«      | _
        t        ||d|z  z   |dd|¬«      | _        y )NrV   r   r'  )r$  )rK   rL   r  Úencoder_hidden_dimÚroundÚhidden_expansionr	  r  r#  Úcsp_rep1Úcsp_rep2r  )	rR   rk   r1  r  r
  r  Úsplit_channelsÚcsp_channelsrT   s	           €r2   rL   zDeimv2RepNCSPELAN5.__init__ß  sÇ   ø€ Ü‰ÑÔØ×/Ñ/ˆ
Ø×/Ñ/ˆØ×0Ñ0ˆØ×2Ñ2°QÑ6ˆÜ˜V×4Ñ4°v×7PÑ7PÑPÐTUÑUÓVˆÜ(¨°¸nÈaÐQRÐ_iÔjˆŒ
Ü)¨&°.ÀAÑ2EÀ|Ð`kÔlˆŒÜ)¨&°,ÀÐYdÔeˆŒÜ(Ø�N a¨,Ñ&6Ñ7¸ÀqÈ!ÐXbô
ˆ�
r1   r%   rI   c                 óè   — | j                  |«      j                  dd¬«      \  }}| j                  |«      }| j                  |«      }t	        j
                  ||||gd¬«      }| j                  |«      S r+  )r  r†   r6  r7  r,   r„   r  )rR   r%   Úhidden_states_1Úhidden_states_2Úhidden_states_3Úhidden_states_4Úmerged_hidden_statess          r2   rb   zDeimv2RepNCSPELAN5.forwardí  sn   € Ø+/¯:©:°mÓ+D×+JÑ+JÈ1ÐRSÐ+JÓ+TÑ(ˆ˜ØŸ-™-¨Ó8ˆØŸ-™-¨Ó8ˆÜ$Ÿy™y¨/¸?ÈOÐ]lÐ)mÐstÔuÐØ�z‰zÐ.Ó/Ð/r1   )r   )r(   r)   r*   r+   r   r‹   rL   r,   r   rb   rg   rh   s   @r2   r0  r0  ×  s6   ø„ ññ
˜|ð 
¸#õ 
ð0 U§\¡\ð 0°e·l±l÷ 0r1   r0  c                   ód   ‡ — e Zd Zdededefˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )ÚDeimv2SCDownrk   r  r  c                 óØ   •— t         ‰| �  «        t        ||j                  |j                  dd«      | _        t        ||j                  |j                  |||j                  «      | _        y r¡   )rK   rL   r	  r3  r  r  )rR   rk   r  r  rT   s       €r2   rL   zDeimv2SCDown.__init__ö  s`   ø€ Ü‰ÑÔÜ(¨°×1JÑ1JÈF×LeÑLeÐghÐjkÓlˆŒ
Ü(ØØ×%Ñ%Ø×%Ñ%ØØØ×%Ñ%ó
ˆ�
r1   Úinput_featuresrI   c                 óJ   — | j                  |«      }| j                  |«      }|S ry   )r  r  )rR   rC  s     r2   rb   zDeimv2SCDown.forward  s$   € ØŸ™ NÓ3ˆØŸ™ NÓ3ˆØÐr1   )
r(   r)   r*   r   r‹   rL   r,   r   rb   rg   rh   s   @r2   rA  rA  õ  s8   ø„ ð

˜|ð 

¸#ð 

Àsõ 

ð e§l¡lð °u·|±|÷ r1   rA  ÚmoduleÚqueryÚkeyrù   ÚscalingÚdropoutrú   c                 óœ  — |€|j                  d«      dz  }t        j                  ||j                  dd«      «      |z  }|�||z   }t        j
                  j                  |d¬«      }t        j
                  j                  ||| j                  ¬«      }t        j                  ||«      }	|	j                  dd«      j                  «       }	|	|fS )NrW   ç      à¿rV   r   r‚   ©ÚpÚtrainingr   )
Úsizer,   ÚmatmulrÈ   rM   r¿   rþ   rI  rN  rÍ   )
rE  rF  rG  r§   rù   rH  rI  rú   Úattn_weightsÚattn_outputs
             r2   Úeager_attention_forwardrS    s»   € ð €Ø—*‘*˜R“. DÑ(ˆô —<‘<  s§}¡}°Q¸Ó':Ó;¸gÑE€LàÐ!Ø# nÑ4ˆä—=‘=×(Ñ(¨¸2Ð(Ó>€LÜ—=‘=×(Ñ(¨¸È6Ï?É?Ð(Ó[€Lä—,‘,˜|¨UÓ3€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€Kà˜Ð$Ð$r1   c                   óà   ‡ — e Zd ZdZ	 	 ddededededef
ˆ fd„Z	 	 dd	e	j                  d
e	j                  dz  de	j                  dz  dee   dee	j                  e	j                  f   f
d„Zˆ xZS )ÚDeimv2SelfAttentionz¸
    Multi-headed self-attention from 'Attention Is All You Need' paper.

    In DEIMV2, position embeddings are added to both queries and keys (but not values) in self-attention.
    rk   rS   Únum_attention_headsrI  rn   c                 óp  •— t         ‰| �  «        || _        ||z  | _        | j                  dz  | _        || _        d| _        t        j                  |||¬«      | _	        t        j                  |||¬«      | _
        t        j                  |||¬«      | _        t        j                  |||¬«      | _        y )NrK  Frm   )rK   rL   rk   Úhead_dimrH  Úattention_dropoutÚ	is_causalrM   rp   Úk_projÚv_projÚq_projÚo_proj)rR   rk   rS   rV  rI  rn   rT   s         €r2   rL   zDeimv2SelfAttention.__init__+  s“   ø€ ô 	‰ÑÔØˆŒØ#Ð':Ñ:ˆŒØ—}‘} dÑ*ˆŒØ!(ˆÔØˆŒä—i‘i ¨[¸tÔDˆŒÜ—i‘i ¨[¸tÔDˆŒÜ—i‘i ¨[¸tÔDˆŒÜ—i‘i ¨[¸tÔDˆ�r1   Nr%   rù   Úposition_embeddingsrú   rI   c                 ó¬  — |j                   dd }g |¢d‘| j                  ‘­}|�||z   n|}| j                  |«      j                  |«      j	                  dd«      }| j                  |«      j                  |«      j	                  dd«      }	| j                  |«      j                  |«      j	                  dd«      }
t        j                  | j                  j                  t        «      } || ||	|
|f| j                  sdn| j                  | j                  dœ|¤Ž\  }} |j                  g |¢d‘­Ž j!                  «       }| j#                  |«      }||fS )zZ
        Position embeddings are added to both queries and keys (but not values).
        NrW   r   rV   ç        )rI  rH  )rd   rX  r]  rÌ   rÈ   r[  r\  r   Úget_interfacerk   Ú_attn_implementationrS  rN  rY  rH  r¾   rÍ   r^  )rR   r%   rù   r_  rú   Úinput_shapeÚhidden_shapeÚquery_key_inputÚquery_statesÚ
key_statesÚvalue_statesÚattention_interfacerR  rQ  s                 r2   rb   zDeimv2SelfAttention.forward?  s_  € ð $×)Ñ)¨#¨2Ð.ˆØ8˜Ð8 bÐ8¨$¯-©-Ñ8ˆàATÐA`˜-Ð*=Ò=Ðfsˆà—{‘{ ?Ó3×8Ñ8¸ÓF×PÑPÐQRÐTUÓVˆØ—[‘[ Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆ
Ø—{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð	%
ð  $Ÿ}š}‘C°$×2HÑ2HØ—L‘Lñ	%
ð ñ	%
Ñ!ˆ�\ð *�k×)Ñ)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—k‘k +Ó.ˆØ˜LÐ(Ð(r1   )ra  T)NN)r(   r)   r*   r+   r   r‹   rf   ÚboolrL   r,   r   r   r   r/   rb   rg   rh   s   @r2   rU  rU  $  s¶   ø„ ñð ØñEàðEð ðEð !ð	Eð
 ðEð õEð. /3Ø37ñ	$)à—|‘|ð$)ð Ÿ™ tÑ+ð$)ð #Ÿ\™\¨DÑ0ð	$)ð
 Ð+Ñ,ð$)ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷$)r1   rU  c                   ó    ‡ — e Zd Zdefˆ fd„Z	 d
dej                  dej                  dej                  dz  dee   dej                  f
d	„Z	ˆ xZ
S )ÚDeimv2EncoderLayerrk   c                 ó$  •— t         ‰| �  «        |j                  | _        |j                  | _        t        || j                  |j                  |j                  ¬«      | _        t        j                  | j                  |j                  ¬«      | _        |j                  | _        t        | j                  |j                  | j                  d|j                  «      | _        t        j                  | j                  |j                  ¬«      | _        y )N©rk   rS   rV  rI  ©rH   rV   )rK   rL   Únormalize_beforer3  rS   rU  rV  rI  Ú	self_attnrM   Ú	LayerNormÚlayer_norm_epsÚself_attn_layer_normr�   Úencoder_ffn_dimÚencoder_activation_functionÚmlpÚfinal_layer_norm©rR   rk   rT   s     €r2   rL   zDeimv2EncoderLayer.__init__g  sÐ   ø€ Ü‰ÑÔØ &× 7Ñ 7ˆÔØ!×4Ñ4ˆÔô -ØØ×(Ñ(Ø &× :Ñ :Ø—N‘Nô	
ˆŒô %'§L¡L°×1AÑ1AÀv×G\ÑG\Ô$]ˆÔ!Ø—~‘~ˆŒÜØ×Ñ˜f×4Ñ4°d×6FÑ6FÈÈ6×KmÑKmó
ˆŒô !#§¡¨T×-=Ñ-=À6×CXÑCXÔ YˆÕr1   Nr%   rù   Úspatial_position_embeddingsrú   rI   c                 ó²  — |}| j                   r| j                  |«      } | j                  d|||dœ|¤Ž\  }}t        j                  j                  || j
                  | j                  ¬«      }||z   }| j                   s| j                  |«      }| j                   r| j                  |«      }|}| j                  |«      }||z   }| j                   s| j                  |«      }| j                  rht        j                  |«      j                  «       sEt        j                  |j                  «      j                  dz
  }t        j                  || |¬«      }|S )a[  
        Args:
            hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, hidden_size)`
            attention_mask (`torch.FloatTensor`): attention mask of size
                `(batch, 1, target_len, source_len)` where padding elements are indicated by very large negative
                values.
            spatial_position_embeddings (`torch.FloatTensor`, *optional*):
                Spatial position embeddings (2D positional encodings of image locations), to be added to both
                the queries and keys in self-attention (but not to values).
        ©r%   rù   r_  rL  iè  ©ÚminÚmaxr0   )rq  ru  rr  rM   r¿   rI  rN  ry  rx  r,   ÚisfiniteÚallÚfinforZ   r€  rÃ   )rR   r%   rù   r{  rú   r,  rÐ   Úclamp_values           r2   rb   zDeimv2EncoderLayer.forwardz  s?  € ð" !ˆØ× Ò Ø ×5Ñ5°mÓDˆMà)˜4Ÿ>™>ð 
Ø'Ø)Ø ;ñ
ð ñ	
Ñˆ�qô Ÿ™×-Ñ-¨m¸t¿|¹|ÐVZ×VcÑVcÐ-ÓdˆØ  =Ñ0ˆØ×$Ò$Ø ×5Ñ5°mÓDˆMà× Ò Ø ×1Ñ1°-Ó@ˆMØ ˆàŸ™ Ó/ˆà  =Ñ0ˆØ×$Ò$Ø ×1Ñ1°-Ó@ˆMà�=Š=Ü—>‘> -Ó0×4Ñ4Ô6Ü#Ÿk™k¨-×*=Ñ*=Ó>×BÑBÀTÑI�Ü %§¡¨MÀ¸|ÐQ\Ô ]�àÐr1   ry   )r(   r)   r*   r   rL   r,   r   r   r   rb   rg   rh   s   @r2   rm  rm  f  sg   ø„ ðZ˜|õ Zð. <@ñ	0à—|‘|ð0ð Ÿ™ð0ð &+§\¡\°DÑ%8ð	0ð
 Ð+Ñ,ð0ð 
�‰÷0r1   rm  é   g     ˆÃ@FrÕ   rÖ   Ú	embed_dimÚtemperatureÚ	cls_tokenr·   rZ   c                 ó,  — |dz  dk7  rt        d|› �«      ‚|dz  }t        j                  |t        j                  |¬«      |z  }d||z  z  }t        j                  | t        j                  |¬«      }	t        j                  |t        j                  |¬«      }
t        j                  |	|
d¬«      \  }	}
|	j                  «       j                  |«      }|
j                  «       j                  |«      }t        j                  |j                  «       |j                  «       |j                  «       |j                  «       gd¬	«      }|r>t        j                  t        j                  d|t        j                  |¬«      |gd¬	«      }|j                  |«      S )
a»  2D sinusoidal position embeddings for an image patch grid.

    Each (h, w) position gets an ``embed_dim``-dimensional vector laid out as
    ``[sin_h | cos_h | sin_w | cos_w]``, with row-major (H-outer) patch ordering.

    Args:
        height: Grid height in patches.
        width: Grid width in patches.
        embed_dim: Total embedding dimension; must be divisible by 4.
        temperature: Base for the frequency decay.
        cls_token: If `True`, prepend a zero row for a CLS token.
        device: Target device; defaults to CPU.
        dtype: Output dtype; frequency arithmetic uses float64 internally.

    Returns:
        Tensor of shape ``(height * width [+1], embed_dim)``.
    r¯   r   z(`embed_dim` must be divisible by 4, got ©rZ   r·   r.  Úij©Úindexingr   r‚   )r   r,   rÅ   Úfloat64Úmeshgridr¼   Úouterr„   ÚsinÚcosr²   r[   )rÕ   rÖ   r†  r‡  rˆ  r·   rZ   Úpos_dimÚomegaÚgrid_hÚgrid_wÚemb_hÚemb_wÚ	pos_embeds                 r2   Ú&build_2d_sinusoidal_position_embeddingrš  ­  s5  € ð4 �1�}˜ÒÜÐCÀIÀ;ÐOÓPÐPà˜1‰n€GÜ�L‰L˜¬¯©¸fÔEÈÑO€EØ�+˜uÑ$Ñ$€Eä�\‰\˜&¬¯©¸fÔE€FÜ�\‰\˜%¤u§}¡}¸VÔD€FÜ—^‘^ F¨F¸TÔB�N€FˆFà�N‰NÓ×"Ñ" 5Ó)€EØ�N‰NÓ×"Ñ" 5Ó)€Eä—	‘	˜5Ÿ9™9›;¨¯	©	«°U·Y±Y³[À%Ç)Á)Ã+ÐNÐTUÔV€IáÜ—I‘IœuŸ{™{¨1¨i¼u¿}¹}ÐU[Ô\Ð^gÐhÐnoÔpˆ	à�<‰<˜ÓÐr1   c            
       óÎ   ‡ — e Zd ZdZddedefˆ fd„Ze ed¬«      dej                  fd„«       «       Z
d	ed
edej                  ez  dej                  dej                  f
d„Zˆ xZS )ÚDeimv2SinePositionEmbeddingzJ
    2D sinusoidal position embedding used in RT-DETR hybrid encoder.
    r†  r‡  c                 ó>   •— t         ‰| �  «        || _        || _        y ry   )rK   rL   r†  r‡  )rR   r†  r‡  rT   s      €r2   rL   z$Deimv2SinePositionEmbedding.__init__â  s   ø€ Ü‰ÑÔØ"ˆŒØ&ˆÕr1   é    ©ÚmaxsizerI   c                  ó   — t        | i |¤ŽS ry   )rš  )Úargsrú   s     r2   Ú._cached_build_2d_sinusoidal_position_embeddingzJDeimv2SinePositionEmbedding._cached_build_2d_sinusoidal_position_embeddingç  s   € ô 6°tÐF¸vÑFÐFr1   rÖ   rÕ   r·   rZ   c                 óš   — | j                  t        |«      t        |«      | j                  | j                  ||¬«      j	                  d«      S )z•
        Generate 2D sinusoidal position embeddings.

        Returns:
            Position embeddings of shape (1, height*width, embed_dim)
        )rÕ   rÖ   r†  r‡  r·   rZ   r   )r£  r   r†  r‡  rÆ   )rR   rÖ   rÕ   r·   rZ   s        r2   rb   z#Deimv2SinePositionEmbedding.forwardì  sN   € ð ×BÑBÜ˜VÓ$Ü˜EÓ"Ø—n‘nØ×(Ñ(ØØð Có 
÷ ‰)�A‹,ð	r1   )r…  i'  )r(   r)   r*   r+   r‹   rL   Ústaticmethodr   r,   r   r£  r·   r¦   rZ   rb   rg   rh   s   @r2   rœ  rœ  Ý  s�   ø„ ññ' #ð '¸#õ 'ð
 Ù(°Ô4ðGÈ5Ï<É<ò Gó 5ó ðGðàðð ðð —‘˜sÑ"ð	ð
 �{‰{ðð 
�‰÷r1   rœ  c                   ój   ‡ — e Zd ZdZdefˆ fd„Zdej                  dee	   dej                  fd„Z
ˆ xZS )ÚDeimv2AIFILayerzf
    AIFI (Attention-based Intra-scale Feature Interaction) layer used in RT-DETR hybrid encoder.
    rk   c                 óR  •— t         ‰| �  «        || _        |j                  | _        |j                  | _        t        | j                  |j                  ¬«      | _        t        j                  t        |j                  «      D �cg c]  }t        |«      ‘Œ c}«      | _        y c c}w )N)r†  r‡  )rK   rL   rk   r3  Ú	eval_sizerœ  Úpositional_encoding_temperatureÚposition_embeddingrM   r™   ró   Úencoder_layersrm  r›   ©rR   rk   rÐ   rT   s      €r2   rL   zDeimv2AIFILayer.__init__  s€   ø€ Ü‰ÑÔØˆŒØ"(×";Ñ";ˆÔØ×)Ñ)ˆŒä"=Ø×-Ñ-Ø×>Ñ>ô#
ˆÔô —m‘mÌÈv×OdÑOdÓIeÖ$fÀAÔ%7¸Õ%?Ò$fÓgˆ�ùÒ$fs   ÂB$r%   rú   rI   c                 óÄ  — |j                   d   }|j                   dd \  }}|j                  d«      j                  dd«      }| j                  s| j                  €*| j                  |||j                  |j                  ¬«      }nd}| j                  D ]  } ||fd|dœ|¤Ž}Œ |j                  dd«      j                  || j                  ||«      j                  «       }|S )z¡
        Args:
            hidden_states (`torch.FloatTensor` of shape `(batch_size, channels, height, width)`):
                Feature map to process.
        r   rV   Nr   )rÖ   rÕ   r·   rZ   )rù   r{  )rd   r¼   rÈ   rN  r©  r«  r·   rZ   r›   r¾   r3  rÍ   )rR   r%   rú   rÏ   rÕ   rÖ   r™  r¤   s           r2   rb   zDeimv2AIFILayer.forward  s  € ð #×(Ñ(¨Ñ+ˆ
Ø%×+Ñ+¨A¨BÐ/‰ˆ�à%×-Ñ-¨aÓ0×:Ñ:¸1¸aÓ@ˆà�=Š=˜DŸN™NÐ2Ø×/Ñ/ØØØ$×+Ñ+Ø#×)Ñ)ð	 0ó ‰Ið ˆIà—[‘[ò 	ˆEÙ!Øðà#Ø,5ñð ñ	‰Mð	ð ×#Ñ# A qÓ)×1Ñ1°*¸d×>UÑ>UÐW]Ð_dÓe×pÑpÓrð 	ð Ðr1   )r(   r)   r*   r+   r   rL   r,   r   r   r   rb   rg   rh   s   @r2   r§  r§    sE   ø„ ñð
h˜|õ 
hð%à—|‘|ð%ð Ð+Ñ,ð%ð 
�‰÷	%r1   r§  c                   ó�   ‡ — e Zd Zdefˆ fd„Zdej                  deej                  ej                  ej                  f   fd„Zˆ xZ	S )ÚDeimv2SpatialTuningAdapterrk   c                 óh  •— t         ‰| �  «        |j                  }t        |d|ddd¬«      | _        t        j                  ddd¬«      | _        t        ||d|z  dd«      | _        t        |d|z  d|z  dd«      | _	        t        |d|z  d|z  dd«      | _
        t        j                  «       | _        y )Nr   rV   Úgelur'  r   ©r  r  r  r¯   )rK   rL   Úspatial_tuning_adapter_inplanesr	  Ú	stem_convrM   Ú	MaxPool2dÚ	stem_poolr  Úconv3Úconv4ÚGELUrv   )rR   rk   ÚinplanesrT   s      €r2   rL   z#Deimv2SpatialTuningAdapter.__init__=  s£   ø€ Ü‰ÑÔØ×9Ñ9ˆÜ,¨V°Q¸À!ÀQÐSYÔZˆŒÜŸ™°!¸AÀqÔIˆŒÜ(¨°¸1¸x¹<ÈÈAÓNˆŒ
Ü(¨°°X±¸qÀ8¹|ÈQÐPQÓRˆŒ
Ü(¨°°X±¸qÀ8¹|ÈQÐPQÓRˆŒ
Ü—g‘g“iˆ�r1   Úpixel_valuesrI   c                 óî   — | j                  | j                  |«      «      }| j                  |«      }| j                  | j	                  |«      «      }| j                  | j	                  |«      «      }|||fS ry   )r·  rµ  r  r¸  rv   r¹  )rR   r¼  r;  r<  r=  r>  s         r2   rb   z"Deimv2SpatialTuningAdapter.forwardG  sb   € ØŸ.™.¨¯©¸Ó)EÓFˆØŸ*™* _Ó5ˆØŸ*™* T§[¡[°Ó%AÓBˆØŸ*™* T§[¡[°Ó%AÓBˆØ °Ð@Ð@r1   )
r(   r)   r*   r   rL   r,   r   r/   rb   rg   rh   s   @r2   r°  r°  <  sD   ø„ ð ˜|õ  ðA E§L¡Lð A°U¸5¿<¹<ÈÏÉÐW\×WcÑWcÐ;cÑ5d÷ Ar1   r°  c                   óx   ‡ — e Zd ZdZdefˆ fd„Zdej                  dej                  dej                  fd„Zˆ xZ	S )ÚDeimv2IntegralaÝ  
    A static layer that calculates integral results from a distribution.

    This layer computes the target location using the formula: `sum{Pr(n) * W(n)}`,
    where Pr(n) is the softmax probability vector representing the discrete
    distribution, and W(n) is the non-uniform Weighting Function.

    Args:
        max_num_bins (int): Max number of the discrete bins. Default is 32.
                       It can be adjusted based on the dataset or task requirements.
    rk   c                 óD   •— t         ‰| �  «        |j                  | _        y ry   )rK   rL   Úmax_num_binsrz  s     €r2   rL   zDeimv2Integral.__init__\  s   ø€ Ü‰ÑÔØ"×/Ñ/ˆÕr1   Úpred_cornersÚprojectrI   c                 ó2  — |j                   \  }}}t        j                  |j                  d| j                  dz   «      d¬«      }t        j
                  ||j                  |j                  «      «      j                  dd«      }|j                  ||d«      }|S )NrW   r   r‚   r¯   )rd   rý   rþ   r¾   rÁ  Úlinearr[   r·   )rR   rÂ  rÃ  rÏ   rÒ   rÐ   s         r2   rb   zDeimv2Integral.forward`  s…   € Ø%1×%7Ñ%7Ñ"ˆ
�K Ü—y‘y ×!5Ñ!5°b¸$×:KÑ:KÈaÑ:OÓ!PÐVWÔXˆÜ—x‘x ¨g¯j©j¸×9LÑ9LÓ.MÓN×VÑVÐWYÐ[\Ó]ˆØ#×+Ñ+¨J¸ÀRÓHˆØÐr1   )
r(   r)   r*   r+   r   rL   r,   r   rb   rg   rh   s   @r2   r¿  r¿  O  s:   ø„ ñ
ð0˜|õ 0ð E§L¡Lð ¸5¿<¹<ð ÈEÏLÉL÷ r1   r¿  c                   ót   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  dej                  fd„Zˆ xZS )Ú	Deimv2LQErk   c                 óÔ   •— t         ‰| �  «        |j                  | _        |j                  | _        t	        d| j                  dz   z  |j
                  d|j                  «      | _        y )Nr¯   r   )rK   rL   Útop_prob_valuesrÁ  r�   Úlqe_hidden_dimÚ
lqe_layersÚreg_confrz  s     €r2   rL   zDeimv2LQE.__init__i  sZ   ø€ Ü‰ÑÔØ%×5Ñ5ˆÔØ"×/Ñ/ˆÔÜ! ! t×';Ñ';¸aÑ'?Ñ"@À&×BWÑBWÐYZÐ\b×\mÑ\mÓnˆ�r1   ÚscoresrÂ  rI   c           	      ó|  — |j                  «       \  }}}t        j                  |j                  ||d| j                  dz   «      d¬«      }|j                  | j                  d¬«      \  }}t        j                  ||j                  dd¬«      gd¬«      }| j                  |j                  ||d«      «      }	||	z   }|S )Nr¯   r   rW   r‚   T)rƒ   rY   )rO  rý   rþ   r¾   rÁ  ÚtopkrÉ  r,   r„   r^   rÌ  )
rR   rÍ  rÂ  rÏ   ÚlengthrÐ   ÚprobÚ	prob_topkÚstatÚquality_scores
             r2   rb   zDeimv2LQE.forwardo  s®   € Ø ,× 1Ñ 1Ó 3Ñˆ
�F˜AÜ�y‰y˜×-Ñ-¨j¸&À!ÀT×EVÑEVÐYZÑEZÓ[ÐacÔdˆØ—y‘y ×!5Ñ!5¸2�yÓ>‰ˆ	�1Ü�y‰y˜) Y§^¡^¸ÀD ^Ó%IÐJÐPRÔSˆØŸ™ d§l¡l°:¸vÀrÓ&JÓKˆØ˜-Ñ'ˆØˆr1   )	r(   r)   r*   r   rL   r,   r   rb   rg   rh   s   @r2   rÇ  rÇ  h  s7   ø„ ðo˜|õ oð˜eŸl™lð ¸%¿,¹,ð È5Ï<É<÷ r1   rÇ  c                   ó$  ‡ — e Zd Zdefˆ fd„Z	 	 	 	 	 	 ddej                  dej                  dz  dej                  dz  dej                  dz  deee	e	f      dz  d	ej                  dz  d
ej                  dz  de
e   dej                  fd„Zˆ xZS )ÚDeimv2DecoderLayerrk   c                 óB  •— t         ‰| �  «        |j                  | _        t	        || j                  |j
                  |j                  ¬«      | _        |j                  | _        t        |j                  «      | _
        t        |¬«      | _        t        |«      | _        t        |j                  «      | _        |j                   rt#        |j                  «      nd | _        |j                   | _        |j                   rd | _        y t        |j                  «      | _        y )Nro  ©rk   )rK   rL   rq   rS   rU  ré   rY  rr  rI  rG   ru  rå   Úencoder_attnrj   rx  ry  Úuse_gatewayr|   ÚgatewayÚencoder_attn_layer_normrz  s     €r2   rL   zDeimv2DecoderLayer.__init__z  sÙ   ø€ Ü‰ÑÔØ!Ÿ>™>ˆÔô -ØØ×(Ñ(Ø &× >Ñ >Ø×,Ñ,ô	
ˆŒð —~‘~ˆŒÜ$1°&·.±.Ó$AˆÔ!Ü?ÀvÔNˆÔÜ" 6Ó*ˆŒÜ -¨f¯n©nÓ =ˆÔØ5;×5GÒ5G”z &§.¡.Ô1ÈTˆŒØ!×-Ñ-ˆÔØ/5×/AÒ/A tˆÕ$Ä}ÐU[×UcÑUcÓGdˆÕ$r1   Nr%   r_  r  r  r  r8   Úencoder_attention_maskrú   rI   c                 óD  — |}	 | j                   d|||dœ|¤Ž\  }}
t        j                  j                  || j                  | j                  ¬«      }|	|z   }| j                  |«      }|}	|€|n||z   }| j                  |||||¬«      \  }}
t        j                  j                  || j                  | j                  ¬«      }| j                  �| j                  |	|«      }n|	|z   }| j                  |«      }|}	| j                  |«      }|	|z   }| j                  |«      }|S )a#  
        Args:
            hidden_states (`torch.FloatTensor`):
                Input to the layer of shape `(batch, seq_len, hidden_size)`.
            object_queries_position_embeddings (`torch.FloatTensor`, *optional*):
                Position embeddings for the object query slots. These are added to both queries and keys
                in the self-attention layer (not values).
            reference_points (`torch.FloatTensor`, *optional*):
                Reference points.
            spatial_shapes (`torch.LongTensor`, *optional*):
                Spatial shapes.
            level_start_index (`torch.LongTensor`, *optional*):
                Level start index.
            encoder_hidden_states (`torch.FloatTensor`):
                cross attention input to the layer of shape `(batch, seq_len, hidden_size)`
            encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size
                `(batch, 1, target_len, source_len)` where padding elements are indicated by very large negative
                values.
        r}  rL  )r%   r8   r  r  r  r0   )rr  rM   r¿   rI  rN  ru  rÙ  rÛ  rÜ  rx  ry  )rR   r%   r_  r  r  r  r8   rÝ  rú   r,  rÐ   s              r2   rb   zDeimv2DecoderLayer.forwardŽ  sM  € ð< !ˆð *˜4Ÿ>™>ð 
Ø'Ø1Ø 3ñ
ð ñ	
Ñˆ�qô Ÿ™×-Ñ-¨m¸t¿|¹|ÐVZ×VcÑVcÐ-ÓdˆØ  =Ñ0ˆØ×1Ñ1°-Ó@ˆà ˆð *=Ð)D™È-ÐZmÑJmˆØ×,Ñ,Ø'Ø"7Ø-Ø)Ø 3ð -ó 
Ñˆ�qô Ÿ™×-Ñ-¨m¸t¿|¹|ÐVZ×VcÑVcÐ-Ódˆà�<‰<Ð#Ø ŸL™L¨°=ÓA‰Mà$ }Ñ4ˆMØ ×8Ñ8¸ÓGˆMð !ˆØŸ™ Ó/ˆØ  =Ñ0ˆØ×-Ñ-¨mÓ<ˆàÐr1   )NNNNNN)r(   r)   r*   r   rL   r,   r   rD   r/   r‹   r   r   rb   rg   rh   s   @r2   rÖ  rÖ  y  sÙ   ø„ ðe˜|õ eð. 48Ø04Ø.2Ø<@Ø59Ø6:ñEà—|‘|ðEð #Ÿ\™\¨DÑ0ðEð  Ÿ,™,¨Ñ-ð	Eð
 Ÿ™ tÑ+ðEð " %¨¨S¨¡/Ñ2°TÑ9ðEð  %Ÿ|™|¨dÑ2ðEð !&§¡¨tÑ 3ðEð Ð+Ñ,ðEð 
�‰÷Er1   rÖ  c                   óv   ‡ — e Zd ZU eed<   dZdZdZg d¢ZdZ	dZ
dZdZ ej                  «       ˆ fd„«       Zˆ xZS )ÚDeimv2PreTrainedModelrk   Údeimv2r¼  )Úimage)ÚDeimv2HybridEncoderÚDeimv2LiteEncoderrÖ  Tc           
      óÒ  •— t         ‰| �  |«       t        |t        t        f«      �r¬|j
                  �©|j
                  D ]š  }| j                  j                  xs d| j                  j                  dz   z  }t        t        j                  d|z
  |z  «       «      }t        j                  |j                  «       t        j                  |j                   |«       Œœ |j"                  �k|j"                  D ]\  }t        j                  |j$                  d   j                  d«       t        j                  |j$                  d   j                   d«       Œ^ t'        |d«      r4t        j                  |j(                  | j                  j(                  «       t'        |d«      r4t        j                  |j*                  | j                  j*                  «       t        |t,        «      �r˜t        j                  |j.                  j                  d«       t1        j2                  «       }t1        j4                  |j6                  t0        j8                  ¬«      j;                  |«      d	t        j<                  z  |j6                  z  z  }t1        j>                  |jA                  «       |jC                  «       gd«      }||jE                  «       jG                  dd
¬«      jH                  z  }|jK                  |j6                  dd«      jM                  dtO        |jP                  «      dg«      }t1        jR                  |jP                  D �cg c]  }t1        j4                  d|dz   «      ‘Œ c}«      jK                  ddd«      }	||	z  }t        jT                  |j.                  j                   |jW                  «       «       t        j                  |jX                  j                  d«       t        j                  |jX                  j                   d«       |jP                  D ��
cg c]  }t[        |«      D ]  }
d|z  ‘Œ	 Œ }}}
t        jT                  |j\                  t1        j^                  |t0        j`                  ¬«      «       t        |tb        «      r¬| j                  j                  xs d| j                  j                  dz   z  }t        t        j                  d|z
  |z  «       «      }t        j                  |jd                  j                  «       t        j                  |jd                  j                   |«       t        |tf        «      rst        t        j                  d«       «      }t        j                  |jh                  j                   |«       t        j                  |jh                  j                  d«       t        |tj        «      rnt        j                  |jl                  j$                  d   j                   d«       t        j                  |jl                  j$                  d   j                  d«       t'        |d«      r?| j                  jn                  r)t        j                  |jp                  j                  «       t'        |d«      rB| j                  jr                  dkD  r)t        j                  |jt                  j                  «       t        |tv        «      rút        j                  |jx                  j                  «       t        j                  |jx                  j                   d«       t        j                  |jz                  j                  «       t        j                  |jz                  j                   d«       t        j                  |j|                  j                  «       t        j                  |j|                  j                   d«       yyc c}w c c}
}w )zInitialize the weightsNr   rW   r   Ú	reg_scaleÚupra  rè   ç       @TrX   rV   r.  Úweight_embeddingÚdenoising_class_embed)?rK   Ú_init_weightsrò   ÚDeimv2ForObjectDetectionÚDeimv2DecoderÚclass_embedrk   Úinitializer_bias_prior_probÚ
num_labelsrf   ÚmathÚlogÚinitÚxavier_uniform_rP   Ú	constant_rn   Ú
bbox_embedr›   Úhasattrræ  rç  rå   rö   r,   Úget_default_dtyperÅ   rê   rÂ   r[   ÚpirÄ   r’  r‘  Úabsr€  Úvaluesr¾   ÚtilerÊ   r«   rË   Úcopy_r¼   rª   ró   rç   rÁ   r\   ÚDeimv2ModelÚenc_score_headr|   r~   rÇ  rÌ  Úlearn_initial_queryré  Únum_denoisingrê  rj   rr   rs   rt   )rR   rE  r¤   Ú
prior_probrn   Údefault_dtypeÚthetasÚ	grid_initrø   rH  rÐ   rç   rT   s               €r2   rë  z#Deimv2PreTrainedModel._init_weightsâ  sƒ  ø€ ô 	‰Ñ˜fÔ%ä�fÔ7¼ÐGÕHØ×!Ñ!Ð-Ø#×/Ñ/ò 5�EØ!%§¡×!HÑ!HÒ!lÈAÐQU×Q\ÑQ\×QgÑQgÐjkÑQkÑLl�JÜ ¤$§(¡(¨A°
©N¸jÑ+HÓ"IÐ!IÓJ�DÜ×(Ñ(¨¯©Ô6Ü—N‘N 5§:¡:¨tÕ4ð	5ð × Ñ Ð,Ø#×.Ñ.ò =�EÜ—N‘N 5§<¡<°Ñ#3×#:Ñ#:¸AÔ>Ü—N‘N 5§<¡<°Ñ#3×#8Ñ#8¸!Õ<ð=ô �v˜{Ô+Ü—‘˜v×/Ñ/°·±×1FÑ1FÔGä�v˜tÔ$Ü—‘˜vŸy™y¨$¯+©+¯.©.Ô9ä�fÔAÕBÜ�N‰N˜6×2Ñ2×9Ñ9¸3Ô?Ü!×3Ñ3Ó5ˆMÜ—\‘\ &§.¡.¼¿¹ÔD×GÑGÈÓVØ”d—g‘g‘ §¡Ñ.ñˆFô Ÿ™ V§Z¡Z£\°6·:±:³<Ð$@À"ÓEˆIØ! I§M¡M£O×$7Ñ$7¸ÀDÐ$7Ó$I×$PÑ$PÑPˆIØ!×)Ñ)¨&¯.©.¸!¸QÓ?×DÑDÀaÌÈV×McÑMcÓIdÐfgÐEhÓiˆIÜ—l‘lÀF×DZÑDZÖ#[¸q¤E§L¡L°°A¸±EÕ$:Ò#[Ó\×dÑdÐefÐhjÐlmÓnˆGØ˜Ñ ˆIÜ�J‰J�v×.Ñ.×3Ñ3°Y×5FÑ5FÓ5HÔIä�N‰N˜6×3Ñ3×:Ñ:¸CÔ@Ü�N‰N˜6×3Ñ3×8Ñ8¸#Ô>à/5×/EÑ/E×X¨!ÌuÐUVËxÒXÈ!  A£ÐX ÐXÐÑXÜ�J‰J�v×.Ñ.´·±Ð=MÔUZ×UbÑUbÔ0cÔdä�fœkÔ*ØŸ™×@Ñ@ÒdÀAÈÏÉ×I_ÑI_ÐbcÑIcÑDdˆJÜœ$Ÿ(™( A¨
¡N°jÑ#@ÓAÐAÓBˆDÜ× Ñ  ×!6Ñ!6×!=Ñ!=Ô>Ü�N‰N˜6×0Ñ0×5Ñ5°tÔ<ä�fœjÔ)Üœ$Ÿ(™( ?Ó3Ð3Ó4ˆDÜ�N‰N˜6Ÿ;™;×+Ñ+¨TÔ2Ü�N‰N˜6Ÿ;™;×-Ñ-¨qÔ1ä�fœiÔ(Ü�N‰N˜6Ÿ?™?×1Ñ1°"Ñ5×:Ñ:¸AÔ>Ü�N‰N˜6Ÿ?™?×1Ñ1°"Ñ5×<Ñ<¸aÔ@ä�6Ð-Ô.°4·;±;×3RÒ3RÜ× Ñ  ×!8Ñ!8×!?Ñ!?Ô@Ü�6Ð2Ô3¸¿¹×8QÑ8QÐTUÒ8UÜ× Ñ  ×!=Ñ!=×!DÑ!DÔEä�fœoÔ.Ü× Ñ  ×!1Ñ!1×!8Ñ!8Ô9Ü�N‰N˜6×+Ñ+×0Ñ0°!Ô4Ü× Ñ  §¡×!6Ñ!6Ô7Ü�N‰N˜6Ÿ>™>×.Ñ.°Ô2Ü× Ñ  ×!1Ñ!1×!8Ñ!8Ô9Ü�N‰N˜6×+Ñ+×0Ñ0°!Õ4ð /ùò= $\ùó  Ys   Í _Ð_#)r(   r)   r*   r   r.   Úbase_model_prefixÚmain_input_nameÚinput_modalitiesÚ_no_split_modulesÚ_supports_sdpaÚ_supports_flash_attnÚ_supports_attention_backendÚ_supports_flex_attnr,   Úno_gradrë  rg   rh   s   @r2   rà  rà  Ö  sS   ø… àÓØ ÐØ$€OØ!ÐÚ]ÐØ€NØÐØ"&ÐØÐà€U‡]�]ƒ_óD5ó ôD5r1   rà  c                   ó2   ‡ — e Zd ZdZˆ fd„Zˆ fd„Zd„ Zˆ xZS )ÚDeimv2FrozenBatchNorm2dzú
    BatchNorm2d where the batch statistics and the affine parameters are fixed.

    Copy-paste from torchvision.misc.ops with added eps before rqsrt, without which any other models than
    torchvision.models.resnet[18,34,50,101] produce nans.
    c                 óJ  •— t         ‰| �  «        | j                  dt        j                  |«      «       | j                  dt        j
                  |«      «       | j                  dt        j
                  |«      «       | j                  dt        j                  |«      «       y )NrP   rn   Úrunning_meanÚrunning_var)rK   rL   rô   r,   rO   r²   )rR   rø   rT   s     €r2   rL   z Deimv2FrozenBatchNorm2d.__init__2  sn   ø€ Ü‰ÑÔØ×Ñ˜X¤u§z¡z°!£}Ô5Ø×Ñ˜V¤U§[¡[°£^Ô4Ø×Ñ˜^¬U¯[©[¸«^Ô<Ø×Ñ˜]¬E¯J©J°q«MÕ:r1   c           	      óH   •— |dz   }||v r||= t         ‰	| �  |||||||«       y )NÚnum_batches_tracked)rK   Ú_load_from_state_dict)
rR   Ú
state_dictÚprefixÚlocal_metadataÚstrictÚmissing_keysÚunexpected_keysÚ
error_msgsÚnum_batches_tracked_keyrT   s
            €r2   r  z-Deimv2FrozenBatchNorm2d._load_from_state_dict9  s?   ø€ ð #)Ð+@Ñ"@ÐØ" jÑ0ØÐ2Ð3ä‰Ñ%Ø˜ °¸ÀoÐWaõ	
r1   c                 óB  — | j                   j                  dddd«      }| j                  j                  dddd«      }| j                  j                  dddd«      }| j                  j                  dddd«      }d}|||z   j                  «       z  }|||z  z
  }||z  |z   S )Nr   rW   çñhãˆµøä>)rP   r¾   rn   r  r  r_   )rR   rz   rP   rn   r  r  ÚepsilonÚscales           r2   rb   zDeimv2FrozenBatchNorm2d.forwardD  s«   € ð —‘×$Ñ$ Q¨¨A¨qÓ1ˆØ�y‰y× Ñ   B¨¨1Ó-ˆØ×&Ñ&×.Ñ.¨q°"°a¸Ó;ˆØ×(Ñ(×0Ñ0°°B¸¸1Ó=ˆØˆØ˜+¨Ñ/×6Ñ6Ó8Ñ8ˆØ�l UÑ*Ñ*ˆØ�5‰y˜4ÑÐr1   )r(   r)   r*   r+   rL   r  rb   rg   rh   s   @r2   r  r  *  s   ø„ ñô;ô	
ö
 r1   r  c                 ó˜  — | j                  «       D �]6  \  }}t        |t        j                  «      rät	        |j
                  «      }|j                  j                  t        j                  d«      k7  r”|j                  j                  |j                  «       |j                  j                  |j                  «       |j                  j                  |j                  «       |j                  j                  |j                  «       || j                  |<   t        t        |j!                  «       «      «      dkD  s�Œ,t#        |«       �Œ9 y)zœ
    Recursively replace all `torch.nn.BatchNorm2d` with `Deimv2FrozenBatchNorm2d`.

    Args:
        model (torch.nn.Module):
            input model
    Úmetar   N)Únamed_childrenrò   rM   r  r  Únum_featuresrP   r·   r,   rý  rn   r  r  Ú_modulesÚlenrD   ÚchildrenÚreplace_batch_norm)ÚmodelÚnamerE  Ú
new_modules       r2   r*  r*  Q  sê   € ð ×,Ñ,Ó.ó '‰ˆˆfÜ�fœbŸn™nÔ-Ü0°×1DÑ1DÓEˆJà�}‰}×#Ñ#¤u§|¡|°FÓ';Ò;Ø×!Ñ!×'Ñ'¨¯©Ô6Ø—‘×%Ñ% f§k¡kÔ2Ø×'Ñ'×-Ñ-¨f×.AÑ.AÔBØ×&Ñ&×,Ñ,¨V×-?Ñ-?Ô@à#-ˆE�N‰N˜4Ñ äŒt�F—O‘OÓ%Ó&Ó'¨!Ô+Ü˜vÖ&ñ'r1   c                   óf   ‡ — e Zd Zˆ fd„Zdej
                  dee   deej
                     fd„Z	ˆ xZ
S )ÚDeimv2ConvEncoderc                 ó   •— t         ‰| �  |«       t        |«      }|j                  r(t	        j
                  «       5  t        |«       d d d «       || _        | j                  j                  | _	        t        j                  | j                  D �cg c]>  }|j                  dk7  rt        |||j                  dd«      nt        j                  «       ‘Œ@ c}«      | _        | j#                  «        y # 1 sw Y   Œ¨xY wc c}w )NÚliter   )rK   rL   r	   Úfreeze_backbone_batch_normsr,   r  r*  r+  ÚchannelsÚintermediate_channel_sizesrM   r™   Úencoder_typer	  r3  r  Úencoder_input_projÚ	post_init)rR   rk   ÚbackboneÚ
in_channelrT   s       €r2   rL   zDeimv2ConvEncoder.__init__k  sÖ   ø€ Ü‰Ñ˜Ô ä  Ó(ˆà×-Ò-ä—‘“ñ -Ü" 8Ô,÷-àˆŒ
Ø*.¯*©*×*=Ñ*=ˆÔ'Ü"$§-¡-ð
 #'×"AÑ"Aö	ð ð ×&Ñ&¨&Ò0ô $ F¨J¸×8QÑ8QÐSTÐVWÔXä—[‘[“]ñ#òó#
ˆÔð 	�‰Õ÷-ð -üò
s   ¼C/ÂAC;Ã/C8r¼  rú   rI   c                 ó¦   —  | j                   |fi |¤Žj                  }t        | j                  |«      D ��cg c]  \  }} ||«      ‘Œ c}}S c c}}w ry   )r+  rC   rš   r6  )rR   r¼  rú   ÚfeaturesÚprojÚfeats         r2   rb   zDeimv2ConvEncoder.forward�  sF   € Ø�4—:‘:˜lÑ5¨fÑ5×BÑBˆÜ-0°×1HÑ1HÈ(Ó-S×T™z˜t T‘�T•
ÓTÐTùÓTs   ·A)r(   r)   r*   rL   r,   r   r   r   rD   rb   rg   rh   s   @r2   r/  r/  j  s=   ø„ ôð,U E§L¡Lð U¸FÐCUÑ<Vð UÐ[_Ð`e×`lÑ`lÑ[m÷ Ur1   r/  c                   ól   ‡ — e Zd Zdefˆ fd„Zdej                  dee   de	ej                     fd„Z
ˆ xZS )ÚDeimv2DINOv3ConvEncoderrk   c                 óŒ  •— t         ‰| �  |«       t        |«      | _        t	        |«      | _        |j                  j                  }|j                  }|j                  }t        j                  t        |||dz  z   |dd«      t        |||dz  z   |dd«      t        |||dz  z   |dd«      g«      | _        | j                  «        y )NrV   r   r¯   )rK   rL   r	   r8  r°  Úspatial_tuning_adapterÚbackbone_configrS   r3  r´  rM   r™   r	  Úfusion_projr7  )rR   rk   r†  r�   Úspatial_tuning_adapter_channelsrT   s        €r2   rL   z Deimv2DINOv3ConvEncoder.__init__‡  sÐ   ø€ Ü‰Ñ˜Ô Ü% fÓ-ˆŒä&@ÀÓ&HˆÔ#à×*Ñ*×6Ñ6ˆ	Ø×.Ñ.ˆ
Ø*0×*PÑ*PÐ'ÜŸ=™=ä# F¨IÐ8WÐZ[Ñ8[Ñ,[Ð]gÐijÐlmÓnÜ# F¨IÐ8WÐZ[Ñ8[Ñ,[Ð]gÐijÐlmÓnÜ# F¨IÐ8WÐZ[Ñ8[Ñ,[Ð]gÐijÐlmÓnðó
ˆÔð 	�‰Õr1   r¼  rú   rI   c                 óÒ  —  | j                   |fi |¤Ž}|j                  }| j                   j                  j                  }|j                  d   |z  }|j                  d   |z  }g }t        |«      }	t        |«      D ]_  \  }
}t        |d|	dz
  |
z
  z  z  «      }t        |d|	dz
  |
z
  z  z  «      }t        j                  |||gdd¬«      }|j                  |«       Œa | j                  |«      }g }t        t        ||«      «      D ]^  \  }
\  }}t        j                  |j                  |j                   «      |gd¬«      }|j                   | j"                  |
   |«      «       Œ` |S )NrV   r   r±   F)rO  r³   rµ   r   r‚   )r8  rC   rk   Ú
patch_sizerd   r(  r¢   r‹   rý   ÚinterpolaterÉ   rA  rš   r,   r„   r[   r·   rC  )rR   r¼  rú   Úbackbone_outputrC   rF  Úheight_patchesÚwidth_patchesÚsemantic_featuresÚ
num_scalesr£   r=  Úresize_heightÚresize_widthÚspatialÚdetail_featuresÚoutputsÚsemantic_featureÚdetail_featureÚfuseds                       r2   rb   zDeimv2DINOv3ConvEncoder.forwardš  sy  € Ø'˜$Ÿ-™-¨Ñ?¸Ñ?ˆØ&×3Ñ3ˆà—]‘]×)Ñ)×4Ñ4ˆ
Ø%×+Ñ+¨AÑ.°*Ñ<ˆØ$×*Ñ*¨1Ñ-°Ñ;ˆàÐÜ˜Ó&ˆ
Ü  Ó.ò 	.‰GˆAˆtÜ °°zÀA±~ÈÑ7IÑ1JÑ JÓKˆMÜ˜}¨q°ZÀ!±^ÀaÑ5GÑ/HÑHÓIˆLÜ—m‘m D°¸|Ð/LÐS]ÐmrÔsˆGØ×$Ñ$ WÕ-ð		.ð ×5Ñ5°lÓCˆàˆÜ5>¼sÐCTÐVeÓ?fÓ5gò 	7Ñ1ˆAÑ1Ð  .Ü—I‘IÐ/×2Ñ2°>×3HÑ3HÓIÈ>ÐZÐ`aÔbˆEØ�N‰NÐ.˜4×+Ñ+¨AÑ.¨uÓ5Õ6ð	7ð ˆr1   )r(   r)   r*   r   rL   r,   r   r   r   rD   rb   rg   rh   s   @r2   r?  r?  †  s@   ø„ ð˜|õ ð& E§L¡Lð ¸FÐCUÑ<Vð Ð[_Ð`e×`lÑ`lÑ[m÷ r1   r?  c                   ó˜   ‡ — e Zd Zd eed¬«       eed¬«      giZdefˆ fd„Zee	de
ej                     dee   d	efd
„«       «       Zˆ xZS )rä  r%   Ú
input_proj)Ú
layer_nameÚbi_fusion_convrk   c                 ól  •— t         ‰| �  |«       |j                  }|j                  }t	        j
                  |j                  D �cg c]  }t        |||dd«      ‘Œ c}«      | _        t	        j                  ddd¬«      | _
        t        |||dd|¬«      | _        t	        j                  ddd¬«      | _        t        |||dd|¬«      | _        t        |||dd|¬«      | _        t        d|j                   z  «      }t#        ||¬«      | _        t#        ||¬«      | _        | j)                  «        y c c}w )Nr   r   rV   r³  r'  ©r1  )rK   rL   r3  r  rM   r™   Úencoder_in_channelsr	  rV  Ú	AvgPool2dÚ
down_pool1Ú
down_conv1Ú
down_pool2Ú
down_conv2rX  r4  Ú
depth_multr0  Ú	fpn_blockÚ	pan_blockr7  )rR   rk   r�   r  r9  r$  rT   s         €r2   rL   zDeimv2LiteEncoder.__init__½  s  ø€ Ü‰Ñ˜Ô Ø×.Ñ.ˆ
Ø×/Ñ/ˆ
äŸ-™-ØY_×YsÑYsÖtÈ:Ô  ¨°ZÀÀAÕFÒtó
ˆŒô Ÿ,™,°1¸QÈÔJˆŒÜ-¨f°jÀ*ÈaÐQRÐ_iÔjˆŒÜŸ,™,°1¸QÈÔJˆŒÜ-¨f°jÀ*ÈaÐQRÐ_iÔjˆŒä1°&¸*ÀjÐRSÐUVÐcmÔnˆÔä˜1˜v×0Ñ0Ñ0Ó1ˆ
Ü+¨FÀ
ÔKˆŒÜ+¨FÀ
ÔKˆŒà�‰Õùò us   ÁD1Úinputs_embedsrú   rI   c                 ód  — t        |«      D ��cg c]  \  }} | j                  |   |«      ‘Œ }}}|j                  | j                  | j	                  |d   «      «      «       | j                  |d   t        j                  |d   d«      z   «      |d<   g }|d   t        j                  |d   dd¬«      z   }|j                  | j                  |«      «       |d   | j                  | j                  |d   «      «      z   }|j                  | j                  |«      «       t        |¬«      S c c}}w )NrW   r   r   rè  Únearest©Úscale_factorr³   ©rC   )r¢   rV  rÉ   r^  r]  rX  rý   Úadaptive_avg_pool2drG  rb  r`  r_  rc  rB   )rR   rd  rú   r£   ÚfeatureÚprojected_featuresrQ  Úfused_features           r2   rb   zDeimv2LiteEncoder.forwardÓ  s"  € ô MVÐVcÓLd×e¹j¸aÀÐ0˜dŸo™o¨aÑ0°Õ9ÐeÐÑeØ×!Ñ! $§/¡/°$·/±/ÐBTÐUWÑBXÓ2YÓ"ZÔ[à!%×!4Ñ!4Ø˜rÑ"¤Q×%:Ñ%:Ð;MÈbÑ;QÐSTÓ%UÑUó"
Ð˜2Ñð ˆØ*¨1Ñ-´·±Ð>PÐQRÑ>SÐbeÐluÔ0vÑvˆØ�‰�t—~‘~ mÓ4Ô5à*¨1Ñ-°·±ÀÇÁÐPWÐXZÑP[Ó@\Ó0]Ñ]ˆØ�‰�t—~‘~ mÓ4Ô5ä"°Ô8Ð8ùó fs   �D,)r(   r)   r*   r   r	  Ú_can_record_outputsr   rL   r   r   rD   r,   r   r   r   rB   rb   rg   rh   s   @r2   rä  rä  ´  sy   ø„ ð 	ÙÐ.¸<ÔHÙÐ.Ð;KÔLð
ðÐð˜|õ ð,  Øð9 T¨%¯,©,Ñ%7ð 9À6ÐJ\ÑC]ð 9Ðbuò 9ó ó  ô9r1   rä  Úfeature_map_1Úfeature_map_2Úfuse_opc                 óH   — |dk(  r| |z   S t        j                  | |gd¬«      S )zJFuses two feature maps via element-wise sum or channel-wise concatenation.rÊ   r   r‚   )r,   r„   )ro  rp  rq  s      r2   Úfuse_feature_mapsrs  ç  s+   € à�%ÒØ˜}Ñ,Ð,Ü�9‰9�m ]Ð3¸Ô;Ð;r1   c            	       ó’   ‡ — e Zd ZdZeedœZdefˆ fd„Ze	 e
d¬«      	 ddeej                     dz  d	ee   d
efd„«       «       Zˆ xZS )rã  aE  
    DEIMv2 variant of DFineHybridEncoder. Uses element-wise sum fusion (`fuse_feature_maps`) instead of
    D-FINE's channel concatenation, Deimv2RepNCSPELAN5 (simplified 4-way concat) instead of DFineRepNCSPELAN4,
    and returns Deimv2EncoderOutput with feature_maps instead of BaseModelOutput with last_hidden_state.
    )r%   r&   rk   c           
      ó¼  •— t         ‰| �  |«       || _        |j                  | _        t        | j                  «      dz
  | _        |j                  | _        |j                  | _        |j                  | _	        |j                  | _
        |j                  | _        | j                  D �cg c]  }| j                  ‘Œ c}| _        | j                  | _        |j                  | _        t!        j"                  t%        t        | j                  «      «      D �cg c]  }t'        |«      ‘Œ c}«      | _        t!        j"                  «       | _        t!        j"                  «       | _        t%        t        | j                  «      dz
  dd«      D ]|  }| j*                  j/                  t1        || j                  | j                  dd«      «       t3        d|j4                  z  «      }| j,                  j/                  t7        ||¬«      «       Œ~ t!        j"                  «       | _        t!        j"                  «       | _        t%        t        | j                  «      dz
  «      D ]f  }| j8                  j/                  t=        |dd«      «       t3        d|j4                  z  «      }| j:                  j/                  t7        ||¬«      «       Œh | j?                  «        y c c}w c c}w )Nr   r   rW   r   rZ  rV   ) rK   rL   rk   r[  r
  r(  Únum_fpn_stagesÚfeat_stridesr3  Úencode_proj_layersrª  r©  r  Úout_stridesÚencoder_fuse_oprq  rM   r™   ró   r§  ÚaifiÚlateral_convsÚ
fpn_blocksrÉ   r	  r4  ra  r0  Údownsample_convsÚ
pan_blocksrA  r7  )rR   rk   rÐ   r$  rT   s       €r2   rL   zDeimv2HybridEncoder.__init__ú  s;  ø€ Ü‰Ñ˜Ô ØˆŒØ!×5Ñ5ˆÔÜ! $×"2Ñ"2Ó3°aÑ7ˆÔØ"×/Ñ/ˆÔØ"(×";Ñ";ˆÔØ"(×";Ñ";ˆÔØ/5×/UÑ/UˆÔ,Ø×)Ñ)ˆŒØ>B×>NÑ>NÖO¸˜T×4Ó4ÒOˆÔØ×,Ñ,ˆÔØ×-Ñ-ˆŒä—M‘MÄEÌ#Èd×NeÑNeÓJfÓDgÖ"h¸q¤?°6Õ#:Ò"hÓiˆŒ	äŸ]™]›_ˆÔÜŸ-™-›/ˆŒÜ”s˜4×+Ñ+Ó,¨qÑ0°!°RÓ8ò 	WˆAØ×Ñ×%Ñ%Ü# F¨D×,CÑ,CÀT×E\ÑE\Ð^_ÐabÓcôô ˜q 6×#4Ñ#4Ñ4Ó5ˆJØ�O‰O×"Ñ"Ô#5°fÈ*Ô#UÕVð	Wô !#§¡£ˆÔÜŸ-™-›/ˆŒÜ”s˜4×+Ñ+Ó,¨qÑ0Ó1ò 	WˆAØ×!Ñ!×(Ñ(¬°f¸aÀÓ)CÔDÜ˜q 6×#4Ñ#4Ñ4Ó5ˆJØ�O‰O×"Ñ"Ô#5°fÈ*Ô#UÕVð	Wð
 	�‰Õùò- Pùò #is   Â)KÄKF)Útie_last_hidden_statesNrd  rú   rI   c                 ó2  — |}| j                   j                  dkD  r9t        | j                  «      D ]!  \  }} | j                  |   ||   fi |¤Ž||<   Œ# |d   g}t        t        | j                  | j                  «      «      D ]w  \  }\  }}	|| j                  |z
  dz
     }
|d   } ||«      }||d<   t        j                  |dd¬«      }t        ||
| j                  «      } |	|«      }|j                  |«       Œy |j                  «        |d   g}t        t        | j                  | j                   «      «      D ]M  \  }\  }}|d   }||dz      } ||«      }t        ||| j                  «      } ||«      }|j                  |«       ŒO t#        |¬«      S )z¿
        Args:
            inputs_embeds (`list[torch.FloatTensor]`):
                Multi-scale feature maps from the backbone (one tensor per feature level) passed to the encoder.
        r   rW   r   rè  rf  rg  ri  )rk   r¬  r¢   rx  r{  rš   r|  r}  rv  rý   rG  rs  rq  rÉ   Úreverser~  r  rB   )rR   rd  rú   rC   r£   Úenc_indÚfpn_feature_mapsÚidxÚlateral_convrb  Úbackbone_feature_mapÚtop_fpn_feature_mapÚfused_feature_mapÚnew_fpn_feature_mapÚpan_feature_mapsÚdownsample_convrc  Útop_pan_feature_mapÚfpn_feature_mapÚdownsampled_feature_mapÚnew_pan_feature_maps                        r2   rb   zDeimv2HybridEncoder.forward  sÛ  € ð %ˆà�;‰;×%Ñ%¨Ò)Ü'¨×(?Ñ(?Ó@ò V‘
��7Ø(4¨¯	©	°!©°\À'Ñ5JÑ(UÈfÑ(U�˜WÒ%ðVð )¨Ñ,Ð-ÐÜ.7¼¸D×<NÑ<NÐPT×P_ÑP_Ó8`Ó.aò 	9Ñ*ˆCÑ*�, 	Ø#/°×0CÑ0CÀcÑ0IÈAÑ0MÑ#NÐ Ø"2°2Ñ"6ÐÙ".Ð/BÓ"CÐØ#6Ð˜RÑ Ü"#§-¡-Ð0CÐRUÐ\eÔ"fÐÜ 1Ð2EÐG[Ð]a×]iÑ]iÓ jÐÙ"+Ð,=Ó">ÐØ×#Ñ#Ð$7Õ8ð	9ð 	× Ñ Ô"ð -¨QÑ/Ð0ÐÜ1:¼3¸t×?TÑ?TÐVZ×VeÑVeÓ;fÓ1gò 	9Ñ-ˆCÑ-�/ 9Ø"2°2Ñ"6ÐØ.¨s°Q©wÑ7ˆOÙ&5Ð6IÓ&JÐ#Ü 1Ð2IÈ?Ð\`×\hÑ\hÓ iÐÙ"+Ð,=Ó">ÐØ×#Ñ#Ð$7Õ8ð	9ô #Ð0@ÔAÐAr1   ry   )r(   r)   r*   r+   r§  rU  rn  r   rL   r   r   rD   r,   r   r   r   rB   rb   rg   rh   s   @r2   rã  rã  î  s€   ø„ ñð )Ø)ñÐð
 ˜|õ  ðD  Ù¨EÔ2ð 48ñ(Bà˜EŸL™LÑ)¨DÑ0ð(Bð Ð+Ñ,ð(Bð 
ò	(Bó 3ó  ô(Br1   rã  c                 ó¦   — | j                  dd¬«      } | j                  |¬«      }d| z
  j                  |¬«      }t        j                  ||z  «      S )Nr   r   r~  )r  )rÃ   r,   rò  )rz   rH   Úx1Úx2s       r2   Úinverse_sigmoidr”  I  sK   € Ø	�‰�A˜1ˆÓ€AØ	
�‰�SˆÓ	€BØ
ˆa‰%�‰˜3ˆÓ	€BÜ�9‰9�R˜"‘WÓÐr1   rÁ  rç  ræ  c                 ó¸  — t        |d   «      t        |«      z  }t        |d   «      t        |«      z  dz  }|dz   d| dz
  z  z  }t        | dz  dz
  dd«      D �cg c]  }||z   dz   ‘Œ }}t        d| dz  «      D �cg c]
  }||z  dz
  ‘Œ }}| g|z   t        j                  |d   d   «      gz   |z   |gz   }	t        j                  |	d«      }	|	S c c}w c c}w )uK  
    Generates the non-uniform Weighting Function W(n) for bounding box regression.

    Args:
        max_num_bins (int): Max number of the discrete bins.
        up (Tensor): Controls upper bounds of the sequence,
                     where maximum offset is Â±up * H / W.
        reg_scale (float): Controls the curvature of the Weighting Function.
                           Larger values result in flatter weights near the central axis W(max_num_bins/2)=0
                           and steeper weights at both ends.
    Returns:
        Tensor: Sequence of Weighting Function.
    r   rV   r   rW   N)rú  ró   r,   Ú
zeros_liker„   )
rÁ  rç  ræ  Úupper_bound1Úupper_bound2Ústepr£   Úleft_valuesÚright_valuesrû  s
             r2   Úweighting_functionrœ  P  sû   € ô �r˜!‘u“:¤ I£Ñ.€LÜ�r˜!‘u“:¤ I£Ñ.°Ñ2€LØ˜1Ñ ! |°aÑ'7Ñ"8Ñ9€DÜ/4°\ÀQÑ5FÈÑ5JÈAÈrÓ/RÖS¨!�d˜q‘[�> AÓ%ÐS€KÐSÜ-2°1°lÀaÑ6GÓ-HÖI¨�T˜a‘K !“OÐI€LÐIØˆmˆ_˜{Ñ*¬e×.>Ñ.>¸rÀ!¹uÀT¹{Ó.KÐ-LÑLÈ|Ñ[Ð_kÐ^lÑl€FÜ�Y‰Y�v˜qÓ!€FØ€Mùò	 TùÚIs   ÁCÁ>CÚdistancec                 ó2  — t        |«      }| d   d|z  |d   z   | d   |z  z  z
  }| d   d|z  |d   z   | d   |z  z  z
  }| d   d|z  |d   z   | d   |z  z  z   }| d   d|z  |d   z   | d   |z  z  z   }t        j                  ||||gd«      }t        |«      S )aˆ  
    Decodes edge-distances into bounding box coordinates.

    Args:
        points (`torch.Tensor`):
            (batch_size, num_boxes, 4) or (num_boxes, 4) format, representing [x_center, y_center, width, height]
        distance (`torch.Tensor`):
            (batch_size, num_boxes, 4) or (num_boxes, 4), representing distances from the point to the left, top, right, and bottom boundaries.
        reg_scale (`float`):
            Controls the curvature of the Weighting Function.
    Returns:
        `torch.Tensor`: Bounding boxes in (batch_size, num_boxes, 4) or (num_boxes, 4) format, representing [x_center, y_center, width, height]
    r¹   r¸   ).rV   rº   ).r   rW   )rú  r,   rÄ   r   )Úpointsr�  ræ  Ú
top_left_xÚ
top_left_yÚbottom_right_xÚbottom_right_yÚbboxess           r2   Údistance2bboxr¥  h  sâ   € ô �I“€IØ˜‘ 3¨¡?°X¸fÑ5EÑ#EÈ&ÐQWÉ.Ð[dÑJdÑ"eÑe€JØ˜‘ 3¨¡?°X¸fÑ5EÑ#EÈ&ÐQWÉ.Ð[dÑJdÑ"eÑe€JØ˜F‘^ s¨Y¡¸À&Ñ9IÑ'IÈfÐU[ÉnÐ_hÑNhÑ&iÑi€NØ˜F‘^ s¨Y¡¸À&Ñ9IÑ'IÈfÐU[ÉnÐ_hÑNhÑ&iÑi€Nä�[‰[˜* j°.À.ÐQÐSUÓV€Fä# FÓ+Ð+r1   c                   ó°   ‡ — e Zd ZdZeeedœZdefˆ fd„Z	e
e	 	 	 	 ddej                  dej                  dej                  dee   d	ef
d
„«       «       Zˆ xZS )rí  aW  
    D-FINE Decoder implementing Fine-grained Distribution Refinement (FDR).

    This decoder refines object detection predictions through iterative updates across multiple layers,
    utilizing attention mechanisms, location quality estimators, and distribution refinement techniques
    to improve bounding box accuracy and robustness.
    )r%   r&   r'   rk   c           	      óÞ  •— t         ‰| �  |«       |j                  dk\  r|j                  n|j                  |j                  z   | _        |j                  | _        t        j                  t        |j                  «      D �cg c]  }t        |«      ‘Œ c}t        |j                  | j                  z
  dz
  «      D �cg c]  }t        |«      ‘Œ c}z   «      | _	        t        d|j                  |j                  d|j                  «      | _        d | _        d | _        t        j                   t#        j$                  |j&                  g«      d¬«      | _        |j(                  | _        |j                  | _        |j*                  | _        t        |j,                  |j,                  dd«      | _        t1        |«      | _        |j4                  | _        t        j                   t#        j$                  |j8                  g«      d¬«      | _        t        j                  t        |j                  «      D �cg c]  }t;        |«      ‘Œ c}«      | _        | j?                  «        y c c}w c c}w c c}w )Nr   r   r¯   r   F)Úrequires_grad) rK   rL   Úeval_idxÚdecoder_layersrI  rM   r™   ró   rÖ  r›   r�   rq   Údecoder_activation_functionÚquery_pos_headrö  rî  rN   r,   rÁ   ræ  rÁ  Úlayer_scalerS   Úpre_bbox_headr¿  Úintegralré   Únum_headrç  rÇ  rË  r7  r­  s      €r2   rL   zDeimv2Decoder.__init__�  sÍ  ø€ Ü‰Ñ˜Ô Ø+1¯?©?¸aÒ+?˜ŸšÀV×EZÑEZÐ]c×]lÑ]lÑElˆŒà—~‘~ˆŒÜ—m‘mÜ16°v×7LÑ7LÓ1MÖN¨AÔ Õ'ÒNÜ38¸×9NÑ9NÐQU×Q^ÑQ^Ñ9^ÐabÑ9bÓ3cÖd¨aÔ! &Õ)Òdñeó
ˆŒô (¨¨6¯>©>¸6¿>¹>È1Èf×NpÑNpÓqˆÔð ˆŒØˆÔÜŸ™¤e§l¡l°F×4DÑ4DÐ3EÓ&FÐV[Ô\ˆŒØ"×/Ñ/ˆÔØ—~‘~ˆŒØ!×-Ñ-ˆÔÜ& v×'9Ñ'9¸6×;MÑ;MÈqÐRSÓTˆÔÜ& vÓ.ˆŒØ×6Ñ6ˆŒÜ—,‘,œuŸ|™|¨V¯Y©Y¨KÓ8ÈÔNˆŒÜŸ-™-ÄEÈ&×J_ÑJ_ÓD`Ö(a¸q¬°6Õ):Ò(aÓbˆŒð 	�‰Õùò' OùÚdùò )bs   ÂI Â<I%
È1I*r8   r  rd  rú   rI   c	                 ó  — |�|}
d}d}d}d}d}dx}}t        | j                  | j                  | j                  «      }t	        j
                  |«      }t        | j                  «      D �]ƒ  \  }}|j                  d«      }| j                  |«      j                  dd¬«      } |
f||||||dœ|	¤Ž}
|dk(  r@t	        j
                  | j                  |
«      t        |«      z   «      }|j                  «       }| j                  �T | j                  |   |
|z   «      |z   }t        | j!                  ||«      | j                  «      }|}|j                  «       }|
j                  «       }||
fz  }| j"                  €�Œ| j$                  s|| j&                  k(  s�Œ0 | j"                  |   |
«      }|dk(  r||fz  }|fz  } | j(                  |   |«      }||fz  }|fz  }|fz  }||fz  }�Œ† t+        j,                  |«      }| j"                  �h| j                  �\t+        j,                  |d¬	«      }t+        j,                  |d¬	«      }t+        j,                  |d¬	«      }t+        j,                  |d¬	«      }t/        
|||||¬
«      S )a³  
        Args:
            inputs_embeds (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`):
                The query embeddings that are passed into the decoder.
            encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
                Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
                of the decoder.
            encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
                Mask to avoid performing cross-attention on padding pixel_values of the encoder. Mask values selected
                in `[0, 1]`:
                - 1 for pixels that are real (i.e. **not masked**),
                - 0 for pixels that are padding (i.e. **masked**).
            reference_points (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)` is `as_two_stage` else `(batch_size, num_queries, 2)` or , *optional*):
                Reference point in range `[0, 1]`, top-left (0,0), bottom-right (1, 1), including padding area.
            spatial_shapes (`torch.FloatTensor` of shape `(num_feature_levels, 2)`):
                Spatial shapes of the feature maps.
            level_start_index (`torch.LongTensor` of shape `(num_feature_levels)`, *optional*):
                Indexes for the start of each feature level. In range `[0, sequence_length]`.
        r0   r   rV   iöÿÿÿé
   r~  )r_  r  r  r  r8   rÝ  r   r‚   )r   r    r!   r"   r#   r$   )rœ  rÁ  rç  ræ  rý   r…   r¢   r›   rÆ   r¬  rÃ   r®  r”  Údetachrö  r¥  r¯  rî  rN  r©  rË  r,   rÄ   r   )rR   r8   r  rd  r  Úlevel_start_indexr  rÝ  Úmemory_maskrú   r%   Úintermediater"   r!   r#   r$   Úoutput_detachÚpred_corners_undetachrÃ  Úref_points_detachr£   Údecoder_layerÚref_points_inputÚquery_pos_embedÚnew_reference_pointsÚref_points_initialrÂ  Úinter_ref_bboxrÍ  s                                r2   rb   zDeimv2Decoder.forward«  sÜ  € ðB Ð$Ø)ˆMð ˆØ(*Ð%Ø ÐØ)+Ð&Ø#%Ð à01Ð1ˆÐ-ä$ T×%6Ñ%6¸¿¹ÀÇÁÓPˆÜŸI™IÐ&6Ó7Ðä )¨$¯+©+Ó 6ó .	BÑˆAˆ}Ø0×:Ñ:¸1Ó=ÐØ"×1Ñ1Ð2CÓD×JÑJÈsÐXZÐJÓ[ˆOá)Øð	à$3Ø!1Ø-Ø$7Ø&;Ø'=ñ	ð ñ	ˆMð �AŠvä'(§y¡yØ×&Ñ& }Ó5¼ÐHYÓ8ZÑZó(Ð$ð &:×%@Ñ%@Ó%BÐ"ð �‰Ð*Ø1˜tŸ™¨qÑ1°-À-Ñ2OÓPÐShÑh�Ü!.Ø&¨¯©°lÀGÓ(LÈdÏnÉnó"�ð )5Ð%Ø$2×$9Ñ$9Ó$;Ð!à)×0Ñ0Ó2ˆMà˜]Ð,Ñ,ˆLà×ÑÒ+°·²À!ÀtÇ}Á}ÔBTØ,˜×)Ñ)¨!Ñ,¨]Ó;�à˜’6Ø'¨F¨9Ñ4Ð'Ø1Ð6JÐ5LÑLÐ1à+˜Ÿ™¨Ñ+¨F°LÓA�Ø#¨ yÑ0Ð#Ø-°.Ð1BÑBÐ-Ø(Ð-?Ð,AÑAÐ(Ø.°<°/ÑAÒ.ð].	Bôb —{‘{ <Ó0ˆØ×ÑÐ'¨D¯O©OÐ,GÜ"'§+¡+Ð.AÀqÔ"IÐÜ-2¯[©[Ð9WÐ]^Ô-_Ð*Ü',§{¡{Ð3KÐQRÔ'SÐ$Ü,1¯K©KÐ8UÐ[\Ô,]Ð)ä"Ø+Ø'3Ø 3Ø*GØ+IØ%=ô
ð 	
r1   ©NNNN)r(   r)   r*   r+   rÖ  rU  rå   rn  r   rL   r   r   r,   r   r   r   r   rb   rg   rh   s   @r2   rí  rí  �  sš   ø„ ñð ,Ø)Ø?ñÐð˜|õ ð6  Øð Ø Ø#Øñm
à$Ÿ|™|ðm
ð  Ÿ,™,ðm
ð —|‘|ð	m
ð Ð+Ñ,ðm
ð 
òm
ó ó  ôm
r1   rí  c                 ó¢  — |dk  ry| D �cg c]  }t        |d   «      ‘Œ }}| d   d   j                  }	t        |«      }
|
dk(  ry||
z  }|dk(  rdn|}t        |«      }t        j                  ||
g|t        j
                  |	¬«      }t        j                  ||
dg|	¬«      }t        j                  ||
gt        j                  |	¬«      }t        |«      D ]4  }||   }|dkD  sŒ| |   d   ||d|…f<   | |   d	   ||d|…f<   d||d|…f<   Œ6 |j                  dd
|z  g«      }|j                  dd
|z  dg«      }|j                  dd
|z  g«      }t        j                  ||
d
z  dg|	¬«      }d|dd…|
d…f<   |j                  d|dg«      }d|z
  }|j                  d«      |z  }t        j                  |«      dd…df   }t        j                  ||D �cg c]  }||z  ‘Œ	 c}«      }t        |
d
z  |z  «      }|dkD  rht        j                  |t        j                  ¬«      |dz  k  }t        j                   |d||j"                  ¬«      }t        j$                  ||z  ||«      }|dkD  r©t'        |«      }t        j                  |dd
d…f   dz  g d¢«      |z  }t        j                   |dd
«      dz  dz
  }t        j                  |«      }|dz   |z  |d|z
  z  z   }||z  }|||z  z  }|j)                  dd¬«       t+        |«      }t-        |«      } ||«      }||z   }t        j                  ||gdt        j                  |	¬«      }t        j.                   ||d…d|…f<   t        |«      D ]I  }|
d
z  |z  }|
d
z  |dz   z  }t        j.                   |||…d|…f<   t        j.                   |||…||…f<   ŒK ||||gdœ} |||| fS c c}w c c}w )a~  
    Creates a contrastive denoising training group using ground-truth samples. It adds noise to labels and boxes.

    Args:
        targets (`list[dict]`):
            The target objects, each containing 'class_labels' and 'boxes' for objects in an image.
        num_classes (`int`):
            Total number of classes in the dataset.
        num_queries (`int`):
            Number of query slots in the transformer.
        class_embed (`callable`):
            A function or a model layer to embed class labels.
        num_denoising_queries (`int`, *optional*, defaults to 100):
            Number of denoising queries.
        label_noise_ratio (`float`, *optional*, defaults to 0.5):
            Ratio of noise applied to labels.
        box_noise_scale (`float`, *optional*, defaults to 1.0):
            Scale of noise applied to bounding boxes.
    Returns:
        `tuple` comprising various elements:
        - **input_query_class** (`torch.FloatTensor`) --
          Class queries with applied label noise.
        - **input_query_bbox** (`torch.FloatTensor`) --
          Bounding box queries with applied box noise.
        - **attn_mask** (`torch.FloatTensor`) --
           Attention mask for separating denoising and reconstruction queries.
        - **denoising_meta_values** (`dict`) --
          Metadata including denoising positive indices, number of groups, and split sizes.
    r   rÀ  Úclass_labelsr   rŠ  r¯   r¶   NÚboxesrV   rW   rè   r¸   .)r   r   rV   rè  r.  ra  r~  )Údn_positive_idxÚdn_num_groupÚdn_num_split)r(  r·   r€  r,   ÚfullÚint32r²   rk  ró   rü  ÚsqueezeÚnonzeror½   r   Ú	rand_likerf   Úrandint_likerZ   Úwherer
   Úclip_r   r”  Úinf)!ÚtargetsÚnum_classesrÒ   rî  Únum_denoising_queriesÚlabel_noise_ratioÚbox_noise_scaleÚtÚnum_ground_truthsr·   Ú
max_gt_numÚnum_groups_denoising_queriesrÏ   Úinput_query_classÚinput_query_bboxÚpad_gt_maskr£   Únum_gtÚnegative_gt_maskÚpositive_gt_maskÚdenoise_positive_idxrø   ÚmaskÚ	new_labelÚ
known_bboxÚdiffÚ	rand_signÚ	rand_partÚtarget_sizeÚ	attn_maskÚidx_block_startÚidx_block_endr?   s!                                    r2   Ú(get_contrastive_denoising_training_grouprê    s‰  € ðN  Ò!Ø%à9@ÖA°Aœ˜Q˜~Ñ.Õ/ÐAÐÐAØ�Q‰Z˜Ñ'×.Ñ.€FäÐ&Ó'€JØ�Q‚Ø%à#8¸JÑ#FÐ Ø(DÈÒ(I¡1ÐOkÐ äÐ&Ó'€JäŸ
™
 J°
Ð#;¸[ÔPU×P[ÑP[ÐdjÔkÐÜ—{‘{ J°
¸AÐ#>ÀvÔNÐÜ—+‘+˜z¨:Ð6¼e¿j¹jÐQWÔX€Kä�:Óò (ˆØ" 1Ñ%ˆØ�A‹:Ø,3°A©J°~Ñ,FÐ˜a  & ˜jÑ)Ø+2°1©:°gÑ+>Ð˜Q   ˜ZÑ(Ø&'ˆK˜˜7˜F˜7˜
Ò#ð(ð *×.Ñ.°°1Ð7SÑ3SÐ/TÓUÐØ'×,Ñ,¨a°Ð5QÑ1QÐSTÐ-UÓVÐØ×"Ñ" A qÐ+GÑ'GÐ#HÓI€Kä—{‘{ J°
¸Q±ÀÐ#BÈ6ÔRÐØ'(Ð’Q˜
™�^Ñ$Ø'×,Ñ,¨aÐ1MÈqÐ-QÓRÐØÐ+Ñ+Ðà'×/Ñ/°Ó3°kÑAÐÜ Ÿ=™=Ð)9Ó:º1¸a¸4Ñ@ÐÜ Ÿ;™;ØÐIZÖ[ÀA˜qÐ#?Ó?Ò[óÐô & j°1¡nÐ7SÑ&SÓTÐà˜1ÒÜ�‰Ð0¼¿¹ÔDÐHYÐ\_ÑH_Ñ`ˆä×&Ñ& t¨Q°ÐCT×CZÑCZÔ[ˆ	Ü!ŸK™K¨¨{Ñ(:¸IÐGXÓYÐà˜ÒÜ-Ð.>Ó?ˆ
Ü�z‰zÐ*¨3°±¨7Ñ3°cÑ9º9ÓEÈÑWˆÜ×&Ñ&Ð'7¸¸AÓ>ÀÑDÀsÑJˆ	Ü—O‘OÐ$4Ó5ˆ	Ø ‘_Ð(8Ñ8¸9ÈÐL\ÑH\Ñ;]Ñ]ˆ	Ø�YÑˆ	Ø�i $Ñ&Ñ&ˆ
Ø×Ñ˜S cÐÔ*Ü3°JÓ?ÐÜ*Ð+;Ó<Ðá#Ð$5Ó6Ðà'¨+Ñ5€KÜ—
‘
˜K¨Ð5°qÄÇÁÐTZÔ[€IäAFÇÁÀ
€IÐ#Ñ$Ð&<Ð'<Ð&<Ð<Ñ=ô Ð/Ó0ò cˆØ$ q™.¨1Ñ,ˆØ" Q™¨!¨a©%Ñ0ˆÜFKÇiÁiÀZˆ	�/ -Ð/Ð1A°/Ð1AÐAÑBÜY^×YbÑYbÐXbˆ	�/ -Ð/°Ð?TÐ1TÐTÒUð	cð 0Ø4Ø.°Ð<ñÐð Ð.°	Ð;PÐPÐPùò] BùòF \s   ‹OÇO
z|
    RT-DETR Model (consisting of a backbone and encoder-decoder) outputting raw hidden states without any head on top.
    c                   óö  ‡ — e Zd Zdefˆ fd„Zd„ Zd„ Ze ed¬«      de	j                  fdeeeef   d	f   d
ede	j                  ez  de	j                   dee	j"                  e	j"                  f   f
d„«       «       Zddde	j                  fd„Zee	 	 	 	 dde	j,                  de	j.                  dz  de	j,                  dz  de	j,                  dz  dee   dz  dee   dee	j,                     ez  fd„«       «       Zˆ xZS )rþ  rk   c           
      ó`  •— t         ‰| �  |«       t        |j                  dd «      dk(  }|rt	        |«      n
t        |«      | _        |j                  dk(  rt        |«      nt        |¬«      | _
        |j                  dkD  r>t        j                  |j                  dz   |j                  |j                  ¬«      | _        |j"                  r/t        j                  |j$                  |j                  «      | _        t        j(                  t        j*                  |j                  |j                  «      t        j,                  |j                  |j.                  ¬«      «      | _        t        j*                  |j                  |j                  «      | _        t5        |j                  |j                  d	d
«      | _        |j8                  r)| j;                  | j<                  ¬«      \  | _        | _         tC        |jD                  «      }g }|jD                  d   }tG        |«      D ]Z  }|jI                  |jJ                  |jD                  d   k(  rt        jL                  «       ntO        |||j                  dd«      «       Œ\ tG        |jP                  |z
  «      D ]Z  }|jI                  |jJ                  |jD                  d   k(  rt        jL                  «       ntO        |||j                  d
d«      «       Œ\ t        jR                  |«      | _*        tW        |«      | _,        | j[                  «        y )NÚ
model_typeÚ
dinov3_vitr1  rØ  r   r   )Úpadding_idxrp  r¯   r   rè   rW   rV   ).rK   rL   ÚgetattrrB  r?  r/  Úconv_encoderr5  rä  rã  Úencoderr  rM   Ú	Embeddingrð  rq   rê  r   rÒ   ré  Ú
Sequentialrp   rs  rt  Ú
enc_outputrÿ  r�   Úenc_bbox_headÚanchor_image_sizeÚgenerate_anchorsrZ   ÚanchorsÚ
valid_maskr(  Údecoder_in_channelsró   rÉ   rS   r  r	  rë   r™   Údecoder_input_projrí  Údecoderr7  )rR   rk   Ú	is_dinov3Únum_backbone_outsrü  r
  rÐ   rT   s          €r2   rL   zDeimv2Model.__init__ž  s„  ø€ Ü‰Ñ˜Ô ä˜F×2Ñ2°LÀ$ÓGÈ<ÑWˆ	Ù?HÔ3°FÔ;ÔN_Ð`fÓNgˆÔà)/×)<Ñ)<ÀÒ)FÔ˜fÔ%ÔL_ÐgmÔLnð 	Œð ×Ñ !Ò#Ü)+¯©Ø×!Ñ! AÑ% v§~¡~À6×CTÑCTô*ˆDÔ&ð ×%Ò%Ü$&§L¡L°×1CÑ1CÀVÇ^Á^Ó$TˆDÔ!äŸ-™-Ü�I‰I�f—n‘n f§n¡nÓ5Ü�L‰L˜Ÿ™¨V×-BÑ-BÔCó
ˆŒô !Ÿi™i¨¯©¸×8IÑ8IÓJˆÔÜ& v§~¡~°v·~±~ÀqÈ!ÓLˆÔà×#Ò#Ø,0×,AÑ,AÈÏ
É
Ð,AÓ,SÑ)ˆDŒL˜$œ/ä × :Ñ :Ó;ÐØÐØ×0Ñ0°Ñ4ˆÜÐ(Ó)ò 	ˆAØ×%Ñ%à×%Ñ%¨×)CÑ)CÀBÑ)GÒGô —‘”ä(¨°¸f¿n¹nÈaÐQRÓSõð	ô �v×0Ñ0Ð3DÑDÓEò 	ˆAØ×%Ñ%à×%Ñ%¨×)CÑ)CÀBÑ)GÒGô —‘”ä(¨°¸f¿n¹nÈaÐQRÓSõð	ô #%§-¡-Ð0BÓ"CˆÔÜ$ VÓ,ˆŒà�‰Õr1   c                 ód   — | j                   j                  «       D ]  }|j                  d«       Œ y )NF©r8  Ú
parametersÚrequires_grad_©rR   Úparams     r2   Úfreeze_backbonezDeimv2Model.freeze_backboneÍ  s,   € Ø—]‘]×-Ñ-Ó/ò 	(ˆEØ× Ñ  Õ'ñ	(r1   c                 ód   — | j                   j                  «       D ]  }|j                  d«       Œ y )NTr  r  s     r2   Úunfreeze_backbonezDeimv2Model.unfreeze_backboneÑ  s,   € Ø—]‘]×-Ñ-Ó/ò 	'ˆEØ× Ñ  Õ&ñ	'r1   rž  rŸ  Úcpur  .Ú	grid_sizer·   rZ   rI   c           	      óz  — g }t        | «      D �]  \  }\  }}t        j                  t        j                  ||¬«      j	                  |«      t        j                  ||¬«      j	                  |«      d¬«      \  }}	t        j
                  |	|gd«      }
|
j                  d«      dz   }
|
dxx   |z  cc<   |
dxx   |z  cc<   t        j                  |
«      |z  d	|z  z  }|j                  t        j                  |
|gd«      j                  d||z  d
«      «       �Œ d}t        j                  |d«      }||kD  |d|z
  k  z  j                  dd¬«      }t        j                  |d|z
  z  «      }t        j                  ||t        j                  t        j                  |«      j                   ||¬«      «      }||fS )N)Úendr·   r‹  rŒ  rW   r   r¸   r¹   rº   rè  r¯   g{®Gáz„?r   TrX   rŠ  )r¢   r,   r�  rÅ   r[   rÄ   rÆ   Ú	ones_likerÉ   rË   r¾   r‚  rò  rÍ  rÁ   rƒ  r€  )r  r
  r·   rZ   rù  ÚlevelrÕ   rÖ   Úgrid_yÚgrid_xÚgrid_xyÚwhrH   rú  s                 r2   Ú_cached_generate_anchorsz$Deimv2Model._cached_generate_anchorsÕ  s“  € ð ˆÜ&/°Ó&?ó 	[Ñ"ˆE‘?�F˜EÜ"Ÿ^™^Ü—‘ °Ô7×:Ñ:¸5ÓAÜ—‘ ¨vÔ6×9Ñ9¸%Ó@Øô‰NˆF�Fô
 —k‘k 6¨6Ð"2°BÓ7ˆGØ×'Ñ'¨Ó*¨SÑ0ˆGØ�F‹O˜uÑ$‹OØ�F‹O˜vÑ%‹OÜ—‘ Ó)¨IÑ5¸¸e¹ÑDˆBØ�N‰Nœ5Ÿ<™<¨°"¨°rÓ:×BÑBÀ2ÀvÐPUÁ~ÐWXÓYÖZð	[ð ˆÜ—,‘,˜w¨Ó*ˆØ ‘}¨°1°s±7Ñ):Ñ;×@Ñ@ÀÈTÐ@ÓRˆ
Ü—)‘)˜G q¨7¡{Ñ3Ó4ˆÜ—+‘+˜j¨'´5·<±<ÄÇÁÈEÓ@R×@VÑ@VÐ^cÐlrÔ3sÓtˆà˜
Ð"Ð"r1   Ngš™™™™™©?c                 ón   ‡ — |€ˆ fd„‰ j                   j                  D «       }‰ j                  ||||«      S )Nc              3   ó²   •K  — | ]N  }t        ‰j                  j                  d    |z  «      t        ‰j                  j                  d   |z  «      f–— ŒP y­w)r   r   N)r‹   rk   r÷  )r•   ÚsrR   s     €r2   r˜   z/Deimv2Model.generate_anchors.<locals>.<genexpr>õ  sR   øè ø€ ò àô �T—[‘[×2Ñ2°1Ñ5¸Ñ9Ó:¼CÀÇÁ×@]Ñ@]Ð^_Ñ@`ÐcdÑ@dÓ<eÔfñùs   ƒAA)rk   rw  r  )rR   r  r
  r·   rZ   s   `    r2   rø  zDeimv2Model.generate_anchorsó  s<   ø€ ØÐ!óàŸ™×1Ñ1ôˆNð ×,Ñ,¨^¸YÈÐPUÓVÐVr1   r¼  Ú
pixel_maskÚencoder_outputsrd  Úlabelsrú   c                 óp  — |€|€t        d«      ‚|€K|j                  \  }}}	}
|j                  }|€t        j                  ||	|
f|¬«      }| j                  |«      }n|j                  d   }|j                  }|} | j                  |fi |¤Ž}g }t        |j                  «      D ])  \  }}|j                   | j                  |   |«      «       Œ+ | j                  j                  t        |«      kD  r™|j                   | j                  t        |«         |j                  d   «      «       t        t        |«      | j                  j                  «      D ]3  }|j                   | j                  |   |j                  d   «      «       Œ5 g }g }t        j                  t        |«      df|t        j                   ¬«      }t        |«      D ]j  \  }}|j                  dd \  }	}
|	||df<   |
||d	f<   |j                  |	|
f«       |j#                  d«      j%                  d	d«      }|j                  |«       Œl t        j&                  |d	«      }t        j&                  |j)                  d
«      |j+                  d	«      j-                  d«      dd f«      }| j.                  r¡| j                  j0                  dkD  rˆ|�†t3        || j                  j4                  | j                  j6                  | j8                  | j                  j0                  | j                  j:                  | j                  j<                  ¬«      \  }}}}nd\  }}}}t        |«      }|j                  }|j>                  }| j.                  s| j                  j@                  €#tC        |«      }| jE                  |||¬«      \  }}n<| jF                  | jH                  }}|jK                  ||«      |jK                  ||«      }}|jK                  |j>                  «      |z  }| jM                  |«      }| jO                  |«      }| jQ                  |«      |z   } t        jR                  |jU                  d«      jV                  | j                  j6                  d	¬«      \  }!}"| jY                  d	|"j[                  d«      j]                  d	d	| j                  d   «      ¬«      }#t_        j`                  |#«      }$|�t        jb                  ||#gd	«      }#|jY                  d	|"j[                  d«      j]                  d	d	|j                  d   «      ¬«      }%| j                  jd                  r| jf                  ji                  |d	d	g«      }&nP|jY                  d	|"j[                  d«      j]                  d	d	|j                  d   «      ¬«      }&|&jk                  «       }&|�t        jb                  ||&gd	«      }&|#jk                  «       }' | jl                  d"|&|||'|||dœ|¤Ž}(to        d"i d|(jp                  “d|(jr                  “d|(jt                  “d|(jv                  “d|(jx                  “d|(jz                  “d|(j|                  “d|(j~                  “d|(j€                  “d|j                  “d|j|                  “d|j~                  “d|'“d|%“d|$“d|“d | “d!|“ŽS )#av  
        inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
            Optionally, instead of passing the flattened feature map (output of the backbone + projection layer), you
            can choose to directly pass a flattened representation of an image.
        labels (`list[Dict]` of len `(batch_size,)`, *optional*):
            Labels for computing the bipartite matching loss. List of dicts, each dictionary containing at least the
            following 2 keys: 'class_labels' and 'boxes' (the class labels and bounding boxes of an image in the batch
            respectively). The class labels themselves should be a `torch.LongTensor` of len `(number of bounding boxes
            in the image,)` and the boxes a `torch.FloatTensor` of shape `(number of bounding boxes in the image, 4)`.

        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, Deimv2Model
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> image_processor = AutoImageProcessor.from_pretrained("PekingU/Deimv2_r50vd")
        >>> model = Deimv2Model.from_pretrained("PekingU/Deimv2_r50vd")

        >>> inputs = image_processor(images=image, return_tensors="pt")

        >>> outputs = model(**inputs)

        >>> last_hidden_states = outputs.last_hidden_state
        >>> list(last_hidden_states.shape)
        [1, 300, 256]
        ```Nz8You have to specify either pixel_values or inputs_embedsr¶   r   rW   rV   )r·   rZ   r°   r   )r   )rÐ  rÑ  rÒ   rî  rÒ  rÓ  rÔ  rÀ  r‚   )rƒ   Úindex)rd  r8   rÝ  r  r  r  r´  r   r    r!   r"   r#   r$   r5   r6   r'   r7   r8   r9   r:   r;   r<   r=   r>   r?   r0   )Ar   rd   r·   r,   rO   rñ  rò  r¢   rC   rÉ   rü  rk   rë   r(  ró   ÚemptyÚlongr¼   rÈ   r„   Ú	new_zerosÚprodÚcumsumrN  r  rê  rð  rÒ   rê  rÓ  rÔ  rZ   r÷  r/   rø  rù  rú  r[   rõ  rÿ  rö  rÏ  r€  rû  ÚgatherrÆ   rÇ   rý   r…   rË   r   ré  rü  r³  rý  r4   r   r    r!   r"   r#   r$   r%   r&   r'   ))rR   r¼  r  r  rd  r  rú   rÏ   Únum_channelsrÕ   rÖ   r·   Ú
proj_featsÚsourcesr  Úsourcer£   Úsource_flattenr  r  r´  Údenoising_classÚdenoising_bbox_unactrù   r?   rZ   Úspatial_shapes_tuplerù  rú  ÚmemoryÚoutput_memoryr=   r>   rÐ   Útopk_indÚreference_points_unactr<   r;   Útargetr:   Údecoder_outputss)                                            r2   rb   zDeimv2Model.forwardû  sÐ  € ð\ Ð MÐ$9ÜÐWÓXÐXð Ð Ø6B×6HÑ6HÑ3ˆJ˜ f¨eØ!×(Ñ(ˆFØÐ!Ü"ŸZ™Z¨*°f¸eÐ)DÈfÔU�
ð ×*Ñ*¨<Ó8‰Jà&×,Ñ,¨QÑ/ˆJØ"×)Ñ)ˆFØ&ˆJà&˜$Ÿ,™,Øñ
àñ
ˆð ˆÜ& ×'CÑ'CÓDò 	C‰MˆE�6Ø�N‰NÐ9˜4×2Ñ2°5Ñ9¸&ÓAÕBð	Cð �;‰;×)Ñ)¬C°«LÒ8Ø�N‰NÐ@˜4×2Ñ2´3°w³<Ñ@À×A]ÑA]Ð^`ÑAaÓbÔcÜœ3˜w›<¨¯©×)GÑ)GÓHò ]�Ø—‘Ð9˜t×6Ñ6°qÑ9¸/×:VÑ:VÐWYÑ:ZÓ[Õ\ð]ð ˆØ ÐÜŸ™¤c¨'£l°AÐ%6¸vÌUÏZÉZÔXˆÜ& wÓ/ò 	*‰MˆE�6Ø"ŸL™L¨¨Ð-‰MˆF�EØ'-ˆN˜5 !˜8Ñ$Ø',ˆN˜5 !˜8Ñ$Ø×&Ñ&¨° Ô7Ø—^‘^ AÓ&×0Ñ0°°AÓ6ˆFØ×!Ñ! &Õ)ð	*ô Ÿ™ >°1Ó5ˆÜ!ŸI™I ~×'?Ñ'?ÀÓ'EÀ~×GZÑGZÐ[\ÓG]×GdÑGdÐefÓGgÐhkÐikÐGlÐ&mÓnÐð �=Š=˜TŸ[™[×6Ñ6¸Ò:¸vÐ?Qô 9ØØ ŸK™K×2Ñ2Ø ŸK™K×3Ñ3Ø ×6Ñ6Ø&*§k¡k×&?Ñ&?Ø"&§+¡+×"?Ñ"?Ø $§¡× ;Ñ ;ôñØØ$ØÙ%ð \rÑXˆOÐ1°>ÐCXä˜Ó(ˆ
Ø×&Ñ&ˆØ×$Ñ$ˆð �=Š=˜DŸK™K×9Ñ9ÐAô $)Ð)<Ó#=Ð Ø"&×"7Ñ"7Ð8LÐU[ÐchÐ"7Ó"iÑˆG‘Zà"&§,¡,°·±�ZˆGØ")§*¡*¨V°UÓ";¸Z¿]¹]È6ÐSXÓ=Y�ZˆGð —‘˜~×3Ñ3Ó4°~ÑEˆàŸ™¨Ó/ˆà ×/Ñ/°Ó>ÐØ#'×#5Ñ#5°mÓ#DÀwÑ#NÐ ä—j‘jÐ!2×!6Ñ!6°rÓ!:×!AÑ!AÀ4Ç;Á;×CZÑCZÐ`aÔb‰ˆˆ8à!9×!@Ñ!@Ø˜×+Ñ+¨BÓ/×6Ñ6°q¸!Ð=U×=[Ñ=[Ð\^Ñ=_Ó`ð "Aó "
Ðô Ÿ)™)Ð$:Ó;ˆØÐ+Ü%*§\¡\Ð3GÐI_Ð2`ÐbcÓ%dÐ"à+×2Ñ2Ø˜×+Ñ+¨BÓ/×6Ñ6°q¸!Ð=N×=TÑ=TÐUWÑ=XÓYð 3ó 
ˆð
 �;‰;×*Ò*Ø×*Ñ*×/Ñ/°¸QÀÐ0BÓC‰Fà"×)Ñ)¨a°x×7IÑ7IÈ"Ó7M×7TÑ7TÐUVÐXYÐ[h×[nÑ[nÐoqÑ[rÓ7sÐ)ÓtˆFØ—]‘]“_ˆFàÐ&Ü—\‘\ ?°FÐ";¸QÓ?ˆFà 6× =Ñ =Ó ?Ðð '˜$Ÿ,™,ð 	
Ø Ø"0Ø#1Ø2Ø)Ø 3Ø/ñ	
ð ñ	
ˆô !ò 
Ø-×?Ò?ð
à'6×'QÒ'Qð
ð !0× CÒ Cð
ð +:×*WÒ*Wð	
ð
 ,;×+YÒ+Yð
ð &5×%MÒ%Mð
ð #2×"?Ò"?ð
ð  /×9Ò9ð
ð -×=Ò=ð
ð '6×&BÒ&Bð
ð #2×"?Ò"?ð
ð  /×9Ò9ð
ñ #8ð
ñ ,ð
ñ ,ð
ñ  0ð!
ñ" &>ð#
ñ$ #8ð%
ð 	
r1   rÀ  )r(   r)   r*   r   rL   r  r  r¥  r   r,   r\   r/   r‹   rf   r·   r¦   rZ   r   r  rø  r   r   r-   Ú
LongTensorrD   r@   r   r   r4   rb   rg   rh   s   @r2   rþ  rþ  ˜  s|  ø„ ð-˜|õ -ò^(ò'ð Ù(°Ô4ð &+Ø"Ÿ]™]ñ	#Ø˜e C¨ H™o¨sÐ2Ñ3ð#àð#ð —‘˜sÑ"ð#ð �{‰{ð	#ð
 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*ò#ó 5ó ð#ð8 /3¸dÈ5ÐX]×XeÑXeó Wð Øð /3Ø48Ø26Ø$(ñ~
à×'Ñ'ð~
ð ×$Ñ$ tÑ+ð~
ð ×*Ñ*¨TÑ1ð	~
ð
 ×(Ñ(¨4Ñ/ð~
ð �T‘
˜TÑ!ð~
ð Ð+Ñ,ð~
ð 
ˆu× Ñ Ñ	!Ð$5Ñ	5ò~
ó ó ô~
r1   rþ  z6
    Output type of [`Deimv2ForObjectDetection`].
    c                   ó˜  — e Zd ZU dZdZej                  dz  ed<   dZe	dz  ed<   dZ
ej                  dz  ed<   dZej                  dz  ed<   dZee	   dz  ed<   dZej                  dz  ed<   dZej                  dz  ed	<   dZej                  dz  ed
<   dZej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZeej                     dz  ed<   dZeej                     dz  ed<   dZeej                     dz  ed<   dZej                  dz  ed<   dZeej                     dz  ed<   dZeej                     dz  ed<   dZeej                     dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZej                  dz  ed<   dZ e	dz  ed<   y)ÚDeimv2ObjectDetectionOutputa  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` are provided)):
        Total loss as a linear combination of a negative log-likelihood (cross-entropy) for class prediction and a
        bounding box loss. The latter is defined as a linear combination of the L1 loss and the generalized
        scale-invariant IoU loss.
    loss_dict (`Dict`, *optional*):
        A dictionary containing the individual losses. Useful for logging.
    logits (`torch.FloatTensor` of shape `(batch_size, num_queries, num_classes + 1)`):
        Classification logits (including no-object) for all queries.
    pred_boxes (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`):
        Normalized boxes coordinates for all queries, represented as (center_x, center_y, width, height). These
        values are normalized in [0, 1], relative to the size of each individual image in the batch (disregarding
        possible padding). You can use [`~Deimv2ImageProcessor.post_process_object_detection`] to retrieve the
        unnormalized (absolute) bounding boxes.
    auxiliary_outputs (`list[Dict]`, *optional*):
        Optional, only returned when auxiliary losses are activated (i.e. `config.auxiliary_loss` is set to `True`)
        and labels are provided. It is a list of dictionaries containing the two above keys (`logits` and
        `pred_boxes`) for each decoder layer.
    last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`):
        Sequence of hidden-states at the output of the last layer of the decoder of the model.
    intermediate_hidden_states (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, hidden_size)`):
        Stacked intermediate hidden states (output of each layer of the decoder).
    intermediate_logits (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, config.num_labels)`):
        Stacked intermediate logits (logits of each layer of the decoder).
    intermediate_reference_points (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, 4)`):
        Stacked intermediate reference points (reference points of each layer of the decoder).
    intermediate_predicted_corners (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, 4)`):
        Stacked intermediate predicted corners (predicted corners of each layer of the decoder).
    initial_reference_points (`torch.FloatTensor` of shape `(batch_size, config.decoder_layers, num_queries, 4)`):
        Stacked initial reference points (initial reference points of each layer of the decoder).
    init_reference_points (`torch.FloatTensor` of shape  `(batch_size, num_queries, 4)`):
        Initial reference points sent through the Transformer decoder.
    enc_topk_logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_labels)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
        Logits of predicted bounding boxes coordinates in the encoder.
    enc_topk_bboxes (`torch.FloatTensor` of shape `(batch_size, sequence_length, 4)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
        Logits of predicted bounding boxes coordinates in the encoder.
    enc_outputs_class (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_labels)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
        Predicted bounding boxes scores where the top `config.two_stage_num_proposals` scoring bounding boxes are
        picked as region proposals in the first stage. Output of bounding box binary classification (i.e.
        foreground and background).
    enc_outputs_coord_logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, 4)`, *optional*, returned when `config.with_box_refine=True` and `config.two_stage=True`):
        Logits of predicted bounding boxes coordinates in the first stage.
    denoising_meta_values (`dict`):
        Extra dictionary for the denoising related values
    NÚlossÚ	loss_dictÚlogitsÚ
pred_boxesÚauxiliary_outputsr   r    r!   r"   r#   r$   r5   r6   r'   r7   r8   r9   r:   r;   r<   r=   r>   r?   )!r(   r)   r*   r+   r3  r,   r-   r.   r4  r@   r5  r6  r7  rD   r   r    r!   r"   r#   r$   r5   r/   r6   r'   r7   r8   r9   r:   r;   r<   r=   r>   r?   r0   r1   r2   r2  r2  ¾  s  … ñ,ð\ &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø!€Iˆt�d‰{Ó!Ø'+€FˆE×Ñ Ñ$Ó+Ø+/€J�×!Ñ! DÑ(Ó/Ø+/Ð�t˜D‘z DÑ(Ó/Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø;?Ð × 1Ñ 1°DÑ 8Ó?Ø48Ð˜×*Ñ*¨TÑ1Ó8Ø>BÐ! 5×#4Ñ#4°tÑ#;ÓBØ?CÐ" E×$5Ñ$5¸Ñ$<ÓCØ9=Ð˜e×/Ñ/°$Ñ6Ó=Ø=AÐ˜5 ×!2Ñ!2Ñ3°dÑ:ÓAØ:>Ð˜˜e×/Ñ/Ñ0°4Ñ7Ó>Ø8<Ð�e˜E×-Ñ-Ñ.°Ñ5Ó<Ø:>Ð˜u×0Ñ0°4Ñ7Ó>Ø=AÐ˜5 ×!2Ñ!2Ñ3°dÑ:ÓAØ:>Ð˜˜e×/Ñ/Ñ0°4Ñ7Ó>Ø=AÐ˜5 ×!2Ñ!2Ñ3°dÑ:ÓAØ04€O�U×&Ñ&¨Ñ-Ó4Ø04€O�U×&Ñ&¨Ñ-Ó4Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø9=Ð˜e×/Ñ/°$Ñ6Ó=Ø)-Ð˜4 $™;Ô-r1   r2  zž
    RT-DETR Model (consisting of a backbone and encoder-decoder) outputting bounding boxes and logits to be further
    decoded into scores and classes.
    c                   ó"  ‡ — e Zd ZdZdddddœZdefˆ fd„Zd	„ Zee		 	 	 	 dd
e
j                  de
j                  dz  de
j                  dz  de
j                  dz  dee   dz  dee   dee
j                     ez  fd„«       «       Zed„ «       Zˆ xZS )rì  Núbbox_embed.0ú^class_embed.0úmodel.decoder.class_embedúmodel.decoder.bbox_embed)úbbox_embed.(?![0])\d+úclass_embed.(?![0])\d+rî  rö  rk   c                 óÌ  •— t         ‰| �  |«       |j                  dk\  r|j                  n|j                  |j                  z   | _        t	        |«      | _        t        |j                  |j                  z  «      }|j                  }t        j                  t        |«      D �cg c],  }t        j                  |j                  |j                  «      ‘Œ. c}«      | _        |j                   rQt#        |j                  |j                  d|j$                  dz   z  d«      }t        j                  |g|z  «      | _        n¾t        j                  t        | j                  dz   «      D �cg c]4  }t#        |j                  |j                  d|j$                  dz   z  d«      ‘Œ6 c}t        |j                  | j                  z
  dz
  «      D �cg c]   }t#        ||d|j$                  dz   z  d«      ‘Œ" c}z   «      | _        | j                  | j
                  j(                  _        | j&                  | j
                  j(                  _        | j+                  «        y c c}w c c}w c c}w )Nr   r¯   r   r   )rK   rL   r©  rª  rþ  r+  r4  r­  rS   rM   r™   ró   rp   rq   rð  rî  Úshare_bbox_headr�   rÁ  rö  rý  r7  )rR   rk   Ú
scaled_dimÚnum_predrÐ   Úshared_bboxrT   s         €r2   rL   z!Deimv2ForObjectDetection.__init__  sð  ø€ Ü‰Ñ˜Ô à+1¯?©?¸aÒ+?˜ŸšÀV×EZÑEZÐ]c×]lÑ]lÑElˆŒÜ  Ó(ˆŒ
Ü˜6×-Ñ-°×0BÑ0BÑBÓCˆ
Ø×(Ñ(ˆÜŸ=™=Ô`eÐfnÓ`oÖ)pÐ[\¬"¯)©)°F·N±NÀF×DUÑDUÕ*VÒ)pÓqˆÔØ×!Ò!Ü# F×$6Ñ$6¸×8JÑ8JÈAÐQW×QdÑQdÐghÑQhÑLiÐklÓmˆKÜ Ÿm™m¨[¨M¸HÑ,DÓEˆD�Oä Ÿm™mô # 4§=¡=°1Ñ#4Ó5öàô ˜f×0Ñ0°&×2DÑ2DÀaÈ6×K^ÑK^ÐabÑKbÑFcÐefÕgòô # 6×#8Ñ#8¸4¿=¹=Ñ#HÈ1Ñ#LÓMöàô ˜j¨*°a¸6×;NÑ;NÐQRÑ;RÑ6SÐUVÕWòñ	ó	ˆDŒOð *.×)9Ñ)9ˆ�
‰
×ÑÔ&Ø(,¯©ˆ�
‰
×ÑÔ%Ø�‰Õùò% *qùòùòs   Â$1IÅ'9IÇ	%I!
c                 óR   — t        ||«      D ��cg c]
  \  }}||dœ‘Œ c}}S c c}}w )N)r5  r6  )rš   )rR   Úoutputs_classÚoutputs_coordÚaÚbs        r2   Ú_set_aux_lossz&Deimv2ForObjectDetection._set_aux_loss6  s&   € Ü;>¸}ÈmÓ;\×]±4°1°a˜1¨AÓ.Ó]Ð]ùÓ]s   �#r¼  r  r  rd  r  rú   rI   c           	      ó   —  | j                   |f||||dœ|¤Ž}| j                  r|j                  nd}|j                  }	|j                  }
|j
                  }|j                  }|	dd…df   }|
dd…df   }d\  }}}}}|�O|j                  }|j                  } | j                  ||| j                  || j                  |	|
f|||||dœ|¤Ž\  }}}t        di d|“d|“d|“d	|“d
|“d|j                  “d|j                  “d|j                  “d|j                  “d|j
                  “d|j                  “d|j                  “d|j                   “d|j"                  “d|j$                  “d|j&                  “d|j(                  “d|j*                  “d|j                  “d|j                  “d|j,                  “d|j.                  “d|j                  “ŽS )aW  
        Example:

        ```python
        >>> import torch
        >>> from transformers.image_utils import load_image
        >>> from transformers import AutoImageProcessor, Deimv2ForObjectDetection

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = load_image(url)

        >>> image_processor = AutoImageProcessor.from_pretrained("harshaljanjani/DEIMv2_HGNetv2_N_COCO_Transformers")
        >>> model = Deimv2ForObjectDetection.from_pretrained("harshaljanjani/DEIMv2_HGNetv2_N_COCO_Transformers")

        >>> # prepare image for the model
        >>> inputs = image_processor(images=image, return_tensors="pt")

        >>> # forward pass
        >>> outputs = model(**inputs)

        >>> logits = outputs.logits
        >>> list(logits.shape)
        [1, 300, 80]

        >>> boxes = outputs.pred_boxes
        >>> list(boxes.shape)
        [1, 300, 4]

        >>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
        >>> target_sizes = torch.tensor([image.size[::-1]])
        >>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)
        >>> result = results[0]  # first image in batch

        >>> for score, label, box in zip(result["scores"], result["labels"], result["boxes"]):
        ...     box = [round(i, 2) for i in box.tolist()]
        ...     print(
        ...         f"Detected {model.config.id2label[label.item()]} with confidence "
        ...         f"{round(score.item(), 3)} at location {box}"
        ...     )
        ```
        )r  r  rd  r  NrW   r  )r;   r<   r?   Úpredicted_cornersr$   r3  r4  r5  r6  r7  r   r    r!   r"   r#   r$   r5   r6   r'   r7   r8   r9   r:   r;   r<   r=   r>   r?   r0   )r+  rN  r?   r!   r"   r#   r$   r;   r<   Úloss_functionr·   rk   r2  r   r    r5   r6   r'   r7   r8   r9   r:   r=   r>   )rR   r¼  r  r  rd  r  rú   rQ  r?   rE  rF  rK  r$   r5  r6  r3  r4  r7  r;   r<   s                       r2   rb   z Deimv2ForObjectDetection.forward9  sw  € ðh �$—*‘*Øð
à!Ø+Ø'Øñ
ð ñ
ˆð BFÇÂ × =Ò =ÐTXÐà×3Ñ3ˆØ×=Ñ=ˆØ#×BÑBÐØ#*×#CÑ#CÐ àšq "˜uÑ%ˆØ"¢1 b 5Ñ)ˆ
àOkÑLˆˆiÐ*¨O¸_ØÐØ%×5Ñ5ˆOØ%×5Ñ5ˆOØ1C°×1CÑ1CØØØ—‘ØØ—‘ØØð2ð !0Ø /Ø&;Ø"3Ø)Añ2ð ñ2Ñ.ˆD�)Ð.ô  +ò 
Ùð
áð
ñ ð
ñ "ð	
ñ
 0ð
ð &×7Ò7ð
ð (/×'IÒ'Ið
ð !(× ;Ò ;ð
ð +2×*OÒ*Oð
ð ,3×+QÒ+Qð
ð &-×%EÒ%Eð
ð #*×"?Ò"?ð
ð  '×9Ò9ð
ð %×5Ò5ð
ð '.×&GÒ&Gð
ð  #*×"?Ò"?ð!
ð"  '×9Ò9ð#
ð$ #*×"?Ò"?ð%
ð& $×3Ò3ð'
ð( $×3Ò3ð)
ð* &×7Ò7ð+
ð, &-×%EÒ%Eð-
ð. #*×"?Ò"?ð/
ð 	
r1   c                 óR   — ddddœ}| j                   j                  r
d|d<   d|d<   |S )	Nr:  r;  r<  )r>  rî  rö  zmodel.decoder.bbox_embed.0z&model\.decoder\.bbox_embed\.(?![0])\d+r9  r=  )rk   r@  )rR   Úkeyss     r2   Ú_tied_weights_keysz+Deimv2ForObjectDetection._tied_weights_keys®  s>   € ð (9Ø6Ø4ñ
ˆð
 �;‰;×&Ò&Ø>[ˆDÐ:Ñ;Ø-<ˆDÐ)Ñ*Øˆr1   rÀ  )r(   r)   r*   r	  rO  r   rL   rI  r   r   r,   r-   r0  rD   r@   r   r   r/   r2  rb   Úpropertyrg   rh   s   @r2   rì  rì    s  ø„ ð Ðà"1Ø#4Ø2Ø0ñ	Ðð˜|õ ò6^ð Øð /3Ø48Ø26Ø$(ñq
à×'Ñ'ðq
ð ×$Ñ$ tÑ+ðq
ð ×*Ñ*¨TÑ1ð	q
ð
 ×(Ñ(¨4Ñ/ðq
ð �T‘
˜TÑ!ðq
ð Ð+Ñ,ðq
ð 
ˆu× Ñ Ñ	!Ð$?Ñ	?òq
ó ó ðq
ðf ñ	ó ô	r1   rì  )rþ  rà  rì  )r­   )Nra  )rÊ   )r   )éd   r¸   r.  )`rñ  Úcollections.abcr   Údataclassesr   r,   Útorch.nnrM   Útorch.nn.functionalr¿   rý   r   Ú r   ró  Úactivationsr   Úbackbone_utilsr	   Úimage_transformsr
   r   Úintegrationsr   Úmodeling_outputsr   Úmodeling_utilsr   r   Úprocessing_utilsr   Úpytorch_utilsr   Úutilsr   r   r   r   Úutils.genericr   r   Úutils.output_capturingr   r   Úconfiguration_deimv2r   r   r4   rB   ÚModulerG   rj   r|   r�   rD   r‹   rã   rå   r	  r  r#  r0  rA  rf   rS  rU  rm  r\   rk  r·   rZ   rš  rœ  r§  r°  r¿  rÇ  rÖ  rà  r  r*  r/  r?  rä  r¦   rs  rã  r”  rœ  r¥  rí  rê  rþ  r2  rì  Ú__all__r0   r1   r2   ú<module>re     s  ðó* Ý $Ý !ã Ý ß Ð Ý å &Ý "Ý +ß RÝ 7Ý +ß FÝ &Ý @ß ZÓ Zß Iß EÝ .ñ ðôð ô=˜+ó =ó óð=ñ: ðôð
 ô1.˜ó 1.ó óð1.ñh ðôð ô<˜+ó <ó óð<ñ ˜YÓ'ôJ�B—I‘Ió Jó (ðJô(�b—i‘iô ô�—‘ô ô�—	‘	ô ð, ñG/ØðG/à ðG/ð ðG/ð ð	G/ð
 ˜#‘YðG/ð óG/ôTY)¨"¯)©)ô Y)ôx˜"Ÿ)™)ô ô@"˜Ÿ	™	ô "ô&4˜Ÿ	™	ô 4ô<0˜Ÿ™ô 0ô<�2—9‘9ô ð2 !Øñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð �T‰\ð%ð ð%ð Ð'Ñ(ó%ô8?)˜"Ÿ)™)ô ?)ôDD˜Ÿ™ô DðT Ø ØØ"&ØŸ™ñ-Øð-àð-ð ð-ð ð	-ð
 ð-ð �L‰L˜4Ñð-ð �;‰;ð-ð ‡\�\ó-ô`# "§)¡)ô #ôL6�b—i‘iô 6ôrA §¡ô Aô&�R—Y‘Yô ô2�—	‘	ô ô"Z˜Ÿ™ô Zðz ôP5˜Oó P5ó ðP5ôf$ ˜bŸi™iô $ òN'ô2UÐ-ô Uô8+Ð3ô +ô\09Ð-ô 09ñf< U§\¡\ð <À%Ç,Á,ð <ÐY\ð <Ðin×iuÑiuó <ôXBÐ/ô XBóvð Sð ¨e¯l©lð Àsð ÈuÏ|É|ó ð0, E§L¡Lð ,¸Uð ,ÀuÇ|Á|ó ,ô2Y
Ð)ô Y
ðB ØØóxQñv ðôô
^
Ð'ó ^
óð
^
ñB	 ðôð
 ôE. +ó E.ó óðE.ñP ðôôfÐ4ó fóðfòR O�r1   