
     `i`                         d dl m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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' 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          Z/ G d( d)ej"                  Z0 ed*e            G d+ d,e/                      Z1d-Z2 ee1e2            ee1ee.            G d/ d0ej"                  Z3 G d1 d2ej"                  Z4 ed3e            G d4 d5e/                      Z5d6Z6 ee5e6            ee5ee.           g d7Z7dS )8    )partial)OptionalN)
FrozenDictfreezeunfreeze)flatten_dictunflatten_dict   )"FlaxBaseModelOutputWithNoAttention,FlaxBaseModelOutputWithPoolingAndNoAttention(FlaxImageClassifierOutputWithNoAttention)ACT2FNFlaxPreTrainedModel append_replace_return_docstringsoverwrite_call_docstring)add_start_docstrings%add_start_docstrings_to_model_forward   )ResNetConfiga  

    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 ([`ResNetConfig`]): 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`].
aA  
    Args:
        pixel_values (`jax.numpy.float32` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`AutoImageProcessor.__call__`] for details.
        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                   2    e Zd ZdZej        d             ZdS )IdentityzIdentity function.c                     |S N )selfxkwargss      /home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/models/resnet/modeling_flax_resnet.py__call__zIdentity.__call__\   s        N)__name__
__module____qualname____doc__nncompactr   r   r    r   r   r   Y   s5        Z  Z  r    r   c                       e Zd ZU eed<   dZeed<   dZeed<   dZee	         ed<   e
j        Ze
j        ed<   d	 Zdde
j        dede
j        fdZdS )FlaxResNetConvLayerout_channelsr
   kernel_sizer   striderelu
activationdtypec                 r   t          j        | j        | j        | j        f| j        | j        dz  | j        dt           j                            ddd| j                            | _        t          j	        dd	| j        
          | _
        | j        t          | j                 nt                      | _        d S )N   F       @fan_outnormal)modedistributionr.   )r*   stridespaddingr.   use_biaskernel_init?h㈵>momentumepsilonr.   )r%   Convr)   r*   r+   r.   initializersvariance_scalingconvolution	BatchNormnormalizationr-   r   r   activation_funcr   s    r   setupzFlaxResNetConvLayer.setuph   s    7)4+;<K$)*889[ckoku8vv
 
 
  \3TZXXX:>/:Uvdo66[c[e[er    Tr   deterministicreturnc                     |                      |          }|                     ||          }|                     |          }|S N)use_running_average)rB   rD   rE   r   r   rH   hidden_states       r   r   zFlaxResNetConvLayer.__call__u   sF    ''**)),M)ZZ++L99r    NT)r!   r"   r#   int__annotations__r*   r+   r-   r   strjnpfloat32r.   rG   ndarrayboolr   r   r    r   r(   r(   a   s         KFCOOO &J&&&{E39"""f f f #+ d ck      r    r(   c                   p    e Zd ZU dZeed<   ej        Zej        ed<   d Z	ddej
        dedej
        fd	Zd
S )FlaxResNetEmbeddingszO
    ResNet Embeddings (stem) composed of a single aggressive convolution.
    configr.   c                     t          | j        j        dd| j        j        | j                  | _        t          t          j        ddd          | _        d S )N   r0   )r*   r+   r-   r.   )r
   r
   )r0   r0   )r   r   r\   )window_shaper6   r7   )	r(   rY   embedding_size
hidden_actr.   embedderr   r%   max_poolrF   s    r   rG   zFlaxResNetEmbeddings.setup   sT    +K&{-*
 
 
  &&Zjkkkr    Tpixel_valuesrH   rI   c                     |j         d         }|| j        j        k    rt          d          |                     ||          }|                     |          }|S )NzeMake sure that the channel dimension of the pixel values match with the one set in the configuration.rH   )shaperY   num_channels
ValueErrorr`   ra   )r   rb   rH   rg   	embeddings        r   r   zFlaxResNetEmbeddings.__call__   sb    #)"-4;333w   MM,mMLL	MM),,	r    NrO   )r!   r"   r#   r$   r   rQ   rS   rT   r.   rG   rU   rV   r   r   r    r   rX   rX   |   s           {E39"""	l 	l 	l S[  QTQ\      r    rX   c                   ~    e Zd ZU dZeed<   dZeed<   ej        Z	ej	        ed<   d Z
ddej        d	ed
ej        fdZdS )FlaxResNetShortCutz
    ResNet shortcut, used to project the residual features to the correct size. If needed, it is also used to
    downsample the input using `stride=2`.
    r)   r0   r+   r.   c                     t          j        | j        d| j        dt           j                            ddd          | j                  | _        t          j        dd	| j        
          | _	        d S )Nr\   Fr1   r2   truncated_normal)r4   r5   )r*   r6   r8   r9   r.   r:   r;   r<   )
r%   r?   r)   r+   r@   rA   r.   rB   rC   rD   rF   s    r   rG   zFlaxResNetShortCut.setup   so    7K889[m8nn*
 
 
  \3TZXXXr    Tr   rH   rI   c                 ^    |                      |          }|                     ||          }|S rK   )rB   rD   rM   s       r   r   zFlaxResNetShortCut.__call__   s3    ''**)),M)ZZr    NrO   )r!   r"   r#   r$   rP   rQ   r+   rS   rT   r.   rG   rU   rV   r   r   r    r   rk   rk      s          
 FCOOO{E39"""	Y 	Y 	Y #+ d ck      r    rk   c                   z    e Zd ZU eed<   dZeed<   ej        Zej        ed<   d Z	ddej
        ded	ej
        fd
ZdS )FlaxResNetBasicLayerCollectionr)   r   r+   r.   c                     t          | j        | j        | j                  t          | j        d | j                  g| _        d S )Nr+   r.   )r-   r.   )r(   r)   r+   r.   layerrF   s    r   rG   z$FlaxResNetBasicLayerCollection.setup   s?     1$+TZXXX 1d$*UUU



r    TrN   rH   rI   c                 4    | j         D ]} |||          }|S Nre   rs   r   rN   rH   rs   s       r   r   z'FlaxResNetBasicLayerCollection.__call__   1    Z 	L 	LE 5]KKKLLr    NrO   )r!   r"   r#   rP   rQ   r+   rS   rT   r.   rG   rU   rV   r   r   r    r   rp   rp      s         FCOOO{E39"""
 
 
 S[  QTQ\      r    rp   c                       e Zd ZU dZeed<   eed<   dZeed<   dZee	         ed<   e
j        Ze
j        ed<   d	 ZddefdZdS )FlaxResNetBasicLayerzO
    A classic ResNet's residual layer composed by two `3x3` convolutions.
    in_channelsr)   r   r+   r,   r-   r.   c                 
   | j         | j        k    p
| j        dk    }|r!t          | j        | j        | j                  nd | _        t          | j        | j        | j                  | _        t          | j	                 | _
        d S )Nr   rr   )r)   r+   r.   )r{   r)   r+   rk   r.   shortcutrp   rs   r   r-   rE   r   should_apply_shortcuts     r   rG   zFlaxResNetBasicLayer.setup   s     $ 0D4E E YXYIY %t0DJWWWW 	
 4*;*
 
 


  &do6r    TrH   c                     |}|                      ||          }| j        |                     ||          }||z  }|                     |          }|S ru   )rs   r}   rE   r   rN   rH   residuals       r   r   zFlaxResNetBasicLayer.__call__   s\    zz,mzLL=$}}X]}KKH ++L99r    NrO   )r!   r"   r#   r$   rP   rQ   r+   r-   r   rR   rS   rT   r.   rG   rV   r   r   r    r   rz   rz      s           FCOOO &J&&&{E39"""7 7 7	 	D 	 	 	 	 	 	r    rz   c                       e Zd ZU eed<   dZeed<   dZee         ed<   dZ	eed<   e
j        Ze
j        ed<   d	 Zdde
j        dede
j        fdZdS )#FlaxResNetBottleNeckLayerCollectionr)   r   r+   r,   r-      	reductionr.   c           	          | j         | j        z  }t          |d| j        d          t          || j        | j        d          t          | j         dd | j        d          g| _        d S )Nr   0)r*   r.   name1)r+   r.   r   2)r*   r-   r.   r   )r)   r   r(   r.   r+   rs   )r   reduces_channelss     r   rG   z)FlaxResNetBottleNeckLayerCollection.setup   sq    ,>   0atzX[\\\ 0DJ]`aaa 1qTY]Ycjmnnn



r    TrN   rH   rI   c                 4    | j         D ]} |||          }|S ru   rv   rw   s       r   r   z,FlaxResNetBottleNeckLayerCollection.__call__   rx   r    NrO   )r!   r"   r#   rP   rQ   r+   r-   r   rR   r   rS   rT   r.   rG   rU   rV   r   r   r    r   r   r      s         FCOOO &J&&&Is{E39"""
 
 
 S[  QTQ\      r    r   c                       e Zd ZU dZeed<   eed<   dZeed<   dZee	         ed<   dZ
eed	<   ej        Zej        ed
<   d Zddej        dedej        fdZdS )FlaxResNetBottleNeckLayera$  
    A classic ResNet's bottleneck layer composed by three `3x3` convolutions. The first `1x1` convolution reduces the
    input by a factor of `reduction` in order to make the second `3x3` convolution faster. The last `1x1` convolution
    remaps the reduced features to `out_channels`.
    r{   r)   r   r+   r,   r-   r   r   r.   c                 "   | j         | j        k    p
| j        dk    }|r!t          | j        | j        | j                  nd | _        t          | j        | j        | j        | j        | j                  | _	        t          | j                 | _        d S )Nr   rr   )r+   r-   r   r.   )r{   r)   r+   rk   r.   r}   r   r-   r   rs   r   rE   r~   s     r   rG   zFlaxResNetBottleNeckLayer.setup  s     $ 0D4E E YXYIY %t0DJWWWW 	 9;n*
 
 

  &do6r    TrN   rH   rI   c                     |}| j         |                      ||          }|                     ||          }||z  }|                     |          }|S ru   )r}   rs   rE   r   s       r   r   z"FlaxResNetBottleNeckLayer.__call__!  sZ    =$}}X]}KKHzz,>> ++L99r    NrO   )r!   r"   r#   r$   rP   rQ   r+   r-   r   rR   r   rS   rT   r.   rG   rU   rV   r   r   r    r   r   r     s           FCOOO &J&&&Is{E39"""7 7 7$ S[  QTQ\      r    r   c                       e Zd ZU dZeed<   eed<   eed<   dZeed<   dZeed<   e	j
        Ze	j        ed<   d	 Zdde	j        dede	j        fdZdS )FlaxResNetStageLayersCollection4
    A ResNet stage composed by stacked layers.
    rY   r{   r)   r0   r+   depthr.   c                 |   | j         j        dk    rt          nt          } || j        | j        | j        | j         j        | j        d          g}t          | j
        dz
            D ]N}|                     || j        | j        | j         j        | j        t          |dz                                  O|| _        d S )N
bottleneckr   )r+   r-   r.   r   r   )r-   r.   r   )rY   
layer_typer   rz   r{   r)   r+   r_   r.   ranger   appendrR   layers)r   rs   r   is       r   rG   z%FlaxResNetStageLayersCollection.setup8  s    -1[-C|-S-S))Ym E !{;1j  

 tzA~&& 		 		AMM%%#{5*QU      r    Tr   rH   rI   c                 8    |}| j         D ]} |||          }|S ru   r   )r   r   rH   rN   rs   s        r   r   z(FlaxResNetStageLayersCollection.__call__T  s6    [ 	L 	LE 5]KKKLLr    NrO   r!   r"   r#   r$   r   rQ   rP   r+   r   rS   rT   r.   rG   rU   rV   r   r   r    r   r   r   ,  s           FCOOOE3NNN{E39"""  8 #+ d ck      r    r   c                       e Zd ZU dZeed<   eed<   eed<   dZeed<   dZeed<   e	j
        Ze	j        ed<   d	 Zdde	j        dede	j        fdZdS )FlaxResNetStager   rY   r{   r)   r0   r+   r   r.   c                 v    t          | j        | j        | j        | j        | j        | j                  | _        d S )N)r{   r)   r+   r   r.   )r   rY   r{   r)   r+   r   r.   r   rF   s    r   rG   zFlaxResNetStage.setupg  s<    5K(*;**
 
 
r    Tr   rH   rI   c                 0    |                      ||          S ru   r   )r   r   rH   s      r   r   zFlaxResNetStage.__call__q  s    {{1M{:::r    NrO   r   r   r    r   r   r   [  s           FCOOOE3NNN{E39"""
 
 
; ;#+ ;d ;ck ; ; ; ; ; ;r    r   c            	       j    e Zd ZU eed<   ej        Zej        ed<   d Z	 	 ddej	        de
de
d	efd
ZdS )FlaxResNetStageCollectionrY   r.   c                    t          | j        j        | j        j        dd                    }t          | j        | j        j        | j        j        d         | j        j        rdnd| j        j        d         | j        d          g}t          t          || j        j        dd                              D ]M\  }\  \  }}}|	                    t          | j        |||| j        t          |dz                                  N|| _        d S )Nr   r   r0   r   )r+   r   r.   r   )r   r.   r   )ziprY   hidden_sizesr   r^   downsample_in_first_stagedepthsr.   	enumerater   rR   stages)r   in_out_channelsr   r   r{   r)   r   s          r   rG   zFlaxResNetStageCollection.setupy  s   dk68PQRQSQS8TUU*(+ KAHqqqk(+j  

 8A_VZVaVhijikikVlAmAm7n7n 	 	3A3+lUMM[,e[_[elopqtupulvlvwww    r    FTrN   output_hidden_statesrH   rI   c                     |rdnd }| j         D ]-}|r||                    dddd          fz   } |||          }.||fS )Nr   r   r
   r   r0   re   )r   	transpose)r   rN   r   rH   hidden_statesstage_modules         r   r   z"FlaxResNetStageCollection.__call__  sq     3< K 	S 	SL# V -1G1G1aQR1S1S0U U'<MRRRLL]**r    N)FTr!   r"   r#   r   rQ   rS   rT   r.   rG   rU   rV   r   r   r   r    r   r   r   u  s         {E39"""  0 &+"	+ +k+ #+ 	+
 
,+ + + + + +r    r   c                   p    e Zd ZU eed<   ej        Zej        ed<   d Z	 	 	 ddej	        de
de
d	e
d
ef
dZdS )FlaxResNetEncoderrY   r.   c                 F    t          | j        | j                  | _        d S )Nr.   )r   rY   r.   r   rF   s    r   rG   zFlaxResNetEncoder.setup  s    /4:NNNr    FTrN   r   return_dictrH   rI   c                     |                      |||          \  }}|r||                    dddd          fz   }|st          d ||fD                       S t          ||          S )N)r   rH   r   r
   r   r0   c              3      K   | ]}||V  	d S r   r   ).0vs     r   	<genexpr>z-FlaxResNetEncoder.__call__.<locals>.<genexpr>  s"      SSqQ]]]]]SSr    )last_hidden_stater   )r   r   tupler   )r   rN   r   r   rH   r   s         r   r   zFlaxResNetEncoder.__call__  s     '+kk/CS` '2 '
 '
#m   	R)\-C-CAq!Q-O-O,QQM 	TSS\=$ASSSSSS1*'
 
 
 	
r    N)FTTr   r   r    r   r   r     s         {E39"""O O O &+ "
 
k
 #
 	

 
 
,
 
 
 
 
 
r    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ee         dedee         dee         fd            Z xZS )FlaxResNetPreTrainedModelz
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    resnetrb   Nmodule_class)r      r   r
   r   TrY   seedr.   _do_initc                      | j         d||d|}|d|j        |j        |j        f}t                                          ||||||           d S )NrY   r.   r   )input_shaper   r.   r   r   )r   
image_sizerg   super__init__)	r   rY   r   r   r.   r   r   module	__class__s	           r   r   z"FlaxResNetPreTrainedModel.__init__  sn     #"H&HHHHf/1BFDWXK[tSXcklllllr    rngr   paramsrI   c                 z   t          j        || j                  }d|i}| j                            ||d          }||t          t          |                    }t          t          |                    }| j        D ]}||         ||<   t                      | _        t          t          |                    S |S )Nr   r   F)r   )rS   zerosr.   r   initr   r   _missing_keyssetr   r	   )r   r   r   r   rb   rngsrandom_paramsmissing_keys           r   init_weightsz&FlaxResNetPreTrainedModel.init_weights  s    yDJ???#((|(OO(-)@)@AAM!(6"2"233F#1 A A&3K&@{##!$D.00111  r    Ftrainr   r   c           	      T   ||n| j         j        }||n| j         j        }t          j        |d          }i }| j                            ||d         n| j        d         ||d         n| j        d         dt          j        |t          j	                  | ||||rdgnd          S )N)r   r0   r
   r   r   batch_stats)r   r   r   F)r   mutable)
rY   r   r   rS   r   r   applyr   arrayrT   )r   rb   r   r   r   r   r   s          r   r   z"FlaxResNetPreTrainedModel.__call__  s     %9$D  $+Jj 	 &1%<kk$+BY}\<@@ {  .4.@&**dkRZF[8>8Jvm44PTP[\iPj  Il#+666I ',7]OO% ! 
 
 	
r    r   )NFNN)r!   r"   r#   r$   r   config_classbase_model_prefixmain_input_namer   r%   ModulerQ   rS   rT   rP   r.   rV   r   jaxrandomPRNGKeyr   r   r   r   RESNET_INPUTS_DOCSTRINGr   dictr   __classcell__)r   s   @r   r   r     sf         
  L $O"L")"""
 %;m mm 	m
 ym m m m m m m! !
 2 ! !PZ !fp ! ! ! !$ +*+BCC "&/3&*
 
 
 	

 'tn
 d^
 
 
 DC
 
 
 
 
r    r   c            	       b    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 )FlaxResNetModulerY   r.   c                     t          | j        | j                  | _        t	          | j        | j                  | _        t          t          j        d          | _	        d S )Nr   )r   r   r   )r7   )
rX   rY   r.   r`   r   encoderr   r%   avg_poolpoolerrF   s    r   rG   zFlaxResNetModule.setup  sV    ,T[
KKK(DJGGG K$
 
 
r    TFrH   r   r   rI   c                    ||n| j         j        }||n| j         j        }|                     ||          }|                     ||||          }|d         }|                     ||j        d         |j        d         f|j        d         |j        d         f                              dddd          }|                    dddd          }|s||f|dd          z   S t          |||j	                  S )	Nre   )r   r   rH   r   r   r0   )r]   r6   r
   )r   pooler_outputr   )
rY   r   use_return_dictr`   r   r   rf   r   r   r   )	r   rb   rH   r   r   embedding_outputencoder_outputsr   pooled_outputs	            r   r   zFlaxResNetModule.__call__  s>    %9$D  $+Jj 	 &1%<kk$+B]==]=SS,,!5#'	 ' 
 
 ,A.+1!46G6Ma6PQ&,Q/1B1H1KL $ 
 
 )Aq!Q

	 	 .771aCC 	L%}58KKK;/')7
 
 
 	
r    N)TFT)r!   r"   r#   r   rQ   rS   rT   r.   rG   rV   r   r   r   r    r   r   r   	  s         {E39"""
 
 
 #%* &
 &
 &
 #	&

 &
 
6&
 &
 &
 &
 &
 &
r    r   zOThe bare ResNet model outputting raw features without any specific head on top.c                       e Zd ZeZdS )FlaxResNetModelN)r!   r"   r#   r   r   r   r    r   r   r   @  s        
 $LLLr    r   an  
    Returns:

    Examples:

    ```python
    >>> from transformers import AutoImageProcessor, FlaxResNetModel
    >>> 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("microsoft/resnet-50")
    >>> model = FlaxResNetModel.from_pretrained("microsoft/resnet-50")
    >>> inputs = image_processor(images=image, return_tensors="np")
    >>> outputs = model(**inputs)
    >>> last_hidden_states = outputs.last_hidden_state
    ```
)output_typer   c                   f    e Zd ZU eed<   ej        Zej        ed<   d Zdej	        dej	        fdZ
dS )FlaxResNetClassifierCollectionrY   r.   c                 \    t          j        | j        j        | j        d          | _        d S )Nr   )r.   r   )r%   DenserY   
num_labelsr.   
classifierrF   s    r   rG   z$FlaxResNetClassifierCollection.setupf  s&    (4;#9RUVVVr    r   rI   c                 ,    |                      |          S r   )r   )r   r   s     r   r   z'FlaxResNetClassifierCollection.__call__i  s    q!!!r    N)r!   r"   r#   r   rQ   rS   rT   r.   rG   rU   r   r   r    r   r   r   b  sn         {E39"""W W W"#+ "#+ " " " " " "r    r   c                   X    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 )	&FlaxResNetForImageClassificationModulerY   r.   c                     t          | j        | j                  | _        | j        j        dk    r"t          | j        | j                  | _        d S t                      | _        d S )Nr   r   r   )r   rY   r.   r   r   r   r   r   rF   s    r   rG   z,FlaxResNetForImageClassificationModule.setupq  sW    &dkLLL;!A%%<T[PTPZ[[[DOOO&jjDOOOr    NTrH   c                    ||n| j         j        }|                     ||||          }|r|j        n|d         }|                     |d d d d ddf                   }|s|f|dd          z   }|S t          ||j                  S )N)rH   r   r   r   r   r0   )logitsr   )rY   r   r   r   r   r   r   )	r   rb   rH   r   r   outputsr   r  outputs	            r   r   z/FlaxResNetForImageClassificationModule.__call__y  s     &1%<kk$+B]++'!5#	  
 
 2=L--'!*qqq!!!Qz!:;; 	Y,FM7vU\Ujkkkkr    )NTNN)r!   r"   r#   r   rQ   rS   rT   r.   rG   rV   r   r   r    r   r  r  m  s~         {E39""") ) ) "!l l l l l l l lr    r  z
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    c                       e Zd ZeZdS ) FlaxResNetForImageClassificationN)r!   r"   r#   r  r   r   r    r   r	  r	    s         :LLLr    r	  a]  
    Returns:

    Example:

    ```python
    >>> from transformers import AutoImageProcessor, FlaxResNetForImageClassification
    >>> 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("microsoft/resnet-50")
    >>> model = FlaxResNetForImageClassification.from_pretrained("microsoft/resnet-50")

    >>> 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()])
    ```
)r	  r   r   )8	functoolsr   typingr   
flax.linenlinenr%   r   	jax.numpynumpyrS   flax.core.frozen_dictr   r   r   flax.traverse_utilr   r	   modeling_flax_outputsr   r   r   modeling_flax_utilsr   r   r   r   utilsr   r   configuration_resnetr   RESNET_START_DOCSTRINGr   r   r   r(   rX   rk   rp   rz   r   r   r   r   r   r   r   r   r   FLAX_VISION_MODEL_DOCSTRINGr   r  r	  FLAX_VISION_CLASSIF_DOCSTRING__all__r   r    r   <module>r     sC                      



       > > > > > > > > > > ; ; ; ; ; ; ; ;         
            Q P P P P P P P . . . . . .! H
     ry       ")   6    29   <       6    RY   "" " " " "29 " " "J    ")   ,( ( ( ( (	 ( ( (V, , , , ,bi , , ,^; ; ; ; ;bi ; ; ;4'+ '+ '+ '+ '+	 '+ '+ '+T
 
 
 
 
	 
 
 
<I
 I
 I
 I
 I
 3 I
 I
 I
X4
 4
 4
 4
 4
ry 4
 4
 4
n U $ $ $ $ $/ $ $	 $ (  *E F F F    !M\h   
" " " " "RY " " "$l $l $l $l $lRY $l $l $lN   : : : : :'@ : : :! 6  9;X Y Y Y    $2Ziu   
 _
^
^r    