o
    hC                     @   s  d 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mZmZ dd
lmZ ddlmZ ddlmZ eeZdZdZg dZ dZ!dZ"dg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+G d d! d!ej$Z,G d"d# d#eZ-d$Z.d%Z/ed&e.G d'd( d(e-Z0ed)e.G d*d+ d+e-Z1dS ),z PyTorch RegNet model.    )OptionalN)Tensornn)BCEWithLogitsLossCrossEntropyLossMSELoss   )ACT2FN)add_code_sample_docstringsadd_start_docstrings%add_start_docstrings_to_model_forward)BaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)logging   )RegNetConfigr   zfacebook/regnet-y-040)r   i@     r   ztabby, tabby catc                       sL   e Zd Z				ddededededed	ee f fd
dZdd Z  ZS )RegNetConvLayerr   r   reluin_channelsout_channelskernel_sizestridegroups
activationc              	      sX   t    tj|||||d |dd| _t|| _|d ur%t| | _	d S t | _	d S )N   F)r   r   paddingr   bias)
super__init__r   Conv2dconvolutionBatchNorm2dnormalizationr	   Identityr   )selfr   r   r   r   r   r   	__class__ `/var/www/html/ai/venv/lib/python3.10/site-packages/transformers/models/regnet/modeling_regnet.pyr!   8   s   
		$zRegNetConvLayer.__init__c                 C   s"   |  |}| |}| |}|S N)r#   r%   r   r'   hidden_stater*   r*   r+   forwardN   s   


zRegNetConvLayer.forward)r   r   r   r   )	__name__
__module____qualname__intr   strr!   r/   __classcell__r*   r*   r(   r+   r   7   s&    r   c                       s.   e Zd ZdZdef fddZdd Z  ZS )RegNetEmbeddingszP
    RegNet Embedddings (stem) composed of a single aggressive convolution.
    configc                    s0   t    t|j|jdd|jd| _|j| _d S )Nr   r   )r   r   r   )r    r!   r   num_channelsembedding_size
hidden_actembedderr'   r7   r(   r*   r+   r!   Z   s
   
zRegNetEmbeddings.__init__c                 C   s*   |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.)shaper8   
ValueErrorr;   )r'   pixel_valuesr8   r.   r*   r*   r+   r/   a   s   


zRegNetEmbeddings.forward)r0   r1   r2   __doc__r   r!   r/   r5   r*   r*   r(   r+   r6   U   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 )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   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!   r   s   
zRegNetShortCut.__init__inputreturnc                 C   s   |  |}| |}|S r,   )r#   r%   )r'   rB   r.   r*   r*   r+   r/   w   s   

zRegNetShortCut.forward)r   )	r0   r1   r2   r@   r3   r!   r   r/   r5   r*   r*   r(   r+   rA   l   s    rA   c                       s2   e Zd ZdZdedef fddZdd Z  ZS )RegNetSELayerz|
    Squeeze and Excitation layer (SE) proposed in [Squeeze-and-Excitation Networks](https://arxiv.org/abs/1709.01507).
    r   reduced_channelsc              	      sL   t    td| _ttj||ddt tj||ddt | _	d S )Nr   r   r   )r   )
r    r!   r   AdaptiveAvgPool2dpooler
Sequentialr"   ReLUSigmoid	attention)r'   r   rE   r(   r*   r+   r!      s   

zRegNetSELayer.__init__c                 C   s    |  |}| |}|| }|S r,   )rH   rL   )r'   r.   pooledrL   r*   r*   r+   r/      s   

zRegNetSELayer.forward)r0   r1   r2   r@   r3   r!   r/   r5   r*   r*   r(   r+   rD   }   s    rD   c                	       <   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 )RegNetXLayerzt
    RegNet's layer composed by three `3x3` convolutions, same as a ResNet bottleneck layer with reduction = 1.
    r   r7   r   r   r   c              
      s   t    ||kp|dk}td||j }|rt|||dnt | _tt	||d|j
dt	|||||j
dt	||dd d| _t|j
 | _d S )Nr   r   r   r   r   r   r   )r    r!   maxgroups_widthrA   r   r&   shortcutrI   r   r:   layerr	   r   r'   r7   r   r   r   should_apply_shortcutr   r(   r*   r+   r!      s   
zRegNetXLayer.__init__c                 C   .   |}|  |}| |}||7 }| |}|S r,   rV   rU   r   r'   r.   residualr*   r*   r+   r/         


zRegNetXLayer.forwardr   	r0   r1   r2   r@   r   r3   r!   r/   r5   r*   r*   r(   r+   rO      s     rO   c                	       rN   )RegNetYLayerzC
    RegNet's Y layer: an X layer with Squeeze and Excitation.
    r   r7   r   r   r   c                    s   t    ||kp|dk}td||j }|rt|||dnt | _tt	||d|j
dt	|||||j
dt|tt|d dt	||dd d| _t|j
 | _d S )Nr   rP   rQ   rR      )rE   )r    r!   rS   rT   rA   r   r&   rU   rI   r   r:   rD   r3   roundrV   r	   r   rW   r(   r*   r+   r!      s   
zRegNetYLayer.__init__c                 C   rY   r,   rZ   r[   r*   r*   r+   r/      r]   zRegNetYLayer.forwardr^   r_   r*   r*   r(   r+   r`      s     r`   c                       sD   e Zd ZdZ		ddededededef
 fdd	Zd
d Z  ZS )RegNetStagez4
    A RegNet stage composed by stacked layers.
    r   r7   r   r   r   depthc                    sZ   t     jdkrtnttj ||dg fddt|d D R  | _d S )NxrP   c                    s   g | ]} qS r*   r*   ).0_r7   rV   r   r*   r+   
<listcomp>   s    z(RegNetStage.__init__.<locals>.<listcomp>r   )	r    r!   
layer_typerO   r`   r   rI   rangelayers)r'   r7   r   r   r   rd   r(   rh   r+   r!      s   
zRegNetStage.__init__c                 C   s   |  |}|S r,   )rl   r-   r*   r*   r+   r/      s   
zRegNetStage.forward)r   r   r_   r*   r*   r(   r+   rc      s     	rc   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 )RegNetEncoderr7   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   rd   )rd   )r    r!   r   
ModuleListstagesappendrc   r9   hidden_sizesdownsample_in_first_stagedepthszip)r'   r7   in_out_channelsr   r   rd   r(   r*   r+   r!      s   
	 zRegNetEncoder.__init__FTr.   output_hidden_statesreturn_dictrC   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*   )rf   vr*   r*   r+   	<genexpr>  s    z(RegNetEncoder.forward.<locals>.<genexpr>)last_hidden_statehidden_states)ro   tupler   )r'   r.   rv   rw   r{   stage_moduler*   r*   r+   r/     s   



zRegNetEncoder.forward)FT)
r0   r1   r2   r   r!   r   boolr   r/   r5   r*   r*   r(   r+   rm      s    rm   c                   @   s$   e Zd ZdZeZdZdZdd ZdS )RegNetPreTrainedModelz
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    regnetr?   c                 C   s^   t |tjrtjj|jddd d S t |tjtjfr-tj|jd tj|j	d d S d S )Nfan_outr   )modenonlinearityr   r   )

isinstancer   r"   initkaiming_normal_weightr$   	GroupNorm	constant_r   )r'   moduler*   r*   r+   _init_weights   s   z#RegNetPreTrainedModel._init_weightsN)	r0   r1   r2   r@   r   config_classbase_model_prefixmain_input_namer   r*   r*   r*   r+   r     s    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 ([`RegNetConfig`]): 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.
aK  
    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 [`~file_utils.ModelOutput`] instead of a plain tuple.
zOThe bare RegNet model outputting raw features without any specific head on top.c                       s\   e Zd Z fddZeeeeee	de
d	ddedee dee d	efd
dZ  ZS )RegNetModelc                    s>   t  | || _t|| _t|| _td| _	| 
  d S )NrF   )r    r!   r7   r6   r;   rm   encoderr   rG   rH   	post_initr<   r(   r*   r+   r!   G  s   

zRegNetModel.__init__vision)
checkpointoutput_typer   modalityexpected_outputNr?   rv   rw   rC   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rv   rw   r   r   )rz   pooler_outputr{   )r7   rv   use_return_dictr;   r   rH   r   r{   )r'   r?   rv   rw   embedding_outputencoder_outputsrz   pooled_outputr*   r*   r+   r/   P  s    

zRegNetModel.forward)NN)r0   r1   r2   r!   r   REGNET_INPUTS_DOCSTRINGr
   _CHECKPOINT_FOR_DOCr   _CONFIG_FOR_DOC_EXPECTED_OUTPUT_SHAPEr   r   r~   r/   r5   r*   r*   r(   r+   r   A  s(    	r   z
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    c                       sp   e Zd Z fddZeeeeee	e
d				ddeej deej dee dee d	ef
d
dZ  ZS )RegNetForImageClassificationc                    s^   t  | |j| _t|| _tt |jdkr#t|j	d |jnt
 | _|   d S )Nr   )r    r!   
num_labelsr   r   r   rI   FlattenLinearrq   r&   
classifierr   r<   r(   r*   r+   r!   }  s   
$z%RegNetForImageClassification.__init__)r   r   r   r   Nr?   labelsrv   rw   rC   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   
regressionsingle_label_classificationmulti_label_classificationr   r   )losslogitsr{   )r7   r   r   r   r   problem_typer   dtypetorchlongr3   r   squeezer   viewr   r   r{   )r'   r?   r   rv   rw   outputsr   r   r   loss_fctoutputr*   r*   r+   r/     s6   


"


z$RegNetForImageClassification.forward)NNNN)r0   r1   r2   r!   r   r   r
   _IMAGE_CLASS_CHECKPOINTr   r   _IMAGE_CLASS_EXPECTED_OUTPUTr   r   FloatTensor
LongTensorr~   r/   r5   r*   r*   r(   r+   r   t  s0    	r   )2r@   typingr   r   torch.utils.checkpointr   r   torch.nnr   r   r   activationsr	   
file_utilsr
   r   r   modeling_outputsr   r   r   modeling_utilsr   utilsr   configuration_regnetr   
get_loggerr0   loggerr   r   r   r   r   $REGNET_PRETRAINED_MODEL_ARCHIVE_LISTModuler   r6   rA   rD   rO   r`   rc   rm   r   REGNET_START_DOCSTRINGr   r   r   r*   r*   r*   r+   <module>   sR   
!&.