Ë
    S^(hŠR  ã            	       óL  — d Z ddlZddlmZ ddlmZmZmZ ddlZddl	Zddl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 ddlmZmZmZmZ ddlmZ  ej<                  e«      Z dZ!dZ"g d¢Z#dZ$dZ%d5dejL                  de'de(dejL                  fd„Z) G d„ de
jT                  «      Z+ G d„ de
jT                  «      Z, G d„ de
jT                  «      Z- G d„ de
jT                  «      Z. G d„ d e
jT                  «      Z/ G d!„ d"e
jT                  «      Z0 G d#„ d$e
jT                  «      Z1 G d%„ d&e
jT                  «      Z2 G d'„ d(e
jT                  «      Z3 G d)„ d*e
jT                  «      Z4 G d+„ d,e«      Z5d-Z6d.Z7 ed/e6«       G d0„ d1e5«      «       Z8 ed2e6«       G d3„ d4e5«      «       Z9y)6z-PyTorch Visual Attention Network (VAN) model.é    N)ÚOrderedDict)ÚOptionalÚTupleÚUnion)Únn)ÚBCEWithLogitsLossÚCrossEntropyLossÚMSELossé   )ÚACT2FN)ÚBaseModelOutputWithNoAttentionÚ(BaseModelOutputWithPoolingAndNoAttentionÚ$ImageClassifierOutputWithNoAttention)ÚPreTrainedModel)Úadd_code_sample_docstringsÚadd_start_docstringsÚ%add_start_docstrings_to_model_forwardÚloggingé   )Ú	VanConfigr   z!Visual-Attention-Network/van-base)r   i   é   r   ztabby, tabby catÚinputÚ	drop_probÚtrainingÚreturnc                 ó  — |dk(  s|s| S d|z
  }| j                   d   fd| j                  dz
  z  z   }|t        j                  || j                  | j
                  ¬«      z   }|j                  «        | j                  |«      |z  }|S )aF  
    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).

    Comment by Ross Wightman: This is the same as the DropConnect impl I created for EfficientNet, etc networks,
    however, the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper...
    See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for changing the
    layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use 'survival rate' as the
    argument.
    ç        r   r   )r   )ÚdtypeÚdevice)ÚshapeÚndimÚtorchÚrandr   r   Úfloor_Údiv)r   r   r   Ú	keep_probr    Úrandom_tensorÚoutputs          úm/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/transformers/models/deprecated/van/modeling_van.pyÚ	drop_pathr*   3   s�   € ð �CÒ™xØˆØ�I‘€IØ�[‰[˜‰^Ð ¨¯
©
°Q©Ñ 7Ñ7€EØ¤§
¡
¨5¸¿¹ÈEÏLÉLÔ YÑY€MØ×ÑÔØ�Y‰Y�yÓ! MÑ1€FØ€Mó    c                   óx   ‡ — e Zd ZdZd	dee   ddfˆ fd„Zdej                  dej                  fd„Z	de
fd„Zˆ xZS )
ÚVanDropPathzXDrop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).Nr   r   c                 ó0   •— t         ‰| �  «        || _        y ©N)ÚsuperÚ__init__r   )Úselfr   Ú	__class__s     €r)   r1   zVanDropPath.__init__J   s   ø€ Ü‰ÑÔØ"ˆ�r+   Úhidden_statesc                 óD   — t        || j                  | j                  «      S r/   )r*   r   r   )r2   r4   s     r)   ÚforwardzVanDropPath.forwardN   s   € Ü˜¨¯©¸¿¹ÓFÐFr+   c                 ó8   — dj                  | j                  «      S )Nzp={})Úformatr   )r2   s    r)   Ú
extra_reprzVanDropPath.extra_reprQ   s   € Ø�}‰}˜TŸ^™^Ó,Ð,r+   r/   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   Úfloatr1   r"   ÚTensorr6   Ústrr9   Ú__classcell__©r3   s   @r)   r-   r-   G   sG   ø„ Ùbñ# (¨5¡/ð #¸Tõ #ðG U§\¡\ð G°e·l±ló Gð-˜C÷ -r+   r-   c            	       ón   ‡ — e Zd ZdZd
dedededefˆ fd„Zdej                  dej                  fd	„Zˆ xZ	S )ÚVanOverlappingPatchEmbedderzû
    Downsamples the input using a patchify operation with a `stride` of 4 by default making adjacent windows overlap by
    half of the area. From [PVTv2: Improved Baselines with Pyramid Vision
    Transformer](https://arxiv.org/abs/2106.13797).
    Úin_channelsÚhidden_sizeÚ
patch_sizeÚstridec                 óš   •— t         ‰| �  «        t        j                  |||||dz  ¬«      | _        t        j
                  |«      | _        y )Né   )Úkernel_sizerH   Úpadding)r0   r1   r   ÚConv2dÚconvolutionÚBatchNorm2dÚnormalization)r2   rE   rF   rG   rH   r3   s        €r)   r1   z$VanOverlappingPatchEmbedder.__init__\   sD   ø€ Ü‰ÑÔÜŸ9™9Ø˜°*ÀVÐU_ÐcdÑUdô
ˆÔô  Ÿ^™^¨KÓ8ˆÕr+   r   r   c                 óJ   — | j                  |«      }| j                  |«      }|S r/   )rN   rP   )r2   r   Úhidden_states      r)   r6   z#VanOverlappingPatchEmbedder.forwardc   s(   € Ø×'Ñ'¨Ó.ˆØ×)Ñ)¨,Ó7ˆØÐr+   )r   r   ©
r:   r;   r<   r=   Úintr1   r"   r?   r6   rA   rB   s   @r)   rD   rD   U   sE   ø„ ññ9 Cð 9°cð 9Àsð 9ÐX[õ 9ð˜UŸ\™\ð ¨e¯l©l÷ r+   rD   c                   óv   ‡ — e Zd ZdZ	 	 ddededededef
ˆ fd„Zdej                  d	ej                  fd
„Z
ˆ xZS )ÚVanMlpLayerz’
    MLP with depth-wise convolution, from [PVTv2: Improved Baselines with Pyramid Vision
    Transformer](https://arxiv.org/abs/2106.13797).
    rE   rF   Úout_channelsÚ
hidden_actÚdropout_ratec                 óX  •— t         ‰| �  «        t        j                  ||d¬«      | _        t        j                  ||dd|¬«      | _        t        |   | _        t        j                  |«      | _	        t        j                  ||d¬«      | _
        t        j                  |«      | _        y )Nr   ©rK   é   ©rK   rL   Úgroups)r0   r1   r   rM   Úin_denseÚ
depth_wiser   Ú
activationÚDropoutÚdropout1Ú	out_denseÚdropout2)r2   rE   rF   rW   rX   rY   r3   s         €r)   r1   zVanMlpLayer.__init__o   s~   ø€ ô 	‰ÑÔÜŸ	™	 +¨{ÈÔJˆŒÜŸ)™) K°È!ÐUVÐ_jÔkˆŒÜ  Ñ,ˆŒÜŸ
™
 <Ó0ˆŒÜŸ™ ;°È!ÔLˆŒÜŸ
™
 <Ó0ˆ�r+   rR   r   c                 óÒ   — | j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }| j	                  |«      }| j                  |«      }|S r/   )r_   r`   ra   rc   rd   re   ©r2   rR   s     r)   r6   zVanMlpLayer.forward   s\   € Ø—}‘} \Ó2ˆØ—‘ |Ó4ˆØ—‘ |Ó4ˆØ—}‘} \Ó2ˆØ—~‘~ lÓ3ˆØ—}‘} \Ó2ˆØÐr+   )Úgeluç      à?)r:   r;   r<   r=   rT   r@   r>   r1   r"   r?   r6   rA   rB   s   @r)   rV   rV   i   s`   ø„ ñð !Ø!ñ1àð1ð ð1ð ð	1ð
 ð1ð õ1ð  E§L¡Lð °U·\±\÷ r+   rV   c                   ó`   ‡ — e Zd ZdZdefˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )ÚVanLargeKernelAttentionz-
    Basic Large Kernel Attention (LKA).
    rF   c                 óÚ   •— t         ‰| �  «        t        j                  ||dd|¬«      | _        t        j                  ||ddd|¬«      | _        t        j                  ||d¬	«      | _        y )
Né   rJ   r]   r   r\   é	   )rK   ÚdilationrL   r^   r   r[   )r0   r1   r   rM   r`   Údepth_wise_dilatedÚ
point_wise©r2   rF   r3   s     €r)   r1   z VanLargeKernelAttention.__init__Ž   s]   ø€ Ü‰ÑÔÜŸ)™) K°È!ÐUVÐ_jÔkˆŒÜ"$§)¡)Ø˜°!¸aÈÐS^ô#
ˆÔô Ÿ)™) K°È!ÔLˆ�r+   rR   r   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S r/   )r`   rp   rq   rg   s     r)   r6   zVanLargeKernelAttention.forward–   s4   € Ø—‘ |Ó4ˆØ×.Ñ.¨|Ó<ˆØ—‘ |Ó4ˆØÐr+   rS   rB   s   @r)   rk   rk   ‰   s1   ø„ ñðM Cõ Mð E§L¡Lð °U·\±\÷ r+   rk   c                   ó`   ‡ — e Zd ZdZdefˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )ÚVanLargeKernelAttentionLayerzV
    Computes attention using Large Kernel Attention (LKA) and attends the input.
    rF   c                 óB   •— t         ‰| �  «        t        |«      | _        y r/   )r0   r1   rk   Ú	attentionrr   s     €r)   r1   z%VanLargeKernelAttentionLayer.__init__¢   s   ø€ Ü‰ÑÔÜ0°Ó=ˆ�r+   rR   r   c                 ó2   — | j                  |«      }||z  }|S r/   )rw   )r2   rR   rw   Úattendeds       r)   r6   z$VanLargeKernelAttentionLayer.forward¦   s   € Ø—N‘N <Ó0ˆ	Ø )Ñ+ˆØˆr+   rS   rB   s   @r)   ru   ru   �   s/   ø„ ñð> Cõ >ð E§L¡Lð °U·\±\÷ r+   ru   c                   óf   ‡ — e Zd ZdZddedefˆ fd„Zdej                  dej                  fd„Z	ˆ xZ
S )	ÚVanSpatialAttentionLayerz¬
    Van spatial attention layer composed by projection (via conv) -> act -> Large Kernel Attention (LKA) attention ->
    projection (via conv) + residual connection.
    rF   rX   c           
      ó  •— t         ‰| �  «        t        j                  t	        dt        j
                  ||d¬«      fdt        |   fg«      «      | _        t        |«      | _	        t        j
                  ||d¬«      | _
        y )NÚconvr   r[   Úact)r0   r1   r   Ú
Sequentialr   rM   r   Úpre_projectionru   Úattention_layerÚpost_projection)r2   rF   rX   r3   s      €r)   r1   z!VanSpatialAttentionLayer.__init__²   sr   ø€ Ü‰ÑÔÜ Ÿm™mÜàœRŸY™Y {°KÈQÔOÐPØœF :Ñ.Ð/ðóó
ˆÔô  <¸KÓHˆÔÜ!Ÿy™y¨°kÈqÔQˆÕr+   rR   r   c                 óz   — |}| j                  |«      }| j                  |«      }| j                  |«      }||z   }|S r/   )r€   r�   r‚   ©r2   rR   Úresiduals      r)   r6   z VanSpatialAttentionLayer.forward¿   sG   € ØˆØ×*Ñ*¨<Ó8ˆØ×+Ñ+¨LÓ9ˆØ×+Ñ+¨LÓ9ˆØ# hÑ.ˆØÐr+   )rh   )r:   r;   r<   r=   rT   r@   r1   r"   r?   r6   rA   rB   s   @r)   r{   r{   ¬   s9   ø„ ññ
R Cð R°Sõ Rð E§L¡Lð °U·\±\÷ r+   r{   c                   óf   ‡ — e Zd ZdZddedefˆ fd„Zdej                  dej                  fd„Z	ˆ xZ
S )	ÚVanLayerScalingzT
    Scales the inputs by a learnable parameter initialized by `initial_value`.
    rF   Úinitial_valuec                 ó†   •— t         ‰| �  «        t        j                  |t	        j
                  |«      z  d¬«      | _        y )NT)Úrequires_grad)r0   r1   r   Ú	Parameterr"   ÚonesÚweight)r2   rF   rˆ   r3   s      €r)   r1   zVanLayerScaling.__init__Í   s/   ø€ Ü‰ÑÔÜ—l‘l =´5·:±:¸{Ó3LÑ#LÐ\`Ôaˆ�r+   rR   r   c                 ó`   — | j                   j                  d«      j                  d«      |z  }|S )Néÿÿÿÿ)r�   Ú	unsqueezerg   s     r)   r6   zVanLayerScaling.forwardÑ   s,   € à—{‘{×,Ñ,¨RÓ0×:Ñ:¸2Ó>ÀÑMˆØÐr+   )g{®Gáz„?)r:   r;   r<   r=   rT   r>   r1   r"   r?   r6   rA   rB   s   @r)   r‡   r‡   È   s9   ø„ ññb Cð b¸õ bð E§L¡Lð °U·\±\÷ r+   r‡   c            	       ór   ‡ — e Zd ZdZ	 	 d
dedededefˆ fd„Zdej                  dej                  fd	„Z
ˆ xZS )ÚVanLayerzv
    Van layer composed by normalization layers, large kernel attention (LKA) and a multi layer perceptron (MLP).
    ÚconfigrF   Ú	mlp_ratioÚdrop_path_ratec                 óÔ  •— t         ‰| �  «        |dkD  rt        |«      nt        j                  «       | _        t        j                  |«      | _        t        ||j                  «      | _
        t        ||j                  «      | _        t        j                  |«      | _        t        |||z  ||j                  |j                   «      | _        t        ||j                  «      | _        y )Nr   )r0   r1   r-   r   ÚIdentityr*   rO   Úpre_normomalizationr{   rX   rw   r‡   Úlayer_scale_init_valueÚattention_scalingÚpost_normalizationrV   rY   ÚmlpÚmlp_scaling)r2   r“   rF   r”   r•   r3   s        €r)   r1   zVanLayer.__init__Ü   sº   ø€ ô 	‰ÑÔØ8FÈÒ8Lœ ^Ô4ÔRT×R]ÑR]ÓR_ˆŒÜ#%§>¡>°+Ó#>ˆÔ Ü1°+¸v×?PÑ?PÓQˆŒÜ!0°¸f×>[Ñ>[Ó!\ˆÔÜ"$§.¡.°Ó"=ˆÔÜØ˜ yÑ0°+¸v×?PÑ?PÐRX×ReÑReó
ˆŒô +¨;¸×8UÑ8UÓVˆÕr+   rR   r   c                 ó2  — |}| j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }||z   }|}| j	                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }||z   }|S r/   )r˜   rw   rš   r*   r›   rœ   r�   r„   s      r)   r6   zVanLayer.forwardî   sž   € Øˆà×/Ñ/°Ó=ˆØ—~‘~ lÓ3ˆØ×-Ñ-¨lÓ;ˆØ—~‘~ lÓ3ˆà ,Ñ.ˆØˆà×.Ñ.¨|Ó<ˆØ—x‘x Ó-ˆØ×'Ñ'¨Ó5ˆØ—~‘~ lÓ3ˆà ,Ñ.ˆØÐr+   )r   ri   ©r:   r;   r<   r=   r   rT   r>   r1   r"   r?   r6   rA   rB   s   @r)   r’   r’   ×   s[   ø„ ñð Ø #ñWàðWð ðWð ð	Wð
 õWð$ E§L¡Lð °U·\±\÷ r+   r’   c                   ó‚   ‡ — e Zd ZdZ	 	 ddededededededed	efˆ fd
„Zdej                  dej                  fd„Z
ˆ xZS )ÚVanStagez2
    VanStage, consisting of multiple layers.
    r“   rE   rF   rG   rH   Údepthr”   r•   c	                 ó  •— t         ‰
| �  «        t        ||||«      | _        t	        j
                  t        |«      D �	cg c]  }	t        ||||¬«      ‘Œ c}	Ž | _        t	        j                  ||j                  ¬«      | _        y c c}	w )N)r”   r•   ©Úeps)r0   r1   rD   Ú
embeddingsr   r   Úranger’   ÚlayersÚ	LayerNormÚlayer_norm_epsrP   )r2   r“   rE   rF   rG   rH   r¢   r”   r•   Ú_r3   s             €r)   r1   zVanStage.__init__  sƒ   ø€ ô 	‰ÑÔÜ5°kÀ;ÐPZÐ\bÓcˆŒÜ—m‘mô ˜u›öð ô ØØØ'Ø#1ö	òð

ˆŒô  Ÿ\™\¨+¸6×;PÑ;PÔQˆÕùòs   ¿BrR   r   c                 ó  — | j                  |«      }| j                  |«      }|j                  \  }}}}|j                  d«      j	                  dd«      }| j                  |«      }|j                  ||||«      j                  dddd«      }|S )NrJ   r   r   r\   )r¦   r¨   r    ÚflattenÚ	transposerP   ÚviewÚpermute)r2   rR   Ú
batch_sizerF   ÚheightÚwidths         r)   r6   zVanStage.forward!  s�   € Ø—‘ |Ó4ˆØ—{‘{ <Ó0ˆà1=×1CÑ1CÑ.ˆ
�K ¨Ø#×+Ñ+¨AÓ.×8Ñ8¸¸AÓ>ˆØ×)Ñ)¨,Ó7ˆà#×(Ñ(¨°V¸UÀKÓP×XÑXÐYZÐ\]Ð_`ÐbcÓdˆØÐr+   )r   r   rŸ   rB   s   @r)   r¡   r¡     s‡   ø„ ñð Ø #ñRàðRð ðRð ð	Rð
 ðRð ðRð ðRð ðRð õRð4	 E§L¡Lð 	°U·\±\÷ 	r+   r¡   c                   óp   ‡ — e Zd ZdZdefˆ fd„Z	 	 d	dej                  dee	   dee	   de
eef   fd„Zˆ xZS )
Ú
VanEncoderz4
    VanEncoder, consisting of multiple stages.
    r“   c                 óT  •— t         ‰| �  «        t        j                  g «      | _        |j
                  }|j                  }|j                  }|j                  }|j                  }t        j                  d|j                  t        |j                  «      «      D �cg c]  }|j                  «       ‘Œ }}t        t!        ||||||«      «      D ]S  \  }	\  }
}}}}}|	dk(  }||	dz
     }|r|j"                  }| j                  j%                  t'        ||||
||||¬«      «       ŒU y c c}w )Nr   r   )rG   rH   r¢   r”   r•   )r0   r1   r   Ú
ModuleListÚstagesÚpatch_sizesÚstridesÚhidden_sizesÚdepthsÚ
mlp_ratiosr"   Úlinspacer•   ÚsumÚitemÚ	enumerateÚzipÚnum_channelsÚappendr¡   )r2   r“   r¹   rº   r»   r¼   r½   ÚxÚdrop_path_ratesÚ	num_stagerG   rH   rF   r¢   Úmlp_expantionr•   Úis_first_stagerE   r3   s                     €r)   r1   zVanEncoder.__init__2  s"  ø€ Ü‰ÑÔÜ—m‘m BÓ'ˆŒØ×(Ñ(ˆØ—.‘.ˆØ×*Ñ*ˆØ—‘ˆØ×&Ñ&ˆ
Ü-2¯^©^¸A¸v×?TÑ?TÔVYÐZ`×ZgÑZgÓVhÓ-iÖj¨˜1Ÿ6™6�8ÐjˆÐjäbkÜ�˜W l°F¸JÈÓXóc
ò 	Ñ^ˆIÑ^˜
 F¨K¸ÀÈ~ð '¨!™^ˆNØ& y°1¡}Ñ5ˆKÙØ$×1Ñ1�Ø�K‰K×ÑÜØØØØ)Ø!ØØ+Ø#1ô	õñ	ùò ks   ÂD%rR   Úoutput_hidden_statesÚreturn_dictr   c                 ó°   — |rdnd }t        | j                  «      D ]  \  }} ||«      }|sŒ||fz   }Œ |st        d„ ||fD «       «      S t        ||¬«      S )N© c              3   ó&   K  — | ]	  }|€Œ|–— Œ y ­wr/   rÍ   )Ú.0Úvs     r)   ú	<genexpr>z%VanEncoder.forward.<locals>.<genexpr>_  s   è ø€ ÒW˜qÈÉœÑWùs   ‚Š)Úlast_hidden_stater4   )rÁ   r¸   Útupler   )r2   rR   rÊ   rË   Úall_hidden_statesr«   Ústage_modules          r)   r6   zVanEncoder.forwardP  sp   € ñ #7™B¸DÐä(¨¯©Ó5ò 	H‰OˆAˆ|Ù'¨Ó5ˆLâ#Ø$5¸¸Ñ$GÑ!ð		Hñ ÜÑW \Ð3DÐ$EÔWÓWÐWä-ÀÐ\mÔnÐnr+   )FT)r:   r;   r<   r=   r   r1   r"   r?   r   Úboolr   r   r   r6   rA   rB   s   @r)   rµ   rµ   -  sd   ø„ ñð˜yõ ðB 05Ø&*ñ	oà—l‘lðoð ' t™nðoð ˜d‘^ð	oð
 
ˆuÐ4Ð4Ñ	5÷or+   rµ   c                   ó&   — e Zd ZdZeZdZdZdZd„ Z	y)ÚVanPreTrainedModelz†
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    ÚvanÚpixel_valuesTc                 óÀ  — t        |t        j                  «      r’t        j                  j	                  |j
                  | j                  j                  ¬«       t        |t        j                  «      r8|j                  �+t        j                  j                  |j                  d«       yyyt        |t        j                  «      rUt        j                  j                  |j                  d«       t        j                  j                  |j
                  d«       yt        |t        j                  «      r©|j                  d   |j                  d   z  |j                  z  }||j                  z  }|j
                  j                  j!                  dt#        j$                  d|z  «      «       |j                  �%|j                  j                  j'                  «        yyy)zInitialize the weights)ÚstdNr   g      ð?r   g       @)Ú
isinstancer   ÚLinearÚinitÚtrunc_normal_r�   r“   Úinitializer_rangeÚbiasÚ	constant_r©   rM   rK   rW   r^   ÚdataÚnormal_ÚmathÚsqrtÚzero_)r2   ÚmoduleÚfan_outs      r)   Ú_init_weightsz VanPreTrainedModel._init_weightso  sC  € ä�fœbŸi™iÔ(Ü�G‰G×!Ñ! &§-¡-°T·[±[×5RÑ5RÐ!ÔSÜ˜&¤"§)¡)Ô,°·±Ð1HÜ—‘×!Ñ! &§+¡+¨qÕ1ð 2IÐ,ä˜¤§¡Ô-Ü�G‰G×Ñ˜fŸk™k¨1Ô-Ü�G‰G×Ñ˜fŸm™m¨SÕ1Ü˜¤§	¡	Ô*Ø×(Ñ(¨Ñ+¨f×.@Ñ.@ÀÑ.CÑCÀf×FYÑFYÑYˆGØ˜Ÿ™Ñ%ˆGØ�M‰M×Ñ×&Ñ& q¬$¯)©)°C¸'±MÓ*BÔCØ�{‰{Ð&Ø—‘× Ñ ×&Ñ&Õ(ð 'ð	 +r+   N)
r:   r;   r<   r=   r   Úconfig_classÚbase_model_prefixÚmain_input_nameÚsupports_gradient_checkpointingrë   rÍ   r+   r)   rØ   rØ   d  s$   „ ñð
 €LØÐØ$€OØ&*Ð#ó)r+   rØ   aE  
    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 ([`VanConfig`]): 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 stages. 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.
zxThe bare VAN model outputting raw features without any specific head on top. Note, VAN does not have an embedding layer.c                   ó¢   ‡ — e Zd Zˆ fd„Z ee«       eeee	de
¬«      	 	 d	deej                     dee   dee   deeef   fd„«       «       Zˆ xZS )
ÚVanModelc                 óØ   •— t         ‰| �  |«       || _        t        |«      | _        t        j                  |j                  d   |j                  ¬«      | _	        | j                  «        y )Nr�   r¤   )r0   r1   r“   rµ   Úencoderr   r©   r»   rª   Ú	layernormÚ	post_init©r2   r“   r3   s     €r)   r1   zVanModel.__init__Ÿ  sP   ø€ Ü‰Ñ˜Ô ØˆŒÜ! &Ó)ˆŒäŸ™ f×&9Ñ&9¸"Ñ&=À6×CXÑCXÔYˆŒà�‰Õr+   Úvision)Ú
checkpointÚoutput_typerì   ÚmodalityÚexpected_outputrÚ   rÊ   rË   r   c                 ó  — |�|n| j                   j                  }|�|n| j                   j                  }| j                  |||¬«      }|d   }|j	                  ddg¬«      }|s
||f|dd  z   S t        |||j                  ¬«      S )N©rÊ   rË   r   éþÿÿÿr�   )Údimr   )rÒ   Úpooler_outputr4   )r“   rÊ   Úuse_return_dictró   Úmeanr   r4   )r2   rÚ   rÊ   rË   Úencoder_outputsrÒ   Úpooled_outputs          r)   r6   zVanModel.forward¨  s¬   € ð %9Ð$DÑ È$Ï+É+×JjÑJjð 	ð &1Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆàŸ,™,ØØ!5Ø#ð 'ó 
ˆð
 ,¨AÑ.Ðà)×.Ñ.°B¸°8Ð.Ó<ˆáØ% }Ð5¸ÈÈÐ8KÑKÐKä7Ø/Ø'Ø)×7Ñ7ô
ð 	
r+   )NN)r:   r;   r<   r1   r   ÚVAN_INPUTS_DOCSTRINGr   Ú_CHECKPOINT_FOR_DOCr   Ú_CONFIG_FOR_DOCÚ_EXPECTED_OUTPUT_SHAPEr   r"   ÚFloatTensorrÖ   r   r   r6   rA   rB   s   @r)   rñ   rñ   ™  s‹   ø„ ôñ +Ð+?Ó@ÙØ&Ø<Ø$ØØ.ôð 04Ø&*ñ	
à˜u×0Ñ0Ñ1ð
ð ' t™nð
ð ˜d‘^ð	
ð
 
ˆuÐ>Ð>Ñ	?ò
óó Aô
r+   rñ   zƒ
    VAN 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eef   f
d„«       «       Zˆ xZS )
ÚVanForImageClassificationc                 ó  •— t         ‰| �  |«       t        |«      | _        |j                  dkD  r-t        j                  |j                  d   |j                  «      nt        j                  «       | _	        | j                  «        y )Nr   r�   )r0   r1   rñ   rÙ   Ú
num_labelsr   rÞ   r»   r—   Ú
classifierrõ   rö   s     €r)   r1   z"VanForImageClassification.__init__Ö  sl   ø€ Ü‰Ñ˜Ô Ü˜FÓ#ˆŒð FL×EVÑEVÐYZÒEZŒB�I‰I�f×)Ñ)¨"Ñ-¨v×/@Ñ/@ÔAÔ`b×`kÑ`kÓ`mð 	Œð
 	�‰Õr+   )rø   rù   rì   rû   rÚ   ÚlabelsrÊ   rË   r   c                 óh  — |�|n| j                   j                  }| j                  |||¬«      }|r|j                  n|d   }| j	                  |«      }d}|��¯| j                   j
                  €¡| j                   j                  dk(  rd| j                   _        nv| j                   j                  dkD  rL|j                  t        j                  k(  s|j                  t        j                  k(  rd| j                   _        nd| j                   _        | j                   j
                  dk(  rSt        «       }	| j                   j                  dk(  r& |	|j                  «       |j                  «       «      }n– |	||«      }nŒ| j                   j
                  dk(  rGt        «       }	 |	|j                  d| j                   j                  «      |j                  d«      «      }n,| j                   j
                  dk(  rt        «       }	 |	||«      }|s|f|dd z   }
|�|f|
z   S |
S t!        |||j"                  ¬	«      S )
aŠ  
        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).
        Nrý   r   Ú
regressionÚsingle_label_classificationÚmulti_label_classificationr�   rJ   )ÚlossÚlogitsr4   )r“   r  rÙ   r   r  Úproblem_typer  r   r"   ÚlongrT   r
   Úsqueezer	   r¯   r   r   r4   )r2   rÚ   r  rÊ   rË   Úoutputsr  r  r  Úloss_fctr(   s              r)   r6   z!VanForImageClassification.forwardá  s×  € ð( &1Ð%<‘kÀ$Ç+Á+×B]ÑB]ˆà—(‘(˜<Ð>RÐ`k�(Ólˆá1<˜×-Ò-À'È!Á*ˆà—‘ Ó/ˆàˆØÑØ�{‰{×'Ñ'Ð/Ø—;‘;×)Ñ)¨QÒ.Ø/;�D—K‘KÕ,Ø—[‘[×+Ñ+¨aÒ/°V·\±\ÄUÇZÁZÒ5OÐSY×S_ÑS_Ôch×clÑclÒSlØ/L�D—K‘KÕ,à/K�D—K‘KÔ,à�{‰{×'Ñ'¨<Ò7Ü"›9�Ø—;‘;×)Ñ)¨QÒ.Ù# F§N¡NÓ$4°f·n±nÓ6FÓG‘Dá# F¨FÓ3‘DØ—‘×)Ñ)Ð-JÒJÜ+Ó-�Ù §¡¨B°·±×0FÑ0FÓ GÈÏÉÐUWËÓY‘Ø—‘×)Ñ)Ð-IÒIÜ,Ó.�Ù ¨Ó/�áØ�Y ¨¨ Ñ,ˆFØ)-Ð)9�T�G˜fÑ$ÐE¸vÐEä3¸ÀfÐ\c×\qÑ\qÔrÐrr+   )NNNN)r:   r;   r<   r1   r   r  r   Ú_IMAGE_CLASS_CHECKPOINTr   r  Ú_IMAGE_CLASS_EXPECTED_OUTPUTr   r"   r	  Ú
LongTensorrÖ   r   r   r6   rA   rB   s   @r)   r  r  Î  sª   ø„ ô	ñ +Ð+?Ó@ÙØ*Ø8Ø$Ø4ô	ð 59Ø-1Ø/3Ø&*ñ0sà˜u×0Ñ0Ñ1ð0sð ˜×)Ñ)Ñ*ð0sð ' t™nð	0sð
 ˜d‘^ð0sð 
ˆuÐ:Ð:Ñ	;ò0sóó Aô0sr+   r  )r   F):r=   ræ   Úcollectionsr   Útypingr   r   r   r"   Útorch.utils.checkpointr   Útorch.nnr   r	   r
   Úactivationsr   Úmodeling_outputsr   r   r   Úmodeling_utilsr   Úutilsr   r   r   r   Úconfiguration_vanr   Ú
get_loggerr:   Úloggerr  r  r  r  r  r?   r>   rÖ   r*   ÚModuler-   rD   rV   rk   ru   r{   r‡   r’   r¡   rµ   rØ   ÚVAN_START_DOCSTRINGr  rñ   r  rÍ   r+   r)   ú<module>r+     sÀ  ðñ 4ã Ý #ß )Ñ )ã Û Ý ß AÑ Aå "÷ñ õ
 /ß vÓ vÝ (ð 
ˆ×	Ñ	˜HÓ	%€ð €ð :Ð Ú'Ð ð >Ð Ø1Ð ñ�U—\‘\ð ¨eð ÀTð ÐV[×VbÑVbó ô(-�"—)‘)ô -ô "§)¡)ô ô(�"—)‘)ô ô@˜bŸi™iô ô( 2§9¡9ô ô˜rŸy™yô ô8�b—i‘iô ô(ˆr�y‰yô (ôV(ˆr�y‰yô (ôV4o�—‘ô 4oôn)˜ô )ð8	Ð ðÐ ñ ðàóô
-
Ð!ó -
óð
-
ñ` ðð óôCsÐ 2ó CsóñCsr+   