
    ^jC                        d 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	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mZmZ ddlmZmZ ddlmZ ddlmZ  ej>                  e       Z! G d dejD                        Z# G d dejH                        Z% G d dejD                        Z& G d dejD                        Z' G d dejD                        Z( G d dejD                        Z)e G d de             Z* G d de*      Z+e G d  d!e*             Z, ed"#       G d$ d%e*             Z- ed&#       G d' d(e	e*             Z.g d)Z/y)*zPyTorch ConvNextV2 model.    N)nn   )initialization)ACT2FN)BackboneMixinfilter_output_hidden_states)BackboneOutputBaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)Unpack)TransformersKwargsauto_docstringlogging)can_return_tuplemerge_with_config_defaults)capture_outputs   )ConvNextV2Configc                   `     e Zd ZdZdef fdZdej                  dej                  fdZ xZ	S )ConvNextV2GRNz)GRN (Global Response Normalization) layerdimc                     t         |           t        j                  t	        j
                  ddd|            | _        t        j                  t	        j
                  ddd|            | _        y )Nr   )super__init__r   	Parametertorchzerosweightbias)selfr   	__class__s     }/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/convnextv2/modeling_convnextv2.pyr   zConvNextV2GRN.__init__*   sL    ll5;;q!Q#<=LLQ1c!:;	    hidden_statesreturnc                     t         j                  j                  |ddd      }||j                  dd      dz   z  }| j                  ||z  z  | j
                  z   |z   }|S )N   )r   r)   T)ordr   keepdim)r   r+   ư>)r   linalgvector_normmeanr    r!   )r"   r&   global_featuresnorm_featuress       r$   forwardzConvNextV2GRN.forward/   si    ,,22=aV]a2b'?+?+?BPT+?+UX\+\]}}'DE		QTaar%   )
__name__
__module____qualname____doc__intr   r   FloatTensorr3   __classcell__r#   s   @r$   r   r   '   s1    3<C <
U%6%6 5;L;L r%   r   c                   f     e Zd ZdZddd fd
Zdej                  dej                  f fdZ xZS )	ConvNextV2LayerNormaA  LayerNorm that supports two data formats: channels_last (default) or channels_first.
    The ordering of the dimensions in the inputs. channels_last corresponds to inputs with shape (batch_size, height,
    width, channels) while channels_first corresponds to inputs with shape (batch_size, channels, height, width).
    r-   channels_lastepsdata_formatc                \    t        |   |fd|i| |dvrt        d|       || _        y )Nr@   )r>   channels_firstzUnsupported data format: )r   r   NotImplementedErrorrA   )r"   normalized_shaper@   rA   kwargsr#   s        r$   r   zConvNextV2LayerNorm.__init__?   s?    )=s=f=AA%(A+&OPP&r%   featuresr'   c                     | j                   dk(  r9|j                  dddd      }t        |   |      }|j                  dddd      }|S t        |   |      }|S )z
        Args:
            features: Tensor of shape (batch_size, channels, height, width) OR (batch_size, height, width, channels)
        rC   r   r)   r   r   )rA   permuter   r3   )r"   rG   r#   s     r$   r3   zConvNextV2LayerNorm.forwardE   sj    
 //''1a3Hwx0H''1a3H  wx0Hr%   	r4   r5   r6   r7   r   r   Tensorr3   r:   r;   s   @r$   r=   r=   9   s4    
 15/ '   r%   r=   c                   Z     e Zd ZdZ fdZdej                  dej                  fdZ xZ	S )ConvNextV2EmbeddingszThis class is comparable to (and inspired by) the SwinEmbeddings class
    found in src/transformers/models/swin/modeling_swin.py.
    c                    t         |           t        j                  |j                  |j
                  d   |j                  |j                        | _        t        |j
                  d   dd      | _	        |j                  | _        y )Nr   kernel_sizestrider-   rC   r?   )
r   r   r   Conv2dnum_channelshidden_sizes
patch_sizepatch_embeddingsr=   	layernormr"   configr#   s     r$   r   zConvNextV2Embeddings.__init__Y   sr     "		!4!4Q!7VEVEV_e_p_p!
 -V-@-@-C[kl"//r%   pixel_valuesr'   c                     |j                   d   }|| j                  k7  rt        d      | j                  |      }| j	                  |      }|S )Nr   zeMake sure that the channel dimension of the pixel values match with the one set in the configuration.)shaperS   
ValueErrorrV   rW   )r"   rZ   rS   
embeddingss       r$   r3   zConvNextV2Embeddings.forwarda   sV    #))!,4,,,w  **<8
^^J/
r%   )
r4   r5   r6   r7   r   r   r9   rK   r3   r:   r;   s   @r$   rM   rM   T   s*    0E$5$5 %,, r%   rM   c                   r     e Zd ZdZd	deddf fdZdej                  dej                  fdZde	fdZ
 xZS )
ConvNextV2DropPathzStochastic depth (DropPath) per sample, for residual blocks.

    Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
    <https://arxiv.org/abs/1603.09382>`_.
    	drop_probr'   Nc                 0    t         |           || _        y N)r   r   ra   )r"   ra   r#   s     r$   r   zConvNextV2DropPath.__init__t   s    "r%   r&   c                 P   | j                   dk(  s| j                  s|S d| j                   z
  }|j                  d   fd|j                  dz
  z  z   }t	        j
                  ||j                  |j                        }t	        j                  ||z         }|j                  |      |z  S )N        r   r   )r   )dtypedevice)
ra   trainingr\   ndimr   randrf   rg   floordiv)r"   r&   	keep_probr\   random_tensors        r$   r3   zConvNextV2DropPath.forwardx   s    >>S   &	$$Q')DM4F4F4J,KK

50C0CML`L`aMI$=>  +m;;r%   c                      d| j                    S )Nzp=)ra   )r"   s    r$   
extra_reprzConvNextV2DropPath.extra_repr   s    DNN#$$r%   )re   )r4   r5   r6   r7   floatr   r   rK   r3   strrp   r:   r;   s   @r$   r`   r`   m   sB    #% #$ #<U\\ <ell <%C %r%   r`   c                   \     e Zd ZdZd fd	Zdej                  dej                  fdZ xZS )ConvNextV2Layera5  This corresponds to the `Block` class in the original implementation.

    There are two equivalent implementations: [DwConv, LayerNorm (channels_first), Conv, GELU,1x1 Conv]; all in (N, C,
    H, W) (2) [DwConv, Permute to (N, H, W, C), LayerNorm (channels_last), Linear, GELU, Linear]; Permute back

    The authors used (2) as they find it slightly faster in PyTorch.

    Args:
        config ([`ConvNextV2Config`]): Model configuration class.
        dim (`int`): Number of input channels.
        drop_path (`float`): Stochastic depth rate. Default: 0.0.
    c                    t         |           t        j                  ||dd|      | _        t        |d      | _        t        j                  |d|z        | _        t        |j                     | _        t        d|z        | _        t        j                  d|z  |      | _        |dkD  rt        |      | _        y t        j                          | _        y )N   r   )rP   paddinggroupsr-   r@      re   )r   r   r   rR   dwconvr=   rW   Linearpwconv1r   
hidden_actactr   grnpwconv2r`   Identity	drop_path)r"   rY   r   r   r#   s       r$   r   zConvNextV2Layer.__init__   s    iiSa3O,Sd;yya#g.&++, S)yyS#.:Cc/+I6r{{}r%   rG   r'   c                 N   |}| j                  |      }|j                  dddd      }| j                  |      }| j                  |      }| j	                  |      }| j                  |      }| j                  |      }|j                  dddd      }|| j                  |      z   }|S )Nr   r)   r   r   )r{   rI   rW   r}   r   r   r   r   )r"   rG   residuals      r$   r3   zConvNextV2Layer.forward   s    ;;x(##Aq!Q/>>(+<<)88H%88H%<<)##Aq!Q/dnnX66r%   )r   rJ   r;   s   @r$   rt   rt      s)    
]  r%   rt   c                   \     e Zd ZdZd fd	Zdej                  dej                  fdZ xZS )ConvNextV2Stagea  ConvNeXTV2 stage, consisting of an optional downsampling layer + multiple residual blocks.

    Args:
        config ([`ConvNextV2Config`]): Model configuration class.
        in_channels (`int`): Number of input channels.
        out_channels (`int`): Number of output channels.
        depth (`int`): Number of residual blocks.
        drop_path_rates(`list[float]`): Stochastic depth rates for each layer.
    c                    t         	|           ||k7  s|dkD  r@t        j                  t	        |dd      t        j
                  ||||      g      | _        nt        j                         | _        |xs dg|z  }t        j                  t        |      D cg c]  }t        ||||          c}      | _	        y c c}w )Nr   r-   rC   r?   rO   re   )r   r   )
r   r   r   
ModuleListr=   rR   downsampling_layerrangert   layers)
r"   rY   in_channelsout_channelsrP   rQ   depthdrop_path_ratesjr#   s
            r$   r   zConvNextV2Stage.__init__   s    ,&&1*&(mm'K[\IIk<[Y_`'D# ')mmoD#):cUU]mm^cdi^jkYZ_VQRASTk
ks   B>rG   r'   c                 j    | j                   D ]
  } ||      } | j                  D ]
  } ||      } |S rc   )r   r   )r"   rG   layers      r$   r3   zConvNextV2Stage.forward   sA    ,, 	'EXH	'[[ 	'EXH	'r%   )r)   r)   r)   NrJ   r;   s   @r$   r   r      s(    
"  r%   r   c                   d     e Zd ZU eed<   dZdZdZdgZ e	j                          fd       Z xZS )ConvNextV2PreTrainedModelrY   
convnextv2rZ   )imagert   c                     t         |   |       t        |t              r?t	        j
                  |j                         t	        j
                  |j                         yy)zInitialize the weightsN)r   _init_weights
isinstancer   initzeros_r    r!   )r"   moduler#   s     r$   r   z'ConvNextV2PreTrainedModel._init_weights   sA     	f%fm,KK&KK$ -r%   )r4   r5   r6   r   __annotations__base_model_prefixmain_input_nameinput_modalities_no_split_modulesr   no_gradr   r:   r;   s   @r$   r   r      s=    $$O!*+U]]_% %r%   r   c                   z     e Zd ZdZdeiZ fdZe ed      de	j                  dee   defd              Z xZS )ConvNextV2Encoderr&   c           
      N   t         |   |       t        j                         | _        t        j                  d|j                  t        |j                        d      j                  |j                        D cg c]  }|j                          }}|j                  d   }t        |j                        D ]V  }|j                  |   }t        ||||dkD  rdnd|j                  |   ||         }| j                  j!                  |       |}X | j#                          y c c}w )Nr   cpu)rg   r)   r   )r   r   rQ   r   r   )r   r   r   r   stagesr   linspacedrop_path_ratesumdepthssplittolistrT   r   
num_stagesr   append	post_init)	r"   rY   xr   prev_chsiout_chsstager#   s	           r$   r   zConvNextV2Encoder.__init__   s    mmo ^^Av'<'<c&-->PY^_eeflfsfst
 HHJ
 
 &&q)v(() 	A))!,G#$$EqqmmA& / 2E KKu%H	 	%
s   ;D"F)tie_last_hidden_statesrF   r'   c                 L    | j                   D ]
  } ||      } t        |      S )N)last_hidden_state)r   r
   )r"   r&   rF   layer_modules       r$   r3   zConvNextV2Encoder.forward  s.     !KK 	8L(7M	8 .NNr%   )r4   r5   r6   r   r   _can_record_outputsr   r   r   r   rK   r   r   r
   r3   r:   r;   s   @r$   r   r      sd    %O*O<.  E2O||O +,O 
(	O 3  Or%   r   c            	       j     e Zd Z fdZee	 ddej                  dz  dee	   de
fd              Z xZS )ConvNextV2Modelc                     t         |   |       || _        t        |      | _        t        |      | _        t        j                  |j                  d   |j                        | _        | j                          y )Nr,   ry   )r   r   rY   rM   r^   r   encoderr   	LayerNormrT   layer_norm_epsrW   r   rX   s     r$   r   zConvNextV2Model.__init__  s`     .v6(0 f&9&9"&=6CXCXY 	r%   NrZ   rF   r'   c                     |t        d      | j                  |      } | j                  |fi |}|j                  }| j	                  |j                  ddg            }t        |||j                        S )Nz You have to specify pixel_valuesr,   )r   pooler_outputr&   )r]   r^   r   r   rW   r0   r   r&   )r"   rZ   rF   embedding_outputencoder_outputsr   pooled_outputs          r$   r3   zConvNextV2Model.forward  s    
 ?@@??<8:F$,,GW:b[a:b+== '8'='=r2h'GH7/')77
 	
r%   rc   )r4   r5   r6   r   r   r   r   r9   r   r   r   r3   r:   r;   s   @r$   r   r     sP     7;
!--4
GMN`Ga
	1
  
r%   r   z
    ConvNextV2 Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    )custom_introc            	            e Zd ZdZ fdZee	 ddej                  dz  dej                  dz  de
fd              Z xZS )	 ConvNextV2ForImageClassificationFc                 <   t         |   |       |j                  | _        t        |      | _        |j                  dkD  r3t        j                  |j                  d   |j                        | _        nt        j                         | _        | j                          y )Nr   r,   )r   r   
num_labelsr   r   r   r|   rT   
classifierr   r   rX   s     r$   r   z)ConvNextV2ForImageClassification.__init__?  su      ++)&1 q  ii(;(;B(?ARARSDO kkmDO 	r%   NrZ   labelsr'   c                      | j                   |fi |}|j                  }| j                  |      }d}|| j                  ||| j                        }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).
        N)r   pooled_logitsrY   )losslogitsr&   )r   r   r   loss_functionrY   r   r&   )r"   rZ   r   rF   outputsr   r   r   s           r$   r3   z(ConvNextV2ForImageClassification.forwardN  sy     =LDOOL<c\b<c--/%%V6RVR]R]%^D3!//
 	
r%   )NN)r4   r5   r6   accepts_loss_kwargsr   r   r   r   r9   
LongTensorr   r3   r:   r;   s   @r$   r   r   5  s^       _c
!--4
EJEUEUX\E\
	-
  
r%   r   zT
    ConvNeXT V2 backbone, to be used with frameworks like DETR and MaskFormer.
    c            	       n     e Zd ZdZ fdZeeedej                  de
e   defd                     Z xZS )ConvNextV2BackboneFc                 p   t         |   |       t        |      | _        t	        |      | _        |j                  d   g|j                  z   | _        i }t        | j                  | j                        D ]  \  }}t        |d      ||<    t        j                  |      | _        | j                          y )Nr   rC   )rA   )r   r   rM   r^   r   r   rT   num_featureszipout_featureschannelsr=   r   
ModuleDicthidden_states_normsr   )r"   rY   r   r   rS   r#   s        r$   r   zConvNextV2Backbone.__init__q  s     .v6(0#0034v7J7JJ !#&t'8'8$--#H 	iE<)<\Wg)h&	i#%==1D#E  	r%   rZ   rF   r'   c                 8   | j                  |      } | j                  |fi |}|j                  }g }t        | j                  |      D ]:  \  }}|| j
                  v s | j                  |   |      }|j                  |       < t        t        |      |      S )a  
        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, AutoBackbone
        >>> import torch
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
        >>> model = AutoBackbone.from_pretrained("facebook/convnextv2-tiny-1k-224")

        >>> inputs = processor(image, return_tensors="pt")
        >>> outputs = model(**inputs)
        ```)feature_mapsr&   )
r^   r   r&   r   stage_namesr   r   r   r	   tuple)	r"   rZ   rF   r   r   r&   r   r   hidden_states	            r$   r3   zConvNextV2Backbone.forward  s    8  ??<8:F$,,GW:b[a:b'55#&t'7'7#G 	2E<)))>t77>|L##L1	2
 5+>m\\r%   )r4   r5   r6   has_attentionsr   r   r   r   r   rK   r   r   r	   r3   r:   r;   s   @r$   r   r   h  s^     N   #]ll#] +,#] 
	#]  ! #]r%   r   )r   r   r   r   )0r7   r   r    r   r   activationsr   backbone_utilsr   r   modeling_outputsr	   r
   r   r   modeling_utilsr   processing_utilsr   utilsr   r   r   utils.genericr   r   utils.output_capturingr   configuration_convnextv2r   
get_loggerr4   loggerModuler   r   r=   rM   r`   rt   r   r   r   r   r   r   __all__ r%   r$   <module>r      sS       & ! H  . & @ @ I 5 6 
		H	%BII $",, 6299 2% %0(bii (X!bii !H % % %"%O1 %OP !
/ !
 !
H )
'@ )
)
X 9](A 9]9]x ur%   