Ë
    S^(hÔù  ã            	       ó  — d Z ddlZddlZddlZddlmZ ddl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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mZmZ ddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& ddl'm(Z(  e$jR                  e*«      Z+dZ,dZ-g d¢Z.dZ/dZ0e G d„ de«      «       Z1dNdejd                  de3de4dejd                  fd„Z5 G d„ dejl                  «      Z7 G d„ dejl                  «      Z8 G d„ d ejl                  «      Z9 G d!„ d"ejl                  «      Z: G d#„ d$e:«      Z; G d%„ d&ejl                  «      Z<e:e;d'œZ= G d(„ d)ejl                  «      Z> G d*„ d+ejl                  «      Z? G d,„ d-ejl                  «      Z@ G d.„ d/ejl                  «      ZA G d0„ d1ejl                  «      ZB G d2„ d3ejl                  «      ZC G d4„ d5e«      ZDd6ZEd7ZF e"d8eE«       G d9„ d:eD«      «       ZG G d;„ d<ejl                  «      ZH e"d=eE«       G d>„ d?eD«      «       ZI G d@„ dAejl                  «      ZJ G dB„ dCejl                  «      ZK G dD„ dEejl                  «      ZL G dF„ dGejl                  «      ZM G dH„ dIejl                  «      ZN e"dJeE«       G dK„ dLeD«      «       ZOg dM¢ZPy)OzPyTorch Data2VecVision model.é    N)Ú	dataclass)ÚListÚOptionalÚTupleÚUnion)Únn)ÚBCEWithLogitsLossÚCrossEntropyLossÚMSELossé   )ÚACT2FN)ÚBaseModelOutputÚBaseModelOutputWithPoolingÚImageClassifierOutputÚSemanticSegmenterOutput)ÚPreTrainedModel)Ú#compile_compatible_method_lru_cacheÚ find_pruneable_heads_and_indicesÚprune_linear_layer)Úadd_code_sample_docstringsÚadd_start_docstringsÚ%add_start_docstrings_to_model_forwardÚloggingÚreplace_return_docstringsÚ	torch_inté   )ÚData2VecVisionConfigr   zfacebook/data2vec-vision-base)r   éÅ   i   z"facebook/data2vec-vision-base-ft1kzremote control, remotec                   ó   — e Zd ZdZy)Ú$Data2VecVisionModelOutputWithPoolinga¾  
    Class for outputs of [`Data2VecVisionModel`].

    Args:
        last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
            Sequence of hidden-states at the output of the last layer of the model.
        pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`):
            Average of the last layer hidden states of the patch tokens (excluding the *[CLS]* token) if
            *config.use_mean_pooling* is set to True. If set to False, then the final hidden state of the *[CLS]* token
            will be returned.
        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer) of
            shape `(batch_size, sequence_length, hidden_size)`.

            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=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 after the attention softmax, used to compute the weighted average in the self-attention
            heads.
    N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__© ó    ús/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/transformers/models/data2vec/modeling_data2vec_vision.pyr    r    >   s   „ òr&   r    ÚinputÚ	drop_probÚtrainingÚreturnc                 ó  — |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)ÚshapeÚndimÚtorchÚrandr.   r/   Úfloor_Údiv)r(   r)   r*   Ú	keep_probr0   Úrandom_tensorÚoutputs          r'   Ú	drop_pathr9   Z   s�   € ð �CÒ™xØˆØ�I‘€IØ�[‰[˜‰^Ð ¨¯
©
°Q©Ñ 7Ñ7€EØ¤§
¡
¨5¸¿¹ÈEÏLÉLÔ YÑY€MØ×ÑÔØ�Y‰Y�yÓ! MÑ1€FØ€Mr&   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 )
ÚData2VecVisionDropPathzXDrop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).Nr)   r+   c                 ó0   •— t         ‰| �  «        || _        y ©N)ÚsuperÚ__init__r)   )Úselfr)   Ú	__class__s     €r'   r?   zData2VecVisionDropPath.__init__r   s   ø€ Ü‰ÑÔØ"ˆ�r&   Úhidden_statesc                 óD   — t        || j                  | j                  «      S r=   )r9   r)   r*   ©r@   rB   s     r'   ÚforwardzData2VecVisionDropPath.forwardv   s   € Ü˜¨¯©¸¿¹ÓFÐFr&   c                 ó8   — dj                  | j                  «      S )Nzp={})Úformatr)   ©r@   s    r'   Ú
extra_reprz!Data2VecVisionDropPath.extra_repry   s   € Ø�}‰}˜TŸ^™^Ó,Ð,r&   r=   )r!   r"   r#   r$   r   Úfloatr?   r2   ÚTensorrE   ÚstrrI   Ú__classcell__©rA   s   @r'   r;   r;   o   sG   ø„ Ùbñ# (¨5¡/ð #¸Tõ #ðG U§\¡\ð G°e·l±ló Gð-˜C÷ -r&   r;   c            	       óÒ   ‡ — e Zd ZdZdeddfˆ fd„Zdej                  dededej                  fd	„Z		 	 dd
ej                  de
ej                     de
e   dej                  fd„Zˆ xZS )ÚData2VecVisionEmbeddingszc
    Construct the CLS token, position and patch embeddings. Optionally, also the mask token.

    Úconfigr+   Nc                 ó2  •— t         ‰| �  «        t        j                  t	        j
                  dd|j                  «      «      | _        |j                  r:t        j                  t	        j
                  dd|j                  «      «      | _	        nd | _	        t        |«      | _        |j                  | _        t        |j                  t        j                   j"                  «      r|j                  n|j                  |j                  f| _        | j                  j$                  }|j&                  r=t        j                  t	        j
                  d|dz   |j                  «      «      | _        nd | _        t        j*                  |j,                  «      | _        y )Nr   )r>   r?   r   Ú	Parameterr2   ÚzerosÚhidden_sizeÚ	cls_tokenÚuse_mask_tokenÚ
mask_tokenÚData2VecVisionPatchEmbeddingsÚpatch_embeddingsÚ
patch_sizeÚ
isinstanceÚ
image_sizeÚcollectionsÚabcÚIterableÚnum_patchesÚ use_absolute_position_embeddingsÚposition_embeddingsÚDropoutÚhidden_dropout_probÚdropout)r@   rQ   ra   rA   s      €r'   r?   z!Data2VecVisionEmbeddings.__init__„   s$  ø€ Ü‰ÑÔäŸ™¤e§k¡k°!°Q¸×8JÑ8JÓ&KÓLˆŒØ× Ò Ü Ÿl™l¬5¯;©;°q¸!¸V×=OÑ=OÓ+PÓQˆD�Oà"ˆDŒOÜ =¸fÓ EˆÔØ ×+Ñ+ˆŒô ˜&×+Ñ+¬[¯_©_×-EÑ-EÔFð ×Òà×#Ñ# V×%6Ñ%6Ð7ð 	Œð
 ×+Ñ+×7Ñ7ˆØ×2Ò2Ü')§|¡|´E·K±KÀÀ;ÐQRÁ?ÐTZ×TfÑTfÓ4gÓ'hˆDÕ$à'+ˆDÔ$Ü—z‘z &×"<Ñ"<Ó=ˆ�r&   Ú
embeddingsÚheightÚwidthc                 ó¦  — |j                   d   dz
  }| j                  j                   d   dz
  }t        j                  j	                  «       s||k(  r||k(  r| j                  S | j                  dd…dd…f   }| j                  dd…dd…f   }|j                   d   }|| j
                  z  }	|| j
                  z  }
t        |dz  «      }|j                  d|||«      }|j                  dddd«      }t        j                  j                  ||	|
fdd	¬
«      }|j                  dddd«      j                  dd|«      }t        j                  ||fd¬«      S )a   
        This method allows to interpolate the pre-trained position encodings, to be able to use the model on higher resolution
        images. This method is also adapted to support torch.jit tracing.

        Adapted from:
        - https://github.com/facebookresearch/dino/blob/de9ee3df6cf39fac952ab558447af1fa1365362a/vision_transformer.py#L174-L194, and
        - https://github.com/facebookresearch/dinov2/blob/e1277af2ba9496fbadf7aec6eba56e8d882d1e35/dinov2/models/vision_transformer.py#L179-L211
        r   Néÿÿÿÿg      à?r   r   é   ÚbicubicF©ÚsizeÚmodeÚalign_corners©Údim)r0   rc   r2   ÚjitÚ
is_tracingr[   r   ÚreshapeÚpermuter   Ú
functionalÚinterpolateÚviewÚcat)r@   rg   rh   ri   ra   Únum_positionsÚclass_pos_embedÚpatch_pos_embedrs   Ú
new_heightÚ	new_widthÚsqrt_num_positionss               r'   Úinterpolate_pos_encodingz1Data2VecVisionEmbeddings.interpolate_pos_encoding›   s`  € ð !×&Ñ& qÑ)¨AÑ-ˆØ×0Ñ0×6Ñ6°qÑ9¸AÑ=ˆô �y‰y×#Ñ#Ô%¨+¸Ò*FÈ6ÐUZÊ?Ø×+Ñ+Ð+à×2Ñ2²1°b°q°b°5Ñ9ˆØ×2Ñ2²1°a±b°5Ñ9ˆà×Ñ˜rÑ"ˆà˜tŸ™Ñ.ˆ
Ø˜TŸ_™_Ñ,ˆ	ä& }°cÑ'9Ó:ÐØ)×1Ñ1°!Ð5GÐI[Ð]`ÓaˆØ)×1Ñ1°!°Q¸¸1Ó=ˆäŸ-™-×3Ñ3ØØ˜iÐ(ØØð	 4ó 
ˆð *×1Ñ1°!°Q¸¸1Ó=×BÑBÀ1ÀbÈ#ÓNˆä�y‰y˜/¨?Ð;ÀÔCÐCr&   Úpixel_valuesÚbool_masked_posr‚   c                 ó8  — | j                   �|�t        j                  d«       |j                  \  }}}}| j	                  |«      \  }\  }}	|j                  «       \  }
}}|�K| j                  j                  |
|d«      }|j                  d«      j                  |«      }|d|z
  z  ||z  z   }| j                  j                  |
dd«      }t        j                  ||fd¬«      }| j                   �|| j                  |||«      z   }| j                  |«      }|||	ffS )Nz·`interpolate_pos_encoding` argument has no effect for BEiTEmbeddings, embeddings are always interpolated to the input image size. The argument will be removed in transformers v4.51.0.rk   r   rr   )rc   ÚwarningsÚwarnr0   rZ   ro   rX   ÚexpandÚ	unsqueezeÚtype_asrV   r2   r{   r‚   rf   )r@   rƒ   r„   r‚   Ú_rh   ri   rg   Úpatch_heightÚpatch_widthÚ
batch_sizeÚseq_lenÚmask_tokensÚwÚ
cls_tokenss                  r'   rE   z Data2VecVisionEmbeddings.forwardÃ   s-  € ð ×#Ñ#Ð/Ð4LÐ4XÜ�M‰Mðnôð
 +×0Ñ0Ñˆˆ1ˆf�eØ26×2GÑ2GÈÓ2UÑ/ˆ
Ñ/�\ ;Ø!+§¡Ó!2Ñˆ
�G˜QàÐ&ØŸ/™/×0Ñ0°¸WÀbÓIˆKà×)Ñ)¨"Ó-×5Ñ5°kÓBˆAØ# q¨1¡uÑ-°¸a±Ñ?ˆJà—^‘^×*Ñ*¨:°r¸2Ó>ˆ
Ü—Y‘Y 
¨JÐ7¸QÔ?ˆ
à×#Ñ#Ð/Ø# d×&CÑ&CÀJÐPVÐX]Ó&^Ñ^ˆJà—\‘\ *Ó-ˆ
à˜L¨+Ð6Ð6Ð6r&   ©NN)r!   r"   r#   r$   r   r?   r2   rK   Úintr‚   r   Ú
BoolTensorÚboolrE   rM   rN   s   @r'   rP   rP   ~   s™   ø„ ñð
>Ð3ð >¸õ >ð.&D°5·<±<ð &DÈð &DÐUXð &DÐ]b×]iÑ]ió &DðV 7;Ø37ñ	7à—l‘lð7ð " %×"2Ñ"2Ñ3ð7ð #+¨4¡.ð	7ð
 
�‰÷7r&   rP   c                   óZ   ‡ — e Zd ZdZˆ fd„Zdej                  dej                  fd„Zˆ xZS )rY   zì
    This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
    `hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
    Transformer.
    c                 ó  •— 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  }|d   |d   z  |d   |d   z  f}|| _        || _        || _        || _
        || _        t        j                  ||||¬«      | _        y )Nr   r   ©Úkernel_sizeÚstride)r>   r?   r]   r[   Únum_channelsrU   r\   r^   r_   r`   ra   Úpatch_shaper   ÚConv2dÚ
projection)	r@   rQ   r]   r[   rœ   rU   ra   r�   rA   s	           €r'   r?   z&Data2VecVisionPatchEmbeddings.__init__ì   s  ø€ Ü‰ÑÔØ!'×!2Ñ!2°F×4EÑ4E�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ˆØ! !‘}¨
°1©Ñ5°zÀ!±}È
ÐSTÉÑ7UÐVˆØ$ˆŒØ$ˆŒØ(ˆÔØ&ˆÔØ&ˆÔäŸ)™) L°+È:Ð^hÔiˆ�r&   rƒ   r+   c                 ó  — |j                   \  }}}}|| j                  k7  rt        d«      ‚| j                  |«      }|j                   d   |j                   d   }}|j	                  d«      j                  dd«      }|||ffS )NzeMake sure that the channel dimension of the pixel values match with the one set in the configuration.rl   r   r   )r0   rœ   Ú
ValueErrorrŸ   ÚflattenÚ	transpose)	r@   rƒ   rŽ   rœ   rh   ri   rg   rŒ   r�   s	            r'   rE   z%Data2VecVisionPatchEmbeddings.forwardý   s�   € Ø2>×2DÑ2DÑ/ˆ
�L &¨%Ø˜4×,Ñ,Ò,ÜØwóð ð —_‘_ \Ó2ˆ
Ø$.×$4Ñ$4°QÑ$7¸×9IÑ9IÈ!Ñ9L�kˆØ×'Ñ'¨Ó*×4Ñ4°Q¸Ó:ˆ
à˜L¨+Ð6Ð6Ð6r&   )	r!   r"   r#   r$   r?   r2   rK   rE   rM   rN   s   @r'   rY   rY   å   s)   ø„ ñôjð"7 E§L¡Lð 7°U·\±\÷ 7r&   rY   c                   ó  ‡ — e Zd Zddedee   ddfˆ fd„Zd„ Z	 	 	 	 	 ddej                  deej                     d	e
d
eej                     de
deee      deeej                     eej                  ej                  f   f   fd„Zˆ xZS )ÚData2VecVisionSelfAttentionNrQ   Úwindow_sizer+   c                 ó<  •— t         ‰| �  «        || _        |j                  |j                  z  dk7  r2t        |d«      s&t        d|j                  › d|j                  › d�«      ‚|j                  | _        t        |j                  |j                  z  «      | _        | j                  | j                  z  | _	        t        j                  |j                  | j                  «      | _        t        j                  |j                  | j                  d¬«      | _        t        j                  |j                  | j                  «      | _        t        j                  |j                   «      | _        t%        |«      | _        | j&                  rt)        ||¬«      | _        y y )	Nr   Úembedding_sizezThe hidden size z4 is not a multiple of the number of attention heads ú.F)Úbias©r¦   )r>   r?   rQ   rU   Únum_attention_headsÚhasattrr¡   r”   Úattention_head_sizeÚall_head_sizer   ÚLinearÚqueryÚkeyÚvaluerd   Úattention_probs_dropout_probrf   r–   Úhas_relative_position_biasÚ"Data2VecVisionRelativePositionBiasÚrelative_position_bias©r@   rQ   r¦   rA   s      €r'   r?   z$Data2VecVisionSelfAttention.__init__  sP  ø€ Ü‰ÑÔØˆŒØ×Ñ × :Ñ :Ñ:¸aÒ?ÌÐPVÐXhÔHiÜØ" 6×#5Ñ#5Ð"6ð 7Ø×3Ñ3Ð4°Að7óð ð
 $*×#=Ñ#=ˆÔ Ü#& v×'9Ñ'9¸F×<VÑ<VÑ'VÓ#WˆÔ Ø!×5Ñ5¸×8PÑ8PÑPˆÔä—Y‘Y˜v×1Ñ1°4×3EÑ3EÓFˆŒ
Ü—9‘9˜V×/Ñ/°×1CÑ1CÈ%ÔPˆŒÜ—Y‘Y˜v×1Ñ1°4×3EÑ3EÓFˆŒ
ä—z‘z &×"EÑ"EÓFˆŒä*.¨{Ó*;ˆÔ'Ø×*Ò*Ü*LÈVÐalÔ*mˆDÕ'ð +r&   c                 ó    — |j                  «       d d | j                  | j                  fz   } |j                  |Ž }|j	                  dddd«      S )Nrk   r   rl   r   r   )ro   r¬   r®   rz   rw   )r@   ÚxÚnew_x_shapes      r'   Útranspose_for_scoresz0Data2VecVisionSelfAttention.transpose_for_scores$  sN   € Ø—f‘f“h˜s �m t×'?Ñ'?À×AYÑAYÐ&ZÑZˆØˆA�F‰F�KÐ ˆØ�y‰y˜˜A˜q !Ó$Ð$r&   rB   Ú	head_maskÚoutput_attentionsr·   r‚   Ú
resolutionc                 óŽ  — | j                  |«      }| j                  | j                  |«      «      }| j                  | j                  |«      «      }	| j                  |«      }
t	        j
                  |
|j                  dd«      «      }|t        j                  | j                  «      z  }| j                  r[|\  }}|| j                  j                  z  || j                  j                  z  f}|| j                  |||j                  d   ¬«      z   }|�||z   }t        j                   j#                  |d¬«      }| j%                  |«      }|�||z  }t	        j
                  ||	«      }|j'                  dddd«      j)                  «       }|j+                  «       d d | j,                  fz   } |j.                  |Ž }|r||f}|S |f}|S )	Nrk   éþÿÿÿr   ©Údim_sizerr   r   rl   r   )r±   r¼   r²   r³   r2   Úmatmulr£   ÚmathÚsqrtr®   rµ   rQ   r[   r·   r0   r   rx   Úsoftmaxrf   rw   Ú
contiguousro   r¯   rz   )r@   rB   r½   r¾   r·   r‚   r¿   Úmixed_query_layerÚ	key_layerÚvalue_layerÚquery_layerÚattention_scoresrh   ri   r¦   Úattention_probsÚcontext_layerÚnew_context_layer_shapeÚoutputss                      r'   rE   z#Data2VecVisionSelfAttention.forward)  sØ  € ð !ŸJ™J }Ó5Ðà×-Ñ-¨d¯h©h°}Ó.EÓFˆ	Ø×/Ñ/°·
±
¸=Ó0IÓJˆØ×/Ñ/Ð0AÓBˆô !Ÿ<™<¨°Y×5HÑ5HÈÈRÓ5PÓQÐà+¬d¯i©i¸×8PÑ8PÓ.QÑQÐð ×*Ò*Ø&‰MˆF�EØ! T§[¡[×%;Ñ%;Ñ;¸UÀdÇkÁk×F\ÑF\Ñ=\Ð]ˆKØ/°$×2MÑ2MØÐ5À×@SÑ@SÐTUÑ@Vð 3Nó 3ñ  Ðð
 "Ð-Ø/Ð2HÑHÐô Ÿ-™-×/Ñ/Ð0@ÀbÐ/ÓIˆð Ÿ,™, Ó7ˆð Ð Ø-°	Ñ9ˆOäŸ™ _°kÓBˆà%×-Ñ-¨a°°A°qÓ9×DÑDÓFˆØ"/×"4Ñ"4Ó"6°s¸Ð";¸t×?QÑ?QÐ>SÑ"SÐØ*˜×*Ñ*Ð,CÐDˆá6G�= /Ð2ˆàˆð O\ÐM]ˆàˆr&   r=   ©NFNFN)r!   r"   r#   r   r   Útupler?   r¼   r2   rK   r–   r   r”   r   rE   rM   rN   s   @r'   r¥   r¥     sÊ   ø„ ñnÐ3ð nÀ(È5Á/ð nÐ]aõ nò.%ð -1Ø"'Ø9=Ø).Ø+/ñ3à—|‘|ð3ð ˜EŸL™LÑ)ð3ð  ð	3ð
 !)¨¯©Ñ 6ð3ð #'ð3ð ˜U 3™ZÑ(ð3ð 
ˆu�U—\‘\Ñ" E¨%¯,©,¸¿¹Ð*DÑ$EÐEÑ	F÷3r&   r¥   c                   óò   ‡ — e Zd Z	 	 	 	 	 d	dej                  deej                     dedeej                     dedeee      de	eej                     eej                  ej                  f   f   fˆ fd„Z
ˆ xZS )
ÚData2VecVisionSdpaSelfAttentionrB   r½   r¾   r·   r‚   r¿   r+   c           	      óœ  •— |s|�*t         j                  d«       t        ‰| �  ||||||¬«      S | j	                  |«      }| j                  | j                  |«      «      }| j                  | j                  |«      «      }	| j                  |«      }
d }| j                  rX|\  }}|| j                  j                  z  || j                  j                  z  f}| j                  |||j                  d   ¬«      }|�
|€|}n||z  }dt        j                  | j                  «      z  }t         j"                  j$                  j'                  |
||	|| j(                  r| j                  j*                  ndd|¬«      }|j-                  dd	dd
«      j/                  «       }|j1                  «       d d | j2                  fz   } |j4                  |Ž }|d fS )Na˜  `Data2VecVisionSdpaSelfAttention` is used but `torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True` or `head_mask`. Falling back to the manual attention implementation, but specifying the manual implementation will be required from Transformers version v5.0.0 onwards. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.)rB   r½   r¾   r·   r‚   r¿   r   rÂ   r-   F)Ú	attn_maskÚ	dropout_pÚ	is_causalÚscaler   rl   r   rÁ   )ÚloggerÚwarning_oncer>   rE   r±   r¼   r²   r³   rµ   rQ   r[   r·   r0   rÅ   rÆ   r®   r2   r   rx   Úscaled_dot_product_attentionr*   r´   rw   rÈ   ro   r¯   rz   )r@   rB   r½   r¾   r·   r‚   r¿   rÉ   rÊ   rË   rÌ   Ú	attn_biasrh   ri   r¦   ÚscalingrÏ   rÐ   rA   s                     €r'   rE   z'Data2VecVisionSdpaSelfAttention.forwarda  sé  ø€ ñ  	Ð 5Ü×Ñðwôô ‘7‘?Ø+Ø#Ø"3Ø'=Ø)AØ%ð #ó ð ð !ŸJ™J }Ó5ÐØ×-Ñ-¨d¯h©h°}Ó.EÓFˆ	Ø×/Ñ/°·
±
¸=Ó0IÓJˆØ×/Ñ/Ð0AÓBˆàˆ	Ø×*Ò*Ø&‰MˆF�EØ! T§[¡[×%;Ñ%;Ñ;¸UÀdÇkÁk×F\ÑF\Ñ=\Ð]ˆKØ×3Ñ3ØÐ5À×@SÑ@SÐTUÑ@Vð 4ó ˆIð
 "Ð-ØÐ Ø2‘	àÐ3Ñ3�	à”d—i‘i × 8Ñ 8Ó9Ñ9ˆÜŸ™×+Ñ+×HÑHØØØØØBFÇ-Â-�d—k‘k×>Ò>ÐUXØØð Ió 
ˆð &×-Ñ-¨a°°A°qÓ9×DÑDÓFˆØ"/×"4Ñ"4Ó"6°s¸Ð";¸t×?QÑ?QÐ>SÑ"SÐØ*˜×*Ñ*Ð,CÐDˆØ˜dÐ"Ð"r&   rÒ   )r!   r"   r#   r2   rK   r   r–   r   r”   r   rE   rM   rN   s   @r'   rÕ   rÕ   `  s¦   ø„ ð -1Ø"'Ø9=Ø).Ø+/ñ:#à—|‘|ð:#ð ˜EŸL™LÑ)ð:#ð  ð	:#ð
 !)¨¯©Ñ 6ð:#ð #'ð:#ð ˜U 3™ZÑ(ð:#ð 
ˆu�U—\‘\Ñ" E¨%¯,©,¸¿¹Ð*DÑ$EÐEÑ	F÷:#ñ :#r&   rÕ   c                   ó~   ‡ — e Zd ZdZdeddfˆ fd„Zd	dej                  dej                  dej                  fd„Zˆ xZ	S )
ÚData2VecVisionSelfOutputz«
    The residual connection is defined in Data2VecVisionLayer instead of here (as is the case with other models), due to the
    layernorm applied before each block.
    rQ   r+   Nc                 óÈ   •— t         ‰| �  «        t        j                  |j                  |j                  «      | _        t        j                  |j                  «      | _        y r=   )	r>   r?   r   r°   rU   Údenserd   re   rf   ©r@   rQ   rA   s     €r'   r?   z!Data2VecVisionSelfOutput.__init__¥  sB   ø€ Ü‰ÑÔÜ—Y‘Y˜v×1Ñ1°6×3EÑ3EÓFˆŒ
Ü—z‘z &×"<Ñ"<Ó=ˆ�r&   rB   Úinput_tensorc                 óJ   — | j                  |«      }| j                  |«      }|S r=   ©rã   rf   )r@   rB   rå   Úgammas       r'   rE   z Data2VecVisionSelfOutput.forwardª  ó$   € ØŸ
™
 =Ó1ˆØŸ™ ]Ó3ˆàÐr&   r=   )
r!   r"   r#   r$   r   r?   r2   rK   rE   rM   rN   s   @r'   rá   rá   Ÿ  sE   ø„ ñð
>Ð3ð >¸õ >ñ
 U§\¡\ð ÀÇÁð Ð^c×^jÑ^j÷ r&   rá   )ÚeagerÚsdpac                   ó   ‡ — e Zd Zddedee   ddfˆ fd„Zd„ Z	 	 	 	 	 ddej                  deej                     d	e
d
ed   de
deee      deeej                     eej                  ej                  f   f   fd„Zˆ xZS )ÚData2VecVisionAttentionNrQ   r¦   r+   c                 óž   •— t         ‰| �  «        t        |j                     ||¬«      | _        t        |«      | _        t        «       | _        y )Nr«   )	r>   r?   Ú&DATA2VEC_VISION_SELF_ATTENTION_CLASSESÚ_attn_implementationÚ	attentionrá   r8   ÚsetÚpruned_headsr¸   s      €r'   r?   z Data2VecVisionAttention.__init__¹  sB   ø€ Ü‰ÑÔÜ?À×@[Ñ@[Ñ\Ø ô
ˆŒô /¨vÓ6ˆŒÜ›EˆÕr&   c                 ó>  — t        |«      dk(  ry t        || j                  j                  | j                  j                  | j
                  «      \  }}t        | j                  j                  |«      | j                  _        t        | j                  j                  |«      | j                  _        t        | j                  j                  |«      | j                  _	        t        | j                  j                  |d¬«      | j                  _        | j                  j                  t        |«      z
  | j                  _        | j                  j                  | j                  j                  z  | j                  _        | j
                  j                  |«      | _        y )Nr   r   rr   )Úlenr   rñ   r¬   r®   ró   r   r±   r²   r³   r8   rã   r¯   Úunion)r@   ÚheadsÚindexs      r'   Úprune_headsz#Data2VecVisionAttention.prune_headsÁ  s  € Üˆu‹:˜Š?ØÜ7Ø�4—>‘>×5Ñ5°t·~±~×7YÑ7YÐ[_×[lÑ[ló
‰ˆˆuô
  2°$·.±.×2FÑ2FÈÓNˆ�‰ÔÜ/°·±×0BÑ0BÀEÓJˆ�‰ÔÜ1°$·.±.×2FÑ2FÈÓNˆ�‰ÔÜ.¨t¯{©{×/@Ñ/@À%ÈQÔOˆ�‰Ôð .2¯^©^×-OÑ-OÔRUÐV[ÓR\Ñ-\ˆ�‰Ô*Ø'+§~¡~×'IÑ'IÈDÏNÉN×LnÑLnÑ'nˆ�‰Ô$Ø ×-Ñ-×3Ñ3°EÓ:ˆÕr&   rB   r½   r¾   r·   r¶   r‚   r¿   c                 ón   — | j                  ||||||«      }| j                  |d   |«      }|f|dd  z   }	|	S )Nr   r   )rñ   r8   )
r@   rB   r½   r¾   r·   r‚   r¿   Úself_outputsÚattention_outputrÑ   s
             r'   rE   zData2VecVisionAttention.forwardÓ  sS   € ð —~‘~Ø˜9Ð&7Ð9OÐQiÐkuó
ˆð  Ÿ;™; |°A¡¸ÓFÐà#Ð%¨°Q°RÐ(8Ñ8ˆØˆr&   r=   rÒ   )r!   r"   r#   r   r   rÓ   r?   rù   r2   rK   r–   r   r”   r   rE   rM   rN   s   @r'   rí   rí   ¸  sÃ   ø„ ñ"Ð3ð "À(È5Á/ð "Ð]aõ "ò;ð* -1Ø"'ØQUØ).Ø+/ñà—|‘|ðð ˜EŸL™LÑ)ðð  ð	ð
 !)Ð)MÑ Nðð #'ðð ˜U 3™ZÑ(ðð 
ˆu�U—\‘\Ñ" E¨%¯,©,¸¿¹Ð*DÑ$EÐEÑ	F÷r&   rí   c                   ó`   ‡ — e Zd Zdeddfˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚData2VecVisionIntermediaterQ   r+   Nc                 ó  •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        |j                  t        «      rt        |j                     | _        y |j                  | _        y r=   )r>   r?   r   r°   rU   Úintermediate_sizerã   r\   Ú
hidden_actrL   r   Úintermediate_act_fnrä   s     €r'   r?   z#Data2VecVisionIntermediate.__init__è  s]   ø€ Ü‰ÑÔÜ—Y‘Y˜v×1Ñ1°6×3KÑ3KÓLˆŒ
Ü�f×'Ñ'¬Ô-Ü'-¨f×.?Ñ.?Ñ'@ˆDÕ$à'-×'8Ñ'8ˆDÕ$r&   rB   c                 óJ   — | j                  |«      }| j                  |«      }|S r=   )rã   r  rD   s     r'   rE   z"Data2VecVisionIntermediate.forwardð  s&   € ØŸ
™
 =Ó1ˆØ×0Ñ0°Ó?ˆàÐr&   ©	r!   r"   r#   r   r?   r2   rK   rE   rM   rN   s   @r'   rþ   rþ   ç  s2   ø„ ð9Ð3ð 9¸õ 9ð U§\¡\ð °e·l±l÷ r&   rþ   c                   ó`   ‡ — e Zd Zdeddfˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚData2VecVisionOutputrQ   r+   Nc                 óÈ   •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        j                  |j                  «      | _	        y r=   )
r>   r?   r   r°   r   rU   rã   rd   re   rf   rä   s     €r'   r?   zData2VecVisionOutput.__init__ù  sB   ø€ Ü‰ÑÔÜ—Y‘Y˜v×7Ñ7¸×9KÑ9KÓLˆŒ
Ü—z‘z &×"<Ñ"<Ó=ˆ�r&   rB   c                 óJ   — | j                  |«      }| j                  |«      }|S r=   rç   rD   s     r'   rE   zData2VecVisionOutput.forwardþ  ré   r&   r  rN   s   @r'   r  r  ø  s2   ø„ ð>Ð3ð >¸õ >ð
 U§\¡\ð °e·l±l÷ r&   r  c                   ó  ‡ — e Zd ZdZ	 ddedee   deddfˆ fd„Z	 	 	 	 	 dde	j                  d	ee	j                     d
edee	j                     dedeee      deee	j                     ee	j                  e	j                  f   f   fd„Zˆ xZS )ÚData2VecVisionLayerz?This corresponds to the Block class in the timm implementation.NrQ   r¦   Údrop_path_rater+   c                 óú  •— t         ‰| �  «        |j                  | _        d| _        t	        ||¬«      | _        t        |«      | _        t        |«      | _	        t        j                  |j                  |j                  ¬«      | _        |dkD  rt        |«      nt        j                   «       | _        t        j                  |j                  |j                  ¬«      | _        |j&                  }|dkD  ryt        j(                  |t+        j,                  |j                  «      z  d¬«      | _        t        j(                  |t+        j,                  |j                  «      z  d¬«      | _        y d\  | _        | _        y )	Nr   r«   ©Úepsr-   r   T)Úrequires_gradr“   )r>   r?   Úchunk_size_feed_forwardÚseq_len_dimrí   rñ   rþ   Úintermediater  r8   r   Ú	LayerNormrU   Úlayer_norm_epsÚlayernorm_beforer;   ÚIdentityr9   Úlayernorm_afterÚlayer_scale_init_valuerS   r2   ÚonesÚlambda_1Úlambda_2)r@   rQ   r¦   r  Úinit_valuesrA   s        €r'   r?   zData2VecVisionLayer.__init__	  s  ø€ ô 	‰ÑÔØ'-×'EÑ'EˆÔ$ØˆÔÜ0°À[ÔQˆŒÜ6°vÓ>ˆÔÜ*¨6Ó2ˆŒÜ "§¡¨V×-?Ñ-?ÀV×EZÑEZÔ [ˆÔØCQÐTWÒCWÔ/°Ô?Ô]_×]hÑ]hÓ]jˆŒÜ!Ÿ|™|¨F×,>Ñ,>ÀF×DYÑDYÔZˆÔà×3Ñ3ˆØ˜Š?ÜŸL™L¨´u·z±zÀ6×CUÑCUÓ7WÑ)WÐgkÔlˆDŒMÜŸL™L¨´u·z±zÀ6×CUÑCUÓ7WÑ)WÐgkÔlˆD�Mà+5Ñ(ˆDŒM˜4�=r&   rB   r½   r¾   r·   r‚   r¿   c                 ó”  — | j                  | j                  |«      |||||¬«      }|d   }|dd  }	| j                  �| j                  |z  }| j                  |«      |z   }| j	                  |«      }
| j                  |
«      }
| j                  |
«      }
| j                  �| j                  |
z  }
| j                  |
«      |z   }
|
f|	z   }	|	S )N)r¾   r·   r‚   r¿   r   r   )rñ   r  r  r9   r  r  r8   r  )r@   rB   r½   r¾   r·   r‚   r¿   Úself_attention_outputsrü   rÑ   Úlayer_outputs              r'   rE   zData2VecVisionLayer.forward  sî   € ð "&§¡Ø×!Ñ! -Ó0ØØ/Ø#9Ø%=Ø!ð "0ó "
Ðð 2°!Ñ4ÐØ(¨¨Ð,ˆð �=‰=Ð$Ø#Ÿ}™}Ð/?Ñ?Ðð Ÿ™Ð'7Ó8¸=ÑHˆð ×+Ñ+¨MÓ:ˆà×(Ñ(¨Ó6ˆØ—{‘{ <Ó0ˆà�=‰=Ð$ØŸ=™=¨<Ñ7ˆLð —~‘~ lÓ3°mÑCˆà�/ GÑ+ˆàˆr&   )Nr-   rÒ   )r!   r"   r#   r$   r   r   rÓ   rJ   r?   r2   rK   r–   r   r”   r   rE   rM   rN   s   @r'   r
  r
    sÔ   ø„ ÙIð jmñ6Ø*ð6Ø9AÀ%¹ð6Øafð6à	õ6ð. -1Ø"'Ø9=Ø).Ø+/ñ)à—|‘|ð)ð ˜EŸL™LÑ)ð)ð  ð	)ð
 !)¨¯©Ñ 6ð)ð #'ð)ð ˜U 3™ZÑ(ð)ð 
ˆu�U—\‘\Ñ" E¨%¯,©,¸¿¹Ð*DÑ$EÐEÑ	F÷)r&   r
  c                   ó˜   ‡ — e Zd Zdededdfˆ fd„Z ed¬«      deeef   de	j                  fd„«       Zdd	ede	j                  fd
„Zˆ xZS )r¶   rQ   r¦   r+   Nc                 óò   •— t         ‰| �  «        || _        d|d   z  dz
  d|d   z  dz
  z  dz   | _        t	        j
                  t        j                  | j                  |j                  «      «      | _	        y )Nrl   r   r   r   )
r>   r?   r¦   Únum_relative_distancer   rS   r2   rT   r¬   Úrelative_position_bias_tabler¸   s      €r'   r?   z+Data2VecVisionRelativePositionBias.__init__K  sr   ø€ Ü‰ÑÔØ&ˆÔØ&'¨+°a©.Ñ&8¸1Ñ&<ÀÀ[ÐQRÁ^ÑASÐVWÑAWÑ%XÐ[\Ñ%\ˆÔ"Ü,.¯L©LÜ�K‰K˜×2Ñ2°F×4NÑ4NÓOó-
ˆÕ)r&   é
   )Úmaxsizec                 ó  — d|d   z  dz
  d|d   z  dz
  z  dz   }|d   |d   z  }t        j                  t        j                  |d   «      t        j                  |d   «      d¬«      }t        j                  |«      }t        j                  |d«      }|dd…dd…df   |dd…ddd…f   z
  }|j                  ddd«      j                  «       }|dd…dd…dfxx   |d   dz
  z  cc<   |dd…dd…dfxx   |d   dz
  z  cc<   |dd…dd…dfxx   d|d   z  dz
  z  cc<   t        j                  |dz   fdz  |j                  ¬«      }|j                  d	«      |dd…dd…f<   |dz
  |ddd…f<   |dz
  |dd…df<   |dz
  |d
<   |S )z·
        This method creates the relative position index, modified to support arbitrary window sizes,
        as introduced in [MiDaS v3.1](https://arxiv.org/abs/2307.14460).
        rl   r   r   r   Úij)ÚindexingN)ro   r.   rk   )r   r   )
r2   ÚmeshgridÚarangeÚstackr¢   rw   rÈ   rT   r.   Úsum)	r@   r¦   r"  Úwindow_areaÚgridÚcoordsÚcoords_flattenÚrelative_coordsÚrelative_position_indexs	            r'   Ú generate_relative_position_indexzCData2VecVisionRelativePositionBias.generate_relative_position_indexT  sµ  € ð "# [°¡^Ñ!3°aÑ!7¸AÀÈAÁÑ<NÐQRÑ<RÑ SÐVWÑ WÐð " !‘n {°1¡~Ñ5ˆÜ�~‰~œeŸl™l¨;°q©>Ó:¼E¿L¹LÈÐUVÉÓ<XÐcgÔhˆÜ—‘˜TÓ"ˆÜŸ™ v¨qÓ1ˆØ(ªªA¨t¨Ñ4°~ÂaÈÊqÀjÑ7QÑQˆØ)×1Ñ1°!°Q¸Ó:×EÑEÓGˆØšš1˜a˜Ó  K°¡N°QÑ$6Ñ6Ó Øšš1˜a˜Ó  K°¡N°QÑ$6Ñ6Ó Øšš1˜a˜Ó  A¨°A©Ñ$6¸Ñ$:Ñ:Ó Ü"'§+¡+°KÀ!±OÐ3EÈÑ3IÐQ`×QfÑQfÔ"gÐØ*9×*=Ñ*=¸bÓ*AÐ ¡ A¡B Ñ'Ø)>ÀÑ)BÐ  1¡2 Ñ&Ø)>ÀÑ)BÐ ¡ A Ñ&Ø(=ÀÑ(AÐ Ñ%Ø&Ð&r&   r‚   c                 ó   — d| j                   d   z  dz
  }d| j                   d   z  dz
  }d|d   z  dz
  }d|d   z  dz
  }| j                  }| j                  }	||z  dz   }
|d|	dz
   }|j                  d||d«      j	                  dddd«      }t
        j                  j                  |t        |«      t        |«      fd¬«      }|j	                  dddd«      j                  |
dz
  d«      }t        j                  |||	dz
  d g«      }| j                  |«      }||j                  d«         }|j                  |d   |d   z  dz   |d   |d   z  dz   d«      }|j	                  ddd«      j                  «       }|rCt
        j                  j                  |j                  d«      ||fdd	¬
«      j                  d«      }|j                  d«      S )zu
        Modification of timm.models.beit.py: Attention._get_rel_pos_bias to support arbitrary window sizes.
        rl   r   r   r   Nrk   Úbilinear)ro   rp   Frn   )r¦   r#  r"  rv   rw   r   rx   ry   r   r2   r{   r3  rz   rÈ   r‰   Úsqueeze)r@   r¦   r‚   rÃ   Ú
old_heightÚ	old_widthr   r€   Ú old_relative_position_bias_tableÚold_num_relative_distanceÚnew_num_relative_distanceÚold_sub_tableÚnew_sub_tableÚ new_relative_position_bias_tabler2  r·   s                   r'   rE   z*Data2VecVisionRelativePositionBias.forwardm  s-  € ð ˜×)Ñ)¨!Ñ,Ñ,¨qÑ0ˆ
Ø˜×(Ñ(¨Ñ+Ñ+¨aÑ/ˆ	à˜ Q™Ñ'¨!Ñ+ˆ
Ø˜ A™Ñ&¨Ñ*ˆ	à+/×+LÑ+LÐ(à$(×$>Ñ$>Ð!Ø$.°Ñ$:¸QÑ$>Ð!à8Ð9XÐ;TÐWXÑ;XÐYˆà%×-Ñ-¨a°¸JÈÓK×SÑSÐTUÐWXÐZ[Ð]^Ó_ˆÜŸ™×1Ñ1Ø¤¨:Ó!6¼	À)Ó8LÐ MÐT^ð 2ó 
ˆð &×-Ñ-¨a°°A°qÓ9×AÑAÐB[Ð^_ÑB_ÐacÓdˆä+0¯9©9ØÐ<Ð=VÐYZÑ=ZÐ=\Ð]Ð^ó,
Ð(ð #'×"GÑ"GÈÓ"TÐØ!AÐBY×B^ÑB^Ð_aÓBbÑ!cÐð "8×!<Ñ!<Ø˜‰N˜[¨™^Ñ+¨aÑ/°¸Q±À+ÈaÁ.Ñ1PÐSTÑ1TÐVXó"
Ðð "8×!?Ñ!?ÀÀ1ÀaÓ!H×!SÑ!SÓ!UÐá#Ü%'§]¡]×%>Ñ%>Ø&×0Ñ0°Ó3Ø Ð)ØØ#ð	 &?ó &÷
 ‰g�a‹jð #ð &×/Ñ/°Ó2Ð2r&   )FN)r!   r"   r#   r   rÓ   r?   r   r   r”   r2   rK   r3  r–   rE   rM   rN   s   @r'   r¶   r¶   J  sn   ø„ ð
Ð3ð 
À%ð 
ÈDõ 
ñ )°Ô4ð'¸EÀ#ÀsÀ(¹Oð 'ÐPU×P\ÑP\ò 'ó 5ð'ñ0-3¸Tð -3Ð]b×]iÑ]i÷ -3r&   r¶   c                   ó²   ‡ — e Zd Zddede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ef      de	deeef   fd„Zˆ xZS )ÚData2VecVisionEncoderNrQ   r¦   r+   c                 óì  •— t         ‰| �  «        || _        |j                  | _        | j                  rt        ||¬«      | _        t        j                  d|j                  |j                  «      D �cg c]  }|j                  «       ‘Œ }}t        j                  t        |j                  «      D �cg c]!  }t        ||j                   r|nd ||   ¬«      ‘Œ# c}«      | _        d| _        y c c}w c c}w )Nr«   r   )r¦   r  F)r>   r?   rQ   Ú!use_shared_relative_position_biasrµ   r¶   r·   r2   Úlinspacer  Únum_hidden_layersÚitemr   Ú
ModuleListÚranger
  Úuse_relative_position_biasÚlayerÚgradient_checkpointing)r@   rQ   r¦   rº   ÚdprÚirA   s         €r'   r?   zData2VecVisionEncoder.__init__Ÿ  s×   ø€ Ü‰ÑÔØˆŒØ*0×*RÑ*RˆÔ'Ø×*Ò*Ü*LÈVÐalÔ*mˆDÔ'ô "'§¡°°6×3HÑ3HÈ&×JbÑJbÓ!cÖd˜Aˆq�v‰v�xÐdˆÐdÜ—]‘]ô ˜v×7Ñ7Ó8öð ô $ØØ/5×/PÒ/P¡ÐVZØ#& q¡6öòó	
ˆŒ
ð ',ˆÕ#ùò eùòs   Á3C,Â2&C1rB   r½   r¾   Úoutput_hidden_statesr‚   r¿   Úreturn_dictc           
      óN  — |rdnd }|rdnd }	t        | j                  «      D ]Õ  \  }
}|r||fz   }| j                  rY|\  }}|| j                  j                  z  || j                  j                  z  f}| j                  |||j                  d   ¬«      }nd }|�||
   nd }| j                  r.| j                  r"| j                  |j                  ||||||«      }n |||||||«      }|d   }|sŒÍ|	|d   fz   }	Œ× |r||fz   }|st        d„ |||	fD «       «      S t        |||	¬«      S )Nr%   r   )r‚   rÃ   r   c              3   ó&   K  — | ]	  }|€Œ|–— Œ y ­wr=   r%   )Ú.0Úvs     r'   ú	<genexpr>z0Data2VecVisionEncoder.forward.<locals>.<genexpr>í  s   è ø€ Òm˜qÐ_`Ñ_lœÑmùs   ‚Š)Úlast_hidden_staterB   Ú
attentions)Ú	enumeraterI  rµ   rQ   r[   r·   r0   rJ  r*   Ú_gradient_checkpointing_funcÚ__call__rÓ   r   )r@   rB   r½   r¾   rM  r‚   r¿   rN  Úall_hidden_statesÚall_self_attentionsrL  Úlayer_modulerh   ri   r¦   r·   Úlayer_head_maskÚlayer_outputss                     r'   rE   zData2VecVisionEncoder.forward´  s‡  € ñ #7™B¸DÐÙ$5™b¸4Ðä(¨¯©Ó4ò &	P‰OˆAˆ|Ù#Ø$5¸Ð8HÑ$HÐ!à×.Ò.Ø *‘�˜Ø%¨¯©×)?Ñ)?Ñ?ÀÈ$Ï+É+×J`ÑJ`ÑA`Ða�Ø)-×)DÑ)DØÐ:RÐ]j×]pÑ]pÐqrÑ]sð *Eó *Ñ&ð *.Ð&à.7Ð.C˜i¨šlÈˆOà×*Ò*¨t¯}ª}Ø $× AÑ AØ ×)Ñ)Ø!Ø#Ø%Ø*Ø,Øó!‘ñ !-Ø!Ø#Ø%Ø*Ø,Øó!�ð *¨!Ñ,ˆMâ Ø&9¸]È1Ñ=MÐ<OÑ&OÑ#ðM&	PñP  Ø 1°]Ð4DÑ DÐáÜÑm ]Ð4EÐGZÐ$[ÔmÓmÐmÜØ+Ø+Ø*ô
ð 	
r&   r=   )NFFFNT)r!   r"   r#   r   r   rÓ   r?   r2   rK   r–   r   r”   r   r   rE   rM   rN   s   @r'   r@  r@  ž  s®   ø„ ñ,Ð3ð ,À(È5Á/ð ,Ð]aõ ,ð0 -1Ø"'Ø%*Ø).Ø04Ø ñ>
à—|‘|ð>
ð ˜EŸL™LÑ)ð>
ð  ð	>
ð
 #ð>
ð #'ð>
ð ˜U 3¨ 8™_Ñ-ð>
ð ð>
ð 
ˆu�oÐ%Ñ	&÷>
r&   r@  c                   ó6   — e Zd ZdZeZdZdZdZdgZ	dgZ
dZd„ Zy)	ÚData2VecVisionPreTrainedModelz†
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    Údata2vec_visionrƒ   Tr
  z.*relative_position_index.*c                 óö  — t        |t        j                  t        j                  t        j                  f«      rm|j
                  j                  j                  d| j                  j                  ¬«       |j                  �%|j                  j                  j                  «        yyt        |t        j                  «      rz|j
                  j                  j                  d| j                  j                  ¬«       |j                  �2|j
                  j                  |j                     j                  «        yyt        |t        j                  «      rJ|j                  j                  j                  «        |j
                  j                  j                  d«       yt        |t         «      r†|j"                  j                  j                  «        |j$                  �$|j$                  j                  j                  «        |j&                  �%|j&                  j                  j                  «        yyt        |t(        «      r%|j*                  j                  j                  «        yt        |t,        «      r€|j.                  �s|j.                  j                  j                  | j                  j0                  «       |j2                  j                  j                  | j                  j0                  «       yyy)zInitialize the weightsr-   )ÚmeanÚstdNg      ð?)r\   r   r°   rž   ÚConvTranspose2dÚweightÚdataÚnormal_rQ   Úinitializer_rangerª   Úzero_Ú	EmbeddingÚpadding_idxr  Úfill_rP   rV   rX   rc   r¶   r#  r
  r  r  r  )r@   Úmodules     r'   Ú_init_weightsz+Data2VecVisionPreTrainedModel._init_weights  s  € ä�fœrŸy™y¬"¯)©)´R×5GÑ5GÐHÔIð �M‰M×Ñ×&Ñ&¨C°T·[±[×5RÑ5RÐ&ÔSØ�{‰{Ð&Ø—‘× Ñ ×&Ñ&Õ(ð 'ä˜¤§¡Ô-Ø�M‰M×Ñ×&Ñ&¨C°T·[±[×5RÑ5RÐ&ÔSØ×!Ñ!Ð-Ø—‘×"Ñ" 6×#5Ñ#5Ñ6×<Ñ<Õ>ð .ä˜¤§¡Ô-Ø�K‰K×Ñ×"Ñ"Ô$Ø�M‰M×Ñ×$Ñ$ SÕ)Ü˜Ô 8Ô9Ø×Ñ×!Ñ!×'Ñ'Ô)Ø× Ñ Ð,Ø×!Ñ!×&Ñ&×,Ñ,Ô.Ø×)Ñ)Ð5Ø×*Ñ*×/Ñ/×5Ñ5Õ7ð 6ä˜Ô BÔCØ×/Ñ/×4Ñ4×:Ñ:Õ<Ü˜Ô 3Ô4Ø�‰Ð*Ø—‘×$Ñ$×*Ñ*¨4¯;©;×+MÑ+MÔNØ—‘×$Ñ$×*Ñ*¨4¯;©;×+MÑ+MÕNð +ð 5r&   N)r!   r"   r#   r$   r   Úconfig_classÚbase_model_prefixÚmain_input_nameÚsupports_gradient_checkpointingÚ_no_split_modulesÚ"_keys_to_ignore_on_load_unexpectedÚ_supports_sdparn  r%   r&   r'   r_  r_  ö  s<   „ ñð
 (€LØ)ÐØ$€OØ&*Ð#Ø.Ð/ÐØ*HÐ)IÐ&Ø€NóOr&   r_  aP  
    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 ([`Data2VecVisionConfig`]): 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.
aß  
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`BeitImageProcessor.__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.
        interpolate_pos_encoding (`bool`, *optional*, defaults to `False`):
            Whether to interpolate the pre-trained position encodings.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
zhThe bare Data2VecVision Model transformer outputting raw hidden-states without any specific head on top.c                   ó
  ‡ — e Zd Zddededdfˆ fd„Zd„ Zd„ Z ee	«       e
eeede¬	«      	 	 	 	 	 	 dd
ej                   deej$                     deej                      dee   dee   dedee   deeef   fd„«       «       Zˆ xZS )ÚData2VecVisionModelrQ   Úadd_pooling_layerr+   Nc                 óš  •— t         ‰| �  |«       || _        t        |«      | _        t        || j                  j                  j                  ¬«      | _        |j                  rt        j                  «       n*t        j                  |j                  |j                  ¬«      | _        |rt!        |«      nd | _        | j%                  «        y )Nr«   r  )r>   r?   rQ   rP   rg   r@  rZ   r�   ÚencoderÚuse_mean_poolingr   r  r  rU   r  Ú	layernormÚData2VecVisionPoolerÚpoolerÚ	post_init)r@   rQ   rx  rA   s      €r'   r?   zData2VecVisionModel.__init__K  s•   ø€ Ü‰Ñ˜Ô ØˆŒä2°6Ó:ˆŒÜ,¨VÀÇÁ×AaÑAa×AmÑAmÔnˆŒð $×4Ò4ŒB�K‰KŒM¼"¿,¹,Àv×GYÑGYÐ_e×_tÑ_tÔ:uð 	Œñ 7HÔ*¨6Ô2ÈTˆŒð 	�‰Õr&   c                 ó.   — | j                   j                  S r=   )rg   rZ   rH   s    r'   Úget_input_embeddingsz(Data2VecVisionModel.get_input_embeddingsZ  s   € Ø�‰×/Ñ/Ð/r&   c                 ó˜   — |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)Úitemsrz  rI  rñ   rù   )r@   Úheads_to_prunerI  r÷   s       r'   Ú_prune_headsz Data2VecVisionModel._prune_heads]  sE   € ð
 +×0Ñ0Ó2ò 	C‰LˆE�5Ø�L‰L×Ñ˜uÑ%×/Ñ/×;Ñ;¸EÕBñ	Cr&   Úvision)Ú
checkpointÚoutput_typero  ÚmodalityÚexpected_outputrƒ   r„   r½   r¾   rM  r‚   rN  c           	      ó:  — |�|n| j                   j                  }|�|n| j                   j                  }|�|n| j                   j                  }| j	                  || j                   j
                  «      }| j                  ||¬«      \  }}	|j                  dd }
| j                  |||||
||¬«      }|d   }| j                  |«      }| j                  �| j                  |«      nd}|s|�||fn|f}||dd z   S t        |||j                  |j                  ¬«      S )zË
        bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`, *optional*):
            Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).
        N)r„   rl   )r½   r¾   rM  r¿   rN  r‚   r   r   )rT  Úpooler_outputrB   rU  )rQ   r¾   rM  Úuse_return_dictÚget_head_maskrD  rg   r0   rz  r|  r~  r    rB   rU  )r@   rƒ   r„   r½   r¾   rM  r‚   rN  Úembedding_outputr‹   r¿   Úencoder_outputsÚsequence_outputÚpooled_outputÚhead_outputss                  r'   rE   zData2VecVisionModel.forwarde  sE  € ð, 2CÐ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð &1Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆð ×&Ñ& y°$·+±+×2OÑ2OÓPˆ	à"Ÿo™o¨lÈO˜oÓ\ÑÐ˜!Ø!×'Ñ'¨¨Ð+ˆ
àŸ,™,ØØØ/Ø!5Ø!Ø#Ø%=ð 'ó 
ˆð *¨!Ñ,ˆØŸ.™.¨Ó9ˆØ8<¿¹Ð8O˜Ÿ™ OÔ4ÐUYˆáØ?LÐ?X˜O¨]Ñ;Ð_nÐ^pˆLØ /°!°"Ð"5Ñ5Ð5ä3Ø-Ø'Ø)×7Ñ7Ø&×1Ñ1ô	
ð 	
r&   )F)NNNNFN)r!   r"   r#   r   r–   r?   r�  r…  r   Ú DATA2VEC_VISION_INPUTS_DOCSTRINGr   Ú_CHECKPOINT_FOR_DOCr    Ú_CONFIG_FOR_DOCÚ_EXPECTED_OUTPUT_SHAPEr2   rK   r   r•   r   rÓ   rE   rM   rN   s   @r'   rw  rw  E  sò   ø„ ñÐ3ð Èð ÐY]õ ò0òCñ +Ð+KÓLÙØ&Ø8Ø$ØØ.ôð 7;Ø,0Ø,0Ø/3Ø).Ø&*ñ4
à—l‘lð4
ð " %×"2Ñ"2Ñ3ð4
ð ˜EŸL™LÑ)ð	4
ð
 $ D™>ð4
ð ' t™nð4
ð #'ð4
ð ˜d‘^ð4
ð 
ˆuÐ:Ð:Ñ	;ò4
óó Mô4
r&   rw  c                   ó`   ‡ — e Zd Zdeddfˆ fd„Zdej                  dej                  fd„Zˆ xZS )r}  rQ   r+   Nc                 óª   •— t         ‰| �  «        |j                  r1t        j                  |j
                  |j                  ¬«      | _        y d | _        y )Nr  )r>   r?   r{  r   r  rU   r  r|  rä   s     €r'   r?   zData2VecVisionPooler.__init__¦  sA   ø€ Ü‰ÑÔàKQ×KbÒKbŒB�L‰L˜×+Ñ+°×1FÑ1FÔGð 	�Øhlð 	�r&   rB   c                 ó�   — | j                   �0|d d …dd …d d …f   }| j                  |j                  d«      «      }|S |d d …df   }|S )Nr   r   )r|  rb  )r@   rB   Úpatch_tokensr’  s       r'   rE   zData2VecVisionPooler.forward¬  sU   € Ø�>‰>Ð%à(ª¨A©B²¨Ñ2ˆLØ ŸN™N¨<×+<Ñ+<¸QÓ+?Ó@ˆMð
 Ðð *ª!¨Q¨$Ñ/ˆMàÐr&   r  rN   s   @r'   r}  r}  ¥  s2   ø„ ð
Ð3ð 
¸õ 
ð	 U§\¡\ð 	°e·l±l÷ 	r&   r}  zÀ
    Data2VecVision Model transformer with an image classification head on top (a linear layer on top of the average of
    the final hidden states of the patch tokens) e.g. for ImageNet.
    c                   óþ   ‡ — e Zd Zdeddfˆ fd„Z ee«       eee	e
e¬«      	 	 	 	 	 	 	 ddeej                     deej                     deej                     d	ee   d
ee   dedee   deee	f   fd„«       «       Zˆ xZS )Ú$Data2VecVisionForImageClassificationrQ   r+   Nc                 ó.  •— t         ‰| �  |«       |j                  | _        t        |d¬«      | _        |j                  dkD  r*t        j                  |j                  |j                  «      nt        j                  «       | _	        | j                  «        y )NT©rx  r   )r>   r?   Ú
num_labelsrw  r`  r   r°   rU   r  Ú
classifierr  rä   s     €r'   r?   z-Data2VecVisionForImageClassification.__init__Á  st   ø€ Ü‰Ñ˜Ô à ×+Ñ+ˆŒÜ2°6ÈTÔRˆÔð OU×N_ÑN_ÐbcÒNcœ"Ÿ)™) F×$6Ñ$6¸×8IÑ8IÔJÔik×itÑitÓivˆŒð 	�‰Õr&   )r‡  rˆ  ro  rŠ  rƒ   r½   Úlabelsr¾   rM  r‚   rN  c                 ó4  — |�|n| j                   j                  }| j                  ||||||¬«      }|r|j                  n|d   }	| j	                  |	«      }
d}|��‡| j                   j
                  €�| j                  dk(  rd| j                   _        nl| j                  dkD  rL|j                  t        j                  k(  s|j                  t        j                  k(  rd| j                   _        nd| j                   _        | j                   j
                  dk(  rIt        «       }| j                  dk(  r& ||
j                  «       |j                  «       «      }nŒ ||
|«      }n‚| j                   j
                  dk(  r=t        «       } ||
j                  d| j                  «      |j                  d«      «      }n,| j                   j
                  dk(  rt        «       } ||
|«      }|s|
f|dd z   }|�|f|z   S |S t!        ||
|j"                  |j$                  ¬	«      S )
aŠ  
        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
        N©r½   r¾   rM  r‚   rN  r   Ú
regressionÚsingle_label_classificationÚmulti_label_classificationrk   rl   ©ÚlossÚlogitsrB   rU  )rQ   r�  r`  rŒ  r¡  Úproblem_typer   r.   r2   Úlongr”   r   r6  r
   rz   r	   r   rB   rU  )r@   rƒ   r½   r¢  r¾   rM  r‚   rN  rÑ   r’  rª  r©  Úloss_fctr8   s                 r'   rE   z,Data2VecVisionForImageClassification.forwardÍ  sÝ  € ð. &1Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆØ×&Ñ&ØØØ/Ø!5Ø%=Ø#ð 'ó 
ˆñ 2=˜×-Ò-À'È!Á*ˆà—‘ Ó/ˆàˆØÑØ�{‰{×'Ñ'Ð/Ø—?‘? aÒ'Ø/;�D—K‘KÕ,Ø—_‘_ qÒ(¨f¯l©l¼e¿j¹jÒ.HÈFÏLÉLÔ\a×\eÑ\eÒLeØ/L�D—K‘KÕ,à/K�D—K‘KÔ,à�{‰{×'Ñ'¨<Ò7Ü"›9�Ø—?‘? aÒ'Ù# F§N¡NÓ$4°f·n±nÓ6FÓG‘Dá# F¨FÓ3‘DØ—‘×)Ñ)Ð-JÒJÜ+Ó-�Ù §¡¨B°·±Ó @À&Ç+Á+ÈbÃ/ÓR‘Ø—‘×)Ñ)Ð-IÒIÜ,Ó.�Ù ¨Ó/�ÙØ�Y ¨¨ Ñ,ˆFØ)-Ð)9�T�G˜fÑ$ÐE¸vÐEä$ØØØ!×/Ñ/Ø×)Ñ)ô	
ð 	
r&   ©NNNNNFN)r!   r"   r#   r   r?   r   r”  r   Ú_IMAGE_CLASS_CHECKPOINTr   r–  Ú_IMAGE_CLASS_EXPECTED_OUTPUTr   r2   rK   r–   r   rÓ   rE   rM   rN   s   @r'   r�  r�  ¸  sâ   ø„ ð
Ð3ð 
¸õ 
ñ +Ð+KÓLÙØ*Ø)Ø$Ø4ô	ð 04Ø,0Ø)-Ø,0Ø/3Ø).Ø&*ñ=
à˜uŸ|™|Ñ,ð=
ð ˜EŸL™LÑ)ð=
ð ˜Ÿ™Ñ&ð	=
ð
 $ D™>ð=
ð ' t™nð=
ð #'ð=
ð ˜d‘^ð=
ð 
ˆuÐ+Ð+Ñ	,ò=
óó Mô=
r&   r�  c                   ó¾   ‡ — e Zd ZdZ	 	 	 ddededeeeeef   f   deeeeef   ef   dedeeeeef   f   dd	fˆ fd
„Z	de
j                  de
j                  fd„Zˆ xZS )ÚData2VecVisionConvModuleaD  
    A convolutional block that bundles conv/norm/activation layers. This block simplifies the usage of convolution
    layers, which are commonly used with a norm layer (e.g., BatchNorm) and activation layer (e.g., ReLU).

    Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation.
    Úin_channelsÚout_channelsrš   Úpaddingrª   Údilationr+   Nc                 óÈ   •— t         ‰| �  «        t        j                  ||||||¬«      | _        t        j
                  |«      | _        t        j                  «       | _        y )N)r³  r´  rš   rµ  rª   r¶  )	r>   r?   r   rž   ÚconvÚBatchNorm2dÚbnÚReLUÚ
activation)r@   r³  r´  rš   rµ  rª   r¶  rA   s          €r'   r?   z!Data2VecVisionConvModule.__init__  sQ   ø€ ô 	‰ÑÔÜ—I‘IØ#Ø%Ø#ØØØô
ˆŒ	ô —.‘. Ó.ˆŒÜŸ'™'›)ˆ�r&   r(   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S r=   )r¸  rº  r¼  )r@   r(   r8   s      r'   rE   z Data2VecVisionConvModule.forward2  s0   € Ø—‘˜5Ó!ˆØ—‘˜“ˆØ—‘ Ó(ˆàˆr&   )r   Fr   )r!   r"   r#   r$   r”   r   r   rL   r–   r?   r2   rK   rE   rM   rN   s   @r'   r²  r²    s¯   ø„ ñð 56ØØ01ñ$àð$ð ð$ð ˜3  c¨3 h¡Ð/Ñ0ð	$ð
 �s˜E # s (™O¨SÐ0Ñ1ð$ð ð$ð ˜˜U 3¨ 8™_Ð,Ñ-ð$ð 
õ$ð*˜UŸ\™\ð ¨e¯l©l÷ r&   r²  c                   óh   ‡ — e Zd Zdedededdfˆ fd„Zdej                  dej                  fd„Zˆ xZS )	Ú!Data2VecVisionPyramidPoolingBlockÚ
pool_scaler³  Úchannelsr+   Nc                 óâ   •— t         ‰| �  «        t        j                  |«      t	        ||d¬«      g| _        t        | j
                  «      D ]   \  }}| j                  t        |«      |«       Œ" y )Nr   ©rš   )	r>   r?   r   ÚAdaptiveAvgPool2dr²  ÚlayersrV  Ú
add_modulerL   )r@   rÀ  r³  rÁ  rL  rI  rA   s         €r'   r?   z*Data2VecVisionPyramidPoolingBlock.__init__<  sa   ø€ Ü‰ÑÔä× Ñ  Ó,Ü$ [°(ÈÔJð
ˆŒô " $§+¡+Ó.ò 	+‰HˆAˆuØ�O‰OœC ›F EÕ*ñ	+r&   r(   c                 ó<   — |}| j                   D ]
  } ||«      }Œ |S r=   )rÅ  )r@   r(   Úhidden_staterI  s       r'   rE   z)Data2VecVisionPyramidPoolingBlock.forwardE  s*   € ØˆØ—[‘[ò 	/ˆEÙ  Ó.‰Lð	/àÐr&   )	r!   r"   r#   r”   r?   r2   rK   rE   rM   rN   s   @r'   r¿  r¿  ;  s?   ø„ ð+ 3ð +°Sð +ÀCð +ÈDõ +ð˜UŸ\™\ð ¨e¯l©l÷ r&   r¿  c            
       ó€   ‡ — e Zd ZdZdeedf   dedededdf
ˆ fd	„Zd
ej                  de
ej                     fd„Zˆ xZS )Ú"Data2VecVisionPyramidPoolingModulea²  
    Pyramid Pooling Module (PPM) used in PSPNet.

    Args:
        pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
            Module.
        in_channels (int): Input channels.
        channels (int): Channels after modules, before conv_seg.
        align_corners (bool): align_corners argument of F.interpolate.

    Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation.
    Úpool_scales.r³  rÁ  rq   r+   Nc                 ó  •— t         ‰| �  «        || _        || _        || _        || _        g | _        t        |«      D ]I  \  }}t        |||¬«      }| j                  j                  |«       | j                  t        |«      |«       ŒK y )N)rÀ  r³  rÁ  )r>   r?   rË  rq   r³  rÁ  ÚblocksrV  r¿  ÚappendrÆ  rL   )	r@   rË  r³  rÁ  rq   rL  rÀ  ÚblockrA   s	           €r'   r?   z+Data2VecVisionPyramidPoolingModule.__init__[  sƒ   ø€ Ü‰ÑÔØ&ˆÔØ*ˆÔØ&ˆÔØ ˆŒØˆŒÜ& {Ó3ò 	+‰MˆAˆzÜ5Ø%°;ÈôˆEð �K‰K×Ñ˜uÔ%Ø�O‰OœC ›F EÕ*ñ	+r&   rº   c                 óÚ   — g }| j                   D ]Y  } ||«      }t        j                  j                  ||j	                  «       dd  d| j
                  ¬«      }|j                  |«       Œ[ |S )Nrl   r5  rn   )rÍ  r   rx   ry   ro   rq   rÎ  )r@   rº   Úppm_outsÚppmÚppm_outÚupsampled_ppm_outs         r'   rE   z*Data2VecVisionPyramidPoolingModule.forwardi  sn   € ØˆØ—;‘;ò 	/ˆCÙ˜!“fˆGÜ "§¡× 9Ñ 9Ø˜aŸf™f›h q r˜l°È4×K]ÑK]ð !:ó !Ðð �O‰OÐ-Õ.ð	/ð ˆr&   )r!   r"   r#   r$   r   r”   r–   r?   r2   rK   r   rE   rM   rN   s   @r'   rÊ  rÊ  M  s[   ø„ ñð+ E¨#¨s¨(¡Oð +À#ð +ÐQTð +Ðeið +Ðnrõ +ð˜Ÿ™ð ¨$¨u¯|©|Ñ*<÷ r&   rÊ  c                   ój   ‡ — e Zd ZdZdeddfˆ fd„Zd„ Zdej                  dej                  fd„Z	ˆ xZ
S )	ÚData2VecVisionUperHeadzò
    Unified Perceptual Parsing for Scene Understanding. This head is the implementation of
    [UPerNet](https://arxiv.org/abs/1807.10221).

    Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation.
    rQ   r+   Nc                 ó  •— t         ‰| �  «        |j                  | _        |j                  gdz  | _        |j                  | _        d| _        t        j                  | j
                  |j                  d¬«      | _
        t        | j                  | j                  d   | j
                  | j                  ¬«      | _        t        | j                  d   t        | j                  «      | j
                  z  z   | j
                  dd¬«      | _        t        j                   «       | _        t        j                   «       | _        | j                  d d D ]s  }t        || j
                  d¬«      }t        | j
                  | j
                  dd¬«      }| j"                  j'                  |«       | j$                  j'                  |«       Œu t        t        | j                  «      | j
                  z  | j
                  dd¬«      | _        y )	Né   Fr   rÃ  rk   )rq   r   ©rš   rµ  )r>   r?   rË  rU   r³  rÁ  rq   r   rž   r   r¡  rÊ  Úpsp_modulesr²  rõ   Ú
bottleneckrF  Úlateral_convsÚ	fpn_convsrÎ  Úfpn_bottleneck)r@   rQ   r³  Úl_convÚfpn_convrA   s        €r'   r?   zData2VecVisionUperHead.__init__}  s�  ø€ Ü‰ÑÔà!×-Ñ-ˆÔØ"×.Ñ.Ð/°!Ñ3ˆÔØ×*Ñ*ˆŒØ"ˆÔÜŸ)™) D§M¡M°6×3DÑ3DÐRSÔTˆŒô >Ø×ÑØ×Ñ˜RÑ Ø�M‰MØ×,Ñ,ô	
ˆÔô 3Ø×Ñ˜RÑ ¤3 t×'7Ñ'7Ó#8¸4¿=¹=Ñ#HÑHØ�M‰MØØô	
ˆŒô  Ÿ]™]›_ˆÔÜŸ™›ˆŒØ×+Ñ+¨C¨RÐ0ò 	,ˆKÜ-¨k¸4¿=¹=ÐVWÔXˆFÜ/°·±¸t¿}¹}ÐZ[ÐefÔgˆHØ×Ñ×%Ñ% fÔ-Ø�N‰N×!Ñ! (Õ+ð		,ô 7Ü�× Ñ Ó! D§M¡MÑ1Ø�M‰MØØô	
ˆÕr&   c                 ó¦   — |d   }|g}|j                  | j                  |«      «       t        j                  |d¬«      }| j	                  |«      }|S )Nrk   r   rr   )ÚextendrÚ  r2   r{   rÛ  )r@   Úinputsrº   Úpsp_outsr8   s        r'   Úpsp_forwardz"Data2VecVisionUperHead.psp_forward£  sL   € Ø�2‰JˆØ�3ˆØ�‰˜×(Ñ(¨Ó+Ô,Ü—9‘9˜X¨1Ô-ˆØ—‘ Ó*ˆàˆr&   Úencoder_hidden_statesc                 óP  — t        | j                  «      D ��cg c]  \  }} |||   «      ‘Œ }}}|j                  | j                  |«      «       t	        |«      }t        |dz
  dd«      D ]V  }||dz
     j                  dd  }||dz
     t        j                  j                  ||   |d| j                  ¬«      z   ||dz
  <   ŒX t        |dz
  «      D �cg c]  } | j                  |   ||   «      ‘Œ }}|j                  |d   «       t        |dz
  dd«      D ]E  }t        j                  j                  ||   |d   j                  dd  d| j                  ¬«      ||<   ŒG t        j                  |d¬«      }| j                  |«      }| j                  |«      }|S c c}}w c c}w )Nr   r   rk   rl   r5  rn   rr   )rV  rÜ  rÎ  rå  rõ   rG  r0   r   rx   ry   rq   rÝ  r2   r{   rÞ  r¡  )	r@   ræ  rL  Úlateral_convÚlateralsÚused_backbone_levelsÚ
prev_shapeÚfpn_outsr8   s	            r'   rE   zData2VecVisionUperHead.forward¬  s¸  € äR[Ð\`×\nÑ\nÓRo×p¹¸qÀ,‘LÐ!6°qÑ!9Õ:ÐpˆÑpà�‰˜×(Ñ(Ð)>Ó?Ô@ô  # 8›}ÐÜÐ+¨aÑ/°°BÓ7ò 	ˆAØ! ! a¡%™×.Ñ.¨q¨rÐ2ˆJØ& q¨1¡u™o´·±×0IÑ0IØ˜‘ *°:ÈT×M_ÑM_ð 1Jó 1ñ ˆH�Q˜‘UŠOð	ô =BÐBVÐYZÑBZÓ<[Ö\°qÐ%�D—N‘N 1Ñ% h¨q¡kÕ2Ð\ˆÐ\à�‰˜ ™Ô%äÐ+¨aÑ/°°BÓ7ò 	ˆAÜŸ-™-×3Ñ3Ø˜‘ (¨1¡+×"3Ñ"3°A°BÐ"7¸jÐX\×XjÑXjð 4ó ˆH�QŠKð	ô —9‘9˜X¨1Ô-ˆØ×$Ñ$ XÓ.ˆØ—‘ Ó(ˆàˆùó3 qùò ]s   ™FÃF#)r!   r"   r#   r$   r   r?   rå  r2   rK   rE   rM   rN   s   @r'   rÖ  rÖ  u  s=   ø„ ñð$
Ð3ð $
¸õ $
òLð¨U¯\©\ð ¸e¿l¹l÷ r&   rÖ  c                   óŒ   ‡ — e Zd ZdZ	 	 	 ddedededeeeeef   f   ddf
ˆ fd„Zd	e	j                  de	j                  fd
„Zˆ xZS )ÚData2VecVisionFCNHeadaÝ  
    Fully Convolution Networks for Semantic Segmentation. This head is implemented of
    [FCNNet](https://arxiv.org/abs/1411.4038>).

    Args:
        config (Data2VecVisionConfig): Configuration.
        in_channels
        kernel_size (int): The kernel size for convs in the head. Default: 3.
        dilation (int): The dilation rate for convs in the head. Default: 1.


    Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation.
    rQ   Úin_indexrš   r¶  r+   Nc           
      ó<  •— t         ‰| �  «        |j                  | _        |j                  | _        |j                  | _        |j                  | _	        || _
        |dz  |z  }g }|j                  t        | j                  | j
                  |||¬«      «       t        | j                  dz
  «      D ]5  }|j                  t        | j
                  | j
                  |||¬«      «       Œ7 | j                  dk(  rt        j                  «       | _        nt        j"                  |Ž | _        | j                  r8t        | j                  | j
                  z   | j
                  ||dz  ¬«      | _        t        j&                  | j
                  |j(                  d¬«      | _        y )Nrl   )rš   rµ  r¶  r   r   rÙ  rÃ  )r>   r?   rU   r³  Úauxiliary_channelsrÁ  Úauxiliary_num_convsÚ	num_convsÚauxiliary_concat_inputÚconcat_inputrï  rÎ  r²  rG  r   r  ÚconvsÚ
SequentialÚconv_catrž   r   r¡  )	r@   rQ   rï  rš   r¶  Úconv_paddingrö  rL  rA   s	           €r'   r?   zData2VecVisionFCNHead.__init__Ú  sX  ø€ ô 	‰ÑÔØ!×-Ñ-ˆÔØ×1Ñ1ˆŒØ×3Ñ3ˆŒØ"×9Ñ9ˆÔØ ˆŒà# qÑ(¨HÑ4ˆØˆØ�‰Ü$Ø× Ñ  $§-¡-¸[ÐR^Ðiqôô	
ô
 �t—~‘~¨Ñ)Ó*ò 	ˆAØ�L‰LÜ(Ø—M‘M 4§=¡=¸kÐS_Ðjrôõð	ð �>‰>˜QÒÜŸ™›ˆD�JäŸ™¨Ð.ˆDŒJØ×ÒÜ4Ø× Ñ  4§=¡=Ñ0°$·-±-È[ÐbmÐqrÑbrôˆDŒMô Ÿ)™) D§M¡M°6×3DÑ3DÐRSÔTˆ�r&   ræ  c                 óÐ   — || j                      }| j                  |«      }| j                  r(| j                  t	        j
                  ||gd¬«      «      }| j                  |«      }|S )Nr   rr   )rï  rö  rõ  rø  r2   r{   r¡  )r@   ræ  rB   r8   s       r'   rE   zData2VecVisionFCNHead.forward   sX   € à-¨d¯m©mÑ<ˆØ—‘˜MÓ*ˆØ×ÒØ—]‘]¤5§9¡9¨m¸VÐ-DÈ!Ô#LÓMˆFØ—‘ Ó(ˆØˆr&   )rl   r   r   )r!   r"   r#   r$   r   r”   r   r   r?   r2   rK   rE   rM   rN   s   @r'   rî  rî  Ë  s|   ø„ ñð" ØØ01ñ$Uà$ð$Uð ð$Uð ð	$Uð
 ˜˜U 3¨ 8™_Ð,Ñ-ð$Uð 
õ$UðL¨U¯\©\ð ¸e¿l¹l÷ r&   rî  zp
    Data2VecVision Model transformer with a semantic segmentation head on top e.g. for ADE20k, CityScapes.
    c                   ó   ‡ — e Zd Zdeddfˆ fd„Zd„ Z ee«       ee	e
¬«      	 	 	 	 	 	 	 ddeej                     deej                     d	eej                     d
ee   dee   dedee   deee	f   fd„«       «       Zˆ xZS )Ú%Data2VecVisionForSemanticSegmentationrQ   r+   Nc                 óx  •— t         ‰| �  |«       |j                  | _        t        |d¬«      | _        t        | j                  j                  «      dk7  rt        d«      ‚t        j                  t        j                  |j                  |j                  dd¬«      t        j                  |j                  «      t        j                  «       t        j                  |j                  |j                  dd¬«      «      | _        t        j                  t        j                  |j                  |j                  dd¬«      «      | _        t        j"                  «       | _        t        j&                  dd¬«      | _        t+        |«      | _        |j.                  rt1        |«      nd | _        | j5                  «        y )NFrŸ  rØ  zÑData2VecVisionForSemanticSegmentation requires config.out_indices to be a list of 4 integers, specifying which features to use from the backbone. One can use [3, 5, 7, 11] in case of a base-sized architecture.rl   r™   )r>   r?   r   rw  r`  rõ   rQ   Úout_indicesr¡   r   r÷  rd  rU   r¹  ÚGELUÚfpn1Úfpn2r  Úfpn3Ú	MaxPool2dÚfpn4rÖ  Údecode_headÚuse_auxiliary_headrî  Úauxiliary_headr  rä   s     €r'   r?   z.Data2VecVisionForSemanticSegmentation.__init__  sQ  ø€ Ü‰Ñ˜Ô à ×+Ñ+ˆŒÜ2°6ÈUÔSˆÔô ˆt�{‰{×&Ñ&Ó'¨1Ò,Üð-óð ô
 —M‘MÜ×Ñ˜v×1Ñ1°6×3EÑ3EÐSTÐ]^Ô_Ü�N‰N˜6×-Ñ-Ó.Ü�G‰G‹IÜ×Ñ˜v×1Ñ1°6×3EÑ3EÐSTÐ]^Ô_ó	
ˆŒ	ô —M‘MÜ×Ñ˜v×1Ñ1°6×3EÑ3EÐSTÐ]^Ô_ó
ˆŒ	ô —K‘K“MˆŒ	Ü—L‘L¨Q°qÔ9ˆŒ	ô 2°&Ó9ˆÔØ?E×?XÒ?XÔ3°FÔ;Ð^bˆÔð 	�‰Õr&   c                 ón  — t         j                  j                  ||j                  dd  dd¬«      }|�0t         j                  j                  ||j                  dd  dd¬«      }t	        | j
                  j                  ¬«      } |||«      }|}|�% ||«      }	|| j
                  j                  |	z  z  }|S )NrÁ   r5  Frn   )Úignore_index)r   rx   ry   r0   r
   rQ   Úsemantic_loss_ignore_indexÚauxiliary_loss_weight)
r@   rª  Úauxiliary_logitsr¢  Úupsampled_logitsÚupsampled_auxiliary_logitsr­  Ú	main_lossr©  Úauxiliary_losss
             r'   Úcompute_lossz2Data2VecVisionForSemanticSegmentation.compute_loss2  sÁ   € äŸ=™=×4Ñ4Ø˜Ÿ™ b cÐ*°È5ð 5ó 
Ðð Ð'Ü)+¯©×)BÑ)BØ  v§|¡|°B°CÐ'8¸zÐY^ð *Có *Ð&ô $°·±×1WÑ1WÔXˆÙÐ-¨vÓ6ˆ	ØˆØÐ'Ù%Ð&@À&ÓIˆNØ�D—K‘K×5Ñ5¸ÑFÑFˆDàˆr&   )rˆ  ro  rƒ   r½   r¢  r¾   rM  r‚   rN  c           	      óT  — |�|n| j                   j                  }|�|n| j                   j                  }|�$| j                   j                  dk(  rt	        d«      ‚| j                  |||d||¬«      }|r|j                  n|d   }	t        |	«      D �
�cg c]#  \  }
}|
dz   | j                   j                  v sŒ"|‘Œ% }}
}|j                  d   }| j                   j                  | j                   j                  z  }|D �cg c]3  }|dd…dd…dd…f   j                  ddd«      j                  |d||«      ‘Œ5 }}| j                  | j                  | j                   | j"                  g}t%        t'        |«      «      D ]  } ||   ||   «      ||<   Œ | j)                  |«      }d}| j*                  �| j+                  |«      }d}|�| j-                  |||«      }|s|r
|f|dd z   }n	|f|dd z   }|�|f|z   S |S t/        |||r|j                  nd|j0                  ¬	«      S c c}}
w c c}w )
aR  
        labels (`torch.LongTensor` of shape `(batch_size, height, width)`, *optional*):
            Ground truth semantic segmentation maps for computing the loss. Indices should be in `[0, ...,
            config.num_labels - 1]`. If `config.num_labels > 1`, a classification loss is computed (Cross-Entropy).

        Returns:

        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, Data2VecVisionForSemanticSegmentation
        >>> from PIL import Image
        >>> import requests

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = Image.open(requests.get(url, stream=True).raw)

        >>> image_processor = AutoImageProcessor.from_pretrained("facebook/data2vec-vision-base")
        >>> model = Data2VecVisionForSemanticSegmentation.from_pretrained("facebook/data2vec-vision-base")

        >>> inputs = image_processor(images=image, return_tensors="pt")
        >>> outputs = model(**inputs)
        >>> # logits are of shape (batch_size, num_labels, height, width)
        >>> logits = outputs.logits
        ```Nr   z/The number of labels should be greater than oneTr¤  r   rl   rk   r¨  )rQ   r�  rM  r   r¡   r`  rB   rV  rþ  r0   r]   r[   rw   rv   r   r  r  r  rG  rõ   r  r  r  r   rU  )r@   rƒ   r½   r¢  r¾   rM  r‚   rN  rÑ   ræ  ÚidxÚfeatureÚfeaturesrŽ   Úpatch_resolutionrº   ÚopsrL  rª  r  r©  r8   s                         r'   rE   z-Data2VecVisionForSemanticSegmentation.forwardE  sd  € ðJ &1Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð Ð $§+¡+×"8Ñ"8¸AÒ"=ÜÐNÓOÐOà×&Ñ&ØØØ/Ø!%Ø%=Ø#ð 'ó 
ˆñ :E × 5Ò 5È'ÐRSÉ*Ðô 1:Ð:OÓ0P×w¡  WÐTWÐZ[ÑT[Ð_c×_jÑ_j×_vÑ_vÒTv’GÐwˆÑwØ!×'Ñ'¨Ñ*ˆ
ØŸ;™;×1Ñ1°T·[±[×5KÑ5KÑKÐànvö
ØijˆAŠa�‘’Qˆh‰K×Ñ  1 aÓ(×0Ñ0°¸RÐAQÐScÕdð
ˆð 
ð
 �y‰y˜$Ÿ)™) T§Y¡Y°·	±	Ð:ˆÜ”s˜8“}Ó%ò 	.ˆAØ ˜#˜a™& ¨!¡Ó-ˆH�QŠKð	.ð ×!Ñ! (Ó+ˆàÐØ×ÑÐ*Ø#×2Ñ2°8Ó<ÐàˆØÐØ×$Ñ$ VÐ-=¸vÓFˆDáÙ#Ø ˜ W¨Q¨R [Ñ0‘à ˜ W¨Q¨R [Ñ0�Ø)-Ð)9�T�G˜fÑ$ÐE¸vÐEä&ØØÙ3G˜'×/Ò/ÈTØ×)Ñ)ô	
ð 	
ùó; xùò
s   Â#HÂ7HÃ>8H%r®  )r!   r"   r#   r   r?   r  r   r”  r   r   r–  r   r2   rK   r–   r   rÓ   rE   rM   rN   s   @r'   rü  rü  
  së   ø„ ðÐ3ð ¸õ ò@ñ& +Ð+KÓLÙÐ+BÐQ`Ôað 04Ø,0Ø)-Ø,0Ø/3Ø).Ø&*ñZ
à˜uŸ|™|Ñ,ðZ
ð ˜EŸL™LÑ)ðZ
ð ˜Ÿ™Ñ&ð	Z
ð
 $ D™>ðZ
ð ' t™nðZ
ð #'ðZ
ð ˜d‘^ðZ
ð 
ˆuÐ-Ð-Ñ	.òZ
ó bó MôZ
r&   rü  )r�  rü  rw  r_  )r-   F)Qr$   Úcollections.abcr^   rÅ   r†   Údataclassesr   Útypingr   r   r   r   r2   Útorch.utils.checkpointr   Útorch.nnr	   r
   r   Úactivationsr   Úmodeling_outputsr   r   r   r   Úmodeling_utilsr   Úpytorch_utilsr   r   r   Úutilsr   r   r   r   r   r   Úconfiguration_data2vec_visionr   Ú
get_loggerr!   rÛ   r–  r•  r—  r¯  r°  r    rK   rJ   r–   r9   ÚModuler;   rP   rY   r¥   rÕ   rá   rï   rí   rþ   r  r
  r¶   r@  r_  ÚDATA2VEC_VISION_START_DOCSTRINGr”  rw  r}  r�  r²  r¿  rÊ  rÖ  rî  rü  Ú__all__r%   r&   r'   ú<module>r'     sÆ  ðñ $ã Û Û Ý !ß /Ó /ã Û Ý ß AÑ Aå !÷ó õ .ß vÑ v÷÷ õ @ð 
ˆ×	Ñ	˜HÓ	%€ð )€ð 6Ð Ú&Ð ð ?Ð Ø7Ð ð ôÐ+Eó ó ðñ4�U—\‘\ð ¨eð ÀTð ÐV[×VbÑVbó ô*-˜RŸY™Yô -ôc7˜rŸy™yô c7ôN#7 B§I¡Iô #7ôNP "§)¡)ô Pôh;#Ð&Aô ;#ô~˜rŸy™yô ð& )Ø+ñ*Ð &ô+˜bŸi™iô +ô^ §¡ô ô"
˜2Ÿ9™9ô 
ô@˜"Ÿ)™)ô @ôHP3¨¯©ô P3ôhT
˜BŸI™Iô T
ôp(O Oô (OðV	#Ð ð$Ð  ñ2 ØnØ#óô
W
Ð7ó W
óð
W
ôv˜2Ÿ9™9ô ñ& ðð $óôQ
Ð+Hó Q
óðQ
ôj"˜rŸy™yô "ôL¨¯	©	ô ô$$¨¯©ô $ôPR˜RŸY™Yô Rôl<˜BŸI™Iô <ñ~ ðð $ó	ôP
Ð,Ió P
óðP
òf�r&   