
    ^j=                     b   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jH                        Z& G d dejH                        Z' G d dejH                        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 ConvNext 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   )ConvNextConfigc                   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 )	ConvNextLayerNormaA  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).
    ư>channels_lastepsdata_formatc                \    t        |   |fd|i| |dvrt        d|       || _        y )Nr   )r   channels_firstzUnsupported data format: )super__init__NotImplementedErrorr   )selfnormalized_shaper   r   kwargs	__class__s        y/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/convnext/modeling_convnext.pyr!   zConvNextLayerNorm.__init__-   s?    )=s=f=AA%(A+&OPP&    featuresreturnc                     | 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)
        r   r      r   r   )r   permuter    forward)r#   r)   r&   s     r'   r.   zConvNextLayerNorm.forward3   sj    
 //''1a3Hwx0H''1a3H  wx0Hr(   	__name__
__module____qualname____doc__r!   torchTensorr.   __classcell__r&   s   @r'   r   r   '   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 )ConvNextEmbeddingszThis 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   r   r   )
r    r!   r   Conv2dnum_channelshidden_sizes
patch_sizepatch_embeddingsr   	layernormr#   configr&   s     r'   r!   zConvNextEmbeddings.__init__F   sr     "		!4!4Q!7VEVEV_e_p_p!
 +6+>+>q+AtYij"//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.)shaper?   
ValueErrorrB   rC   )r#   rF   r?   
embeddingss       r'   r.   zConvNextEmbeddings.forwardN   sV    #))!,4,,,w  **<8
^^J/
r(   )
r0   r1   r2   r3   r!   r4   FloatTensorr5   r.   r6   r7   s   @r'   r9   r9   A   s*    0E$5$5 %,, r(   r9   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 )
ConvNextDropPathzStochastic 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!   rN   )r#   rN   r&   s     r'   r!   zConvNextDropPath.__init__a   s    "r(   hidden_statesc                 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)
rN   trainingrH   ndimr4   randrT   rU   floordiv)r#   rQ   	keep_probrH   random_tensors        r'   r.   zConvNextDropPath.forwarde   s    >>S   &	$$Q')DM4F4F4J,KK

50C0CML`L`aMI$=>  +m;;r(   c                      d| j                    S )Nzp=)rN   )r#   s    r'   
extra_reprzConvNextDropPath.extra_reprn   s    DNN#$$r(   )rS   )r0   r1   r2   r3   floatr!   r4   r5   r.   strr^   r6   r7   s   @r'   rM   rM   Z   sB    #% #$ #<U\\ <ell <%C %r(   rM   c                   \     e Zd ZdZd fd	Zdej                  dej                  fdZ xZS )ConvNextLayera3  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 ([`ConvNextConfig`]): 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        j                  d|z  |      | _        |j                  dkD  r7t        j                  |j                  t        j                   |      z  d	      nd | _        |d
kD  rt%        |      | _        y t        j&                         | _        y )N   r   )r<   paddinggroupsr   r      r   T)requires_gradrS   )r    r!   r   r>   dwconvr   rC   Linearpwconv1r   
hidden_actactpwconv2layer_scale_init_value	Parameterr4   oneslayer_scale_parameterrM   Identity	drop_path)r#   rE   dimru   r&   s       r'   r!   zConvNextLayer.__init__   s    iiSa3O*3D9yya#g.&++,yyS#. ,,q0 LL66CHX\] 	"
 9BC))4R[[]r(   r)   r*   c                 b   |}| j                  |      }|j                  dddd      }| j                  |      }| j                  |      }| j	                  |      }| j                  |      }| j                  | j                  |z  }|j                  dddd      }|| j                  |      z   }|S )Nr   r,   r   r   )rj   r-   rC   rl   rn   ro   rs   ru   )r#   r)   residuals      r'   r.   zConvNextLayer.forward   s    ;;x(##Aq!Q/>>(+<<)88H%<<)%%111H<H##Aq!Q/dnnX66r(   )r   r/   r7   s   @r'   rb   rb   r   s)    [  r(   rb   c                   \     e Zd ZdZd fd	Zdej                  dej                  fdZ xZS )ConvNextStagea  ConvNeXT stage, consisting of an optional downsampling layer + multiple residual blocks.

    Args:
        config ([`ConvNextConfig`]): 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   r   r   r;   rS   )rv   ru   )
r    r!   r   
ModuleListr   r>   downsampling_layerrangerb   layers)
r#   rE   in_channelsout_channelsr<   r=   depthdrop_path_ratesjr&   s
            r'   r!   zConvNextStage.__init__   s    ,&&1*&(mm%ktIYZIIk<[Y_`'D# ')mmoD#):cUU]mm\abg\hiWX]6|q?QRi
is   B>r)   r*   c                 j    | j                   D ]
  } ||      } | j                  D ]
  } ||      } |S rP   )r}   r   )r#   r)   layers      r'   r.   zConvNextStage.forward   sA    ,, 	'EXH	'[[ 	'EXH	'r(   )r,   r,   r,   Nr/   r7   s   @r'   rz   rz      s(    
"  r(   rz   c                   f     e Zd ZU eed<   dZdZdZddgZ e	j                          fd       Z xZS )ConvNextPreTrainedModelrE   convnextrF   )imagerb   rz   c                     t         |   |       t        |t              rB|j                  5t        j                  |j                  | j                  j                         yyy)zInitialize the weightsN)	r    _init_weights
isinstancerb   rs   init	constant_rE   rp   )r#   moduler&   s     r'   r   z%ConvNextPreTrainedModel._init_weights   sP     	f%fm,++7v;;T[[=_=_` 8 -r(   )r0   r1   r2   r   __annotations__base_model_prefixmain_input_nameinput_modalities_no_split_modulesr4   no_gradr   r6   r7   s   @r'   r   r      sA    "$O!(/:U]]_a a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 )ConvNextEncoderrQ   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)rU   r,   r   )r   r   r=   r   r   )r    r!   r   r|   stagesr4   linspacedrop_path_ratesumdepthssplittolistr@   r~   
num_stagesrz   append	post_init)	r#   rE   xr   prev_chsiout_chsstager&   s	           r'   r!   zConvNextEncoder.__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_statesr%   r*   c                 L    | j                   D ]
  } ||      } t        |      S )N)last_hidden_state)r   r
   )r#   rQ   r%   layer_modules       r'   r.   zConvNextEncoder.forward   s.     !KK 	8L(7M	8 .NNr(   )r0   r1   r2   r   rz   _can_record_outputsr!   r   r   r4   r5   r   r   r
   r.   r6   r7   s   @r'   r   r      sd    %O*M:.  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 )ConvNextModelc                     t         |   |       || _        t        |      | _        t        |      | _        t        j                  |j                  d   |j                        | _        | j                          y )Nrg   )r    r!   rE   r9   rJ   r   encoderr   	LayerNormr@   layer_norm_epsrC   r   rD   s     r'   r!   zConvNextModel.__init__   s`     ,V4&v. f&9&9"&=6CXCXY 	r(   NrF   r%   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_outputrQ   )rI   rJ   r   r   rC   meanr   rQ   )r#   rF   r%   embedding_outputencoder_outputsr   pooled_outputs          r'   r.   zConvNextModel.forward	  s    
 ?@@??<8:F$,,GW:b[a:b+== '8'='=r2h'GH7/')77
 	
r(   rP   )r0   r1   r2   r!   r   r   r4   rK   r   r   r   r.   r6   r7   s   @r'   r   r      sP     7;
!--4
GMN`Ga
	1
  
r(   r   z
    ConvNext 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 )	ConvNextForImageClassificationFc                 <   t         |   |       |j                  | _        t        |      | _        |j                  dkD  r3t        j                  |j                  d   |j                        | _        nt        j                         | _        | j                          y )Nr   r   )r    r!   
num_labelsr   r   r   rk   r@   
classifierrt   r   rD   s     r'   r!   z'ConvNextForImageClassification.__init__(  su      ++%f- q  ii(;(;B(?ARARSDO kkmDO 	r(   NrF   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_logitsrE   )losslogitsrQ   )r   r   r   loss_functionrE   r   rQ   )r#   rF   r   r%   outputsr   r   r   s           r'   r.   z&ConvNextForImageClassification.forward7  sy     =JDMM,<aZ`<a--/%%V6RVR]R]%^D3!//
 	
r(   )NN)r0   r1   r2   accepts_loss_kwargsr!   r   r   r4   rK   
LongTensorr   r.   r6   r7   s   @r'   r   r     s^       _c
!--4
EJEUEUX\E\
	-
  
r(   r   zQ
    ConvNeXt 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 )ConvNextBackboneFc                 p   t         |   |       t        |      | _        t	        |      | _        |j                  d   g|j                  z   | _        i }t        | j                  | j                        D ]  \  }}t        |d      ||<    t        j                  |      | _        | j                          y )Nr   r   )r   )r    r!   r9   rJ   r   r   r@   num_featureszipout_featureschannelsr   r   
ModuleDicthidden_states_normsr   )r#   rE   r   r   r?   r&   s        r'   r!   zConvNextBackbone.__init__Y  s     ,V4&v.#0034v7J7JJ !#&t'8'8$--#H 	gE<):<Ue)f&	g#%==1D#E  	r(   rF   r%   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/convnext-tiny-224")
        >>> model = AutoBackbone.from_pretrained("facebook/convnext-tiny-224")

        >>> inputs = processor(image, return_tensors="pt")
        >>> outputs = model(**inputs)
        ```)feature_mapsrQ   )
rJ   r   rQ   r   stage_namesr   r   r   r	   tuple)	r#   rF   r%   r   r   rQ   r   r   hidden_states	            r'   r.   zConvNextBackbone.forwardi  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(   )r0   r1   r2   has_attentionsr!   r   r   r   r4   r5   r   r   r	   r.   r6   r7   s   @r'   r   r   Q  s^     N   #]ll#] +,#] 
	#]  ! #]r(   r   )r   r   r   r   )/r3   r4   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_convnextr   
get_loggerr0   loggerr   r   Moduler9   rM   rb   rz   r   r   r   r   r   __all__ r(   r'   <module>r      sF      & ! H  . & @ @ I 5 2 
		H	% 4 2%ryy %0(BII (V!BII !H ao a a %O- %OP !
+ !
 !
H )
%< )
)
X 
9]}&= 9]
9]x mr(   