
    RЦid                        S r SSKrSSKrSSKrSSKJr  SSKJrJ	r	J
r
JrJr  SSKrSSKJs  Jr  SSKJr  SSKJrJr  SSKJrJrJrJrJrJrJrJrJrJrJ r J!r!  SS	K"J#r#  SS
K$J%r%  SSK&J'r'  SSK(J)r)J*r*  SSK+J,r,J-r-J.r.  S/r/\R`                  " \15      r2 " S S\Rf                  5      r4 " S S\Rf                  5      r5 " S S\Rf                  5      r6S\74S jr8\'S\74S j5       r9 " S S\Rf                  5      r: " S S\Rf                  5      r;S1S\Rf                  S\<S\=4S jjr>S r?S  r@S2S! jrAS3S" jrB\-" \B" 5       \B" 5       \B" 5       \B" S#S$9\B" S#S$9\B" S#S$9S%.5      rC\,S2S&\;4S' jj5       rD\,S2S&\;4S( jj5       rE\,S2S&\;4S) jj5       rF\,S2S&\;4S* jj5       rG\,S2S&\;4S+ jj5       rH\,S2S&\;4S, jj5       rI\." \1S-S.S/S0.5        g)4a  Nested Transformer (NesT) in PyTorch

A PyTorch implement of Aggregating Nested Transformers as described in:

'Aggregating Nested Transformers'
    - https://arxiv.org/abs/2105.12723

The official Jax code is released and available at https://github.com/google-research/nested-transformer. The weights
have been converted with convert/convert_nest_flax.py

Acknowledgments:
* The paper authors for sharing their research, code, and model weights
* Ross Wightman's existing code off which I based this

Copyright 2021 Alexander Soare
    N)partial)ListOptionalTupleTypeUnion)nnIMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STD)
PatchEmbedMlpDropPathcalculate_drop_path_ratescreate_classifiertrunc_normal__assertcreate_conv2dcreate_pool2d	to_ntupleuse_fused_attn	LayerNorm   )build_model_with_cfg)feature_take_indices)register_notrace_function)checkpoint_seqnamed_apply)register_modelgenerate_default_cfgsregister_model_deprecationsNestc                      ^  \ rS rSr% Sr\R                  R                  \   \	S'         SS\
S\
S\S\S\4
U 4S	 jjjrS
 rSrU =r$ )	Attention6   z
This is much like `.vision_transformer.Attention` but uses *localised* self attention by accepting an input with
 an extra "image block" dim

fused_attndim	num_headsqkv_bias	attn_drop	proj_dropc                 X  > XgS.n[         T
U ]  5         X l        X-  n	U	S-  U l        [	        5       U l        [        R                  " USU-  4SU0UD6U l        [        R                  " U5      U l
        [        R                  " X40 UD6U l        [        R                  " U5      U l        g )Ndevicedtypeg         bias)super__init__r(   scaler   r&   r	   LinearqkvDropoutr*   projr+   )selfr'   r(   r)   r*   r+   r.   r/   ddhead_dim	__class__s             O/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/timm/models/nest.pyr3   Attention.__init__=   s     /"#%
(*99S!C%=h="=I.IIc-"-	I.    c           	         UR                   u  p#pEU R                  U5      R                  X#USU R                  XPR                  -  5      R	                  SSSSSS5      nUR                  S5      u  pxn	U R                  (       a=  [        R                  " XxXR                  (       a  U R                  R                  OSS9nOFXpR                  -  nXxR                  S	S
5      -  n
U
R                  S
S9n
U R                  U
5      n
X-  nUR	                  SSSSS5      R                  X#XE5      nU R                  U5      nU R!                  U5      nU$ )z]
x is shape: B (batch_size), T (image blocks), N (seq length per image block), C (embed dim)
r0   r      r                 )	dropout_p)r'   )shaper6   reshaper(   permuteunbindr&   Fscaled_dot_product_attentiontrainingr*   pr4   	transposesoftmaxr8   r+   )r9   xBTNCr6   qkvattns              r=   forwardAttention.forwardS   s    WW
ahhqk!!!1dnna>>>QRZZ[\^_abdeghjkl**Q-a??..qQVcVc$..BRBRiklAJJA{{2r**D<<B<'D>>$'DA IIaAq!$,,Q18IIaLNN1r?   )r*   r&   r(   r8   r+   r6   r4   )   FrD   rD   NN)__name__
__module____qualname____firstlineno____doc__torchjitFinalbool__annotations__intfloatr3   r[   __static_attributes____classcell__r<   s   @r=   r$   r$   6   su     		%%
 "!!// / 	/
 / / /, r?   r$   c                      ^  \ rS rSrSrSSSSS\R                  \R                  SS4	S\S\S	\	S
\
S\	S\	S\	S\\R                     S\\R                     4U 4S jjjrS rSrU =r$ )TransformerLayerl   z
This is much like `.vision_transformer.Block` but:
    - Called TransformerLayer here to allow for "block" as defined in the paper ("non-overlapping image blocks")
    - Uses modified Attention layer that handles the "block" dimension
      @FrD   Nr'   r(   	mlp_ratior)   r+   r*   	drop_path	act_layer
norm_layerc                   > XS.n[         TU ]  5         U	" U40 UD6U l        [        U4UUUUS.UD6U l        US:  a  [        U5      O[        R                  " 5       U l        U	" U40 UD6U l	        [        X-  5      n[        SUUUUS.UD6U l        US:  a  [        U5      U l        g [        R                  " 5       U l        g )Nr-   )r(   r)   r*   r+   rD   )in_featureshidden_featuresrs   drop )r2   r3   norm1r$   rZ   r   r	   Identity
drop_path1norm2rh   r   mlp
drop_path2)r9   r'   r(   rq   r)   r+   r*   rr   rs   rt   r.   r/   r:   mlp_hidden_dimr<   s                 r=   r3   TransformerLayer.__init__r   s     /*r*


 
	 2;R(9-R[[]*r*
S_- 
*	

 
 2;R(9-R[[]r?   c                     U R                  U5      nXR                  U R                  U5      5      -   nXR                  U R	                  U R                  U5      5      5      -   nU$ N)rz   r|   rZ   r   r~   r}   )r9   rR   ys      r=   r[   TransformerLayer.forward   sO    JJqM		!--A 788r?   )rZ   r|   r   r~   rz   r}   )r^   r_   r`   ra   rb   r	   GELUr   rh   ri   rf   r   Moduler3   r[   rj   rk   rl   s   @r=   rn   rn   l   s      ""!!!)+*,,,#S#S #S 	#S
 #S #S #S #S BII#S RYY#S #SJ r?   rn   c            	       f   ^  \ rS rSr   S	S\S\S\\R                     S\4U 4S jjjr	S r
SrU =r$ )
ConvPool   in_channelsout_channelsrt   pad_typec                    > XVS.n[         TU ]  5         [        X4SUSS.UD6U l        U" U40 UD6U l        [        SSSUS9U l        g )Nr-   r0   T)kernel_sizepaddingr1   maxrB   )r   strider   )r2   r3   r   convnormr   pool)	r9   r   r   rt   r   r.   r/   r:   r<   s	           r=   r3   ConvPool.__init__   sX     /!+nT\cgnkmn	|2r2	!%Qq(S	r?   c                 0   [        UR                  S   S-  S:H  S5        [        UR                  S   S-  S:H  S5        U R                  U5      nU R                  UR	                  SSSS5      5      R	                  SSSS5      nU R                  U5      nU$ )z*
x is expected to have shape (B, C, H, W)
rF   rB   r   z1BlockAggregation requires even input spatial dimsrG   r0   r   )r   rH   r   r   rJ   r   r9   rR   s     r=   r[   ConvPool.forward   s     	a1$&YZa1$&YZIIaLIIaii1a+,44Q1a@IIaLr?   )r   r   r   ) NN)r^   r_   r`   ra   rh   r   r	   r   strr3   r[   rj   rk   rl   s   @r=   r   r      sV     TT T RYY	T
 T T
 
r?   r   
block_sizec                     U R                   u  p#pE[        X1-  S:H  S5        [        XA-  S:H  S5        X1-  nXA-  nU R                  X&XX5      n U R                  SS5      R                  X&U-  SU5      n U $ )zimage to blocks
Args:
    x (Tensor): with shape (B, H, W, C)
    block_size (int): edge length of a single square block in units of H, W
r   z,`block_size` must divide input height evenlyz+`block_size` must divide input width evenlyrB   r0   rG   )rH   r   rI   rP   )rR   r   rS   HWrV   grid_height
grid_widths           r=   blockifyr      s~     ''JA!ANa!OPANa!NO/KJ			!**HA	Aq!!!:%=r1EAHr?   c                     U R                   u  p#pE[        [        R                  " U5      5      nXa-  =pxU R	                  X&XaX5      n U R                  SS5      R	                  X'X5      n U $ )zblocks to image
Args:
    x (Tensor): with shape (B, T, N, C) where T is number of blocks and N is sequence size per block
    block_size (int): edge length of a single square block in units of desired H, W
rB   r0   )rH   rh   mathsqrtrI   rP   )	rR   r   rS   rT   _rV   	grid_sizeheightwidths	            r=   
deblockifyr      sb     JA!DIIaL!I++F			!	zEA	Aq!!!U6AHr?   c                      ^  \ rS rSrSr           SS\S\S\S\S\S\S	\\   S
\S\S\S\S\\	\      S\\
\R                        S\\
\R                        S\4U 4S jjjrS rSrU =r$ )	NestLevel   z6Single hierarchical level of a Nested Transformer
    
num_blocksr   
seq_lengthr(   depth	embed_dimprev_embed_dimrq   r)   r+   r*   rr   rt   rs   r   c                   > UUS.n[         TU ]  5         X l        SU l        [        R
                  " [        R                  " SXU40 UD65      U l        Ub  [        Xv4XS.UD6U l
        O[        R                  " 5       U l
        [        U5      (       a  [        U5      U:X  d   S5       e[        R                  " [        U5       Vs/ s H$  n[        SUUUU	U
UU(       a  UU   OS UUS.	UD6PM&     sn6 U l        g s  snf )Nr-   Fr   )rt   r   zDMust provide as many drop path rates as there are transformer layers)	r'   r(   rq   r)   r+   r*   rr   rt   rs   ry   )r2   r3   r   grad_checkpointingr	   	Parameterrc   zeros	pos_embedr   r   r{   len
Sequentialrangern   transformer_encoder)r9   r   r   r   r(   r   r   r   rq   r)   r+   r*   rr   rt   rs   r   r.   r/   r:   ir<   s                       r=   r3   NestLevel.__init__   s	   ( /$"'ekk!ZY&]Z\&]^% kzkhjkDIDI y>>y>U*r,rr*#%== 5\3# "  ##!##*3)A,%#  "3# $$  3#s   +C=c                    U R                  U5      nUR                  SSSS5      n[        XR                  5      nXR                  -   nU R
                  (       a:  [        R                  R                  5       (       d  [        U R                  U5      nOU R                  U5      n[        XR                  5      nUR                  SSSS5      $ )z
expects x as (B, C, H, W)
r   rB   r0   r   )r   rJ   r   r   r   r   rc   rd   is_scriptingr   r   r   r   s     r=   r[   NestLevel.forward  s     IIaLIIaAq!Q(""599+A+A+C+Ct77;A((+Aq//*yyAq!$$r?   )r   r   r   r   r   )Nrp   TrD   rD   NNNr   NN)r^   r_   r`   ra   rb   rh   r   ri   rf   r   r   r	   r   r   r3   r[   rj   rk   rl   s   @r=   r   r      s     -1!!!!/34837%0$0$ 0$ 	0$
 0$ 0$ 0$ %SM0$ 0$ 0$ 0$ 0$  U,0$ !bii10$  RYY00$  !0$ 0$d% %r?   r   c            '       f  ^  \ rS rSrSr                     S.S\S\S\S\S\\S4   S	\\S4   S
\\S4   S\S\S\S\S\S\S\S\	\
\R                        S\	\
\R                        S\S\S\4&U 4S jjjr\R                   R"                  S/S j5       r\R                   R"                  S 5       r\R                   R"                  S0S j5       r\R                   R"                  S1S j5       r\R                   R"                  S\R                  4S j5       rS2S\S\4S jjr     S3S\R0                  S \	\\\\   4      S!\S"\S#\S$\S\\\R0                     \\R0                  \\R0                     4   4   4S% jjr   S4S \\\\   4   S&\S'\4S( jjrS) rS0S*\4S+ jjrS, rS-r U =r!$ )5r"   i   zxNested Transformer (NesT)

A PyTorch impl of : `Aggregating Nested Transformers`
    - https://arxiv.org/abs/2105.12723
img_sizein_chans
patch_size
num_levels
embed_dims.r(   depthsnum_classesrq   r)   	drop_rateproj_drop_rateattn_drop_ratedrop_path_ratert   rs   r   weight_initglobal_poolc                 2  > [         T U ]  5         UUS.nS HU  n[        5       U   n[        U[        R
                  R                  5      (       d  M;  [        U5      U:X  a  ML   SU S35       e   [        U5      " U5      n[        U5      " U5      n[        U5      " U5      nXl	        X l
        US   =U l        U l        / U l        U=(       d    [        nU=(       d    [        R                   nXl        X@l        [        U[        R
                  R                  5      (       a  US   US   :X  d   S5       eUS   nX-  S:X  d   S	5       eX0l        S
[(        R*                  " US[(        R,                  S9-  R/                  S5      R1                  5       U l        X-  [4        R6                  " U R2                  S   5      -  S:X  d   S5       e[9        X-  [4        R6                  " U R2                  S   5      -  5      U l        [=        SUUUUS   SS.UD6U l        U R>                  R@                  U l         U R@                  U R2                  S   -  U l!        / n[E        XSS9nSnS
n[G        [        U R2                  5      5       H  nUU   nURI                  [K        U R2                  U   U R:                  U RB                  UU   UU   UU4U	U
UUUU   UUUS.UD65        U =R                  [M        UUSU 3S9/-  sl        UnUS-  nM     [        RN                  " U6 U l(        U" US   40 UD6U l)        [U        U R                  U R                  4SU0UD6u  nnUU l+        [        RX                  " U5      U l-        UU l.        U R_                  U5        g)a  
Args:
    img_size (int, tuple): input image size
    in_chans (int): number of input channels
    patch_size (int): patch size
    num_levels (int): number of block hierarchies (T_d in the paper)
    embed_dims (int, tuple): embedding dimensions of each level
    num_heads (int, tuple): number of attention heads for each level
    depths (int, tuple): number of transformer layers for each level
    num_classes (int): number of classes for classification head
    mlp_ratio (int): ratio of mlp hidden dim to embedding dim for MLP of transformer layers
    qkv_bias (bool): enable bias for qkv if True
    drop_rate (float): dropout rate for MLP of transformer layers, MSA final projection layer, and classifier
    attn_drop_rate (float): attention dropout rate
    drop_path_rate (float): stochastic depth rate
    norm_layer: (nn.Module): normalization layer for transformer layers
    act_layer: (nn.Module): activation layer in MLP of transformer layers
    pad_type: str: Type of padding to use '' for PyTorch symmetric, 'same' for TF SAME
    weight_init: (str): weight init scheme
    global_pool: (str): type of pooling operation to apply to final feature map

Notes:
    - Default values follow NesT-B from the original Jax code.
    - `embed_dims`, `num_heads`, `depths` should be ints or tuples with length `num_levels`.
    - For those following the paper, Table A1 may have errors!
        - https://github.com/google-research/nested-transformer/issues/2
r-   r   r(   r   zRequire `len(z) == num_levels`rG   r   r   z Model only handles square inputsz*`patch_size` must divide `img_size` evenlyrA   cpuzUFirst level blocks don't fit evenly. Check `img_size`, `patch_size`, and `num_levels`F)r   r   r   r   flattenT)	stagewiseN)rq   r)   r+   r*   rr   rt   rs   r   zlevels.)num_chs	reductionmodulerB   	pool_typery   )0r2   r3   locals
isinstancecollectionsabcSequencer   r   r   r   num_featureshead_hidden_sizefeature_infor   r	   r   r   r   r   rc   arangelongfliptolistr   r   r   rh   r   r   patch_embednum_patchesr   r   r   appendr   dictr   levelsr   r   r   r7   	head_dropheadinit_weights)!r9   r   r   r   r   r   r(   r   r   rq   r)   r   r   r   r   rt   rs   r   r   r   r.   r/   r:   
param_nameparam_valuer   dp_ratesprev_dimcurr_strider   r'   r   r<   s!                                   r=   r3   Nest.__init__'  s   f 	/?J (:.K+{'?'?@@;':5czlRb7cc5 @
 z*:6
j))4	:&v.& 4>rNBD1,9
(	"$h 8 899A;(1+-Q/QQ-{H$)W+WW)$ ZUZZ XX^^_`ahhj&$))DOOA4F*GG1L 	ed	eL x5$))DOOTUDV:WWX & 
! m
 
  ++77**dooa.@@ ,^tTs4??+,AQ-CMM)"!q	 $!(("1+%#!  ! $ $skT[\][^R_"`!aaH1K- -. mmV, z"~44	 .d.?.?AQAQo]holnoT&I.	+&r?   c                     US;   d   eSU;   a!  [         R                  " U R                  5      * OSnU R                   H  n[	        UR
                  SSSS9  M     [        [        [        US9U 5        g )	N)nlhbr   r   rD   {Gz?rF   rB   stdab)	head_bias)	r   logr   r   r   r   r   r   _init_nest_weights)r9   moder   levels       r=   r   Nest.init_weights  sa    |###39T>TXXd..//r	[[E%//sbA> !G.)DdKr?   c                 r    [        [        U R                  5      5       Vs1 s H	  nSU S3iM     sn$ s  snf )Nzlevel.z
.pos_embed)r   r   r   )r9   r   s     r=   no_weight_decayNest.no_weight_decay  s3    05c$++6F0GH0G1&:&0GHHHs   4c                 6    [        SU(       a  SOSS 4SS/S9nU$ )Nz^patch_embedz^levels\.(\d+)z*^levels\.(\d+)\.transformer_encoder\.(\d+))z"^levels\.(\d+)\.(?:pool|pos_embed))r   )z^norm)i )stemblocks)r   )r9   coarsematchers      r=   group_matcherNest.group_matcher  s0     &,"2_aef=$
 r?   c                 6    U R                    H	  nXl        M     g r   )r   r   )r9   enablels      r=   set_grad_checkpointingNest.set_grad_checkpointing  s    A#)  r?   returnc                     U R                   $ r   )r   )r9   s    r=   get_classifierNest.get_classifier  s    yyr?   c                 h    Xl         [        U R                  U R                   US9u  U l        U l        g )N)r   )r   r   r   r   r   )r9   r   r   s      r=   reset_classifierNest.reset_classifier  s0    &&7t//;'H#$)r?   rR   indicesr   
stop_early
output_fmtintermediates_onlyc           	         US;   d   S5       e/ n[        [        U R                  5      U5      u  pU R                  U5      n[        U R                  5      S-
  n
[
        R                  R                  5       (       d  U(       d  U R                  nOU R                  SU	S-    n[        U5       Hy  u  pU" U5      nX;   d  M  U(       aM  X:X  aH  U R                  UR                  SSSS5      5      R                  SSSS5      nUR                  U5        Mh  UR                  U5        M{     U(       a  U$ WU
:X  a5  U R                  UR                  SSSS5      5      R                  SSSS5      nX4$ )a  Forward features that returns intermediates.

Args:
    x: Input image tensor
    indices: Take last n blocks if int, all if None, select matching indices if sequence
    norm: Apply norm layer to compatible intermediates
    stop_early: Stop iterating over blocks when last desired intermediate hit
    output_fmt: Shape of intermediate feature outputs
    intermediates_only: Only return intermediate features
Returns:

)NCHWzOutput shape must be NCHW.r   Nr   rB   r0   )r   r   r   r   r   rc   rd   r   	enumerater   rJ   r   )r9   rR   r  r   r  r  r  intermediatestake_indices	max_indexlast_idxstagesfeat_idxstagex_inters                  r=   forward_intermediatesNest.forward_intermediates  sI   * Y&D(DD&"6s4;;7G"Q Qt'!+99!!##:[[F[[)a-0F(0OHaA'H0"ii		!Q1(=>FFq!QPQRG!((1!((+  1   x		!))Aq!Q/088Aq!DAr?   
prune_norm
prune_headc                     [        [        U R                  5      U5      u  pEU R                  SUS-    U l        U(       a  [        R                  " 5       U l        U(       a  U R                  SS5        U$ )z?Prune layers not required for specified intermediates.
        Nr   r   r   )r   r   r   r	   r{   r   r  )r9   r  r&  r'  r  r  s         r=   prune_intermediate_layersNest.prune_intermediate_layers
  s[     #7s4;;7G"Qkk.9q=1DI!!!R(r?   c                     U R                  U5      nU R                  U5      nU R                  UR                  SSSS5      5      R                  SSSS5      nU$ )Nr   rB   r0   r   )r   r   r   rJ   r   s     r=   forward_featuresNest.forward_features  sR    QKKNIIaii1a+,44Q1a@r?   
pre_logitsc                 z    U R                  U5      nU R                  U5      nU(       a  U$ U R                  U5      $ r   )r   r   r   )r9   rR   r.  s      r=   forward_headNest.forward_head!  s5    QNN1q0DIIaL0r?   c                 J    U R                  U5      nU R                  U5      nU$ r   )r,  r0  r   s     r=   r[   Nest.forward&  s'    !!!$a r?   )r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   )   r0   rA   r0         i   rA   r]      rB   rB        rp   TrD   rD   rD   g      ?NNr   r   avgNNr   F)T)r=  )NFFr  F)r   FT)"r^   r_   r`   ra   rb   rh   r   ri   rf   r   r   r	   r   r   r3   rc   rd   ignorer   r   r  r  r  r  Tensorr   r   r$  r)  r,  r0  r[   rj   rk   rl   s   @r=   r"   r"      s     *9)3&0#!!!$&$&$'4837!$-H'H' H' 	H'
 H' c3hH' S#XH' #s(OH' H' H' H' H' "H' "H' "H'  !bii1!H'"  RYY0#H'$ %H'& 'H'( )H' H'T YYL L YYI I YY	 	 YY* * YY		  HC Hc H 8<$$',1 ||1  eCcN341  	1 
 1  1  !%1  
tELL!5tELL7I)I#JJ	K1 j ./$#	3S	>*  	 1$ 1
 r?   r   namer   c                 f   [        U [        R                  5      (       a  UR                  S5      (       aA  [	        U R
                  SSSS9  [        R                  R                  U R                  U5        g[	        U R
                  SSSS9  U R                  b*  [        R                  R                  U R                  5        gg[        U [        R                  5      (       aN  [	        U R
                  SSSS9  U R                  b*  [        R                  R                  U R                  5        ggg)zeNesT weight initialization
Can replicate Jax implementation. Otherwise follows vision_transformer.py
r   r   rF   rB   r   N)r   r	   r5   
startswithr   weightinit	constant_r1   zeros_Conv2d)r   rB  r   s      r=   r   r   ,  s     &"))$$??6""&--SB!<GGfkk95&--SB!<{{&v{{+ '	FBII	&	&fmma8;;"GGNN6;;' # 
'r?   c                    [         R                  SU R                  UR                  5        U R                  S   nUR                  SS u  p4[        [        R
                  " X4-  5      5      n[        U [        [        R
                  " U5      5      5      R                  SSSS5      n [        R                  " XU/SSS9n [        U R                  SSSS5      [        [        R
                  " U5      5      5      n U $ )	z
Rescale the grid of position embeddings when loading from state_dict
Expected shape of position embeddings is (1, T, N, C), and considers only square images
z$Resized position embedding: %s to %srB   r   r0   r   bicubicF)sizer   align_corners)_loggerinforH   rh   r   r   r   rJ   rL   interpolater   )posemb
posemb_newseq_length_oldnum_blocks_newseq_length_newsize_news         r=   resize_pos_embedrW  >  s    
 LL7zGWGWX\\!_N%/%5%5a%:"N499^:;<HDIIn$= >?GG1aQRSF]]68(<9\abFfnnQ1a0#dii6O2PQFMr?   c                    U R                  5        Vs/ s H  o"R                  S5      (       d  M  UPM     nnU HC  nX   R                  [        X5      R                  :w  d  M*  [	        X   [        X5      5      X'   ME     U $ s  snf )z3resize positional embeddings of pretrained weights 
pos_embed_)keysrD  rH   getattrrW  )
state_dictmodelrX   pos_embed_keyss       r=   checkpoint_filter_fnr_  O  sp    !+!2Q!2All<6Pa!2NQ='%"3"9"99,Z]GE<MNJM  	 Rs
   BBc                 H    [        [        U U4[        SSS9[        S.UD6nU$ )N)r   r   rB   T)out_indicesflatten_sequential)feature_cfgpretrained_filter_fn)r   r"   r   r_  )variant
pretrainedkwargsr]  s       r=   _create_nestrh  X  s:      Y4H1 E Lr?   c                 8    U SSSS/SSS[         [        SSS	S
.UE$ )Nr<  )r0   r4  r4     g      ?rK  Tzpatch_embed.projr   z
apache-2.0)urlr   
input_size	pool_sizecrop_pctinterpolationfixed_input_sizemeanr   
first_conv
classifierlicenser
   )rk  rg  s     r=   _cfgru  e  s9    =Bx9$%.B(  r?   ztimm/)	hf_hub_id)znest_base.untrainedznest_small.untrainedznest_tiny.untrainedznest_base_jx.goog_in1kznest_small_jx.goog_in1kznest_tiny_jx.goog_in1kr  c                 >    [        SSSSS.UD6n[        SSU 0UD6nU$ )Nest-B @ 224x224
    r5  r8  r:  r   rf  ry   )	nest_baser   rh  rf  rg  model_kwargsr]  s       r=   ry  ry  |  s<      W"jWOUWLLL|LELr?   c                 >    [        SSSSS.UD6n[        SSU 0UD6nU$ )Nest-S @ 224x224
    `      i  r0         r:  r   rf  ry   )
nest_smallrz  r{  s       r=   r  r    s3     e>ZPZe^deLM*MMELr?   c                 >    [        SSSSS.UD6n[        SSU 0UD6nU$ )Nest-T @ 224x224
    r  r  rB   rB   r]   r   rf  ry   )	nest_tinyrz  r{  s       r=   r  r    s3     d>ZPYd]cdLLL|LELr?   c                 b    UR                  SS5        [        SSSSS.UD6n[        S	SU 0UD6nU$ )
rx  r   samer5  r8  r:  r   rf  ry   )nest_base_jx
setdefaultr   rh  r{  s       r=   r  r    sL     j&) W"jWOUWLOJO,OELr?   c                 b    UR                  SS5        [        SSSSS.UD6n[        S	SU 0UD6nU$ )
r~  r   r  r  r  r:  r   rf  ry   )nest_small_jxr  r{  s       r=   r  r    sC     j&)e>ZPZe^deLPZP<PELr?   c                 b    UR                  SS5        [        SSSSS.UD6n[        S	SU 0UD6nU$ )
r  r   r  r  r  r  r   rf  ry   )nest_tiny_jxr  r{  s       r=   r  r    sC     j&)d>ZPYd]cdLOJO,OELr?   r  r  r  )jx_nest_basejx_nest_smalljx_nest_tiny)r   rD   r?  r>  )Jrb   collections.abcr   loggingr   	functoolsr   typingr   r   r   r   r   rc   torch.nn.functionalr	   
functionalrL   	timm.datar   r   timm.layersr   r   r   r   r   r   r   r   r   r   r   r   _builderr   	_featuresr   _features_fxr   _manipulater   r   	_registryr   r    r!   __all__	getLoggerr^   rN  r   r$   rn   r   rh   r   r   r   r"   r   ri   r   rW  r_  rh  ru  default_cfgsry  r  r  r  r  r  ry   r?   r=   <module>r     s  "     5 5     A    + + 3 4 Y Y(


H
%3		 3l/ryy /dryy :C   c  C%		 C%LI299 IX(ryy ( (U ($"
	 %6 F6"W5#g6"W5&  T   d   T            H"$"' r?   