
    rh;                        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 dd
lmZmZ ddlmZ  ej2                  e      Z G d dej8                        Z G d dej8                        Z G d dej8                        Z G d dej8                        Z  G d dej8                        Z! G d dej8                        Z" G d dej8                        Z# G d dej8                        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)BCEWithLogitsLossCrossEntropyLossMSELoss   )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          }/var/www/html/ai-insurance-compliance-backend/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&   r9   r'   s     r(   r    zRegNetEmbeddings.__init__J   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;   
ValueErrorr>   )r&   pixel_valuesr;   r-   s       r(   r.   zRegNetEmbeddings.forwardQ   sF    #))!,4,,,w  }}\2r)   )r0   r1   r2   __doc__r   r    r.   r5   r6   s   @r(   r8   r8   E   s    0| 0r)   r8   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__b   s:    99[,AV\chi^^L9r)   inputreturnc                 J    | j                  |      }| j                  |      }|S r+   )r"   r$   )r&   rH   r-   s      r(   r.   zRegNetShortCut.forwardg   s(    ''.)),7r)   )r   )	r0   r1   r2   rD   r3   r    r   r.   r5   r6   s   @r(   rF   rF   \   s5    
:C :s :C :
V  r)   rF   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   rM   r'   s      r(   r    zRegNetSELayer.__init__r   sd    **62IIk#3CGGIII&CJJL	
r)   c                 T    | j                  |      }| j                  |      }||z  }|S r+   )rQ   rU   )r&   r-   pooledrU   s       r(   r.   zRegNetSELayer.forward}   s.    \*NN6*	#i/r)   )r0   r1   r2   rD   r3   r    r.   r5   r6   s   @r(   rL   rL   m   s     	
C 	
3 	
r)   rL   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.
    r9   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_widthrF   r   r%   shortcutrR   r   r=   layerr
   r   r&   r9   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+   ra   r`   r   r&   r-   residuals      r(   r.   zRegNetXLayer.forward   A    zz,/==* |4r)   r   	r0   r1   r2   rD   r   r3   r    r.   r5   r6   s   @r(   rY   rY      s/    4| 4# 4S 4Z] 4r)   rY   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.
    r9   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]      )rM   )r   r    r^   r_   rF   r   r%   r`   rR   r   r=   rL   r3   roundra   r
   r   rb   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+   re   rf   s      r(   r.   zRegNetYLayer.forward   rh   r)   ri   rj   r6   s   @r(   rl   rl      s/    4| 4# 4S 4Z] 4r)   rl   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.
    r9   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_typerY   rl   r   rR   rangelayers)	r&   r9   r   r   r   rs   ra   _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+   )rx   r,   s     r(   r.   zRegNetStage.forward   s    {{<0r)   )r   r   rj   r6   s   @r(   rr   rr      sJ     

 
 	

 
 
.r)   rr   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 )	RegNetEncoderr9   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   rs   )rs   )r   r    r   
ModuleListstagesappendrr   r<   hidden_sizesdownsample_in_first_stagedepthszip)r&   r9   in_out_channelsr   r   rs   r'   s         r(   r    zRegNetEncoder.__init__   s    mmB'%%##A&"<<q!mmA&	
 f1163F3Fqr3JK25ov}}UVUWGX2Y 	\.'[,KK{6;TYZ[	\r)   r-   output_hidden_statesreturn_dictrI   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&   r-   r   r   r   stage_modules         r(   r.   zRegNetEncoder.forward   sq     3 KK 	6L# - ?'5L		6  )\O;MS\=$ASSS-\ijjr)   )FT)
r0   r1   r2   r   r    r   boolr   r.   r5   r6   s   @r(   r|   r|      sB    \| \$ ]ak"k:>kUYk	'kr)   r|   c                   ,    e Zd ZU eed<   dZdZdgZd Zy)RegNetPreTrainedModelr9   regnetrC   rl   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_inry   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)	r0   r1   r2   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 )NrO   )r   r    r9   r8   r>   r|   encoderr   rP   rQ   	post_initr?   s     r(   r    zRegNetModel.__init__  sK     (0$V,**62r)   rC   r   r   rI   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   )r9   r   use_return_dictr>   r   rQ   r   r   )r&   rC   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)r0   r1   r2   r    r   r   r   r   r   r.   r5   r6   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   rR   Flattenr   r   r%   
classifierr   r?   s     r(   r    z%RegNetForImageClassification.__init__M  s      ++!&)--JJLEKEVEVYZEZBIIf))"-v/@/@A`b`k`k`m

 	r)   rC   labelsr   r   rI   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   )r9   r   r   r   r   problem_typer   dtypetorchlongr3   r   squeezer   viewr   r   r   )r&   rC   r   r   r   outputsr   r   r   loss_fctoutputs              r(   r.   z$RegNetForImageClassification.forwardY  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)r0   r1   r2   r    r   r   r   FloatTensor
LongTensorr   r   r.   r5   r6   s   @r(   r   r   E  s    
  59-1/3&*/su001/s ))*/s 'tn	/s
 d^/s 
./s /sr)   r   )r   r   r   ))rD   r   typingr   r   torch.utils.checkpointr   r   torch.nnr   r   r   activationsr
   modeling_outputsr   r   r   modeling_utilsr   utilsr   r   configuration_regnetr   
get_loggerr0   loggerModuler   r8   rF   rL   rY   rl   rr   r|   r   r   r   __all__r   r)   r(   <module>r      s9         A A ! 
 . , . 
		H	%bii <ryy .RYY "BII 0299 8299 :")) B#kBII #kL .O . ., $
' $
 $
N =s#8 =s=s@ Sr)   