ó
    !Eñis<  ã                   óð   • S SK r S SKJr  S SKrS SKJrJr  S SKJrJ	r	  S SK
Jr  SSKJr  SSKJr  / S	Qr " S
 S\5      r " S S\5      r\\\\   \4   r " S S\5      r " S S\5      r " S S\5      rg)é    N)ÚUnion)ÚSizeÚTensor)Ú
functionalÚinit)Ú	Parameteré   )ÚCrossMapLRN2d)ÚModule)ÚLocalResponseNormr
   Ú	LayerNormÚ	GroupNormÚRMSNormc                   ó”   ^ • \ rS rSr% Sr/ SQr\\S'   \\S'   \\S'   \\S'    SS\S\S\S\SS	4
U 4S
 jjjr	S\
S\
4S jrS rSrU =r$ )r   é   a;  Applies local response normalization over an input signal.

The input signal is composed of several input planes, where channels occupy the second dimension.
Applies normalization across channels.

.. math::
    b_{c} = a_{c}\left(k + \frac{\alpha}{n}
    \sum_{c'=\max(0, c-n/2)}^{\min(N-1,c+n/2)}a_{c'}^2\right)^{-\beta}

Args:
    size: amount of neighbouring channels used for normalization
    alpha: multiplicative factor. Default: 0.0001
    beta: exponent. Default: 0.75
    k: additive factor. Default: 1

Shape:
    - Input: :math:`(N, C, *)`
    - Output: :math:`(N, C, *)` (same shape as input)

Examples::

    >>> lrn = nn.LocalResponseNorm(2)
    >>> signal_2d = torch.randn(32, 5, 24, 24)
    >>> signal_4d = torch.randn(16, 5, 7, 7, 7, 7)
    >>> output_2d = lrn(signal_2d)
    >>> output_4d = lrn(signal_4d)

)ÚsizeÚalphaÚbetaÚkr   r   r   r   ÚreturnNc                 óR   >• [         TU ]  5         Xl        X l        X0l        X@l        g ©N©ÚsuperÚ__init__r   r   r   r   ©Úselfr   r   r   r   Ú	__class__s        €Ú[/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torch/nn/modules/normalization.pyr   ÚLocalResponseNorm.__init__5   ó$   ø€ ô 	‰ÑÔØŒ	ØŒ
ØŒ	Ø�ó    Úinputc                 ó„   • [         R                  " XR                  U R                  U R                  U R
                  5      $ ©z
Runs the forward pass.
)ÚFÚlocal_response_normr   r   r   r   ©r   r#   s     r   ÚforwardÚLocalResponseNorm.forward>   s+   € ô ×$Ò$ U¯I©I°t·z±zÀ4Ç9Á9ÈdÏfÉfÓUÐUr"   c                 ó:   • SR                   " S0 U R                  D6$ ©ú0
Return the extra representation of the module.
z){size}, alpha={alpha}, beta={beta}, k={k}© ©ÚformatÚ__dict__©r   s    r   Ú
extra_reprÚLocalResponseNorm.extra_reprD   ó   € ð ;×AÒAÑRÀDÇMÁMÑRÐRr"   ©r   r   r   r   )ç-Cëâ6?ç      è?g      ð?)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú__constants__ÚintÚ__annotations__Úfloatr   r   r)   r3   Ú__static_attributes__Ú__classcell__©r   s   @r   r   r      s~   ø‡ ñò: 3€MØ
ƒIØƒLØ
ƒKØƒHð NQñØðØ %ðØ49ðØEJðà	÷ð ðV˜Vð V¨ô V÷Sð Sr"   r   c                   ó�   ^ • \ rS rSr% \\S'   \\S'   \\S'   \\S'    SS\S\S\S\SS4
U 4S jjjrS	\S\4S
 jr	S\
4S jrSrU =r$ )r
   éK   r   r   r   r   r   Nc                 óR   >• [         TU ]  5         Xl        X l        X0l        X@l        g r   r   r   s        €r   r   ÚCrossMapLRN2d.__init__Q   r!   r"   r#   c                 ó„   • [         R                  " XR                  U R                  U R                  U R
                  5      $ r%   )Ú_cross_map_lrn2dÚapplyr   r   r   r   r(   s     r   r)   ÚCrossMapLRN2d.forwardZ   s+   € ô  ×%Ò% e¯Y©Y¸¿
¹
ÀDÇIÁIÈtÏvÉvÓVÐVr"   c                 ó:   • SR                   " S0 U R                  D6$ r,   r/   r2   s    r   r3   ÚCrossMapLRN2d.extra_repr`   r5   r"   r6   )r7   r8   r	   )r9   r:   r;   r<   r?   r@   rA   r   r   r)   Ústrr3   rB   rC   rD   s   @r   r
   r
   K   sz   ø‡ Ø
ƒIØƒLØ
ƒKØƒHð NOñØðØ %ðØ49ðØEJðà	÷ð ðW˜Vð W¨ô WðS˜C÷ Sò Sr"   r
   c                   ó®   ^ • \ rS rSr% Sr/ SQr\\S4   \S'   \	\S'   \
\S'        SS\S\	S\
S	\
S
S4
U 4S jjjrSS jrS\S
\4S jrS
\4S jrSrU =r$ )r   éj   aÆ  Applies Layer Normalization over a mini-batch of inputs.

This layer implements the operation as described in
the paper `Layer Normalization <https://arxiv.org/abs/1607.06450>`__

.. math::
    y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta

The mean and standard-deviation are calculated over the last `D` dimensions, where `D`
is the dimension of :attr:`normalized_shape`. For example, if :attr:`normalized_shape`
is ``(3, 5)`` (a 2-dimensional shape), the mean and standard-deviation are computed over
the last 2 dimensions of the input (i.e. ``input.mean((-2, -1))``).
:math:`\gamma` and :math:`\beta` are learnable affine transform parameters of
:attr:`normalized_shape` if :attr:`elementwise_affine` is ``True``.
The variance is calculated via the biased estimator, equivalent to
`torch.var(input, correction=0)`.

.. note::
    Unlike Batch Normalization and Instance Normalization, which applies
    scalar scale and bias for each entire channel/plane with the
    :attr:`affine` option, Layer Normalization applies per-element scale and
    bias with :attr:`elementwise_affine`.

This layer uses statistics computed from input data in both training and
evaluation modes.

Args:
    normalized_shape (int or list or torch.Size): input shape from an expected input
        of size

        .. math::
            [* \times \text{normalized\_shape}[0] \times \text{normalized\_shape}[1]
                \times \ldots \times \text{normalized\_shape}[-1]]

        If a single integer is used, it is treated as a singleton list, and this module will
        normalize over the last dimension which is expected to be of that specific size.
    eps: a value added to the denominator for numerical stability. Default: 1e-5
    elementwise_affine: a boolean value that when set to ``True``, this module
        has learnable per-element affine parameters initialized to ones (for weights)
        and zeros (for biases). Default: ``True``.
    bias: If set to ``False``, the layer will not learn an additive bias (only relevant if
        :attr:`elementwise_affine` is ``True``). Default: ``True``.

Attributes:
    weight: the learnable weights of the module of shape
        :math:`\text{normalized\_shape}` when :attr:`elementwise_affine` is set to ``True``.
        The values are initialized to 1.
    bias:   the learnable bias of the module of shape
            :math:`\text{normalized\_shape}` when :attr:`elementwise_affine` is set to ``True``.
            The values are initialized to 0.

Shape:
    - Input: :math:`(N, *)`
    - Output: :math:`(N, *)` (same shape as input)

Examples::

    >>> # NLP Example
    >>> batch, sentence_length, embedding_dim = 20, 5, 10
    >>> embedding = torch.randn(batch, sentence_length, embedding_dim)
    >>> layer_norm = nn.LayerNorm(embedding_dim)
    >>> # Activate module
    >>> layer_norm(embedding)
    >>>
    >>> # Image Example
    >>> N, C, H, W = 20, 5, 10, 10
    >>> input = torch.randn(N, C, H, W)
    >>> # Normalize over the last three dimensions (i.e. the channel and spatial dimensions)
    >>> # as shown in the image below
    >>> layer_norm = nn.LayerNorm([C, H, W])
    >>> output = layer_norm(input)

.. image:: ../_static/img/nn/layer_norm.jpg
    :scale: 50 %

©Únormalized_shapeÚepsÚelementwise_affine.rS   rT   rU   NÚbiasr   c                 ó"  >• XVS.n[         TU ]  5         [        U[        R                  5      (       a  U4n[        U5      U l        X l        X0l        U R                  (       ay  [        [        R                  " U R                  40 UD65      U l        U(       a0  [        [        R                  " U R                  40 UD65      U l        O7U R                  SS 5        O$U R                  SS 5        U R                  SS 5        U R                  5         g )N©ÚdeviceÚdtyperV   Úweight)r   r   Ú
isinstanceÚnumbersÚIntegralÚtuplerS   rT   rU   r   ÚtorchÚemptyr[   rV   Úregister_parameterÚreset_parameters)	r   rS   rT   rU   rV   rY   rZ   Úfactory_kwargsr   s	           €r   r   ÚLayerNorm.__init__½   sà   ø€ ð %+Ñ;ˆÜ‰ÑÔÜÐ&¬×(8Ñ(8×9Ñ9à 0Ð2ÐÜ %Ð&6Ó 7ˆÔØŒØ"4ÔØ×"×"Ü#Ü—’˜D×1Ñ1ÑD°^ÑDóˆDŒKö Ü%Ü—K’K × 5Ñ 5ÑH¸ÑHó�•	ð ×'Ñ'¨°Õ5à×#Ñ# H¨dÔ3Ø×#Ñ# F¨DÔ1à×ÑÕr"   c                 óÄ   • U R                   (       aO  [        R                  " U R                  5        U R                  b!  [        R
                  " U R                  5        g g g r   )rU   r   Úones_r[   rV   Úzeros_r2   s    r   rc   ÚLayerNorm.reset_parametersÞ   s?   € Ø×"×"Ü�JŠJ�t—{‘{Ô#Ø�y‰yÑ$Ü—’˜DŸI™IÕ&ð %ð #r"   r#   c                 ó„   • [         R                  " XR                  U R                  U R                  U R
                  5      $ r   )r&   Ú
layer_normrS   r[   rV   rT   r(   s     r   r)   ÚLayerNorm.forwardä   s.   € Ü�|Š|Ø×(Ñ(¨$¯+©+°t·y±yÀ$Ç(Á(ó
ð 	
r"   c                 ó:   • SR                   " S0 U R                  D6$ )NúF{normalized_shape}, eps={eps}, elementwise_affine={elementwise_affine}r.   r/   r2   s    r   r3   ÚLayerNorm.extra_repré   s)   € ð6ß6<±fð=ñ NØ?C¿}¹}ñNð	
r"   )rV   rU   rT   rS   r[   )çñhãˆµøä>TTNN©r   N)r9   r:   r;   r<   r=   r>   r_   r?   r@   rA   ÚboolÚ_shape_tr   rc   r   r)   rO   r3   rB   rC   rD   s   @r   r   r   j   s    ø‡ ñKòZ F€MØ˜C ˜H‘oÓ%Ø	ƒJØÓð
 Ø#'ØØØñ à"ð ð ð ð !ð	 ð
 ð ð 
÷ ð  ôB'ð
˜Vð 
¨ô 
ð

˜C÷ 
ò 
r"   r   c                   ó¬   ^ • \ rS rSr% Sr/ SQr\\S'   \\S'   \\S'   \	\S'       SS\S\S\S\	S	S4
U 4S
 jjjr
SS jrS\S	\4S jrS	\4S jrSrU =r$ )r   éð   a-  Applies Group Normalization over a mini-batch of inputs.

This layer implements the operation as described in
the paper `Group Normalization <https://arxiv.org/abs/1803.08494>`__

.. math::
    y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta

The input channels are separated into :attr:`num_groups` groups, each containing
``num_channels / num_groups`` channels. :attr:`num_channels` must be divisible by
:attr:`num_groups`. The mean and standard-deviation are calculated
separately over each group. :math:`\gamma` and :math:`\beta` are learnable
per-channel affine transform parameter vectors of size :attr:`num_channels` if
:attr:`affine` is ``True``.
The variance is calculated via the biased estimator, equivalent to
`torch.var(input, correction=0)`.

This layer uses statistics computed from input data in both training and
evaluation modes.

Args:
    num_groups (int): number of groups to separate the channels into
    num_channels (int): number of channels expected in input
    eps: a value added to the denominator for numerical stability. Default: 1e-5
    affine: a boolean value that when set to ``True``, this module
        has learnable per-channel affine parameters initialized to ones (for weights)
        and zeros (for biases). Default: ``True``.

Shape:
    - Input: :math:`(N, C, *)` where :math:`C=\text{num\_channels}`
    - Output: :math:`(N, C, *)` (same shape as input)

Examples::

    >>> input = torch.randn(20, 6, 10, 10)
    >>> # Separate 6 channels into 3 groups
    >>> m = nn.GroupNorm(3, 6)
    >>> # Separate 6 channels into 6 groups (equivalent with InstanceNorm)
    >>> m = nn.GroupNorm(6, 6)
    >>> # Put all 6 channels into a single group (equivalent with LayerNorm)
    >>> m = nn.GroupNorm(1, 6)
    >>> # Activating the module
    >>> output = m(input)
)Ú
num_groupsÚnum_channelsrT   Úaffinerv   rw   rT   rx   Nr   c                 ó®  >• XVS.n[         TU ]  5         X!-  S:w  a  [        SU SU S35      eXl        X l        X0l        X@l        U R                  (       aK  [        [        R                  " U40 UD65      U l
        [        [        R                  " U40 UD65      U l        O$U R                  SS 5        U R                  SS 5        U R                  5         g )NrX   r   znum_channels (z#) must be divisible by num_groups (Ú)r[   rV   )r   r   Ú
ValueErrorrv   rw   rT   rx   r   r`   ra   r[   rV   rb   rc   )	r   rv   rw   rT   rx   rY   rZ   rd   r   s	           €r   r   ÚGroupNorm.__init__$  sÄ   ø€ ð %+Ñ;ˆÜ‰ÑÔØÑ$¨Ó)ÜØ   Ð.QÐR\ÐQ]Ð]^Ð_óð ð %ŒØ(ÔØŒØŒØ�;�;Ü#¤E§K¢K°Ñ$OÀÑ$OÓPˆDŒKÜ!¤%§+¢+¨lÑ"M¸nÑ"MÓNˆD�Ià×#Ñ# H¨dÔ3Ø×#Ñ# F¨DÔ1à×ÑÕr"   c                 ó¨   • U R                   (       aA  [        R                  " U R                  5        [        R                  " U R
                  5        g g r   )rx   r   rg   r[   rh   rV   r2   s    r   rc   ÚGroupNorm.reset_parametersA  s.   € Ø�;�;Ü�JŠJ�t—{‘{Ô#Ü�KŠK˜Ÿ	™	Õ"ð r"   r#   c                 ó„   • [         R                  " XR                  U R                  U R                  U R
                  5      $ r   )r&   Ú
group_normrv   r[   rV   rT   r(   s     r   r)   ÚGroupNorm.forwardF  s'   € Ü�|Š|˜E§?¡?°D·K±KÀÇÁÈDÏHÉHÓUÐUr"   c                 ó:   • SR                   " S0 U R                  D6$ )Nz8{num_groups}, {num_channels}, eps={eps}, affine={affine}r.   r/   r2   s    r   r3   ÚGroupNorm.extra_reprI  s!   € ØI×PÒPñ 
Ø�m‰mñ
ð 	
r"   )rx   rV   rT   rw   rv   r[   )rp   TNNrq   )r9   r:   r;   r<   r=   r>   r?   r@   rA   rr   r   rc   r   r)   rO   r3   rB   rC   rD   s   @r   r   r   ð   sš   ø‡ ñ+òZ D€MØƒOØÓØ	ƒJØƒLð ØØØñ àð ð ð ð ð	 ð
 ð ð 
÷ ð  ô:#ð
V˜Vð V¨ô Vð
˜C÷ 
ò 
r"   r   c            	       óÜ   ^ • \ rS rSr% Sr/ SQr\\S4   \S'   \	S-  \S'   \
\S'       SS\S\	S-  S\
S	S4U 4S
 jjjrSS jrS\R                  S	\R                  4S jrS	\4S jrSrU =r$ )r   iO  aâ  Applies Root Mean Square Layer Normalization over a mini-batch of inputs.

This layer implements the operation as described in
the paper `Root Mean Square Layer Normalization <https://arxiv.org/pdf/1910.07467.pdf>`__

.. math::
    y_i = \frac{x_i}{\mathrm{RMS}(x)} * \gamma_i, \quad
    \text{where} \quad \text{RMS}(x) = \sqrt{\epsilon + \frac{1}{n} \sum_{i=1}^{n} x_i^2}

The RMS is taken over the last ``D`` dimensions, where ``D``
is the dimension of :attr:`normalized_shape`. For example, if :attr:`normalized_shape`
is ``(3, 5)`` (a 2-dimensional shape), the RMS is computed over
the last 2 dimensions of the input.

Args:
    normalized_shape (int or list or torch.Size): input shape from an expected input
        of size

        .. math::
            [* \times \text{normalized\_shape}[0] \times \text{normalized\_shape}[1]
                \times \ldots \times \text{normalized\_shape}[-1]]

        If a single integer is used, it is treated as a singleton list, and this module will
        normalize over the last dimension which is expected to be of that specific size.
    eps: a value added to the denominator for numerical stability. If not specified,
        uses the machine epsilon of the computation (opmath) type: fp16/bf16 and
        fp32 inputs use ``torch.finfo(torch.float32).eps``, while fp64 inputs use
        ``torch.finfo(torch.float64).eps``.
    elementwise_affine: a boolean value that when set to ``True``, this module
        has learnable per-element affine parameters initialized to ones (for weights). Default: ``True``.

Shape:
    - Input: :math:`(N, *)`
    - Output: :math:`(N, *)` (same shape as input)

Examples::

    >>> rms_norm = nn.RMSNorm([2, 3])
    >>> input = torch.randn(2, 2, 3)
    >>> rms_norm(input)

rR   .rS   NrT   rU   r   c                 ól  >• XES.n[         TU ]  5         [        U[        R                  5      (       a  U4n[        U5      U l        X l        X0l        U R                  (       a0  [        [        R                  " U R                  40 UD65      U l        OU R                  SS 5        U R                  5         g )NrX   r[   )r   r   r\   r]   r^   r_   rS   rT   rU   r   r`   ra   r[   rb   rc   )r   rS   rT   rU   rY   rZ   rd   r   s          €r   r   ÚRMSNorm.__init__€  s˜   ø€ ð %+Ñ;ˆÜ‰ÑÔÜÐ&¬×(8Ñ(8×9Ñ9à 0Ð2ÐÜ %Ð&6Ó 7ˆÔØŒØ"4ÔØ×"×"Ü#Ü—’˜D×1Ñ1ÑD°^ÑDóˆD�Kð ×#Ñ# H¨dÔ3Ø×ÑÕr"   c                 óh   • U R                   (       a!  [        R                  " U R                  5        gg)zC
Resets parameters based on their initialization used in __init__.
N)rU   r   rg   r[   r2   s    r   rc   ÚRMSNorm.reset_parameters˜  s"   € ð ×"×"Ü�JŠJ�t—{‘{Õ#ð #r"   Úxc                 ón   • [         R                  " XR                  U R                  U R                  5      $ r%   )r&   Úrms_normrS   r[   rT   )r   r‰   s     r   r)   ÚRMSNorm.forwardŸ  s%   € ô �zŠz˜!×2Ñ2°D·K±KÀÇÁÓJÐJr"   c                 ó:   • SR                   " S0 U R                  D6$ )r-   rn   r.   r/   r2   s    r   r3   ÚRMSNorm.extra_repr¥  s)   € ð
6ß6<±fð=ñ NØ?C¿}¹}ñNð	
r"   )rU   rT   rS   r[   )NTNNrq   )r9   r:   r;   r<   r=   r>   r_   r?   r@   rA   rr   rs   r   rc   r`   r   r)   rO   r3   rB   rC   rD   s   @r   r   r   O  s¥   ø‡ ñ)òV F€MØ˜C ˜H‘oÓ%Ø	�‰ÓØÓð
 !Ø#'ØØñ à"ð ð �T‰\ð ð !ð	 ð 
÷ ð  ô0$ðK˜Ÿ™ð K¨%¯,©,ô Kð
˜C÷ 
ò 
r"   r   )r]   Útypingr   r`   r   r   Útorch.nnr   r&   r   Útorch.nn.parameterr   Ú
_functionsr
   rJ   Úmoduler   Ú__all__r   r?   Úlistrs   r   r   r   r.   r"   r   Ú<module>r–      s…   ðã Ý ã ß ß *Ý (å 9Ý ò V€ô7S˜ô 7SôtS�Fô Sð8 ��d˜3‘i Ð%Ñ&€ôC
�ô C
ôL\
�ô \
ô~]
ˆfõ ]
r"   