Ë
    ÛÓ^j¼Ï  ã                   óŒ  — d Z ddlZddlZddlmZ ddlmZ ddlZddlm	Z	 ddl
mZ ddlmZ dd	lmZ dd
lmZ ddlmZmZmZmZ ddlmZ ddlmZ ddlmZmZmZ ddl m!Z!  ejD                  e#«      Z$ ed¬«      e G d„ de«      «       «       Z% G d„ de	jL                  «      Z' G d„ de	jL                  «      Z( 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                  «      Z0 G d(„ d)e«      Z1 G d*„ d+e	jL                  «      Z2 G d,„ d-e	jL                  «      Z3e G d.„ d/e«      «       Z4e G d0„ d1e4«      «       Z5 G d2„ d3e	jL                  «      Z6 ed4¬«       G d5„ d6e4«      «       Z7 G d7„ d8e	jL                  «      Z8 G d9„ d:e	jL                  «      Z9 G d;„ d<e	jL                  «      Z: G d=„ d>e	jL                  «      Z; G d?„ d@e	jL                  «      Z<e G dA„ dBe4«      «       Z=g dC¢Z>y)DzPyTorch Data2VecVision model.é    N)Ú	dataclass)ÚOptional)Únn)ÚCrossEntropyLossé   )Úinitialization)ÚACT2FN)ÚGradientCheckpointingLayer)ÚBaseModelOutputÚBaseModelOutputWithPoolingÚImageClassifierOutputÚSemanticSegmenterOutput)ÚPreTrainedModel)Ú#compile_compatible_method_lru_cache)Úauto_docstringÚloggingÚ	torch_inté   )ÚData2VecVisionConfigz7
    Class for outputs of [`Data2VecVisionModel`].
    )Úcustom_introc                   ó   — e Zd ZdZy)Ú$Data2VecVisionModelOutputWithPoolingaF  
    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.
    N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__© ó    ú€/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/data2vec/modeling_data2vec_vision.pyr   r   +   s   „ ò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j                  dz  dej                  fd„Zˆ xZS )ÚData2VecVisionEmbeddingszc
    Construct the CLS token, position and patch embeddings. Optionally, also the mask token.

    ÚconfigÚreturnNc                 ó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   )ÚsuperÚ__init__r   Ú	ParameterÚtorchÚ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)Úselfr"   r6   Ú	__class__s      €r   r&   z!Data2VecVisionEmbeddings.__init__B   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)Úshaper8   r(   ÚjitÚ
is_tracingr0   r   ÚreshapeÚpermuter   Ú
functionalÚinterpolateÚviewÚcat)r<   r>   r?   r@   r6   Únum_positionsÚclass_pos_embedÚpatch_pos_embedrJ   Ú
new_heightÚ	new_widthÚsqrt_num_positionss               r   Úinterpolate_pos_encodingz1Data2VecVisionEmbeddings.interpolate_pos_encodingY   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_posc                 óò  — |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 ©NrB   r   rI   )rK   r/   rF   r-   ÚexpandÚ	unsqueezeÚtype_asr+   r(   rS   r8   rZ   r;   )r<   r[   r\   Ú_r?   r@   r>   Úpatch_heightÚpatch_widthÚ
batch_sizeÚseq_lenÚmask_tokensÚwÚ
cls_tokenss                 r   Úforwardz Data2VecVisionEmbeddings.forward�   s  € ð
 +×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   ©N)r   r   r   r   r   r&   r(   ÚTensorÚintrZ   Ú
BoolTensorrj   Ú__classcell__©r=   s   @r   r!   r!   <   sˆ   ø„ ñð
>Ð3ð >¸õ >ð.&D°5·<±<ð &DÈð &DÐUXð &DÐ]b×]iÑ]ió &DðV 48ñ7à—l‘lð7ð ×)Ñ)¨DÑ0ð7ð 
�‰÷	7r   r!   c                   óZ   ‡ — e Zd ZdZˆ fd„Zdej                  dej                  fd„Zˆ xZS )r.   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&   r2   r0   Únum_channelsr*   r1   r3   r4   r5   r6   Úpatch_shaper   ÚConv2dÚ
projection)	r<   r"   r2   r0   rv   r*   r6   rw   r=   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	                  | j                  j
                  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.rC   r   r   )	rK   rv   Ú
ValueErrorry   ÚtoÚweightÚdtypeÚflattenÚ	transpose)	r<   r[   re   rv   r?   r@   r>   rc   rd   s	            r   rj   z%Data2VecVisionPatchEmbeddings.forward´   s©   € Ø2>×2DÑ2DÑ/ˆ
�L &¨%Ø˜4×,Ñ,Ò,ÜØwóð ð —_‘_ \§_¡_°T·_±_×5KÑ5K×5QÑ5QÓ%RÓSˆ
Ø$.×$4Ñ$4°QÑ$7¸×9IÑ9IÈ!Ñ9L�kˆØ×'Ñ'¨Ó*×4Ñ4°Q¸Ó:ˆ
à˜L¨+Ð6Ð6Ð6r   )	r   r   r   r   r&   r(   rl   rj   ro   rp   s   @r   r.   r.   œ   s)   ø„ ñôjð"7 E§L¡Lð 7°U·\±\÷ 7r   r.   c                   óê   ‡ — e Zd Zddededz  ddfˆ fd„Z	 	 	 	 ddej                  dedej                  dz  d	ed
ee	   dz  deej                     eej                  ej                  f   z  fd„Z
ˆ xZS )ÚData2VecVisionSelfAttentionNr"   Ú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&   r"   r*   Únum_attention_headsÚhasattrr{   rm   Úattention_head_sizeÚall_head_sizer   ÚLinearÚqueryÚkeyÚvaluer9   Úattention_probs_dropout_probr;   ÚboolÚhas_relative_position_biasÚ"Data2VecVisionRelativePositionBiasÚrelative_position_bias©r<   r"   rƒ   r=   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   Úhidden_statesÚoutput_attentionsr•   rZ   Ú
resolutionc                 ó   — |j                   d d }g |¢d‘| j                  ‘­}| j                  |«      j                  |«      j	                  dd«      }| j                  |«      j                  |«      j	                  dd«      }	| j                  |«      j                  |«      j	                  dd«      }
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%                  |«      }t        j                  ||
«      }|j'                  dddd«      j)                  «       }|j+                  «       d d | j,                  fz   } |j                  |Ž }|r||f}|S |f}|S )	NrB   r   rC   éþÿÿÿ©Údim_sizerI   r   r   )rK   r‹   rŽ   rR   r€   r�   r�   r(   ÚmatmulÚmathÚsqrtr“   r"   r0   r•   r   rP   Úsoftmaxr;   rO   Ú
contiguousrF   rŒ   )r<   r—   r˜   r•   rZ   r™   Úinput_shapeÚhidden_shapeÚquery_layerÚ	key_layerÚvalue_layerÚattention_scoresr?   r@   rƒ   Úattention_probsÚcontext_layerÚnew_context_layer_shapeÚoutputss                      r   rj   z#Data2VecVisionSelfAttention.forwardÛ   s  € ð $×)Ñ)¨#¨2Ð.ˆØC˜ÐC bÐC¨$×*BÑ*BÑCˆØ—j‘j Ó/×4Ñ4°\ÓB×LÑLÈQÐPQÓRˆØ—H‘H˜]Ó+×0Ñ0°Ó>×HÑHÈÈAÓNˆ	Ø—j‘j Ó/×4Ñ4°\ÓB×LÑLÈQÐPQÓRˆô !Ÿ<™<¨°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ˆäŸ™ _°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   rk   ©FNFN)r   r   r   r   Útupler&   r(   rl   r’   rm   rj   ro   rp   s   @r   r‚   r‚   Ã   sª   ø„ ñnÐ3ð nÀ%È$Á,ð nÐZ^õ nð4 #(Ø6:Ø).Ø(,ñ.à—|‘|ð.ð  ð.ð !&§¡¨tÑ 3ð	.ð
 #'ð.ð ˜#‘J Ñ%ð.ð 
ˆu�|‰|Ñ	˜u U§\¡\°5·<±<Ð%?Ñ@Ñ	@÷.r   r‚   c                   óÂ   — e Zd Z	 	 	 	 d	dej                  dedej                  dz  dedee   dz  deej                     eej                  ej                  f   z  fd„Zy)
ÚData2VecVisionSdpaSelfAttentionNr—   r˜   r•   rZ   r™   r#   c           	      ó:  — |r,t         j                  | j                  j                  › d�«       |j                  d d }g |¢d‘| j
                  ‘­}| j                  |«      j                  |«      j                  dd«      }| j                  |«      j                  |«      j                  dd«      }	| j                  |«      j                  |«      j                  dd«      }
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
«      j1                  «       }|j3                  «       d d | j4                  fz   } |j                  |Ž }|d fS )NzÁ does not support `output_attentions=True`. The returned attention weights will be `None`. If you want to get attention weights, please set `attn_implementation='eager'` when loading the model.rB   r   rC   rœ   ç        F)Ú	attn_maskÚ	dropout_pÚ	is_causalÚscaler   r   r›   )ÚloggerÚwarning_oncer=   r   rK   r‹   rŽ   rR   r€   r�   r�   r“   r"   r0   r•   rŸ   r    r(   r   rP   Úscaled_dot_product_attentionÚtrainingr‘   rO   r¢   rF   rŒ   )r<   r—   r˜   r•   rZ   r™   r£   r¤   r¥   r¦   r§   Ú	attn_biasr?   r@   rƒ   Úscalingrª   r«   s                     r   rj   z'Data2VecVisionSdpaSelfAttention.forward  s  € ñ Ü×ÑØ—>‘>×*Ñ*Ð+ð ,Dð Dôð $×)Ñ)¨#¨2Ð.ˆØC˜ÐC bÐC¨$×*BÑ*BÑCˆØ—j‘j Ó/×4Ñ4°\ÓB×LÑLÈQÐPQÓRˆØ—H‘H˜]Ó+×0Ñ0°Ó>×HÑHÈÈAÓNˆ	Ø—j‘j Ó/×4Ñ4°\ÓB×LÑLÈQÐPQÓRˆàˆ	Ø×*Ò*Ø&‰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   r(   rl   r’   r®   rm   rj   r   r   r   r°   r°     s…   „ ð #(Ø6:Ø).Ø(,ñ/#à—|‘|ð/#ð  ð/#ð !&§¡¨tÑ 3ð	/#ð
 #'ð/#ð ˜#‘J Ñ%ð/#ð 
ˆu�|‰|Ñ	˜u U§\¡\°5·<±<Ð%?Ñ@Ñ	@ô/#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.
    r"   r#   Nc                 óÈ   •— t         ‰| �  «        t        j                  |j                  |j                  «      | _        t        j                  |j                  «      | _        y rk   )	r%   r&   r   r�   r*   Údenser9   r:   r;   ©r<   r"   r=   s     €r   r&   z!Data2VecVisionSelfOutput.__init__G  sB   ø€ Ü‰ÑÔÜ—Y‘Y˜v×1Ñ1°6×3EÑ3EÓFˆŒ
Ü—z‘z &×"<Ñ"<Ó=ˆ�r   r—   Úinput_tensorc                 óJ   — | j                  |«      }| j                  |«      }|S rk   ©rÀ   r;   )r<   r—   rÂ   Úgammas       r   rj   z Data2VecVisionSelfOutput.forwardL  ó$   € ØŸ
™
 =Ó1ˆØŸ™ ]Ó3ˆàÐr   rk   )
r   r   r   r   r   r&   r(   rl   rj   ro   rp   s   @r   r¾   r¾   A  sE   ø„ ñð
>Ð3ð >¸õ >ñ
 U§\¡\ð ÀÇÁð Ð^c×^jÑ^j÷ r   r¾   )ÚeagerÚsdpac                   óÖ   ‡ — e Zd Zddededz  ddfˆ fd„Z	 	 	 	 ddej                  dede	d	   d
edee
   dz  deej                     eej                  ej                  f   z  fd„Zˆ xZS )ÚData2VecVisionAttentionNr"   rƒ   r#   c                 ó€   •— t         ‰| �  «        t        |j                     ||¬«      | _        t        |«      | _        y )Nrˆ   )r%   r&   Ú&DATA2VEC_VISION_SELF_ATTENTION_CLASSESÚ_attn_implementationÚ	attentionr¾   Úoutputr–   s      €r   r&   z Data2VecVisionAttention.__init__[  s8   ø€ Ü‰ÑÔÜ?À×@[Ñ@[Ñ\Ø ô
ˆŒô /¨vÓ6ˆ�r   r—   r˜   r•   r”   rZ   r™   c                 ól   — | j                  |||||«      }| j                  |d   |«      }|f|dd  z   }|S )Nr   r   )rÎ   rÏ   )	r<   r—   r˜   r•   rZ   r™   Úself_outputsÚattention_outputr¬   s	            r   rj   zData2VecVisionAttention.forwardb  sQ   € ð —~‘~ØÐ,Ð.DÐF^Ð`jó
ˆð  Ÿ;™; |°A¡¸ÓFÐà#Ð%¨°Q°RÐ(8Ñ8ˆØˆr   rk   r­   )r   r   r   r   r®   r&   r(   rl   r’   r   rm   rj   ro   rp   s   @r   rÊ   rÊ   Z  s£   ø„ ñ7Ð3ð 7À%È$Á,ð 7ÐZ^õ 7ð #(ØQUØ).Ø(,ñà—|‘|ðð  ðð !)Ð)MÑ Nð	ð
 #'ðð ˜#‘J Ñ%ðð 
ˆu�|‰|Ñ	˜u U§\¡\°5·<±<Ð%?Ñ@Ñ	@÷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 )ÚData2VecVisionIntermediater"   r#   Nc                 ó  •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        |j                  t        «      rt        |j                     | _        y |j                  | _        y rk   )r%   r&   r   r�   r*   Úintermediate_sizerÀ   r1   Ú
hidden_actÚstrr	   Úintermediate_act_fnrÁ   s     €r   r&   z#Data2VecVisionIntermediate.__init__v  s]   ø€ Ü‰ÑÔÜ—Y‘Y˜v×1Ñ1°6×3KÑ3KÓLˆŒ
Ü�f×'Ñ'¬Ô-Ü'-¨f×.?Ñ.?Ñ'@ˆDÕ$à'-×'8Ñ'8ˆDÕ$r   r—   c                 óJ   — | j                  |«      }| j                  |«      }|S rk   )rÀ   rÙ   ©r<   r—   s     r   rj   z"Data2VecVisionIntermediate.forward~  s&   € ØŸ
™
 =Ó1ˆØ×0Ñ0°Ó?ˆàÐr   ©	r   r   r   r   r&   r(   rl   rj   ro   rp   s   @r   rÔ   rÔ   u  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 )ÚData2VecVisionOutputr"   r#   Nc                 óÈ   •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        j                  |j                  «      | _	        y rk   )
r%   r&   r   r�   rÖ   r*   rÀ   r9   r:   r;   rÁ   s     €r   r&   zData2VecVisionOutput.__init__‡  sB   ø€ Ü‰ÑÔÜ—Y‘Y˜v×7Ñ7¸×9KÑ9KÓLˆŒ
Ü—z‘z &×"<Ñ"<Ó=ˆ�r   r—   c                 óJ   — | j                  |«      }| j                  |«      }|S rk   rÄ   rÛ   s     r   rj   zData2VecVisionOutput.forwardŒ  rÆ   r   rÜ   rp   s   @r   rÞ   rÞ   †  s2   ø„ ð>Ð3ð >¸õ >ð
 U§\¡\ð °e·l±l÷ r   rÞ   c                   ór   ‡ — e Zd ZdZd	deddfˆ fd„Zdej                  dej                  fd„Zde	fd„Z
ˆ xZS )
ÚData2VecVisionDropPathzÏStochastic depth (DropPath) per sample, for residual blocks.

    Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
    <https://arxiv.org/abs/1603.09382>`_.
    Ú	drop_probr#   Nc                 ó0   •— t         ‰| �  «        || _        y rk   )r%   r&   rã   )r<   rã   r=   s     €r   r&   zData2VecVisionDropPath.__init__›  s   ø€ Ü‰ÑÔØ"ˆ�r   r—   c                 óP  — | j                   dk(  s| j                  s|S d| j                   z
  }|j                  d   fd|j                  dz
  z  z   }t	        j
                  ||j                  |j                  ¬«      }t	        j                  ||z   «      }|j                  |«      |z  S )Nr²   r   r   )r   )r~   Údevice)
rã   rº   rK   Úndimr(   Úrandr~   ræ   ÚfloorÚdiv)r<   r—   Ú	keep_probrK   Úrandom_tensors        r   rj   zData2VecVisionDropPath.forwardŸ  s—   € Ø�>‰>˜SÒ ¨¯ªØ Ð Ø˜Ÿ™Ñ&ˆ	Ø×$Ñ$ QÑ'Ð)¨D°M×4FÑ4FÈÑ4JÑ,KÑKˆÜŸ
™
 5°×0CÑ0CÈM×L`ÑL`ÔaˆÜŸ™ M°IÑ$=Ó>ˆØ× Ñ  Ó+¨mÑ;Ð;r   c                 ó    — d| j                   › �S )Nzp=)rã   ©r<   s    r   Ú
extra_reprz!Data2VecVisionDropPath.extra_repr¨  s   € Ø�D—N‘NÐ#Ð$Ð$r   )r²   )r   r   r   r   Úfloatr&   r(   rl   rj   rØ   rï   ro   rp   s   @r   râ   râ   ”  sB   ø„ ññ# %ð #°$õ #ð< U§\¡\ð <°e·l±ló <ð%˜C÷ %r   râ   c                   óø   ‡ — e Zd ZdZ	 ddededz  deddfˆ fd„Z	 	 	 	 ddej                  d	e
d
ej                  dz  de
deeef   dz  deej                     eej                  ej                  f   z  fd„Zˆ xZS )ÚData2VecVisionLayerz?This corresponds to the Block class in the timm implementation.Nr"   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_grad)NN)r%   r&   Úchunk_size_feed_forwardÚseq_len_dimrÊ   rÎ   rÔ   ÚintermediaterÞ   rÏ   r   Ú	LayerNormr*   Úlayer_norm_epsÚlayernorm_beforerâ   ÚIdentityÚ	drop_pathÚlayernorm_afterÚlayer_scale_init_valuer'   r(   ÚonesÚlambda_1Úlambda_2)r<   r"   rƒ   ró   Úinit_valuesr=   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À&×BTÑBTÓ7UÑ)UÐeiÔjˆDŒMÜŸL™L¨´u·z±zÀ&×BTÑBTÓ7UÑ)UÐeiÔjˆD�Mà+5Ñ(ˆDŒM˜4�=r   r—   r˜   r•   rZ   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•   rZ   r™   r   r   )rÎ   rý   r  rÿ   r   rú   rÏ   r  )
r<   r—   r˜   r•   rZ   r™   Úself_attention_outputsrÒ   r¬   Úlayer_outputs
             r   rj   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ð   r&   r(   rl   r’   rm   rj   ro   rp   s   @r   rò   rò   ­  s½   ø„ ÙIð gjñ6Ø*ð6Ø9>À¹ð6Ø^cð6à	õ6ð. #(Ø6:Ø).Ø-1ñ'à—|‘|ð'ð  ð'ð !&§¡¨tÑ 3ð	'ð
 #'ð'ð ˜#˜s˜(‘O dÑ*ð'ð 
ˆu�|‰|Ñ	˜u U§\¡\°5·<±<Ð%?Ñ@Ñ	@÷'r   rò   c                   ó¢   ‡ — e Zd Zdededdfˆ fd„Ze 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”   r"   rƒ   r#   Nc                 óò   •— t         ‰| �  «        || _        d|d   z  dz
  d|d   z  dz
  z  dz   | _        t	        j
                  t        j                  | j                  |j                  «      «      | _	        y )NrC   r   r   r   )
r%   r&   rƒ   Únum_relative_distancer   r'   r(   r)   r‰   Úrelative_position_bias_tabler–   s      €r   r&   z+Data2VecVisionRelativePositionBias.__init__ð  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://huggingface.co/papers/2307.14460).
        rC   r   r   r   Úij)ÚindexingN)rF   r~   rB   )r   r   )
r(   ÚmeshgridÚarangeÚstackr   rO   r¢   r)   r~   Úsum)rƒ   r  Úwindow_areaÚgridÚcoordsÚcoords_flattenÚrelative_coordsÚrelative_position_indexs           r   Ú generate_relative_position_indexzCData2VecVisionRelativePositionBias.generate_relative_position_indexù  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   rZ   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.
        rC   r   r   r   NrB   Úbilinear)rF   rG   FrE   )rƒ   r  r  rN   rO   r   rP   rQ   r   r(   rS   r  rR   r¢   r`   Úsqueeze)r<   rƒ   rZ   r�   Ú
old_heightÚ	old_widthrW   rX   Ú old_relative_position_bias_tableÚold_num_relative_distanceÚnew_num_relative_distanceÚold_sub_tableÚnew_sub_tableÚ new_relative_position_bias_tabler  r•   s                   r   rj   z*Data2VecVisionRelativePositionBias.forward  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&   Ústaticmethodr   rm   r(   rl   r  r’   rj   ro   rp   s   @r   r”   r”   ï  ss   ø„ ð
Ð3ð 
À%ð 
ÈDõ 
ð Ù(°Ô4ð'°e¸CÀ¸H±oð 'È%Ï,É,ò 'ó 5ó ð'ñ0-3¸Tð -3Ð]b×]iÑ]i÷ -3r   r”   c                   óŽ   ‡ — e Zd Zddededz  ddfˆ fd„Z	 	 	 	 	 ddej                  deded	ed
ee	e	f   dz  dedee
z  fd„Zˆ xZS )ÚData2VecVisionEncoderNr"   rƒ   r#   c                 óð  •— t         ‰| �  «        || _        |j                  | _        | j                  rt        ||¬«      | _        t        j                  d|j                  |j                  d¬«      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   Úcpu)ræ   )rƒ   ró   F)r%   r&   r"   Ú!use_shared_relative_position_biasr“   r”   r•   r(   Úlinspaceró   Únum_hidden_layersÚitemr   Ú
ModuleListÚrangerò   Úuse_relative_position_biasÚlayerÚgradient_checkpointing)r<   r"   rƒ   ÚxÚdprÚir=   s         €r   r&   zData2VecVisionEncoder.__init__E  sÚ   ø€ Ü‰ÑÔØˆŒØ*0×*RÑ*RˆÔ'Ø×*Ò*Ü*LÈVÐalÔ*mˆDÔ'ô "'§¡°°6×3HÑ3HÈ&×JbÑJbÐkpÔ!qÖr˜Aˆq�v‰v�xÐrˆÐrÜ—]‘]ô ˜v×7Ñ7Ó8öð ô $ØØ/5×/PÒ/P¡ÐVZØ#& q¡6öòó	
ˆŒ
ð ',ˆÕ#ùò sùòs   Á5C.Â4&C3r—   r˜   Úoutput_hidden_statesrZ   r™   Úreturn_dictc                 óÈ  — |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 } |
|||||¬«      }|d   }|sŒŠ||d   fz   }Œ” |r||fz   }|st        d„ |||fD «       «      S t        |||¬«      S )Nr   r   )rZ   r�   r  r   c              3   ó&   K  — | ]	  }|€Œ|–— Œ y ­wrk   r   )Ú.0Úvs     r   ú	<genexpr>z0Data2VecVisionEncoder.forward.<locals>.<genexpr>„  s   è ø€ Òm˜qÐ_`Ñ_lœÑmùs   ‚Š)Úlast_hidden_stater—   Ú
attentions)	Ú	enumerater5  r“   r"   r0   r•   rK   r®   r   )r<   r—   r˜   r:  rZ   r™   r;  Úall_hidden_statesÚall_self_attentionsr9  Úlayer_moduler?   r@   rƒ   r•   Úlayer_outputss                   r   rj   zData2VecVisionEncoder.forwardZ  s6  € ñ #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ó *Ñ&ð *.Ð&á(ØØ"3Ø'=Ø)AØ%ôˆMð *¨!Ñ,ˆMâ Ø&9¸]È1Ñ=MÐ<OÑ&OÑ#ð1	Pñ4  Ø 1°]Ð4DÑ DÐáÜÑm ]Ð4EÐGZÐ$[ÔmÓmÐmÜØ+Ø+Ø*ô
ð 	
r   rk   )FFFNT)r   r   r   r   r®   r&   r(   rl   r’   rm   r   rj   ro   rp   s   @r   r+  r+  D  s“   ø„ ñ,Ð3ð ,À%È$Á,ð ,ÐZ^õ ,ð0 #(Ø%*Ø).Ø-1Ø ñ/
à—|‘|ð/
ð  ð/
ð #ð	/
ð
 #'ð/
ð ˜#˜s˜(‘O dÑ*ð/
ð ð/
ð 
�Ñ	 ÷/
r   r+  c                   ór   ‡ — e Zd ZU eed<   dZdZdZdZdgZ	dgZ
dZ ej                  «       ˆ fd„«       Zˆ xZS )	ÚData2VecVisionPreTrainedModelr"   Údata2vec_vision)Úimager[   Trò   z.*relative_position_index.*c                 óž  •— t         ‰| �  |«       t        |t        «      rwt	        j
                  |j                  «       |j                  �t	        j
                  |j                  «       |j                  � t	        j
                  |j                  «       yyt        |t        «      r t	        j
                  |j                  «       yt        |t        «      rv|j                  �it	        j                  |j                  | j                  j                  «       t	        j                  |j                   | j                  j                  «       yyy)zInitialize the weightsN)r%   Ú_init_weightsr1   r!   ÚinitÚzeros_r+   r-   r8   r”   r  rò   r  Ú	constant_r"   r  r  )r<   Úmoduler=   s     €r   rM  z+Data2VecVisionPreTrainedModel._init_weights˜  sä   ø€ ô 	‰Ñ˜fÔ%Ü�fÔ6Ô7Ü�K‰K˜×(Ñ(Ô)Ø× Ñ Ð,Ü—‘˜F×-Ñ-Ô.Ø×)Ñ)Ð5Ü—‘˜F×6Ñ6Õ7ð 6ä˜Ô BÔCÜ�K‰K˜×;Ñ;Õ<Ü˜Ô 3Ô4Ø�‰Ð*Ü—‘˜vŸ™°·±×0RÑ0RÔSÜ—‘˜vŸ™°·±×0RÑ0RÕSð +ð 5r   )r   r   r   r   Ú__annotations__Úbase_model_prefixÚinput_modalitiesÚmain_input_nameÚsupports_gradient_checkpointingÚ_no_split_modulesÚ"_keys_to_ignore_on_load_unexpectedÚ_supports_sdpar(   Úno_gradrM  ro   rp   s   @r   rI  rI  Œ  sU   ø… ð !Ó Ø)ÐØ!ÐØ$€OØ&*Ð#Ø.Ð/ÐØ*HÐ)IÐ&Ø€Nà€U‡]�]ƒ_óTó ôTr   rI  c                   ó´   ‡ — e Zd Zddededdfˆ fd„Zd„ Ze	 	 	 	 	 ddej                  dej                  dz  d	edz  d
edz  dededz  deez  fd„«       Zˆ xZS )ÚData2VecVisionModelr"   Ú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)zw
        add_pooling_layer (bool, *optional*, defaults to `False`):
            Whether to add a pooling layer
        rˆ   rõ   N)r%   r&   r"   r!   r>   r+  r/   rw   ÚencoderÚuse_mean_poolingr   rþ   rû   r*   rü   Ú	layernormÚData2VecVisionPoolerÚpoolerÚ	post_init)r<   r"   r]  r=   s      €r   r&   zData2VecVisionModel.__init__­  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 rk   )r>   r/   rî   s    r   Úget_input_embeddingsz(Data2VecVisionModel.get_input_embeddingsÀ  s   € Ø�‰×/Ñ/Ð/r   r[   r\   r˜   r:  rZ   r;  c                 óì  — |�|n| j                   j                  }|�|n| j                   j                  }|�|n| 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\   rC   )r˜   r:  r™   r;  rZ   r   r   )rA  Úpooler_outputr—   rB  )r"   r˜   r:  r;  r>   rK   r_  ra  rc  r   r—   rB  )r<   r[   r\   r˜   r:  rZ   r;  ÚkwargsÚembedding_outputrb   r™   Úencoder_outputsÚsequence_outputÚpooled_outputÚhead_outputss                  r   rj   zData2VecVisionModel.forwardÃ  s$  € ð 2CÐ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆà"Ÿ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)NNNFN)r   r   r   r   r’   r&   rf  r   r(   rl   rn   r®   r   rj   ro   rp   s   @r   r\  r\  ª  s®   ø„ ñÐ3ð Èð ÐY]õ ò&0ð ð 48Ø)-Ø,0Ø).Ø#'ñ,
à—l‘lð,
ð ×)Ñ)¨DÑ0ð,
ð   $™;ð	,
ð
 # T™kð,
ð #'ð,
ð ˜D‘[ð,
ð 
Ð5Ñ	5ò,
ó ô,
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 )rb  r"   r#   Nc                 óª   •— t         ‰| �  «        |j                  r1t        j                  |j
                  |j                  ¬«      | _        y d | _        y )Nrõ   )r%   r&   r`  r   rû   r*   rü   ra  rÁ   s     €r   r&   zData2VecVisionPooler.__init__õ  sA   ø€ Ü‰ÑÔàKQ×KbÒKbŒB�L‰L˜×+Ñ+°×1FÑ1FÔGð 	�Øhlð 	�r   r—   c                 ó„   — | j                   �,| j                  |d d …dd …d d …f   j                  d«      «      S |d d …df   S )Nr   r   )ra  ÚmeanrÛ   s     r   rj   zData2VecVisionPooler.forwardû  sD   € àBFÇ.Á.ÐB\ˆt�~‰~˜mªA¨q©r²1¨HÑ5×:Ñ:¸1Ó=Ó>ÐuÐboÒpqÐstÐptÑbuÐur   rÜ   rp   s   @r   rb  rb  ô  s5   ø„ ð
Ð3ð 
¸õ 
ðv U§\¡\ð v°e·l±l÷ vr   rb  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	 	 	 	 	 	 ddej                  dz  dej                  dz  dedz  dedz  d	ed
edz  de	e
z  fd„«       Zˆ xZS )Ú$Data2VecVisionForImageClassificationr"   r#   Nc                 ó.  •— t         ‰| �  |«       |j                  | _        t        |d¬«      | _        |j                  dkD  r*t        j                  |j                  |j                  «      nt        j                  «       | _	        | j                  «        y )NT©r]  r   )r%   r&   Ú
num_labelsr\  rJ  r   r�   r*   rþ   Ú
classifierrd  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[   Úlabelsr˜   r:  rZ   r;  c                 ó\  — |�|n| j                   j                  }| j                  |||||¬«      }|r|j                  n|d   }	| j	                  |	«      }
d}|�| j                  ||
| j                   «      }|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:  rZ   r;  r   rC   ©ÚlossÚlogitsr—   rB  )	r"   r;  rJ  rh  rx  Úloss_functionr   r—   rB  )r<   r[   ry  r˜   r:  rZ   r;  ri  r¬   rm  r~  r}  rÏ   s                r   rj   z,Data2VecVisionForImageClassification.forward  sÕ   € ð" &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆØ×&Ñ&ØØ/Ø!5Ø%=Ø#ð 'ó 
ˆñ 2=˜×-Ò-À'È!Á*ˆà—‘ Ó/ˆàˆØÐØ×%Ñ% f¨f°d·k±kÓBˆDáØ�Y ¨¨ Ñ,ˆFØ)-Ð)9�T�G˜fÑ$ÐE¸vÐEä$ØØØ!×/Ñ/Ø×)Ñ)ô	
ð 	
r   ©NNNNFN)r   r   r   r   r&   r   r(   rl   r’   r®   r   rj   ro   rp   s   @r   rt  rt     s§   ø„ ð
Ð3ð 
¸õ 
ð ð -1Ø&*Ø)-Ø,0Ø).Ø#'ñ*
à—l‘l TÑ)ð*
ð —‘˜tÑ#ð*
ð   $™;ð	*
ð
 # T™kð*
ð #'ð*
ð ˜D‘[ð*
ð 
Ð&Ñ	&ò*
ó ô*
r   rt  c                   óÂ   ‡ — e Zd Z	 	 	 	 	 	 	 ddededeeeef   z  dedeeeef   z  ez  dedeeeef   z  ded	efˆ fd
„Zdej                  dej                  fd„Z
ˆ xZS )ÚData2VecVisionConvLayerÚin_channelsÚout_channelsrt   ru   Úpaddingr‡   ÚdilationÚgroupsÚ
activationc
           
      óî   •— t         ‰
| �  «        t        j                  ||||||||¬«      | _        t        j
                  |«      | _        |	�t        |	   | _	        y t        j                  «       | _	        y )N)rƒ  r„  rt   ru   r…  r†  r‡  r‡   )
r%   r&   r   rx   ÚconvolutionÚBatchNorm2dÚnormalizationr	   rþ   rˆ  )r<   rƒ  r„  rt   ru   r…  r‡   r†  r‡  rˆ  r=   s             €r   r&   z Data2VecVisionConvLayer.__init__D  si   ø€ ô 	‰ÑÔÜŸ9™9Ø#Ø%Ø#ØØØØØô	
ˆÔô  Ÿ^™^¨LÓ9ˆÔØ0:Ð0Fœ& Ñ,ˆ�ÌBÏKÉKËMˆ�r   r—   r#   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S rk   )rŠ  rŒ  rˆ  rÛ   s     r   rj   zData2VecVisionConvLayer.forward^  s6   € Ø×(Ñ(¨Ó7ˆØ×*Ñ*¨=Ó9ˆØŸ™¨Ó6ˆØÐr   )r   r   r   Fr   r   Úrelu)r   r   r   rm   r®   rØ   r’   r&   r(   rl   rj   ro   rp   s   @r   r‚  r‚  C  sÈ   ø„ ð
 ./ØØ/0ØØ*+ØØ ñZàðZð ðZð ˜5  c ™?Ñ*ð	Zð
 ðZð �u˜S #˜X‘Ñ&¨Ñ,ðZð ðZð ˜˜c 3˜h™Ñ'ðZð ðZð õZð4 U§\¡\ð °e·l±l÷ r   r‚  c                   óv   ‡ — e Zd Zdedededdfˆ fd„Zdej                  deeef   dej                  fd	„Zˆ xZ	S )
Ú!Data2VecVisionPyramidPoolingBlockÚ
pool_scalerƒ  Úchannelsr#   Nc                 ó|   •— t         ‰| �  «        t        j                  |«      | _        t        ||d¬«      | _        y )Nr   ©rt   )r%   r&   r   ÚAdaptiveAvgPool2dÚpoolingr‚  Úconv)r<   r‘  rƒ  r’  r=   s       €r   r&   z*Data2VecVisionPyramidPoolingBlock.__init__g  s0   ø€ Ü‰ÑÔÜ×+Ñ+¨JÓ7ˆŒÜ+¨K¸ÈqÔQˆ�	r   ÚinputrF   c                 ó�   — | j                  |«      }| j                  |«      }t        j                  j	                  ||dd¬«      }|S )Nr  FrE   )r–  r—  r   rP   rQ   )r<   r˜  rF   Úhidden_states       r   rj   z)Data2VecVisionPyramidPoolingBlock.forwardl  sB   € Ø—|‘| EÓ*ˆØ—y‘y Ó.ˆÜ—}‘}×0Ñ0°ÀDÈzÐinÐ0ÓoˆØÐr   )
r   r   r   rm   r&   r(   rl   r®   rj   ro   rp   s   @r   r�  r�  f  sS   ø„ ðR 3ð R°Sð RÀCð RÈDõ Rð
˜UŸ\™\ð °°s¸C°x±ð ÀUÇ\Á\÷ r   r�  c                   ó|   ‡ — e Zd ZdZdeedf   dededdfˆ fd„Zd	ej                  de	ej                     fd
„Z
ˆ xZS )Ú"Data2VecVisionPyramidPoolingModuleak  
    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.

    Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation.
    Úpool_scales.rƒ  r’  r#   Nc           
      ó¾   •— t         ‰| �  «        || _        || _        || _        t        j                  |D �cg c]  }t        |||¬«      ‘Œ c}«      | _        y c c}w )N)r‘  rƒ  r’  )	r%   r&   r�  rƒ  r’  r   r2  r�  Úblocks)r<   r�  rƒ  r’  r‘  r=   s        €r   r&   z+Data2VecVisionPyramidPoolingModule.__init__�  s]   ø€ Ü‰ÑÔØ&ˆÔØ&ˆÔØ ˆŒÜ—m‘mð #.öàô 2¸ZÐU`ÐksÖtòó
ˆ�ùòs   ¸Ar—   c                 óv   — |j                  «       dd  }| j                  D �cg c]  } |||¬«      ‘Œ c}S c c}w )NrC   )rF   )rF   rŸ  )r<   r—   Úoriginal_sizeÚblocks       r   rj   z*Data2VecVisionPyramidPoolingModule.forward�  s6   € Ø%×*Ñ*Ó,¨Q¨RÐ0ˆØFJÇkÁkÖR¸U‘�m¨-Ö8ÒRÐRùÒRs   ¢6)r   r   r   r   r®   rm   r&   r(   rl   Úlistrj   ro   rp   s   @r   rœ  rœ  t  sV   ø„ ñ
ð

 E¨#¨s¨(¡Oð 

À#ð 

ÐQTð 

ÐY]õ 

ðS U§\¡\ð S°d¸5¿<¹<Ñ6H÷ Sr   rœ  c                   ó¨   ‡ — e Zd ZdZdeddfˆ fd„Zdeej                     dej                  fd„Z	de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://huggingface.co/papers/1807.10221).

    Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation.
    r"   r#   Nc           	      óÖ  •— t         ‰| �  «        |j                  | _        |j                  gdz  | _        |j                  | _        t        j                  | j
                  |j                  d¬«      | _	        t        | j                  | j                  d   | j
                  «      | _        t        | j                  d   t        | j                  «      | j
                  z  z   | j
                  dd¬«      | _        t        j                  «       | _        t        j                  «       | _        | j                  d d D ]o  }| j                   j%                  t        || j
                  d¬«      «       | j"                  j%                  t        | j
                  | j
                  dd¬«      «       Œq t        t        | j                  «      | j
                  z  | j
                  dd¬«      | _        y )Né   r   r”  rB   r   ©rt   r…  )r%   r&   r�  r*   rƒ  r’  r   rx   rw  rx  rœ  Úpsp_modulesr‚  ÚlenÚpsp_bottleneckr2  Úlateral_convsÚ	fpn_convsÚappendÚfpn_bottleneck)r<   r"   rƒ  r=   s      €r   r&   zData2VecVisionUperHead.__init__›  s‡  ø€ Ü‰ÑÔà!×-Ñ-ˆÔØ"×.Ñ.Ð/°!Ñ3ˆÔØ×*Ñ*ˆŒÜŸ)™) D§M¡M°6×3DÑ3DÐRSÔTˆŒô >Ø×ÑØ×Ñ˜RÑ Ø�M‰Mó
ˆÔô
 6Ø×Ñ˜RÑ ¤3 t×'7Ñ'7Ó#8¸4¿=¹=Ñ#HÑHØ�M‰MØØô	
ˆÔô  Ÿ]™]›_ˆÔÜŸ™›ˆŒØ×+Ñ+¨C¨RÐ0ò 	sˆKØ×Ñ×%Ñ%Ô&=¸kÈ4Ï=É=ÐfgÔ&hÔiØ�N‰N×!Ñ!Ô"9¸$¿-¹-ÈÏÉÐdeÐopÔ"qÕrð	sô 6Ü�× Ñ Ó! D§M¡MÑ1Ø�M‰MØØô	
ˆÕr   r—   c                 ó€   — |d   }t        j                  |g| j                  |«      ¢d¬«      }| j                  |«      S r^   )r(   rS   r©  r«  )r<   r—   rš  s      r   Úpsp_forwardz"Data2VecVisionUperHead.psp_forward½  sA   € Ø$ RÑ(ˆÜ—y‘y ,Ð!P°×1AÑ1AÀ,Ó1OÐ!PÐVWÔXˆØ×"Ñ" <Ó0Ð0r   Úencoder_hidden_statesc                 ó6  — g }t        | j                  |«      D ]  \  }}|j                   ||«      «       Œ |j                  | j                  |«      «       t	        |«      }t        |dz
  dd«      D ]L  }||dz
     j                  dd  }||dz
     t        j                  j                  ||   |dd¬«      z   ||dz
  <   ŒN g }t        |dz
  «      D ])  }|j                   | j                  |   ||   «      «       Œ+ |j                  |d   «       t        |dz
  dd«      D ];  }t        j                  j                  ||   |d   j                  dd  dd¬«      ||<   Œ= t        j                  |d¬«      }| j                  |«      }	| j                  |	«      }	|	S )	Nr   r   rB   rC   r  FrE   rI   )Úzipr¬  r®  r±  rª  r3  rK   r   rP   rQ   r­  r(   rS   r¯  rx  )
r<   r²  ÚlateralsÚlateral_convrš  Úused_backbone_levelsr9  Ú
prev_shapeÚfpn_outsrÏ   s
             r   rj   zData2VecVisionUperHead.forwardÂ  s¹  € àˆÜ*-¨d×.@Ñ.@ÐBWÓ*Xò 	8Ñ&ˆL˜,Ø�O‰O™L¨Ó6Õ7ð	8ð 	�‰˜×(Ñ(Ð)>Ó?Ô@ô  # 8›}ÐÜÐ+¨aÑ/°°BÓ7ò 	ˆAØ! ! a¡%™×.Ñ.¨q¨rÐ2ˆJØ& q¨1¡u™o´·±×0IÑ0IØ˜‘ *°:ÈUð 1Jó 1ñ ˆH�Q˜‘UŠOð	ð ˆÜÐ+¨aÑ/Ó0ò 	<ˆAØ�O‰OÐ-˜DŸN™N¨1Ñ-¨h°q©kÓ:Õ;ð	<ð 	�‰˜ ™Ô%äÐ+¨aÑ/°°BÓ7ò 	ˆAÜŸ-™-×3Ñ3Ø˜‘ (¨1¡+×"3Ñ"3°A°BÐ"7¸jÐX]ð 4ó ˆH�QŠKð	ô —9‘9˜X¨1Ô-ˆØ×$Ñ$ XÓ.ˆØ—‘ Ó(ˆàˆr   )r   r   r   r   r   r&   r£  r(   rl   r±  rj   ro   rp   s   @r   r¥  r¥  “  s]   ø„ ñð 
Ð3ð  
¸õ  
ðD1¨¨e¯l©lÑ);ð 1ÀÇÁó 1ð
¨T°%·,±,Ñ-?ð ÀEÇLÁL÷ r   r¥  c                   óŽ   ‡ — e Zd ZdZ	 	 	 ddedededeeeef   z  ddf
ˆ fd„Zd	e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://huggingface.co/papers/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.
    r"   Úin_indexrt   r†  r#   Nc           
      ó0  •— t         ‰| �  «        |j                  | _        |j                  | _        |j                  | _        |j                  | _	        || _
        |dz  |z  }t        j                  «       | _        | j                  dkD  r—| j                  j                  t        | j                  | j
                  |||¬«      «       t!        | j                  dz
  «      D ]?  }| j                  j                  t        | j
                  | j
                  |||¬«      «       ŒA | j                  r8t        | j                  | j
                  z   | j
                  ||dz  ¬«      | _        t        j$                  | j
                  |j&                  d¬«      | _        y )NrC   r   )rt   r…  r†  r   r¨  r”  )r%   r&   r*   rƒ  Úauxiliary_channelsr’  Úauxiliary_num_convsÚ	num_convsÚauxiliary_concat_inputÚconcat_inputr¼  r   r2  Úconvsr®  r‚  r3  Úconv_catrx   rw  rx  )r<   r"   r¼  rt   r†  Úconv_paddingrb   r=   s          €r   r&   zData2VecVisionFCNHead.__init__ô  sQ  ø€ ô 	‰ÑÔØ!×-Ñ-ˆÔØ×1Ñ1ˆŒØ×3Ñ3ˆŒØ"×9Ñ9ˆÔØ ˆŒà# qÑ(¨HÑ4ˆÜ—]‘]“_ˆŒ
Ø�>‰>˜AÒØ�J‰J×ÑÜ'Ø×$Ñ$ d§m¡mÀÐVbÐmuôôô
 ˜4Ÿ>™>¨AÑ-Ó.ò 	�Ø—
‘
×!Ñ!Ü+ØŸ™ØŸ™Ø$/Ø ,Ø!)ôõð	ð ×ÒÜ3Ø× Ñ  4§=¡=Ñ0°$·-±-È[ÐbmÐqrÑbrôˆDŒMô Ÿ)™) D§M¡M°6×3DÑ3DÐRSÔTˆ�r   r²  c                 óä   — || j                      }|}| j                  D ]
  } ||«      }Œ | j                  r(| j                  t	        j
                  ||gd¬«      «      }| j                  |«      }|S )Nr   rI   )r¼  rÃ  rÂ  rÄ  r(   rS   rx  )r<   r²  Úresidualr—   r—  s        r   rj   zData2VecVisionFCNHead.forward  sn   € Ø(¨¯©Ñ7ˆØ ˆØ—J‘Jò 	0ˆDÙ  Ó/‰Mð	0à×ÒØ ŸM™M¬%¯)©)°X¸}Ð4MÐSTÔ*UÓVˆMØŸ™¨Ó6ˆØÐr   )rC   r   r   )r   r   r   r   r   rm   r®   r&   r£  r(   rl   rj   ro   rp   s   @r   r»  r»  å  s|   ø„ ñð" ØØ*+ñ%Uà$ð%Uð ð%Uð ð	%Uð
 ˜˜c 3˜h™Ñ'ð%Uð 
õ%UðN¨T°%·,±,Ñ-?ð ÀEÇLÁL÷ r   r»  c                   ó¶   ‡ — e Zd Zdeddfˆ fd„Zd„ Ze	 	 	 	 	 	 ddej                  dz  dej                  dz  de	dz  d	e	dz  d
e	de	dz  de
ez  fd„«       Zˆ xZS )Ú%Data2VecVisionForSemanticSegmentationr"   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 )NFrv  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.rC   rs   )r%   r&   rw  r\  rJ  rª  r"   Úout_indicesr{   r   Ú
SequentialÚConvTranspose2dr*   r‹  ÚGELUÚfpn1Úfpn2rþ   Úfpn3Ú	MaxPool2dÚfpn4r¥  Údecode_headÚuse_auxiliary_headr»  Úauxiliary_headrd  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›   r  FrE   )Úignore_index)r   rP   rQ   rK   r   r"   Úsemantic_loss_ignore_indexÚauxiliary_loss_weight)
r<   r~  Úauxiliary_logitsry  Úupsampled_logitsÚupsampled_auxiliary_logitsÚloss_fctÚ	main_lossr}  Úauxiliary_losss
             r   Úcompute_lossz2Data2VecVisionForSemanticSegmentation.compute_lossI  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[   ry  r˜   r:  rZ   r;  c           	      óR  — |�|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 )
a‘  
        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).

        Examples:

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

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

        >>> image_processor = AutoImageProcessor.from_pretrained("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   rC   rB   r|  )r"   r;  r:  rw  r{   rJ  r—   rC  rË  rK   r2   r0   rO   rN   rÏ  rÐ  rÑ  rÓ  r3  rª  rÔ  rÖ  rá  r   rB  )r<   r[   ry  r˜   r:  rZ   r;  ri  r¬   r²  ÚidxÚfeatureÚfeaturesre   Úpatch_resolutionr7  Úopsr9  r~  rÛ  r}  rÏ   s                         r   rj   z-Data2VecVisionForSemanticSegmentation.forward\  sa  € ðH &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆà$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Â6HÃ=8H$r€  )r   r   r   r   r&   rá  r   r(   rl   r’   r®   r   rj   ro   rp   s   @r   rÉ  rÉ  &  s¶   ø„ ðÐ3ð ¸õ ò@ð& ð -1Ø&*Ø)-Ø,0Ø).Ø#'ñY
à—l‘l TÑ)ðY
ð —‘˜tÑ#ðY
ð   $™;ð	Y
ð
 # T™kðY
ð #'ðY
ð ˜D‘[ðY
ð 
Ð(Ñ	(òY
ó ôY
r   rÉ  )rt  rÉ  r\  rI  )?r   Úcollections.abcr3   rŸ   Údataclassesr   Útypingr   r(   r   Útorch.nnr   Ú r   rN  Úactivationsr	   Úmodeling_layersr
   Úmodeling_outputsr   r   r   r   Úmodeling_utilsr   Úpytorch_utilsr   Úutilsr   r   r   Úconfiguration_data2vec_visionr   Ú
get_loggerr   r·   r   ÚModuler!   r.   r‚   r°   r¾   rÌ   rÊ   rÔ   rÞ   râ   rò   r”   r+  rI  r\  rb  rt  r‚  r�  rœ  r¥  r»  rÉ  Ú__all__r   r   r   ú<module>r÷     sU  ðñ $ã Û Ý !Ý ã Ý Ý %å &Ý !Ý 9÷ó õ .Ý @ß 7Ñ 7Ý ?ð 
ˆ×	Ñ	˜HÓ	%€ñ ðôð
 ôÐ+Eó ó óðô\7˜rŸy™yô \7ô@#7 B§I¡Iô #7ôNF "§)¡)ô FôT0#Ð&Aô 0#ôh˜rŸy™yô ð& )Ø+ñ*Ð &ô˜bŸi™iô ô6 §¡ô ô"
˜2Ÿ9™9ô 
ô%˜RŸY™Yô %ô2>Ð4ô >ôDQ3¨¯©ô Q3ôjE
˜BŸI™Iô E
ðP ôT Oó Tó ðTð8 ôD
Ð7ó D
ó ðD
ôP	v˜2Ÿ9™9ô 	vñ ðôô8
Ð+Hó 8
óð8
ôx˜bŸi™iô ôF
¨¯	©	ô 
ôS¨¯©ô Sô>N˜RŸY™Yô Nôd>˜BŸI™Iô >ðB ôN
Ð,Ió N
ó ðN
òb�r   