
    fTh=C                        S r SSKrSSKJr  SSKrSSKrSSKJrJr  SSKJ	r	J
r
Jr  SSKJr  SSKJrJrJrJr  SS	KJr  SS
KJrJr  SSKJr  SSKJr  \R8                  " \5      r " S S\R>                  5      r  " S S\R>                  5      r! " S S\R>                  5      r" " S S\R>                  5      r# " S S\R>                  5      r$ " S S\R>                  5      r% " S S\R>                  5      r&\ " S S\5      5       r'\ " S S\'5      5       r(\" S S!9 " S" S#\'5      5       r)\" S$S!9 " S% S&\'\5      5       r*/ S'Qr+g)(zPyTorch ResNet model.    N)Optional)Tensornn)BCEWithLogitsLossCrossEntropyLossMSELoss   )ACT2FN)BackboneOutputBaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)auto_docstringlogging)BackboneMixin   )ResNetConfigc                   X   ^  \ rS rSr SS\S\S\S\S\4
U 4S jjjrS\S	\4S
 jrSr	U =r
$ )ResNetConvLayer)   in_channelsout_channelskernel_sizestride
activationc           	         > [         TU ]  5         [        R                  " XX4US-  SS9U l        [        R
                  " U5      U l        Ub  [        U   U l	        g [        R                  " 5       U l	        g )N   F)r   r   paddingbias)
super__init__r   Conv2dconvolutionBatchNorm2dnormalizationr
   Identityr   )selfr   r   r   r   r   	__class__s         b/var/www/auris/envauris/lib/python3.13/site-packages/transformers/models/resnet/modeling_resnet.pyr"   ResNetConvLayer.__init__*   sb     	99;WbfgWgns
  ^^L90:0F&,BKKM    inputreturnc                 l    U R                  U5      nU R                  U5      nU R                  U5      nU$ N)r$   r&   r   r(   r-   hidden_states      r*   forwardResNetConvLayer.forward4   s6    ''.)),7|4r,   )r   r$   r&   )r	   r   relu)__name__
__module____qualname____firstlineno__intstrr"   r   r3   __static_attributes____classcell__r)   s   @r*   r   r   )   sW    lrZZ.1Z@CZQTZfiZ ZV   r,   r   c                   F   ^  \ rS rSrSrS\4U 4S jjrS\S\4S jrSr	U =r
$ )	ResNetEmbeddings;   zG
ResNet Embeddings (stem) composed of a single aggressive convolution.
configc                    > [         TU ]  5         [        UR                  UR                  SSUR
                  S9U l        [        R                  " SSSS9U l	        UR                  U l        g )N   r   )r   r   r   r	   r   )r   r   r   )
r!   r"   r   num_channelsembedding_size
hidden_actembedderr   	MaxPool2dpoolerr(   rB   r)   s     r*   r"   ResNetEmbeddings.__init__@   s\    '!6!6Aa\b\m\m
 llqAF"//r,   pixel_valuesr.   c                     UR                   S   nX R                  :w  a  [        S5      eU R                  U5      nU R	                  U5      nU$ )Nr   zeMake sure that the channel dimension of the pixel values match with the one set in the configuration.)shaperE   
ValueErrorrH   rJ   )r(   rM   rE   	embeddings       r*   r3   ResNetEmbeddings.forwardH   sR    #))!,,,,w  MM,/	KK	*	r,   )rH   rE   rJ   )r6   r7   r8   r9   __doc__r   r"   r   r3   r<   r=   r>   s   @r*   r@   r@   ;   s,    0| 0F v  r,   r@   c                   R   ^  \ rS rSrSrSS\S\S\4U 4S jjjrS\S\4S	 jrS
r	U =r
$ )ResNetShortCutS   z
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   r   r   c                    > [         TU ]  5         [        R                  " XSUSS9U l        [        R
                  " U5      U l        g )Nr   F)r   r   r    )r!   r"   r   r#   r$   r%   r&   )r(   r   r   r   r)   s       r*   r"   ResNetShortCut.__init__Y   s8    99[AV\chi^^L9r,   r-   r.   c                 J    U R                  U5      nU R                  U5      nU$ r0   r$   r&   r1   s      r*   r3   ResNetShortCut.forward^   s(    ''.)),7r,   rZ   )r   )r6   r7   r8   r9   rS   r:   r"   r   r3   r<   r=   r>   s   @r*   rU   rU   S   s?    
:C :s :C : :
V   r,   rU   c            	       J   ^  \ rS rSrSrS
S\S\S\S\4U 4S jjjrS rS	r	U =r
$ )ResNetBasicLayerd   zG
A classic ResNet's residual layer composed by two `3x3` convolutions.
r   r   r   r   c           	        > [         TU ]  5         X:g  =(       d    US:g  nU(       a
  [        XUS9O[        R                  " 5       U l        [        R                  " [        XUS9[        X"S S95      U l        [        U   U l
        g )Nr   r   r   r!   r"   rU   r   r'   shortcut
Sequentialr   layerr
   r   )r(   r   r   r   r   should_apply_shortcutr)   s         r*   r"   ResNetBasicLayer.__init__i   ss     + ; Jv{H]N;VDcecncncp 	 ]]KfEL4H

 !,r,   c                 x    UnU R                  U5      nU R                  U5      nX-  nU R                  U5      nU$ r0   re   rc   r   r(   r2   residuals      r*   r3   ResNetBasicLayer.forwardu   ?    zz,/==* |4r,   r   re   rc   )r   r5   )r6   r7   r8   r9   rS   r:   r;   r"   r3   r<   r=   r>   s   @r*   r]   r]   d   s9    
-C 
-s 
-C 
-Y\ 
- 
- r,   r]   c                   Z   ^  \ rS rSrSr    SS\S\S\S\S\S\4U 4S	 jjjrS
 r	Sr
U =r$ )ResNetBottleNeckLayer~   a  
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`. If
`downsample_in_bottleneck` is true, downsample will be in the first layer instead of the second layer.
r   r   r   r   	reductiondownsample_in_bottleneckc                 N  > [         T	U ]  5         X:g  =(       d    US:g  nX%-  nU(       a
  [        XUS9O[        R                  " 5       U l        [        R                  " [        XSU(       a  UOSS9[        XU(       d  UOSS9[        XSS S95      U l        [        U   U l
        g )Nr   r`   )r   r   )r   r   rb   )
r(   r   r   r   r   rr   rs   rf   reduces_channelsr)   s
            r*   r"   ResNetBottleNeckLayer.__init__   s     	 + ; Jv{'4H]N;VDcecncncp 	 ]]1OgVmn ,Umvstu,VZ[

 !,r,   c                 x    UnU R                  U5      nU R                  U5      nX-  nU R                  U5      nU$ r0   ri   rj   s      r*   r3   ResNetBottleNeckLayer.forward   rm   r,   rn   )r   r5      F)r6   r7   r8   r9   rS   r:   r;   boolr"   r3   r<   r=   r>   s   @r*   rp   rp   ~   sd      ).-- - 	-
 - - #'- -0 r,   rp   c                   ^   ^  \ rS rSrSr  SS\S\S\S\S\4
U 4S jjjrS	\S
\4S jr	Sr
U =r$ )ResNetStage   z,
A ResNet stage composed by stacked layers.
rB   r   r   r   depthc                 r  > [         T	U ]  5         UR                  S:X  a  [        O[        nUR                  S:X  a  U" UUUUR
                  UR                  S9nOU" X#XAR
                  S9n[        R                  " U/[        US-
  5       Vs/ s H  o" X3UR
                  S9PM     snQ76 U l
        g s  snf )N
bottleneck)r   r   rs   )r   r   r   ra   )r!   r"   
layer_typerp   r]   rG   rs   r   rd   rangelayers)
r(   rB   r   r   r   r~   re   first_layer_r)   s
            r*   r"   ResNetStage.__init__   s     	)/):):l)J%P`,!,,)/)H)HK  &UfUfgKmm
dijorsjsdtudt_`5HYHYZdtu
us   B4
r-   r.   c                 @    UnU R                    H  nU" U5      nM     U$ r0   r   )r(   r-   r2   re   s       r*   r3   ResNetStage.forward   s%    [[E .L !r,   r   )r   r   )r6   r7   r8   r9   rS   r   r:   r"   r   r3   r<   r=   r>   s   @r*   r|   r|      sb     

 
 	

 
 
 
4V   r,   r|   c            	       P   ^  \ rS rSrS\4U 4S jjr S
S\S\S\S\4S jjr	S	r
U =r$ )ResNetEncoder   rB   c           
        > [         TU ]  5         [        R                  " / 5      U l        U R                  R                  [        UUR                  UR                  S   UR                  (       a  SOSUR                  S   S95        [        UR                  UR                  SS  5      n[        X!R                  SS  5       H+  u  u  p4nU R                  R                  [        XXES95        M-     g )Nr   r   r   )r   r~   )r~   )r!   r"   r   
ModuleListstagesappendr|   rF   hidden_sizesdownsample_in_first_stagedepthszip)r(   rB   in_out_channelsr   r   r~   r)   s         r*   r"   ResNetEncoder.__init__   s    mmB'%%##A&"<<q!mmA&	
 f1163F3Fqr3JK25o}}UVUWGX2Y.'[KK{6Z[ 3Zr,   r2   output_hidden_statesreturn_dictr.   c                     U(       a  SOS nU R                    H  nU(       a  XA4-   nU" U5      nM     U(       a  XA4-   nU(       d  [        S X4 5       5      $ [        UUS9$ )N c              3   .   #    U  H  oc  M  Uv   M     g 7fr0   r   ).0vs     r*   	<genexpr>(ResNetEncoder.forward.<locals>.<genexpr>   s     S$Aq$As   	)last_hidden_statehidden_states)r   tupler   )r(   r2   r   r   r   stage_modules         r*   r3   ResNetEncoder.forward   sk     3 KKL# - ?'5L	 (  )O;MS\$ASSS-*'
 	
r,   )r   )FT)r6   r7   r8   r9   r   r"   r   rz   r   r3   r<   r=   r>   s   @r*   r   r      sB    \| \$ ]a
"
:>
UY
	'
 
r,   r   c                   .    \ rS rSr\rSrSrSS/rS r	Sr
g)	ResNetPreTrainedModel   resnetrM   r   rU   c                 b   [        U[        R                  5      (       a*  [        R                  R	                  UR
                  SSS9  g [        U[        R                  5      (       a  [        R                  R                  UR
                  [        R                  " S5      S9  UR                  by  [        R                  R                  UR
                  5      u  p#US:  a  S[        R                  " U5      -  OSn[        R                  R                  UR                  U* U5        g g [        U[        R                  [        R                  45      (       aU  [        R                  R                  UR
                  S5        [        R                  R                  UR                  S5        g g )Nfan_outr5   )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_weights#ResNetPreTrainedModel._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,   r   N)r6   r7   r8   r9   r   config_classbase_model_prefixmain_input_name_no_split_modulesr   r<   r   r,   r*   r   r      s#    L $O*,<=.r,   r   c            
       ^   ^  \ rS rSrU 4S jr\ S	S\S\\   S\\   S\	4S jj5       r
SrU =r$ )
ResNetModeli  c                    > [         TU ]  U5        Xl        [        U5      U l        [        U5      U l        [        R                  " S5      U l	        U R                  5         g )N)r   r   )r!   r"   rB   r@   rH   r   encoderr   AdaptiveAvgPool2drJ   	post_initrK   s     r*   r"   ResNetModel.__init__  sI     (0$V,**62r,   rM   r   r   r.   c                 &   Ub  UOU R                   R                  nUb  UOU R                   R                  nU R                  U5      nU R	                  XBUS9nUS   nU R                  U5      nU(       d	  Xg4USS  -   $ [        UUUR                  S9$ )Nr   r   r   r   )r   pooler_outputr   )rB   r   use_return_dictrH   r   rJ   r   r   )r(   rM   r   r   embedding_outputencoder_outputsr   pooled_outputs           r*   r3   ResNetModel.forward  s    
 %9$D $++JjJj 	 &1%<k$++B]B]==6,,U` ' 
 ,A.$56%58KKK7/')77
 	
r,   )rB   rH   r   rJ   NN)r6   r7   r8   r9   r"   r   r   r   rz   r   r3   r<   r=   r>   s   @r*   r   r     sI     os
"
:B4.
^fgk^l
	1
 
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.
    )custom_introc                      ^  \ rS rSrU 4S jr\    S
S\\R                     S\\R                     S\\
   S\\
   S\4
S jj5       rS	rU =r$ )ResNetForImageClassificationi5  c                   > [         TU ]  U5        UR                  U l        [        U5      U l        [
        R                  " [
        R                  " 5       UR                  S:  a.  [
        R                  " UR                  S   UR                  5      O[
        R                  " 5       5      U l        U R                  5         g )Nr   )r!   r"   
num_labelsr   r   r   rd   Flattenr   r   r'   
classifierr   rK   s     r*   r"   %ResNetForImageClassification.__init__<  s      ++!&)--JJLEKEVEVYZEZBIIf))"-v/@/@A`b`k`k`m

 	r,   rM   labelsr   r   r.   c                 0   Ub  UOU R                   R                  nU R                  XUS9nU(       a  UR                  OUS   nU R	                  U5      nSnUGb  U R                   R
                  c  U R                  S:X  a  SU R                   l        OoU R                  S:  aN  UR                  [        R                  :X  d  UR                  [        R                  :X  a  SU R                   l        OSU R                   l        U R                   R
                  S:X  aI  [        5       n	U R                  S:X  a&  U	" UR                  5       UR                  5       5      nOU	" Xr5      nOU R                   R
                  S:X  a=  [        5       n	U	" UR                  SU R                  5      UR                  S5      5      nO,U R                   R
                  S:X  a  [        5       n	U	" Xr5      nU(       d  U4USS -   n
Ub  U4U
-   $ U
$ [!        XUR"                  S	9$ )
a  
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   )rB   r   r   r   r   problem_typer   dtypetorchlongr:   r   squeezer   viewr   r   r   )r(   rM   r   r   r   outputsr   r   r   loss_fctoutputs              r*   r3   $ResNetForImageClassification.forwardH  s    &1%<k$++B]B]++lcn+o1<--'!*/{{''/??a'/;DKK,__q(fllejj.HFLL\a\e\eLe/LDKK,/KDKK,{{''<7"9??a'#FNN$4fnn6FGD#F3D))-JJ+-B @&++b/R))-II,./Y,F'+'7D7V#CVC3\c\q\qrrr,   )r   r   r   )NNNN)r6   r7   r8   r9   r"   r   r   r   FloatTensor
LongTensorrz   r   r3   r<   r=   r>   s   @r*   r   r   5  s    
  59-1/3&*/su001/s ))*/s 'tn	/s
 d^/s 
./s /sr,   r   zO
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    c            
       ^   ^  \ rS rSrU 4S jr\ S	S\S\\   S\\   S\	4S jj5       r
SrU =r$ )
ResNetBackbonei{  c                    > [         TU ]  U5        [         TU ]	  U5        UR                  /UR                  -   U l        [        U5      U l        [        U5      U l	        U R                  5         g r0   )r!   r"   _init_backbonerF   r   num_featuresr@   rH   r   r   r   rK   s     r*   r"   ResNetBackbone.__init__  s]     v&#223f6I6II(0$V, 	r,   rM   r   r   r.   c                    Ub  UOU R                   R                  nUb  UOU R                   R                  nU R                  U5      nU R	                  USSS9nUR
                  nSn[        U R                  5       H  u  pXR                  ;   d  M  XvU   4-  nM      U(       d  U4n
U(       a  XR
                  4-  n
U
$ [        UU(       a  UR
                  SS9$ SSS9$ )a  
Examples:

```python
>>> from transformers import AutoImageProcessor, AutoBackbone
>>> import torch
>>> from PIL import Image
>>> import requests

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

>>> processor = AutoImageProcessor.from_pretrained("microsoft/resnet-50")
>>> model = AutoBackbone.from_pretrained(
...     "microsoft/resnet-50", out_features=["stage1", "stage2", "stage3", "stage4"]
... )

>>> inputs = processor(image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 2048, 7, 7]
```NTr   r   )feature_mapsr   
attentions)
rB   r   r   rH   r   r   	enumeratestage_namesout_featuresr   )r(   rM   r   r   r   r   r   r   idxstager   s              r*   r3   ResNetBackbone.forward  s    8 &1%<k$++B]B]$8$D $++JjJj 	  ==6,,/dX\,]--#D$4$45JC)))s!3 55 6 "_F#0022M%3G'//
 	
MQ
 	
r,   )rH   r   r   r   )r6   r7   r8   r9   r"   r   r   r   rz   r   r3   r<   r=   r>   s   @r*   r   r   {  sI    	 os5
"5
:B4.5
^fgk^l5
	5
 5
r,   r   )r   r   r   r   ),rS   r   typingr   r   torch.utils.checkpointr   r   torch.nnr   r   r   activationsr
   modeling_outputsr   r   r   r   modeling_utilsr   utilsr   r   utils.backbone_utilsr   configuration_resnetr   
get_loggerr6   loggerModuler   r@   rU   r]   rp   r|   r   r   r   r   r   __all__r   r,   r*   <module>r     sU         A A !  . , 1 . 
		H	%bii $ryy 0RYY "ryy 4'BII 'T#")) #L&
BII &
R .O . .* $
' $
 $
N =s#8 =s=s@ 
B
*M B

B
J er,   