Ë
    ÛÓ^jÃ½  ã                   óô  — d 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 ddlmZmZmZ ddlmZmZ ddlmZ ddlmZmZmZm Z m!Z! ddl"m#Z#m$Z$ ddl%m&Z& ddl'm(Z(  e jR                  e*«      Z+ ed¬«      e G d„ de«      «       «       Z, ed¬«      e G d„ de«      «       «       Z- G d„ dej\                  «      Z/ G d„ dej\                  «      Z0 G d„ d ej\                  «      Z1	 	 dWd!ej\                  d"ejd                  d#ejd                  d$ejd                  d%ejd                  dz  d&e3dz  d'e3d(ee   fd)„Z4 G d*„ d+ej\                  «      Z5 G d,„ d-ej\                  «      Z6 G d.„ d/ej\                  «      Z7 G d0„ d1ej\                  «      Z8 G d2„ d3ej\                  «      Z9 G d4„ d5e«      Z: G d6„ d7ej\                  «      Z;d8„ Z< G d9„ d:ej\                  «      Z= G d;„ d<ej\                  «      Z> G d=„ d>ej\                  «      Z? G d?„ d@ej\                  «      Z@e G dA„ dBe«      «       ZA G dC„ dDej\                  «      ZBe G dE„ dFeA«      «       ZC G dG„ dHej\                  «      ZD G dI„ dJej\                  «      ZE G dK„ dLej\                  «      ZF edM¬«       G dN„ dOeA«      «       ZG G dP„ dQej\                  «      ZH G dR„ dSej\                  «      ZIe G dT„ dUeA«      «       ZJg dV¢ZKy)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)ÚCallable)Ú	dataclass)Únn)ÚCrossEntropyLossé   )Úinitialization)ÚACT2FN)Úload_backbone)ÚGradientCheckpointingLayer)ÚBaseModelOutputÚDepthEstimatorOutputÚSemanticSegmenterOutput)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚloggingÚ	torch_int)Úcan_return_tupleÚmerge_with_config_defaults)Úcapture_outputsé   )Ú	DPTConfigz£
    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.:
    )Úcustom_introc                   ól   — e Zd ZU dZdZej                  dz  ed<   dZe	ej                  df   dz  ed<   y)Ú*BaseModelOutputWithIntermediateActivationsak  
    last_hidden_states (`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   ÚtorchÚFloatTensorÚ__annotations__r    Útuple© ó    úo/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/dpt/modeling_dpt.pyr   r   -   s?   … ñð 48Ð˜×)Ñ)¨DÑ0Ó7ØEIÐ˜e E×$5Ñ$5°sÐ$:Ñ;¸dÑBÔIr*   r   z¶
    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.
    c                   óø   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)	Ú4BaseModelOutputWithPoolingAndIntermediateActivationsaÐ  
    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.
    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   r(   r1   r    r)   r*   r+   r-   r-   @   s’   … ñð 37Ð�u×(Ñ(¨4Ñ/Ó6Ø.2€M�5×$Ñ$ tÑ+Ó2Ø:>€M�5˜×*Ñ*¨CÐ/Ñ0°4Ñ7Ó>Ø7;€J��e×'Ñ'¨Ð,Ñ-°Ñ4Ó;ØEIÐ˜e E×$5Ñ$5°sÐ$:Ñ;¸dÑBÔIr*   r-   c                   ór   ‡ — e Zd ZdZddedeeef   dz  fˆ fd„Zdd„Z	 dde	j                  ded	e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.
    NÚconfigÚfeature_sizec                 ó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)Úselfr4   r5   r=   r>   r?   r@   Únum_patchesÚfeature_dimÚfeat_map_shapeÚ	__class__s             €r+   r<   zDPTViTHybridEmbeddings.__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ˆä% 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                 óz  — |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 ©
Nr   ç      à?r   r7   r   é   Úbilinear)ÚsizeÚmode©Údim)	r   ÚshapeÚreshapeÚpermuter   Ú
functionalÚinterpolater%   Úcat©rQ   Ú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 ¡˜_Ñ-ˆä! +×"3Ñ"3°AÑ"6¸#Ñ"=Ó>ˆà!×)Ñ)¨!¨]¸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Ú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   }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).r7   rY   r]   )r   r    )r_   r?   rH   r=   rm   rP   r>   rE   Úfeature_mapsrI   rL   ÚflattenÚ	transposerO   Úexpandr%   rd   r   )rQ   rn   ro   Ú
batch_sizer?   ÚheightÚwidthrP   Ú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ˆ
ô :Ø)Ø%9ô
ð 	
ùò  rs   Ã)E9©N©r   ©F)r!   r"   r#   r$   r   r(   Úintr<   rm   r%   ÚTensorÚboolr   r�   Ú__classcell__©rU   s   @r+   r3   r3   Y   sY   ø„ ññ e˜yð  e¸¸cÀ3¸h¹È$Ñ8Nõ  eóDð LQñ&
Ø!ŸL™Lð&
ØDHð&
à	3÷&
r*   r3   c                   óN   ‡ — e Zd ZdZˆ fd„Zdd„Zdej                  def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   rM   r%   rN   r@   rO   ÚDPTViTPatchEmbeddingsÚpatch_embeddingsrR   rP   ÚDropoutÚhidden_dropout_probÚdropoutr4   )rQ   r4   rR   rU   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 rW   )	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*   rn   rp   c                 ó�  — |j                   \  }}}}| j                  j                  }| j                  | j                  ||z  ||z  «      }| j                  |«      }|j                  «       \  }}	}
| j                  j                  |dd«      }t        j                  ||fd¬«      }||z   }| j                  |«      }t        |¬«      S )Nr7   r   r]   )r   )r_   r4   r>   rm   rP   rŽ   r[   rO   rw   r%   rd   r‘   r   )rQ   rn   rx   r?   ry   rz   r>   rP   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ƒ   )r!   r"   r#   r$   r<   rm   r%   r†   r   r�   rˆ   r‰   s   @r+   r‹   r‹   ¹   s-   ø„ ñô
óðY E§L¡Lð YÐ5_÷ Yr*   r‹   c                   ó`   ‡ — e Zd ZdZdefˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )r�   z$
    Image to Patch Embedding.

    r4   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   )r:   Ústride)r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rR   r   rK   rL   )rQ   r4   r=   r>   r?   r@   rR   rU   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*   rn   rp   c                 ó¼   — |j                   \  }}}}|| j                  k7  rt        d«      ‚| j                  |«      j	                  d«      j                  dd«      }|S )Nrr   rY   r   )r_   r?   rH   rL   ru   rv   )rQ   rn   rx   r?   ry   rz   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†   r�   rˆ   r‰   s   @r+   r�   r�   ð   s1   ø„ ñð
j˜yõ jð E§L¡Lð °U·\±\÷ r*   r�   ÚmoduleÚqueryÚkeyÚvalueÚattention_maskÚscalingr‘   Úkwargsc                 óœ  — |€|j                  d«      dz  }t        j                  ||j                  dd«      «      |z  }|�||z   }t        j
                  j                  |d¬«      }t        j
                  j                  ||| j                  ¬«      }t        j                  ||«      }	|	j                  dd«      j                  «       }	|	|fS )Nr7   ç      à¿rY   r   r]   )ÚpÚtrainingr   )
r[   r%   Úmatmulrv   r   rb   Úsoftmaxr‘   r¥   Ú
contiguous)
r›   rœ   r�   rž   rŸ   r    r‘   r¡   Úattn_weightsÚattn_outputs
             r+   Úeager_attention_forwardr«     s»   € ð €Ø—*‘*˜R“. DÑ(ˆô —<‘<  s§}¡}°Q¸Ó':Ó;¸gÑE€LàÐ!Ø# nÑ4ˆä—=‘=×(Ñ(¨¸2Ð(Ó>€LÜ—=‘=×(Ñ(¨¸È6Ï?É?Ð(Ó[€Lä—,‘,˜|¨UÓ3€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€Kà˜Ð$Ð$r*   c                   ó„   ‡ — e Zd Zdefˆ fd„Zdej                  dee   de	ej                  ej                  f   fd„Z
ˆ xZS )ÚDPTSelfAttentionr4   c                 ó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 ú.r£   F)Úbias)r;   r<   r@   Únum_attention_headsÚhasattrrH   r4   r…   Úattention_head_sizeÚall_head_sizeÚattention_probs_dropout_probÚdropout_probr    Ú	is_causalr   ÚLinearÚqkv_biasrœ   r�   rž   ©rQ   r4   rU   s     €r+   r<   zDPTSelfAttention.__init__.  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*   r0   r¡   rp   c                 ó°  — |j                   d   }|d| j                  | j                  f} | j                  |«      j                  |Ž j                  dd«      } | j                  |«      j                  |Ž j                  dd«      } | j                  |«      j                  |Ž j                  dd«      }t        j                  | j                  j                  t        «      } || |||d f| j                  | j                  | j                  sdn| j                   dœ|¤Ž\  }	}
|	j#                  «       d d | j$                  fz   }|	j'                  |«      }	|	|
fS )Nr   r7   r   rY   ç        )r¸   r    r‘   r8   )r_   r²   r´   r�   Úviewrv   rž   rœ   r   Úget_interfacer4   Ú_attn_implementationr«   r¸   r    r¥   r·   r[   rµ   r`   )rQ   r0   r¡   rx   Ú	new_shapeÚ	key_layerÚvalue_layerÚquery_layerÚattention_interfaceÚcontext_layerÚattention_probsÚnew_context_layer_shapes               r+   r�   zDPTSelfAttention.forwardB  sY  € ð
 #×(Ñ(¨Ñ+ˆ
Ø  D×$<Ñ$<¸d×>VÑ>VÐVˆ	à0�D—H‘H˜]Ó+×0Ñ0°)Ð<×FÑFÀqÈ!ÓLˆ	Ø4�d—j‘j Ó/×4Ñ4°iÐ@×JÑJÈ1ÈaÓPˆØ4�d—j‘j Ó/×4Ñ4°iÐ@×JÑJÈ1ÈaÓPˆä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ *=ØØØØØð
*
ð —n‘nØ—L‘LØ#Ÿ}š}‘C°$×2CÑ2Cñ
*
ð ñ
*
Ñ&ˆ�ð #0×"4Ñ"4Ó"6°s¸Ð";¸t×?QÑ?QÐ>SÑ"SÐØ%×-Ñ-Ð.EÓFˆà˜oÐ-Ð-r*   )r!   r"   r#   r   r<   r%   r†   r   r   r(   r�   rˆ   r‰   s   @r+   r­   r­   -  sN   ø„ ð]˜yõ ]ð(.à—|‘|ð.ð Ð+Ñ,ð.ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷	.r*   r­   c                   óx   ‡ — e Zd ZdZdefˆ fd„Zdej                  dej                  dej                  fd„Zˆ xZ	S )ÚDPTViTSelfOutputz 
    The residual connection is defined in ViTLayer instead of here (as is the case with other models), due to the
    layernorm applied before each block.
    r4   c                 óÈ   •— 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__k  sB   ø€ Ü‰ÑÔÜ—Y‘Y˜v×1Ñ1°6×3EÑ3EÓFˆŒ
Ü—z‘z &×"<Ñ"<Ó=ˆ�r*   r0   Úinput_tensorrp   c                 óJ   — | j                  |«      }| j                  |«      }|S r‚   ©rÌ   r‘   ©rQ   r0   rÍ   s      r+   r�   zDPTViTSelfOutput.forwardp  s$   € ØŸ
™
 =Ó1ˆØŸ™ ]Ó3ˆØÐr*   rš   r‰   s   @r+   rÊ   rÊ   e  s=   ø„ ñð
>˜yõ >ð
 U§\¡\ð ÀÇÁð ÐRW×R^ÑR^÷ r*   rÊ   c                   óf   ‡ — e Zd Zdefˆ fd„Zdej                  dee   dej                  fd„Z	ˆ xZ
S )ÚDPTViTAttentionr4   c                 ób   •— t         ‰| �  «        t        |«      | _        t	        |«      | _        y r‚   )r;   r<   r­   Ú	attentionrÊ   Úoutputr»   s     €r+   r<   zDPTViTAttention.__init__x  s&   ø€ Ü‰ÑÔÜ)¨&Ó1ˆŒÜ& vÓ.ˆ�r*   r0   r¡   rp   c                 óV   —  | j                   |fi |¤Ž\  }}| j                  ||«      }|S r‚   )rÔ   rÕ   )rQ   r0   r¡   Úself_attn_outputr•   rÕ   s         r+   r�   zDPTViTAttention.forward}  s5   € ð
 -˜dŸn™n¨]ÑE¸fÑEÑÐ˜!Ø—‘Ð-¨}Ó=ˆØˆr*   )r!   r"   r#   r   r<   r%   r†   r   r   r�   rˆ   r‰   s   @r+   rÒ   rÒ   w  s>   ø„ ð/˜yõ /ð
à—|‘|ðð Ð+Ñ,ðð 
�‰÷	r*   rÒ   c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚDPTViTIntermediater4   c                 ó  •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        |j                  t        «      rt        |j                     | _        y |j                  | _        y r‚   )r;   r<   r   r¹   r@   Úintermediate_sizerÌ   rA   Ú
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*   r0   rp   c                 óJ   — | j                  |«      }| j                  |«      }|S r‚   )rÌ   rÞ   )rQ   r0   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Ù   ˆ  s*   ø„ ð9˜yõ 9ð U§\¡\ð °e·l±l÷ r*   rÙ   c                   ót   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  dej                  fd„Zˆ xZS )ÚDPTViTOutputr4   c                 óÈ   •— 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*   r0   rÍ   rp   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â   ˜  s8   ø„ ð>˜yõ >ð
 U§\¡\ð ÀÇÁð ÐRW×R^ÑR^÷ r*   râ   c                   ój   ‡ — e Zd ZdZdefˆ fd„Zdej                  dee	   dej                  fd„Z
ˆ xZS )ÚDPTViTLayerz?This corresponds to the Block class in the timm implementation.r4   c                 ó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*   r0   r¡   rp   c                 óÀ   — | j                  |«      } | j                  |fi |¤Ž}||z   }| j                  |«      }| j                  |«      }| j	                  ||«      }|S r‚   )rï   rÔ   rð   rì   rÕ   )rQ   r0   r¡   Úhidden_states_normÚattention_outputÚlayer_outputs         r+   r�   zDPTViTLayer.forward³  sr   € ð
 "×2Ñ2°=ÓAÐØ)˜4Ÿ>™>Ð*<ÑGÀÑGÐð )¨=Ñ8ˆð ×+Ñ+¨MÓ:ˆØ×(Ñ(¨Ó6ˆð —{‘{ <°Ó?ˆàÐr*   )r!   r"   r#   r$   r   r<   r%   r†   r   r   r�   rˆ   r‰   s   @r+   ræ   ræ   ¦  sC   ø„ ÙIð[˜yõ [ðà—|‘|ðð Ð+Ñ,ðð 
�‰÷	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<   r4   r   Ú
ModuleListÚlayersÚ	is_hybridÚ_init_reassemble_dpt_hybridÚ_init_reassemble_dptÚneck_ignore_stagesr»   s     €r+   r<   zDPTReassembleStage.__init__Ø  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   ©rF   ÚfactorÚprojectzReadout type z! is not supported for DPT-Hybrid.rY   N)ÚzipÚrangerG   Úneck_hidden_sizesÚreassemble_factorsrù   Úappendr   ÚIdentityÚDPTReassembleLayerÚreadout_typerH   rø   Úreadout_projectsÚ_get_backbone_hidden_sizeÚ
Sequentialr¹   r	   rÜ   )rQ   r4   Úir   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  rY   )r  r  rG   r  r  rù   r  r  r	  r   rø   r
  r  r  r¹   r	   rÜ   )rQ   r4   r  r   r@   r•   s         r+   rü   z'DPTReassembleStage._init_reassemble_dptþ  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*   r0   rp   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   rX   r   rY   r  )r   rY   r   r7   Úadd)Ú	enumeraterý   r_   r`   r   ra   r¨   r4   r	  ru   Ú	unsqueezeÚ	expand_asr
  r%   rd   rù   r  )rQ   r0   Úpatch_heightÚpatch_widthÚoutr  Úhidden_staterO   rx   Ú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ü   Úlistr%   r†   r�   rˆ   r‰   s   @r+   rö   rö   È  s@   ø„ ñô
<òò4
ñ# T¨%¯,©,Ñ%7ð #ÐaeÐfk×frÑfrÑas÷ #r*   rö   c                 óŠ   — | j                   �,t        | j                   d«      r| j                   j                  S | j                  S )Nr@   )Úbackbone_configr³   r@   )r4   s    r+   r  r  0  s;   € Ø×ÑÐ)¬g°f×6LÑ6LÈmÔ.\Ø×%Ñ%×1Ñ1Ð1à×!Ñ!Ð!r*   c                   ó2   ‡ — e Zd Zdededefˆ fd„Zd„ Zˆ xZS )r  r4   rF   r   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_channelsr:   r   ©r:   r˜   Úpaddingr   )
r;   r<   r  r   rK   rL   ÚConvTranspose2dÚresizer  r…   )rQ   r4   rF   r   r@   rU   s        €r+   r<   zDPTReassembleLayer.__init__8  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‚   )rL   r&  )rQ   r  s     r+   r�   zDPTReassembleLayer.forwardG  s$   € Ø—‘ |Ó4ˆØ—{‘{ <Ó0ˆØÐr*   )r!   r"   r#   r   r…   r<   r�   rˆ   r‰   s   @r+   r  r  7  s&   ø„ ðj˜yð j°Cð jÀõ jör*   r  c                   ó*   ‡ — e Zd Zdefˆ fd„Zd„ Zˆ xZS )ÚDPTFeatureFusionStager4   c                 óâ   •— t         ‰| �  «        t        j                  «       | _        t        t        |j                  «      «      D ]&  }| j                  j                  t        |«      «       Œ( y r‚   )
r;   r<   r   rø   rù   r  rG   r  r  ÚDPTFeatureFusionLayer©rQ   r4   r•   rU   s      €r+   r<   zDPTFeatureFusionStage.__init__N  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 )Nr7   )r  rù   r  )rQ   r0   Úfused_hidden_statesÚfused_hidden_stater  Úlayers         r+   r�   zDPTFeatureFusionStage.forwardT  sq   € à%¡d¨ dÑ+ˆà ÐØ!ÐÜ#& }°d·k±kÓ#Bò 	;ÑˆL˜%Ø!Ð)á%*¨<Ó%8Ñ"á%*Ð+=¸|Ó%LÐ"Ø×&Ñ&Ð'9Õ:ð	;ð #Ð"r*   )r!   r"   r#   r   r<   r�   rˆ   r‰   s   @r+   r)  r)  M  s   ø„ ð>˜yõ >ö#r*   r)  c                   ó`   ‡ — e Zd ZdZdefˆ 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.
    r4   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   )r:   r˜   r$  r±   )r;   r<   Ú!use_batch_norm_in_fusion_residualÚuse_batch_normÚuse_bias_in_fusion_residualr   ÚReLUÚactivation1rK   Úfusion_hidden_sizeÚconvolution1Úactivation2Úconvolution2ÚBatchNorm2dÚbatch_norm1Úbatch_norm2)rQ   r4   r6  rU   s      €r+   r<   zDPTPreActResidualLayer.__init__n  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  rp   c                 ó  — |}| j                  |«      }| j                  |«      }| j                  r| j                  |«      }| j	                  |«      }| j                  |«      }| j                  r| j                  |«      }||z   S r‚   )r8  r:  r5  r>  r;  r<  r?  ©rQ   r  Úresiduals      r+   r�   zDPTPreActResidualLayer.forward�  s„   € ØˆØ×'Ñ'¨Ó5ˆà×(Ñ(¨Ó6ˆà×ÒØ×+Ñ+¨LÓ9ˆLà×'Ñ'¨Ó5ˆØ×(Ñ(¨Ó6ˆà×ÒØ×+Ñ+¨LÓ9ˆLà˜hÑ&Ð&r*   rš   r‰   s   @r+   r2  r2  e  s2   ø„ ñð I˜yõ  IðD' E§L¡Lð '°U·\±\÷ 'r*   r2  c                   ó†   ‡ — e Zd ZdZd
dedefˆ fd„Zddej                  dej                  dz  dej                  fd	„Z	ˆ xZ
S )r+  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.
    r4   Úalign_cornersc                 óÔ   •— t         ‰| �  «        || _        t        j                  |j
                  |j
                  dd¬«      | _        t        |«      | _        t        |«      | _	        y )Nr   T)r:   r±   )
r;   r<   rD  r   rK   r9  rL   r2  Úresidual_layer1Úresidual_layer2)rQ   r4   rD  rU   s      €r+   r<   zDPTFeatureFusionLayer.__init__¬  sT   ø€ Ü‰ÑÔà*ˆÔäŸ)™) F×$=Ñ$=¸v×?XÑ?XÐfgÐnrÔsˆŒä5°fÓ=ˆÔÜ5°fÓ=ˆÕr*   Nr  rB  rp   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 )NrY   r   rZ   F©r[   r\   rD  ©Úscale_factorr\   rD  )r_   r   rb   rc   rF  rG  rD  rL   rA  s      r+   r�   zDPTFeatureFusionLayer.forward¶  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"   r#   r$   r   r‡   r<   r%   r†   r�   rˆ   r‰   s   @r+   r+  r+  ¢  sI   ø„ ññ>˜yð >¸õ >ñ E§L¡Lð ¸E¿L¹LÈ4Ñ<Oð Ð[`×[gÑ[g÷ r*   r+  c                   ó|   ‡ — e Zd ZU eed<   dZdZdZdZdZ	dZ
dZdZeedœZ ej"                  «       ˆ fd„«       Zˆ xZS )ÚDPTPreTrainedModelr4   Údptrn   )ÚimageT)r0   r1   c                 óÎ   •— t         ‰| �  |«       t        |t        t        f«      r?t        j                  |j                  «       t        j                  |j                  «       yy)zInitialize the weightsN)	r;   Ú_init_weightsrA   r‹   r3   ÚinitÚzeros_rO   rP   )rQ   r›   rU   s     €r+   rR  z DPTPreTrainedModel._init_weights×  sM   ø€ ô 	‰Ñ˜fÔ%Ü�fÔ/Ô1GÐHÔIÜ�K‰K˜×(Ñ(Ô)Ü�K‰K˜×2Ñ2Õ3ð Jr*   )r!   r"   r#   r   r'   Úbase_model_prefixÚmain_input_nameÚinput_modalitiesÚsupports_gradient_checkpointingÚ_supports_sdpaÚ_supports_flash_attnÚ_supports_flex_attnÚ_supports_attention_backendræ   r­   Ú_can_record_outputsr%   Úno_gradrR  rˆ   r‰   s   @r+   rN  rN  Ç  sa   ø… àÓØÐØ$€OØ!ÐØ&*Ð#Ø€NØÐØÐØ"&Ðà$Ø&ñÐð
 €U‡]�]ƒ_ó4ó ô4r*   rN  c            	       óZ   ‡ — e Zd Zdefˆ fd„Z	 ddej                  dedee	   de
fd„Zˆ xZS )	ÚDPTViTEncoderr4   c                 óÂ   •— t         ‰| �  «        || _        t        j                  t        |j                  «      D �cg c]  }t        |«      ‘Œ c}«      | _        y c c}w r‚   )	r;   r<   r4   r   rø   r  Únum_hidden_layersræ   r0  r,  s      €r+   r<   zDPTViTEncoder.__init__á  sC   ø€ Ü‰ÑÔØˆŒÜ—]‘]ÄÀv×G_ÑG_ÓA`Ö#a¸A¤K°Õ$7Ò#aÓbˆ�
ùÒ#as   ½Ar0   r~   r¡   rp   c                 óL   — | j                   D ]
  } ||«      }Œ t        |¬«      S )N)r.   )r0  r   )rQ   r0   r~   r¡   Úlayer_modules        r+   r�   zDPTViTEncoder.forwardæ  s.   € ð !ŸJ™Jò 	8ˆLÙ(¨Ó7‰Mð	8ô °Ô?Ð?r*   r„   )r!   r"   r#   r   r<   r%   r†   r‡   r   r   r   r�   rˆ   r‰   s   @r+   r`  r`  à  sL   ø„ ðc˜yõ cð INñ@Ø"Ÿ\™\ð@ØAEð@ØY_Ð`rÑYsð@à	÷@r*   r`  c            	       óŠ   ‡ — e Zd Zddedefˆ fd„Zd„ Ze ed¬«      e	de
j                  dee   d	efd
„«       «       «       Zˆ xZS )ÚDPTModelr4   Úadd_pooling_layerc                 óT  •— t         ‰| �  |«       || _        |j                  rt	        |«      | _        nt        |«      | _        t        |«      | _        t        j                  |j                  |j                  ¬«      | _        |rt        |«      nd| _        | j!                  «        y)zv
        add_pooling_layer (bool, *optional*, defaults to `True`):
            Whether to add a pooling layer
        rè   N)r;   r<   r4   rú   r3   r   r‹   r`  Úencoderr   rí   r@   rî   Ú	layernormÚDPTViTPoolerÚpoolerÚ	post_init)rQ   r4   rg  rU   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‚   )r4   rú   r   rŽ   )rQ   s    r+   Úget_input_embeddingszDPTModel.get_input_embeddings  s)   € Ø�;‰;× Ò Ø—?‘?Ð"à—?‘?×3Ñ3Ð3r*   F)Útie_last_hidden_statesrn   r¡   rp   c                 ó
  — | j                  |«      }|j                  } | j                  |fi |¤Ž}|j                  }| j	                  |«      }| j
                  �| j                  |«      nd }t        |||j                  ¬«      S )N)r.   r/   r    )r   r   ri  r.   rj  rl  r-   r    )rQ   rn   r¡   Úembedding_outputÚembedding_last_hidden_statesÚencoder_outputsÚsequence_outputÚpooled_outputs           r+   r�   zDPTModel.forward  sˆ   € ð HLÇÁÐWcÓGdÐØ'7×'JÑ'JÐ$à+7¨4¯<©<Ð8TÑ+_ÐX^Ñ+_ˆØ)×;Ñ;ˆàŸ.™.¨Ó9ˆØ8<¿¹Ð8O˜Ÿ™ OÔ4ÐUYˆäCØ-Ø'Ø%5×%NÑ%Nô
ð 	
r*   rL  )r!   r"   r#   r   r‡   r<   ro  r   r   r   r%   r&   r   r   r-   r�   rˆ   r‰   s   @r+   rf  rf  ï  sl   ø„ ñ˜yð ¸Tõ ò*4ð  Ù¨EÔ2Øð
à×'Ñ'ð
ð Ð+Ñ,ð
ð 
>ò	
ó ó 3ó  ô
r*   rf  c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )rk  r4   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*   r0   rp   c                 ó\   — |d d …df   }| j                  |«      }| j                  |«      }|S )Nr   )rÌ   r{  )rQ   r0   Úfirst_token_tensorrv  s       r+   r�   zDPTViTPooler.forward+  s6   € ð +ª1¨a¨4Ñ0ÐØŸ
™
Ð#5Ó6ˆØŸ™¨Ó6ˆØÐr*   rà   r‰   s   @r+   rk  rk  %  s*   ø„ ð4˜yõ 4ð
 U§\¡\ð °e·l±l÷ r*   rk  c            
       ó†   ‡ — e Zd ZdZdefˆ fd„Z	 	 d
deej                     de	dz  de	dz  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.
    r4   c           
      ó˜  •— t         ‰| �  «        || _        |j                  �!|j                  j                  dk(  rd | _        nt        |«      | _        t        j                  «       | _	        |j                  D ]?  }| j                  j                  t        j                  ||j                  ddd¬«      «       ŒA t        |«      | _        y )NÚswinv2r   r   F©r:   r$  r±   )r;   r<   r4   r  Ú
model_typeÚreassemble_stagerö   r   rø   Úconvsr  r  rK   r9  r)  Úfusion_stage)rQ   r4   ÚchannelrU   s      €r+   r<   zDPTNeck.__init__@  s«   ø€ Ü‰ÑÔØˆŒð ×!Ñ!Ð-°&×2HÑ2H×2SÑ2SÐW_Ò2_Ø$(ˆDÕ!ä$6°vÓ$>ˆDÔ!ä—]‘]“_ˆŒ
Ø×/Ñ/ò 	sˆGØ�J‰J×ÑœbŸi™i¨°×1JÑ1JÐXYÐcdÐkpÔqÕrð	sô 2°&Ó9ˆÕr*   Nr0   r  r  rp   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.)rA   r(   r  Ú	TypeErrorrG   r4   r  rH   r„  r  r…  r†  )rQ   r0   r  r  r  Úfeaturer|   rÕ   s           r+   r�   zDPTNeck.forwardQ  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:r  )r!   r"   r#   r$   r   r<   r  r%   r†   r…   r�   rˆ   r‰   s   @r+   r  r  4  sa   ø„ ñ	ð:˜yõ :ð( $(Ø"&ñ	à˜EŸL™LÑ)ðð ˜D‘jðð ˜4‘Zð	ð
 
ˆe�l‰lÑ	÷r*   r  c                   óf   ‡ — e Zd ZdZdefˆ 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).
    r4   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   r#  rY   r   r   rZ   TrJ  é    r   )r;   r<   r4   rL   Úadd_projectionr   rK   r9  r  ÚUpsampler7  Úhead©rQ   r4   r|   rU   s      €r+   r<   zDPTDepthEstimationHead.__init__u  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*   r0   rp   c                 óì   — || j                   j                     }| j                  �+| j                  |«      } t        j                  «       |«      }| j                  |«      }|j                  d¬«      }|S )Nr   r]   )r4   Úhead_in_indexrL   r   r7  r’  Úsqueeze)rQ   r0   Ú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"   r#   r$   r   r<   r  r%   r†   r�   rˆ   r‰   s   @r+   rŒ  rŒ  n  s4   ø„ ñð
˜yõ 
ð& 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	 ddej                  dej                  dz  de	e
   defd„«       «       Zˆ xZS )	ÚDPTForDepthEstimationc                 ó  •— t         ‰| �  |«       d | _        |j                  du r|j                  �t        |«      | _        nt        |d¬«      | _        t        |«      | _	        t        |«      | _        | j                  «        y ©NF)rg  )r;   r<   rE   rú   r  r
   rf  rO  r  ÚneckrŒ  r’  rm  r»   s     €r+   r<   zDPTForDepthEstimation.__init__œ  sq   ø€ Ü‰Ñ˜Ô àˆŒØ×Ñ˜uÑ$¨×)?Ñ)?Ð)KÜ)¨&Ó1ˆD�Mä ¸%Ô@ˆDŒHô ˜F“OˆŒ	ô +¨6Ó2ˆŒ	ð 	�‰Õr*   Nrn   Úlabelsr¡   rp   c                 ó°  ‡ — d}|�t        d«      ‚|j                  d«      xs t        ‰ j                  dd«      }d|d<   ‰ j                  �* ‰ j                  j
                  |fi |¤Ž}|j                  }n£ ‰ j                  |fi |¤Ž}|j                  }‰ j                  j                  s:t        |dd «      D ��	cg c]   \  }}	|‰ j                  j                  v sŒ|	‘Œ" }}}	n4|j                  }
|
j                  ˆ fd„t        |dd «      D «       «       |
}d\  }}‰ j                  j                  �S‰ j                  j                  du r;|j                  \  }}}}‰ j                  j                  j                   }||z  }||z  }‰ j#                  |||«      }‰ j%                  |«      }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.

        Examples:
        ```python
        >>> from transformers import AutoImageProcessor, DPTForDepthEstimation
        >>> import torch
        >>> import numpy as np
        >>> 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("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 yetr~   FTr   c              3   ó^   •K  — | ]$  \  }}|‰j                   j                  d d v r|–— Œ& y­w©rY   N©r4   Úbackbone_out_indices©Ú.0ÚidxrŠ  rQ   s      €r+   ú	<genexpr>z0DPTForDepthEstimation.forward.<locals>.<genexpr>õ  s6   øè ø€ ò .á$˜˜WØ˜dŸk™k×>Ñ>¸q¸rÐBÑBô ñ.ùs   ƒ*-r  )Úlossr—  r0   r1   )ÚNotImplementedErrorÚgetÚgetattrr4   rE   Úforward_with_filtered_kwargsrt   rO  r0   rú   r  r¢  r    Úextendr  r_   r>   rœ  r’  r   r1   )rQ   rn   r�  r¡   r§  Úuser_requested_hidden_statesÚoutputsr0   r¥  rŠ  Úbackbone_hidden_statesr  r  r•   ry   rz   r>   r—  s   `                 r+   r�   zDPTForDepthEstimation.forward®  sè  ø€ ð\ ˆØÐÜ%Ð&GÓHÐHð (.§z¡zÐ2HÓ'Iò (
ÌWØ�K‰KÐ/°óN
Ð$ð *.ˆÐ%Ñ&à�=‰=Ð$Ø@�d—m‘m×@Ñ@ÀÑXÐQWÑXˆGØ#×0Ñ0‰Mà�d—h‘h˜|Ñ6¨vÑ6ˆGØ#×1Ñ1ˆMð —;‘;×(Ò(ä09¸-ÈÈÐ:KÓ0L÷!Ù ,  WÐPSÐW[×WbÑWb×WwÑWwÒPw’Gð!�ò !ð *1×)IÑ)IÐ&Ø&×-Ñ-ó .ä(1°-ÀÀÐ2CÓ(Dô.ô ð
 !7�à$.Ñ!ˆ�kØ�;‰;×&Ñ&Ð2°t·{±{×7LÑ7LÐPUÑ7UØ".×"4Ñ"4ÑˆAˆq�&˜%ØŸ™×4Ñ4×?Ñ?ˆJØ! ZÑ/ˆLØ :Ñ-ˆKàŸ	™	 -°¸{ÓKˆØŸ)™) MÓ2ˆä#ØØ+Ù3O˜'×/Ò/ÐUYØ×)Ñ)ô	
ð 	
ùó-!s   Â< GÃGr‚   )r!   r"   r#   r<   r   r   r%   r&   Ú
LongTensorr   r   r   r�   rˆ   r‰   s   @r+   r™  r™  –  sl   ø„ ôð$ Øð +/ñ[
à×'Ñ'ð[
ð × Ñ  4Ñ'ð[
ð Ð+Ñ,ð	[
ð
 
ò[
ó ó ô[
r*   r™  c                   ób   ‡ — e Zd Zdefˆ fd„Zdeej                     dej                  fd„Zˆ xZ	S )ÚDPTSemanticSegmentationHeadr4   c                 ó¦  •— 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‚  r9   rY   rZ   TrJ  )r;   r<   r4   r9  r   r  rK   r=  r7  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*   r0   rp   c                 óZ   — || j                   j                     }| j                  |«      }|S r‚   )r4   r•  r’  ©rQ   r0   Úlogitss      r+   r�   z#DPTSemanticSegmentationHead.forward  s)   € à% d§k¡k×&?Ñ&?Ñ@ˆØ—‘˜=Ó)ˆØˆr*   )
r!   r"   r#   r   r<   r  r%   r†   r�   rˆ   r‰   s   @r+   r²  r²    s/   ø„ ð
˜yõ 
ð T¨%¯,©,Ñ%7ð ¸E¿L¹L÷ r*   r²  c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚDPTAuxiliaryHeadr4   c                 ó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š™™™™™¹?r9   )r;   r<   r9  r   r  rK   r=  r7  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*   r0   rp   c                 ó(   — | j                  |«      }|S r‚   )r’  r·  s      r+   r�   zDPTAuxiliaryHead.forward1  s   € Ø—‘˜=Ó)ˆØˆr*   rà   r‰   s   @r+   rº  rº  $  s*   ø„ ð

˜yõ 

ð U§\¡\ð °e·l±l÷ r*   rº  c                   ó�   ‡ — e Zd Zdefˆ fd„Zee	 	 d	dej                  dz  dej                  dz  de
e   defd„«       «       Zˆ xZS )
ÚDPTForSemanticSegmentationr4   c                 óä   •— t         ‰| �  |«       t        |d¬«      | _        t	        |«      | _        t        |«      | _        |j                  rt        |«      nd | _
        | j                  «        y r›  )r;   r<   rf  rO  r  rœ  r²  r’  Úuse_auxiliary_headrº  Úauxiliary_headrm  r»   s     €r+   r<   z#DPTForSemanticSegmentation.__init__8  s^   ø€ Ü‰Ñ˜Ô ä˜F°eÔ<ˆŒô ˜F“OˆŒ	ô 0°Ó7ˆŒ	Ø:@×:SÒ:SÔ.¨vÔ6ÐY]ˆÔð 	�‰Õr*   Nrn   r�  r¡   rp   c                 ó@  ‡ — |�$‰ j                   j                  dk(  rt        d«      ‚|j                  d«      xs t	        ‰ j                   dd«      }d|d<    ‰ j
                  |fi |¤Ž}|j                  }‰ j                   j                  s:t        |dd «      D ��cg c]   \  }}|‰ j                   j                  v sŒ|‘Œ" }}}n4|j                  }	|	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   }t-        ||
|r|j                  nd|j.                  ¬«      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).

        Examples:
        ```python
        >>> from transformers import AutoImageProcessor, DPTForSemanticSegmentation
        >>> 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("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 oner~   FTc              3   ó`   •K  — | ]%  \  }}|‰j                   j                  d d v sŒ"|–— Œ' y­wr   r¡  r£  s      €r+   r¦  z5DPTForSemanticSegmentation.forward.<locals>.<genexpr>|  s7   øè ø€ ò *Ù(˜C ÈCÐSW×S^ÑS^×SsÑSsÐtuÐtvÐSwÒLw”ñ*ùs   ƒ#.§.)r0   r7   r8   rZ   rI  )Úignore_index)r§  r¸  r0   r1   )r4   rµ  rH   r©  rª  rO  r0   rú   r  r¢  r    r¬  rœ  r’  rÁ  r   rb   rc   r_   r   Úsemantic_loss_ignore_indexÚauxiliary_loss_weightr   r1   )rQ   rn   r�  r¡   r­  r®  r0   r¥  rŠ  r¯  r¸  Úauxiliary_logitsr§  Úupsampled_logitsÚupsampled_auxiliary_logitsÚloss_fctÚ	main_lossÚauxiliary_losss   `                 r+   r�   z"DPTForSemanticSegmentation.forwardG  s<  ø€ ð@ Ð $§+¡+×"8Ñ"8¸AÒ"=ÜÐNÓOÐOð (.§z¡zÐ2HÓ'Iò (
ÌWØ�K‰KÐ/°óN
Ð$ð *.ˆÐ%Ñ&àHPÈÏÉÐQ]ÑHhÐagÑHhˆØ×-Ñ-ˆð �{‰{×$Ò$ä,5°mÀAÀBÐ6GÓ,H÷Ù(˜C ÈCÐSW×S^ÑS^×SsÑSsÒLs’ðˆMò ð &-×%EÑ%EÐ"Ø"×)Ñ)ó *Ü,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ä&ØØÙ3O˜'×/Ò/ÐUYØ×)Ñ)ô	
ð 	
ùóEs   Â HÂ>Hr  )r!   r"   r#   r   r<   r   r   r%   r&   r°  r   r   r   r�   rˆ   r‰   s   @r+   r¾  r¾  6  s{   ø„ ð˜yõ ð Øð 26Ø*.ñU
à×'Ñ'¨$Ñ.ðU
ð × Ñ  4Ñ'ðU
ð Ð+Ñ,ð	U
ð
 
!òU
ó ó ôU
r*   r¾  )r™  r¾  rf  rN  )Nr½   )Lr$   Úcollections.abcrB   r   Údataclassesr   r%   r   Útorch.nnr   Ú r   rS  Úactivationsr	   Úbackbone_utilsr
   Úmodeling_layersr   Úmodeling_outputsr   r   r   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   r   r   r   Úutils.genericr   r   Úutils.output_capturingr   Úconfiguration_dptr   Ú
get_loggerr!   Úloggerr   r-   ÚModuler3   r‹   r�   r†   Úfloatr«   r­   rÊ   rÒ   rÙ   râ   ræ   rö   r  r  r)  r2  r+  rN  r`  rf  rk  r  rŒ  r™  r²  rº  r¾  Ú__all__r)   r*   r+   ú<module>rà     s  ðñó Ý $Ý !ã Ý Ý %å &Ý !Ý +Ý 9ß ^Ñ ^ß FÝ &ß XÕ Xß IÝ 5Ý (ð 
ˆ×	Ñ	˜HÓ	%€ñ ðôð ô	J°ó 	Jó óð	Jñ ðôð ôJ¸;ó Jó óðJô$]
˜RŸY™Yô ]
ô@4Y�r—y‘yô 4Yôn˜BŸI™Iô ðL !Øñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð �T‰\ð%ð ð%ð Ð'Ñ(ó%ô:4.�r—y‘yô 4.ôp�r—y‘yô ô$�b—i‘iô ô"˜Ÿ™ô ô 
�2—9‘9ô 
ôÐ,ô ôDe˜Ÿ™ô eòP"ô˜Ÿ™ô ô,#˜BŸI™Iô #ô0:'˜RŸY™Yô :'ôz"˜BŸI™Iô "ðJ ô4˜ó 4ó ð4ô0@�B—I‘Iô @ð ô1
Ð!ó 1
ó ð1
ôj�2—9‘9ô ô7ˆb�i‰iô 7ôt%˜RŸY™Yô %ñP ðôô
p
Ð.ó p
óð
p
ôf "§)¡)ô ô,�r—y‘yô ð$ ôg
Ð!3ó g
ó ðg
òT d�r*   