
    rhK              	          d Z ddl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mZ dd	lmZ dd
lmZmZ ddlmZ ddlmZ  ej6                  e      Zd+dej<                  dede dej<                  fd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& G d dejD                        Z' G d dejD                        Z(e 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.    )OptionalUnionN)nn)BCEWithLogitsLossCrossEntropyLossMSELoss   )ACT2FN)BackboneOutputBaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)auto_docstringlogging)BackboneMixin   )ConvNextConfig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          /var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/transformers/models/convnext/modeling_convnext.py	drop_pathr'   )   s     CxII[[^

Q 77E

5ELL YYMYYy!M1F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 )
ConvNextDropPathzXDrop 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&   r.   zConvNextDropPath.__init__A   s    "r(   hidden_statesc                 D    t        || j                  | j                        S r,   )r'   r   r   r/   r1   s     r&   forwardzConvNextDropPath.forwardE   s    FFr(   c                      d| j                    S )Nzp=)r   )r/   s    r&   
extra_reprzConvNextDropPath.extra_reprH   s    DNN#$$r(   r,   )__name__
__module____qualname____doc__r   floatr.   r   Tensorr4   strr6   __classcell__r0   s   @r&   r*   r*   >   sG    b#(5/ #T #GU\\ Gell G%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 )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).
    c                 N   t         |           t        j                  t	        j
                  |            | _        t        j                  t	        j                  |            | _        || _	        || _
        | j                  dvrt        d| j                         |f| _        y )N)channels_lastchannels_firstzUnsupported data format: )r-   r.   r   	Parameterr   onesweightzerosbiasepsdata_formatNotImplementedErrornormalized_shape)r/   rM   rJ   rK   r0   s       r&   r.   zConvNextLayerNorm.__init__R   s    ll5::.>#?@LL-=!>?	&#FF%(A$BRBRAS&TUU!1 3r(   xr   c                 d   | j                   dk(  rWt        j                  j                  j	                  || j
                  | j                  | j                  | j                        }|S | j                   dk(  r|j                  }|j                         }|j                  dd      }||z
  j                  d      j                  dd      }||z
  t        j                  || j                  z         z  }|j                  |      }| j                  d d d d f   |z  | j                  d d d d f   z   }|S )NrC   rD   r   T)keepdim   )r   )rK   r   r   
functional
layer_normrM   rG   rI   rJ   r   r;   meanpowsqrtto)r/   rN   input_dtypeuss        r&   r4   zConvNextLayerNorm.forward\   s
   .##..q$2G2GVZV_V_aeaiaijA  !11''K	Aq$'AQA##At#4AQ%**Q\22A;'AAtTM*Q.1dD=1IIAr(   )ư>rC   )	r7   r8   r9   r:   r.   r   r<   r4   r>   r?   s   @r&   rA   rA   L   s(    
4 %,, r(   rA   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[   rD   rJ   rK   )
r-   r.   r   Conv2dnum_channelshidden_sizes
patch_sizepatch_embeddingsrA   	layernormr/   configr0   s     r&   r.   zConvNextEmbeddings.__init__o   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.)r   rd   
ValueErrorrg   rh   )r/   rk   rd   
embeddingss       r&   r4   zConvNextEmbeddings.forwardw   sV    #))!,4,,,w  **<8
^^J/
r(   
r7   r8   r9   r:   r.   r   FloatTensorr<   r4   r>   r?   s   @r&   r]   r]   j   s*    0E$5$5 %,, 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 )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[   rJ      r   T)requires_gradr   )r-   r.   r   rc   dwconvrA   rh   Linearpwconv1r
   
hidden_actactpwconv2layer_scale_init_valuerE   r   rF   layer_scale_parameterr*   Identityr'   )r/   rj   dimr'   r0   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(   r1   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   rQ   r	   r   )rz   permuterh   r|   r~   r   r   r'   )r/   r1   r   rN   s       r&   r4   zConvNextLayer.forward   s    KK&IIaAq!NN1LLOHHQKLLO%%1**Q.AIIaAq!DNN1%%r(   )r   ro   r?   s   @r&   rr   rr      s+    [U%6%6 5<< r(   rr   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
                  ||||            | _        nt        j                         | _        |xs dg|z  }t        j                  t        |      D cg c]  }t        ||||          c} | _
        y c c}w )Nr   r[   rD   rb   r_   r   )r   r'   )r-   r.   r   
SequentialrA   rc   downsampling_layerr   rangerr   layers)
r/   rj   in_channelsout_channelsr`   ra   depthdrop_path_ratesjr0   s
            r&   r.   zConvNextStage.__init__   s    ,&&1*&(mm!+4EUV		+|U[\'D#
 ')kkmD#):cUU]mm]bch]ijXYmFPQ@RSj
js   B:r1   r   c                 J    | j                  |      }| j                  |      }|S r,   )r   r   r3   s     r&   r4   zConvNextStage.forward   s&    //>M2r(   )rQ   rQ   rQ   Nro   r?   s   @r&   r   r      s*    
U%6%6 5<< r(   r   c                   f     e Zd Z fdZ	 	 ddej
                  dee   dee   dee	e
f   fdZ xZS )ConvNextEncoderc           
      ,   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 y c c}w )Nr   cpu)r   rQ   r   )r   r   ra   r   r   )r-   r.   r   
ModuleListstagesr   linspacedrop_path_ratesumdepthssplittolistre   r   
num_stagesr   append)	r/   rj   rN   r   prev_chsiout_chsstager0   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r1   output_hidden_statesreturn_dictr   c                     |rdnd }t        | j                        D ]  \  }}|r||fz   } ||      } |r||fz   }|st        d ||fD              S t        ||      S )N c              3   &   K   | ]	  }||  y wr,   r   ).0vs     r&   	<genexpr>z*ConvNextEncoder.forward.<locals>.<genexpr>   s     Xq!-Xs   )last_hidden_stater1   )	enumerater   tupler   )r/   r1   r   r   all_hidden_statesr   layer_modules          r&   r4   zConvNextEncoder.forward   s     #7BD(5 	8OA|#$58H$H!(7M		8   1]4D DX]4E$FXXX-++
 	
r(   )FT)r7   r8   r9   r.   r   rp   r   boolr   r   r   r4   r>   r?   s   @r&   r   r      sT    0 05&*	
((
 'tn
 d^	

 
u44	5
r(   r   c                   ,    e Zd ZU eed<   dZdZdgZd Zy)ConvNextPreTrainedModelrj   convnextrk   rr   c                    t        |t        j                  t        j                  f      rm|j                  j
                  j                  d| j                  j                         |j                  %|j                  j
                  j                          yyt        |t        j                  t        f      rJ|j                  j
                  j                          |j                  j
                  j                  d       yt        |t              rG|j                  :|j                  j
                  j                  | j                  j                          yyy)zInitialize the weightsr   )rT   stdNg      ?)
isinstancer   r{   rc   rG   datanormal_rj   initializer_rangerI   zero_	LayerNormrA   fill_rr   r   r   )r/   modules     r&   _init_weightsz%ConvNextPreTrainedModel._init_weights  s    fryy"))45 MM&&CT[[5R5R&S{{&  &&( '/@ ABKK""$MM$$S).++7,,11778Z8Z[ 8 /r(   N)	r7   r8   r9   r   __annotations__base_model_prefixmain_input_name_no_split_modulesr   r   r(   r&   r   r      s"    "$O()\r(   r   c                   x     e Zd Z fdZe	 	 	 ddeej                     dee   dee   de	e
ef   fd       Z xZS )ConvNextModelc                     t         |   |       || _        t        |      | _        t        |      | _        t        j                  |j                  d   |j                        | _        | j                          y )Nrw   )r-   r.   rj   r]   rn   r   encoderr   r   re   layer_norm_epsrh   	post_initri   s     r&   r.   zConvNextModel.__init__  s`     ,V4&v. f&9&9"&=6CXCXY 	r(   rk   r   r   r   c                 d   ||n| j                   j                  }||n| j                   j                  }|t        d      | j	                  |      }| j                  |||      }|d   }| j                  |j                  ddg            }|s
||f|dd  z   S t        |||j                        S )Nz You have to specify pixel_valuesr   r   r   r   r   )r   pooler_outputr1   )
rj   r   use_return_dictrm   rn   r   rh   rT   r   r1   )r/   rk   r   r   embedding_outputencoder_outputsr   pooled_outputs           r&   r4   zConvNextModel.forward$  s     %9$D $++JjJj 	 &1%<k$++B]B]?@@??<8,,!5# ' 
 ,A. '8'='=r2h'GH%}58KKK7/')77
 	
r(   )NNN)r7   r8   r9   r.   r   r   r   rp   r   r   r   r   r4   r>   r?   s   @r&   r   r     sk      59/3&*	"
u001"
 'tn"
 d^	"

 
u>>	?"
 "
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 fdZ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 )	ConvNextForImageClassificationc                 0   t         |   |       |j                  | _        t        |      | _        |j                  dkD  r-t        j                  |j                  d   |j                        nt        j                         | _	        | j                          y )Nr   r   )r-   r.   
num_labelsr   r   r   r{   re   r   
classifierr   ri   s     r&   r.   z'ConvNextForImageClassification.__init__Q  sy      ++%f- FLEVEVYZEZBIIf))"-v/@/@A`b`k`k`m 	
 	r(   rk   labelsr   r   r   c                    ||n| j                   j                  }| j                  |||      }|r|j                  n|d   }| j	                  |      }d}|| j                   j
                  | j                  dk(  rd| j                   _        nl| j                  dkD  rL|j                  t        j                  k(  s|j                  t        j                  k(  rd| j                   _        nd| j                   _        | j                   j
                  dk(  rIt               }	| j                  dk(  r& |	|j                         |j                               }n |	||      }n| j                   j
                  dk(  r=t               }	 |	|j                  d| 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   rQ   )losslogitsr1   )rj   r   r   r   r   problem_typer   r   r   longintr   squeezer   viewr   r   r1   )r/   rk   r   r   r   outputsr   r   r   loss_fctr%   s              r&   r4   z&ConvNextForImageClassification.forward_  s    &1%<k$++B]B]--CWep-q1<--'!*/{{''/??a'/;DKK,__q(fllejj.HFLL\a\e\eLe/LDKK,/KDKK,{{''<7"9??a'#FNN$4fnn6FGD#FF3D))-JJ+-B @&++b/R))-II,./Y,F)-)9TGf$EvE3!//
 	
r(   )NNNN)r7   r8   r9   r.   r   r   r   rp   
LongTensorr   r   r   r   r4   r>   r?   s   @r&   r   r   J  s      59-1/3&*3
u0013
 ))*3
 'tn	3

 d^3
 
u::	;3
 3
r(   r   zQ
    ConvNeXt backbone, to be used with frameworks like DETR and MaskFormer.
    c            
       f     e Zd Z fdZe	 	 ddej                  dee   dee   de	fd       Z
 xZS )ConvNextBackbonec                    t         |   |       t         | 	  |       t        |      | _        t        |      | _        |j                  d   g|j                  z   | _        i }t        | j                  | j                        D ]  \  }}t        |d      ||<    t        j                  |      | _        | j!                          y )Nr   rD   )rK   )r-   r.   _init_backboner]   rn   r   r   re   num_featureszip_out_featureschannelsrA   r   
ModuleDicthidden_states_normsr   )r/   rj   r   r   rd   r0   s        r&   r.   zConvNextBackbone.__init__  s     v&,V4&v.#0034v7J7JJ !#&t'9'94==#I 	gE<):<Ue)f&	g#%==1D#E  	r(   rk   r   r   r   c                    ||n| j                   j                  }||n| j                   j                  }| j                  |      }| j	                  |d|      }|r|j
                  n|d   }d}t        | j                  |      D ]/  \  }}	|| j                  v s | j                  |   |	      }	||	fz  }1 |s|f}
|r|
|fz  }
|
S t        ||r|d      S dd      S )ah  
        Examples:

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

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

        >>> 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)
        ```NTr   r   r   )feature_mapsr1   
attentions)rj   r   r   rn   r   r1   r   stage_namesout_featuresr   r   )r/   rk   r   r   r   r   r1   r   r   hidden_stater%   s              r&   r4   zConvNextBackbone.forward  s   2 &1%<k$++B]B]$8$D $++JjJj 	  ??<8,,!%#  
 2=--'!*#&t'7'7#G 	0E<)))>t77>|L/	0
 "_F#=**M%+?-
 	
EI
 	
r(   )NN)r7   r8   r9   r.   r   r   r<   r   r   r   r4   r>   r?   s   @r&   r   r     sV    "  04&*	7
ll7
 'tn7
 d^	7

 
7
 7
r(   r   )r   r   r   r   )r   F).r:   typingr   r   r   torch.utils.checkpointr   torch.nnr   r   r   activationsr
   modeling_outputsr   r   r   r   modeling_utilsr   utilsr   r   utils.backbone_utilsr   configuration_convnextr   
get_loggerr7   loggerr<   r;   r   r'   Moduler*   rA   r]   rr   r   r   r   r   r   r   __all__r   r(   r&   <module>r     ss    "    A A !  . , 1 2 
		H	%U\\ e T V[VbVb *%ryy %		 < 0)BII )XBII @-
bii -
` \o \ \, 1
+ 1
 1
h C
%< C
C
L 
J
. J

J
Z mr(   