o
    Zh=C                     @   s  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 ddlmZ ddlmZ eeZG dd dejZ G dd dejZ!G dd dejZ"G dd dejZ#G dd dejZ$G dd dejZ%G dd dejZ&eG dd deZ'eG dd de'Z(ed d!G d"d# d#e'Z)ed$d!G d%d& d&e'eZ*g d'Z+dS )(zPyTorch ResNet model.    N)Optional)Tensornn)BCEWithLogitsLossCrossEntropyLossMSELoss   )ACT2FN)BackboneOutputBaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)auto_docstringlogging)BackboneMixin   )ResNetConfigc                       sH   e Zd Z	ddededededef
 fd	d
ZdedefddZ  ZS )ResNetConvLayerr   r   reluin_channelsout_channelskernel_sizestride
activationc                    sV   t    tj|||||d dd| _t|| _|d ur$t| | _	d S t | _	d S )N   F)r   r   paddingbias)
super__init__r   Conv2dconvolutionBatchNorm2dnormalizationr	   Identityr   )selfr   r   r   r   r   	__class__ Y/var/www/auris/lib/python3.10/site-packages/transformers/models/resnet/modeling_resnet.pyr   *   s   
$zResNetConvLayer.__init__inputreturnc                 C   s"   |  |}| |}| |}|S N)r!   r#   r   r%   r*   hidden_stater(   r(   r)   forward4   s   


zResNetConvLayer.forward)r   r   r   )	__name__
__module____qualname__intstrr   r   r/   __classcell__r(   r(   r&   r)   r   )   s    
r   c                       s8   e Zd ZdZdef fddZdedefddZ  ZS )	ResNetEmbeddingszO
    ResNet Embeddings (stem) composed of a single aggressive convolution.
    configc                    sB   t    t|j|jdd|jd| _tjdddd| _	|j| _d S )N   r   )r   r   r   r   r   )r   r   r   )
r   r   r   num_channelsembedding_size
hidden_actembedderr   Z	MaxPool2dpoolerr%   r7   r&   r(   r)   r   @   s   
zResNetEmbeddings.__init__pixel_valuesr+   c                 C   s4   |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.)shaper9   
ValueErrorr<   r=   )r%   r?   r9   Z	embeddingr(   r(   r)   r/   H   s   



zResNetEmbeddings.forward)	r0   r1   r2   __doc__r   r   r   r/   r5   r(   r(   r&   r)   r6   ;   s    r6   c                       sB   e Zd ZdZddededef fddZded	efd
dZ  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                    s0   t    tj||d|dd| _t|| _d S )Nr   F)r   r   r   )r   r   r   r    r!   r"   r#   )r%   r   r   r   r&   r(   r)   r   Y   s   
zResNetShortCut.__init__r*   r+   c                 C   s   |  |}| |}|S r,   )r!   r#   r-   r(   r(   r)   r/   ^   s   

zResNetShortCut.forward)r   )	r0   r1   r2   rB   r3   r   r   r/   r5   r(   r(   r&   r)   rC   S   s    rC   c                	       s<   e Zd ZdZddedededef fdd	Zd
d Z  ZS )ResNetBasicLayerzO
    A classic ResNet's residual layer composed by two `3x3` convolutions.
    r   r   r   r   r   r   c                    sf   t    ||kp|dk}|rt|||dnt | _tt|||dt||d d| _t	| | _
d S )Nr   r   r   r   r   rC   r   r$   shortcut
Sequentialr   layerr	   r   )r%   r   r   r   r   should_apply_shortcutr&   r(   r)   r   i   s   
zResNetBasicLayer.__init__c                 C   .   |}|  |}| |}||7 }| |}|S r,   rJ   rH   r   r%   r.   Zresidualr(   r(   r)   r/   u      


zResNetBasicLayer.forward)r   r   )	r0   r1   r2   rB   r3   r4   r   r/   r5   r(   r(   r&   r)   rD   d   s     rD   c                       sL   e Zd ZdZ				ddededed	ed
edef fddZdd Z  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           	   
      s   t    ||kp|dk}|| }|rt|||dnt | _tt||d|r)|nddt|||s3|nddt||dd d| _t	| | _
d S )Nr   rE   )r   r   )r   r   rG   )	r%   r   r   r   r   rR   rS   rK   Zreduces_channelsr&   r(   r)   r      s   
	zResNetBottleNeckLayer.__init__c                 C   rL   r,   rM   rN   r(   r(   r)   r/      rO   zResNetBottleNeckLayer.forward)r   r   rQ   F)
r0   r1   r2   rB   r3   r4   boolr   r/   r5   r(   r(   r&   r)   rP   ~   s(    rP   c                       sN   e Zd ZdZ		ddededededef
 fdd	Zd
edefddZ  Z	S )ResNetStagez4
    A ResNet stage composed by stacked layers.
    r   r7   r   r   r   depthc                    s   t     jdkrtnt jdkr|| j jd}n	|| jd}tj|g fddt	|d D R  | _
d S )NZ
bottleneck)r   r   rS   )r   r   c                    s   g | ]
} j d qS )rF   )r;   ).0_r7   rJ   r   r(   r)   
<listcomp>   s    z(ResNetStage.__init__.<locals>.<listcomp>r   )r   r   Z
layer_typerP   rD   r;   rS   r   rI   rangelayers)r%   r7   r   r   r   rV   Zfirst_layerr&   rY   r)   r      s    

zResNetStage.__init__r*   r+   c                 C   s   |}| j D ]}||}q|S r,   )r\   )r%   r*   r.   rJ   r(   r(   r)   r/      s   

zResNetStage.forward)r   r   )
r0   r1   r2   rB   r   r3   r   r   r/   r5   r(   r(   r&   r)   rU      s     	rU   c                	       s@   e Zd Zdef fddZ	ddededed	efd
dZ  Z	S )ResNetEncoderr7   c              	      s   t    tg | _| jt||j|jd |j	rdnd|j
d d t|j|jdd  }t||j
dd  D ]\\}}}| jt||||d q9d S )Nr   r   r   )r   rV   )rV   )r   r   r   Z
ModuleListstagesappendrU   r:   hidden_sizesZdownsample_in_first_stageZdepthszip)r%   r7   Zin_out_channelsr   r   rV   r&   r(   r)   r      s   
	 zResNetEncoder.__init__FTr.   output_hidden_statesreturn_dictr+   c                 C   sb   |rdnd }| j D ]}|r||f }||}q	|r||f }|s+tdd ||fD S t||dS )Nr(   c                 s   s    | ]	}|d ur|V  qd S r,   r(   )rW   vr(   r(   r)   	<genexpr>   s    z(ResNetEncoder.forward.<locals>.<genexpr>)last_hidden_statehidden_states)r^   tupler   )r%   r.   rb   rc   rg   Zstage_moduler(   r(   r)   r/      s   



zResNetEncoder.forward)FT)
r0   r1   r2   r   r   r   rT   r   r/   r5   r(   r(   r&   r)   r]      s    r]   c                   @   s(   e Zd ZeZdZdZddgZdd ZdS )ResNetPreTrainedModelresnetr?   r   rC   c                 C   s   t |tjrtjj|jddd d S t |tjrMtjj|jt	dd |j
d urKtj|j\}}|dkr=dt	| nd}tj|j
| | d S d S t |tjtjfrhtj|jd tj|j
d d S d S )NZfan_outr   )modeZnonlinearity   )ar   r   )
isinstancer   r    initZkaiming_normal_weightLinearZkaiming_uniform_mathsqrtr   Z_calculate_fan_in_and_fan_outZuniform_r"   Z	GroupNormZ	constant_)r%   moduleZfan_inrX   boundr(   r(   r)   _init_weights   s   
z#ResNetPreTrainedModel._init_weightsN)	r0   r1   r2   r   Zconfig_classZbase_model_prefixZmain_input_nameZ_no_split_modulesrv   r(   r(   r(   r)   ri      s    ri   c                
       F   e Zd Z fddZe	d
dedee dee defdd	Z	  Z
S )ResNetModelc                    s>   t  | || _t|| _t|| _td| _	| 
  d S )N)r   r   )r   r   r7   r6   r<   r]   encoderr   ZAdaptiveAvgPool2dr=   	post_initr>   r&   r(   r)   r     s   

zResNetModel.__init__Nr?   rb   rc   r+   c                 C   s|   |d ur|n| j j}|d ur|n| j j}| |}| j|||d}|d }| |}|s6||f|dd   S t|||jdS )Nrb   rc   r   r   )rf   pooler_outputrg   )r7   rb   use_return_dictr<   ry   r=   r   rg   )r%   r?   rb   rc   embedding_outputZencoder_outputsrf   pooled_outputr(   r(   r)   r/     s    

zResNetModel.forwardNN)r0   r1   r2   r   r   r   r   rT   r   r/   r5   r(   r(   r&   r)   rx     s    	rx   z
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    )Zcustom_introc                       s\   e Zd Z fddZe				ddeej deej dee	 dee	 de
f
d	d
Z  ZS )ResNetForImageClassificationc                    s^   t  | |j| _t|| _tt |jdkr#t|j	d |jnt
 | _|   d S )Nr   )r   r   
num_labelsrx   rj   r   rI   ZFlattenrq   r`   r$   
classifierrz   r>   r&   r(   r)   r   <  s   
$z%ResNetForImageClassification.__init__Nr?   labelsrb   rc   r+   c                 C   sb  |dur|n| j j}| j|||d}|r|jn|d }| |}d}|dur| j jdu rP| jdkr6d| j _n| jdkrL|jtj	ksG|jtj
krLd| j _nd| j _| j jdkrnt }	| jdkrh|	| | }n+|	||}n%| j jdkrt }	|	|d| j|d}n| j jdkrt }	|	||}|s|f|dd  }
|dur|f|
 S |
S t|||jd	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   Z
regressionZsingle_label_classificationZmulti_label_classificationr   r   )losslogitsrg   )r7   r}   rj   r|   r   Zproblem_typer   Zdtypetorchlongr3   r   Zsqueezer   viewr   r   rg   )r%   r?   r   rb   rc   outputsr   r   r   Zloss_fctoutputr(   r(   r)   r/   H  s6   


"


z$ResNetForImageClassification.forward)NNNN)r0   r1   r2   r   r   r   r   ZFloatTensorZ
LongTensorrT   r   r/   r5   r(   r(   r&   r)   r   5  s$    r   zO
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    c                
       rw   )ResNetBackbonec                    sH   t  | t  | |jg|j | _t|| _t|| _	| 
  d S r,   )r   r   Z_init_backboner:   r`   Znum_featuresr6   r<   r]   ry   rz   r>   r&   r(   r)   r     s   

zResNetBackbone.__init__Nr?   rb   rc   r+   c                 C   s   |dur|n| j j}|dur|n| j j}| |}| j|ddd}|j}d}t| jD ]\}}	|	| jv r;||| f7 }q+|sK|f}
|rI|
|jf7 }
|
S t	||rU|jddS dddS )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_mapsrg   Z
attentions)
r7   r}   rb   r<   ry   rg   	enumerateZstage_namesZout_featuresr
   )r%   r?   rb   rc   r~   r   rg   r   idxZstager   r(   r(   r)   r/     s0   

zResNetBackbone.forwardr   )r0   r1   r2   r   r   r   r   rT   r
   r/   r5   r(   r(   r&   r)   r   {  s    r   )r   rx   ri   r   ),rB   rr   typingr   r   Ztorch.utils.checkpointr   r   Ztorch.nnr   r   r   Zactivationsr	   Zmodeling_outputsr
   r   r   r   Zmodeling_utilsr   utilsr   r   Zutils.backbone_utilsr   Zconfiguration_resnetr   Z
get_loggerr0   loggerModuler   r6   rC   rD   rP   rU   r]   ri   rx   r   r   __all__r(   r(   r(   r)   <module>   sD   
*&)'@E