
    gLM                        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mZ dd	lmZ dd
lmZmZmZmZmZ ddlmZ ddlmZ  ej        e           Z!dZ"dZ#g dZ$dZ%d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          Z/d"Z0d#Z1 ed$e0           G d% d&e/                      Z2 ed'e0           G d( d)e/                      Z3 ed*e0           G d+ d,e/e                      Z4dS )-zPyTorch ResNet model.    N)Optional)Tensornn)BCEWithLogitsLossCrossEntropyLossMSELoss   )ACT2FN)BackboneOutputBaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)add_code_sample_docstringsadd_start_docstrings%add_start_docstrings_to_model_forwardloggingreplace_return_docstrings)BackboneMixin   )ResNetConfigr   zmicrosoft/resnet-50)r   i      r   z	tiger catc                   H     e 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 )ResNetConvLayerr	   r   reluin_channelsout_channelskernel_sizestride
activationc                    t                                                       t          j        |||||dz  d          | _        t          j        |          | _        |t          |         nt          j                    | _	        d S )N   F)r   r   paddingbias)
super__init__r   Conv2dconvolutionBatchNorm2dnormalizationr
   Identityr    )selfr   r   r   r   r    	__class__s         f/var/www/html/ai-engine/env/lib/python3.11/site-packages/transformers/models/resnet/modeling_resnet.pyr&   zResNetConvLayer.__init__;   s}     	9;vWbfgWgns
 
 
  ^L990:0F&,,BKMM    inputreturnc                     |                      |          }|                     |          }|                     |          }|S N)r(   r*   r    r,   r0   hidden_states      r.   forwardzResNetConvLayer.forwardE   s?    ''..)),77|44r/   )r	   r   r   )	__name__
__module____qualname__intstrr&   r   r6   __classcell__r-   s   @r.   r   r   :   s        lrZ ZZ.1Z@CZQTZfiZ Z Z Z Z ZV         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        | _        d S )Nr   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__Q   so    '!6Aa\b\m
 
 
 lqAFFF"/r/   pixel_valuesr1   c                     |j         d         }|| j        k    rt          d          |                     |          }|                     |          }|S )Nr   zeMake sure that the channel dimension of the pixel values match with the one set in the configuration.)shaperB   
ValueErrorrE   rG   )r,   rI   rB   	embeddings       r.   r6   zResNetEmbeddings.forwardY   s\    #)!,4,,,w   MM,//	KK	**	r/   )	r7   r8   r9   __doc__r   r&   r   r6   r<   r=   s   @r.   r?   r?   L   sp         0| 0 0 0 0 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   r   c                     t                                                       t          j        ||d|d          | _        t          j        |          | _        d S )Nr   F)r   r   r$   )r%   r&   r   r'   r(   r)   r*   )r,   r   r   r   r-   s       r.   r&   zResNetShortCut.__init__j   sP    9[,AV\chiii^L99r/   r0   r1   c                 Z    |                      |          }|                     |          }|S r3   )r(   r*   r4   s      r.   r6   zResNetShortCut.forwardo   s.    ''..)),77r/   )r"   )	r7   r8   r9   rN   r:   r&   r   r6   r<   r=   s   @r.   rP   rP   d   s         
: :C :s :C : : : : : :
V         r/   rP   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   r   r    c                 P   t                                                       ||k    p|dk    }|rt          |||          nt          j                    | _        t          j        t          |||          t          ||d                     | _        t          |         | _
        d S )Nr   r   r    r%   r&   rP   r   r+   shortcut
Sequentialr   layerr
   r    )r,   r   r   r   r    should_apply_shortcutr-   s         r.   r&   zResNetBasicLayer.__init__z   s     +| ; Jv{H]pN;VDDDDcecncpcp 	 ]KfEEEL,4HHH
 

 !,r/   c                     |}|                      |          }|                     |          }||z  }|                     |          }|S r3   r[   rY   r    r,   r5   residuals      r.   r6   zResNetBasicLayer.forward   J    zz,//==** |44r/   )r   r   )	r7   r8   r9   rN   r:   r;   r&   r6   r<   r=   s   @r.   rT   rT   u   sx         
- 
-C 
-s 
-C 
-Y\ 
- 
- 
- 
- 
- 
-      r/   rT   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      Fr   r   r   r    	reductiondownsample_in_bottleneckc           
         t                                                       ||k    p|dk    }||z  }|rt          |||          nt          j                    | _        t          j        t          ||d|r|nd          t          |||s|nd          t          ||dd                     | _        t          |         | _
        d S )Nr   rV   )r   r   )r   r    rX   )
r,   r   r   r   r    re   rf   r\   reduces_channelsr-   s
            r.   r&   zResNetBottleNeckLayer.__init__   s     	 +| ; Jv{'94H]pN;VDDDDcecncpcp 	 ]-1OgEnVVmn   ,.>UmGtvvstuuu,lVZ[[[
 

 !,r/   c                     |}|                      |          }|                     |          }||z  }|                     |          }|S r3   r^   r_   s      r.   r6   zResNetBottleNeckLayer.forward   ra   r/   )r   r   rd   F)
r7   r8   r9   rN   r:   r;   boolr&   r6   r<   r=   s   @r.   rc   rc      s           ).- -- - 	-
 - - #'- - - - - -0      r/   rc   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   r   depthc                 ^   t                                                       j        dk    rt          nt          j        dk    r ||j        j                  }n ||j                  }t          j        |gfdt          |dz
            D             R  | _
        d S )N
bottleneck)r   r    rf   )r   r    c                 6    g | ]} j                    S )rW   )rD   ).0_r@   r[   r   s     r.   
<listcomp>z(ResNetStage.__init__.<locals>.<listcomp>   s.    uuu_`55|HYZZZuuur/   r   )r%   r&   
layer_typerc   rT   rD   rf   r   rZ   rangelayers)	r,   r@   r   r   r   rm   first_layerr[   r-   s	    ` `   @r.   r&   zResNetStage.__init__   s     	)/):l)J)J%%P`,,%!,)/)H  KK  %\&U[UfgggKm
uuuuuudijorsjsdtdtuuu
 
 
r/   r0   r1   c                 4    |}| j         D ]} ||          }|S r3   )rv   )r,   r0   r5   r[   s       r.   r6   zResNetStage.forward   s/    [ 	/ 	/E 5..LLr/   )r"   r"   )
r7   r8   r9   rN   r   r:   r&   r   r6   r<   r=   s   @r.   rl   rl      s          
 

 
 	

 
 
 
 
 
 
 
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                            t          ||j        |j        d         |j	        rdnd|j
        d                              t          |j        |j        dd                    }t          ||j
        dd                    D ]3\  \  }}}| j                            t          ||||                     4d S )Nr   r"   r   )r   rm   )rm   )r%   r&   r   
ModuleListstagesappendrl   rC   hidden_sizesdownsample_in_first_stagedepthszip)r,   r@   in_out_channelsr   r   rm   r-   s         r.   r&   zResNetEncoder.__init__   s   mB''%#A&"<Cqq!mA&  	
 	
 	
 f163Fqrr3JKK25ov}UVUWUWGX2Y2Y 	\ 	\.'[,K{6;TYZZZ[[[[	\ 	\r/   FTr5   output_hidden_statesreturn_dictr1   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   | ]}||V  	d S r3   r   )rq   vs     r.   	<genexpr>z(ResNetEncoder.forward.<locals>.<genexpr>   s"      SSqQ]]]]]SSr/   )last_hidden_statehidden_states)r}   tupler   )r,   r5   r   r   r   stage_modules         r.   r6   zResNetEncoder.forward   s     3< K 	6 	6L# @ - ?'<55LL 	<)\O;M 	TSS\=$ASSSSSS-*'
 
 
 	
r/   )FT)
r7   r8   r9   r   r&   r   rj   r   r6   r<   r=   s   @r.   rz   rz      s        \| \ \ \ \ \ \$ ]a
 
"
:>
UY
	'
 
 
 
 
 
 
 
r/   rz   c                   ,    e Zd ZdZeZdZdZddgZd Z	dS )ResNetPreTrainedModelz
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    resnetrI   r   rP   c                    t          |t          j                  r)t          j                            |j        dd           d S t          |t          j                  rt          j                            |j        t          j	        d                     |j
        ot          j                            |j                  \  }}|dk    rdt          j	        |          z  nd}t          j                            |j
        | |           d S d S t          |t          j        t          j        f          rLt          j                            |j        d           t          j                            |j
        d           d S d S )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_inrr   bounds        r.   _init_weightsz#ResNetPreTrainedModel._init_weights  sF   fbi(( 	.G##FM	PV#WWWWW	** 	.G$$V]dill$CCC{&GAA&-PP	17!DIf----  ufe<<<<< '&  >?? 	.GfmQ///Gfk1-----	. 	.r/   N)
r7   r8   r9   rN   r   config_classbase_model_prefixmain_input_name_no_split_modulesr   r   r/   r.   r   r     sK         
  L $O*,<=. . . . .r/   r   aH  
    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 matter related to general usage and
    behavior.

    Parameters:
        config ([`ResNetConfig`]): 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.
aF  
    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 [`~utils.ModelOutput`] instead of a plain tuple.
zOThe bare ResNet 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 )ResNetModelc                    t                                          |           || _        t          |          | _        t          |          | _        t          j        d          | _	        | 
                                 d S )N)r   r   )r%   r&   r@   r?   rE   rz   encoderr   AdaptiveAvgPool2drG   	post_initrH   s     r.   r&   zResNetModel.__init__@  sh       (00$V,,*622r/   vision)
checkpointoutput_typer   modalityexpected_outputNrI   r   r   r1   c                 &   ||n| j         j        }||n| j         j        }|                     |          }|                     |||          }|d         }|                     |          }|s||f|dd          z   S t          |||j                  S )Nr   r   r   r   )r   pooler_outputr   )r@   r   use_return_dictrE   r   rG   r   r   )r,   rI   r   r   embedding_outputencoder_outputsr   pooled_outputs           r.   r6   zResNetModel.forwardI  s     %9$D  $+Jj 	 &1%<kk$+B]==66,,3GU` ' 
 
 ,A.$566 	L%}58KKK7/')7
 
 
 	
r/   NN)r7   r8   r9   r&   r   RESNET_INPUTS_DOCSTRINGr   _CHECKPOINT_FOR_DOCr   _CONFIG_FOR_DOC_EXPECTED_OUTPUT_SHAPEr   r   rj   r6   r<   r=   s   @r.   r   r   ;  s        
     +*+BCC&<$.   pt
 
"
:B4.
^fgk^l
	1
 
 
  DC
 
 
 
 
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.
    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 )ResNetForImageClassificationc                    t                                          |           |j        | _        t          |          | _        t          j        t          j                    |j        dk    r%t          j        |j	        d         |j                  nt          j
                              | _        |                                  d S )Nr   )r%   r&   
num_labelsr   r   r   rZ   Flattenr   r   r+   
classifierr   rH   s     r.   r&   z%ResNetForImageClassification.__init__u  s        +!&))-JLLEKEVYZEZEZBIf)"-v/@AAA`b`k`m`m
 

 	r/   )r   r   r   r   NrI   labelsr   r   r1   c                    ||n| j         j        }|                     |||          }|r|j        n|d         }|                     |          }d}|Z| j         j        f| j        dk    rd| j         _        nN| j        dk    r7|j        t          j	        k    s|j        t          j
        k    rd| j         _        nd| j         _        | j         j        dk    rWt                      }	| j        dk    r1 |	|                                |                                          }n |	||          }n| j         j        dk    rGt                      }	 |	|                    d| j                  |                    d                    }n*| j         j        dk    rt                      }	 |	||          }|s|f|dd         z   }
||f|
z   n|
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longr:   r   squeezer   viewr   r   r   )r,   rI   r   r   r   outputsr   r   r   loss_fctoutputs              r.   r6   z$ResNetForImageClassification.forward  s   & &1%<kk$+B]++lAUcn+oo1<L--'!*//{'/?a''/;DK,,_q((flej.H.HFL\a\eLeLe/LDK,,/KDK,{'<77"99?a''#8FNN$4$4fnn6F6FGGDD#8FF33DD)-JJJ+--xB @ @&++b//RR)-III,..x// 	DY,F'+'7D7V##VC3f\c\qrrrrr/   )NNNN)r7   r8   r9   r&   r   r   r   _IMAGE_CLASS_CHECKPOINTr   r   _IMAGE_CLASS_EXPECTED_OUTPUTr   r   FloatTensor
LongTensorrj   r6   r<   r=   s   @r.   r   r   m  s        
 
 
 
 
 +*+BCC*8$4	   59-1/3&*/s /su01/s )*/s 'tn	/s
 d^/s 
./s /s /s  DC/s /s /s /s /sr/   r   zO
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    c                        e Zd Z fdZ ee           eee          	 d	de	de
e         de
e         defd                        Z xZS )
ResNetBackbonec                 .   t                                          |           t                                          |           |j        g|j        z   | _        t          |          | _        t          |          | _	        | 
                                 d S r3   )r%   r&   _init_backbonerC   r   num_featuresr?   rE   rz   r   r   rH   s     r.   r&   zResNetBackbone.__init__  s       v&&&#23f6II(00$V,, 	r/   )r   r   NrI   r   r   r1   c                 j   ||n| j         j        }||n| j         j        }|                     |          }|                     |dd          }|j        }d}t          | j                  D ]\  }}	|	| j        v r|||         fz  }|s|f}
|r|
|j        fz  }
|
S t          ||r|j        ndd          S )a3  
        Returns:

        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)
r@   r   r   rE   r   r   	enumeratestage_namesout_featuresr   )r,   rI   r   r   r   r   r   r   idxstager   s              r.   r6   zResNetBackbone.forward  s   > &1%<kk$+B]$8$D  $+Jj 	  ==66,,/dX\,]]-#D$455 	6 	6JC)))s!3 55 	"_F# 37022M%3GQ'//T
 
 
 	
r/   r   )r7   r8   r9   r&   r   r   r   r   r   r   r   rj   r6   r<   r=   s   @r.   r   r     s        	 	 	 	 	 +*+BCC>XXXos7
 7
"7
:B4.7
^fgk^l7
	7
 7
 7
 YX DC7
 7
 7
 7
 7
r/   r   )5rN   r   typingr   r   torch.utils.checkpointr   r   torch.nnr   r   r   activationsr
   modeling_outputsr   r   r   r   modeling_utilsr   utilsr   r   r   r   r   utils.backbone_utilsr   configuration_resnetr   
get_loggerr7   loggerr   r   r   r   r   Moduler   r?   rP   rT   rc   rl   rz   r   RESNET_START_DOCSTRINGr   r   r   r   r   r/   r.   <module>r      s                         A A A A A A A A A A ! ! ! ! ! !            . - - - - -              2 1 1 1 1 1 . . . . . . 
	H	%	% ! , (  0 *     bi   $    ry   0    RY   "    ry   4' ' ' ' 'BI ' ' 'T# # # # #") # # #L&
 &
 &
 &
 &
BI &
 &
 &
R. . . . .O . . .4	   U +
 +
 +
 +
 +
' +
 +
	 +
\   Cs Cs Cs Cs Cs#8 Cs Cs CsL  	 E
 E
 E
 E
 E
*M E
 E
 E
 E
 E
r/   