U
    ,-e}D                     @   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ddddg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-040i@     ztabby, tabby catc                       s:   e Zd Zd	eeeeeee d fddZdd Z  ZS )
RegNetConvLayerr   r   relu)in_channelsout_channelskernel_sizestridegroups
activationc              	      sR   t    tj|||||d |dd| _t|| _|d k	rDt| nt | _	d S )N   F)r   r   paddingr   bias)
super__init__r   Conv2dconvolutionBatchNorm2dnormalizationr	   Identityr   )selfr   r   r   r   r   r   	__class__ k/var/www/html/Darija-Ai-Train/env/lib/python3.8/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ed 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'   r8   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.)shaper9   
ValueErrorr<   )r'   pixel_valuesr9   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                       s<   e Zd ZdZd	eeed fddZeed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'   rC   r.   r*   r*   r+   r/   w   s    

zRegNetShortCut.forward)r   )	r0   r1   r2   rA   r3   r!   r   r/   r5   r*   r*   r(   r+   rB   l   s   rB   c                       s0   e Zd ZdZeed 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"   ZReLUZSigmoid	attention)r'   r   rF   r(   r*   r+   r!      s    
zRegNetSELayer.__init__c                 C   s    |  |}| |}|| }|S r,   )rI   rK   )r'   r.   ZpooledrK   r*   r*   r+   r/      s    

zRegNetSELayer.forward)r0   r1   r2   rA   r3   r!   r/   r5   r*   r*   r(   r+   rE   }   s   rE   c                       s6   e Zd ZdZdeeeed 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   r8   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_widthrB   r   r&   shortcutrJ   r   r;   layerr	   r   r'   r8   r   r   r   Zshould_apply_shortcutr   r(   r*   r+   r!      s    
zRegNetXLayer.__init__c                 C   s.   |}|  |}| |}||7 }| |}|S r,   rT   rS   r   r'   r.   Zresidualr*   r*   r+   r/      s    


zRegNetXLayer.forward)r   	r0   r1   r2   rA   r   r3   r!   r/   r5   r*   r*   r(   r+   rL      s   rL   c                       s6   e Zd ZdZdeeeed fddZdd Z  ZS )	RegNetYLayerzC
    RegNet's Y layer: an X layer with Squeeze and Excitation.
    r   rM   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   rN   rO   rP      )rF   )r    r!   rQ   rR   rB   r   r&   rS   rJ   r   r;   rE   r3   roundrT   r	   r   rU   r(   r*   r+   r!      s    
zRegNetYLayer.__init__c                 C   s.   |}|  |}| |}||7 }| |}|S r,   rV   rW   r*   r*   r+   r/      s    


zRegNetYLayer.forward)r   rX   r*   r*   r(   r+   rY      s   rY   c                       s8   e Zd ZdZdeeeeed fddZdd Z  ZS )	RegNetStagez4
    A RegNet stage composed by stacked layers.
    r   )r8   r   r   r   depthc                    sX   t     jdkrtnttj ||df fddt|d D  | _d S )NxrN   c                    s   g | ]} qS r*   r*   ).0_r8   rT   r   r*   r+   
<listcomp>   s     z(RegNetStage.__init__.<locals>.<listcomp>r   )	r    r!   Z
layer_typerL   rY   r   rJ   rangelayers)r'   r8   r   r   r   r]   r(   ra   r+   r!      s    
zRegNetStage.__init__c                 C   s   |  |}|S r,   )rd   r-   r*   r*   r+   r/      s    
zRegNetStage.forward)r   r   rX   r*   r*   r(   r+   r\      s   	  r\   c                       s8   e Zd Zed fddZd	eeeedddZ  Z	S )
RegNetEncoderr7   c              	      s   t    tg | _| jt||j|jd |j	r6dnd|j
d d t|j|jdd  }t||j
dd  D ]$\\}}}| jt||||d qrd S )Nr   r   r   )r   r]   )r]   )r    r!   r   Z
ModuleListstagesappendr\   r:   hidden_sizesZdownsample_in_first_stageZdepthszip)r'   r8   Zin_out_channelsr   r   r]   r(   r*   r+   r!      s    
	 zRegNetEncoder.__init__FT)r.   output_hidden_statesreturn_dictrD   c                 C   sb   |rdnd }| j D ]}|r$||f }||}q|r<||f }|sVtdd ||fD S t||dS )Nr*   c                 s   s   | ]}|d k	r|V  qd S r,   r*   )r_   vr*   r*   r+   	<genexpr>  s      z(RegNetEncoder.forward.<locals>.<genexpr>)last_hidden_statehidden_states)rf   tupler   )r'   r.   rj   rk   ro   Zstage_moduler*   r*   r+   r/     s    



zRegNetEncoder.forward)FT)
r0   r1   r2   r   r!   r   boolr   r/   r5   r*   r*   r(   r+   re      s        re   c                   @   s2   e Zd ZdZeZdZdZdZdd Z	ddd	Z
d
S )RegNetPreTrainedModelz
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    regnetr@   Tc                 C   sX   t |tjr"tjj|jddd n2t |tjtjfrTtj|jd tj|j	d d S )NZfan_outr   )modeZnonlinearityr   r   )

isinstancer   r"   initZkaiming_normal_weightr$   Z	GroupNormZ	constant_r   )r'   moduler*   r*   r+   _init_weights!  s
    z#RegNetPreTrainedModel._init_weightsFc                 C   s   t |tr||_d S r,   )ru   RegNetModelZgradient_checkpointing)r'   rx   valuer*   r*   r+   _set_gradient_checkpointing(  s    
z1RegNetPreTrainedModel._set_gradient_checkpointingN)F)r0   r1   r2   rA   r   config_classZbase_model_prefixZmain_input_nameZsupports_gradient_checkpointingry   r|   r*   r*   r*   r+   rr     s   rr   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                       sT   e Zd Z fddZeeeeee	de
dd	eee ee edddZ  ZS )
rz   c                    s>   t  | || _t|| _t|| _td| _	| 
  d S )NrG   )r    r!   r8   r6   r<   re   encoderr   rH   rI   	post_initr=   r(   r*   r+   r!   L  s    

zRegNetModel.__init__Zvision)
checkpointoutput_typer}   Zmodalityexpected_outputN)r@   rj   rk   rD   c                 C   s|   |d k	r|n| j j}|d k	r |n| j j}| |}| j|||d}|d }| |}|sl||f|dd   S t|||jdS )Nrj   rk   r   r   )rn   pooler_outputro   )r8   rj   use_return_dictr<   r~   rI   r   ro   )r'   r@   rj   rk   Zembedding_outputZencoder_outputsrn   pooled_outputr*   r*   r+   r/   U  s$    
  
zRegNetModel.forward)NN)r0   r1   r2   r!   r   REGNET_INPUTS_DOCSTRINGr
   _CHECKPOINT_FOR_DOCr   _CONFIG_FOR_DOC_EXPECTED_OUTPUT_SHAPEr   r   rq   r/   r5   r*   r*   r(   r+   rz   F  s"   	     rz   z
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    c                	       s`   e Zd Z fddZeeeeee	e
ddeej eej ee ee edddZ  ZS )	RegNetForImageClassificationc                    s^   t  | |j| _t|| _tt |jdkrFt|j	d |jnt
 | _|   d S )Nr   )r    r!   
num_labelsrz   rs   r   rJ   ZFlattenZLinearrh   r&   
classifierr   r=   r(   r*   r+   r!     s    
$z%RegNetForImageClassification.__init__)r   r   r}   r   N)r@   labelsrj   rk   rD   c                 C   sl  |dk	r|n| j j}| j|||d}|r.|jn|d }| |}d}|dk	r,| j jdkr| jdkrnd| j _n4| jdkr|jtj	ks|jtj
krd| j _nd| j _| j jdkrt }	| jdkr|	| | }n
|	||}nN| j jdkrt }	|	|d| j|d}n| j jdkr,t }	|	||}|s\|f|dd  }
|dk	rX|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logitsro   )r8   r   rs   r   r   Zproblem_typer   Zdtypetorchlongr3   r   Zsqueezer   viewr   r   ro   )r'   r@   r   rj   rk   outputsr   r   r   Z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   ZFloatTensorZ
LongTensorrq   r/   r5   r*   r*   r(   r+   r   y  s&   	    r   )2rA   typingr   r   Ztorch.utils.checkpointr   r   Ztorch.nnr   r   r   Zactivationsr	   Z
file_utilsr
   r   r   Zmodeling_outputsr   r   r   Zmodeling_utilsr   utilsr   Zconfiguration_regnetr   Z
get_loggerr0   loggerr   r   r   r   r   Z$REGNET_PRETRAINED_MODEL_ARCHIVE_LISTModuler   r6   rB   rE   rL   rY   r\   re   rr   ZREGNET_START_DOCSTRINGr   rz   r   r*   r*   r*   r+   <module>   sP   
!&.