
    rhq              	          d Z ddlZddlmZmZ ddlZddlZddlmZ ddlm	Z	 ddl
mZmZ ddlmZ dd	lmZmZ dd
lmZmZ ddlmZ  ej.                  e      Zd7dej4                  dededej4                  fd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 d0 d1ej<                        Z. ed23       G d4 d5e(             Z/g d6Z0y)8zPyTorch GLPN model.    N)OptionalUnion)nn   )ACT2FN)BaseModelOutputDepthEstimatorOutput)PreTrainedModel) find_pruneable_heads_and_indicesprune_linear_layer)auto_docstringlogging   )
GLPNConfiginput	drop_probtrainingreturnc                    |dk(  s|s| S d|z
  }| j                   d   fd| j                  dz
  z  z   }|t        j                  || j                  | j
                        z   }|j                          | j                  |      |z  }|S )aF  
    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).

    Comment by Ross Wightman: This is the same as the DropConnect impl I created for EfficientNet, etc networks,
    however, the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper...
    See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for changing the
    layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use 'survival rate' as the
    argument.
            r   r   )r   )dtypedevice)shapendimtorchrandr   r   floor_div)r   r   r   	keep_probr   random_tensoroutputs          y/var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/transformers/models/glpn/modeling_glpn.py	drop_pathr#   $   s     CxII[[^

Q 77E

5ELL YYMYYy!M1FM    c                   x     e Zd ZdZd	dee   ddf fdZdej                  dej                  fdZ	de
fdZ xZS )
GLPNDropPathzXDrop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).Nr   r   c                 0    t         |           || _        y N)super__init__r   )selfr   	__class__s     r"   r*   zGLPNDropPath.__init__<   s    "r$   hidden_statesc                 D    t        || j                  | j                        S r(   )r#   r   r   )r+   r-   s     r"   forwardzGLPNDropPath.forward@   s    FFr$   c                      d| j                    S )Nzp=)r   )r+   s    r"   
extra_reprzGLPNDropPath.extra_reprC   s    DNN#$$r$   r(   )__name__
__module____qualname____doc__r   floatr*   r   Tensorr/   strr1   __classcell__r,   s   @r"   r&   r&   9   sG    b#(5/ #T #GU\\ Gell G%C %r$   r&   c                   (     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)r)   r*   r   Conv2dproj	LayerNorm
layer_norm)r+   
patch_sizerA   num_channelshidden_sizer,   s        r"   r*   z#GLPNOverlapPatchEmbeddings.__init__K   sC    II"!O
	 ,,{3r$   c                     | j                  |      }|j                  \  }}}}|j                  d      j                  dd      }| j	                  |      }|||fS )Nr>   r   )rD   r   flatten	transposerF   )r+   pixel_values
embeddings_heightwidths         r"   r/   z"GLPNOverlapPatchEmbeddings.forwardW   s^    YY|,
(..1fe  ''*44Q:
__Z0
65((r$   r2   r3   r4   r5   r*   r/   r9   r:   s   @r"   r<   r<   H   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@   rA   )r)   r*   rI   num_attention_heads
ValueErrorintattention_head_sizeall_head_sizer   LinearquerykeyvalueDropoutattention_probs_dropout_probdropoutsr_ratiorC   srrE   rF   r+   configrI   rW   sequence_reduction_ratior,   s        r"   r*   z#GLPNEfficientSelfAttention.__init__f   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                   \  }}}| j                  |      j                  |d| j                  | j                        j                  dd      }| j                  dkD  r{|j                   \  }}	}
|j                  ddd      j                  ||
||      }| j                  |      }|j                  ||
d      j                  ddd      }| j                  |      }| j                  |      j                  |d| j                  | j                        j                  dd      }| j                  |      j                  |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]   viewrW   rZ   rL   rc   permutereshaperd   rF   r^   r_   r   matmulmathsqrtr   
functionalsoftmaxrb   
contiguoussizer[   )r+   r-   rP   rQ   output_attentions
batch_size
seq_lengthrO   query_layerseq_lenrH   	key_layervalue_layerattention_scoresattention_probscontext_layernew_context_layer_shapeoutputss                     r"   r/   z"GLPNEfficientSelfAttention.forward   s7    %2$7$7!
JJJ}%T*b$":":D<T<TUYq!_ 	 ==10=0C0C-J)11!Q:BB:|]cejkM GGM2M)11*lBOWWXY[\^_`M OOM:M HH]#T*b$":":D<T<TUYq!_ 	 JJ}%T*b$":":D<T<TUYq!_ 	 !<<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$   FrR   r:   s   @r"   rT   rT   b   s    98@  7r$   rT   c                   $     e Zd Z fdZd Z xZS )GLPNSelfOutputc                     t         |           t        j                  ||      | _        t        j
                  |j                        | _        y r(   )r)   r*   r   r\   denser`   hidden_dropout_probrb   )r+   rf   rI   r,   s      r"   r*   zGLPNSelfOutput.__init__   s6    YY{K8
zz&"<"<=r$   c                 J    | j                  |      }| j                  |      }|S r(   )r   rb   )r+   r-   input_tensors      r"   r/   zGLPNSelfOutput.forward   s$    

=1]3r$   r2   r3   r4   r*   r/   r9   r:   s   @r"   r   r      s    >
r$   r   c                   ,     e Zd Z fdZd ZddZ xZS )GLPNAttentionc                     t         |           t        ||||      | _        t	        ||      | _        t               | _        y )N)rf   rI   rW   rg   )rI   )r)   r*   rT   r+   r   r!   setpruned_headsre   s        r"   r*   zGLPNAttention.__init__   s@    .# 3%=	
	 %VEEr$   c                 >   t        |      dk(  ry t        || j                  j                  | j                  j                  | j
                        \  }}t        | j                  j                  |      | j                  _        t        | j                  j                  |      | j                  _        t        | j                  j                  |      | j                  _	        t        | j                  j                  |d      | j                  _        | j                  j                  t        |      z
  | j                  _        | j                  j                  | j                  j                  z  | j                  _        | j
                  j                  |      | _        y )Nr   r   rk   )lenr   r+   rW   rZ   r   r   r]   r^   r_   r!   r   r[   union)r+   headsindexs      r"   prune_headszGLPNAttention.prune_heads   s   u:?749900$))2O2OQUQbQb
u
 -TYY__eD		*499==%@		,TYY__eD		.t{{/@/@%QO )-		(E(EE
(R		%"&))"?"?$))B_B_"_		 --33E:r$   c                 j    | j                  ||||      }| j                  |d   |      }|f|dd  z   }|S )Nr   r   )r+   r!   )r+   r-   rP   rQ   rw   self_outputsattention_outputr   s           r"   r/   zGLPNAttention.forward   sE    yy?PQ;;|AF#%QR(88r$   r   )r2   r3   r4   r*   r   r/   r9   r:   s   @r"   r   r      s    	";$r$   r   c                   &     e Zd Zd fd	Zd Z xZS )
GLPNDWConvc           	      d    t         |           t        j                  ||dddd|      | _        y )Nr   r   T)biasgroups)r)   r*   r   rC   dwconv)r+   rl   r,   s     r"   r*   zGLPNDWConv.__init__   s*    iiS!QSIr$   c                     |j                   \  }}}|j                  dd      j                  ||||      }| j                  |      }|j	                  d      j                  dd      }|S )Nr   r>   )r   rL   rm   r   rK   )r+   r-   rP   rQ   rx   r{   rH   s          r"   r/   zGLPNDWConv.forward   sj    ,9,?,?)
G\%//15:::|U[]bcM2%--a0::1a@r$   )i   r   r:   s   @r"   r   r      s    Jr$   r   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 r(   )r)   r*   r   r\   dense1r   r   
isinstance
hidden_actr8   r   intermediate_act_fndense2r`   r   rb   )r+   rf   in_featureshidden_featuresout_featuresr,   s        r"   r*   zGLPNMixFFN.__init__   s    #2{ii_= 1f''-'-f.?.?'@D$'-'8'8D$ii>zz&"<"<=r$   c                     | j                  |      }| j                  |||      }| j                  |      }| j                  |      }| j	                  |      }| j                  |      }|S r(   )r   r   r   rb   r   )r+   r-   rP   rQ   s       r"   r/   zGLPNMixFFN.forward  sb    M2M65A00?]3M2]3r$   )NNr   r:   s   @r"   r   r      s    
>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)rI   rW   rg   r   )r   r   )r)   r*   r   rE   layer_norm_1r   	attentionr&   Identityr#   layer_norm_2rY   r   mlp)	r+   rf   rI   rW   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)rw   r   r   )r   r   r#   r   r   )
r+   r-   rP   rQ   rw   self_attention_outputsr   r   
mlp_outputlayer_outputs
             r"   r/   zGLPNLayer.forward(  s    !%m,/	 "0 "
 2!4(,  >>*:;(=8XXd//>N
 ^^J/
!M1/G+r$   r   rR   r:   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   )rG   rA   rH   rI   )rI   rW   r#   rg   r   )r)   r*   rf   r   linspacedrop_path_ratesumdepthsitemrangenum_encoder_blocksappendr<   patch_sizesstridesrH   hidden_sizesr   
ModuleListpatch_embeddingsr   rW   	sr_ratios
mlp_ratiosblockrE   rF   )r+   rf   xdprrN   iblockscurlayersjr,   s             r"   r*   zGLPNEncoder.__init__C  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r(   r   ).0vs     r"   	<genexpr>z&GLPNEncoder.forward.<locals>.<genexpr>  s     mq_`_lms   last_hidden_stater-   
attentions)r   	enumeratezipr   r   rF   ro   rn   ru   tupler   )r+   rM   rw   output_hidden_statesreturn_dictall_hidden_statesall_self_attentionsrx   r-   idxr   embedding_layerblock_layer
norm_layerrP   rQ   r   blklayer_outputss                      r"   r/   zGLPNEncoder.forwards  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$   )FFTr   r:   s   @r"   r   r   B  s    .
f  "$
r$   r   c                   *    e Zd ZU eed<   dZdZg Zd Zy)GLPNPreTrainedModelrf   glpnrM   c                 B   t        |t        j                  t        j                  f      rm|j                  j
                  j                  d| j                  j                         |j                  %|j                  j
                  j                          yyt        |t        j                        rz|j                  j
                  j                  d| j                  j                         |j                  2|j                  j
                  |j                     j                          yyt        |t        j                  t        j                  f      rJ|j                  j
                  j                          |j                  j
                  j                  d       yy)zInitialize the weightsr   )meanstdNg      ?)r   r   r\   rC   weightdatanormal_rf   initializer_ranger   zero_	Embeddingpadding_idxrE   BatchNorm2dfill_)r+   modules     r"   _init_weightsz!GLPNPreTrainedModel._init_weights  s   fryy"))45 MM&&CT[[5R5R&S{{&  &&( '-MM&&CT[[5R5R&S!!-""6#5#56<<> .r~~ >?KK""$MM$$S) @r$   N)	r2   r3   r4   r   __annotations__base_model_prefixmain_input_name_no_split_modulesr   r   r$   r"   r   r     s    $O*r$   r   c                        e Zd Z fdZd Ze	 	 	 d	dej                  dee	   dee	   dee	   de
eef   f
d       Z xZS )
	GLPNModelc                 r    t         |   |       || _        t        |      | _        | j                          y r(   )r)   r*   rf   r   encoder	post_initr+   rf   r,   s     r"   r*   zGLPNModel.__init__  s1      #6* 	r$   c                     |j                         D ]7  \  }}| j                  j                  |   j                  j	                  |       9 y)z
        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
        class PreTrainedModel
        N)itemsr  layerr   r   )r+   heads_to_pruner	  r   s       r"   _prune_headszGLPNModel._prune_heads  sE    
 +002 	CLE5LLu%//;;EB	Cr$   rM   rw   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rw   r   r   r   r   r   )rf   rw   r   use_return_dictr  r   r-   r   )r+   rM   rw   r   r   encoder_outputssequence_outputs          r"   r/   zGLPNModel.forward  s     2C1N-TXT_T_TqTq$8$D $++JjJj 	 &1%<k$++B]B],,/!5#	 ' 
 *!,#%(;;;-)77&11
 	
r$   )NNN)r2   r3   r4   r*   r  r   r   FloatTensorr   boolr   r   r   r/   r9   r:   s   @r"   r  r    sy    C 
 -1/3&*
''
 $D>
 'tn	

 d^
 
uo%	&
 
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@   rA   rB   )r)   r*   r   
SequentialrC   rY   r   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   )r   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$   )@   rR   r:   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   rC   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 r(   )r1  r2  r4  )r+   hidden_stateresiduals      r"   r/   zGLPNDecoderStage.forward  s<    ''5;;|X>L}}\2r$   r(   r   r:   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*  stagesr2  r3  final_upsample)r+   rf   reserved_hidden_sizesr  rI   r,   s        r"   r*   zGLPNDecoder.__init__*  s     & 3 3DbD 911mmLab[k<8b
 !%A kkqzY^_ cs   Br-   r   c                     g }d }t        |d d d   | j                        D ]  \  }} |||      }|j                  |       ! | j                  |      |d<   |S )Nri   )r   r=  r   r>  )r+   r-   stage_hidden_statesstage_hidden_stater7  stages         r"   r/   zGLPNDecoder.forward8  sr     !#&}TrT':DKK#H 	;L%!&|5G!H&&'9:	; #'"5"56H"IB""r$   	r2   r3   r4   r*   listr   r7   r/   r9   r:   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 r(   )r)   r*   lambd)r+   rI  r,   s     r"   r*   zSiLogLoss.__init__M  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>   )detachr   logrr   powr   rI  )r+   predtarget
valid_maskdiff_loglosss         r"   r/   zSiLogLoss.forwardQ  s    qj((*
99VJ/0599T*=M3NNzz%))Ha0557$**uyyQYQ^Q^Q`bcGd:dder$   )g      ?rR   r:   s   @r"   rG  rG  D  s    r$   rG  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  rC   r  head)r+   rf   channelsr,   s      r"   r*   z GLPNDepthEstimationHead.__init__Z  sd    --MMIIha1MGGE"IIhqAF
	r$   r-   r   c                     || j                   j                     }| j                  |      }t        j                  |      | j                   j
                  z  }|j                  d      }|S )Nr   rk   )rf   head_in_indexrW  r   r  	max_depthsqueeze)r+   r-   predicted_depths      r"   r/   zGLPNDepthEstimationHead.forwardf  sZ    %dkk&?&?@		-0--69N9NN)11a18r$   rD  r:   s   @r"   rT  rT  Y  s(    

	T%,,%7 	ELL 	r$   rT  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ej                     dee   dee   dee   de	e
ej                     ef   fd       Z xZS )
GLPNForDepthEstimationc                     t         |   |       t        |      | _        t	        |      | _        t        |      | _        | j                          y r(   )	r)   r*   r  r   r:  decoderrT  rW  r  r  s     r"   r*   zGLPNForDepthEstimation.__init__x  s@     f%	"6*+F3	 	r$   rM   labelsrw   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 requests

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = Image.open(requests.get(url, stream=True).raw)

        >>> 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>   )rR  r]  r-   r   )
rf   r  r   r   r-   rb  rW  rG  r	   r   )r+   rM   rc  rw   r   r   r   r-   outr]  rR  loss_fctr!   s                r"   r/   zGLPNForDepthEstimation.forward  s   \ &1%<k$++B]B]$8$D $++JjJj 	 ))/!%#	  
 2=--'!*ll=)))C. {HOV4D#)+gabk9)+gabk9)-)9TGf$EvE#+3G'//T))	
 	
r$   )NNNN)r2   r3   r4   r*   r   r   r  r   r  r   r   r7   r	   r/   r9   r:   s   @r"   r`  r`  r  s      /3,0/3&*O
''O
 **+O
 $D>	O

 'tnO
 d^O
 
uU\\"$88	9O
 O
r$   r`  )r`  r   r  r   )r   F)1r5   rq   typingr   r   r   torch.utils.checkpointr   activationsr   modeling_outputsr   r	   modeling_utilsr
   pytorch_utilsr   r   utilsr   r   configuration_glpnr   
get_loggerr2   loggerr7   r6   r  r#   Moduler&   r<   rT   r   r   r   r   r   r   r   r  r  r*  r:  rG  rT  r`  __all__r   r$   r"   <module>rs     s     "    ! E - Q , * 
		H	%U\\ e T V[VbVb *%299 %) )4V Vt	RYY 	#BII #N  0(		 (VU
")) U
p */ * *0 2
# 2
 2
j) )Xryy (#")) #6		 *bii 2 
[
0 [

[
| Vr$   