Ë
    ÛÓ^jpg  ã                   óN  — d Z ddlZddlZddlmZ ddlmZ ddlmZmZ ddl	m
Z
 ddlmZmZ d	d
lmZ  ej                   e«      Z G d„ dej&                  «      Z G d„ dej&                  «      Z G d„ dej&                  «      Z G d„ dej&                  «      Z G d„ dej&                  «      Z G d„ dej&                  «      Z G d„ dej&                  «      Z G d„ dej&                  «      Z G d„ dej&                  «      Ze G d„ de
«      «       Ze G d„ d e«      «       Z G d!„ d"ej&                  «      Z G d#„ d$ej&                  «      Z  G d%„ d&ej&                  «      Z! G d'„ d(ej&                  «      Z" G d)„ d*ej&                  «      Z# ed+¬,«       G d-„ d.e«      «       Z$g d/¢Z%y)0zPyTorch GLPN model.é    N)Únné   )ÚACT2FN)ÚBaseModelOutputÚDepthEstimatorOutput)ÚPreTrainedModel)Úauto_docstringÚloggingé   )Ú
GLPNConfigc                   ó(   ‡ — e Zd ZdZˆ fd„Zd„ Zˆ xZS )ÚGLPNOverlapPatchEmbeddingsz+Construct the overlapping patch embeddings.c                 óš   •— t         ‰| �  «        t        j                  |||||dz  ¬«      | _        t        j
                  |«      | _        y )Né   ©Úkernel_sizeÚstrideÚpadding)ÚsuperÚ__init__r   ÚConv2dÚprojÚ	LayerNormÚ
layer_norm)ÚselfÚ
patch_sizer   Únum_channelsÚhidden_sizeÚ	__class__s        €úq/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/glpn/modeling_glpn.pyr   z#GLPNOverlapPatchEmbeddings.__init__#   sC   ø€ Ü‰ÑÔÜ—I‘IØØØ"ØØ !‘Oô
ˆŒ	ô Ÿ,™, {Ó3ˆ�ó    c                 ó´   — | j                  |«      }|j                  \  }}}}|j                  d«      j                  dd«      }| j	                  |«      }|||fS )Nr   r   )r   ÚshapeÚflattenÚ	transposer   )r   Úpixel_valuesÚ
embeddingsÚ_ÚheightÚwidths         r    Úforwardz"GLPNOverlapPatchEmbeddings.forward/   s^   € Ø—Y‘Y˜|Ó,ˆ
Ø(×.Ñ.Ñˆˆ1ˆf�eð  ×'Ñ'¨Ó*×4Ñ4°Q¸Ó:ˆ
Ø—_‘_ ZÓ0ˆ
Ø˜6 5Ð(Ð(r!   ©Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r+   Ú__classcell__©r   s   @r    r   r       s   ø„ Ù5ô
4ö)r!   r   c                   ó,   ‡ — e Zd ZdZˆ fd„Z	 dd„Zˆ xZS )ÚGLPNEfficientSelfAttentionz£SegFormer's efficient self-attention mechanism. Employs the sequence reduction process introduced in the [PvT
    paper](https://huggingface.co/papers/2102.12122).c                 ó8  •— t         ‰| �  «        || _        || _        | j                  | j                  z  dk7  r&t	        d| j                  › d| j                  › d�«      ‚t        | j                  | j                  z  «      | _        | j                  | j                  z  | _        t        j                  | j                  | j                  «      | _
        t        j                  | j                  | j                  «      | _        t        j                  | j                  | j                  «      | _        t        j                  |j                  «      | _        || _        |dkD  r9t        j"                  ||||¬«      | _        t        j&                  |«      | _        y y )Nr   zThe hidden size (z6) is not a multiple of the number of attention heads (ú)r   )r   r   )r   r   r   Únum_attention_headsÚ
ValueErrorÚintÚattention_head_sizeÚall_head_sizer   ÚLinearÚqueryÚkeyÚvalueÚDropoutÚattention_probs_dropout_probÚdropoutÚsr_ratior   Úsrr   r   ©r   Úconfigr   r7   Úsequence_reduction_ratior   s        €r    r   z#GLPNEfficientSelfAttention.__init__>   sT  ø€ Ü‰ÑÔØ&ˆÔØ#6ˆÔ à×Ñ˜d×6Ñ6Ñ6¸!Ò;ÜØ# D×$4Ñ$4Ð#5ð 6Ø×2Ñ2Ð3°1ð6óð ô
 $' t×'7Ñ'7¸$×:RÑ:RÑ'RÓ#SˆÔ Ø!×5Ñ5¸×8PÑ8PÑPˆÔä—Y‘Y˜t×/Ñ/°×1CÑ1CÓDˆŒ
Ü—9‘9˜T×-Ñ-¨t×/AÑ/AÓBˆŒÜ—Y‘Y˜t×/Ñ/°×1CÑ1CÓDˆŒ
ä—z‘z &×"EÑ"EÓFˆŒà0ˆŒØ# aÒ'Ü—i‘iØ˜[Ð6NÐWoôˆDŒGô !Ÿl™l¨;Ó7ˆD�Oð	 (r!   c                 óœ  — |j                   d d }g |¢d‘| j                  ‘­}| j                  |«      j                  |«      j	                  dd«      }| j
                  dkD  r{|j                   \  }}	}
|j                  ddd«      j                  ||
||«      }| j                  |«      }|j                  ||
d«      j                  ddd«      }| j                  |«      }g |j                   d d ¢d‘| j                  ‘­}| j                  |«      j                  |«      j	                  dd«      }| j                  |«      j                  |«      j	                  dd«      }t        j                  ||j	                  dd«      «      }|t        j                  | j                  «      z  }t         j"                  j%                  |d¬«      }| j'                  |«      }t        j                  ||«      }|j                  dddd«      j)                  «       }|j+                  «       d d | j,                  fz   }|j                  |«      }|r||f}|S |f}|S )Néÿÿÿÿr   r   r   éþÿÿÿ©Údimr   )r#   r:   r=   Úviewr%   rC   ÚpermuteÚreshaperD   r   r>   r?   ÚtorchÚmatmulÚmathÚsqrtr   Ú
functionalÚsoftmaxrB   Ú
contiguousÚsizer;   )r   Úhidden_statesr)   r*   Úoutput_attentionsÚinput_shapeÚhidden_shapeÚquery_layerÚ
batch_sizeÚseq_lenr   Úkv_shapeÚ	key_layerÚvalue_layerÚattention_scoresÚattention_probsÚcontext_layerÚnew_context_layer_shapeÚoutputss                      r    r+   z"GLPNEfficientSelfAttention.forwardY   s=  € ð $×)Ñ)¨#¨2Ð.ˆØC˜ÐC bÐC¨$×*BÑ*BÑCˆØ—j‘j Ó/×4Ñ4°\ÓB×LÑLÈQÐPQÓRˆà�=‰=˜1ÒØ0=×0CÑ0CÑ-ˆJ˜ à)×1Ñ1°!°Q¸Ó:×BÑBÀ:È|Ð]cÐejÓkˆMà ŸG™G MÓ2ˆMà)×1Ñ1°*¸lÈBÓO×WÑWÐXYÐ[\Ð^_Ó`ˆMØ ŸO™O¨MÓ:ˆMàL�]×(Ñ(¨¨"Ð-ÐL¨rÐL°4×3KÑ3KÑLˆØ—H‘H˜]Ó+×0Ñ0°Ó:×DÑDÀQÈÓJˆ	Ø—j‘j Ó/×4Ñ4°XÓ>×HÑHÈÈAÓNˆô !Ÿ<™<¨°Y×5HÑ5HÈÈRÓ5PÓQÐà+¬d¯i©i¸×8PÑ8PÓ.QÑQÐô Ÿ-™-×/Ñ/Ð0@ÀbÐ/ÓIˆð Ÿ,™, Ó7ˆäŸ™ _°kÓBˆà%×-Ñ-¨a°°A°qÓ9×DÑDÓFˆØ"/×"4Ñ"4Ó"6°s¸Ð";¸t×?QÑ?QÐ>SÑ"SÐØ%×*Ñ*Ð+BÓCˆá6G�= /Ð2ˆàˆð O\ÐM]ˆàˆr!   ©Fr,   r2   s   @r    r4   r4   :   s   ø„ ñ9ô8ð@  ÷-r!   r4   c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )ÚGLPNSelfOutputc                 ó    •— t         ‰| �  «        t        j                  ||«      | _        t        j
                  |j                  «      | _        y ©N)r   r   r   r<   Údenser@   Úhidden_dropout_probrB   )r   rF   r   r   s      €r    r   zGLPNSelfOutput.__init__‹   s6   ø€ Ü‰ÑÔÜ—Y‘Y˜{¨KÓ8ˆŒ
Ü—z‘z &×"<Ñ"<Ó=ˆ�r!   c                 óJ   — | j                  |«      }| j                  |«      }|S rk   )rl   rB   )r   rX   Úinput_tensors      r    r+   zGLPNSelfOutput.forward�   s$   € ØŸ
™
 =Ó1ˆØŸ™ ]Ó3ˆØÐr!   ©r-   r.   r/   r   r+   r1   r2   s   @r    ri   ri   Š   s   ø„ ô>ö
r!   ri   c                   ó&   ‡ — e Zd Zˆ fd„Zdd„Zˆ xZS )ÚGLPNAttentionc                 ón   •— t         ‰| �  «        t        ||||¬«      | _        t	        ||¬«      | _        y )N)rF   r   r7   rG   )r   )r   r   r4   r   ri   ÚoutputrE   s        €r    r   zGLPNAttention.__init__˜   s6   ø€ Ü‰ÑÔÜ.ØØ#Ø 3Ø%=ô	
ˆŒ	ô % V¸ÔEˆ�r!   c                 ój   — | j                  ||||«      }| j                  |d   |«      }|f|dd  z   }|S )Nr   r   )r   rt   )r   rX   r)   r*   rY   Úself_outputsÚattention_outputrf   s           r    r+   zGLPNAttention.forward¢   sE   € Ø—y‘y °¸Ð?PÓQˆàŸ;™; |°A¡¸ÓFÐØ#Ð%¨°Q°RÐ(8Ñ8ˆØˆr!   rg   rp   r2   s   @r    rr   rr   —   s   ø„ ôF÷r!   rr   c                   ó*   ‡ — e Zd ZdZdˆ fd„	Zd„ Zˆ xZS )ÚGLPNDepthWiseConvzVDepthwise convolution used in the Mix-FFN to implicitly encode positional information.c                 ób   •— t         ‰| �  «        t        j                  ||ddd|¬«      | _        y )Nr   r   )Úgroups)r   r   r   r   Údwconv)r   rL   r   s     €r    r   zGLPNDepthWiseConv.__init__®   s(   ø€ Ü‰ÑÔÜ—i‘i  S¨!¨Q°¸#Ô>ˆ�r!   c                 óÒ   — |j                   \  }}}|j                  dd«      j                  ||||«      }| j                  |«      }|j	                  d«      j                  dd«      }|S )Nr   r   )r#   r%   rM   r|   r$   )r   rX   r)   r*   r]   r^   r   s          r    r+   zGLPNDepthWiseConv.forward²   sj   € Ø,9×,?Ñ,?Ñ)ˆ
�G˜\Ø%×/Ñ/°°1Ó5×:Ñ:¸:À|ÐU[Ð]bÓcˆØŸ™ MÓ2ˆØ%×-Ñ-¨aÓ0×:Ñ:¸1¸aÓ@ˆØÐr!   )i   r,   r2   s   @r    ry   ry   «   s   ø„ Ù`õ?ör!   ry   c                   ó&   ‡ — e Zd Zdˆ fd„	Zd„ Zˆ xZS )Ú
GLPNMixFFNc                 óŠ  •— t         ‰| �  «        |xs |}t        j                  ||«      | _        t        |«      | _        t        |j                  t        «      rt        |j                     | _        n|j                  | _        t        j                  ||«      | _        t        j                  |j                  «      | _        y rk   )r   r   r   r<   Údense1ry   r|   Ú
isinstanceÚ
hidden_actÚstrr   Úintermediate_act_fnÚdense2r@   rm   rB   )r   rF   Úin_featuresÚhidden_featuresÚout_featuresr   s        €r    r   zGLPNMixFFN.__init__¼   s�   ø€ Ü‰ÑÔØ#Ò2 {ˆÜ—i‘i ¨_Ó=ˆŒÜ'¨Ó8ˆŒÜ�f×'Ñ'¬Ô-Ü'-¨f×.?Ñ.?Ñ'@ˆDÕ$à'-×'8Ñ'8ˆDÔ$Ü—i‘i °Ó>ˆŒÜ—z‘z &×"<Ñ"<Ó=ˆ�r!   c                 óÖ   — | j                  |«      }| j                  |||«      }| j                  |«      }| j                  |«      }| j	                  |«      }| j                  |«      }|S rk   )r�   r|   r…   rB   r†   )r   rX   r)   r*   s       r    r+   zGLPNMixFFN.forwardÈ   sb   € ØŸ™ MÓ2ˆØŸ™ M°6¸5ÓAˆØ×0Ñ0°Ó?ˆØŸ™ ]Ó3ˆØŸ™ MÓ2ˆØŸ™ ]Ó3ˆØÐr!   )NNrp   r2   s   @r    r   r   »   s   ø„ õ
>ör!   r   c                   ór   ‡ — e Zd ZdZd	deddfˆ fd„Zdej                  dej                  fd„Zde	fd„Z
ˆ xZS )
ÚGlpnDropPathzÏStochastic depth (DropPath) per sample, for residual blocks.

    Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
    <https://arxiv.org/abs/1603.09382>`_.
    Ú	drop_probÚreturnNc                 ó0   •— t         ‰| �  «        || _        y rk   )r   r   r�   )r   r�   r   s     €r    r   zGlpnDropPath.__init__Ú   s   ø€ Ü‰ÑÔØ"ˆ�r!   rX   c                 óP  — | j                   dk(  s| j                  s|S d| j                   z
  }|j                  d   fd|j                  dz
  z  z   }t	        j
                  ||j                  |j                  ¬«      }t	        j                  ||z   «      }|j                  |«      |z  S )Nç        r   r   )r   )ÚdtypeÚdevice)
r�   Útrainingr#   ÚndimrP   Úrandr’   r“   ÚfloorÚdiv)r   rX   Ú	keep_probr#   Úrandom_tensors        r    r+   zGlpnDropPath.forwardÞ   s—   € Ø�>‰>˜SÒ ¨¯ªØ Ð Ø˜Ÿ™Ñ&ˆ	Ø×$Ñ$ QÑ'Ð)¨D°M×4FÑ4FÈÑ4JÑ,KÑKˆÜŸ
™
 5°×0CÑ0CÈM×L`ÑL`ÔaˆÜŸ™ M°IÑ$=Ó>ˆØ× Ñ  Ó+¨mÑ;Ð;r!   c                 ó    — d| j                   › �S )Nzp=)r�   )r   s    r    Ú
extra_reprzGlpnDropPath.extra_reprç   s   € Ø�D—N‘NÐ#Ð$Ð$r!   )r‘   )r-   r.   r/   r0   Úfloatr   rP   ÚTensorr+   r„   rœ   r1   r2   s   @r    rŒ   rŒ   Ó   sB   ø„ ññ# %ð #°$õ #ð< U§\¡\ð <°e·l±ló <ð%˜C÷ %r!   rŒ   c                   ó*   ‡ — e Zd ZdZˆ fd„Zdd„Zˆ xZS )Ú	GLPNLayerzCThis corresponds to the Block class in the original implementation.c                 óF  •— t         ‰| �  «        t        j                  |«      | _        t        ||||¬«      | _        |dkD  rt        |«      nt        j                  «       | _	        t        j                  |«      | _
        t        ||z  «      }t        |||¬«      | _        y )N)r   r7   rG   r‘   )r‡   rˆ   )r   r   r   r   Úlayer_norm_1rr   Ú	attentionrŒ   ÚIdentityÚ	drop_pathÚlayer_norm_2r9   r   Úmlp)	r   rF   r   r7   r¥   rG   Ú	mlp_ratioÚmlp_hidden_sizer   s	           €r    r   zGLPNLayer.__init__ï   sƒ   ø€ Ü‰ÑÔÜŸL™L¨Ó5ˆÔÜ&ØØ#Ø 3Ø%=ô	
ˆŒð 5>À²Oœ iÔ0ÌÏÉËˆŒÜŸL™L¨Ó5ˆÔÜ˜k¨IÑ5Ó6ˆÜ˜f°+ÈÔ_ˆ�r!   c                 ó
  — | j                  | j                  |«      |||¬«      }|d   }|dd  }| j                  |«      }||z   }| j                  | j	                  |«      ||«      }| j                  |«      }||z   }	|	f|z   }|S )N)rY   r   r   )r£   r¢   r¥   r§   r¦   )
r   rX   r)   r*   rY   Úself_attention_outputsrw   rf   Ú
mlp_outputÚlayer_outputs
             r    r+   zGLPNLayer.forwardý   sª   € Ø!%§¡Ø×Ñ˜mÓ,ØØØ/ð	 "0ó "
Ðð 2°!Ñ4ÐØ(¨¨Ð,ˆð  Ÿ>™>Ð*:Ó;ÐØ(¨=Ñ8ˆà—X‘X˜d×/Ñ/°Ó>ÀÈÓNˆ
ð —^‘^ JÓ/ˆ
Ø! MÑ1ˆà�/ GÑ+ˆàˆr!   rg   r,   r2   s   @r    r    r    ì   s   ø„ ÙMô`÷r!   r    c                   ó,   ‡ — e Zd Zˆ fd„Z	 	 	 dd„Zˆ xZS )ÚGLPNEncoderc                 ó²  •— t         ‰
| �  «        || _        t        j                  d|j
                  t        |j                  «      d¬«      D �cg c]  }|j                  «       ‘Œ }}g }t        |j                  «      D ]h  }|j                  t        |j                  |   |j                  |   |dk(  r|j                  n|j                   |dz
     |j                   |   ¬«      «       Œj t#        j$                  |«      | _        g }d}t        |j                  «      D ]¹  }g }|dk7  r||j                  |dz
     z  }t        |j                  |   «      D ]\  }	|j                  t)        ||j                   |   |j*                  |   |||	z      |j,                  |   |j.                  |   ¬«      «       Œ^ |j                  t#        j$                  |«      «       Œ» t#        j$                  |«      | _        t#        j$                  t        |j                  «      D �cg c]$  }t#        j2                  |j                   |   «      ‘Œ& c}«      | _        y c c}w c c}w )Nr   Úcpu)r“   r   )r   r   r   r   )r   r7   r¥   rG   r¨   )r   r   rF   rP   ÚlinspaceÚdrop_path_rateÚsumÚdepthsÚitemÚrangeÚnum_encoder_blocksÚappendr   Úpatch_sizesÚstridesr   Úhidden_sizesr   Ú
ModuleListÚpatch_embeddingsr    r7   Ú	sr_ratiosÚ
mlp_ratiosÚblockr   r   )r   rF   ÚxÚdprr'   ÚiÚblocksÚcurÚlayersÚjr   s             €r    r   zGLPNEncoder.__init__  s  ø€ Ü‰ÑÔØˆŒô "'§¡°°6×3HÑ3HÌ#ÈfÏmÉmÓJ\ÐejÔ!kÖl˜Aˆq�v‰v�xÐlˆÐlð ˆ
Ü�v×0Ñ0Ó1ò 	ˆAØ×ÑÜ*Ø%×1Ñ1°!Ñ4Ø!Ÿ>™>¨!Ñ,Ø89¸Qº ×!4Ò!4ÀF×DWÑDWÐXYÐ\]ÑX]ÑD^Ø &× 3Ñ 3°AÑ 6ô	õð	ô !#§¡¨jÓ 9ˆÔð ˆØˆÜ�v×0Ñ0Ó1ò 	1ˆAàˆFØ�AŠvØ�v—}‘} Q¨¡UÑ+Ñ+�Ü˜6Ÿ=™=¨Ñ+Ó,ò 
�Ø—‘ÜØØ$*×$7Ñ$7¸Ñ$:Ø,2×,FÑ,FÀqÑ,IØ"% c¨A¡g¡,Ø17×1AÑ1AÀ!Ñ1DØ"(×"3Ñ"3°AÑ"6ôõ	ð
ð �M‰Mœ"Ÿ-™-¨Ó/Õ0ð!	1ô$ —]‘] 6Ó*ˆŒ
ô Ÿ-™-Ü;@À×AZÑAZÓ;[Ö\°aŒR�\‰\˜&×-Ñ-¨aÑ0Õ1Ò\ó
ˆ�ùòO mùòP ]s   ÁIÈ)Ic                 ó
  — |rdnd }|rdnd }|j                   d   }|}t        t        | j                  | j                  | j
                  «      «      D ]‹  \  }	}
|
\  }}} ||«      \  }}}t        |«      D ]!  \  }} |||||«      }|d   }|sŒ||d   fz   }Œ#  ||«      }|j                  |||d«      j                  dddd«      j                  «       }|sŒ†||fz   }Œ� |st        d„ |||fD «       «      S t        |||¬«      S )	N© r   r   rI   r   r   c              3   ó&   K  — | ]	  }|€Œ|–— Œ y ­wrk   rÊ   )Ú.0Úvs     r    ú	<genexpr>z&GLPNEncoder.forward.<locals>.<genexpr>g  s   è ø€ Òm˜qÐ_`Ñ_lœÑmùs   ‚Š©Úlast_hidden_staterX   Ú
attentions)r#   Ú	enumerateÚzipr¾   rÁ   r   rO   rN   rV   Útupler   )r   r&   rY   Úoutput_hidden_statesÚreturn_dictÚall_hidden_statesÚall_self_attentionsr]   rX   ÚidxrÂ   Úembedding_layerÚblock_layerÚ
norm_layerr)   r*   rÄ   ÚblkÚlayer_outputss                      r    r+   zGLPNEncoder.forwardH  sL  € ñ #7™B¸DÐÙ$5™b¸4Ðà!×'Ñ'¨Ñ*ˆ
à$ˆÜ¤ D×$9Ñ$9¸4¿:¹:ÀtÇÁÓ WÓXò 	I‰FˆC�Ø78Ñ4ˆO˜[¨*á+:¸=Ó+IÑ(ˆM˜6 5ä# KÓ0ò T‘��3Ù # M°6¸5ÐBSÓ T�Ø -¨aÑ 0�Ú$Ø*=ÀÈqÑAQÐ@SÑ*SÑ'ð	Tñ ' }Ó5ˆMà)×1Ñ1°*¸fÀeÈRÓP×XÑXÐYZÐ\]Ð_`ÐbcÓd×oÑoÓqˆMÚ#Ø$5¸Ð8HÑ$HÑ!ð	Iñ" ÜÑm ]Ð4EÐGZÐ$[ÔmÓmÐmÜØ+Ø+Ø*ô
ð 	
r!   )FFTrp   r2   s   @r    r¯   r¯     s   ø„ ô.
ðf  Ø"Ø÷$
r!   r¯   c                   ó(   — e Zd ZU eed<   dZdZdZg Zy)ÚGLPNPreTrainedModelrF   Úglpnr&   )ÚimageN)	r-   r.   r/   r   Ú__annotations__Úbase_model_prefixÚmain_input_nameÚinput_modalitiesÚ_no_split_modulesrÊ   r!   r    rà   rà   o  s   … àÓØÐØ$€OØ!ÐØÑr!   rà   c                   óx   ‡ — e Zd Zˆ fd„Ze	 	 	 d	dej                  dedz  dedz  dedz  dee	z  f
d„«       Z
ˆ xZS )
Ú	GLPNModelc                 ór   •— t         ‰| �  |«       || _        t        |«      | _        | j                  «        y rk   )r   r   rF   r¯   ÚencoderÚ	post_init©r   rF   r   s     €r    r   zGLPNModel.__init__{  s1   ø€ Ü‰Ñ˜Ô ØˆŒô # 6Ó*ˆŒð 	�‰Õr!   Nr&   rY   rÕ   rÖ   rŽ   c                 ó,  — |�|n| j                   j                  }|�|n| j                   j                  }|�|n| j                   j                  }| j	                  ||||¬«      }|d   }|s	|f|dd  z   S t        ||j                  |j                  ¬«      S )N©rY   rÕ   rÖ   r   r   rÏ   )rF   rY   rÕ   rÖ   rë   r   rX   rÑ   )r   r&   rY   rÕ   rÖ   ÚkwargsÚencoder_outputsÚsequence_outputs           r    r+   zGLPNModel.forward…  s·   € ð 2CÐ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆàŸ,™,ØØ/Ø!5Ø#ð	 'ó 
ˆð *¨!Ñ,ˆáØ#Ð%¨¸¸Ð(;Ñ;Ð;äØ-Ø)×7Ñ7Ø&×1Ñ1ô
ð 	
r!   )NNN)r-   r.   r/   r   r	   rP   ÚFloatTensorÚboolrÔ   r   r+   r1   r2   s   @r    ré   ré   x  sn   ø„ ôð ð
 *.Ø,0Ø#'ñ
à×'Ñ'ð
ð   $™;ð
ð # T™kð	
ð
 ˜D‘[ð
ð 
�Ñ	 ò
ó ô
r!   ré   c                   ó*   ‡ — e Zd ZdZdˆ fd„	Zd„ Zˆ xZS )ÚGLPNSelectiveFeatureFusionzû
    Selective Feature Fusion module, as explained in the [paper](https://huggingface.co/papers/2201.07436) (section 3.4). This
    module adaptively selects and integrates local and global features by attaining an attention map for each feature.
    c           	      óV  •— t         ‰| �  «        t        j                  t        j                  t        |dz  «      |ddd¬«      t        j                  |«      t        j                  «       «      | _        t        j                  t        j                  |t        |dz  «      ddd¬«      t        j                  t        |dz  «      «      t        j                  «       «      | _	        t        j                  t        |dz  «      dddd¬«      | _
        t        j                  «       | _        y )Nr   r   r   )Úin_channelsÚout_channelsr   r   r   )r   r   r   Ú
Sequentialr   r9   ÚBatchNorm2dÚReLUÚconvolutional_layer1Úconvolutional_layer2Úconvolutional_layer3ÚSigmoidÚsigmoid)r   Ú
in_channelr   s     €r    r   z#GLPNSelectiveFeatureFusion.__init__­  sÝ   ø€ Ü‰ÑÔä$&§M¡MÜ�I‰I¤# j°1¡nÓ"5ÀJÐ\]ÐfgÐqrÔsÜ�N‰N˜:Ó&Ü�G‰G‹Ió%
ˆÔ!ô %'§M¡MÜ�I‰I *¼3¸zÈA¹~Ó;NÐ\]ÐfgÐqrÔsÜ�N‰Nœ3˜z¨A™~Ó.Ó/Ü�G‰G‹Ió%
ˆÔ!ô %'§I¡IÜ˜J¨™NÓ+¸!ÈÐSTÐ^_ô%
ˆÔ!ô —z‘z“|ˆ�r!   c                 óF  — t        j                  ||fd¬«      }| j                  |«      }| j                  |«      }| j	                  |«      }| j                  |«      }||d d …dd d …d d …f   j                  d«      z  ||d d …dd d …d d …f   j                  d«      z  z   }|S )Nr   rK   r   )rP   Úcatrý   rþ   rÿ   r  Ú	unsqueeze)r   Úlocal_featuresÚglobal_featuresÚfeaturesÚattnÚhybrid_featuress         r    r+   z"GLPNSelectiveFeatureFusion.forwardÂ  s©   € ä—9‘9˜n¨oÐ>ÀAÔFˆà×,Ñ,¨XÓ6ˆØ×,Ñ,¨XÓ6ˆØ×,Ñ,¨XÓ6ˆà�|‰|˜HÓ%ˆà(¨4²°1²aº°
Ñ+;×+EÑ+EÀaÓ+HÑHÈ?Ð]aÚˆq’!’QˆJñ^
ç
‰)�A‹,ñLñ ˆð Ðr!   )é@   r,   r2   s   @r    rö   rö   §  s   ø„ ñõ
$ö*r!   rö   c                   ó&   ‡ — e Zd Zˆ fd„Zdd„Zˆ xZS )ÚGLPNDecoderStagec                 óì   •— t         ‰| �  «        ||k(  }|st        j                  ||d¬«      nt        j                  «       | _        t        |«      | _        t        j                  ddd¬«      | _	        y )Nr   )r   r   ÚbilinearF©Úscale_factorÚmodeÚalign_corners)
r   r   r   r   r¤   Úconvolutionrö   ÚfusionÚUpsampleÚupsample)r   rø   rù   Úshould_skipr   s       €r    r   zGLPNDecoderStage.__init__Ô  s\   ø€ Ü‰ÑÔØ! \Ñ1ˆÙVaœ2Ÿ9™9 [°,ÈAÕNÔgi×grÑgrÓgtˆÔÜ0°Ó>ˆŒÜŸ™°¸ÐSXÔYˆ�r!   c                 ór   — | j                  |«      }|�| j                  ||«      }| j                  |«      }|S rk   )r  r  r  )r   Úhidden_stateÚresiduals      r    r+   zGLPNDecoderStage.forwardÛ  s<   € Ø×'Ñ'¨Ó5ˆØÐØŸ;™; |°XÓ>ˆLØ—}‘} \Ó2ˆàÐr!   rk   rp   r2   s   @r    r  r  Ó  s   ø„ ôZ÷	r!   r  c                   ób   ‡ — e Zd Zˆ fd„Zdeej                     deej                     fd„Zˆ xZS )ÚGLPNDecoderc           	      ó.  •— t         ‰| �  «        |j                  d d d…   }|j                  }t	        j
                  |D �cg c]  }t        ||«      ‘Œ c}«      | _        d | j                  d   _        t	        j                  ddd¬«      | _
        y c c}w )NrI   r   r   r  Fr  )r   r   r¼   Údecoder_hidden_sizer   r½   r  Ústagesr  r  Úfinal_upsample)r   rF   Úreserved_hidden_sizesrù   r   r   s        €r    r   zGLPNDecoder.__init__è  s‚   ø€ Ü‰ÑÔà &× 3Ñ 3±D°b°DÑ 9ÐØ×1Ñ1ˆä—m‘mØLaÖb¸[Ô˜k¨<Õ8Òbó
ˆŒð !%ˆ�‰�A‰Ôä Ÿk™k°q¸zÐY^Ô_ˆÕùò cs   ÁBrX   rŽ   c                 ó²   — g }d }t        |d d d…   | j                  «      D ]  \  }} |||«      }|j                  |«       Œ! | j                  |«      |d<   |S )NrI   )rÓ   r   r¹   r!  )r   rX   Ústage_hidden_statesÚstage_hidden_stater  Ústages         r    r+   zGLPNDecoder.forwardö  sr   € Ø ÐØ!ÐÜ#& }±T°r°TÑ':¸D¿K¹KÓ#Hò 	;ÑˆL˜%Ù!& |Ð5GÓ!HÐØ×&Ñ&Ð'9Õ:ð	;ð #'×"5Ñ"5Ð6HÓ"IÐ˜BÑà"Ð"r!   ©	r-   r.   r/   r   ÚlistrP   rž   r+   r1   r2   s   @r    r  r  ç  s.   ø„ ô`ð	# T¨%¯,©,Ñ%7ð 	#¸DÀÇÁÑ<N÷ 	#r!   r  c                   ó*   ‡ — e Zd ZdZdˆ fd„	Zd„ Zˆ xZS )Ú	SiLogLosszÿ
    Implements the Scale-invariant log scale loss [Eigen et al., 2014](https://huggingface.co/papers/1406.2283).

    $$L=\frac{1}{n} \sum_{i} d_{i}^{2}-\frac{1}{2 n^{2}}\left(\sum_{i} d_{i}^{2}\right)$$ where $d_{i}=\log y_{i}-\log
    y_{i}^{*}$.

    c                 ó0   •— t         ‰| �  «        || _        y rk   )r   r   Úlambd)r   r,  r   s     €r    r   zSiLogLoss.__init__  s   ø€ Ü‰ÑÔØˆ�
r!   c                 ó`  — |dkD  j                  «       }t        j                  ||   «      t        j                  ||   «      z
  }t        j                  t        j                  |d«      j                  «       | j                  t        j                  |j                  «       d«      z  z
  «      }|S )Nr   r   )ÚdetachrP   ÚlogrS   ÚpowÚmeanr,  )r   ÚpredÚtargetÚ
valid_maskÚdiff_logÚlosss         r    r+   zSiLogLoss.forward  s…   € Ø˜q‘j×(Ñ(Ó*ˆ
Ü—9‘9˜V JÑ/Ó0´5·9±9¸TÀ*Ñ=MÓ3NÑNˆÜ�z‰zœ%Ÿ)™) H¨aÓ0×5Ñ5Ó7¸$¿*¹*ÄuÇyÁyÐQY×Q^ÑQ^ÓQ`ÐbcÓGdÑ:dÑdÓeˆàˆr!   )g      à?r,   r2   s   @r    r*  r*    s   ø„ ñõör!   r*  c                   ó\   ‡ — e Zd Zˆ fd„Zdeej                     dej                  fd„Zˆ xZS )ÚGLPNDepthEstimationHeadc                 ó  •— t         ‰| �  «        || _        |j                  }t	        j
                  t	        j                  ||ddd¬«      t	        j                  d¬«      t	        j                  |dddd¬«      «      | _        y )Nr   r   r   F)Úinplace)	r   r   rF   r  r   rú   r   rü   Úhead)r   rF   Úchannelsr   s      €r    r   z GLPNDepthEstimationHead.__init__  sd   ø€ Ü‰ÑÔàˆŒà×-Ñ-ˆÜ—M‘MÜ�I‰I�h °aÀÈ1ÔMÜ�G‰G˜EÔ"Ü�I‰I�h ¨q¸ÀAÔFó
ˆ�	r!   rX   rŽ   c                 óÖ   — || j                   j                     }| j                  |«      }t        j                  |«      | j                   j
                  z  }|j                  d¬«      }|S )Nr   rK   )rF   Úhead_in_indexr;  rP   r  Ú	max_depthÚsqueeze)r   rX   Úpredicted_depths      r    r+   zGLPNDepthEstimationHead.forward$  sZ   € à% d§k¡k×&?Ñ&?Ñ@ˆàŸ	™	 -Ó0ˆäŸ-™-¨Ó6¸¿¹×9NÑ9NÑNˆØ)×1Ñ1°aÐ1Ó8ˆàÐr!   r'  r2   s   @r    r8  r8    s(   ø„ ô

ð	 T¨%¯,©,Ñ%7ð 	¸E¿L¹L÷ 	r!   r8  zg
    GLPN Model transformer with a lightweight depth estimation head on top e.g. for KITTI, NYUv2.
    )Úcustom_introc                   ó²   ‡ — e Zd Zˆ fd„Ze	 	 	 	 d
dej                  dej                  dz  dedz  dedz  dedz  deej                     e
z  fd	„«       Zˆ xZS )ÚGLPNForDepthEstimationc                 ó¤   •— t         ‰| �  |«       t        |«      | _        t	        |«      | _        t        |«      | _        | j                  «        y rk   )	r   r   ré   rá   r  Údecoderr8  r;  rì   rí   s     €r    r   zGLPNForDepthEstimation.__init__6  s@   ø€ Ü‰Ñ˜Ô ä˜fÓ%ˆŒ	Ü" 6Ó*ˆŒÜ+¨FÓ3ˆŒ	ð 	�‰Õr!   Nr&   ÚlabelsrY   rÕ   rÖ   rŽ   c                 ó¼  — |�|n| j                   j                  }|�|n| j                   j                  }| j                  ||d|¬«      }|r|j                  n|d   }| j                  |«      }	| j                  |	«      }
d}|�t        «       } ||
|«      }|s|r
|
f|dd z   }n	|
f|dd z   }|�|f|z   S |S t        ||
|r|j                  nd|j                  ¬«      S )aç  
        labels (`torch.FloatTensor` of shape `(batch_size, height, width)`, *optional*):
            Ground truth depth estimation maps for computing the loss.

        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, GLPNForDepthEstimation
        >>> 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("vinvino02/glpn-kitti")
        >>> model = GLPNForDepthEstimation.from_pretrained("vinvino02/glpn-kitti")

        >>> # 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"))
        ```NTrï   r   r   )r6  rA  rX   rÑ   )
rF   rÖ   rÕ   rá   rX   rF  r;  r*  r   rÑ   )r   r&   rG  rY   rÕ   rÖ   rð   rf   rX   ÚoutrA  r6  Úloss_fctrt   s                 r    r+   zGLPNForDepthEstimation.forward@  s  € ðb &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð —)‘)ØØ/Ø!%Ø#ð	 ó 
ˆñ 2=˜×-Ò-À'È!Á*ˆà�l‰l˜=Ó)ˆØŸ)™) C›.ˆàˆØÐÜ “{ˆHÙ˜O¨VÓ4ˆDáÙ#Ø)Ð+¨g°a°b¨kÑ9‘à)Ð+¨g°a°b¨kÑ9�Ø)-Ð)9�T�G˜fÑ$ÐE¸vÐEä#ØØ+Ù3G˜'×/Ò/ÈTØ×)Ñ)ô	
ð 	
r!   )NNNN)r-   r.   r/   r   r	   rP   ró   rô   rÔ   rž   r   r+   r1   r2   s   @r    rD  rD  0  s˜   ø„ ôð ð ,0Ø)-Ø,0Ø#'ñR
à×'Ñ'ðR
ð ×!Ñ! DÑ(ðR
ð   $™;ð	R
ð
 # T™kðR
ð ˜D‘[ðR
ð 
ˆu�|‰|Ñ	Ð3Ñ	3òR
ó ôR
r!   rD  )rD  r    ré   rà   )&r0   rR   rP   r   Úactivationsr   Úmodeling_outputsr   r   Úmodeling_utilsr   Úutilsr	   r
   Úconfiguration_glpnr   Ú
get_loggerr-   ÚloggerÚModuler   r4   ri   rr   ry   r   rŒ   r    r¯   rà   ré   rö   r  r  r*  r8  rD  Ú__all__rÊ   r!   r    ú<module>rT     sˆ  ðñ ã ã Ý å !ß EÝ -ß ,Ý *ð 
ˆ×	Ñ	˜HÓ	%€ô) §¡ô )ô4L §¡ô Lô`	�R—Y‘Yô 	ô�B—I‘Iô ô(˜Ÿ	™	ô ô �—‘ô ô0%�2—9‘9ô %ô2(�—	‘	ô (ôVU
�"—)‘)ô U
ðp ô˜/ó ó ðð ô+
Ð#ó +
ó ð+
ô\) §¡ô )ôX�r—y‘yô ô(#�"—)‘)ô #ô6�—	‘	ô ô*˜bŸi™iô ñ2 ðôô
^
Ð0ó ^
óð
^
òB V�r!   