tj4> ddlZddlZddlmZmZddlmZmZddlm Z ddl m Z ddl mZgdZGd d eZGd d eZ eeezezZGd deZGddeZGddeZdS)N)SizeTensor) functionalinit) Parameter) CrossMapLRN2d)Module)LocalResponseNormr LayerNorm GroupNormRMSNormc eZdZUdZgdZeed<eed<eed<eed< ddedededed d f fd Zd e d e fdZ dZ xZ S)r aApplies 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) )sizealphabetakrrrr-C6???returnNct||_||_||_||_dSNsuper__init__rrrrselfrrrr __class__s \/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/nn/modules/normalization.pyrzLocalResponseNorm.__init__4;    inputcZtj||j|j|j|jSz( Runs the forward pass. )Flocal_response_normrrrrrr#s r forwardzLocalResponseNorm.forward=s%$UDItz49dfUUUr"c&djdi|jS@ Return the extra representation of the module. z){size}, alpha={alpha}, beta={beta}, k={k}format__dict__rs r extra_reprzLocalResponseNorm.extra_reprC!B:ARRDMRRRr")rrr) __name__ __module__ __qualname____doc__ __constants__int__annotations__floatrrr)r2 __classcell__rs@r r r s:322M III LLL KKK HHHNQ %49EJ VVVVVVV SSSSSSSr"r c ~eZdZUeed<eed<eed<eed< ddededededd f fd Zd edefd Zde fd Z xZ S)r rrrrrrrrNct||_||_||_||_dSrrrs r rzCrossMapLRN2d.__init__Pr!r"r#cZtj||j|j|j|jSr%)_cross_map_lrn2dapplyrrrrr(s r r)zCrossMapLRN2d.forwardYs% %eTY DItvVVVr"c&djdi|jSr+r.r1s r r2zCrossMapLRN2d.extra_repr_r3r")rrr) r4r5r6r9r:r;rrr)strr2r<r=s@r r r Js III LLL KKK HHHNO %49EJ WVWWWWW SCSSSSSSSSr"r c eZdZUdZgdZeedfed<eed<e ed< dde dede d e d d f fd Z dd Z de d e fdZd efdZxZS)r a Applies Layer Normalization over a mini-batch of inputs. This layer implements the operation as described in the paper `Layer Normalization `__ .. 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_shapeepselementwise_affine.rGrHrIh㈵>TNbiasrc6||d}tt|tjr|f}t ||_||_||_|jrlttj |jfi||_ |r*ttj |jfi||_ nC|ddn,|dd|dd|dS)NdevicedtyperKweight)rr isinstancenumbersIntegraltuplerGrHrIrtorchemptyrPrKregister_parameterreset_parameters) rrGrHrIrKrNrOfactory_kwargsrs r rzLayerNorm.__init__s/%+U;;  &(8 9 9 3 02  %&6 7 7"4  " 2# D1DD^DDDK 6%K 5HHHH ''5555  # #Hd 3 3 3  # #FD 1 1 1 r"c|jr;tj|j|jtj|jdSdSdSr)rIrones_rPrKzeros_r1s r rXzLayerNorm.reset_parameterssO  " ' Jt{ # # #y$ DI&&&&& ' '$$r"r#cZtj||j|j|j|jSr)r& layer_normrGrPrKrHr(s r r)zLayerNorm.forwards*| 4($+ty$(   r"c<djdi|jd|jduiS)NzW{normalized_shape}, eps={eps}, elementwise_affine={elementwise_affine}, bias={use_bias}use_biasr-r/r0rKr1s r r2zLayerNorm.extra_reprN % $ V V'+} V V?CyPT?T V V V r")rJTTNNrN)r4r5r6r7r8rTr9r:r;bool_shape_trrXrr)rDr2r<r=s@r r r isKKZFEEMCHo%%% JJJ #'  "  !           B''''  V      C        r"r ceZdZUdZgdZeed<eed<eed<eed< ddd dedededed ed d f fd Z ddZ de d e fdZ d e fdZxZS)r aRApplies Group Normalization over a mini-batch of inputs. This layer implements the operation as described in the paper `Group Normalization `__ .. 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`` bias: If set to ``False``, the layer will not learn an additive bias (only relevant if :attr:`affine` is ``True``). 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_channelsrHaffinergrhrHrirJTN)rKrKrc||d}t||zdkrtd|d|d||_||_||_||_|jrbttj |fi||_ |r%ttj |fi||_ nC| ddn,| dd| dd| dS)NrMrznum_channels (z#) must be divisible by num_groups ()rKrP)rr ValueErrorrgrhrHrirrUrVrPrKrWrX) rrgrhrHrirNrOrKrYrs r rzGroupNorm.__init__%s3%+U;;  * $ ) )___R\___ %( ; 2#EK $O$O$O$OPPDK 6%ek,&Q&Q.&Q&QRR ''5555  # #Hd 3 3 3  # #FD 1 1 1 r"c|jr;tj|j|jtj|jdSdSdSr)rirr[rPrKr\r1s r rXzGroupNorm.reset_parametersGsN ; ' Jt{ # # #y$ DI&&&&& ' '$$r"r#cZtj||j|j|j|jSr)r& group_normrgrPrKrHr(s r r)zGroupNorm.forwardMs"|E4?DKDHUUUr"c<djdi|jd|jduiS)NzI{num_groups}, {num_channels}, eps={eps}, affine={affine}, bias={use_bias}r`r-rar1s r r2zGroupNorm.extra_reprPrbr")rJTNNrc)r4r5r6r7r8r9r:r;rdrrXrr)rDr2r<r=s@r r r s3--^DCCMOOO JJJ LLL                         D'''' VVVVVVV C        r"r c eZdZUdZgdZeedfed<edzed<e ed< dde dedzde d dffd Z dd Z d e jd e jfd Zd efdZxZS)raApplies 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 `__ .. 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 (float, optional): 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``. Default: ``None`` 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) rF.rGNrHrITrc||d}tt|tjr|f}t ||_||_||_|jr*ttj |jfi||_ n| dd|dS)NrMrP)rrrQrRrSrTrGrHrIrrUrVrPrWrX)rrGrHrIrNrOrYrs r rzRMSNorm.__init__s%+U;;  &(8 9 9 3 02  %&6 7 7"4  " 4# D1DD^DDDKK  # #Hd 3 3 3 r"cJ|jrtj|jdSdS)zS Resets parameters based on their initialization used in __init__. N)rIrr[rPr1s r rXzRMSNorm.reset_parameterss1  " $ Jt{ # # # # # $ $r"xcNtj||j|j|jSr%)r&rms_normrGrPrH)rrts r r)zRMSNorm.forwards!z!T2DKJJJr"c&djdi|jS)r,zF{normalized_shape}, eps={eps}, elementwise_affine={elementwise_affine}r-r.r1s r r2zRMSNorm.extra_reprs1  = 66< N N?C} N N r")NTNNrc)r4r5r6r7r8rTr9r:r;rdrerrXrUrr)rDr2r<r=s@r rrWs ))VFEEMCHo%%%  !#'   " T\ !         0$$$$KK%,KKKK  C        r"r)rRrUrrtorch.nnrr&rtorch.nn.parameterr _functionsr rAmoduler __all__r r9listrer r rr-r"r r~s ********((((((999999 V U U7S7S7S7S7S7S7S7StSSSSSFSSS8 c?T !C C C C C C C C Le e e e e e e e P] ] ] ] ] f] ] ] ] ] r"