
    sgE                        d Z ddlZddlmZ ddlZddlZddlmZmZ ddlm	Z	m
Z
mZ ddlmZ ddlmZmZmZ dd	lmZmZmZ dd
lmZ ddlmZ ddlmZ  ej8                  e      ZdZdZ g dZ!dZ"dZ# G d dejH                        Z% G d dejH                        Z& G d dejH                        Z' G d dejH                        Z( G d dejH                        Z) G d dejH                        Z* G d dejH                        Z+ G d  d!ejH                        Z, G d" d#e      Z-d$Z.d%Z/ ed&e.       G d' d(e-             Z0 ed)e.       G d* d+e-             Z1y),zPyTorch RegNet model.    N)Optional)Tensornn)BCEWithLogitsLossCrossEntropyLossMSELoss   )ACT2FN)add_code_sample_docstringsadd_start_docstrings%add_start_docstrings_to_model_forward)BaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)logging   )RegNetConfigr   zfacebook/regnet-y-040)r   i@     r   ztabby, tabby catc                   N     e Zd Z	 	 	 	 d	dedededededee   f fdZd Z xZS )
RegNetConvLayerin_channelsout_channelskernel_sizestridegroups
activationc           	          t         |           t        j                  |||||dz  |d      | _        t        j
                  |      | _        |t        |   | _	        y t        j                         | _	        y )N   F)r   r   paddingr   bias)
super__init__r   Conv2dconvolutionBatchNorm2dnormalizationr
   Identityr   )selfr   r   r   r   r   r   	__class__s          ]/var/www/html/venv/lib/python3.12/site-packages/transformers/models/regnet/modeling_regnet.pyr#   zRegNetConvLayer.__init__4   sk     	99#1$
  ^^L90:0F&,BKKM    c                 l    | j                  |      }| j                  |      }| j                  |      }|S N)r%   r'   r   r)   hidden_states     r+   forwardzRegNetConvLayer.forwardJ   s6    ''5)),7|4r,   )r	   r   r   relu)	__name__
__module____qualname__intr   strr#   r1   __classcell__r*   s   @r+   r   r   3   s`    
 $*ZZ Z 	Z
 Z Z SMZ,r,   r   c                   .     e Zd ZdZdef fdZd Z xZS )RegNetEmbeddingszP
    RegNet Embedddings (stem) composed of a single aggressive convolution.
    configc                     t         |           t        |j                  |j                  dd|j
                        | _        |j                  | _        y )Nr	   r   )r   r   r   )r"   r#   r   num_channelsembedding_size
hidden_actembedderr)   r<   r*   s     r+   r#   zRegNetEmbeddings.__init__V   sH    '!6!6Aa\b\m\m
 #//r,   c                 z    |j                   d   }|| j                  k7  rt        d      | j                  |      }|S )Nr   zeMake sure that the channel dimension of the pixel values match with the one set in the configuration.)shaper>   
ValueErrorrA   )r)   pixel_valuesr>   r0   s       r+   r1   zRegNetEmbeddings.forward]   sF    #))!,4,,,w  }}\2r,   )r3   r4   r5   __doc__r   r#   r1   r8   r9   s   @r+   r;   r;   Q   s    0| 0r,   r;   c                   B     e Zd ZdZd	dededef fdZdedefdZ xZS )
RegNetShortCutz
    RegNet 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   r   r   c                     t         |           t        j                  ||d|d      | _        t        j
                  |      | _        y )Nr   F)r   r   r!   )r"   r#   r   r$   r%   r&   r'   )r)   r   r   r   r*   s       r+   r#   zRegNetShortCut.__init__n   s:    99[,AV\chi^^L9r,   inputreturnc                 J    | j                  |      }| j                  |      }|S r.   )r%   r'   )r)   rK   r0   s      r+   r1   zRegNetShortCut.forwards   s(    ''.)),7r,   )r   )	r3   r4   r5   rG   r6   r#   r   r1   r8   r9   s   @r+   rI   rI   h   s5    
:C :s :C :
V  r,   rI   c                   2     e Zd ZdZdedef fdZd Z xZS )RegNetSELayerz|
    Squeeze and Excitation layer (SE) proposed in [Squeeze-and-Excitation Networks](https://arxiv.org/abs/1709.01507).
    r   reduced_channelsc           	      0   t         |           t        j                  d      | _        t        j
                  t        j                  ||d      t        j                         t        j                  ||d      t        j                               | _	        y )Nr   r   r   )r   )
r"   r#   r   AdaptiveAvgPool2dpooler
Sequentialr$   ReLUSigmoid	attention)r)   r   rP   r*   s      r+   r#   zRegNetSELayer.__init__~   sd    **62IIk#3CGGIII&CJJL	
r,   c                 T    | j                  |      }| j                  |      }||z  }|S r.   )rT   rX   )r)   r0   pooledrX   s       r+   r1   zRegNetSELayer.forward   s.    \*NN6*	#i/r,   )r3   r4   r5   rG   r6   r#   r1   r8   r9   s   @r+   rO   rO   y   s     	
C 	
3 	
r,   rO   c            	       <     e Zd ZdZddedededef fdZd Z xZS )	RegNetXLayerzt
    RegNet's layer composed by three `3x3` convolutions, same as a ResNet bottleneck layer with reduction = 1.
    r<   r   r   r   c           
         t         |           ||k7  xs |dk7  }t        d||j                  z        }|rt	        |||      nt        j                         | _        t        j                  t        ||d|j                        t        |||||j                        t        ||dd             | _        t        |j                     | _        y )Nr   r   r   r   r   r   r   )r"   r#   maxgroups_widthrI   r   r(   shortcutrU   r   r@   layerr
   r   r)   r<   r   r   r   should_apply_shortcutr   r*   s          r+   r#   zRegNetXLayer.__init__   s     +| ; Jv{Q(;(;;<H]N;VDcecncncp 	 ]]K1QWQbQbcL,vfagararsL,ARVW


 !!2!23r,   c                 z    |}| j                  |      }| j                  |      }||z  }| j                  |      }|S r.   rd   rc   r   r)   r0   residuals      r+   r1   zRegNetXLayer.forward   A    zz,/==* |4r,   r   	r3   r4   r5   rG   r   r6   r#   r1   r8   r9   s   @r+   r\   r\      s/    4| 4# 4S 4Z] 4r,   r\   c            	       <     e Zd ZdZddedededef fdZd Z xZS )	RegNetYLayerzC
    RegNet's Y layer: an X layer with Squeeze and Excitation.
    r<   r   r   r   c                    t         |           ||k7  xs |dk7  }t        d||j                  z        }|rt	        |||      nt        j                         | _        t        j                  t        ||d|j                        t        |||||j                        t        |t        t        |dz                    t        ||dd             | _        t        |j                     | _        y )Nr   r^   r_   r`      )rP   )r"   r#   ra   rb   rI   r   r(   rc   rU   r   r@   rO   r6   roundrd   r
   r   re   s          r+   r#   zRegNetYLayer.__init__   s     +| ; Jv{Q(;(;;<H]N;VDcecncncp 	 ]]K1QWQbQbcL,vfagarars,U;QR?=S9TUL,ARVW	

 !!2!23r,   c                 z    |}| j                  |      }| j                  |      }||z  }| j                  |      }|S r.   rh   ri   s      r+   r1   zRegNetYLayer.forward   rk   r,   rl   rm   r9   s   @r+   ro   ro      s/    4| 4# 4S 4Z] 4r,   ro   c                   D     e Zd ZdZ	 	 d	dededededef
 fdZd Z xZS )
RegNetStagez4
    A RegNet stage composed by stacked layers.
    r<   r   r   r   depthc                     t         |           |j                  dk(  rt        nt        }t        j                   |||||      gt        |dz
        D cg c]  } ||||       c} | _        y c c}w )Nxr^   r   )	r"   r#   
layer_typer\   ro   r   rU   rangelayers)	r)   r<   r   r   r   rv   rd   _r*   s	           r+   r#   zRegNetStage.__init__   sw     	 & 1 1S 8lmm		
 BGuqyAQRAeFL,7R	
 Ss   A3
c                 (    | j                  |      }|S r.   )r{   r/   s     r+   r1   zRegNetStage.forward   s    {{<0r,   )r   r   rm   r9   s   @r+   ru   ru      sJ     

 
 	

 
 
.r,   ru   c            	       @     e Zd Zdef fdZ	 ddedededefdZ xZ	S )	RegNetEncoderr<   c           
         t         |           t        j                  g       | _        | j                  j                  t        ||j                  |j                  d   |j                  rdnd|j                  d                t        |j                  |j                  dd        }t        ||j                  dd        D ]0  \  \  }}}| j                  j                  t        ||||             2 y )Nr   r   r   )r   rv   )rv   )r"   r#   r   
ModuleListstagesappendru   r?   hidden_sizesdownsample_in_first_stagedepthszip)r)   r<   in_out_channelsr   r   rv   r*   s         r+   r#   zRegNetEncoder.__init__   s    mmB'%%##A&"<<q!mmA&	
 f1163F3Fqr3JK25ov}}UVUWGX2Y 	\.'[,KK{6;TYZ[	\r,   r0   output_hidden_statesreturn_dictrL   c                     |rdnd }| j                   D ]  }|r||fz   } ||      } |r||fz   }|st        d ||fD              S t        ||      S )N c              3   &   K   | ]	  }||  y wr.   r   ).0vs     r+   	<genexpr>z(RegNetEncoder.forward.<locals>.<genexpr>  s     SqQ]Ss   )last_hidden_statehidden_states)r   tupler   )r)   r0   r   r   r   stage_modules         r+   r1   zRegNetEncoder.forward   sq     3 KK 	6L# - ?'5L		6  )\O;MS\=$ASSS-\ijjr,   )FT)
r3   r4   r5   r   r#   r   boolr   r1   r8   r9   s   @r+   r   r      sB    \| \$ ]ak"k:>kUYk	'kr,   r   c                   (    e Zd ZdZeZdZdZdgZd Z	y)RegNetPreTrainedModelz
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    regnetrF   ro   c                 J   t        |t        j                        r-t        j                  j	                  |j
                  dd       y t        |t        j                        rt        j                  j                  |j
                  t        j                  d             |j                  xt        j                  j                  |j
                        \  }}|dkD  rdt        j                  |      z  nd}t        j                  j                  |j                  | |       y y t        |t        j                  t        j                  f      rUt        j                  j                  |j
                  d       t        j                  j                  |j                  d       y y )Nfan_outr2   )modenonlinearity   )ar   r   )
isinstancer   r$   initkaiming_normal_weightLinearkaiming_uniform_mathsqrtr!   _calculate_fan_in_and_fan_outuniform_r&   	GroupNorm	constant_)r)   modulefan_inr|   bounds        r+   _init_weightsz#RegNetPreTrainedModel._init_weights  s   fbii(GG##FMM	PV#W		*GG$$V]]diil$C{{&GGAA&--P	17!DIIf--  ufe< '  >?GGfmmQ/GGfkk1- @r,   N)
r3   r4   r5   rG   r   config_classbase_model_prefixmain_input_name_no_split_modulesr   r   r,   r+   r   r     s'    
  L $O'(.r,   r   aI  
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
    as a regular PyTorch Module and refer to the PyTorch documentation for all matters related to general usage and
    behavior.

    Parameters:
        config ([`RegNetConfig`]): 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 [`~PreTrainedModel.from_pretrained`] method to load the model weights.
aK  
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__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 [`~file_utils.ModelOutput`] instead of a plain tuple.
zOThe bare RegNet model outputting raw features without any specific head on top.c                   |     e Zd Z fdZ ee       eeee	de
      	 d	dedee   dee   defd              Z xZS )
RegNetModelc                     t         |   |       || _        t        |      | _        t        |      | _        t        j                  d      | _	        | j                          y )NrR   )r"   r#   r<   r;   rA   r   encoderr   rS   rT   	post_initrB   s     r+   r#   zRegNetModel.__init__K  sK     (0$V,**62r,   vision)
checkpointoutput_typer   modalityexpected_outputrF   r   r   rL   c                 (   ||n| j                   j                  }||n| j                   j                  }| j                  |      }| j	                  |||      }|d   }| j                  |      }|s
||f|dd  z   S t        |||j                        S )Nr   r   r   r   )r   pooler_outputr   )r<   r   use_return_dictrA   r   rT   r   r   )r)   rF   r   r   embedding_outputencoder_outputsr   pooled_outputs           r+   r1   zRegNetModel.forwardT  s     %9$D $++JjJj 	 &1%<k$++B]B]==6,,3GU` ' 
 ,A.$56%}58KKK7/')77
 	
r,   )NN)r3   r4   r5   r#   r   REGNET_INPUTS_DOCSTRINGr   _CHECKPOINT_FOR_DOCr   _CONFIG_FOR_DOC_EXPECTED_OUTPUT_SHAPEr   r   r   r1   r8   r9   s   @r+   r   r   E  sp     ++BC&<$. pt
"
:B4.
^fgk^l
	1
 D
r,   r   z
    RegNet 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 fdZ ee       eeee	e
      	 	 	 	 d	deej                     deej                     dee   dee   def
d              Z xZS )
RegNetForImageClassificationc                 |   t         |   |       |j                  | _        t        |      | _        t        j                  t        j                         |j                  dkD  r-t        j                  |j                  d   |j                        nt        j                               | _        | j                          y )Nr   )r"   r#   
num_labelsr   r   r   rU   Flattenr   r   r(   
classifierr   rB   s     r+   r#   z%RegNetForImageClassification.__init__  s      ++!&)--JJLEKEVEVYZEZBIIf))"-v/@/@A`b`k`k`m

 	r,   )r   r   r   r   rF   labelsr   r   rL   c                    ||n| j                   j                  }| j                  |||      }|r|j                  n|d   }| j	                  |      }d}|| j                   j
                  | j                  dk(  rd| j                   _        nl| j                  dkD  rL|j                  t        j                  k(  s|j                  t        j                  k(  rd| j                   _        nd| j                   _        | j                   j
                  dk(  rIt               }	| j                  dk(  r& |	|j                         |j                               }n |	||      }n| j                   j
                  dk(  r=t               }	 |	|j                  d| j                        |j                  d            }n,| j                   j
                  dk(  rt               }	 |	||      }|s|f|dd z   }
||f|
z   S |
S t!        |||j"                  	      S )
a0  
        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 classification loss is computed (Cross-Entropy).
        Nr   r   
regressionsingle_label_classificationmulti_label_classificationr   r   )losslogitsr   )r<   r   r   r   r   problem_typer   dtypetorchlongr6   r   squeezer   viewr   r   r   )r)   rF   r   r   r   outputsr   r   r   loss_fctoutputs              r+   r1   z$RegNetForImageClassification.forward  s   & &1%<k$++B]B]++lAUcn+o1<--'!*/{{''/??a'/;DKK,__q(fllejj.HFLL\a\e\eLe/LDKK,/KDKK,{{''<7"9??a'#FNN$4fnn6FGD#FF3D))-JJ+-B @&++b/R))-II,./Y,F'+'7D7V#CVC3f\c\q\qrrr,   )NNNN)r3   r4   r5   r#   r   r   r   _IMAGE_CLASS_CHECKPOINTr   r   _IMAGE_CLASS_EXPECTED_OUTPUTr   r   FloatTensor
LongTensorr   r1   r8   r9   s   @r+   r   r   x  s    
 ++BC*8$4	 59-1/3&*/su001/s ))*/s 'tn	/s
 d^/s 
./s D/sr,   r   )2rG   r   typingr   r   torch.utils.checkpointr   r   torch.nnr   r   r   activationsr
   
file_utilsr   r   r   modeling_outputsr   r   r   modeling_utilsr   utilsr   configuration_regnetr   
get_loggerr3   loggerr   r   r   r   r   Moduler   r;   rI   rO   r\   ro   ru   r   r   REGNET_START_DOCSTRINGr   r   r   r   r,   r+   <module>r      sm         A A ! q q 
 .  . 
		H	% ! . (  2 1 bii <ryy .RYY "BII 0299 8299 :")) B#kBII #kL.O .6	   U
+
' +

+
\  Cs#8 CsCsr,   