Ë
    S^(hæ  ã                   óì  — d Z ddlZddlmZ ddlmZmZmZm	Z	m
Z
mZ ddlZddlZddlmZ ddlmZ ddlmZ dd	lmZmZmZmZ dd
lmZmZmZ ddlmZmZ ddlm Z m!Z! ddl"m#Z#m$Z$m%Z% ddl&m'Z' ddl(m)Z)  e$jT                  e+«      Z,dZ-dZ.g d¢Z/e G d„ de#«      «       Z0e G d„ de#«      «       Z1 G d„ dejd                  «      Z3 G d„ dejd                  «      Z4 G d„ dejd                  «      Z5	 dWdejd                  dejl                  d ejl                  d!ejl                  d"eejl                     d#e7d$e7fd%„Z8 G d&„ d'ejd                  «      Z9 G d(„ d)ejd                  «      Z: G d*„ d+ejd                  «      Z; G d,„ d-ejd                  «      Z< G d.„ d/ejd                  «      Z= G d0„ d1ejd                  «      Z> G d2„ d3ejd                  «      Z? G d4„ d5ejd                  «      Z@d6„ ZA G d7„ d8ejd                  «      ZB G d9„ d:ejd                  «      ZC G d;„ d<ejd                  «      ZD G d=„ d>ejd                  «      ZE G d?„ d@e«      ZFdAZGdBZH edCeG«       G dD„ dEeF«      «       ZI G dF„ dGejd                  «      ZJ G dH„ dIejd                  «      ZK G dJ„ dKejd                  «      ZL edLeG«       G dM„ dNeF«      «       ZM G dO„ dPejd                  «      ZN G dQ„ dRejd                  «      ZO edSeG«       G dT„ dUeF«      «       ZPg dV¢ZQy)XzèPyTorch DPT (Dense Prediction Transformers) model.

This implementation is heavily inspired by OpenMMLab's implementation, found here:
https://github.com/open-mmlab/mmsegmentation/blob/master/mmseg/models/decode_heads/dpt_head.py.

é    N)Ú	dataclass)ÚCallableÚListÚOptionalÚSetÚTupleÚUnion)Únn)ÚCrossEntropyLossé   )ÚACT2FN)Úadd_code_sample_docstringsÚadd_start_docstringsÚ%add_start_docstrings_to_model_forwardÚreplace_return_docstrings)ÚBaseModelOutputÚDepthEstimatorOutputÚSemanticSegmenterOutput)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)Ú find_pruneable_heads_and_indicesÚprune_linear_layer)ÚModelOutputÚloggingÚ	torch_int)Úload_backboneé   )Ú	DPTConfigr   zIntel/dpt-large)r   iA  i   c                   ól   — e Zd ZU dZdZeej                     ed<   dZ	ee
ej                  df      ed<   y)Ú*BaseModelOutputWithIntermediateActivationsa#  
    Base class for model's outputs that also contains intermediate activations that can be used at later stages. Useful
    in the context of Vision models.:

    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.
        intermediate_activations (`tuple(torch.FloatTensor)`, *optional*):
            Intermediate activations that can be used to compute hidden states of the model at various layers.
    NÚlast_hidden_states.Úintermediate_activations)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r!   r   ÚtorchÚFloatTensorÚ__annotations__r"   r   © ó    úb/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/transformers/models/dpt/modeling_dpt.pyr    r    8   s?   … ñ	ð 7;Ð˜ ×!2Ñ!2Ñ3Ó:ØHLÐ˜h u¨U×->Ñ->ÀÐ-CÑ'DÑEÔLr+   r    c                   óø   — e Zd ZU dZdZeej                     ed<   dZ	eej                     ed<   dZ
eeej                  df      ed<   dZeeej                  df      ed<   dZeeej                  df      ed<   y)	Ú4BaseModelOutputWithPoolingAndIntermediateActivationsa  
    Base class for model's outputs that also contains a pooling of the last hidden states as well as intermediate
    activations that can be used by the model at later stages.

    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)`):
            Last layer hidden-state of the first token of the sequence (classification token) after further processing
            through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
            the classification token after processing through a linear layer and a tanh activation function. The linear
            layer weights are trained from the next sentence prediction (classification) objective during pretraining.
        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, if the model has an embedding layer, +
            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 optional 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.
        intermediate_activations (`tuple(torch.FloatTensor)`, *optional*):
            Intermediate activations that can be used to compute hidden states of the model at various layers.
    NÚlast_hidden_stateÚpooler_output.Úhidden_statesÚ
attentionsr"   )r#   r$   r%   r&   r/   r   r'   r(   r)   r0   r1   r   r2   r"   r*   r+   r,   r.   r.   I   s’   … ñð6 6:Ð�x × 1Ñ 1Ñ2Ó9Ø15€M�8˜E×-Ñ-Ñ.Ó5Ø=A€M�8˜E %×"3Ñ"3°SÐ"8Ñ9Ñ:ÓAØ:>€J�˜˜u×0Ñ0°#Ð5Ñ6Ñ7Ó>ØHLÐ˜h u¨U×->Ñ->ÀÐ-CÑ'DÑEÔLr+   r.   c            	       óp   ‡ — e Zd ZdZd	ˆ fd„	Zd
d„Z	 ddej                  dededej                  fd„Z	ˆ xZ
S )ÚDPTViTHybridEmbeddingszì
    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                 ób  •— 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  }t        |«      | _        | j                  j                  d   }t        | j                  j                  «      dk7  r+t        dt        | j                  j                  «      › �«      ‚ddg| _        |€|j                   }	|	dd  }|	d   }nCt        |t        j                  j                  «      r|n||f}| j                  j                  d   }|| _        |d   | _        || _        t#        j$                  ||d¬«      | _        t#        j(                  t+        j,                  dd|j
                  «      «      | _        t#        j(                  t+        j,                  d|dz   |j
                  «      «      | _        y )Nr   r   éÿÿÿÿr   z1Expected backbone to have 3 output features, got éþÿÿÿ©Úkernel_size)ÚsuperÚ__init__Ú
image_sizeÚ
patch_sizeÚnum_channelsÚhidden_sizeÚ
isinstanceÚcollectionsÚabcÚIterabler   ÚbackboneÚchannelsÚlenÚ
ValueErrorÚresidual_feature_map_indexÚbackbone_featmap_shaper
   ÚConv2dÚ
projectionÚ	Parameterr'   ÚzerosÚ	cls_tokenÚposition_embeddings)ÚselfÚconfigÚfeature_sizer<   r=   r>   r?   Únum_patchesÚfeature_dimÚfeat_map_shapeÚ	__class__s             €r,   r;   zDPTViTHybridEmbeddings.__init__t   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ˆä% fÓ-ˆŒØ—m‘m×,Ñ,¨RÑ0ˆÜˆt�}‰}×%Ñ%Ó&¨!Ò+ÜÐPÔQTÐUY×UbÑUb×UkÑUkÓQlÐPmÐnÓoÐoØ+,¨a¨&ˆÔ'àÐØ#×:Ñ:ˆNØ)¨"¨#Ð.ˆLØ(¨Ñ+‰Kô !+¨<¼¿¹×9QÑ9QÔ R‘ÐYeÐgsÐXtð ð Ÿ-™-×0Ñ0°Ñ4ˆKà$ˆŒØ$ Q™-ˆŒØ(ˆÔäŸ)™) K°È!ÔLˆŒäŸ™¤e§k¡k°!°Q¸×8JÑ8JÓ&KÓLˆŒÜ#%§<¡<´·±¸A¸{ÈQ¹ÐPV×PbÑPbÓ0cÓ#dˆÕ r+   c                 ór  — |d d …d |…f   }|d|d …f   }t        t        |«      dz  «      }|j                  d||d«      j                  dddd«      }t        j
                  j                  |||fd¬«      }|j                  dddd«      j                  d||z  d«      }t        j                  ||gd¬	«      }|S ©
Nr   ç      à?r   r6   r   é   Úbilinear)ÚsizeÚmode©Údim)	r   rF   ÚreshapeÚpermuter
   Ú
functionalÚinterpolater'   Úcat©rP   ÚposembÚgrid_size_heightÚgrid_size_widthÚstart_indexÚ
posemb_tokÚposemb_gridÚold_grid_sizes           r,   Ú_resize_pos_embedz(DPTViTHybridEmbeddings._resize_pos_embed–   sÍ   € ØšA˜| ˜|˜OÑ,ˆ
Ø˜Q ¡˜_Ñ-ˆä!¤# kÓ"2°cÑ"9Ó:ˆà!×)Ñ)¨!¨]¸MÈ2ÓN×VÑVÐWXÐZ[Ð]^Ð`aÓbˆÜ—m‘m×/Ñ/°ÐCSÐUdÐBeÐlvÐ/ÓwˆØ!×)Ñ)¨!¨Q°°1Ó5×=Ñ=¸aÐAQÐTcÑAcÐegÓhˆä—‘˜J¨Ð4¸!Ô<ˆàˆr+   Úpixel_valuesÚinterpolate_pos_encodingÚreturn_dictÚreturnc                 ó  — |j                   \  }}}}|| j                  k7  rt        d«      ‚|sV|| j                  d   k7  s|| j                  d   k7  r2t        d|› d|› d| j                  d   › d| j                  d   › d�	«      ‚| j	                  | j
                  || j                  z  || j                  z  «      }| j                  |«      }	|	j                  d   }
| j                  D �cg c]  }|	j                  |   ‘Œ }}| j                  |
«      j                  d	«      j                  dd	«      }| j                  j                  |dd«      }t        j                   ||fd¬
«      }||z   }|s||fS t#        ||¬«      S c c}w )NúeMake sure that the channel dimension of the pixel values match with the one set in the configuration.r   r   zInput image size (Ú*z) doesn't match model (z).r6   rZ   r^   )r!   r"   )Úshaper>   rG   r<   rm   rO   r=   rD   Úfeature_mapsrH   rK   ÚflattenÚ	transposerN   Úexpandr'   rd   r    )rP   rn   ro   rp   Ú
batch_sizer>   ÚheightÚwidthrO   Úbackbone_outputÚfeaturesÚindexÚoutput_hidden_statesÚ
embeddingsÚ
cls_tokenss                  r,   ÚforwardzDPTViTHybridEmbeddings.forward¤   s§  € ð 3?×2DÑ2DÑ/ˆ
�L &¨%Ø˜4×,Ñ,Ò,ÜØwóð ñ (Ø˜Ÿ™¨Ñ+Ò+¨u¸¿¹ÈÑ8JÒ/JÜ Ø(¨¨°°%°ð 9ØŸ™¨Ñ+Ð,¨A¨d¯o©o¸aÑ.@Ð-AÀðEóð ð
 #×4Ñ4Ø×$Ñ$ f°·±Ñ&?ÀÈ$Ï/É/ÑAYó
Ðð Ÿ-™-¨Ó5ˆà"×/Ñ/°Ñ3ˆð RV×QpÑQpÖqÈ × <Ñ <¸UÓ CÐqÐÐqà—_‘_ XÓ.×6Ñ6°qÓ9×CÑCÀAÀqÓIˆ
à—^‘^×*Ñ*¨:°r¸2Ó>ˆ
Ü—Y‘Y 
¨JÐ7¸QÔ?ˆ
ð  Ð"5Ñ5ˆ
áØÐ 4Ð5Ð5ô :Ø)Ø%9ô
ð 	
ùò  rs   Ã)E?©N©r   )FF)r#   r$   r%   r&   r;   rm   r'   ÚTensorÚboolrƒ   Ú__classcell__©rV   s   @r,   r4   r4   m   sH   ø„ ñõ eóDð glñ)
Ø!ŸL™Lð)
ØDHð)
Ø_cð)
à	�‰÷)
r+   r4   c                   ó2   ‡ — e Zd ZdZˆ fd„Zdd„Zdd„Zˆ xZS )ÚDPTViTEmbeddingszB
    Construct the CLS token, position and patch embeddings.

    c                 ó®  •— t         ‰| �  «        t        j                  t	        j
                  dd|j                  «      «      | _        t        |«      | _	        | j                  j                  }t        j                  t	        j
                  d|dz   |j                  «      «      | _        t        j                  |j                  «      | _        || _        y )Nr   )r:   r;   r
   rL   r'   rM   r?   rN   ÚDPTViTPatchEmbeddingsÚpatch_embeddingsrS   rO   ÚDropoutÚhidden_dropout_probÚdropoutrQ   )rP   rQ   rS   rV   s      €r,   r;   zDPTViTEmbeddings.__init__Ö   s•   ø€ Ü‰ÑÔäŸ™¤e§k¡k°!°Q¸×8JÑ8JÓ&KÓLˆŒÜ 5°fÓ =ˆÔØ×+Ñ+×7Ñ7ˆÜ#%§<¡<´·±¸A¸{ÈQ¹ÐPV×PbÑPbÓ0cÓ#dˆÔ Ü—z‘z &×"<Ñ"<Ó=ˆŒØˆ�r+   c                 ó~  — |d d …d |…f   }|d|d …f   }t        |j                  d«      dz  «      }|j                  d||d«      j                  dddd«      }t        j
                  j                  |||fd¬«      }|j                  dddd«      j                  d||z  d«      }t        j                  ||gd¬	«      }|S rX   )	r   r\   r`   ra   r
   rb   rc   r'   rd   re   s           r,   rm   z"DPTViTEmbeddings._resize_pos_embedà   sÓ   € ØšA˜| ˜|˜OÑ,ˆ
Ø˜Q ¡˜_Ñ-ˆä! +×"2Ñ"2°1Ó"5¸Ñ"<Ó=ˆà!×)Ñ)¨!¨]¸MÈ2ÓN×VÑVÐWXÐZ[Ð]^Ð`aÓbˆÜ—m‘m×/Ñ/°ÐCSÐUdÐBeÐlvÐ/ÓwˆØ!×)Ñ)¨!¨Q°°1Ó5×=Ñ=¸aÐAQÐTcÑAcÐegÓhˆä—‘˜J¨Ð4¸!Ô<ˆàˆr+   c                 óš  — |j                   \  }}}}| j                  j                  }| j                  | j                  ||z  ||z  «      }| j                  |«      }	|	j                  «       \  }}
}| j                  j                  |dd«      }t        j                  ||	fd¬«      }	|	|z   }	| j                  |	«      }	|s|	fS t        |	¬«      S )Nr6   r   r^   )r!   )ru   rQ   r=   rm   rO   rŽ   r\   rN   ry   r'   rd   r‘   r    )rP   rn   rp   rz   r>   r{   r|   r=   rO   r�   Úseq_lenÚ_r‚   s                r,   rƒ   zDPTViTEmbeddings.forwardî   sÔ   € Ø2>×2DÑ2DÑ/ˆ
�L &¨%ð —[‘[×+Ñ+ˆ
Ø"×4Ñ4Ø×$Ñ$ f°
Ñ&:¸EÀZÑ<Oó
Ðð ×*Ñ*¨<Ó8ˆ
à!+§¡Ó!2Ñˆ
�G˜Qð —^‘^×*Ñ*¨:°r¸2Ó>ˆ
Ü—Y‘Y 
¨JÐ7¸QÔ?ˆ
ð  Ð"5Ñ5ˆ
à—\‘\ *Ó-ˆ
áØ�=Ð ä9ÈZÔXÐXr+   r…   )F)r#   r$   r%   r&   r;   rm   rƒ   rˆ   r‰   s   @r,   r‹   r‹   Ð   s   ø„ ñô
ó÷Yr+   r‹   c                   ó(   ‡ — e Zd ZdZˆ fd„Zd„ Zˆ xZS )r�   z$
    Image to Patch Embedding.

    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  }|| _        || _        || _        || _
        t        j                  ||||¬«      | _        y )Nr   r   )r9   Ústride)r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rS   r
   rJ   rK   )rP   rQ   r<   r=   r>   r?   rS   rV   s          €r,   r;   zDPTViTPatchEmbeddings.__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ˆØ$ˆŒØ$ˆŒØ(ˆÔØ&ˆÔäŸ)™) L°+È:Ð^hÔiˆ�r+   c                 ó¼   — |j                   \  }}}}|| j                  k7  rt        d«      ‚| j                  |«      j	                  d«      j                  dd«      }|S )Nrs   rZ   r   )ru   r>   rG   rK   rw   rx   )rP   rn   rz   r>   r{   r|   r�   s          r,   rƒ   zDPTViTPatchEmbeddings.forward  sb   € Ø2>×2DÑ2DÑ/ˆ
�L &¨%Ø˜4×,Ñ,Ò,ÜØwóð ð —_‘_ \Ó2×:Ñ:¸1Ó=×GÑGÈÈ1ÓMˆ
ØÐr+   ©r#   r$   r%   r&   r;   rƒ   rˆ   r‰   s   @r,   r�   r�   
  s   ø„ ñô
jör+   r�   ÚmoduleÚqueryÚkeyÚvalueÚattention_maskÚscalingr‘   c                 óÀ  — t        j                  ||j                  dd«      «      |z  }t        j                  j                  |dt         j                  ¬«      j                  |j                  «      }t        j                  j                  ||| j                  ¬«      }|�||z  }t        j                  ||«      }	|	j                  dd«      j                  «       }	|	|fS )Nr6   r7   )r_   Údtype)ÚpÚtrainingr   rZ   )r'   Úmatmulrx   r
   rb   ÚsoftmaxÚfloat32Útor¢   r‘   r¤   Ú
contiguous)
r›   rœ   r�   rž   rŸ   r    r‘   ÚkwargsÚattn_weightsÚattn_outputs
             r,   Úeager_attention_forwardr­   *  sÀ   € ô —<‘<  s§}¡}°R¸Ó'<Ó=ÀÑG€Lô —=‘=×(Ñ(¨¸2ÄUÇ]Á]Ð(ÓS×VÑVÐW\×WbÑWbÓc€Lô —=‘=×(Ñ(¨¸È6Ï?É?Ð(Ó[€Lð Ð!Ø# nÑ4ˆä—,‘,˜|¨UÓ3€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€Kà˜Ð$Ð$r+   c            
       óè   ‡ — e Zd Zdeddfˆ fd„Zdej                  dej                  fd„Z	 d
deej                     de	de
eej                  ej                  f   eej                     f   fd	„Zˆ xZS )ÚDPTSelfAttentionrQ   rq   Nc                 ó2  •— t         ‰| �  «        |j                  |j                  z  dk7  r2t	        |d«      s&t        d|j                  › d|j                  › d�«      ‚|| _        |j                  | _        t        |j                  |j                  z  «      | _        | j                  | j                  z  | _	        |j                  | _        | j                  dz  | _        d| _        t        j                  |j                  | j                  |j                   ¬«      | _        t        j                  |j                  | j                  |j                   ¬«      | _        t        j                  |j                  | j                  |j                   ¬«      | _        y )	Nr   Úembedding_sizezThe hidden size z4 is not a multiple of the number of attention heads ú.g      à¿F)Úbias)r:   r;   r?   Únum_attention_headsÚhasattrrG   rQ   ÚintÚattention_head_sizeÚall_head_sizeÚattention_probs_dropout_probÚdropout_probr    Ú	is_causalr
   ÚLinearÚqkv_biasrœ   r�   rž   ©rP   rQ   rV   s     €r,   r;   zDPTSelfAttention.__init__J  sF  ø€ Ü‰ÑÔØ×Ñ × :Ñ :Ñ:¸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ˆÔØ"×?Ñ?ˆÔØ×/Ñ/°Ñ5ˆŒØˆŒä—Y‘Y˜v×1Ñ1°4×3EÑ3EÈFÏOÉOÔ\ˆŒ
Ü—9‘9˜V×/Ñ/°×1CÑ1CÈ&Ï/É/ÔZˆŒÜ—Y‘Y˜v×1Ñ1°4×3EÑ3EÈFÏOÉOÔ\ˆ�
r+   Úxc                 ó¤   — |j                  «       d d | j                  | j                  fz   }|j                  |«      }|j	                  dddd«      S )Nr6   r   rZ   r   r   )r\   r´   r·   Úviewra   )rP   r¿   Únew_x_shapes      r,   Útranspose_for_scoresz%DPTSelfAttention.transpose_for_scores^  sL   € Ø—f‘f“h˜s �m t×'?Ñ'?À×AYÑAYÐ&ZÑZˆØ�F‰F�;ÓˆØ�y‰y˜˜A˜q !Ó$Ð$r+   Ú	head_maskÚoutput_attentionsc           
      ó˜  — | j                  | j                  |«      «      }| j                  | j                  |«      «      }| j                  | j                  |«      «      }t        }| j
                  j                  dk7  rN| j
                  j                  dk(  r|rt        j                  d«       nt        | j
                  j                     } || ||||| j                  | j                  | j                  sdn| j                  ¬«      \  }}	|j                  «       d d | j                  fz   }
|j!                  |
«      }|r||	f}|S |f}|S )NÚeagerÚsdpazã`torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. Falling back to eager attention. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.ç        )r»   r    r‘   r7   )rÃ   r�   rž   rœ   r­   rQ   Ú_attn_implementationÚloggerÚwarning_oncer   r»   r    r¤   rº   r\   r¸   r`   )rP   r1   rÄ   rÅ   Ú	key_layerÚvalue_layerÚquery_layerÚattention_interfaceÚcontext_layerÚattention_probsÚnew_context_layer_shapeÚoutputss               r,   rƒ   zDPTSelfAttention.forwardc  s=  € ð ×-Ñ-¨d¯h©h°}Ó.EÓFˆ	Ø×/Ñ/°·
±
¸=Ó0IÓJˆØ×/Ñ/°·
±
¸=Ó0IÓJˆä(?ÐØ�;‰;×+Ñ+¨wÒ6Ø�{‰{×/Ñ/°6Ò9Ñ>OÜ×#Ñ#ðLõô
 '>¸d¿k¹k×>^Ñ>^Ñ&_Ð#á)<ØØØØØØ—n‘nØ—L‘LØ#Ÿ}š}‘C°$×2CÑ2Cô	*
Ñ&ˆ�ð #0×"4Ñ"4Ó"6°s¸Ð";¸t×?QÑ?QÐ>SÑ"SÐØ%×-Ñ-Ð.EÓFˆá6G�= /Ð2ˆàˆð O\ÐM]ˆàˆr+   ©NF)r#   r$   r%   r   r;   r'   r†   rÃ   r   r‡   r	   r   rƒ   rˆ   r‰   s   @r,   r¯   r¯   I  s†   ø„ ð]˜yð ]¨Tõ ]ð(% e§l¡lð %°u·|±|ó %ð bgñ!Ø(0°·±Ñ(>ð!ØZ^ð!à	ˆu�U—\‘\ 5§<¡<Ð/Ñ0°%¸¿¹Ñ2EÐEÑ	F÷!r+   r¯   c                   ó|   ‡ — e Zd ZdZdeddfˆ fd„Zdej                  dej                  dej                  fd„Zˆ xZ	S )	ÚDPTViTSelfOutputz 
    The residual connection is defined in DPTLayer instead of here (as is the case with other models), due to the
    layernorm applied before each block.
    rQ   rq   Nc                 óÈ   •— t         ‰| �  «        t        j                  |j                  |j                  «      | _        t        j                  |j                  «      | _        y r„   )	r:   r;   r
   r¼   r?   Údenser�   r�   r‘   r¾   s     €r,   r;   zDPTViTSelfOutput.__init__Ž  sB   ø€ Ü‰ÑÔÜ—Y‘Y˜v×1Ñ1°6×3EÑ3EÓFˆŒ
Ü—z‘z &×"<Ñ"<Ó=ˆ�r+   r1   Úinput_tensorc                 óJ   — | j                  |«      }| j                  |«      }|S r„   ©rÙ   r‘   ©rP   r1   rÚ   s      r,   rƒ   zDPTViTSelfOutput.forward“  s$   € ØŸ
™
 =Ó1ˆØŸ™ ]Ó3ˆàÐr+   )
r#   r$   r%   r&   r   r;   r'   r†   rƒ   rˆ   r‰   s   @r,   r×   r×   ˆ  sD   ø„ ñð
>˜yð >¨Tõ >ð
 U§\¡\ð ÀÇÁð ÐRW×R^ÑR^÷ r+   r×   c                   óà   ‡ — e Zd Zdeddfˆ fd„Zdee   ddfd„Z	 	 ddej                  de
ej                     d	edeeej                  ej                  f   eej                     f   fd
„Zˆ xZS )ÚDPTViTAttentionrQ   rq   Nc                 ó€   •— t         ‰| �  «        t        |«      | _        t	        |«      | _        t        «       | _        y r„   )r:   r;   r¯   Ú	attentionr×   ÚoutputÚsetÚpruned_headsr¾   s     €r,   r;   zDPTViTAttention.__init__›  s0   ø€ Ü‰ÑÔÜ)¨&Ó1ˆŒÜ& vÓ.ˆŒÜ›EˆÕr+   Úheadsc                 ó>  — 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   r^   )rF   r   rá   r´   r·   rä   r   rœ   r�   rž   râ   rÙ   r¸   Úunion)rP   rå   r   s      r,   Úprune_headszDPTViTAttention.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+   r1   rÄ   rÅ   c                 óh   — | j                  |||«      }| j                  |d   |«      }|f|dd  z   }|S )Nr   r   )rá   râ   )rP   r1   rÄ   rÅ   Úself_outputsÚattention_outputrÔ   s          r,   rƒ   zDPTViTAttention.forwardµ  sE   € ð —~‘~ m°YÐ@QÓRˆàŸ;™; |°A¡¸ÓFÐà#Ð%¨°Q°RÐ(8Ñ8ˆØˆr+   rÕ   )r#   r$   r%   r   r;   r   r¶   rè   r'   r†   r   r‡   r	   r   rƒ   rˆ   r‰   s   @r,   rß   rß   š  s’   ø„ ð"˜yð "¨Tõ "ð;  S¡ð ;¨dó ;ð, -1Ø"'ñ	à—|‘|ðð ˜EŸL™LÑ)ðð  ð	ð
 
ˆu�U—\‘\ 5§<¡<Ð/Ñ0°%¸¿¹Ñ2EÐ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 )ÚDPTViTIntermediaterQ   rq   Nc                 ó  •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        |j                  t        «      rt        |j                     | _        y |j                  | _        y r„   )r:   r;   r
   r¼   r?   Úintermediate_sizerÙ   r@   Ú
hidden_actÚstrr   Úintermediate_act_fnr¾   s     €r,   r;   zDPTViTIntermediate.__init__Å  s]   ø€ Ü‰ÑÔÜ—Y‘Y˜v×1Ñ1°6×3KÑ3KÓLˆŒ
Ü�f×'Ñ'¬Ô-Ü'-¨f×.?Ñ.?Ñ'@ˆDÕ$à'-×'8Ñ'8ˆDÕ$r+   r1   c                 óJ   — | j                  |«      }| j                  |«      }|S r„   )rÙ   rò   )rP   r1   s     r,   rƒ   zDPTViTIntermediate.forwardÍ  s&   € ØŸ
™
 =Ó1ˆØ×0Ñ0°Ó?ˆàÐr+   ©	r#   r$   r%   r   r;   r'   r†   rƒ   rˆ   r‰   s   @r,   rí   rí   Ä  s1   ø„ ð9˜yð 9¨Tõ 9ð U§\¡\ð °e·l±l÷ r+   rí   c                   óx   ‡ — e Zd Zdeddfˆ fd„Zdej                  dej                  dej                  fd„Zˆ xZS )ÚDPTViTOutputrQ   rq   Nc                 óÈ   •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        j                  |j                  «      | _	        y r„   )
r:   r;   r
   r¼   rï   r?   rÙ   r�   r�   r‘   r¾   s     €r,   r;   zDPTViTOutput.__init__Ö  sB   ø€ Ü‰ÑÔÜ—Y‘Y˜v×7Ñ7¸×9KÑ9KÓLˆŒ
Ü—z‘z &×"<Ñ"<Ó=ˆ�r+   r1   rÚ   c                 óT   — | j                  |«      }| j                  |«      }||z   }|S r„   rÜ   rÝ   s      r,   rƒ   zDPTViTOutput.forwardÛ  s.   € ØŸ
™
 =Ó1ˆØŸ™ ]Ó3ˆà%¨Ñ4ˆàÐr+   rô   r‰   s   @r,   rö   rö   Õ  s?   ø„ ð>˜yð >¨Tõ >ð
 U§\¡\ð ÀÇÁð ÐRW×R^ÑR^÷ r+   rö   c                   óÎ   ‡ — e Zd ZdZdeddfˆ fd„Z	 	 d
dej                  deej                     de	de
eej                  ej                  f   eej                     f   fd	„Zˆ xZS )ÚDPTViTLayerz?This corresponds to the Block class in the timm implementation.rQ   rq   Nc                 ór  •— t         ‰| �  «        |j                  | _        d| _        t	        |«      | _        t        |«      | _        t        |«      | _	        t        j                  |j                  |j                  ¬«      | _        t        j                  |j                  |j                  ¬«      | _        y )Nr   ©Úeps)r:   r;   Úchunk_size_feed_forwardÚseq_len_dimrß   rá   rí   Úintermediaterö   râ   r
   Ú	LayerNormr?   Úlayer_norm_epsÚlayernorm_beforeÚlayernorm_afterr¾   s     €r,   r;   zDPTViTLayer.__init__è  s‡   ø€ Ü‰ÑÔØ'-×'EÑ'EˆÔ$ØˆÔÜ(¨Ó0ˆŒÜ.¨vÓ6ˆÔÜ" 6Ó*ˆŒÜ "§¡¨V×-?Ñ-?ÀV×EZÑEZÔ [ˆÔÜ!Ÿ|™|¨F×,>Ñ,>ÀF×DYÑDYÔZˆÕr+   r1   rÄ   rÅ   c                 óÞ   — | j                  | j                  |«      ||¬«      }|d   }|dd  }||z   }| j                  |«      }| j                  |«      }| j	                  ||«      }|f|z   }|S )N)rÅ   r   r   )rá   r  r  r   râ   )rP   r1   rÄ   rÅ   Úself_attention_outputsrë   rÔ   Úlayer_outputs           r,   rƒ   zDPTViTLayer.forwardò  s–   € ð "&§¡Ø×!Ñ! -Ó0ØØ/ð "0ó "
Ðð
 2°!Ñ4ÐØ(¨¨Ð,ˆð )¨=Ñ8ˆð ×+Ñ+¨MÓ:ˆØ×(Ñ(¨Ó6ˆð —{‘{ <°Ó?ˆà�/ GÑ+ˆàˆr+   rÕ   )r#   r$   r%   r&   r   r;   r'   r†   r   r‡   r	   r   rƒ   rˆ   r‰   s   @r,   rú   rú   å  s�   ø„ ÙIð[˜yð [¨Tõ [ð -1Ø"'ñ	à—|‘|ðð ˜EŸL™LÑ)ðð  ð	ð
 
ˆu�U—\‘\ 5§<¡<Ð/Ñ0°%¸¿¹Ñ2EÐEÑ	F÷r+   rú   c                   óŠ   ‡ — e Zd Zdeddfˆ fd„Z	 	 	 	 ddej                  deej                     deded	ede	e
ef   fd
„Zˆ xZS )ÚDPTViTEncoderrQ   rq   Nc                 óÐ   •— t         ‰| �  «        || _        t        j                  t        |j                  «      D �cg c]  }t        |«      ‘Œ c}«      | _        d| _	        y c c}w rÕ   )
r:   r;   rQ   r
   Ú
ModuleListÚrangeÚnum_hidden_layersrú   ÚlayerÚgradient_checkpointing©rP   rQ   r•   rV   s      €r,   r;   zDPTViTEncoder.__init__  sN   ø€ Ü‰ÑÔØˆŒÜ—]‘]ÄÀv×G_ÑG_ÓA`Ö#a¸A¤K°Õ$7Ò#aÓbˆŒ
Ø&+ˆÕ#ùò $bs   ½A#r1   rÄ   rÅ   r€   rp   c                 ót  — |rdnd }|rdnd }t        | j                  «      D ]h  \  }}	|r||fz   }|�||   nd }
| j                  r+| j                  r| j	                  |	j
                  ||
|«      }n
 |	||
|«      }|d   }|sŒ`||d   fz   }Œj |r||fz   }|st        d„ |||fD «       «      S t        |||¬«      S )Nr*   r   r   c              3   ó&   K  — | ]	  }|€Œ|–— Œ y ­wr„   r*   )Ú.0Úvs     r,   ú	<genexpr>z(DPTViTEncoder.forward.<locals>.<genexpr>;  s   è ø€ Òm˜qÐ_`Ñ_lœÑmùs   ‚Š)r/   r1   r2   )Ú	enumerater  r  r¤   Ú_gradient_checkpointing_funcÚ__call__Útupler   )rP   r1   rÄ   rÅ   r€   rp   Úall_hidden_statesÚall_self_attentionsÚiÚlayer_moduleÚlayer_head_maskÚlayer_outputss               r,   rƒ   zDPTViTEncoder.forward  sÿ   € ñ #7™B¸DÐÙ$5™b¸4Ðä(¨¯©Ó4ò 	P‰OˆAˆ|Ù#Ø$5¸Ð8HÑ$HÐ!à.7Ð.C˜i¨šlÈˆOà×*Ò*¨t¯}ª}Ø $× AÑ AØ ×)Ñ)Ø!Ø#Ø%ó	!‘ñ !-¨]¸OÐM^Ó _�à)¨!Ñ,ˆMâ Ø&9¸]È1Ñ=MÐ<OÑ&OÑ#ð'	Pñ*  Ø 1°]Ð4DÑ DÐáÜÑm ]Ð4EÐGZÐ$[ÔmÓmÐmÜØ+Ø+Ø*ô
ð 	
r+   )NFFT)r#   r$   r%   r   r;   r'   r†   r   r‡   r	   r  r   rƒ   rˆ   r‰   s   @r,   r	  r	    sz   ø„ ð,˜yð ,¨Tõ ,ð -1Ø"'Ø%*Ø ñ)
à—|‘|ð)
ð ˜EŸL™LÑ)ð)
ð  ð	)
ð
 #ð)
ð ð)
ð 
ˆu�oÐ%Ñ	&÷)
r+   r	  c                   ót   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zddeej                     deej                     fd„Z
ˆ xZS )	ÚDPTReassembleStagea@  
    This class reassembles the hidden states of the backbone into image-like feature representations at various
    resolutions.

    This happens in 3 stages:
    1. Map the N + 1 tokens to a set of N tokens, by taking into account the readout ([CLS]) token according to
       `config.readout_type`.
    2. Project the channel dimension of the hidden states according to `config.neck_hidden_sizes`.
    3. Resizing the spatial dimensions (height, width).

    Args:
        config (`[DPTConfig]`):
            Model configuration class defining the model architecture.
    c                 óâ   •— t         ‰| �  «        || _        t        j                  «       | _        |j                  r| j                  |«       n| j                  |«       |j                  | _	        y r„   )
r:   r;   rQ   r
   r  ÚlayersÚ	is_hybridÚ_init_reassemble_dpt_hybridÚ_init_reassemble_dptÚneck_ignore_stagesr¾   s     €r,   r;   zDPTReassembleStage.__init__S  sU   ø€ Ü‰ÑÔàˆŒÜ—m‘m“oˆŒØ×ÒØ×,Ñ,¨VÕ4à×%Ñ% fÔ-à"(×";Ñ";ˆÕr+   c           	      óv  — t        t        t        |j                  «      «      |j                  «      D ]r  \  }}|dk  r.| j
                  j                  t        j                  «       «       Œ9|dkD  sŒ?| j
                  j                  t        ||j                  |   |¬«      «       Œt |j                  dk7  rt        d|j                  › d�«      ‚t        j                  «       | _        t        |«      }t        t        |j                  «      «      D ]¥  }|dk  rA| j                  j                  t        j                  t        j                  «       «      «       ŒI|dkD  sŒO| j                  j                  t        j                  t        j                   d|z  |«      t"        |j$                     «      «       Œ§ y)a   "
        For DPT-Hybrid the first 2 reassemble layers are set to `nn.Identity()`, please check the official
        implementation: https://github.com/isl-org/DPT/blob/f43ef9e08d70a752195028a51be5e1aff227b913/dpt/vit.py#L438
        for more details.
        r   ©rE   ÚfactorÚprojectzReadout type z! is not supported for DPT-Hybrid.rZ   N)Úzipr  rF   Úneck_hidden_sizesÚreassemble_factorsr#  Úappendr
   ÚIdentityÚDPTReassembleLayerÚreadout_typerG   r  Úreadout_projectsÚ_get_backbone_hidden_sizeÚ
Sequentialr¼   r   rð   )rP   rQ   r  r*  r?   s        r,   r%  z.DPTReassembleStage._init_reassemble_dpt_hybrid_  sX  € ô œU¤3 v×'?Ñ'?Ó#@ÓAÀ6×C\ÑC\Ó]ò 	t‰IˆAˆvØ�AŠvØ—‘×"Ñ"¤2§;¡;£=Õ1Ø�Q“Ø—‘×"Ñ"Ô#5°fÀv×G_ÑG_Ð`aÑGbÐkqÔ#rÕsð		tð ×Ñ )Ò+Ü˜}¨V×-@Ñ-@Ð,AÐAbÐcÓdÐdô !#§¡£ˆÔÜ/°Ó7ˆÜ”s˜6×3Ñ3Ó4Ó5ò 	ˆAØ�AŠvØ×%Ñ%×,Ñ,¬R¯]©]¼2¿;¹;»=Ó-IÕJØ�Q“Ø×%Ñ%×,Ñ,Ü—M‘M¤"§)¡)¨A°©O¸[Ó"IÌ6ÐRX×RcÑRcÑKdÓeõñ		r+   c           	      ó<  — t        t        t        |j                  «      «      |j                  «      D ]9  \  }}| j
                  j                  t        ||j                  |   |¬«      «       Œ; |j                  dk(  rŸt        j                  «       | _        t        |«      }t        t        |j                  «      «      D ]Y  }| j                  j                  t        j                  t        j                  d|z  |«      t        |j                      «      «       Œ[ y y )Nr)  r+  rZ   )r,  r  rF   r-  r.  r#  r/  r1  r2  r
   r  r3  r4  r5  r¼   r   rð   )rP   rQ   r  r*  r?   r•   s         r,   r&  z'DPTReassembleStage._init_reassemble_dpty  sæ   € ÜœU¤3 v×'?Ñ'?Ó#@ÓAÀ6×C\ÑC\Ó]ò 	p‰IˆAˆvØ�K‰K×ÑÔ1°&À6×C[ÑC[Ð\]ÑC^ÐgmÔnÕoð	pð ×Ñ )Ò+Ü$&§M¡M£OˆDÔ!Ü3°FÓ;ˆKÜœ3˜v×7Ñ7Ó8Ó9ò �Ø×%Ñ%×,Ñ,Ü—M‘M¤"§)¡)¨A°©O¸[Ó"IÌ6ÐRX×RcÑRcÑKdÓeõñð ,r+   r1   rq   c                 ó   — g }t        |«      D �]¼  \  }}|| j                  v�r–|dd…df   |dd…dd…f   }}|j                  \  }}	}
|�|�|j                  ||||
«      }n"t	        |	dz  «      }|j                  ||||
«      }|j                  dddd«      j                  «       }|j                  }| j                  j                  dk(  rŽ|j                  d«      j                  d«      }|j                  d«      j                  |«      } | j                  |   t        j                  ||fd	«      «      }|j                  ddd«      j                  |«      }nM| j                  j                  d
k(  r4|j                  d«      |j                  d	«      z   }|j                  |«      } | j                  |   |«      }|j!                  |«       �Œ¿ |S )zÇ
        Args:
            hidden_states (`List[torch.FloatTensor]`, each of shape `(batch_size, sequence_length + 1, hidden_size)`):
                List of hidden states from the backbone.
        Nr   r   rY   r   rZ   r+  )r   rZ   r   r6   Úadd)r  r'  ru   r`   r   ra   r©   rQ   r2  rw   Ú	unsqueezeÚ	expand_asr3  r'   rd   r#  r/  )rP   r1   Úpatch_heightÚpatch_widthÚoutr  Úhidden_staterN   rz   Úsequence_lengthr>   r\   Úfeature_shapeÚreadouts                 r,   rƒ   zDPTReassembleStage.forward…  sË  € ð ˆä(¨Ó7ó 	%‰OˆAˆ|Ø˜×/Ñ/Ò/à*6²q¸!°tÑ*<¸lÊ1ÈaÉbÈ5Ñ>Q˜<�	Ø<H×<NÑ<NÑ9�
˜O¨\ØÐ+°Ð0GØ#/×#7Ñ#7¸
ÀLÐR]Ð_kÓ#l‘Lä$ _°cÑ%9Ó:�DØ#/×#7Ñ#7¸
ÀDÈ$ÐP\Ó#]�LØ+×3Ñ3°A°q¸!¸QÓ?×JÑJÓL�à ,× 2Ñ 2�Ø—;‘;×+Ñ+¨yÒ8à#/×#7Ñ#7¸Ó#:×#BÑ#BÀ9Ó#M�LØ'×1Ñ1°!Ó4×>Ñ>¸|ÓL�Gà#; 4×#8Ñ#8¸Ñ#;¼E¿I¹IÀ|ÐU\ÐF]Ð_aÓ<bÓ#c�Là#/×#7Ñ#7¸¸1¸aÓ#@×#HÑ#HÈÓ#W‘LØ—[‘[×-Ñ-°Ò6Ø#/×#7Ñ#7¸Ó#:¸Y×=PÑ=PÐQSÓ=TÑ#T�LØ#/×#7Ñ#7¸Ó#F�LØ-˜tŸ{™{¨1™~¨lÓ;�Ø�J‰J�|Ö$ð3	%ð6 ˆ
r+   ©NN)r#   r$   r%   r&   r;   r%  r&  r   r'   r†   rƒ   rˆ   r‰   s   @r,   r!  r!  C  s@   ø„ ñô
<òò4
ñ# T¨%¯,©,Ñ%7ð #ÐaeÐfk×frÑfrÑas÷ #r+   r!  c                 óz   — | j                   �$| j                  du r| j                   j                  S | j                  S rÕ   )Úbackbone_configr$  r?   )rQ   s    r,   r4  r4  «  s9   € Ø×ÑÐ)¨f×.>Ñ.>À%Ñ.GØ×%Ñ%×1Ñ1Ð1à×!Ñ!Ð!r+   c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )r1  c           	      ó\  •— t         ‰| �  «        t        |«      }t        j                  ||d¬«      | _        |dkD  r t        j                  ||||d¬«      | _        y |dk(  rt        j                  «       | _        y |dk  r,t        j                  ||dt        d|z  «      d¬«      | _        y y )Nr   )Úin_channelsÚout_channelsr9   r   ©r9   r˜   Úpaddingr   )
r:   r;   r4  r
   rJ   rK   ÚConvTranspose2dÚresizer0  r¶   )rP   rQ   rE   r*  r?   rV   s        €r,   r;   zDPTReassembleLayer.__init__³  s–   ø€ Ü‰ÑÔä/°Ó7ˆÜŸ)™)°È(Ð`aÔbˆŒð �AŠ:Ü×,Ñ,¨X°xÈVÐ\bÐlmÔnˆD�KØ�qŠ[ÜŸ+™+›-ˆD�KØ�aŠZäŸ)™) H¨hÀAÌcÐRSÐV\ÑR\ËoÐghÔiˆD�Kð r+   c                 óJ   — | j                  |«      }| j                  |«      }|S r„   )rK   rL  )rP   r>  s     r,   rƒ   zDPTReassembleLayer.forwardÂ  s$   € Ø—‘ |Ó4ˆØ—{‘{ <Ó0ˆØÐr+   ©r#   r$   r%   r;   rƒ   rˆ   r‰   s   @r,   r1  r1  ²  s   ø„ ôjör+   r1  c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )ÚDPTFeatureFusionStagec                 óâ   •— t         ‰| �  «        t        j                  «       | _        t        t        |j                  «      «      D ]&  }| j                  j                  t        |«      «       Œ( y r„   )
r:   r;   r
   r  r#  r  rF   r-  r/  ÚDPTFeatureFusionLayerr  s      €r,   r;   zDPTFeatureFusionStage.__init__É  sR   ø€ Ü‰ÑÔÜ—m‘m“oˆŒÜ”s˜6×3Ñ3Ó4Ó5ò 	>ˆAØ�K‰K×ÑÔ4°VÓ<Õ=ñ	>r+   c                 ó¤   — |d d d…   }g }d }t        || j                  «      D ]*  \  }}|€	 ||«      }n	 |||«      }|j                  |«       Œ, |S )Nr6   )r,  r#  r/  )rP   r1   Úfused_hidden_statesÚfused_hidden_stater>  r  s         r,   rƒ   zDPTFeatureFusionStage.forwardÏ  sq   € à%¡d¨ dÑ+ˆà ÐØ!ÐÜ#& }°d·k±kÓ#Bò 	;ÑˆL˜%Ø!Ð)á%*¨<Ó%8Ñ"á%*Ð+=¸|Ó%LÐ"Ø×&Ñ&Ð'9Õ:ð	;ð #Ð"r+   rN  r‰   s   @r,   rP  rP  È  s   ø„ ô>ö#r+   rP  c                   óZ   ‡ — e Zd ZdZˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚDPTPreActResidualLayerz©
    ResidualConvUnit, pre-activate residual unit.

    Args:
        config (`[DPTConfig]`):
            Model configuration class defining the model architecture.
    c                 ól  •— t         ‰| �  «        |j                  | _        |j                  �|j                  n| j                   }t        j                  «       | _        t        j                  |j                  |j                  ddd|¬«      | _
        t        j                  «       | _        t        j                  |j                  |j                  ddd|¬«      | _        | j                  rIt        j                  |j                  «      | _        t        j                  |j                  «      | _        y y )Nr   r   )r9   r˜   rJ  r³   )r:   r;   Ú!use_batch_norm_in_fusion_residualÚuse_batch_normÚuse_bias_in_fusion_residualr
   ÚReLUÚactivation1rJ   Úfusion_hidden_sizeÚconvolution1Úactivation2Úconvolution2ÚBatchNorm2dÚbatch_norm1Úbatch_norm2)rP   rQ   r[  rV   s      €r,   r;   zDPTPreActResidualLayer.__init__é  s  ø€ Ü‰ÑÔà$×FÑFˆÔð ×1Ñ1Ð=ð ×.Ò.à×(Ñ(Ð(ð 	$ô Ÿ7™7›9ˆÔÜŸI™IØ×%Ñ%Ø×%Ñ%ØØØØ,ô
ˆÔô Ÿ7™7›9ˆÔÜŸI™IØ×%Ñ%Ø×%Ñ%ØØØØ,ô
ˆÔð ×ÒÜ!Ÿ~™~¨f×.GÑ.GÓHˆDÔÜ!Ÿ~™~¨f×.GÑ.GÓHˆDÕð r+   r>  rq   c                 ó  — |}| j                  |«      }| j                  |«      }| j                  r| j                  |«      }| j	                  |«      }| j                  |«      }| j                  r| j                  |«      }||z   S r„   )r]  r_  rZ  rc  r`  ra  rd  ©rP   r>  Úresiduals      r,   rƒ   zDPTPreActResidualLayer.forward  s„   € ØˆØ×'Ñ'¨Ó5ˆà×(Ñ(¨Ó6ˆà×ÒØ×+Ñ+¨LÓ9ˆLà×'Ñ'¨Ó5ˆØ×(Ñ(¨Ó6ˆà×ÒØ×+Ñ+¨LÓ9ˆLà˜hÑ&Ð&r+   )	r#   r$   r%   r&   r;   r'   r†   rƒ   rˆ   r‰   s   @r,   rW  rW  à  s*   ø„ ñô IðD' E§L¡Lð '°U·\±\÷ 'r+   rW  c                   ó,   ‡ — e Zd ZdZdˆ fd„	Zdd„Zˆ xZS )rR  a3  Feature fusion layer, merges feature maps from different stages.

    Args:
        config (`[DPTConfig]`):
            Model configuration class defining the model architecture.
        align_corners (`bool`, *optional*, defaults to `True`):
            The align_corner setting for bilinear upsample.
    c                 óÔ   •— t         ‰| �  «        || _        t        j                  |j
                  |j
                  dd¬«      | _        t        |«      | _        t        |«      | _	        y )Nr   T)r9   r³   )
r:   r;   Úalign_cornersr
   rJ   r^  rK   rW  Úresidual_layer1Úresidual_layer2)rP   rQ   rj  rV   s      €r,   r;   zDPTFeatureFusionLayer.__init__'  sT   ø€ Ü‰ÑÔà*ˆÔäŸ)™) F×$=Ñ$=¸v×?XÑ?XÐfgÐnrÔsˆŒä5°fÓ=ˆÔÜ5°fÓ=ˆÕr+   c                 ó€  — |�l|j                   |j                   k7  r?t        j                  j                  ||j                   d   |j                   d   fdd¬«      }|| j	                  |«      z   }| j                  |«      }t        j                  j                  |dd| j                  ¬«      }| j                  |«      }|S )NrZ   r   r[   F©r\   r]   rj  ©Úscale_factorr]   rj  )ru   r
   rb   rc   rk  rl  rj  rK   rf  s      r,   rƒ   zDPTFeatureFusionLayer.forward1  s¾   € ØÐØ×!Ñ! X§^¡^Ò3ÜŸ=™=×4Ñ4Ø L×$6Ñ$6°qÑ$9¸<×;MÑ;MÈaÑ;PÐ#QÐXbÐrwð 5ó �ð (¨$×*>Ñ*>¸xÓ*HÑHˆLà×+Ñ+¨LÓ9ˆÜ—}‘}×0Ñ0Ø q¨zÈ×I[ÑI[ð 1ó 
ˆð —‘ |Ó4ˆàÐr+   ©Tr„   rš   r‰   s   @r,   rR  rR    s   ø„ ñõ>÷r+   rR  c                   ó.   — e Zd ZdZeZdZdZdZdZ	dZ
d„ Zy)ÚDPTPreTrainedModelz†
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    Údptrn   Tc                 óÒ  — t        |t        j                  t        j                  t        j                  f«      rl|j
                  j                  j                  d| j                  j                  ¬«       |j                  �ˆ|j                  j                  j                  «        nct        |t        j                  «      rI|j                  j                  j                  «        |j
                  j                  j                  d«       t        |t        t        f«      rI|j                   j                  j                  «        |j"                  j                  j                  «        yy)zInitialize the weightsrÉ   )ÚmeanÚstdNg      ð?)r@   r
   r¼   rJ   rK  ÚweightÚdataÚnormal_rQ   Úinitializer_ranger³   Úzero_r  Úfill_r‹   r4   rN   rO   )rP   r›   s     r,   Ú_init_weightsz DPTPreTrainedModel._init_weightsO  sí   € ä�fœrŸy™y¬"¯)©)´R×5GÑ5GÐHÔIð �M‰M×Ñ×&Ñ&¨C°T·[±[×5RÑ5RÐ&ÔSØ�{‰{Ð&Ø—‘× Ñ ×&Ñ&Õ(Ü˜¤§¡Ô-Ø�K‰K×Ñ×"Ñ"Ô$Ø�M‰M×Ñ×$Ñ$ SÔ)Ü�fÔ/Ô1GÐHÔIØ×Ñ×!Ñ!×'Ñ'Ô)Ø×&Ñ&×+Ñ+×1Ñ1Õ3ð Jr+   N)r#   r$   r%   r&   r   Úconfig_classÚbase_model_prefixÚmain_input_nameÚsupports_gradient_checkpointingÚ_supports_sdpaÚ_supports_flash_attn_2r~  r*   r+   r,   rs  rs  B  s/   „ ñð
 €LØÐØ$€OØ&*Ð#Ø€NØ!Ðó4r+   rs  aE  
    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 ([`ViTConfig`]): 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.
aP  
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`DPTImageProcessor.__call__`]
            for details.

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

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

        output_attentions (`bool`, *optional*):
            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
            tensors for more detail.
        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
z]The bare DPT Model transformer outputting raw hidden-states without any specific head on top.c                   óÖ   ‡ — e Zd Zdˆ 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   d	ee   d
ee   deee
f   fd„«       «       Zˆ xZS )ÚDPTModelc                 óT  •— t         ‰| �  |«       || _        |j                  rt	        |«      | _        nt        |«      | _        t        |«      | _        t        j                  |j                  |j                  ¬«      | _        |rt        |«      nd | _        | j!                  «        y )Nrü   )r:   r;   rQ   r$  r4   r�   r‹   r	  Úencoderr
   r  r?   r  Ú	layernormÚDPTViTPoolerÚpoolerÚ	post_init)rP   rQ   Úadd_pooling_layerrV   s      €r,   r;   zDPTModel.__init__†  s€   ø€ Ü‰Ñ˜Ô ØˆŒð ×ÒÜ4°VÓ<ˆD�Oä.¨vÓ6ˆDŒOÜ$ VÓ,ˆŒäŸ™ f×&8Ñ&8¸f×>SÑ>SÔTˆŒÙ.?”l 6Ô*ÀTˆŒð 	�‰Õr+   c                 ór   — | j                   j                  r| j                  S | j                  j                  S r„   )rQ   r$  r�   rŽ   )rP   s    r,   Úget_input_embeddingszDPTModel.get_input_embeddings—  s)   € Ø�;‰;× Ò Ø—?‘?Ð"à—?‘?×3Ñ3Ð3r+   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)Úitemsrˆ  r  rá   rè   )rP   Úheads_to_pruner  rå   s       r,   Ú_prune_headszDPTModel._prune_heads�  sE   € ð
 +×0Ñ0Ó2ò 	C‰LˆE�5Ø�L‰L×Ñ˜uÑ%×/Ñ/×;Ñ;¸EÕBñ	Cr+   Úvision)Ú
checkpointÚoutput_typer  ÚmodalityÚexpected_outputrn   rÄ   rÅ   r€   rp   rq   c                 óZ  — |�|n| j                   j                  }|�|n| j                   j                  }|�|n| j                   j                  }| j	                  || j                   j
                  «      }| j                  ||¬«      }|s|d   n|j                  }| j                  |||||¬«      }|d   }	| j                  |	«      }	| j                  �| j                  |	«      nd }
|s|
�|	|
fn|	f}||dd  z   |dd  z   S t        |	|
|j                  |j                  |j                  ¬«      S )N)rp   r   ©rÄ   rÅ   r€   rp   r   )r/   r0   r1   r2   r"   )rQ   rÅ   r€   Úuse_return_dictÚget_head_maskr  r�   r!   rˆ  r‰  r‹  r.   r1   r2   r"   )rP   rn   rÄ   rÅ   r€   rp   Úembedding_outputÚembedding_last_hidden_statesÚencoder_outputsÚsequence_outputÚpooled_outputÚhead_outputss               r,   rƒ   zDPTModel.forward¥  sU  € ð  2CÐ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð &1Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆð ×&Ñ& y°$·+±+×2OÑ2OÓPˆ	àŸ?™?¨<À[˜?ÓQÐáBMÐ'7¸Ò':ÐSc×SvÑSvÐ$àŸ,™,Ø(ØØ/Ø!5Ø#ð 'ó 
ˆð *¨!Ñ,ˆØŸ.™.¨Ó9ˆØ8<¿¹Ð8O˜Ÿ™ OÔ4ÐUYˆáØ?LÐ?X˜O¨]Ñ;Ð_nÐ^pˆLØ /°!°"Ð"5Ñ5Ð8HÈÈÐ8LÑLÐLäCØ-Ø'Ø)×7Ñ7Ø&×1Ñ1Ø%5×%NÑ%Nô
ð 	
r+   rq  )NNNN)r#   r$   r%   r;   r�  r“  r   ÚDPT_INPUTS_DOCSTRINGr   Ú_CHECKPOINT_FOR_DOCr.   Ú_CONFIG_FOR_DOCÚ_EXPECTED_OUTPUT_SHAPEr'   r(   r   r‡   r	   r   rƒ   rˆ   r‰   s   @r,   r†  r†  �  sº   ø„ õ
ò"4òCñ +Ð+?Ó@ÙØ&ØHØ$ØØ.ôð 26Ø,0Ø/3Ø&*ñ/
à×'Ñ'ð/
ð ˜E×-Ñ-Ñ.ð/
ð $ D™>ð	/
ð
 ' t™nð/
ð ˜d‘^ð/
ð 
ˆuÐJÐJÑ	Kò/
óó Aô/
r+   r†  c                   ó*   ‡ — e Zd Zdefˆ fd„Zd„ Zˆ xZS )rŠ  rQ   c                 ó°   •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        |j                     | _	        y r„   )
r:   r;   r
   r¼   r?   Úpooler_output_sizerÙ   r   Ú
pooler_actÚ
activationr¾   s     €r,   r;   zDPTViTPooler.__init__á  s>   ø€ Ü‰ÑÔÜ—Y‘Y˜v×1Ñ1°6×3LÑ3LÓMˆŒ
Ü  ×!2Ñ!2Ñ3ˆ�r+   c                 ó\   — |d d …df   }| j                  |«      }| j                  |«      }|S )Nr   )rÙ   r«  )rP   r1   Úfirst_token_tensorr¡  s       r,   rƒ   zDPTViTPooler.forwardæ  s6   € ð +ª1¨a¨4Ñ0ÐØŸ
™
Ð#5Ó6ˆØŸ™¨Ó6ˆØÐr+   )r#   r$   r%   r   r;   rƒ   rˆ   r‰   s   @r,   rŠ  rŠ  à  s   ø„ ð4˜yõ 4ö
r+   rŠ  c                   óh   ‡ — e Zd ZdZˆ fd„Zddeej                     deej                     fd„Zˆ xZ	S )ÚDPTNecka;  
    DPTNeck. A neck is a module that is normally used between the backbone and the head. It takes a list of tensors as
    input and produces another list of tensors as output. For DPT, it includes 2 stages:

    * DPTReassembleStage
    * DPTFeatureFusionStage.

    Args:
        config (dict): config dict.
    c           
      ó–  •— t         ‰| �  «        || _        |j                  � |j                  j                  dv rd | _        nt        |«      | _        t        j                  «       | _	        |j                  D ]?  }| j                  j                  t        j                  ||j                  ddd¬«      «       ŒA t        |«      | _        y )N)Úswinv2r   r   F©r9   rJ  r³   )r:   r;   rQ   rD  Ú
model_typeÚreassemble_stager!  r
   r  Úconvsr-  r/  rJ   r^  rP  Úfusion_stage)rP   rQ   ÚchannelrV   s      €r,   r;   zDPTNeck.__init__û  s«   ø€ Ü‰ÑÔØˆŒð ×!Ñ!Ð-°&×2HÑ2H×2SÑ2SÐWaÑ2aØ$(ˆDÕ!ä$6°vÓ$>ˆDÔ!ä—]‘]“_ˆŒ
Ø×/Ñ/ò 	sˆGØ�J‰J×ÑœbŸi™i¨°×1JÑ1JÐXYÐcdÐkpÔqÕrð	sô 2°&Ó9ˆÕr+   r1   rq   c                 ó€  — t        |t        t        f«      st        d«      ‚t	        |«      t	        | j
                  j                  «      k7  rt        d«      ‚| j                  �| j                  |||«      }t        |«      D ��cg c]  \  }} | j                  |   |«      ‘Œ }}}| j                  |«      }|S c c}}w )zñ
        Args:
            hidden_states (`List[torch.FloatTensor]`, each of shape `(batch_size, sequence_length, hidden_size)` or `(batch_size, hidden_size, height, width)`):
                List of hidden states from the backbone.
        z2hidden_states should be a tuple or list of tensorszOThe number of hidden states should be equal to the number of neck hidden sizes.)r@   r  ÚlistÚ	TypeErrorrF   rQ   r-  rG   r´  r  rµ  r¶  )rP   r1   r;  r<  r  Úfeaturer~   râ   s           r,   rƒ   zDPTNeck.forward  s°   € ô ˜-¬%´¨Ô7ÜÐPÓQÐQäˆ}Ó¤ T§[¡[×%BÑ%BÓ!CÒCÜÐnÓoÐoð × Ñ Ð,Ø ×1Ñ1°-ÀÈ{Ó[ˆMä=FÀ}Ó=U×V©z¨q°'�M�D—J‘J˜q‘M 'Õ*ÐVˆÑVð ×"Ñ" 8Ó,ˆàˆùó Ws   ÂB:rB  ©
r#   r$   r%   r&   r;   r   r'   r†   rƒ   rˆ   r‰   s   @r,   r¯  r¯  ï  s6   ø„ ñ	ô:ñ" T¨%¯,©,Ñ%7ð ÐaeÐfk×frÑfrÑas÷ r+   r¯  c                   ó`   ‡ — e Zd ZdZˆ fd„Zdeej                     dej                  fd„Zˆ xZ	S )ÚDPTDepthEstimationHeada	  
    Output head consisting of 3 convolutional layers. It progressively halves the feature dimension and upsamples
    the predictions to the input resolution after the first convolutional layer (details can be found in the paper's
    supplementary material).
    c                 óú  •— t         ‰| �  «        || _        d | _        |j                  rt        j                  ddddd¬«      | _        |j                  }t        j                  t        j                  ||dz  ddd¬«      t        j                  ddd	¬
«      t        j                  |dz  dddd¬«      t        j                  «       t        j                  ddddd¬«      t        j                  «       «      | _        y )Né   )r   r   )r   r   rI  rZ   r   r   r[   Tro  é    r   )r:   r;   rQ   rK   Úadd_projectionr
   rJ   r^  r5  ÚUpsampler\  Úhead©rP   rQ   r~   rV   s      €r,   r;   zDPTDepthEstimationHead.__init__+  sÀ   ø€ Ü‰ÑÔàˆŒàˆŒØ× Ò Ü Ÿi™i¨¨S¸fÈVÐ]cÔdˆDŒOà×,Ñ,ˆÜ—M‘MÜ�I‰I�h ¨A¡¸1ÀQÐPQÔRÜ�K‰K Q¨ZÀtÔLÜ�I‰I�h !‘m R°Q¸qÈ!ÔLÜ�G‰G‹IÜ�I‰I�b˜!¨°1¸aÔ@Ü�G‰G‹Ió
ˆ�	r+   r1   rq   c                 óì   — || j                   j                     }| j                  �+| j                  |«      } t        j                  «       |«      }| j                  |«      }|j                  d¬«      }|S )Nr   r^   )rQ   Úhead_in_indexrK   r
   r\  rÄ  Úsqueeze)rP   r1   Úpredicted_depths      r,   rƒ   zDPTDepthEstimationHead.forward>  sg   € à% d§k¡k×&?Ñ&?Ñ@ˆà�?‰?Ð&Ø ŸO™O¨MÓ:ˆMØ%œBŸG™G›I mÓ4ˆMàŸ)™) MÓ2ˆà)×1Ñ1°aÐ1Ó8ˆàÐr+   r¼  r‰   s   @r,   r¾  r¾  $  s-   ø„ ñô
ð& T¨%¯,©,Ñ%7ð ¸E¿L¹L÷ r+   r¾  zu
    DPT Model with a depth estimation head on top (consisting of 3 convolutional layers) e.g. for KITTI, NYUv2.
    c                   óü   ‡ — e Zd Zˆ fd„Z ee«       eee¬«      	 	 	 	 	 dde	j                  dee	j                     dee	j                     dee   dee   dee   d	eee	j                      ef   fd
„«       «       Zˆ xZS )ÚDPTForDepthEstimationc                 ó$  •— t         ‰| �  |«       d | _        |j                  du r)|j                  €|j                  �t        |«      | _        nt        |d¬«      | _        t        |«      | _	        t        |«      | _        | j                  «        y ©NF)r�  )r:   r;   rD   r$  rD  r   r†  rt  r¯  Úneckr¾  rÄ  rŒ  r¾   s     €r,   r;   zDPTForDepthEstimation.__init__T  s}   ø€ Ü‰Ñ˜Ô àˆŒØ×Ñ˜uÑ$¨&×*@Ñ*@Ð*LÐPV×P_ÑP_ÐPkÜ)¨&Ó1ˆD�Mä ¸%Ô@ˆDŒHô ˜F“OˆŒ	ô +¨6Ó2ˆŒ	ð 	�‰Õr+   ©r–  r  rn   rÄ   ÚlabelsrÅ   r€   rp   rq   c                 óf  ‡ — d}|�t        d«      ‚|�|n‰ j                  j                  }|�|n‰ j                  j                  }|�|n‰ j                  j                  }‰ j
                  �+‰ j
                  j                  |||¬«      }|j                  }	n½‰ j                  |||d|¬«      }|r|j                  n|d   }	‰ j                  j                  s:t        |	dd «      D �
�cg c]   \  }
}|
‰ j                  j                  v sŒ|‘Œ" }	}
}nD|r|j                  nt        |d   «      }|j                  ˆ fd„t        |	dd «      D «       «       |}	d	\  }}‰ j                  j                   �S‰ j                  j                  d
u r;|j"                  \  }}}}‰ j                  j                   j$                  }||z  }||z  }‰ j'                  |	||«      }	‰ j)                  |	«      }|s|r
|f|dd z   }n	|f|dd z   }|�|f|z   S |S t+        |||r|j                  nd|j,                  ¬«      S c c}}
w )aš  
        labels (`torch.LongTensor` of shape `(batch_size, height, width)`, *optional*):
            Ground truth depth estimation maps for computing the loss.

        Returns:

        Examples:
        ```python
        >>> from transformers import AutoImageProcessor, DPTForDepthEstimation
        >>> import torch
        >>> import numpy as np
        >>> 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("Intel/dpt-large")
        >>> model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large")

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

        >>> with torch.no_grad():
        ...     outputs = model(**inputs)

        >>> # interpolate to original size
        >>> post_processed_output = image_processor.post_process_depth_estimation(
        ...     outputs,
        ...     target_sizes=[(image.height, image.width)],
        ... )

        >>> # visualize the prediction
        >>> predicted_depth = post_processed_output[0]["predicted_depth"]
        >>> depth = predicted_depth * 255 / predicted_depth.max()
        >>> depth = depth.detach().cpu().numpy()
        >>> depth = Image.fromarray(depth.astype("uint8"))
        ```NzTraining is not implemented yet)r€   rÅ   Trš  r   r6   c              3   ó^   •K  — | ]$  \  }}|‰j                   j                  d d v r|–— Œ& y­w©rZ   N©rQ   Úbackbone_out_indices©r  Úidxr»  rP   s      €r,   r  z0DPTForDepthEstimation.forward.<locals>.<genexpr>·  s6   øè ø€ ò .á$˜˜WØ˜dŸk™k×>Ñ>¸q¸rÐBÑBô ñ.ùs   ƒ*-rB  FrZ   )ÚlossrÉ  r1   r2   )ÚNotImplementedErrorrQ   r›  r€   rÅ   rD   Úforward_with_filtered_kwargsrv   rt  r1   r$  r  rÕ  r"   r¹  ÚextendrD  ru   r=   rÎ  rÄ  r   r2   )rP   rn   rÄ   rÐ  rÅ   r€   rp   rØ  rÔ   r1   r×  r»  Úbackbone_hidden_statesr;  r<  r•   r{   r|   r=   rÉ  râ   s   `                    r,   rƒ   zDPTForDepthEstimation.forwardf  st  ø€ ðb ˆØÐÜ%Ð&GÓHÐHà%0Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð 2CÐ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà�=‰=Ð$Ø—m‘m×@Ñ@ØÐ3GÐ[lð Aó ˆGð $×0Ñ0‰Mà—h‘hØØ#Ø"3Ø%)Ø'ð ó ˆGñ 6A˜G×1Ò1ÀgÈaÁjˆMð —;‘;×(Ò(ä09¸-ÈÈÐ:KÓ0L÷!Ù ,  WÐPSÐW[×WbÑWb×WwÑWwÒPw’Gð!�ò !ñ NY¨×)IÒ)IÔ^bÐcjÐkmÑcnÓ^oÐ&Ø&×-Ñ-ó .ä(1°-ÀÀÐ2CÓ(Dô.ô ð !7�à$.Ñ!ˆ�kØ�;‰;×&Ñ&Ð2°t·{±{×7LÑ7LÐPUÑ7UØ".×"4Ñ"4ÑˆAˆq�&˜%ØŸ™×4Ñ4×?Ñ?ˆJØ! ZÑ/ˆLØ :Ñ-ˆKàŸ	™	 -°¸{ÓKˆàŸ)™) MÓ2ˆáÙ#Ø)Ð+¨g°a°b¨kÑ9‘à)Ð+¨g°a°b¨kÑ9�Ø)-Ð)9�T�G˜fÑ$ÐE¸vÐEä#ØØ+Ù3G˜'×/Ò/ÈTØ×)Ñ)ô	
ð 	
ùó?!s   Ã& H-ÄH-)NNNNN)r#   r$   r%   r;   r   r£  r   r   r¥  r'   r(   r   Ú
LongTensorr‡   r	   r   r†   rƒ   rˆ   r‰   s   @r,   rË  rË  M  sÎ   ø„ ôñ$ +Ð+?Ó@ÙÐ+?ÈoÔ^ð 26Ø-1Ø,0Ø/3Ø&*ñn
à×'Ñ'ðn
ð ˜E×-Ñ-Ñ.ðn
ð ˜×)Ñ)Ñ*ð	n
ð
 $ D™>ðn
ð ' t™nðn
ð ˜d‘^ðn
ð 
ˆu�U—\‘\Ñ"Ð$8Ð8Ñ	9òn
ó _ó Aôn
r+   rË  c                   ó\   ‡ — e Zd Zˆ fd„Zdeej                     dej                  fd„Zˆ xZS )ÚDPTSemanticSegmentationHeadc                 ó¦  •— t         ‰| �  «        || _        |j                  }t	        j
                  t	        j                  ||ddd¬«      t	        j                  |«      t	        j                  «       t	        j                  |j                  «      t	        j                  ||j                  d¬«      t	        j                  ddd¬	«      «      | _        y )
Nr   r   Fr²  r8   rZ   r[   Tro  )r:   r;   rQ   r^  r
   r5  rJ   rb  r\  r�   Úsemantic_classifier_dropoutÚ
num_labelsrÃ  rÄ  rÅ  s      €r,   r;   z$DPTSemanticSegmentationHead.__init__Ú  s‘   ø€ Ü‰ÑÔàˆŒà×,Ñ,ˆÜ—M‘MÜ�I‰I�h °aÀÈÔOÜ�N‰N˜8Ó$Ü�G‰G‹IÜ�J‰J�v×9Ñ9Ó:Ü�I‰I�h × 1Ñ 1¸qÔAÜ�K‰K Q¨ZÀtÔLó
ˆ�	r+   r1   rq   c                 óZ   — || j                   j                     }| j                  |«      }|S r„   )rQ   rÇ  rÄ  ©rP   r1   Úlogitss      r,   rƒ   z#DPTSemanticSegmentationHead.forwardé  s)   € à% d§k¡k×&?Ñ&?Ñ@ˆà—‘˜=Ó)ˆàˆr+   )	r#   r$   r%   r;   r   r'   r†   rƒ   rˆ   r‰   s   @r,   rß  rß  Ù  s(   ø„ ô
ð T¨%¯,©,Ñ%7ð ¸E¿L¹L÷ r+   rß  c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )ÚDPTAuxiliaryHeadc                 óX  •— t         ‰| �  «        |j                  }t        j                  t        j
                  ||ddd¬«      t        j                  |«      t        j                  «       t        j                  dd«      t        j
                  ||j                  d¬«      «      | _
        y )Nr   r   Fr²  gš™™™™™¹?r8   )r:   r;   r^  r
   r5  rJ   rb  r\  r�   râ  rÄ  rÅ  s      €r,   r;   zDPTAuxiliaryHead.__init__ó  sv   ø€ Ü‰ÑÔà×,Ñ,ˆÜ—M‘MÜ�I‰I�h °aÀÈÔOÜ�N‰N˜8Ó$Ü�G‰G‹IÜ�J‰J�s˜EÓ"Ü�I‰I�h × 1Ñ 1¸qÔAó
ˆ�	r+   c                 ó(   — | j                  |«      }|S r„   )rÄ  rä  s      r,   rƒ   zDPTAuxiliaryHead.forwardÿ  s   € Ø—‘˜=Ó)ˆàˆr+   rN  r‰   s   @r,   rç  rç  ò  s   ø„ ô

ör+   rç  zY
    DPT Model with a semantic segmentation head on top e.g. for ADE20k, CityScapes.
    c                   ó  ‡ — e Zd Zˆ f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	e   d	eee
j                      ef   fd
„«       «       Zˆ xZS )ÚDPTForSemanticSegmentationc                 óä   •— t         ‰| �  |«       t        |d¬«      | _        t	        |«      | _        t        |«      | _        |j                  rt        |«      nd | _
        | j                  «        y rÍ  )r:   r;   r†  rt  r¯  rÎ  rß  rÄ  Úuse_auxiliary_headrç  Úauxiliary_headrŒ  r¾   s     €r,   r;   z#DPTForSemanticSegmentation.__init__  s^   ø€ Ü‰Ñ˜Ô ä˜F°eÔ<ˆŒô ˜F“OˆŒ	ô 0°Ó7ˆŒ	Ø:@×:SÒ:SÔ.¨vÔ6ÐY]ˆÔð 	�‰Õr+   rÏ  rn   rÄ   rÐ  rÅ   r€   rp   rq   c                 óÀ  ‡ — |�|n‰ j                   j                  }|�|n‰ j                   j                  }|�$‰ j                   j                  dk(  rt	        d«      ‚‰ j                  |||d|¬«      }|r|j                  n|d   }‰ j                   j                  s:t        |dd «      D �	�
cg c]   \  }	}
|	‰ j                   j                  v sŒ|
‘Œ" }}	}
nD|r|j                  nt        |d   «      }|j                  ˆ fd„t        |dd «      D «       «       |}‰ j                  |¬«      }‰ j                  |«      }d}‰ j                  �‰ j                  |d   «      }d}|�°t         j"                  j%                  ||j&                  d	d d
d¬«      }|�0t         j"                  j%                  ||j&                  d	d d
d¬«      }t)        ‰ j                   j*                  ¬«      } |||«      } ||«      }|‰ j                   j,                  |z  z   }|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 )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).

        Returns:

        Examples:
        ```python
        >>> from transformers import AutoImageProcessor, DPTForSemanticSegmentation
        >>> 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("Intel/dpt-large-ade")
        >>> model = DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade")

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

        >>> outputs = model(**inputs)
        >>> logits = outputs.logits
        ```Nr   z/The number of labels should be greater than oneTrš  r6   c              3   ó`   •K  — | ]%  \  }}|‰j                   j                  d d v sŒ"|–— Œ' y­wrÓ  rÔ  rÖ  s      €r,   r  z5DPTForSemanticSegmentation.forward.<locals>.<genexpr>X  s7   øè ø€ ò *Ù(˜C ÈCÐSW×S^ÑS^×SsÑSsÐtuÐtvÐSwÒLw”ñ*ùs   ƒ#.§.)r1   r7   r[   Frn  )Úignore_indexrZ   )rØ  rå  r1   r2   )rQ   r›  r€   râ  rG   rt  r1   r$  r  rÕ  r"   r¹  rÛ  rÎ  rÄ  rî  r
   rb   rc   ru   r   Úsemantic_loss_ignore_indexÚauxiliary_loss_weightr   r2   )rP   rn   rÄ   rÐ  rÅ   r€   rp   rÔ   r1   r×  r»  rÜ  rå  Úauxiliary_logitsrØ  Úupsampled_logitsÚupsampled_auxiliary_logitsÚloss_fctÚ	main_lossÚauxiliary_lossrâ   s   `                    r,   rƒ   z"DPTForSemanticSegmentation.forward  sž  ø€ ðF &1Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð Ð $§+¡+×"8Ñ"8¸AÒ"=ÜÐNÓOÐOà—(‘(ØØØ/Ø!%Ø#ð ó 
ˆñ 2=˜×-Ò-À'È!Á*ˆð �{‰{×$Ò$ä,5°mÀAÀBÐ6GÓ,H÷Ù(˜C ÈCÐSW×S^ÑS^×SsÑSsÒLs’ðˆMò ñ JU W×%EÒ%EÔZ^Ð_fÐgiÑ_jÓZkÐ"Ø"×)Ñ)ó *Ü,5°mÀAÀBÐ6GÓ,Hô*ô ð 3ˆMàŸ	™	°˜	Ó>ˆà—‘˜=Ó)ˆàÐØ×ÑÐ*Ø#×2Ñ2°=ÀÑ3DÓEÐàˆØÐä!Ÿ}™}×8Ñ8Ø˜VŸ\™\¨"¨#Ð.°ZÈuð  9ó  Ðð  Ð+Ü-/¯]©]×-FÑ-FØ$¨6¯<©<¸¸Ð+<À:Ð]bð .Gó .Ð*ô (°T·[±[×5[Ñ5[Ô\ˆHÙ Ð!1°6Ó:ˆIÙ%Ð&@À&ÓIˆNØ˜tŸ{™{×@Ñ@À>ÑQÑQˆDáÙ#Ø ˜ W¨Q¨R [Ñ0‘à ˜ W¨Q¨R [Ñ0�Ø)-Ð)9�T�G˜fÑ$ÐE¸vÐEä&ØØÙ3G˜'×/Ò/ÈTØ×)Ñ)ô	
ð 	
ùóUs   Â, IÃI)NNNNNN)r#   r$   r%   r;   r   r£  r   r   r¥  r   r'   r(   rÝ  r‡   r	   r   r†   rƒ   rˆ   r‰   s   @r,   rë  rë    s×   ø„ ôñ +Ð+?Ó@ÙÐ+BÐQ`Ôað 59Ø15Ø-1Ø,0Ø/3Ø&*ñe
à˜u×0Ñ0Ñ1ðe
ð ˜E×-Ñ-Ñ.ðe
ð ˜×)Ñ)Ñ*ð	e
ð
 $ D™>ðe
ð ' t™nðe
ð ˜d‘^ðe
ð 
ˆu�U—\‘\Ñ"Ð$;Ð;Ñ	<òe
ó bó Aôe
r+   rë  )rË  rë  r†  rs  )rÉ   )Rr&   Úcollections.abcrA   Údataclassesr   Útypingr   r   r   r   r   r	   r'   Útorch.utils.checkpointr
   Útorch.nnr   Úactivationsr   Ú
file_utilsr   r   r   r   Úmodeling_outputsr   r   r   Úmodeling_utilsr   r   Úpytorch_utilsr   r   Úutilsr   r   r   Úutils.backbone_utilsr   Úconfiguration_dptr   Ú
get_loggerr#   rË   r¥  r¤  r¦  r    r.   ÚModuler4   r‹   r�   r†   Úfloatr­   r¯   r×   rß   rí   rö   rú   r	  r!  r4  r1  rP  rW  rR  rs  ÚDPT_START_DOCSTRINGr£  r†  rŠ  r¯  r¾  rË  rß  rç  rë  Ú__all__r*   r+   r,   ú<module>r     s  ðñó Ý !ß >× >ã Û Ý Ý %å !÷ó ÷ _Ñ ^ß Fß Qß 4Ñ 4Ý 1Ý (ð 
ˆ×	Ñ	˜HÓ	%€ð €ð (Ð Ú'Ð ð ôM°ó Mó ðMð  ô M¸;ó  Mó ð MôF`
˜RŸY™Yô `
ôF7Y�r—y‘yô 7Yôt˜BŸI™Iô ðN ñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 ˜UŸ\™\Ñ*ð%ð ð%ð ó%ô>;�r—y‘yô ;ô~�r—y‘yô ô$&�b—i‘iô &ôT˜Ÿ™ô ô"�2—9‘9ô ô '�"—)‘)ô 'ôV0
�B—I‘Iô 0
ôfe˜Ÿ™ô eòP"ô˜Ÿ™ô ô,#˜BŸI™Iô #ô0:'˜RŸY™Yô :'ôz"˜BŸI™Iô "ôJ4˜ô 4ð:	Ð ðÐ ñ. ØcØóôW
Ð!ó W
ó	ðW
ôv�2—9‘9ô ô2ˆb�i‰iô 2ôj&˜RŸY™Yô &ñR ðð ó	ôC
Ð.ó C
óðC
ôL "§)¡)ô ô2�r—y‘yô ñ& ðð ó	ôw
Ð!3ó w
óðw
òt d�r+   