
     `i+p                        d Z ddlZddlmZmZ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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 ddlmZmZ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+	 dBdej)        dej,        dej,        dej,        deej,                 de-de-fdZ. G d dej)                  Z/ G d  d!ej)                  Z0 G d" d#ej)                  Z1 G d$ d%ej)                  Z2dCd'ej,        d(e-d)e3d*ej,        fd+Z4 G d, d-ej)                  Z5 G d. d/ej)                  Z6 G d0 d1ej)                  Z7 G d2 d3e          Z8 G d4 d5ej)                  Z9e G d6 d7e                      Z:e G d8 d9e:                      Z; ed:;           G d< d=e:                      Z< ed>;           G d? d@e:e                       Z=g dAZ>dS )DzPyTorch DINOv2 model.    N)CallableOptionalUnion)nn   )ACT2FN)GradientCheckpointingLayer)BackboneOutputBaseModelOutputBaseModelOutputWithPoolingImageClassifierOutput)ALL_ATTENTION_FUNCTIONSPreTrainedModel)Unpack) find_pruneable_heads_and_indicesprune_linear_layer)TransformersKwargsauto_docstringlogging	torch_int)BackboneMixin)can_return_tuplecheck_model_inputs   )Dinov2Configc                        e Zd ZdZdeddf fdZdej        dededej        fd	Z	dd
ej        de
ej                 dej        fdZ xZS )Dinov2EmbeddingszM
    Construct the CLS token, mask token, position and patch embeddings.
    configreturnNc                 @   t                                                       t          j        t	          j        dd|j                            | _        |j        r1t          j        t	          j	        d|j                            | _
        t          |          | _        | j        j        }t          j        t	          j        d|dz   |j                            | _        t          j        |j                  | _        |j        | _        |j        | _        || _        d S )Nr   )super__init__r   	Parametertorchrandnhidden_size	cls_tokenuse_mask_tokenzeros
mask_tokenDinov2PatchEmbeddingspatch_embeddingsnum_patchesposition_embeddingsDropouthidden_dropout_probdropout
patch_sizer   )selfr   r-   	__class__s      ~/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/models/dinov2/modeling_dinov2.pyr"   zDinov2Embeddings.__init__+   s    ek!Q8J&K&KLL  	O l5;q&:L+M+MNNDO 5f = =+7#%<A{QPVPb0c0c#d#d z&"<== +$3    
embeddingsheightwidthc                    |j         d         dz
  }| j        j         d         dz
  }t          j                                        s||k    r||k    r| j        S | j        ddddf         }| j        ddddf         }|j         d         }|| j        z  }	|| j        z  }
t          |dz            }|                    d|||          }|                    dddd          }|j	        }t          j                            |                    t          j                  |	|
fdd	
                              |          }|                    dddd                              dd|          }t          j        ||fd          S )a-  
        This method allows to interpolate the pre-trained position encodings, to be able to use the model on higher resolution
        images. This method is also adapted to support torch.jit tracing and interpolation at torch.float32 precision.

        Adapted from:
        - https://github.com/facebookresearch/dino/blob/de9ee3df6cf39fac952ab558447af1fa1365362a/vision_transformer.py#L174-L194, and
        - https://github.com/facebookresearch/dinov2/blob/e1277af2ba9496fbadf7aec6eba56e8d882d1e35/dinov2/models/vision_transformer.py#L179-L211
        r   Ng      ?r   r      bicubicF)sizemodealign_cornersdtypedim)shaper.   r$   jit
is_tracingr2   r   reshapepermuterB   r   
functionalinterpolatetofloat32viewcat)r3   r7   r8   r9   r-   num_positionsclass_pos_embedpatch_pos_embedrD   
new_height	new_widthsqrt_num_positionstarget_dtypes                r5   interpolate_pos_encodingz)Dinov2Embeddings.interpolate_pos_encoding9   s    !&q)A-06q9A= y##%% 	,+*F*F6UZ??++2111bqb592111abb59r"t.
T_,	&}c'9::)11!5GI[]`aa)11!Q1==&,-33u}--i(	 4 
 

 "<"
 
  	 *11!Q1==BB1b#NNy/?;CCCCr6   pixel_valuesbool_masked_posc                 &   |j         \  }}}}| j        j        j        j        }|                     |                    |                    }|`| j        rYt          j        |	                    d          | j
                            |j                  	                    d          |          }| j                            |dd          }	t          j        |	|fd          }||                     |||          z   }|                     |          }|S )NrA   r;   r   r   rC   )rE   r,   
projectionweightrB   rL   r(   r$   where	unsqueezer*   r'   expandrO   rW   r1   )
r3   rX   rY   
batch_size_r8   r9   rV   r7   
cls_tokenss
             r5   forwardzDinov2Embeddings.forwarda   s   '3'9$
Avu,7>D**<???+N+NOO
&4+>&))"--t/A/A*BR/S/S/]/]^_/`/`bl J
 ^**:r2>>
Y
J7Q???
  $"?"?
FTY"Z"ZZ
\\*--
r6   N)__name__
__module____qualname____doc__r   r"   r$   TensorintrW   r   rc   __classcell__r4   s   @r5   r   r   &   s         |       &D5< &D &DUX &D]b]i &D &D &D &DP EL 8ELCY ejeq        r6   r   c                   F     e Zd ZdZ fdZdej        dej        fdZ xZS )r+   z
    This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
    `hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
    Transformer.
    c                    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        ||||          | _        d S )Nr   r   )kernel_sizestride)r!   r"   
image_sizer2   num_channelsr&   
isinstancecollectionsabcIterabler-   r   Conv2dr[   )r3   r   rq   r2   rr   r&   r-   r4   s          r5   r"   zDinov2PatchEmbeddings.__init__~   s    !'!2F4EJ
$*$79Kk#-j+/:R#S#SqZZZdfpYq
#-j+/:R#S#SqZZZdfpYq
!!}
15*Q-:VW=:XY$$(&)L+:^hiiir6   rX   r   c                     |j         d         }|| j        k    rt          d| j         d| d          |                     |                              d                              dd          }|S )Nr   zoMake sure that the channel dimension of the pixel values match with the one set in the configuration. Expected z	 but got .r<   )rE   rr   
ValueErrorr[   flatten	transpose)r3   rX   rr   r7   s       r5   rc   zDinov2PatchEmbeddings.forward   s    #)!,4,,,I!.I I9EI I I   __\22::1==GG1MM
r6   )	re   rf   rg   rh   r"   r$   ri   rc   rk   rl   s   @r5   r+   r+   w   sm         j j j j jEL U\        r6   r+           modulequerykeyvalueattention_maskscalingr1   c                    t          j        ||                    dd                    |z  }t          j                            |dt           j                                      |j                  }t          j        	                    ||| j
                  }|||z  }t          j        ||          }	|	                    dd                                          }	|	|fS )Nr;   )rD   rB   )ptrainingr   r<   )r$   matmulr|   r   rJ   softmaxrM   rL   rB   r1   r   
contiguous)
r~   r   r   r   r   r   r1   kwargsattn_weightsattn_outputs
             r5   eager_attention_forwardr      s     <s}}R'<'<==GL =((2U](SSVVW\WbccL =((6?([[L !#n4,|U33K''1--88::K$$r6   c            	            e Zd Zdef fdZ	 ddej        deej                 deej        ej        f         fdZ	 xZ
S )	Dinov2SelfAttentionr   c                    t                                                       |j        |j        z  dk    r0t	          |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                  | _        d S )	Nr   embedding_sizezThe hidden size z4 is not a multiple of the number of attention heads ry   g      Fbias)r!   r"   r&   num_attention_headshasattrrz   r   rj   attention_head_sizeall_head_sizeattention_probs_dropout_probdropout_probr   	is_causalr   Linearqkv_biasr   r   r   r3   r   r4   s     r5   r"   zDinov2SelfAttention.__init__   sB    ::a??PVXhHiHi?76#5 7 737 7 7  
 #)#= #&v'9F<V'V#W#W !58PP"?/5Yv143EFO\\\
9V/1C&/ZZZYv143EFO\\\


r6   Nhidden_states	head_maskr   c           
         |j         d         }|d| j        | j        f} |                     |          j        |                     dd          } |                     |          j        |                     dd          } |                     |          j        |                     dd          }t          }| j	        j
        dk    rt          | j	        j
                 } || ||||| j        | j        | j        sdn| j                  \  }	}
|	                                d d         | j        fz   }|	                    |          }	|	|
fS )	Nr   r;   r   r<   eagerr}   )r   r   r1   r   )rE   r   r   r   rN   r|   r   r   r   r   _attn_implementationr   r   r   r   r   r>   r   rH   )r3   r   r   r`   	new_shape	key_layervalue_layerquery_layerattention_interfacecontext_layerattention_probsnew_context_layer_shapes               r5   rc   zDinov2SelfAttention.forward   sY    #(+
D$<d>VV	0DHH]++0)<FFq!LL	4djj//4i@JJ1aPP4djj//4i@JJ1aPP(?;+w66"9$+:Z"[)<)<nL#}CCC$2C	*
 	*
 	*
& #0"4"4"6"6ss";t?Q>S"S%--.EFFo--r6   rd   )re   rf   rg   r   r"   r$   ri   r   tuplerc   rk   rl   s   @r5   r   r      s        ]| ] ] ] ] ] ]* PT. ."\.6>u|6L.	u|U\)	*. . . . . . . .r6   r   c                   Z     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 )Dinov2SelfOutputz
    The residual connection is defined in Dinov2Layer instead of here (as is the case with other models), due to the
    layernorm applied before each block.
    r   c                     t                                                       t          j        |j        |j                  | _        t          j        |j                  | _        d S rd   )	r!   r"   r   r   r&   denser/   r0   r1   r   s     r5   r"   zDinov2SelfOutput.__init__   sJ    Yv163EFF
z&"<==r6   r   input_tensorr   c                 Z    |                      |          }|                     |          }|S rd   )r   r1   )r3   r   r   s      r5   rc   zDinov2SelfOutput.forward   s*    

=11]33r6   )
re   rf   rg   rh   r   r"   r$   ri   rc   rk   rl   s   @r5   r   r      s         
>| > > > > > >
U\  RWR^        r6   r   c                   |     e Zd Zdef fdZdee         fdZd
dej	        de
ej	                 dej	        fd	Z xZS )Dinov2Attentionr   c                     t                                                       t          |          | _        t	          |          | _        t                      | _        d S rd   )r!   r"   r   	attentionr   outputsetpruned_headsr   s     r5   r"   zDinov2Attention.__init__   sI    ,V44&v..EEr6   headsc                    t          |          dk    rd S 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                            |          | _        d S )Nr   r   rC   )lenr   r   r   r   r   r   r   r   r   r   r   r   union)r3   r   indexs      r5   prune_headszDinov2Attention.prune_heads  s   u::??F74>5t~7Y[_[l
 
u
  2$.2FNN/0BEJJ1$.2FNN.t{/@%QOOO .2^-ORUV[R\R\-\*'+~'IDNLn'n$ -33E::r6   Nr   r   r   c                 d    |                      ||          \  }}|                     ||          }|S rd   )r   r   )r3   r   r   self_attn_outputra   r   s         r5   rc   zDinov2Attention.forward  s4    "nn]IFF!-}==r6   rd   )re   rf   rg   r   r"   r   rj   r   r$   ri   r   rc   rk   rl   s   @r5   r   r      s        "| " " " " " ";S ; ; ; ;$ U\ hu|>T `e`l        r6   r   c                   D     e Zd Zd fdZdej        dej        fdZ xZS )Dinov2LayerScaler   Nc                     t                                                       t          j        |j        t          j        |j                  z            | _        d S rd   )	r!   r"   r   r#   layerscale_valuer$   onesr&   lambda1r   s     r5   r"   zDinov2LayerScale.__init__  sC    |F$;ejI[>\>\$\]]r6   hidden_statec                     || j         z  S rd   )r   r3   r   s     r5   rc   zDinov2LayerScale.forward#  s    dl**r6   r   Nre   rf   rg   r"   r$   ri   rc   rk   rl   s   @r5   r   r     si        ^ ^ ^ ^ ^ ^+EL +U\ + + + + + + + +r6   r   Finput	drop_probr   r   c                     |dk    s|s| S d|z
  }| j         d         fd| j        dz
  z  z   }|t          j        || j        | j                  z   }|                                 |                     |          |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   )r   )rB   device)rE   ndimr$   randrB   r   floor_div)r   r   r   	keep_probrE   random_tensorr   s          r5   	drop_pathr   (  s     CxII[^
Q 77E
5EL Y Y YYMYYy!!M1FMr6   c                   j     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 )
Dinov2DropPathzXDrop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).Nr   r   c                 V    t                                                       || _        d S rd   )r!   r"   r   )r3   r   r4   s     r5   r"   zDinov2DropPath.__init__@  s$    "r6   r   c                 8    t          || j        | j                  S rd   )r   r   r   )r3   r   s     r5   rc   zDinov2DropPath.forwardD  s    FFFr6   c                     d| j          S )Nzp=)r   r3   s    r5   
extra_reprzDinov2DropPath.extra_reprG  s    $DN$$$r6   rd   )re   rf   rg   rh   r   floatr"   r$   ri   rc   strr   rk   rl   s   @r5   r   r   =  s        bb# #(5/ #T # # # # # #GU\ Gel G G G G%C % % % % % % % %r6   r   c                   D     e Zd Zd fdZdej        dej        fdZ xZS )	Dinov2MLPr   Nc                 ~   t                                                       |j        x}}t          |j        |j        z            }t          j        ||d          | _        t          |j	        t                    rt          |j	                 | _        n|j	        | _        t          j        ||d          | _        d S )NTr   )r!   r"   r&   rj   	mlp_ratior   r   fc1rs   
hidden_actr   r   
activationfc2r3   r   in_featuresout_featureshidden_featuresr4   s        r5   r"   zDinov2MLP.__init__L  s    %+%77lf063CCDD9[/EEEf'-- 	0$V%67DOO$/DO9_lFFFr6   r   c                     |                      |          }|                     |          }|                     |          }|S rd   )r   r   r   r   s     r5   rc   zDinov2MLP.forwardW  s;    xx--|44xx--r6   r   r   rl   s   @r5   r   r   K  si        	G 	G 	G 	G 	G 	GEL U\        r6   r   c                   D     e Zd Zd fdZdej        dej        fdZ xZS )Dinov2SwiGLUFFNr   Nc                 D   t                                                       |j        x}}t          |j        |j        z            }t          |dz  dz            dz   dz  dz  }t          j        |d|z  d          | _        t          j        ||d          | _        d S )Nr<   r         Tr   )	r!   r"   r&   rj   r   r   r   
weights_inweights_outr   s        r5   r"   zDinov2SwiGLUFFN.__init___  s    %+%77lf063CCDD2Q677!;AAE)K_1D4PPP9_lNNNr6   r   c                     |                      |          }|                    dd          \  }}t          j                            |          |z  }|                     |          S )Nr<   r;   rC   )r   chunkr   rJ   silur   )r3   r   x1x2hiddens        r5   rc   zDinov2SwiGLUFFN.forwardh  s]    |44##A2#..B##B''",'''r6   r   r   rl   s   @r5   r   r   ^  si        O O O O O O(EL (U\ ( ( ( ( ( ( ( (r6   r   c                   n     e Zd ZdZdeddf fdZ	 d	dej        deej                 dej        fdZ	 xZ
S )
Dinov2LayerzCThis corresponds to the Block class in the original implementation.r   r   Nc                 "   t                                                       t          j        |j        |j                  | _        t          |          | _        t          |          | _
        |j        dk    rt          |j                  nt          j                    | _        t          j        |j        |j                  | _        |j        rt#          |          | _        nt'          |          | _        t          |          | _        d S )Nepsr}   )r!   r"   r   	LayerNormr&   layer_norm_epsnorm1r   r   r   layer_scale1drop_path_rater   Identityr   norm2use_swiglu_ffnr   mlpr   layer_scale2r   s     r5   r"   zDinov2Layer.__init__r  s    \&"4&:OPPP
(00,V44BHBWZ]B]B](=>>>cecncpcp\&"4&:OPPP
  	)&v..DHH ((DH,V44r6   r   r   c                 d   |                      |          }|                     ||          }|                     |          }|                     |          |z   }|                     |          }|                     |          }|                     |          }|                     |          |z   }|S rd   )r  r   r  r   r  r  r	  )r3   r   r   hidden_states_normself_attention_outputlayer_outputs         r5   rc   zDinov2Layer.forward  s    
 "ZZ66 $/A9 M M $ 1 12G H H '<==M zz-00xx--((66 ~~l33mCr6   rd   )re   rf   rg   rh   r   r"   r$   ri   r   rc   rk   rl   s   @r5   r   r   o  s        MM5| 5 5 5 5 5 5 5& -1 | EL) 
	       r6   r   c            	       `     e Zd Zdef fdZ	 d
dej        deej                 dede	fd	Z
 xZS )Dinov2Encoderr   c                     t                                                       | _        t          j        fdt          j                  D                       | _        d| _        d S )Nc                 .    g | ]}t                    S  )r   .0ra   r   s     r5   
<listcomp>z*Dinov2Encoder.__init__.<locals>.<listcomp>  s!    #a#a#aAK$7$7#a#a#ar6   F)	r!   r"   r   r   
ModuleListrangenum_hidden_layerslayergradient_checkpointingr   s    `r5   r"   zDinov2Encoder.__init__  s`    ]#a#a#a#avG_A`A`#a#a#abb
&+###r6   NFr   r   output_hidden_statesr   c                     |r|gnd }t          | j                  D ]4\  }}|||         nd } |||          }|r|                    |           5t          ||rt	          |          nd           S )N)last_hidden_stater   )	enumerater  appendr   r   )r3   r   r   r  all_hidden_statesilayer_modulelayer_head_masks           r5   rc   zDinov2Encoder.forward  s     0DM]OO(44 	8 	8OA|.7.CillO(LHHM  8!((777+6GQ% 1222T
 
 
 	
r6   )NF)re   rf   rg   r   r"   r$   ri   r   boolr   rc   rk   rl   s   @r5   r  r    s        ,| , , , , , , sx
 
"\
6>u|6L
ko
	
 
 
 
 
 
 
 
r6   r  c                       e Zd ZU eed<   dZdZdZdgZdZ	dZ
dZdZdeiZdeej        ej        ej        f         dd	fd
Zd	S )Dinov2PreTrainedModelr   dinov2rX   Tr   
attentionsr~   r   Nc                 :   t          |t          j        t          j        f          rt          j                            |j        j                            t          j
                  d| j        j                                      |j        j                  |j        _        |j         |j        j                                         dS dS t          |t          j                  r?|j        j                                         |j        j                            d           dS t          |t$                    r"t          j                            |j        j                            t          j
                  d| j        j                                      |j        j                  |j        _        t          j                            |j        j                            t          j
                  d| j        j                                      |j        j                  |j        _        | j        j        r |j        j                                         dS dS t          |t.                    r+|j        j                            | j        j                   dS dS )zInitialize the weightsr}   )meanstdNg      ?)rs   r   r   rw   inittrunc_normal_r\   datarL   r$   rM   r   initializer_rangerB   r   zero_r   fill_r   r.   r'   r(   r*   r   r   r   )r3   r~   s     r5   _init_weightsz#Dinov2PreTrainedModel._init_weights  s?   fry")455 	D "$!6!6"%%em443DKDa "7 " "b$%% M {& &&((((( '&-- 	DK""$$$M$$S))))) 011 	D.0g.C.C*/225=AAK1 /D / / b+122	 &+ %'G$9$9 %((77K1 %: % % b!'((	 ! {) /!&,,...../ / 011 	DN%%dk&BCCCCC	D 	Dr6   )re   rf   rg   r   __annotations__base_model_prefixmain_input_namesupports_gradient_checkpointing_no_split_modules_supports_sdpa_supports_flash_attn_supports_flex_attn_supports_attention_backendr   _can_record_outputsr   r   r   rw   r   r2  r  r6   r5   r&  r&    s          $O&*#&N"&)DE")RY*L$M DRV D D D D D Dr6   r&  c                       e Zd Zdef fdZdefdZdeee	e         f         ddfdZ
 ed	          e	 	 	 	 dd
eej                 deej                 deej                 dee         def
d                        Z xZS )Dinov2Modelr   c                    t                                          |           || _        t          |          | _        t          |          | _        t          j        |j	        |j
                  | _        |                                  d S )Nr   )r!   r"   r   r   r7   r  encoderr   r   r&   r  	layernorm	post_initr   s     r5   r"   zDinov2Model.__init__  st       *622$V,,f&8f>STTT 	r6   r   c                     | j         j        S rd   r7   r,   r   s    r5   get_input_embeddingsz Dinov2Model.get_input_embeddings      //r6   heads_to_pruneNc                     |                                 D ]/\  }}| j        j        |         j                            |           0dS )z
        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
        class PreTrainedModel
        N)itemsr@  r  r   r   )r3   rG  r  r   s       r5   _prune_headszDinov2Model._prune_heads  sU    
 +0022 	C 	CLE5Lu%/;;EBBBB	C 	Cr6   F)tie_last_hidden_statesrX   rY   r   r  c                 b   || j         j        }|t          d          |                     || j         j                  }|                     ||          }|                     |||          }|j        }|                     |          }|dddddf         }	t          ||	|j
                  S )z
        bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, sequence_length)`):
            Boolean masked positions. Indicates which patches are masked (1) and which aren't (0). Only relevant for
            pre-training.
        Nz You have to specify pixel_values)rY   )r   r  r   )r  pooler_outputr   )r   r  rz   get_head_maskr  r7   r@  r  rA  r   r   )
r3   rX   rY   r   r  r   embedding_outputencoder_outputssequence_outputpooled_outputs
             r5   rc   zDinov2Model.forward  s      '#';#C ?@@@ &&y$+2OPP	??<?YY+/<<	H\ ,8 ,
 ,
 *;..99'1aaa0)-')7
 
 
 	
r6   )NNNN)re   rf   rg   r   r"   r+   rE  dictrj   listrJ  r   r   r   r$   ri   r$  r   rc   rk   rl   s   @r5   r>  r>    s*       
| 
 
 
 
 
 
0&; 0 0 0 0C4T#Y+? CD C C C C u555 0426,0/3'
 '
u|,'
 "%,/'
 EL)	'

 'tn'
 
$'
 '
 '
 ^ 65'
 '
 '
 '
 '
r6   r>  z
    Dinov2 Model transformer with an image classification head on top (a linear layer on top of the final hidden state
    of the [CLS] token) e.g. for ImageNet.
    )custom_introc                        e Zd Zdeddf fdZee	 	 	 d
deej	                 deej	                 deej	                 de
e         def
d	                        Z xZS )Dinov2ForImageClassificationr   r   Nc                 <   t                                          |           |j        | _        t          |          | _        |j        dk    r"t          j        |j        dz  |j                  nt          j                    | _	        | 
                                 d S )Nr   r<   )r!   r"   
num_labelsr>  r'  r   r   r&   r  
classifierrB  r   s     r5   r"   z%Dinov2ForImageClassification.__init__+  s        +!&)) EKDUXYDYDYBIf(1,f.?@@@_a_j_l_l 	
 	r6   rX   r   labelsr   c                 R    | j         |fd|i|}|j        }|dddf         }|ddddf         }t          j        ||                    d          gd          }	|                     |	          }
d}| | j        ||
| j        fi |}t          ||
|j	        |j
                  S )a  
        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
        r   Nr   r   rC   )losslogitsr   r(  )r'  r  r$   rO   r*  rZ  loss_functionr   r   r   r(  )r3   rX   r   r[  r   outputsrQ  r'   patch_tokenslinear_inputr^  r]  s               r5   rc   z$Dinov2ForImageClassification.forward9  s     /:dk,.f.fR[.f_e.f.f!3#AAAqD)	&qqq!""u-y)\->->1->-E-E!FANNN..%4%ffdkLLVLLD$!/)	
 
 
 	
r6   )NNN)re   rf   rg   r   r"   r   r   r   r$   ri   r   r   r   rc   rk   rl   s   @r5   rW  rW  $  s        |         04,0)-	
 
u|,
 EL)
 &	

 +,
 

 
 
 ^ 
 
 
 
 
r6   rW  zO
    Dinov2 backbone, to be used with frameworks like DETR and MaskFormer.
    c            	       x     e Zd Z fdZdefdZee	 ddej	        de
e         defd                        Z xZS )	Dinov2Backbonec                    t                                                     t                                                     fdt          j        dz             D             | _        t                    | _        t                    | _	        t          j        j        j                  | _        |                                  d S )Nc                     g | ]	}j         
S r  )r&   r  s     r5   r  z+Dinov2Backbone.__init__.<locals>.<listcomp>g  s    ]]]AV/]]]r6   r   r   )r!   r"   _init_backboner  r  num_featuresr   r7   r  r@  r   r   r&   r  rA  rB  r   s    `r5   r"   zDinov2Backbone.__init__c  s       v&&&]]]]v?WZ[?[9\9\]]]*622$V,,f&8f>STTT 	r6   r   c                     | j         j        S rd   rD  r   s    r5   rE  z#Dinov2Backbone.get_input_embeddingsp  rF  r6   NrX   r  c                 t   || j         j        }|                     |          }|                     |d          }|j        }g }t          | j        |          D ]\  }}	|| j        v r| j         j        r| 	                    |	          }	| j         j
        rn|	ddddf         }	|j        \  }
}}}| j         j        }|	                    |
||z  ||z  d          }	|	                    dddd                                          }	|                    |	           t#          t%          |          |r|nd	          S )
a%  
        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, AutoBackbone
        >>> import torch
        >>> from PIL import Image
        >>> import requests

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

        >>> processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
        >>> model = AutoBackbone.from_pretrained(
        ...     "facebook/dinov2-base", out_features=["stage2", "stage5", "stage8", "stage11"]
        ... )

        >>> inputs = processor(image, return_tensors="pt")

        >>> outputs = model(**inputs)
        >>> feature_maps = outputs.feature_maps
        >>> list(feature_maps[-1].shape)
        [1, 768, 16, 16]
        ```NT)r  r   r;   r   r   r<   )feature_mapsr   )r   r  r7   r@  r   zipstage_namesr   apply_layernormrA  reshape_hidden_statesrE   r2   rH   rI   r   r  r
   r   )r3   rX   r  r   rO  r   r   rk  stager   r`   ra   r8   r9   r2   s                  r5   rc   zDinov2Backbone.forwards  si   :  '#';#C ??<88"&,,/?VZ,"["[,#&t'7#G#G 	2 	2E<)));. @#'>>,#?#?L;4 Q#/122#6L 4@3E0J65!%!7J#/#7#7
FjDXZ_cmZmoq#r#rL#/#7#71a#C#C#N#N#P#PL##L111|,,+?I--T
 
 
 	
r6   rd   )re   rf   rg   r"   r+   rE  r   r   r$   ri   r   r$  r
   rc   rk   rl   s   @r5   rd  rd  ]  s            0&; 0 0 0 0 QU4
 4
!L4
@H4
	4
 4
 4
 ^ 4
 4
 4
 4
 4
r6   rd  )rW  r>  r&  rd  )r}   )r}   F)?rh   collections.abcrt   typingr   r   r   r$   r   activationsr   modeling_layersr	   modeling_outputsr
   r   r   r   modeling_utilsr   r   processing_utilsr   pytorch_utilsr   r   utilsr   r   r   r   utils.backbone_utilsr   utils.genericr   r   configuration_dinov2r   
get_loggerre   loggerModuler   r+   ri   r   r   r   r   r   r   r$  r   r   r   r   r   r  r&  r>  rW  rd  __all__r  r6   r5   <module>r     s&         , , , , , , , , , ,        ! ! ! ! ! ! 9 9 9 9 9 9 r r r r r r r r r r r r F F F F F F F F & & & & & & Q Q Q Q Q Q Q Q K K K K K K K K K K K K 1 1 1 1 1 1 A A A A A A A A . . . . . . 
	H	%	%N N N N Nry N N Nb    BI   R % %I%<% 
% <	%
 U\*% % % % % %>1. 1. 1. 1. 1.") 1. 1. 1.j    ry   $    bi   >+ + + + +ry + + + U\ e T V[Vb    *% % % % %RY % % %    	   &( ( ( ( (bi ( ( ("' ' ' ' ', ' ' 'T
 
 
 
 
BI 
 
 
. +D +D +D +D +DO +D +D +D\ A
 A
 A
 A
 A
' A
 A
 A
H   0
 0
 0
 0
 0
#8 0
 0
 0
f   
G
 G
 G
 G
 G
*M G
 G
 
G
T e
d
dr6   