Ë
    T^(h]‰  ã            	       óT  — d Z ddlZddlZddlmZmZmZmZm	Z	 ddl
Z
ddl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mZmZmZ dd
lmZ ddlmZ  ej:                  e«      ZdZ  G d„ dejB                  «      Z"e
jF                  jH                  d„ «       Z%d„ Z& G d„ dejB                  «      Z'd4de
jP                  de)de*de
jP                  fd„Z+ G d„ dejB                  «      Z, G d„ dejB                  «      Z- G d„ dejB                  «      Z. G d„ d ejB                  «      Z/d!„ Z0d"„ Z1 G d#„ d$ejB                  «      Z2 G d%„ d&ejB                  «      Z3d'ejB                  ddfd(„Z4 G d)„ d*e«      Z5d+Z6d,Z7 ed-e6«       G d.„ d/e5«      «       Z8 ed0e6«       G d1„ d2e5e«      «       Z9g d3¢Z:y)5zPyTorch ViTDet backbone.é    N)ÚDictÚListÚOptionalÚTupleÚUnion)Únné   )ÚACT2FN)ÚBackboneOutputÚBaseModelOutput)ÚPreTrainedModel)Úadd_start_docstringsÚ%add_start_docstrings_to_model_forwardÚloggingÚreplace_return_docstrings)ÚBackboneMixiné   )ÚVitDetConfigr   c                   ó`   ‡ — e Zd ZdZˆ fd„Zd„ Zdej                  dej                  fd„Zˆ xZ	S )ÚVitDetEmbeddingsz·
    This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
    `hidden_states` (patch embeddings) to be consumed by a Transformer.
    c                 óp  •— t         ‰| �  «        |j                  |j                  }}|j                  |j
                  }}t        |t        j                  j                  «      r|n||f}t        |t        j                  j                  «      r|n||f}|d   |d   z  |d   |d   z  z  }|| _
        || _        || _        || _        |j                  r?|dz   }t        j                  t        j                   d||j
                  «      «      | _        nd | _        t        j$                  ||||¬«      | _        y )Nr   r   )Úkernel_sizeÚstride)ÚsuperÚ__init__Úpretrain_image_sizeÚ
patch_sizeÚnum_channelsÚhidden_sizeÚ
isinstanceÚcollectionsÚabcÚIterableÚ
image_sizeÚnum_patchesÚ use_absolute_position_embeddingsr   Ú	ParameterÚtorchÚzerosÚposition_embeddingsÚConv2dÚ
projection)	ÚselfÚconfigr$   r   r   r   r%   Únum_positionsÚ	__class__s	           €úh/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/transformers/models/vitdet/modeling_vitdet.pyr   zVitDetEmbeddings.__init__2   s  ø€ Ü‰ÑÔØ!'×!;Ñ!;¸V×=NÑ=N�Jˆ
Ø$*×$7Ñ$7¸×9KÑ9K�kˆä#-¨j¼+¿/¹/×:RÑ:RÔ#S‘ZÐZdÐfpÐYqˆ
Ü#-¨j¼+¿/¹/×:RÑ:RÔ#S‘ZÐZdÐfpÐYqˆ
Ø! !‘}¨
°1©Ñ5¸*ÀQ¹-È:ÐVWÉ=Ñ:XÑYˆØ$ˆŒØ$ˆŒØ(ˆÔØ&ˆÔà×2Ò2à'¨!™OˆMÜ')§|¡|´E·K±KÀÀ=ÐRX×RdÑRdÓ4eÓ'fˆDÕ$à'+ˆDÔ$äŸ)™) L°+È:Ð^hÔiˆ�ó    c                 óÎ  — |r|dd…dd…f   }|j                   d   }t        t        j                  |«      «      }||z  |k7  rt	        d«      ‚t
        j                  j                  «       s
||k7  s||k7  r]t        j                  j                  |j                  d||d«      j                  dddd«      ||fdd	¬
«      }|j                  dddd«      S |j                  d||d«      S )a¯  
        Calculate absolute positional embeddings. If needed, resize embeddings and remove cls_token dimension for the
        original embeddings.

        Args:
            abs_pos_embeddings (`torch.Tensor`):
                Absolute positional embeddings with (1, num_position, num_channels).
            has_cls_token (`bool`):
                If true, has 1 embedding in abs_pos_embeddings for cls token.
            height (`int`):
                Height of input image tokens.
            width (`int`):
                Width of input image tokens.

        Returns:
            Absolute positional embeddings after processing with shape (1, height, width, num_channels)
        Nr   z5Absolute position embeddings must be a square number.éÿÿÿÿr   r	   é   ÚbicubicF)ÚsizeÚmodeÚalign_corners)ÚshapeÚintÚmathÚsqrtÚ
ValueErrorr(   ÚjitÚ
is_tracingr   Ú
functionalÚinterpolateÚreshapeÚpermute)r-   Úabs_pos_embeddingsÚhas_cls_tokenÚheightÚwidthÚnum_positionr7   Únew_abs_pos_embeddingss           r1   Úget_absolute_positionsz'VitDetEmbeddings.get_absolute_positionsH   së   € ñ$ Ø!3²A°q±r°EÑ!:ÐØ)×/Ñ/°Ñ2ˆÜ”4—9‘9˜\Ó*Ó+ˆØ�$‰;˜,Ò&ÜÐTÓUÐUä�9‰9×ÑÔ! d¨f¢n¸Àºä%'§]¡]×%>Ñ%>Ø"×*Ñ*¨1¨d°D¸"Ó=×EÑEÀaÈÈAÈqÓQØ˜e�_ØØ#ð	 &?ó &Ð"ð *×1Ñ1°!°Q¸¸1Ó=Ð=à%×-Ñ-¨a°¸ÀÓCÐCr2   Úpixel_valuesÚreturnc                 óz  — |j                   d   }|| j                  k7  rt        d| j                  › d|› d�«      ‚| j                  |«      }| j                  �c|j                  dddd«      }|| j                  | j                  d|j                   d   |j                   d   «      z   }|j                  dddd«      }|S )	Nr   zoMake sure that the channel dimension of the pixel values match with the one set in the configuration. Expected z	 but got ú.r   r5   r	   T)r:   r   r>   r,   r*   rD   rK   )r-   rL   r   Ú
embeddingss       r1   ÚforwardzVitDetEmbeddings.forwardn   sÙ   € Ø#×)Ñ)¨!Ñ,ˆØ˜4×,Ñ,Ò,ÜðØ!×.Ñ.Ð/¨y¸¸ÀaðIóð ð —_‘_ \Ó2ˆ
à×#Ñ#Ð/à#×+Ñ+¨A¨q°!°QÓ7ˆJà# d×&AÑ&AØ×(Ñ(¨$°
×0@Ñ0@ÀÑ0CÀZ×EUÑEUÐVWÑEXó'ñ ˆJð $×+Ñ+¨A¨q°!°QÓ7ˆJàÐr2   )
Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   rK   r(   ÚTensorrQ   Ú__classcell__©r0   s   @r1   r   r   ,   s0   ø„ ñô
jò,$DðL E§L¡Lð °U·\±\÷ r2   r   c                 óT  — t        dt        | |«      z  dz
  «      }|j                  d   |k7  rtt        j                  j                  |j                  d|j                  d   d«      j                  ddd«      |d¬«      }|j                  d|«      j                  dd«      }n|}t        j                  | «      dd…df   t        || z  d«      z  }t        j                  |«      ddd…f   t        | |z  d«      z  }||z
  |dz
  t        | |z  d«      z  z   }||j                  «          S )	a�  
    Get relative positional embeddings according to the relative positions of query and key sizes.

    Args:
        q_size (`int`):
            Size of query q.
        k_size (`int`):
            Size of key k.
        rel_pos (`torch.Tensor`):
            Relative position embeddings (num_embeddings, num_channels).

    Returns:
        Extracted positional embeddings according to relative positions.
    r5   r   r   r4   Úlinear)r7   r8   Nç      ð?)r;   Úmaxr:   r   rA   rB   rC   rD   r(   ÚarangeÚlong)Úq_sizeÚk_sizeÚrel_posÚmax_rel_distÚrel_pos_resizedÚq_coordsÚk_coordsÚrelative_coordss           r1   Úget_rel_posrg   „   s%  € ô  �qœ3˜v vÓ.Ñ.°Ñ2Ó3€Là‡}�}�QÑ˜<Ò'äŸ-™-×3Ñ3Ø�O‰O˜A˜wŸ}™}¨QÑ/°Ó4×<Ñ<¸QÀÀ1ÓEØØð 4ó 
ˆð
 *×1Ñ1°"°lÓC×KÑKÈAÈqÓQ‰à!ˆô �|‰|˜FÓ#¢A t GÑ,¬s°6¸F±?ÀCÓ/HÑH€HÜ�|‰|˜FÓ# Dª! GÑ,¬s°6¸F±?ÀCÓ/HÑH€HØ (Ñ*¨v¸©z¼SÀÈ&ÁÐRUÓ=VÑ.VÑV€Oà˜?×/Ñ/Ó1Ñ2Ð2r2   c                 ó–  — |\  }}|\  }}	t        |||«      }
t        ||	|«      }|j                  \  }}}|j                  ||||«      }t        j                  d||
«      }
t        j                  d||«      }| j                  |||||	«      |
dd…dd…dd…dd…df   z   |dd…dd…dd…ddd…f   z   j                  |||z  ||	z  «      } | S )aÀ  
    Calculate decomposed Relative Positional Embeddings as introduced in
    [MViT2](https://github.com/facebookresearch/mvit/blob/19786631e330df9f3622e5402b4a419a263a2c80/mvit/models/attention.py).

    Args:
        attn (`torch.Tensor`):
            Attention map.
        queries (`torch.Tensor`):
            Query q in the attention layer with shape (batch_size, queries_height * queries_width, num_channels).
        rel_pos_h (`torch.Tensor`):
            Relative position embeddings (Lh, num_channels) for height axis.
        rel_pos_w (`torch.Tensor`):
            Relative position embeddings (Lw, num_channels) for width axis.
        q_size (`Tuple[int]`):
            Spatial sequence size of query q with (queries_height, queries_width).
        k_size (`Tuple[int]`):
            Spatial sequence size of key k with (keys_height, keys_width).

    Returns:
        attn (Tensor): attention map with added relative positional embeddings.
    zbhwc,hkc->bhwkzbhwc,wkc->bhwkN)rg   r:   rC   r(   ÚeinsumÚview)ÚattnÚqueriesÚ	rel_pos_hÚ	rel_pos_wr_   r`   Úqueries_heightÚqueries_widthÚkeys_heightÚ
keys_widthÚrelative_heightÚrelative_widthÚ
batch_sizeÚ_ÚdimÚr_qÚrelative_weights                    r1   Ú!add_decomposed_relative_positionsrz   ©   sê   € ð, %+Ñ!€N�MØ$Ñ€K�Ü! .°+¸yÓI€OÜ  °
¸IÓF€Nà Ÿ™Ñ€J��3Ø
�/‰/˜* n°mÀSÓ
I€CÜ—l‘lÐ#3°S¸/ÓJ€OÜ—l‘lÐ#3°S¸.ÓI€Oð 	�	‰	�*˜n¨m¸[È*ÓUØ
š!šQ¢¢1 dÐ*Ñ
+ñ	,à
š!šQ¢ 4ªÐ*Ñ
+ñ	,÷ �dˆ:�~¨Ñ5°{ÀZÑ7OÓPð	 	ð €Kr2   c                   ó,   ‡ — e Zd ZdZdˆ fd„	Zdd„Zˆ xZS )ÚVitDetAttentionz=Multi-head Attention block with relative position embeddings.c                 ó   •— t         ‰| �  «        |j                  }|j                  }|| _        ||z  }|dz  | _        t        j                  ||dz  |j                  ¬«      | _	        t        j                  ||«      | _
        |j                  | _        | j                  rot        j                  t        j                  d|d   z  dz
  |«      «      | _        t        j                  t        j                  d|d   z  dz
  |«      «      | _        yy)zô
        Args:
            config (`VitDetConfig`):
                Model configuration.
            input_size (`Tuple[int]`, *optional*):
                Input resolution, only required in case relative position embeddings are added.
        g      à¿r	   ©Úbiasr5   r   r   N)r   r   r   Únum_attention_headsÚ	num_headsÚscaler   ÚLinearÚqkv_biasÚqkvÚprojÚ use_relative_position_embeddingsr'   r(   r)   rm   rn   )r-   r.   Ú
input_sizerw   r�   Úhead_dimr0   s         €r1   r   zVitDetAttention.__init__Õ   sÞ   ø€ ô 	‰ÑÔà× Ñ ˆØ×.Ñ.ˆ	à"ˆŒØ˜)Ñ#ˆØ˜t‘^ˆŒ
ä—9‘9˜S #¨¡'°·±Ô@ˆŒÜ—I‘I˜c 3Ó'ˆŒ	à06×0WÑ0WˆÔ-Ø×0Ò0äŸ\™\¬%¯+©+°a¸*ÀQ¹-Ñ6GÈ!Ñ6KÈXÓ*VÓWˆDŒNÜŸ\™\¬%¯+©+°a¸*ÀQ¹-Ñ6GÈ!Ñ6KÈXÓ*VÓWˆD�Nð 1r2   c           	      ó0  — |j                   \  }}}}| j                  |«      j                  |||z  d| j                  d«      j	                  ddddd«      }|j                  d|| j                  z  ||z  d«      j                  d«      \  }}	}
|| j                  z  |	j                  dd«      z  }| j                  r(t        ||| j                  | j                  ||f||f«      }|j                  d¬«      }||
z  }|j                  || j                  ||d«      }|j	                  ddddd«      }|j                  |||d«      }| j                  |«      }|r>|j                  || j                  |j                   d   |j                   d   «      }||f}|S |f}|S )	Nr	   r4   r5   r   r   é   éþÿÿÿ)rw   )r:   r…   rC   r�   rD   Úunbindr‚   Ú	transposer‡   rz   rm   rn   Úsoftmaxrj   r†   )r-   Úhidden_stateÚoutput_attentionsru   rG   rH   rv   r…   rl   ÚkeysÚvaluesÚattention_scoresÚattention_probsÚoutputss                 r1   rQ   zVitDetAttention.forwardï   s²  € Ø'3×'9Ñ'9Ñ$ˆ
�F˜E 1à�h‰h�|Ó$×,Ñ,¨Z¸À%¹ÈÈDÏNÉNÐ\^Ó_×gÑgÐhiÐklÐnoÐqrÐtuÓvˆà #§¡¨A¨z¸D¿N¹NÑ/JÈFÐUZÉNÐ\^Ó _× fÑ fÐghÓ iÑˆ��và# d§j¡jÑ0°D·N±NÀ2ÀrÓ4JÑJÐà×0Ò0Ü@Ø  '¨4¯>©>¸4¿>¹>ÈFÐTYÈ?Ð]cÐejÐ\kó Ðð +×2Ñ2°rÐ2Ó:ˆà&¨Ñ/ˆØ#×(Ñ(¨°T·^±^ÀVÈUÐTVÓWˆØ#×+Ñ+¨A¨q°!°Q¸Ó:ˆØ#×+Ñ+¨J¸ÀÀrÓJˆØ—y‘y Ó.ˆáØ-×5Ñ5Ø˜DŸN™N¨O×,AÑ,AÀ"Ñ,EÀ×G\ÑG\Ð]_ÑG`óˆOð $ _Ð5ˆGð ˆð $�oˆGàˆr2   ©N)F©rR   rS   rT   rU   r   rQ   rW   rX   s   @r1   r|   r|   Ò   s   ø„ ÙGõX÷4r2   r|   ÚinputÚ	drop_probÚtrainingrM   c                 ó  — |dk(  s|s| S d|z
  }| j                   d   fd| j                  dz
  z  z   }|t        j                  || j                  | j
                  ¬«      z   }|j                  «        | j                  |«      |z  }|S )aF  
    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).

    Comment by Ross Wightman: This is the same as the DropConnect impl I created for EfficientNet, etc networks,
    however, the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper...
    See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for changing the
    layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use 'survival rate' as the
    argument.
    ç        r   r   )r   )ÚdtypeÚdevice)r:   Úndimr(   Úrandrž   rŸ   Úfloor_Údiv)r™   rš   r›   Ú	keep_probr:   Úrandom_tensorÚoutputs          r1   Ú	drop_pathr§     s�   € ð �CÒ™xØˆØ�I‘€IØ�[‰[˜‰^Ð ¨¯
©
°Q©Ñ 7Ñ7€EØ¤§
¡
¨5¸¿¹ÈEÏLÉLÔ YÑY€MØ×ÑÔØ�Y‰Y�yÓ! MÑ1€FØ€Mr2   c                   óx   ‡ — e Zd ZdZd	dee   ddfˆ fd„Zdej                  dej                  fd„Z	de
fd„Zˆ xZS )
ÚVitDetDropPathzXDrop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).Nrš   rM   c                 ó0   •— t         ‰| �  «        || _        y r—   )r   r   rš   )r-   rš   r0   s     €r1   r   zVitDetDropPath.__init__)  s   ø€ Ü‰ÑÔØ"ˆ�r2   Úhidden_statesc                 óD   — t        || j                  | j                  «      S r—   )r§   rš   r›   )r-   r«   s     r1   rQ   zVitDetDropPath.forward-  s   € Ü˜¨¯©¸¿¹ÓFÐFr2   c                 ó8   — dj                  | j                  «      S )Nzp={})Úformatrš   ©r-   s    r1   Ú
extra_reprzVitDetDropPath.extra_repr0  s   € Ø�}‰}˜TŸ^™^Ó,Ð,r2   r—   )rR   rS   rT   rU   r   Úfloatr   r(   rV   rQ   Ústrr°   rW   rX   s   @r1   r©   r©   &  sG   ø„ Ùbñ# (¨5¡/ð #¸Tõ #ðG U§\¡\ð G°e·l±ló Gð-˜C÷ -r2   r©   c                   ó*   ‡ — e Zd ZdZdˆ fd„	Zd„ Zˆ xZS )ÚVitDetLayerNormaL  
    A LayerNorm variant, popularized by Transformers, that performs point-wise mean and variance normalization over the
    channel dimension for inputs that have shape (batch_size, channels, height, width).
    https://github.com/facebookresearch/ConvNeXt/blob/d1fa8f6fef0a165b27399986cc2bdacc92777e40/models/convnext.py#L119
    c                 óô   •— t         ‰| �  «        t        j                  t	        j
                  |«      «      | _        t        j                  t	        j                  |«      «      | _        || _	        |f| _
        y r—   )r   r   r   r'   r(   ÚonesÚweightr)   r   ÚepsÚnormalized_shape)r-   r¹   r¸   r0   s      €r1   r   zVitDetLayerNorm.__init__;  sT   ø€ Ü‰ÑÔÜ—l‘l¤5§:¡:Ð.>Ó#?Ó@ˆŒÜ—L‘L¤§¡Ð-=Ó!>Ó?ˆŒ	ØˆŒØ!1Ð 3ˆÕr2   c                 ó  — |j                  dd¬«      }||z
  j                  d«      j                  dd¬«      }||z
  t        j                  || j                  z   «      z  }| j
                  d d …d d f   |z  | j                  d d …d d f   z   }|S )Nr   T)Úkeepdimr5   )ÚmeanÚpowr(   r=   r¸   r·   r   )r-   ÚxÚuÚss       r1   rQ   zVitDetLayerNorm.forwardB  s†   € Ø�F‰F�1˜dˆFÓ#ˆØ�‰U�K‰K˜‹N×Ñ ¨4ÐÓ0ˆØ�‰U”e—j‘j  T§X¡X¡Ó.Ñ.ˆØ�K‰Kš˜4 ˜Ñ&¨Ñ*¨T¯Y©Y²q¸$À°}Ñ-EÑEˆØˆr2   )g�íµ ÷Æ°>r˜   rX   s   @r1   r´   r´   4  s   ø„ ñõ4ör2   r´   c                   ó(   ‡ — e Zd ZdZˆ fd„Zd„ Zˆ xZS )ÚVitDetResBottleneckBlockz�
    The standard bottleneck residual block without the last activation layer. It contains 3 conv layers with kernels
    1x1, 3x3, 1x1.
    c                 ó˜  •— t         ‰| �  «        t        j                  ||dd¬«      | _        t        |«      | _        t        |j                     | _	        t        j                  ||ddd¬«      | _
        t        |«      | _        t        |j                     | _        t        j                  ||dd¬«      | _        t        |«      | _        y)ar  
        Args:
            config (`VitDetConfig`):
                Model configuration.
            in_channels (`int`):
                Number of input channels.
            out_channels (`int`):
                Number of output channels.
            bottleneck_channels (`int`):
                Number of output channels for the 3x3 "bottleneck" conv layers.
        r   Fr~   r	   )Úpaddingr   N)r   r   r   r+   Úconv1r´   Únorm1r
   Ú
hidden_actÚact1Úconv2Únorm2Úact2Úconv3Únorm3)r-   r.   Úin_channelsÚout_channelsÚbottleneck_channelsr0   s        €r1   r   z!VitDetResBottleneckBlock.__init__P  s¤   ø€ ô 	‰ÑÔÜ—Y‘Y˜{Ð,?ÀÈÔOˆŒ
Ü$Ð%8Ó9ˆŒ
Ü˜6×,Ñ,Ñ-ˆŒ	ä—Y‘YÐ2Ð4GÈÐTUÐ\aÔbˆŒ
Ü$Ð%8Ó9ˆŒ
Ü˜6×,Ñ,Ñ-ˆŒ	ä—Y‘YÐ2°LÀ!È%ÔPˆŒ
Ü$ \Ó2ˆ�
r2   c                 óN   — |}| j                  «       D ]
  } ||«      }Œ ||z   }|S r—   )Úchildren)r-   r¾   ÚoutÚlayers       r1   rQ   z VitDetResBottleneckBlock.forwardh  s5   € ØˆØ—]‘]“_ò 	ˆEÙ˜“*‰Cð	ð �#‰gˆØˆ
r2   r˜   rX   s   @r1   rÂ   rÂ   J  s   ø„ ñô
3ö0r2   rÂ   c                   ód   ‡ — e Zd Zdededdfˆ fd„Zdej                  dej                  fd„Zˆ xZS )Ú	VitDetMlpÚin_featuresÚhidden_featuresrM   Nc                 ó  •— t         ‰| �  «        t        j                  ||«      | _        t
        |j                     | _        t        j                  ||«      | _        t        j                  |j                  «      | _        y r—   )r   r   r   rƒ   Úfc1r
   rÇ   ÚactÚfc2ÚDropoutÚdropout_probÚdrop)r-   r.   r×   rØ   r0   s       €r1   r   zVitDetMlp.__init__r  sZ   ø€ Ü‰ÑÔÜ—9‘9˜[¨/Ó:ˆŒÜ˜&×+Ñ+Ñ,ˆŒÜ—9‘9˜_¨kÓ:ˆŒÜ—J‘J˜v×2Ñ2Ó3ˆ�	r2   r¾   c                 ó°   — | j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }|S r—   )rÚ   rÛ   rß   rÜ   )r-   r¾   s     r1   rQ   zVitDetMlp.forwardy  sH   € Ø�H‰H�Q‹KˆØ�H‰H�Q‹KˆØ�I‰I�a‹LˆØ�H‰H�Q‹KˆØ�I‰I�a‹Lˆàˆr2   )	rR   rS   rT   r;   r   r(   rV   rQ   rW   rX   s   @r1   rÖ   rÖ   q  s8   ø„ ð4¨Cð 4À#ð 4È$õ 4ð˜Ÿ™ð ¨%¯,©,÷ r2   rÖ   c           	      ó`  — | j                   \  }}}}|||z  z
  |z  }|||z  z
  |z  }t        j                  j                  | ddd|d|f«      } ||z   ||z   }	}| j	                  |||z  ||	|z  ||«      } | j                  dddddd«      j                  «       j	                  d|||«      }
|
||	ffS )a  
    Partition into non-overlapping windows with padding if needed.

    Args:
        hidden_state (`torch.Tensor`):
            Input tokens with [batch_size, height, width, num_channels].
        window_size (`int`):
            Window size.

    Returns:
        `tuple(torch.FloatTensor)` comprising various elements:
        - windows: windows after partition with [batch_size * num_windows, window_size, window_size, num_channels].
        - (padded_height, padded_width): padded height and width before partition
    r   r   r	   r5   r‹   é   r4   )r:   r   rA   Úpadrj   rD   Ú
contiguous)r�   Úwindow_sizeru   rG   rH   r   Ú
pad_heightÚ	pad_widthÚpadded_heightÚpadded_widthÚwindowss              r1   Úwindow_partitionrë   ƒ  sé   € ð /;×.@Ñ.@Ñ+€J�˜˜|à ¨Ñ 4Ñ4¸ÑC€JØ˜u {Ñ2Ñ2°kÑA€Iô —=‘=×$Ñ$ \°A°q¸!¸YÈÈ:Ð3VÓW€Là"(¨:Ñ"5°u¸yÑ7H�<€Mà×$Ñ$Ø�M [Ñ0°+¸|È{Ñ?ZÐ\gÐiuó€Lð ×"Ñ" 1 a¨¨A¨q°!Ó4×?Ñ?ÓA×FÑFÀrÈ;ÐXcÐeqÓr€GØ�] LÐ1Ð1Ð1r2   c                 ó6  — |\  }}|\  }}| j                   d   ||z  |z  |z  z  }| j                  |||z  ||z  ||d«      }	|	j                  dddddd«      j                  «       }	|	j                  |||d«      }	|	dd…d|…d|…dd…f   j                  «       }	|	S )	aB  
    Window unpartition into original sequences and removing padding.

    Args:
        windows (`torch.Tensor`):
            Input tokens with [batch_size * num_windows, window_size, window_size, num_channels].
        window_size (`int`):
            Window size.
        pad_height_width (`Tuple[int]`):
            Padded height and width (padded_height, padded_width).
        height_width (`Tuple[int]`):
            Original height and width before padding.

    Returns:
        hidden_state: unpartitioned sequences with [batch_size, height, width, num_channels].
    r   r4   r   r	   r5   r‹   râ   N)r:   rj   rD   rä   )
rê   rå   Úpad_height_widthÚheight_widthrè   ré   rG   rH   ru   r�   s
             r1   Úwindow_unpartitionrï   £  sÈ   € ð" #3Ñ€M�<Ø �M€FˆEØ—‘˜qÑ! m°lÑ&BÀkÑ&QÐU`Ñ&`Ña€JØ—<‘<Ø�M [Ñ0°,À+Ñ2MÈ{Ð\gÐikó€Lð  ×'Ñ'¨¨1¨a°°A°qÓ9×DÑDÓF€LØ×$Ñ$ Z°ÀÈbÓQ€Lð  ¢ 7 F 7¨F¨U¨F²AÐ 5Ñ6×AÑAÓC€LØÐr2   c                   óÞ   ‡ — e Zd ZdZ	 ddededededdf
ˆ fd„Z	 	 dd	e	j                  d
ee	j                     dedeee	j                  e	j                  f   ee	j                     f   fd„Zˆ xZS )ÚVitDetLayerzCThis corresponds to the Block class in the original implementation.r.   Údrop_path_raterå   Úuse_residual_blockrM   Nc                 óÜ  •— t         ‰	| �  «        |j                  }|j                  }t	        |t
        t        f«      r|n||f}|j                  }t	        |t
        t        f«      r|n||f}|d   |d   z  |d   |d   z  f}t        j                  ||j                  ¬«      | _        t        ||dk(  r|n||f¬«      | _        |dkD  rt        |«      nt        j                  «       | _        t        j                  ||j                  ¬«      | _        t%        ||t'        ||j(                  z  «      ¬«      | _        || _        || _        | j.                  rt1        ||||dz  ¬«      | _        y y )	Nr   r   )r¸   )rˆ   r�   )r.   r×   rØ   r5   )r.   rÎ   rÏ   rÐ   )r   r   r   r$   r    ÚlistÚtupler   r   Ú	LayerNormÚlayer_norm_epsrÆ   r|   Ú	attentionr©   ÚIdentityr§   rÊ   rÖ   r;   Ú	mlp_ratioÚmlprå   ró   rÂ   Úresidual)
r-   r.   rò   rå   ró   rw   r$   r   rˆ   r0   s
            €r1   r   zVitDetLayer.__init__Å  sX  ø€ ô 	‰ÑÔà× Ñ ˆà×&Ñ&ˆ
Ü#-¨j¼4Ä¸-Ô#H‘ZÈzÐ[eÐNfˆ
à×&Ñ&ˆ
Ü#-¨j¼4Ä¸-Ô#H‘ZÈzÐ[eÐNfˆ
à  ‘m z°!¡}Ñ4°jÀ±mÀzÐRSÁ}Ñ6TÐUˆ
Ü—\‘\ #¨6×+@Ñ+@ÔAˆŒ
Ü(Ø¨[¸AÒ-=™zÀKÐQ\ÐC]ô
ˆŒð <JÈCÒ;Oœ¨Ô7ÔUW×U`ÑU`ÓUbˆŒÜ—\‘\ #¨6×+@Ñ+@ÔAˆŒ
Ü F¸ÌSÐQTÐW]×WgÑWgÑQgÓMhÔiˆŒà&ˆÔà"4ˆÔØ×"Ò"ä4ØØØ Ø$'¨1¡Hô	ˆD�Mð #r2   r«   Ú	head_maskr‘   c                 óf  — |j                  dddd«      }|}| j                  |«      }| j                  dkD  r7|j                  d   |j                  d   }}t	        || j                  «      \  }}| j                  ||¬«      }|d   }|dd  }	| j                  dkD  rt        || j                  f«      }|| j                  |«      z   }|| j                  | j                  | j                  |«      «      «      z   }|j                  dddd«      }| j                  r| j                  |«      }|f|	z   }	|	S )Nr   r5   r	   r   )r‘   )rD   rÆ   rå   r:   rë   rù   rï   r§   rü   rÊ   ró   rý   )
r-   r«   rþ   r‘   ÚshortcutrG   rH   rí   Úself_attention_outputsr–   s
             r1   rQ   zVitDetLayer.forwardè  sM  € ð &×-Ñ-¨a°°A°qÓ9ˆà ˆàŸ
™
 =Ó1ˆð ×Ñ˜aÒØ)×/Ñ/°Ñ2°M×4GÑ4GÈÑ4J�EˆFÜ.>¸}Èd×N^ÑN^Ó._Ñ+ˆMÐ+à!%§¡ØØ/ð "0ó "
Ðð /¨qÑ1ˆØ(¨¨Ð,ˆð ×Ñ˜aÒÜ.¨}¸d×>NÑ>NÐP`ÐciÐkpÐbqÓrˆMð ! 4§>¡>°-Ó#@Ñ@ˆà%¨¯©°t·x±xÀÇ
Á
È=Ó@YÓ7ZÓ([Ñ[ˆà%×-Ñ-¨a°°A°qÓ9ˆà×"Ò"Ø ŸM™M¨-Ó8ˆMà Ð" WÑ,ˆàˆr2   )r   r   F)NF)rR   rS   rT   rU   r   r±   r;   Úboolr   r(   rV   r   r   r   rQ   rW   rX   s   @r1   rñ   rñ   Â  s    ø„ ÙMð qvñ!Ø"ð!Ø49ð!ØLOð!Øimð!à	õ!ðL -1Ø"'ñ	(à—|‘|ð(ð ˜EŸL™LÑ)ð(ð  ð	(ð
 
ˆu�U—\‘\ 5§<¡<Ð/Ñ0°%¸¿¹Ñ2EÐEÑ	F÷(r2   rñ   c                   óŠ   ‡ — e Zd Zdeddfˆ fd„Z	 	 	 	 ddej                  deej                     deded	ede	e
ef   fd
„Zˆ xZS )ÚVitDetEncoderr.   rM   Nc           
      ó¾  •— t         ‰| �  «        || _        |j                  }t	        j
                  d|j                  |«      D �cg c]  }|j                  «       ‘Œ }}g }t        |«      D ]I  }|j                  t        |||   ||j                  v r|j                  nd||j                  v ¬«      «       ŒK t        j                  |«      | _        d| _        y c c}w )Nr   )rò   rå   ró   F)r   r   r.   Únum_hidden_layersr(   Úlinspacerò   ÚitemÚrangeÚappendrñ   Úwindow_block_indicesrå   Úresidual_block_indicesr   Ú
ModuleListrÔ   Úgradient_checkpointing)r-   r.   Údepthr¾   rò   ÚlayersÚir0   s          €r1   r   zVitDetEncoder.__init__  sÍ   ø€ Ü‰ÑÔØˆŒØ×(Ñ(ˆô -2¯N©N¸1¸f×>SÑ>SÐUZÓ,[Ö\ q˜!Ÿ&™&�(Ð\ˆÐ\àˆÜ�u“ò 	ˆAØ�M‰MÜØØ#1°!Ñ#4Ø67¸6×;VÑ;VÑ6V × 2Ò 2Ð\]Ø'(¨F×,IÑ,IÐ'Iô	õð	ô —]‘] 6Ó*ˆŒ
Ø&+ˆÕ#ùò ]s   ÁCr«   rþ   r‘   Úoutput_hidden_statesÚreturn_dictc                 ót  — |rdnd }|rdnd }t        | j                  «      D ]h  \  }}	|r||fz   }|�||   nd }
| j                  r+| j                  r| j	                  |	j
                  ||
|«      }n
 |	||
|«      }|d   }|sŒ`||d   fz   }Œj |r||fz   }|st        d„ |||fD «       «      S t        |||¬«      S )N© r   r   c              3   ó&   K  — | ]	  }|€Œ|–— Œ y ­wr—   r  )Ú.0Úvs     r1   ú	<genexpr>z(VitDetEncoder.forward.<locals>.<genexpr>N  s   è ø€ Òm˜qÐ_`Ñ_lœÑmùs   ‚Š©Úlast_hidden_stater«   Ú
attentions)Ú	enumeraterÔ   r  r›   Ú_gradient_checkpointing_funcÚ__call__rö   r   )r-   r«   rþ   r‘   r  r  Úall_hidden_statesÚall_self_attentionsr  Úlayer_moduleÚlayer_head_maskÚlayer_outputss               r1   rQ   zVitDetEncoder.forward*  sÿ   € ñ #7™B¸DÐÙ$5™b¸4Ðä(¨¯©Ó4ò 	P‰OˆAˆ|Ù#Ø$5¸Ð8HÑ$HÐ!à.7Ð.C˜i¨šlÈˆOà×*Ò*¨t¯}ª}Ø $× AÑ AØ ×)Ñ)Ø!Ø#Ø%ó	!‘ñ !-¨]¸OÐM^Ó _�à)¨!Ñ,ˆMâ Ø&9¸]È1Ñ=MÐ<OÑ&OÑ#ð'	Pñ*  Ø 1°]Ð4DÑ DÐáÜÑm ]Ð4EÐGZÐ$[ÔmÓmÐmÜØ+Ø+Ø*ô
ð 	
r2   )NFFT)rR   rS   rT   r   r   r(   rV   r   r  r   rö   r   rQ   rW   rX   s   @r1   r  r    sz   ø„ ð,˜|ð ,°õ ,ð2 -1Ø"'Ø%*Ø ñ)
à—|‘|ð)
ð ˜EŸL™LÑ)ð)
ð  ð	)
ð
 #ð)
ð ð)
ð 
ˆu�oÐ%Ñ	&÷)
r2   r  Úmodulec                 óÊ   — t         j                  j                  | j                  dd¬«       | j                  �+t         j                  j                  | j                  d«       yy)a  
    Initialize `module.weight` using the "MSRAFill" implemented in Caffe2. Also initializes `module.bias` to 0.

    Source: https://detectron2.readthedocs.io/en/latest/_modules/fvcore/nn/weight_init.html.

    Args:
        module (torch.nn.Module): module to initialize.
    Úfan_outÚrelu)r8   ÚnonlinearityNr   )r   ÚinitÚkaiming_normal_r·   r   Ú	constant_)r%  s    r1   Úcaffe2_msra_fillr-  V  sH   € ô ‡G�G×Ñ˜FŸM™M°	ÈÐÔOØ‡{�{ÐÜ
�‰×Ñ˜&Ÿ+™+ qÕ)ð r2   c                   ó|   — e Zd ZdZeZdZdZdZg Z	de
ej                  ej                  ej                  f   ddfd„Zy)	ÚVitDetPreTrainedModelz†
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    ÚvitdetrL   Tr%  rM   Nc                 ó>  — t        |t        j                  t        j                  f«      rËt        j                  j                  |j                  j                  j                  t        j                  «      d| j                  j                  ¬«      j                  |j                  j                  «      |j                  _        |j                  �%|j                  j                  j                  «        yyt        |t        j                   «      rJ|j                  j                  j                  «        |j                  j                  j#                  d«       yt        |t$        «      ršt        j                  j                  |j&                  j                  j                  t        j                  «      d| j                  j                  ¬«      j                  |j&                  j                  «      |j&                  _        yt        |t(        «      �r| j                  j*                  rít        j                  j                  |j,                  j                  j                  t        j                  «      d| j                  j                  ¬«      |j,                  _        t        j                  j                  |j.                  j                  j                  t        j                  «      d| j                  j                  ¬«      |j.                  _        yt        |t0        «      rö|j2                  |j4                  |j6                  fD ]  }t9        |«       Œ |j:                  |j<                  fD ]K  }|j                  j                  j#                  d«       |j                  j                  j                  «        ŒM |j>                  j                  j                  j                  «        |j>                  j                  j                  j                  «        yy)zInitialize the weightsr�   )r¼   ÚstdNr[   ) r    r   rƒ   r+   r*  Útrunc_normal_r·   ÚdataÚtor(   Úfloat32r.   Úinitializer_rangerž   r   Úzero_r÷   Úfill_r   r*   r|   r‡   rm   rn   rÂ   rÅ   rÉ   rÌ   r-  rÆ   rÊ   rÍ   )r-   r%  rÔ   s      r1   Ú_init_weightsz#VitDetPreTrainedModel._init_weightsp  sÎ  € ä�fœrŸy™y¬"¯)©)Ð4Ô5ô "$§¡×!6Ñ!6Ø—‘×"Ñ"×%Ñ%¤e§m¡mÓ4¸3ÀDÇKÁK×DaÑDað "7ó "ç‰b�—‘×$Ñ$Ó%ð �M‰MÔð �{‰{Ð&Ø—‘× Ñ ×&Ñ&Õ(ð 'ä˜¤§¡Ô-Ø�K‰K×Ñ×"Ñ"Ô$Ø�M‰M×Ñ×$Ñ$ SÕ)ä˜Ô 0Ô1Ü.0¯g©g×.CÑ.CØ×*Ñ*×/Ñ/×2Ñ2´5·=±=ÓAØØ—K‘K×1Ñ1ð /Dó /÷ ‰b�×+Ñ+×1Ñ1Ó2ð	 ×&Ñ&Õ+ô ˜¤Õ0°T·[±[×5aÒ5aÜ$&§G¡G×$9Ñ$9Ø× Ñ ×%Ñ%×(Ñ(¬¯©Ó7ØØ—K‘K×1Ñ1ð %:ó %ˆF×ÑÔ!ô
 %'§G¡G×$9Ñ$9Ø× Ñ ×%Ñ%×(Ñ(¬¯©Ó7ØØ—K‘K×1Ñ1ð %:ó %ˆF×ÑÕ!ô ˜Ô 8Ô9Ø Ÿ,™,¨¯©°f·l±lÐCò (�Ü  Õ'ð(à Ÿ,™,¨¯©Ð5ò (�Ø—‘×!Ñ!×'Ñ'¨Ô,Ø—
‘
—‘×%Ñ%Õ'ð(ð �L‰L×Ñ×$Ñ$×*Ñ*Ô,Ø�L‰L×Ñ×"Ñ"×(Ñ(Õ*ð :r2   )rR   rS   rT   rU   r   Úconfig_classÚbase_model_prefixÚmain_input_nameÚsupports_gradient_checkpointingÚ_no_split_modulesr   r   rƒ   r+   r÷   r:  r  r2   r1   r/  r/  d  sQ   „ ñð
  €LØ ÐØ$€OØ&*Ð#ØÐð)+ E¨"¯)©)°R·Y±YÀÇÁÐ*LÑ$Mð )+ÐRVô )+r2   r/  aH  
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`VitDetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
aK  
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`ViTImageProcessor.__call__`]
            for details.

        head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
            Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:

            - 1 indicates the head is **not masked**,
            - 0 indicates the head is **masked**.

        output_attentions (`bool`, *optional*):
            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
            tensors for more detail.
        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
z`The bare VitDet Transformer model outputting raw hidden-states without any specific head on top.c                   óü   ‡ — e Zd Zdefˆ fd„Zdefd„Zdeee	e   f   ddfd„Z
 ee«       eee¬«      	 	 	 	 	 dd	eej$                     d
eej$                     dee   dee   dee   deeef   fd„«       «       Zˆ xZS )ÚVitDetModelr.   c                 ó’   •— t         ‰| �  |«       || _        t        |«      | _        t        |«      | _        | j                  «        y r—   )r   r   r.   r   rP   r  ÚencoderÚ	post_init)r-   r.   r0   s     €r1   r   zVitDetModel.__init__Ã  s;   ø€ Ü‰Ñ˜Ô ØˆŒä*¨6Ó2ˆŒÜ$ VÓ,ˆŒð 	�‰Õr2   rM   c                 ó.   — | j                   j                  S r—   ©rP   r,   r¯   s    r1   Úget_input_embeddingsz VitDetModel.get_input_embeddingsÍ  ó   € Ø�‰×)Ñ)Ð)r2   Úheads_to_pruneNc                 ó˜   — |j                  «       D ]7  \  }}| j                  j                  |   j                  j	                  |«       Œ9 y)z�
        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
        class PreTrainedModel
        N)ÚitemsrC  rÔ   rù   Úprune_heads)r-   rI  rÔ   Úheadss       r1   Ú_prune_headszVitDetModel._prune_headsÐ  sE   € ð
 +×0Ñ0Ó2ò 	C‰LˆE�5Ø�L‰L×Ñ˜uÑ%×/Ñ/×;Ñ;¸EÕBñ	Cr2   ©Úoutput_typer;  rL   rþ   r‘   r  r  c                 ó¶  — |�|n| j                   j                  }|�|n| j                   j                  }|�|n| j                   j                  }|€t	        d«      ‚| j                  || j                   j                  «      }| j                  |«      }| j                  |||||¬«      }|d   }|s	|f|dd z   S t        ||j                  |j                  ¬«      S )añ  
        Returns:

        Examples:

        ```python
        >>> from transformers import VitDetConfig, VitDetModel
        >>> import torch

        >>> config = VitDetConfig()
        >>> model = VitDetModel(config)

        >>> pixel_values = torch.randn(1, 3, 224, 224)

        >>> with torch.no_grad():
        ...     outputs = model(pixel_values)

        >>> last_hidden_states = outputs.last_hidden_state
        >>> list(last_hidden_states.shape)
        [1, 768, 14, 14]
        ```Nz You have to specify pixel_values)rþ   r‘   r  r  r   r   r  )r.   r‘   r  Úuse_return_dictr>   Úget_head_maskr  rP   rC  r   r«   r  )	r-   rL   rþ   r‘   r  r  Úembedding_outputÚencoder_outputsÚsequence_outputs	            r1   rQ   zVitDetModel.forwardØ  sù   € ð> 2CÐ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð &1Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆàÐÜÐ?Ó@Ð@ð ×&Ñ& y°$·+±+×2OÑ2OÓPˆ	àŸ?™?¨<Ó8ÐàŸ,™,ØØØ/Ø!5Ø#ð 'ó 
ˆð *¨!Ñ,ˆáØ#Ð%¨¸¸Ð(;Ñ;Ð;äØ-Ø)×7Ñ7Ø&×1Ñ1ô
ð 	
r2   )NNNNN)rR   rS   rT   r   r   r   rG  r   r;   r   rN  r   ÚVITDET_INPUTS_DOCSTRINGr   r   Ú_CONFIG_FOR_DOCr   r(   rV   r  r   r   rQ   rW   rX   s   @r1   rA  rA  ¾  sÝ   ø„ ð
˜|õ ð*Ð&6ó *ðC¨4°°T¸#±Y°Ñ+?ð CÀDó Cñ +Ð+BÓCÙ¨?ÈÔYð 04Ø,0Ø,0Ø/3Ø&*ñ?
à˜uŸ|™|Ñ,ð?
ð ˜EŸL™LÑ)ð?
ð $ D™>ð	?
ð
 ' t™nð?
ð ˜d‘^ð?
ð 
ˆu�oÐ%Ñ	&ò?
ó Zó Dô?
r2   rA  zF
    ViTDet backbone, to be used with frameworks like Mask R-CNN.
    c                   ó¤   ‡ — e Zd Zˆ fd„Zdefd„Z ee«       ee	e
¬«      	 	 	 d
dej                  dee   dee   dee   de	f
d	„«       «       Zˆ xZS )ÚVitDetBackbonec                 ó  •— t         ‰| �  |«       t         ‰| �	  |«       t        |«      | _        t        |«      | _        t        |j                  dz   «      D �cg c]  }|j                  ‘Œ c}| _
        | j                  «        y c c}w )Nr   )r   r   Ú_init_backboner   rP   r  rC  r	  r  r   Únum_featuresrD  )r-   r.   rv   r0   s      €r1   r   zVitDetBackbone.__init__#  sq   ø€ Ü‰Ñ˜Ô Ü‰Ñ˜vÔ&ä*¨6Ó2ˆŒÜ$ VÓ,ˆŒÜ9>¸v×?WÑ?WÐZ[Ñ?[Ó9\Ö]°A˜V×/Ó/Ò]ˆÔð 	�‰Õùò ^s   ÁBrM   c                 ó.   — | j                   j                  S r—   rF  r¯   s    r1   rG  z#VitDetBackbone.get_input_embeddings.  rH  r2   rO  rL   r  r‘   r  c                 óú  — |�|n| j                   j                  }|�|n| j                   j                  }|�|n| j                   j                  }| j	                  |«      }| j                  |d||¬«      }|r|j                  n|d   }d}t        | j                  |«      D ]  \  }	}
|	| j                  v sŒ||
fz  }Œ |s|r|f|dd z   }|S |f|dd z   }|S t        ||r|j                  nd|j                  ¬«      S )aê  
        Returns:

        Examples:

        ```python
        >>> from transformers import VitDetConfig, VitDetBackbone
        >>> import torch

        >>> config = VitDetConfig()
        >>> model = VitDetBackbone(config)

        >>> pixel_values = torch.randn(1, 3, 224, 224)

        >>> with torch.no_grad():
        ...     outputs = model(pixel_values)

        >>> feature_maps = outputs.feature_maps
        >>> list(feature_maps[-1].shape)
        [1, 768, 14, 14]
        ```NT)r  r‘   r  r   r  r5   )Úfeature_mapsr«   r  )r.   rR  r  r‘   rP   rC  r«   ÚzipÚstage_namesÚout_featuresr   r  )r-   rL   r  r‘   r  rT  r–   r«   r`  Ústager�   r¦   s               r1   rQ   zVitDetBackbone.forward1  s5  € ð< &1Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð 2CÐ1NÑ-ÐTX×T_ÑT_×TqÑTqÐàŸ?™?¨<Ó8Ðà—,‘,ØØ!%Ø/Ø#ð	 ó 
ˆñ 2=˜×-Ò-À'È!Á*ˆàˆÜ#& t×'7Ñ'7¸Ó#Gò 	0ÑˆE�<Ø˜×)Ñ)Ò)Ø  Ñ/‘ð	0ñ Ù#Ø&˜¨7°1°2¨;Ñ6�ð ˆMð '˜¨7°1°2¨;Ñ6�ØˆMäØ%Ù3G˜'×/Ò/ÈTØ×)Ñ)ô
ð 	
r2   )NNN)rR   rS   rT   r   r   rG  r   rW  r   r   rX  r(   rV   r   r  rQ   rW   rX   s   @r1   rZ  rZ    s‹   ø„ ô	ð*Ð&6ó *ñ +Ð+BÓCÙ¨>ÈÔXð 04Ø,0Ø&*ñ=
à—l‘lð=
ð ' t™nð=
ð $ D™>ð	=
ð
 ˜d‘^ð=
ð 
ò=
ó Yó Dô=
r2   rZ  )rA  r/  rZ  )r�   F);rU   Úcollections.abcr!   r<   Útypingr   r   r   r   r   r(   Útorch.utils.checkpointr   Úactivationsr
   Úmodeling_outputsr   r   Úmodeling_utilsr   Úutilsr   r   r   r   Úutils.backbone_utilsr   Úconfiguration_vitdetr   Ú
get_loggerrR   ÚloggerrX  ÚModuler   r?   Úscript_if_tracingrg   rz   r|   rV   r±   r  r§   r©   r´   rÂ   rÖ   rë   rï   rñ   r  r-  r/  ÚVITDET_START_DOCSTRINGrW  rA  rZ  Ú__all__r  r2   r1   ú<module>rt     sÔ  ðñ ã Û ß 5Õ 5ã Û Ý å !ß ?Ý -÷ó õ 2Ý .ð 
ˆ×	Ñ	˜HÓ	%€ð !€ôU�r—y‘yô Uðp ‡�×Ññ!3ó ð!3òH&ôR;�b—i‘iô ;ñ~�U—\‘\ð ¨eð ÀTð ÐV[×VbÑVbó ô*-�R—Y‘Yô -ô�b—i‘iô ô,$˜rŸy™yô $ôN�—	‘	ô ò$2ò@ô>N�"—)‘)ô Nôb@
�B—I‘Iô @
ðF*˜RŸY™Yð *¨4ó *ô5+˜Oô 5+ðp	Ð ðÐ ñ. ØfØóôW
Ð'ó W
ó	ðW
ñt ðð ó	ôN
Ð*¨Mó N
óðN
òb E�r2   