
     `iJy                        d Z ddlZddlZddlmZ ddlmZ ddl	Z	ddl
mZ ddlmZ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 dd	lmZmZmZmZ dd
lm Z m!Z! ddl"m#Z# dZ$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+ej,        fdZ- G d dej&                  Z. G d dej&                  Z/ G d dej&                  Z0 G d  d!ej&                  Z1 G d" d#ej&                  Z2 G d$ d%ej&                  Z3 G d& d'ej&                  Z4 G d( d)e          Z5 G d* d+ej&                  Z6 e d,e$           G d- d.e5                      Z7d/Z8 ee7e8            ee7ee#0            G d1 d2ej&                  Z9 e d3e$           G d4 d5e5                      Z:d6Z; ee:e;            ee:ee#0           g d7Z<dS )8zFlax DINOv2 model.    N)Optional)
FrozenDictfreezeunfreeze)dot_product_attention_weights)flatten_dictunflatten_dict   )FlaxBaseModelOutputFlaxBaseModelOutputWithPoolingFlaxSequenceClassifierOutput)ACT2FNFlaxPreTrainedModel append_replace_return_docstringsoverwrite_call_docstring)add_start_docstrings%add_start_docstrings_to_model_forward   )Dinov2Configa  

    This model inherits from [`FlaxPreTrainedModel`]. Check the superclass documentation for the generic methods the
    library implements for all its model (such as downloading, saving and converting weights from PyTorch models)

    This model is also a
    [flax.linen.Module](https://flax.readthedocs.io/en/latest/api_reference/flax.linen/module.html) subclass. Use it as
    a regular Flax linen Module and refer to the Flax documentation for all matter related to general usage and
    behavior.

    Finally, this model supports inherent JAX features such as:

    - [Just-In-Time (JIT) compilation](https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit)
    - [Automatic Differentiation](https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation)
    - [Vectorization](https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap)
    - [Parallelization](https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap)

    Parameters:
        config ([`Dinov2Config`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~FlaxPreTrainedModel.from_pretrained`] method to load the model weights.
        dtype (`jax.numpy.dtype`, *optional*, defaults to `jax.numpy.float32`):
            The data type of the computation. Can be one of `jax.numpy.float32`, `jax.numpy.float16` (on GPUs) and
            `jax.numpy.bfloat16` (on TPUs).

            This can be used to enable mixed-precision training or half-precision inference on GPUs or TPUs. If
            specified all the computation will be performed with the given `dtype`.

            **Note that this only specifies the dtype of the computation and does not influence the dtype of model
            parameters.**

            If you wish to change the dtype of the model parameters, see [`~FlaxPreTrainedModel.to_fp16`] and
            [`~FlaxPreTrainedModel.to_bf16`].
a
  
    Args:
        pixel_values (`numpy.ndarray` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`Dinov2ImageProcessor.__call__`]
            for details.

        output_attentions (`bool`, *optional*):
            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
            tensors for more detail.
        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
c                   H    e Zd ZU eed<   ej        Zej        ed<   d Zd Z	dS )FlaxDinov2PatchEmbeddingsconfigdtypec                    | 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  }|| _        | j         j        | _        t          j
        | j         j        ||d| j        t          j	        j                            | j         j        dz  dd                    | _        d S )Nr   r   VALID   fan_intruncated_normal)kernel_sizestridespaddingr   kernel_init)r   
image_size
patch_size
isinstancecollectionsabcIterablenum_patchesnum_channelsnnConvhidden_sizer   jaxinitializersvariance_scalinginitializer_range
projection)selfr#   r$   r)   s       /home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/models/dinov2/modeling_flax_dinov2.pysetupzFlaxDinov2PatchEmbeddings.setup_   s    [+
[+
#-j+/:R#S#SqZZZdfpYq
#-j+/:R#S#SqZZZdfpYq
!!}
15*Q-:VW=:XY& K4'K#"*+<<-q0(<N 	
 	
 	
    c                     |j         d         }|| j        k    rt          d          |                     |          }|j         \  }}}}t	          j        ||d|f          S )NzeMake sure that the channel dimension of the pixel values match with the one set in the configuration.)shaper*   
ValueErrorr2   jnpreshape)r3   pixel_valuesr*   
embeddings
batch_size_channelss          r4   __call__z"FlaxDinov2PatchEmbeddings.__call__t   so    #)"-4,,,w   __\22
%/%5"
Aq({:
B'ABBBr6   N
__name__
__module____qualname__r   __annotations__r;   float32r   r5   rB    r6   r4   r   r   [   sY         {E39"""
 
 
*C C C C Cr6   r   c                   T    e Zd ZU dZeed<   ej        Zej        ed<   d Z	d Z
d	dZdS )
FlaxDinov2Embeddingsz7Construct the CLS token, position and patch embeddings.r   r   c                    |                      dt          j        j                            | j        j        dz  dd          dd| j        j        f          | _        | j        j	        rY|                      dt          j        j                            | j        j        dz  dd          d| j        j        f          | _
        t          | j        | j                  | _        | j        j        }|                      dt          j        j                            | j        j        dz  dd          d|dz   | j        j        f          | _        t          j        | j        j        	          | _        d S )
N	cls_tokenr   r   r   r   
mask_tokenr   position_embeddingsrate)paramr.   r+   r/   r0   r   r1   r-   rM   use_mask_tokenrN   r   r   patch_embeddingsr)   rP   Dropouthidden_dropout_probdropout)r3   r)   s     r4   r5   zFlaxDinov2Embeddings.setup   sC   F001NPQ1QS[]opp4;*+
 

 ;% 	"jj#44T[5RTU5UW_asttDK+, DO
 !:$+TZ X X X+7#'::!F001NPQ1QS[]oppa!89$
 $
 
 zt{'FGGGr6   c           	         |j         d         dz
  }|j         d         dz
  }||k    r||k    r|S |d d df         }|d d dd f         }	|j         d         }
||j        z  }||j        z  }|dz   |dz   }}|	                    dt          t	          j        |                    t          t	          j        |                    |
f          }	t          j        |	d          }	|	j        }t          j	        |t	          j        |          z            }t          j	        |t	          j        |          z            }t          j
        ||gt          j	                  }t          j
        ddgt          j	                  }t          j                            |	                    t          j	                  |	j         d         |	j         d         ||fd||d	d
          }	|	                    |          }	t          j        |	d                              |j         d         d|
f          }	t          j        |	|j         d         ddf          }t          j        ||j         d         ddf          }t          j        ||fd          S )Nr   r   r8   g?)r   r
   r   r   rO           )r   r
   bicubicF)r9   spatial_dimsscaletranslationmethod	antialiasr   r   r
   r   axis)r9   r$   r<   intmathsqrtr;   	transposer   rH   arrayr.   imagescale_and_translateastypetileconcatenate)r3   r   hidden_statesheightwidthrP   r)   num_positionsclass_pos_embedpatch_pos_embeddimhwtarget_dtypenew_height_rationew_width_ratior]   r^   patch_pos_embed_expandedclass_pos_embed_expandeds                       r4   interpolate_pos_encodingz-FlaxDinov2Embeddings.interpolate_pos_encoding   sx   #)!,q0+1!4q8-''FeOO&&-aaad3-aaae4!"%f''V&&CS)11DIm,,--s49]3K3K/L/LcR
 
 -FF&,;v	-0H0H'HII+edi.F.F&FGG	+_=S[QQQic
#+>>>)77""3;//"(+_-B1-Eq!L# 8 
 
 *00>>-FFNNPcPijkPlnpruOvww#&8Om>QRS>TVWYZ=[#\#\ #&8Om>QRS>TVWYZ=[#\#\  8:RSZ[\\\\r6   Tc                    |j         d         }| j        j        j        }|j         d         |j         d         }}|                     |                    |                    }t          j        | j        |d| j        j	        f          }t          j
        ||fd          }||                     | j        |||| j                  z   }|                     ||          }|S )Nr   r   r   rb   deterministic)r9   rU   r2   r   rk   r;   broadcast_torM   r   r-   rm   r|   rP   rX   )	r3   r=   r   r?   rw   ro   rp   r>   
cls_tokenss	            r4   rB   zFlaxDinov2Embeddings.__call__   s    !'*
,7=$*1-|/A!/D**<+>+>|+L+LMM
%dnz1dkF]6^__
_j*%=AFFF
$"?"?KVUD4L#
 #
 

 \\*M\JJ
r6   NT)rD   rE   rF   __doc__r   rG   r;   rH   r   r5   r|   rB   rI   r6   r4   rK   rK      su         AA{E39"""H H H*&] &] &]P     r6   rK   c                   T    e Zd ZU eed<   ej        Zej        ed<   d Zd
de	de	fdZ
d	S )FlaxDinov2SelfAttentionr   r   c           	         | j         j        | j         j        z  dk    rt          d          t	          j        | j         j        | j        t          j        j        	                    | j         j
        dz  dd          | j         j                  | _        t	          j        | j         j        | j        t          j        j        	                    | j         j
        dz  dd          | j         j                  | _        t	          j        | j         j        | j        t          j        j        	                    | j         j
        dz  dd          | j         j                  | _        d S )Nr   z`config.hidden_size`: {self.config.hidden_size} has to be a multiple of `config.num_attention_heads`: {self.config.num_attention_heads}r   r   r   )modedistribution)r   r"   use_bias)r   r-   num_attention_headsr:   r+   Denser   r.   r/   r0   r1   qkv_biasquerykeyvaluer3   s    r4   r5   zFlaxDinov2SelfAttention.setup   sW   ;"T[%DDII5  
 XK#*+<<-q0xN` =   [)
 
 

 8K#*+<<-q0xN` =   [)
 
 
 XK#*+<<-q0xN` =   [)
 
 



r6   TFr   output_attentionsc           
         | j         j        | j         j        z  }|                     |                              |j        d d         | j         j        |fz             }|                     |                              |j        d d         | j         j        |fz             }|                     |                              |j        d d         | j         j        |fz             }d }|s%| j         j        dk    r| 	                    d          }t          |||| j         j        d|| j        d           }	t          j        d|	|          }
|
                    |
j        d d         dz             }
|r|
|	fn|
f}|S )Nr   rZ   rX   T)dropout_rngdropout_ratebroadcast_dropoutr   r   	precisionz...hqk,...khd->...qhd)r8   )r   r-   r   r   r<   r9   r   r   attention_probs_dropout_probmake_rngr   r   r;   einsum)r3   rn   r   r   head_dimquery_statesvalue_states
key_statesr   attn_weightsattn_outputoutputss               r4   rB   z FlaxDinov2SelfAttention.__call__   s   ;*dk.MMzz-0088#t{'F&QQ
 
 zz-0088#t{'F&QQ
 
 XXm,,44#t{'F&QQ
 

  	3!IC!O!O--	22K4#A"'*	
 	
 	
 j!8,UU!))+*;BQB*?%*GHH1BV;--r6   NTFrD   rE   rF   r   rG   r;   rH   r   r5   boolrB   rI   r6   r4   r   r      sn         {E39"""
 
 
@   T  UY            r6   r   c                   P    e Zd ZU eed<   ej        Zej        ed<   d Zdde	fdZ
dS )	FlaxDinov2SelfOutputr   r   c                    t          j        | j        j        t          j         j                            | j        j        dz  dd          | j                  | _	        t          j
        | j        j                  | _        d S )Nr   r   r   r"   r   rQ   )r+   r   r   r-   r.   r/   r0   r1   r   denserV   rW   rX   r   s    r4   r5   zFlaxDinov2SelfOutput.setup!  sr    XK#+<<-q0(<N  *
 
 

 zt{'FGGGr6   Tr   c                 ^    |                      |          }|                     ||          }|S )Nr~   )r   rX   )r3   rn   input_tensorr   s       r4   rB   zFlaxDinov2SelfOutput.__call__+  s.    

=11]-PPr6   Nr   r   rI   r6   r4   r   r     sh         {E39"""H H H 4      r6   r   c                   P    e Zd ZU eed<   ej        Zej        ed<   d Zd	de	fdZ
dS )
FlaxDinov2Attentionr   r   c                     t          | j        | j                  | _        t	          | j        | j                  | _        d S NrO   )r   r   r   	attentionr   outputr   s    r4   r5   zFlaxDinov2Attention.setup6  s6    0DJOOO*4;djIIIr6   TFr   c                     |                      |||          }|d         }|                     |||          }|f}|r||d         fz  }|S )Nr   r   r   r~   r   )r   r   )r3   rn   r   r   attn_outputsr   r   s          r4   rB   zFlaxDinov2Attention.__call__:  s`    ~~m=du~vv"1oKm\\ " 	*Q))Gr6   Nr   r   rI   r6   r4   r   r   2  sh         {E39"""J J J
 
T 
 
 
 
 
 
r6   r   c                 2    t          j        ||          |z  S N)r;   ones)r   r9   r]   r   s       r4   ones_with_scaler   G  s    8E5!!E))r6   c                   H    e Zd ZU eed<   ej        Zej        ed<   d Zd Z	dS )FlaxDinov2LayerScaler   r   c                     | j         j        |                     dt          j        j        j        | j         j        f          z  | _        | j        | j         j        z  | _        d S )Nlambda1)	r   layerscale_valuerS   r.   r+   r/   r   r-   r   r   s    r4   r5   zFlaxDinov2LayerScale.setupO  sU    {3djjF$[$&7
 7
 

 |dk&BBr6   c                     | j         |z  S r   )r   r3   rn   s     r4   rB   zFlaxDinov2LayerScale.__call__W  s    |m++r6   NrC   rI   r6   r4   r   r   K  sW         {E39"""C C C, , , , ,r6   r   c                   \    e Zd ZU dZeed<   ej        j        dde	e
         fd            ZdS )FlaxDinov2DropPathzXDrop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).rR   Tr   c                 *   | j         dk    r|S d| j         z
  }|r|S |j        d         fd|j        dz
  z  z   }|                     d          }|t          j                            |||j                  z   }t          j	        |          }||z  |z  }|S )NrZ   g      ?r   )r   r   droppath)r9   r   )
rR   r9   ndimr   r.   randomuniformr   r;   floor)	r3   inputsr   	keep_probr9   rngrandom_tensorbinary_tensorr   s	            r4   rB   zFlaxDinov2DropPath.__call__a  s    9M$)O	 	M\!_&q)AAE--
++C%
(:(:3eSYS_(:(`(``MIm44Mi'-7FMr6   Nr   )rD   rE   rF   r   floatrG   r+   modulecompactr   r   rB   rI   r6   r4   r   r   \  sY         bb
KKKY htn      r6   r   c                   H    e Zd ZU eed<   ej        Zej        ed<   d Zd Z	dS )FlaxDinov2MLPr   r   c                 ,   t          j        | j        j        | j        j        z  t
          j         j                            | j        j        dz  dd          | j	                  | _
        t          j        | j        j        t
          j         j                            | j        j        dz  dd          | j	                  | _        t          | j        j        t                    rt          | j        j                 | _        d S | j        j        | _        d S )Nr   r   r   r   )r+   r   r   r-   	mlp_ratior.   r/   r0   r1   r   fc1fc2r%   
hidden_actstrr   actr   s    r4   r5   zFlaxDinov2MLP.setupu  s    8K#dk&;;+<<-q0(<N  *
 
 
 8K#+<<-q0(<N  *
 
 
 dk,c22 	.dk45DHHH{-DHHHr6   c                     |                      |          }|                     |          }|                     |          }|S r   )r   r   r   r   s     r4   rB   zFlaxDinov2MLP.__call__  s;    //////r6   NrC   rI   r6   r4   r   r   q  sT         {E39""". . .(    r6   r   c                   H    e Zd ZU eed<   ej        Zej        ed<   d Zd Z	dS )FlaxDinov2SwiGLUFFNr   r   c                    t          | j        j        | j        j        z            }t          |dz  dz            dz   dz  dz  }t	          j        d|z  t          j        j                            | j        j	        dz  dd          | j
                  | _        t	          j        | j        j        t          j        j                            | j        j	        dz  dd          | j
                  | _        d S )Nr   r
         r   r   r   )rd   r   r-   r   r+   r   r.   r/   r0   r1   r   
weights_inweights_out)r3   hidden_featuress     r4   r5   zFlaxDinov2SwiGLUFFN.setup  s    dk58MMNN2Q677!;AAE(+<<-q0(<N  *
 
 
 8K#+<<-q0(<N  *
 
 
r6   c                     |                      |          }t          j        |dd          \  }}t          j        |          |z  }|                     |          S )Nr   r8   rb   )r   r;   splitr+   silur   )r3   rn   x1x2hiddens        r4   rB   zFlaxDinov2SwiGLUFFN.__call__  sS    66=!"555Br!'''r6   NrC   rI   r6   r4   r   r     sT         {E39"""
 
 
&( ( ( ( (r6   r   c                   T    e Zd ZU eed<   ej        Zej        ed<   d Zd
de	de	fdZ
d	S )FlaxDinov2Layerr   r   c                 D   t          j        | j        j        | j                  | _        t          | j        | j                  | _        t          | j        | j                  | _	        t          | j        j                  | _        t          j        | j        j        | j                  | _        | j        j        r!t          | j        | j                  | _        n t#          | j        | j                  | _        t          | j        | j                  | _        d S )Nepsilonr   rO   )r+   	LayerNormr   layer_norm_epsr   norm1r   r   r   layer_scale1r   drop_path_rate	drop_pathnorm2use_swiglu_ffnr   mlpr   layer_scale2r   s    r4   r5   zFlaxDinov2Layer.setup  s    \$+*DDJWWW
,T[
KKK0DJOOO+DK,FGG\$+*DDJWWW
;% 	D*4;djIIIDHH$T[
CCCDH0DJOOOr6   TFr   r   c                    |                      |                     |          ||          }|d         }|                     |          }|dd          }|                     |          |z   }|                     |          }|                     |          }|                     |          }|                     |          |z   }|f|z   }|S )Nr   r   r   )r   r   r   r   r   r   r   )r3   rn   r   r   self_attention_outputsattention_outputr   layer_outputs           r4   rB   zFlaxDinov2Layer.__call__  s    !%JJ}%%'/ "0 "
 "
 2!4,,-=>>(, '788=H zz-00xx--((66 ~~l33mC/G+r6   Nr   r   rI   r6   r4   r   r     sp         {E39"""P P P T UY      r6   r   c            	       d    e Zd ZU eed<   ej        Zej        ed<   d Z	 	 	 	 dde	de	de	d	e	fd
Z
dS )FlaxDinov2LayerCollectionr   r   c                 \      fdt           j        j                  D              _        d S )Nc                 b    g | ]+}t          j        t          |          j                   ,S ))namer   )r   r   r   r   ).0ir3   s     r4   
<listcomp>z3FlaxDinov2LayerCollection.setup.<locals>.<listcomp>  s?     
 
 
LMODKc!ffDJGGG
 
 
r6   )ranger   num_hidden_layerslayersr   s   `r4   r5   zFlaxDinov2LayerCollection.setup  s@    
 
 
 
QVW[WbWtQuQu
 
 
r6   TFr   r   output_hidden_statesreturn_dictc                    |rdnd }|rdnd }t          | j                  D ]1\  }}	|r||fz  } |	|||          }
|
d         }|r||
d         fz  }2|r||fz  }|f}|st          d |D                       S t          |||          S )NrI   r   r   r   c              3      K   | ]}||V  	d S r   rI   )r   vs     r4   	<genexpr>z5FlaxDinov2LayerCollection.__call__.<locals>.<genexpr>  s"      ==qq}}}}}==r6   )last_hidden_statern   
attentions)	enumerater  tupler   )r3   rn   r   r   r  r  all_attentionsall_hidden_statesr   layerlayer_outputsr   s               r4   rB   z"FlaxDinov2LayerCollection.__call__  s      1:d"6@BBD!$+.. 		6 		6HAu# 6!m%55!!E-}`qrrrM)!,M  6=#3"55 	2-!11 " 	>==G======"+;LYg
 
 
 	
r6   NTFFTr   rI   r6   r4   r   r     s         {E39"""
 
 
 #"'%* 
 
 
  	

 #
 
 
 
 
 
 
r6   r   c            	       d    e Zd ZU eed<   ej        Zej        ed<   d Z	 	 	 	 dde	de	de	d	e	fd
Z
dS )FlaxDinov2Encoderr   r   c                 F    t          | j        | j                  | _        d S r   )r   r   r   r  r   s    r4   r5   zFlaxDinov2Encoder.setup  s    .t{$*MMM


r6   TFr   r   r  r  c                 6    |                      |||||          S )Nr   r   r  r  )r  )r3   rn   r   r   r  r  s         r4   rB   zFlaxDinov2Encoder.__call__  s.     zz'/!5#  
 
 	
r6   Nr  r   rI   r6   r4   r  r  
  s         {E39"""N N N #"'%* 
 
 
  	

 #
 
 
 
 
 
 
r6   r  c                   `    e Zd ZU dZeZdZdZdZe	j
        ed<   ddej        dfded	ed
ej        def fdZddej        j        dededefdZ ee                    d                    	 	 	 	 	 	 ddee         dej        j        dedee         dee         dee         fd            Z xZS )FlaxDinov2PreTrainedModelz
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    dinov2r=   Nmodule_classr   Tr   seedr   _do_initc                      | j         d||d|}|d|j        |j        |j        f}t                                          ||||||           d S )Nr   r   r   )input_shaper  r   r  rI   )r  r#   r*   super__init__)	r3   r   r!  r  r   r  kwargsr   	__class__s	           r4   r#  z"FlaxDinov2PreTrainedModel.__init__-  sn     #"H&HHHHf/1BFDWXK[tSXcklllllr6   r   r!  paramsreturnc                    t          j        || j                  }t          j                            |          \  }}t          j                            |          \  }}|||d}| j                            ||d          d         }	||t          t          |	                    }	t          t          |                    }| j
        D ]}
|	|
         ||
<   t                      | _
        t          t          |                    S |	S )NrO   )r&  rX   r   F)r  r&  )r;   zerosr   r.   r   r   r   initr   r   _missing_keyssetr   r	   )r3   r   r!  r&  r=   
params_rngr   droppath_rngrngsrandom_paramsmissing_keys              r4   init_weightsz&FlaxDinov2PreTrainedModel.init_weights;  s    yDJ???"%*"2"23"7"7
K$'J$4$4[$A$A!\$,WW((|(OOPXY(-)@)@AAM!(6"2"233F#1 A A&3K&@{##!$D.00111  r6   zbatch_size, sequence_lengthFr   trainr   r  r  c           	      ~   ||n| j         j        }||n| j         j        }||n| j         j        }t	          j        |d          }i }|,t          j                            |          \  }}	||d<   |	|d<   | j	        
                    d|p| j        it	          j        |t          j                  | ||||          S )Nra   rX   r   r&  rO   )r/  )r   r   r  r  r;   rg   r.   r   r   r   applyr&  rh   rH   )
r3   r=   r&  r   r3  r   r  r  r/  r.  s
             r4   rB   z"FlaxDinov2PreTrainedModel.__call__O  s     2C1N--TXT_Tq$8$D  $+Jj 	 &1%<kk$+BY}\<@@"(+
(8(8(E(E%K)DO+D{  v,-Il#+666I  ! 
 
 	
r6   r   )NNFNNN)rD   rE   rF   r   r   config_classbase_model_prefixmain_input_namer  r+   ModulerG   r;   rH   rd   r   r   r#  r.   r   PRNGKeyr  r   r2  r   DINOV2_INPUTS_DOCSTRINGformatr   dictrB   __classcell__)r%  s   @r4   r  r  "  s         
  L $O"L")"""
 ;m mm 	m
 ym m m m m m m! !
 2 ! !PZ !fp ! ! ! !( +*+B+I+IJg+h+hii "&*.,0/3&* 
  
  
 Z'	 

  
 $D> 
 'tn 
 d^ 
  
  
 ji 
  
  
  
  
r6   r  c            	       d    e Zd ZU eed<   ej        Zej        ed<   d Z	 	 	 	 dde	de	de	d	e	fd
Z
dS )FlaxDinov2Moduler   r   c                     t          | j        | j                  | _        t	          | j        | j                  | _        t          j        | j        j        | j                  | _	        d S )NrO   r   )
rK   r   r   r>   r  encoderr+   r   r   	layernormr   s    r4   r5   zFlaxDinov2Module.setupw  sU    .t{$*MMM(DJGGGdk.HPTPZ[[[r6   TFr   r   r  r  c                    |                      ||          }|                     |||||          }|d         }|                     |          }|d d dd d f         }	|s||	f}
|
|dd          z   S t          ||	|j        |j                  S )Nr~   r  r   r   )r  pooler_outputrn   r  )r>   rB  rC  r   rn   r  )r3   r=   r   r   r  r  rn   encoder_outputssequence_outputpooled_outputhead_outputss              r4   rB   zFlaxDinov2Module.__call__|  s     MRR,,'/!5# ' 
 
 *!,..99'1aaa0 	6+];L/!"""555--')7&1	
 
 
 	
r6   Nr  r   rI   r6   r4   r@  r@  s  s         {E39"""\ \ \ #"'%* 
 
 
  	

 #
 
 
 
 
 
 
r6   r@  z`The bare Dinov2 Model transformer outputting raw hidden-states without any specific head on top.c                       e Zd ZeZdS )FlaxDinov2ModelN)rD   rE   rF   r@  r  rI   r6   r4   rK  rK    s        
 $LLLr6   rK  ar  
    Returns:

    Examples:

    ```python
    >>> from transformers import AutoImageProcessor, FlaxDinov2Model
    >>> 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("facebook/dinov2-base")
    >>> model = FlaxDinov2Model.from_pretrained("facebook/dinov2-base")

    >>> inputs = image_processor(images=image, return_tensors="np")
    >>> outputs = model(**inputs)
    >>> last_hidden_states = outputs.last_hidden_state
    ```
)output_typer6  c                   Z    e Zd ZU eed<   ej        Zej        ed<   d Z	 	 	 	 	 dde	fdZ
dS )	&FlaxDinov2ForImageClassificationModuler   r   c           	          t          | j        | j                  | _        t	          j        | j        j        | j        t          j        j        	                    | j        j
        dz  dd                    | _        d S )Nr   r   r   r   )r   r"   )r@  r   r   r  r+   r   
num_labelsr.   r/   r0   r1   
classifierr   s    r4   r5   z,FlaxDinov2ForImageClassificationModule.setup  sm    &dkLLL(K"*+<<-q0(<N 
 
 
r6   NTr   c                 x   ||n| j         j        }|                     |||||          }|d         }|d d df         }|d d dd f         }	t          j        ||	                    d          gd          }
|                     |
          }|s|f|dd          z   }|S t          ||j        |j	                  S )Nr  r   r   rb   r8   r   )logitsrn   r  )
r   use_return_dictr  r;   rm   meanrQ  r   rn   r  )r3   r=   r   r   r  r  r   rn   rM   patch_tokenslinear_inputrS  r   s                r4   rB   z/FlaxDinov2ForImageClassificationModule.__call__  s     &1%<kk$+B]++'/!5#  
 
  
!!!!Q$'	$QQQU+	<3D3D!3D3L3L'MTVWWW.. 	Y,FM+!/)
 
 
 	
r6   )NTNNNr   rI   r6   r4   rN  rN    sy         {E39"""
 
 
 "!"
 "
 "
 "
 "
 "
 "
 "
r6   rN  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.
    c                       e Zd ZeZdS ) FlaxDinov2ForImageClassificationN)rD   rE   rF   rN  r  rI   r6   r4   rY  rY    s         :LLLr6   rY  a  
    Returns:

    Example:

    ```python
    >>> from transformers import AutoImageProcessor, FlaxDinov2ForImageClassification
    >>> from PIL import Image
    >>> import jax
    >>> import requests

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

    >>> image_processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base-imagenet1k-1-layer")
    >>> model = FlaxDinov2ForImageClassification.from_pretrained("facebook/dinov2-base-imagenet1k-1-layer", from_pt=True)

    >>> inputs = image_processor(images=image, return_tensors="np")
    >>> outputs = model(**inputs)
    >>> logits = outputs.logits

    >>> # model predicts one of the 1000 ImageNet classes
    >>> predicted_class_idx = jax.numpy.argmax(logits, axis=-1)
    >>> print("Predicted class:", model.config.id2label[predicted_class_idx.item()])
    ```
)rY  rK  r  )=r   collections.abcr&   re   typingr   
flax.linenlinenr+   r.   	jax.numpynumpyr;   flax.core.frozen_dictr   r   r   flax.linen.attentionr   flax.traverse_utilr   r	   modeling_flax_outputsr   r   r   modeling_flax_utilsr   r   r   r   utilsr   r   configuration_dinov2r   DINOV2_START_DOCSTRINGr;  r9  r   rK   r   r   r   rH   r   r   r   r   r   r   r   r  r  r@  rK  FLAX_VISION_MODEL_DOCSTRINGrN  rY  $FLAX_VISION_CLASSIFICATION_DOCSTRING__all__rI   r6   r4   <module>rk     sI                      



       > > > > > > > > > > > > > > > > ; ; ; ; ; ; ; ; v v v v v v v v v v            Q P P P P P P P . . . . . .! F "!C !C !C !C !C	 !C !C !CHR R R R R29 R R RlD D D D Dbi D D DP    29   *    ")   * .1[ * * * *, , , , ,29 , , ,"       *    BI   >( ( ( ( (") ( ( (<, , , , ,bi , , ,`(
 (
 (
 (
 (
	 (
 (
 (
X
 
 
 
 
	 
 
 
0N
 N
 N
 N
 N
 3 N
 N
 N
b(
 (
 (
 (
 (
ry (
 (
 (
V f $ $ $ $ $/ $ $	 $ ,  *E F F F    !?l   
0
 0
 0
 0
 0
RY 0
 0
 0
f   : : : : :'@ : : :( $6  9;_ ` ` `    $2N]i   
 _
^
^r6   