
    kh-                        d Z ddlZddlmZ ddlZddlmZ ddlmc mZ	 ddl
mZmZmZmZmZmZmZmZ 	 ddlmZ  G d dej*                        Z G d	 d
ej*                        Z G d dej.                        Z G d dej.                        Zdej2                  defdZdej2                  dej2                  dej2                  defdZdej2                  dej2                  dej2                  defdZ G d dej.                        Z G d dej@                        Z! G d dej@                        Z" G d dej@                        Z# G d  d!ej@                        Z$y# e$ r
 ddl
mZ Y 2w xY w)"z Normalization layers and wrappers

Norm layer definitions that support fast norm and consistent channel arg order (always first arg).

Hacked together by / Copyright 2022 Ross Wightman
    N)Tuple   )is_fast_normfast_group_normfast_layer_normfast_rms_norm
rms_norm2dfast_rms_norm2dfast_simple_normsimple_norm)rms_normc                   `     e Zd ZU ej                  j
                  e   ed<   d fd	Zd Z	 xZ
S )	GroupNorm
_fast_normc                 J    t         |   ||||       t               | _        y )N)epsaffinesuper__init__r   r   )selfnum_channels
num_groupsr   r   	__class__s        L/var/www/teggl/fontify/venv/lib/python3.12/site-packages/timm/layers/norm.pyr   zGroupNorm.__init__   s"    \s6J&.    c                 
   | j                   r7t        || j                  | j                  | j                  | j
                        S t        j                  || j                  | j                  | j                  | j
                        S Nr   r   r   weightbiasr   F
group_normr   xs     r   forwardzGroupNorm.forward!   S    ??"1doot{{DIItxxXX<<4??DKKDHHUUr   )    gh㈵>T)__name__
__module____qualname__torchjitFinalbool__annotations__r   r&   __classcell__r   s   @r   r   r      s!    		%%)
Vr   r   c                        e Zd ZU dZej
                  j                  e   ed<    fdZ	dej                  dej                  fdZ xZS )
GroupNorm1zL Group Normalization with 1 group.
    Input: tensor in shape [B, C, *]
    r   c                 F    t        |   d|fi | t               | _        y )Nr   r   )r   r   kwargsr   s      r   r   zGroupNorm1.__init__.   s     L3F3&.r   r%   returnc                 
   | j                   r7t        || j                  | j                  | j                  | j
                        S t        j                  || j                  | j                  | j                  | j
                        S r   r   r$   s     r   r&   zGroupNorm1.forward2   r'   r   r)   r*   r+   __doc__r,   r-   r.   r/   r0   r   Tensorr&   r1   r2   s   @r   r4   r4   (   s@     		%%)V V%,, Vr   r4   c                        e Zd ZU dZej
                  j                  e   ed<   d fd	Z	dej                  dej                  fdZ xZS )	LayerNormz# LayerNorm w/ fast norm option
    r   c                 H    t         |   |||       t               | _        y N)r   elementwise_affiner   r   r   r   r   r   s       r   r   zLayerNorm.__init__>        36J&.r   r%   r7   c                    | j                   r9t        || j                  | j                  | j                  | j
                        }|S t        j                  || j                  | j                  | j                  | j
                        }|S r   )r   r   normalized_shaper    r!   r   r"   
layer_normr$   s     r   r&   zLayerNorm.forwardB   sf    ??4#8#8$++tyyRVRZRZ[A  Q 5 5t{{DIItxxXAr   ư>Tr9   r2   s   @r   r=   r=   9   s;    		%%) %,, r   r=   c                        e Zd ZU dZej
                  j                  e   ed<   d fd	Z	dej                  dej                  fdZ xZS )LayerNorm2dz5 LayerNorm for channels of '2D' spatial NCHW tensors r   c                 H    t         |   |||       t               | _        y r?   r   rA   s       r   r   zLayerNorm2d.__init__N   rB   r   r%   r7   c                 `   |j                  dddd      }| j                  r8t        || j                  | j                  | j
                  | j                        }nAt        j                  || j                  | j                  | j
                  | j                        }|j                  dddd      }|S Nr         r   )	permuter   r   rD   r    r!   r   r"   rE   r$   s     r   r&   zLayerNorm2d.forwardR   s    IIaAq!??4#8#8$++tyyRVRZRZ[AQ 5 5t{{DIItxxXAIIaAq!r   rF   r9   r2   s   @r   rI   rI   J   s9    ?		%%) %,, r   rI   tensorr7   c                     t         j                  j                         r| j                         S | j                  t         j                        S )N)memory_format)r,   r-   is_scriptingis_contiguouscontiguous_format)rP   s    r   _is_contiguousrV   \   s;    yy##%%##%2I2I#JJr   r%   r    r!   r   c                     t        j                  | ddd      \  }}| |z
  t        j                  ||z         z  } | |d d d d f   z  |d d d d f   z   } | S )Nr   FT)dimunbiasedkeepdim)r,   var_meanrsqrt)r%   r    r!   r   sus         r   _layer_norm_cfr_   d   s_    >>!UDADAq	
Q%++a#g&&A	F1dD=!!DD$$77AHr   c                    | j                  dd      }| | z  j                  dd      ||z  z
  j                  d      }| |z
  t        j                  ||z         z  } | |j	                  dddd      z  |j	                  dddd      z   } | S )Nr   T)rX   rZ   r   )meanclampr,   r\   view)r%   r    r!   r   r^   r]   s         r   _layer_norm_cf_sqmre   k   s    	1d#A
a%!T	*a!e	4;;A>A	
Q%++a#g&&A	FKK2q!$$tyyB1'==AHr   c                   D     e Zd ZdZd fd	Zdej                  fdZ xZS )LayerNormExp2da_   LayerNorm for channels_first tensors with 2d spatial dimensions (ie N, C, H, W).

    Experimental implementation w/ manual norm for tensors non-contiguous tensors.

    This improves throughput in some scenarios (tested on Ampere GPU), esp w/ channels_last
    layout. However, benefits are not always clear and can perform worse on other GPUs.
    c                 (    t         |   ||       y )N)r   )r   r   )r   r   r   r   s      r   r   zLayerNormExp2d.__init__|   s    3/r   r7   c                 B   t        |      rgt        j                  |j                  dddd      | j                  | j
                  | j                  | j                        j                  dddd      }|S t        || j
                  | j                  | j                        }|S rL   )	rV   r"   rE   rO   rD   r    r!   r   r_   r$   s     r   r&   zLayerNormExp2d.forward   s    !		!Q1%t'<'<dkk499VZV^V^``g`ghiklnoqr`s   q$++tyy$((CAr   )rG   )	r)   r*   r+   r:   r   r,   r;   r&   r1   r2   s   @r   rg   rg   s   s    0ELL r   rg   c                        e Zd ZU dZg dZeedf   ed<   eed<   e	ed<   e	ed<   dd fd	Z
dd
Zdej                  dej                  fdZ xZS )RmsNormz. RmsNorm w/ fast (apex) norm if available
    rD   r   r@   r   .rD   r   r@   r   r7   c                    ||d}t         |           |}t        |t        j                        r|f}t        |      | _        || _        || _        t               | _
        | j                  r9t        j                  t        j                  | j                  fi |      | _        n| j!                  dd        | j#                          y N)devicedtyper    r   r   
isinstancenumbersIntegraltuplerD   r   r@   r   r   nn	Parameterr,   emptyr    register_parameterreset_parameters	r   channelsr   r   ro   rp   factory_kwargsrD   r   s	           r   r   zRmsNorm.__init__       $*U;#&(8(89 02 %&6 7"(&."",,u{{43H3H'[N'[\DK##Hd3r   c                 p    | j                   r*t        j                  j                  | j                         y y r   r@   rv   initones_r    r   s    r   rz   zRmsNorm.reset_parameters   $    ""GGMM$++& #r   r%   c                     | j                   r.t        || j                  | j                  | j                        }|S t        || j                  | j                  | j                        }|S r   )r   r   rD   r    r   r   r$   s     r   r&   zRmsNorm.forward   sU     ??a!6!6TXXNA  D114;;IAr   rG   TNNr7   Nr)   r*   r+   r:   __constants__r   intr0   floatr/   r   rz   r,   r;   r&   r1   r2   s   @r   rk   rk      Q    SMCHo%	J &' %,, r   rk   c                        e Zd ZU dZg dZeedf   ed<   eed<   e	ed<   e	ed<   dd fd	Z
dd
Zdej                  dej                  fdZ xZS )	RmsNorm2daB   RmsNorm2D for NCHW tensors, w/ fast apex or cast norm if available

    NOTE: It's currently (2025-05-10) faster to use an eager 2d kernel that does reduction
    on dim=1 than to permute and use internal PyTorch F.rms_norm, this may change if something
    like https://github.com/pytorch/pytorch/pull/150576 lands.
    rl   .rD   r   r@   r   r7   c                    ||d}t         |           |}t        |t        j                        r|f}t        |      | _        || _        || _        t               | _
        | j                  r9t        j                  t        j                  | j                  fi |      | _        n| j!                  dd        | j#                          y rn   rq   r{   s	           r   r   zRmsNorm2d.__init__   r~   r   c                 p    | j                   r*t        j                  j                  | j                         y y r   r   r   s    r   rz   zRmsNorm2d.reset_parameters   r   r   r%   c                     | j                   r.t        || j                  | j                  | j                        }|S t        || j                  | j                  | j                        }|S r   )r   r
   rD   r    r   r	   r$   s     r   r&   zRmsNorm2d.forward   sU     ??4#8#8$++txxPA  1d33T[[$((KAr   r   r   r   r2   s   @r   r   r      sT     TMCHo%	J &' %,, r   r   c                        e Zd ZU dZg dZeedf   ed<   eed<   e	ed<   e	ed<   dd fd	Z
dd
Zdej                  dej                  fdZ xZS )
SimpleNormz SimpleNorm (x / std(x))
    rl   .rD   r   r@   r   r7   c                    ||d}t         |           |}t        |t        j                        r|f}t        |      | _        || _        || _        t               | _
        | j                  r9t        j                  t        j                  | j                  fi |      | _        n| j!                  dd        | j#                          y rn   rq   r{   s	           r   r   zSimpleNorm.__init__   r~   r   c                 p    | j                   r*t        j                  j                  | j                         y y r   r   r   s    r   rz   zSimpleNorm.reset_parameters   r   r   r%   c                     | j                   r.t        || j                  | j                  | j                        }|S t        || j                  | j                  | j                        }|S r   )r   r   rD   r    r   r   r$   s     r   r&   zSimpleNorm.forward   sS    ?? D$9$94;;QA  At44dkk488LAr   r   r   r   r2   s   @r   r   r      sQ    SMCHo%	J &' %,, r   r   c                        e Zd ZU dZg dZeedf   ed<   eed<   e	ed<   e	ed<   dd fd	Z
dd
Zdej                  dej                  fdZ xZS )SimpleNorm2dz! SimpleNorm for NCHW tensors
    rl   .rD   r   r@   r   r7   c                    ||d}t         |           |}t        |t        j                        r|f}t        |      | _        || _        || _        t               | _
        | j                  r9t        j                  t        j                  | j                  fi |      | _        n| j!                  dd        | j#                          y rn   rq   r{   s	           r   r   zSimpleNorm2d.__init__  r~   r   c                 p    | j                   r*t        j                  j                  | j                         y y r   r   r   s    r   rz   zSimpleNorm2d.reset_parameters$  r   r   r%   c                     |j                  dddd      }| j                  r-t        || j                  | j                  | j
                        }n,t        || j                  | j                  | j
                        }|j                  dddd      }|S rL   )rO   r   r   rD   r    r   r   r$   s     r   r&   zSimpleNorm2d.forward(  sr    IIaAq!?? D$9$94;;QAAt44dkk488LAIIaAq!r   r   r   r   r2   s   @r   r   r     r   r   r   )%r:   rs   typingr   r,   torch.nnrv   torch.nn.functional
functionalr"   	fast_normr   r   r   r   r	   r
   r   r   r   ImportErrorr   r4   r=   rI   r;   r/   rV   r   r_   re   rg   Modulerk   r   r   r    r   r   <module>r      sZ          
$,
V VV V" "",, $K5<< KD Kell ELL  SX %,,  ELL W\ R\\ *'bii 'T+		 +\% %P'299 'g  $##$s   E E.-E.