o
    	۷i<                     @   sT  d Z ddlmZmZmZ ddlZddlmZ ddlmZ ddl	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 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!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 TextNet model.    )AnyOptionalUnionN)Tensor)PreTrainedModel)ACT2CLS)BackboneOutputBaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)TextNetConfig)logging)BackboneMixin   )auto_docstringc                       s8   e Zd Zdef fddZdejdejfddZ  ZS )TextNetConvLayerconfigc                    s   t    |j| _|j| _|j| _t|jt	r%|jd d |jd d fn|jd }t
j|j|j|j|j|dd| _t
|j|j| _t
 | _| jd urVt| j  | _d S d S )Nr         F)kernel_sizestridepaddingbias)super__init__stem_kernel_sizer   stem_strider   stem_act_funcactivation_function
isinstancetuplennConv2dstem_num_channelsstem_out_channelsconvBatchNorm2dbatch_norm_eps
batch_normIdentity
activationr   )selfr   r   	__class__ b/home/ubuntu/vllm_env/lib/python3.10/site-packages/transformers/models/textnet/modeling_textnet.pyr   *   s*   



zTextNetConvLayer.__init__hidden_statesreturnc                 C   s   |  |}| |}| |S N)r%   r(   r*   )r+   r0   r.   r.   r/   forwardE   s   


zTextNetConvLayer.forward)	__name__
__module____qualname__r   r   torchr   r3   __classcell__r.   r.   r,   r/   r   )   s    r   c                
       sL   e Zd ZdZdededededef
 fddZd	ejd
ejfddZ	  Z
S )TextNetRepConvLayera  
    This layer supports re-parameterization by combining multiple convolutional branches
    (e.g., main convolution, vertical, horizontal, and identity branches) during training.
    At inference time, these branches can be collapsed into a single convolution for
    efficiency, as per the re-parameterization paradigm.

    The "Rep" in the name stands for "re-parameterization" (introduced by RepVGG).
    r   in_channelsout_channelsr   r   c           	         sf  t    || _|| _|| _|| _|d d d |d d d f}t | _tj	|||||dd| _
tj||jd| _|d d d df}d|d d d f}|d dkrotj	|||d df||dd| _tj||jd| _nd\| _| _|d dkrtj	||d|d f||dd| _tj||jd| _nd\| _| _||kr|dkrtj||jd| _d S d | _d S )Nr   r   r   F)r:   r;   r   r   r   r   )num_featuresepsNN)r   r   num_channelsr;   r   r   r!   ReLUr   r"   	main_convr&   r'   main_batch_normvertical_convvertical_batch_normhorizontal_convhorizontal_batch_normrbr_identity)	r+   r   r:   r;   r   r   r   vertical_paddinghorizontal_paddingr,   r.   r/   r   U   sZ   
 


zTextNetRepConvLayer.__init__r0   r1   c                 C   s   |  |}| |}| jd ur| |}| |}|| }| jd ur0| |}| |}|| }| jd ur>| |}|| }| |S r2   )rA   rB   rC   rD   rE   rF   rG   r   )r+   r0   main_outputsvertical_outputshorizontal_outputsid_outr.   r.   r/   r3      s   










zTextNetRepConvLayer.forward)r4   r5   r6   __doc__r   intr   r7   r   r3   r8   r.   r.   r,   r/   r9   K   s    "	9r9   c                       s.   e Zd Zdedef fddZdd Z  ZS )TextNetStager   depthc                    s   t    |j| }|j| }t|}|j| }|j|d  }|g|g|d   }|g| }	g }
t||	||D ]}|
t|g|R   q7t	
|
| _d S )Nr   )r   r   conv_layer_kernel_sizesconv_layer_strideslenhidden_sizeszipappendr9   r!   
ModuleListstage)r+   r   rQ   r   r   
num_layersstage_in_channel_sizestage_out_channel_sizer:   r;   rY   stage_configr,   r.   r/   r      s   




zTextNetStage.__init__c                 C   s   | j D ]}||}q|S r2   )rY   )r+   hidden_stateblockr.   r.   r/   r3      s   

zTextNetStage.forward)r4   r5   r6   r   rO   r   r3   r8   r.   r.   r,   r/   rP      s    rP   c                	       sL   e Zd Zdef fddZ		ddejdee dee de	fd	d
Z
  ZS )TextNetEncoderr   c                    sF   t    g }t|j}t|D ]
}|t|| qt|| _	d S r2   )
r   r   rT   rR   rangerW   rP   r!   rX   stages)r+   r   rb   
num_stagesstage_ixr,   r.   r/   r      s   

zTextNetEncoder.__init__Nr^   output_hidden_statesreturn_dictr1   c                 C   sL   |g}| j D ]}||}|| q|s |f}|r||f S |S t||dS )N)last_hidden_stater0   )rb   rW   r	   )r+   r^   re   rf   r0   rY   outputr.   r.   r/   r3      s   
zTextNetEncoder.forwardr>   )r4   r5   r6   r   r   r7   r   r   boolr	   r3   r8   r.   r.   r,   r/   r`      s    r`   c                   @   s&   e Zd ZU eed< dZdZdd ZdS )TextNetPreTrainedModelr   textnetpixel_valuesc                 C   s   t |tjtjfr#|jjjd| jjd |j	d ur!|j	j
  d S d S t |tjr=|jjd |j	d ur?|j	j
  d S d S d S )Ng        )meanstdg      ?)r   r!   Linearr"   weightdatanormal_r   initializer_ranger   zero_r&   fill_)r+   moduler.   r.   r/   _init_weights   s   

z$TextNetPreTrainedModel._init_weightsN)r4   r5   r6   r   __annotations__base_model_prefixmain_input_namerw   r.   r.   r.   r/   rj      s
   
 rj   c                       s`   e Zd Z fddZe	d
dedee dee dee	e
ee
 f e	e
 ef fdd	Z  ZS )TextNetModelc                    s8   t  | t|| _t|| _td| _| 	  d S )N)r   r   )
r   r   r   stemr`   encoderr!   AdaptiveAvgPool2dpooler	post_initr+   r   r,   r.   r/   r      s
   

zTextNetModel.__init__Nrl   re   rf   r1   c           	      C   s   |d ur|n| j j}|d ur|n| j j}| |}| j|||d}|d }| |}|s;||f}|r9||d f S |S t|||rF|d dS d dS )Nre   rf   r   r   )rg   pooler_outputr0   )r   use_return_dictre   r|   r}   r   r
   )	r+   rl   re   rf   r^   encoder_outputsrg   pooled_outputrh   r.   r.   r/   r3      s&   


zTextNetModel.forwardr>   )r4   r5   r6   r   r   r   r   ri   r   r    r   listr
   r3   r8   r.   r.   r,   r/   r{      s    r{   z
    TextNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    )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 )TextNetForImageClassificationc                    s|   t  | |j| _t|| _td| _t | _	|jdkr)t
|jd |jnt | _t| j| j	g| _|   d S )N)r   r   r   )r   r   
num_labelsr{   rk   r!   r~   avg_poolFlattenflattenro   rU   r)   fcrX   
classifierr   r   r,   r.   r/   r     s   

(z&TextNetForImageClassification.__init__Nrl   labelsre   rf   r1   c                 C   s   |dur|n| j j}| j|||d}|d }| jD ]}||}q| |}d}	|dur3| ||| j }	|sI|f|dd  }
|	durG|	f|
 S |
S t|	||jdS )al  
        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 regression loss is computed (Mean-Square loss), If
            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).

        Examples:
        ```python
        >>> import torch
        >>> import requests
        >>> from transformers import TextNetForImageClassification, TextNetImageProcessor
        >>> from PIL import Image

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = Image.open(requests.get(url, stream=True).raw)

        >>> processor = TextNetImageProcessor.from_pretrained("czczup/textnet-base")
        >>> model = TextNetForImageClassification.from_pretrained("czczup/textnet-base")

        >>> inputs = processor(images=image, return_tensors="pt")
        >>> with torch.no_grad():
        ...     outputs = model(**inputs)
        >>> outputs.logits.shape
        torch.Size([1, 2])
        ```Nr   r   r   )losslogitsr0   )r   r   rk   r   r   loss_functionr   r0   )r+   rl   r   re   rf   outputsrg   layerr   r   rh   r.   r.   r/   r3   &  s   !


z%TextNetForImageClassification.forward)NNNN)r4   r5   r6   r   r   r   r7   FloatTensor
LongTensorri   r   r3   r8   r.   r.   r,   r/   r     s$    r   zP
    TextNet backbone, to be used with frameworks like DETR and MaskFormer.
    c                       sV   e Zd ZdZ fddZe	ddedee dee de	e
e
 ef fd	d
Z  ZS )TextNetBackboneFc                    s6   t  | t  | t|| _|j| _|   d S r2   )r   r   _init_backboner{   rk   rU   r<   r   r   r,   r.   r/   r   b  s
   
zTextNetBackbone.__init__Nrl   re   rf   r1   c           
      C   s   |dur|n| j j}|dur|n| j j}| j|d|d}|r!|jn|d }d}t| jD ]\}}|| jv r<||| f7 }q,|sT|f}	|rR|rI|jn|d }|	|f7 }	|	S t||r^|jddS dddS )a  
        Examples:

        ```python
        >>> import torch
        >>> import requests
        >>> from PIL import Image
        >>> from transformers import AutoImageProcessor, AutoBackbone

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = Image.open(requests.get(url, stream=True).raw)

        >>> processor = AutoImageProcessor.from_pretrained("czczup/textnet-base")
        >>> model = AutoBackbone.from_pretrained("czczup/textnet-base")

        >>> inputs = processor(image, return_tensors="pt")
        >>> with torch.no_grad():
        >>>     outputs = model(**inputs)
        ```NTr   r   r.   )feature_mapsr0   
attentions)	r   r   re   rk   r0   	enumeratestage_namesout_featuresr   )
r+   rl   re   rf   r   r0   r   idxrY   rh   r.   r.   r/   r3   l  s0   

zTextNetBackbone.forwardr>   )r4   r5   r6   has_attentionsr   r   r   r   ri   r   r    r   r3   r8   r.   r.   r,   r/   r   Z  s    
r   )r   r{   rj   r   )'rN   typingr   r   r   r7   torch.nnr!   r   transformersr   transformers.activationsr   transformers.modeling_outputsr   r	   r
   r   1transformers.models.textnet.configuration_textnetr   transformers.utilsr   !transformers.utils.backbone_utilsr   utilsr   
get_loggerr4   loggerModuler   r9   rP   r`   rj   r{   r   r   __all__r.   r.   r.   r/   <module>   s<   
"Z%C@