
    ^jB                        d Z ddlZddlZddlmZmZ ddlmZ ddlm	Z	 ddl
mZmZ ddlmZmZmZmZ dd	lmZ dd
lmZmZ ddlmZ ddlmZ  ej6                  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%e G d de             Z&e G d de&             Z' ed !       G d" d#e&             Z( ed$!       G d% d&ee&             Z)g d'Z*y)(zPyTorch ResNet model.    N)Tensornn   )initialization)ACT2FN)BackboneMixinfilter_output_hidden_states)BackboneOutputBaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)auto_docstringlogging)can_return_tuple   )ResNetConfigc                        e Zd Z	 	 	 	 	 	 ddededeeeef   z  dededeeeef   z  dedef fd	Zd
ej                  dej                  fdZ
 xZS )ResNetConvLayerin_channelsout_channelskernel_sizestridebiasdilationgroups
activationc	           
          t         	|           t        j                  |||||dz  |||      | _        t        j
                  |      | _        |t        |   | _	        y t        j                         | _	        y )N   )r   r   r   r   paddingr   r   r   )
super__init__r   Conv2dconvolutionBatchNorm2dnormalizationr   Identityr   )
selfr   r   r   r   r   r   r   r   	__class__s
            u/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/resnet/modeling_resnet.pyr"   zResNetConvLayer.__init__(   sn     	99#%#1$	
  ^^L90:0F&,BKKM    hidden_statesreturnc                 l    | j                  |      }| j                  |      }| j                  |      }|S N)r$   r&   r   )r(   r,   s     r*   forwardzResNetConvLayer.forwardA   s6    ((7**=96r+   )r   r   Fr   r   relu)__name__
__module____qualname__inttupleboolstrr"   torchr   r0   __classcell__r)   s   @r*   r   r   '   s    
 ./*+ ZZ Z 5c?*	Z
 Z Z c3h'Z Z Z2U\\ ell r+   r   c                   8     e Zd ZdZdef fdZdedefdZ xZS )ResNetEmbeddingszO
    ResNet Embeddings (stem) composed of a single aggressive convolution.
    configc                     t         |           t        |j                  |j                  dd|j
                        | _        t        j                  ddd      | _	        |j                  | _        y )N   r   )r   r   r   r   r   )r   r   r    )
r!   r"   r   num_channelsembedding_size
hidden_actembedderr   	MaxPool2dpoolerr(   r>   r)   s     r*   r"   zResNetEmbeddings.__init__M   s\    '!6!6Aa\b\m\m
 llqAF"//r+   pixel_valuesr-   c                     |j                   d   }|| j                  k7  rt        d      | j                  |      }| j	                  |      }|S )Nr   zeMake sure that the channel dimension of the pixel values match with the one set in the configuration.)shaperA   
ValueErrorrD   rF   )r(   rH   rA   	embeddings       r*   r0   zResNetEmbeddings.forwardU   sT    #))!,4,,,w  MM,/	KK	*	r+   )	r2   r3   r4   __doc__r   r"   r   r0   r:   r;   s   @r*   r=   r=   H   s'    0| 0F v 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 )
ResNetShortCutz
    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         |           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ResNetShortCut.__init__f   s:    99[,AV\chi^^L9r+   inputr-   c                 J    | j                  |      }| j                  |      }|S r/   )r$   r&   )r(   rQ   hidden_states      r*   r0   zResNetShortCut.forwardk   s(    ''.)),7r+   )r   )	r2   r3   r4   rM   r5   r"   r   r0   r:   r;   s   @r*   rO   rO   `   s5    
:C :s :C :
V  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 )	ResNetBasicLayerzO
    A classic ResNet's residual layer composed by two `3x3` convolutions.
    r   r   r   r   c                    t         |           ||k7  xs |dk7  }|rt        |||      nt        j                         | _        t        j                  t        |||      t        ||d             | _        t        |   | _
        y )Nr   r   r   r!   r"   rO   r   r'   shortcut
Sequentialr   layerr   r   )r(   r   r   r   r   should_apply_shortcutr)   s         r*   r"   zResNetBasicLayer.__init__v   s{     +| ; Jv{H]N;VDcecncncp 	 ]]KfEL,4H

 !,r+   c                 z    |}| j                  |      }| j                  |      }||z  }| j                  |      }|S r/   r\   rZ   r   r(   rS   residuals      r*   r0   zResNetBasicLayer.forward   A    zz,/==* |4r+   )r   r1   )	r2   r3   r4   rM   r5   r8   r"   r0   r:   r;   s   @r*   rU   rU   q   s/    
-C 
-s 
-C 
-Y\ 
-r+   rU   c                   L     e Zd ZdZ	 	 	 	 d
dedededededef fdZd	 Z xZ	S )ResNetBottleNeckLayera  
    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           
      F   t         	|           ||k7  xs |dk7  }||z  }|rt        |||      nt        j                         | _        t        j                  t        ||d|r|nd      t        |||s|nd      t        ||dd             | _        t        |   | _
        y )Nr   rW   )r   r   )r   r   rY   )
r(   r   r   r   r   re   rf   r]   reduces_channelsr)   s
            r*   r"   zResNetBottleNeckLayer.__init__   s     	 +| ; Jv{'94H]N;VDcecncncp 	 ]]-1OgVmn ,.>Umvstu,lVZ[

 !,r+   c                 z    |}| j                  |      }| j                  |      }||z  }| j                  |      }|S r/   r_   r`   s      r*   r0   zResNetBottleNeckLayer.forward   rb   r+   )r   r1      F)
r2   r3   r4   rM   r5   r8   r7   r"   r0   r:   r;   s   @r*   rd   rd      sZ      ).-- - 	-
 - - #'-0r+   rd   c                   N     e Zd ZdZ	 	 ddededededef
 fdZded	efd
Z xZ	S )ResNetStagez4
    A ResNet stage composed by stacked layers.
    r>   r   r   r   depthc                    t         	|           |j                  dk(  rt        nt        }|j                  dk(  r" |||||j
                  |j                        }n |||||j
                        }t        j                  |gt        |dz
        D cg c]  } ||||j
                         c} | _
        y c c}w )N
bottleneck)r   r   rf   )r   r   r   rX   )r!   r"   
layer_typerd   rU   rC   rf   r   r[   rangelayers)
r(   r>   r   r   r   rm   r\   first_layer_r)   s
            r*   r"   zResNetStage.__init__   s     	)/):):l)J%P`,!,,)/)H)HK  \&U[UfUfgKmm
dijorsjsdtu_`5|HYHYZu
us   B;
rQ   r-   c                 <    |}| j                   D ]
  } ||      } |S r/   )rr   )r(   rQ   rS   r\   s       r*   r0   zResNetStage.forward   s*    [[ 	/E .L	/r+   )r   r   )
r2   r3   r4   rM   r   r5   r"   r   r0   r:   r;   s   @r*   rl   rl      sX     

 
 	

 
 
4V  r+   rl   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 )	ResNetEncoderr>   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   rm   )rm   )r!   r"   r   
ModuleListstagesappendrl   rB   hidden_sizesdownsample_in_first_stagedepthszip)r(   r>   in_out_channelsr   r   rm   r)   s         r*   r"   zResNetEncoder.__init__   s    mmB'%%##A&"<<q!mmA&	
 f1163F3Fqr3JK25ov}}UVUWGX2Y 	\.'[,KK{6;TYZ[	\r+   rS   output_hidden_statesreturn_dictr-   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(ResNetEncoder.forward.<locals>.<genexpr>   s     SqQ]Ss   )last_hidden_stater,   )rz   r6   r   )r(   rS   r   r   r,   stage_modules         r*   r0   zResNetEncoder.forward   sv     3 KK 	6L# - ?'5L		6  )\O;MS\=$ASSS-*'
 	
r+   )FT)
r2   r3   r4   r   r"   r   r7   r   r0   r:   r;   s   @r*   rw   rw      s=    \| \$ ]a
"
:>
UY
	'
r+   rw   c                   f     e Zd ZU eed<   dZdZdZddgZ e	j                          fd       Z xZS )ResNetPreTrainedModelr>   resnetrH   )imager   rO   c                    t         |   |       t        |t        j                        r#t        j                  |j                  dd       y t        |t        j                        rt        j                  |j                  t        j                  d             |j                  xt        j                  j
                  j                  |j                        \  }}|dkD  rdt        j                  |      z  nd}t        j                  |j                  | |       y y d|j                   j"                  v rt        j$                  |j                         t        j&                  |j                         t        j&                  |j(                         t        j$                  |j*                         t-        |d	d        t        j&                  |j.                         y y y )
Nfan_outr1   )modenonlinearity   )ar   r   	BatchNormnum_batches_tracked)r!   _init_weights
isinstancer   r#   initkaiming_normal_weightLinearkaiming_uniform_mathsqrtr   r9   _calculate_fan_in_and_fan_outuniform_r)   r2   ones_zeros_running_meanrunning_vargetattrr   )r(   modulefan_inrt   boundr)   s        r*   r   z#ResNetPreTrainedModel._init_weights  sE   f%fbii(  YVT		*!!&--499Q<@{{&!HHMMGGV	17!DIIf--fkkE659 '
 F,,555JJv}}%KK$KK++,JJv))*v4d;GF667 H 6r+   )r2   r3   r4   r   __annotations__base_model_prefixmain_input_nameinput_modalities_no_split_modulesr9   no_gradr   r:   r;   s   @r*   r   r     s@     $O!*,<=U]]_8 8r+   r   c            
       R     e Zd Z fdZe	 	 ddededz  dedz  defd       Z xZ	S )	ResNetModelc                     t         |   |       || _        t        |      | _        t        |      | _        t        j                  d      | _	        | j                          y )N)r   r   )r!   r"   r>   r=   rD   rw   encoderr   AdaptiveAvgPool2drF   	post_initrG   s     r*   r"   zResNetModel.__init__$  sK     (0$V,**62r+   NrH   r   r   r-   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   r   rD   r   rF   r   r,   )	r(   rH   r   r   kwargsembedding_outputencoder_outputsr   pooled_outputs	            r*   r0   zResNetModel.forward-  s     %9$D $++JjJj 	 &1%<k$++BYBY==6,,3GU` ' 
 ,A.$56%}58KKK7/')77
 	
r+   NN)
r2   r3   r4   r"   r   r   r7   r   r0   r:   r;   s   @r*   r   r   "  sR      -1#'	

 #Tk
 D[	
 
2
 
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                        e Zd Z fdZe	 	 	 	 d	dej                  dz  dej                  dz  dedz  dedz  de	f
d       Z
 xZS )
ResNetForImageClassificationc                 |   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   r[   Flattenr   r|   r'   
classifierr   rG   s     r*   r"   z%ResNetForImageClassification.__init__U  s      ++!&)--JJLEKEVEVYZEZBIIf))"-v/@/@A`b`k`k`m

 	r+   NrH   labelsr   r   r-   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,   )r>   r   r   r   r   loss_functionr   r,   )r(   rH   r   r   r   r   outputsr   r   r   outputs              r*   r0   z$ResNetForImageClassification.forwarda  s     &1%<k$++BYBY++lAUcn+o1<--'!*/%%ffdkkBDY,F'+'7D7V#CVC3f\c\q\qrrr+   )NNNN)r2   r3   r4   r"   r   r9   FloatTensor
LongTensorr7   r   r0   r:   r;   s   @r*   r   r   N  s    
  26*.,0#'s''$.s   4's #Tk	s
 D[s 
.s sr+   r   zO
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    c                   j     e Zd ZdZ fdZeee	 	 d	dede	dz  de	dz  de
fd                     Z xZS )
ResNetBackboneFc                     t         |   |       |j                  g|j                  z   | _        t        |      | _        t        |      | _        | j                          y r/   )
r!   r"   rB   r|   num_featuresr=   rD   rw   r   r   rG   s     r*   r"   zResNetBackbone.__init__  sP     #223f6I6II(0$V, 	r+   NrH   r   r   r-   c                    ||n| j                   j                  }||n| j                   j                  }| j                  |      }| j	                  |dd      }|j
                  }d}t        | j                        D ]  \  }	}
|
| j                  v s|||	   fz  } |s|f}|r||j
                  fz  }|S t        ||r|j
                  d      S dd      S )ar  
        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, AutoBackbone
        >>> import torch
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> 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)
r>   r   r   rD   r   r,   	enumeratestage_namesout_featuresr
   )r(   rH   r   r   r   r   r   r,   r   idxstager   s               r*   r0   zResNetBackbone.forward  s    H &1%<k$++BYBY$8$D $++JjJj 	  ==6,,/dX\,]--#D$4$45 	6JC)))s!3 55	6 "_F#70022M%3G'//
 	
MQ
 	
r+   r   )r2   r3   r4   has_attentionsr"   r   r	   r   r   r7   r
   r0   r:   r;   s   @r*   r   r     si     N   -1#'	;
;
 #Tk;
 D[	;
 
;
  ! ;
r+   r   )r   r   r   r   )+rM   r   r9   r   r    r   r   activationsr   backbone_utilsr   r	   modeling_outputsr
   r   r   r   modeling_utilsr   utilsr   r   utils.genericr   configuration_resnetr   
get_loggerr2   loggerModuler   r=   rO   rU   rd   rl   rw   r   r   r   r   __all__r   r+   r*   <module>r      sR       & ! H  . , - . 
		H	%bii Bryy 0RYY "ryy 4'BII 'T#")) #L&
BII &
R 8O 8 8: (
' (
 (
V ,s#8 ,s,s^ 
K
]$9 K

K
\ er+   