
    hV7                     f   d Z ddlZddlmZ ddlZddlmZm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  ej(                  e      Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Ze G d de             Z e G d de              Z! ed !       G d" d#e              Z"g d$Z#y)%zPyTorch RegNet model.    N)Optional)Tensornn   )ACT2FN)BaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)auto_docstringlogging   )RegNetConfigc                   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          i/var/www/html/aiagenthome/venv/lib/python3.12/site-packages/transformers/models/regnet/modeling_regnet.pyr   zRegNetConvLayer.__init__&   sk     	99#1$
  ^^L90:0F&,BKKM    c                 l    | j                  |      }| j                  |      }| j                  |      }|S N)r   r!   r   r#   hidden_states     r%   forwardzRegNetConvLayer.forward<   s6    ''5)),7|4r&   )r   r   r   relu)	__name__
__module____qualname__intr   strr   r+   __classcell__r$   s   @r%   r   r   %   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 )RegNetEmbeddingszO
    RegNet Embeddings (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#   r6   r$   s     r%   r   zRegNetEmbeddings.__init__H   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.)shaper8   
ValueErrorr;   )r#   pixel_valuesr8   r*   s       r%   r+   zRegNetEmbeddings.forwardO   sF    #))!,4,,,w  }}\2r&   )r-   r.   r/   __doc__r   r   r+   r2   r3   s   @r%   r5   r5   C   s    0| 0r&   r5   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__`   s:    99[,AV\chi^^L9r&   inputreturnc                 J    | j                  |      }| j                  |      }|S r(   )r   r!   )r#   rE   r*   s      r%   r+   zRegNetShortCut.forwarde   s(    ''.)),7r&   )r   )	r-   r.   r/   rA   r0   r   r   r+   r2   r3   s   @r%   rC   rC   Z   s5    
:C :s :C :
V  r&   rC   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://huggingface.co/papers/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   rJ   r$   s      r%   r   zRegNetSELayer.__init__p   sd    **62IIk#3CGGIII&CJJL	
r&   c                 T    | j                  |      }| j                  |      }||z  }|S r(   )rN   rR   )r#   r*   pooledrR   s       r%   r+   zRegNetSELayer.forward{   s.    \*NN6*	#i/r&   )r-   r.   r/   rA   r0   r   r+   r2   r3   s   @r%   rI   rI   k   s     	
C 	
3 	
r&   rI   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.
    r6   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_widthrC   r   r"   shortcutrO   r   r:   layerr   r   r#   r6   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(   r^   r]   r   r#   r*   residuals      r%   r+   zRegNetXLayer.forward   A    zz,/==* |4r&   r   	r-   r.   r/   rA   r   r0   r   r+   r2   r3   s   @r%   rV   rV      s/    4| 4# 4S 4Z] 4r&   rV   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.
    r6   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   rX   rY   rZ      )rJ   )r   r   r[   r\   rC   r   r"   r]   rO   r   r:   rI   r0   roundr^   r   r   r_   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(   rb   rc   s      r%   r+   zRegNetYLayer.forward   re   r&   rf   rg   r3   s   @r%   ri   ri      s/    4| 4# 4S 4Z] 4r&   ri   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.
    r6   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xrX   r   )	r   r   
layer_typerV   ri   r   rO   rangelayers)	r#   r6   r   r   r   rp   r^   _r$   s	           r%   r   zRegNetStage.__init__   s}     	 & 1 1S 8lmm		
 BGuqyAQRAQAeFL,7AQR	
 Ss   A3
c                 (    | j                  |      }|S r(   )ru   r)   s     r%   r+   zRegNetStage.forward   s    {{<0r&   )r   r   rg   r3   s   @r%   ro   ro      sJ     

 
 	

 
 
.r&   ro   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 )	RegNetEncoderr6   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   rp   )rp   )r   r   r   
ModuleListstagesappendro   r9   hidden_sizesdownsample_in_first_stagedepthszip)r#   r6   in_out_channelsr   r   rp   r$   s         r%   r   zRegNetEncoder.__init__   s    mmB'%%##A&"<<q!mmA&	
 f1163F3Fqr3JK25ov}}UVUWGX2Y.'[,KK{6;TYZ[ 3Zr&   r*   output_hidden_statesreturn_dictrF   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     S$AqQ]$As   )last_hidden_statehidden_states)r|   tupler   )r#   r*   r   r   r   stage_modules         r%   r+   zRegNetEncoder.forward   sl     3 KKL# - ?'5L	 (  )\O;MS\=$ASSS-\ijjr&   )FT)
r-   r.   r/   r   r   r   boolr   r+   r2   r3   s   @r%   ry   ry      sB    \| \$ ]ak"k:>kUYk	'kr&   ry   c                   ,    e Zd ZU eed<   dZdZdgZd Zy)RegNetPreTrainedModelr6   regnetr@   ri   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_outr,   )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_inrv   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)	r-   r.   r/   r   __annotations__base_model_prefixmain_input_name_no_split_modulesr   r   r&   r%   r   r     s!     $O'(.r&   r   c            
       P     e Zd Z fdZ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 )NrL   )r   r   r6   r5   r;   ry   encoderr   rM   rN   	post_initr<   s     r%   r   zRegNetModel.__init__  sK     (0$V,**62r&   r@   r   r   rF   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   )r6   r   use_return_dictr;   r   rN   r	   r   )r#   r@   r   r   embedding_outputencoder_outputsr   pooled_outputs           r%   r+   zRegNetModel.forward&  s    
 %9$D $++JjJj 	 &1%<k$++B]B]==6,,3GU` ' 
 ,A.$56%}58KKK7/')77
 	
r&   )NN)r-   r.   r/   r   r   r   r   r   r	   r+   r2   r3   s   @r%   r   r     sI     os
"
:B4.
^fgk^l
	1
 
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.
    )custom_introc                        e Zd Z fdZ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   rO   Flattenr   r~   r"   
classifierr   r<   s     r%   r   z%RegNetForImageClassification.__init__K  s      ++!&)--JJLEKEVEVYZEZBIIf))"-v/@/@A`b`k`k`m

 	r&   r@   labelsr   r   rF   c                 B   ||n| j                   j                  }| j                  |||      }|r|j                  n|d   }| j	                  |      }d}|| j                  ||| j                         }|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   r   )losslogitsr   )r6   r   r   r   r   loss_functionr
   r   )
r#   r@   r   r   r   outputsr   r   r   outputs
             r%   r+   z$RegNetForImageClassification.forwardW  s     &1%<k$++B]B]++lAUcn+o1<--'!*/%%ffdkkBDY,F'+'7D7V#CVC3f\c\q\qrrr&   )NNNN)r-   r.   r/   r   r   r   torchFloatTensor
LongTensorr   r
   r+   r2   r3   s   @r%   r   r   C  s    
  59-1/3&*su001s ))*s 'tn	s
 d^s 
.s sr&   r   )r   r   r   )$rA   r   typingr   r   r   r   activationsr   modeling_outputsr   r	   r
   modeling_utilsr   utilsr   r   configuration_regnetr   
get_loggerr-   loggerModuler   r5   rC   rI   rV   ri   ro   ry   r   r   r   __all__r   r&   r%   <module>r      s0        ! 
 . , . 
		H	%bii <ryy .RYY "BII 0299 8299 :")) B#kBII #kL .O . ., $
' $
 $
N +s#8 +s+s\ Sr&   