
    ^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    II"!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^    YY|,
(..1fe  ''*44Q:
__Z0
65((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 )GLPNEfficientSelfAttentionzSegFormer'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316 
 $'t'7'7$:R:R'R#S !558P8PPYYt//1C1CD
99T--t/A/ABYYt//1C1CD
zz&"E"EF0#a'ii[6NWoDG !ll;7DO	 (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 )Nr   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CbC$*B*BCjj/44\BLLQPQR==10=0C0C-J)11!Q:BB:|]cejkM GGM2M)11*lBOWWXY[\^_`M OOM:ML](("-LrL43K3KLHH]+00:DDQJ	jj/44X>HHAN !<<Y5H5HR5PQ+dii8P8P.QQ --//0@b/I ,,7_kB%--aAq9DDF"/"4"4"6s";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    YY{K8
zz&"<"<=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    yy?PQ;;|AF#%QR(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(    ii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::1a@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{ii_='8f''-'-f.?.?'@D$'-'8'8D$ii>zz&"<"<=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M65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 )
GlpnDropPathzStochastic 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')DM4F4F4J,KK

50C0CML`L`aMI$=>  +m;;r!   c                      d| j                    S )Nzp=)r   )r   s    r    
extra_reprzGlpnDropPath.extra_repr   s    DNN#$$r!   )r   )r-   r.   r/   r0   floatr   rP   Tensorr+   r   r   r1   r2   s   @r    r   r      sB    #% #$ #<U\\ <ell <%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    LL5&# 3%=	
 5>Oi0LL5kI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XXd//>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    "'63H3H#fmmJ\ej!klAqvvxll 
v001 	A*%11!4!>>!,89Q!4!4FDWDWXY\]X]D^ & 3 3A 6		 !#j 9 v001 	1AFAvv}}QU++6==+, 
$*$7$7$:,2,F,Fq,I"%cAg,171A1A!1D"("3"3A"6	
 MM"--/0!	1$ ]]6*
 --;@AZAZ;[\aR\\&--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     mq_`_lms   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    #7BD$5b4!''*
$D$9$94::t WX 	IFC784O[*+:=+I(M65#K0 T3 #M65BS T -a 0$*=qAQ@S*S'	T '}5M)11*feRPXXYZ\]_`bcdooqM#$58H$H!	I" m]4EGZ$[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-TXT_T_TqTq$8$D $++JjJj 	 &1%<k$++BYBY,,/!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#'
''
  $;
 #Tk	

 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    $&MMII#j1n"5J\]fgqrsNN:&GGI%
! %'MMII*3zA~;N\]fgqrsNN3zA~./GGI%
! %'IIJN+!ST^_%
! zz|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    99no>AF,,X6,,X6,,X6||H%(41a
+;+E+Ea+HH?]aq!QJ^

)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Va299[,ANgigrgrgt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 3DbD 911mmLab[k<8b
 !%A kkqzY^_ 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     !#&}TrT':DKK#H 	;L%!&|5G!H&&'9:	; #'"5"56H"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    qj((*
99VJ/0599T*=M3NNzz%))Ha0557$**uyyQYQ^Q^Q`bcGd: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    --MMIIha1MGGE"IIh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    %dkk&?&?@		-0--69N9NN)11a18r!   r'  r2   s   @r    r8  r8    s(    

	T%,,%7 	ELL 	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$++BYBY$8$D $++JjJj 	 ))/!%#	  
 2=--'!*ll=)))C. {HOV4D#)+gabk9)+gabk9)-)9TGf$Ev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

 #Tk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`	RYY 	BII (		   0%299 %2(		 (VU
")) U
p /   +
# +
 +
\) )Xryy (#")) #6		 *bii 2 
^
0 ^

^
B Vr!   