
    '}h )                         d dl Z d dlmZ d dlZd dlmZ d dlmZmZ ddlm	Z
 ddlmZ dd	lmZ dd
lmZ g dZ G d de      Z G d de      Z G d de      Z G d de      Z G d dee      Zy)    N)Any)Tensor)	ParameterUninitializedParameter   )
functional)init   )Module)LazyModuleMixin)BilinearIdentity
LazyLinearLinearc                   @     e Zd ZdZdededdf fdZdedefdZ xZS )	r   a  A placeholder identity operator that is argument-insensitive.

    Args:
        args: any argument (unused)
        kwargs: any keyword argument (unused)

    Shape:
        - Input: :math:`(*)`, where :math:`*` means any number of dimensions.
        - Output: :math:`(*)`, same shape as the input.

    Examples::

        >>> m = nn.Identity(54, unused_argument1=0.1, unused_argument2=False)
        >>> input = torch.randn(128, 20)
        >>> output = m(input)
        >>> print(output.size())
        torch.Size([128, 20])

    argskwargsreturnNc                 "    t         |           y Nsuper__init__)selfr   r   	__class__s      V/var/www/html/test/engine/venv/lib/python3.12/site-packages/torch/nn/modules/linear.pyr   zIdentity.__init__*   s        inputc                     |S r    r   r   s     r   forwardzIdentity.forward-   s    r   )	__name__
__module____qualname____doc__r   r   r   r"   __classcell__r   s   @r   r   r      s5    (c S T V  r   r   c            	            e Zd ZU dZddgZeed<   eed<   eed<   	 	 ddedededdf fdZ	dd	Z
d
edefdZdefdZ xZS )r   a'  Applies a linear transformation to the incoming data: :math:`y = xA^T + b`.

    This module supports :ref:`TensorFloat32<tf32_on_ampere>`.

    On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.

    Args:
        in_features: size of each input sample
        out_features: size of each output sample
        bias: If set to ``False``, the layer will not learn an additive bias.
            Default: ``True``

    Shape:
        - Input: :math:`(*, H_{in})` where :math:`*` means any number of
          dimensions including none and :math:`H_{in} = \text{in\_features}`.
        - Output: :math:`(*, H_{out})` where all but the last dimension
          are the same shape as the input and :math:`H_{out} = \text{out\_features}`.

    Attributes:
        weight: the learnable weights of the module of shape
            :math:`(\text{out\_features}, \text{in\_features})`. The values are
            initialized from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, where
            :math:`k = \frac{1}{\text{in\_features}}`
        bias:   the learnable bias of the module of shape :math:`(\text{out\_features})`.
                If :attr:`bias` is ``True``, the values are initialized from
                :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where
                :math:`k = \frac{1}{\text{in\_features}}`

    Examples::

        >>> m = nn.Linear(20, 30)
        >>> input = torch.randn(128, 20)
        >>> output = m(input)
        >>> print(output.size())
        torch.Size([128, 30])
    in_featuresout_featuresweightNbiasr   c                 &   ||d}t         |           || _        || _        t	        t        j                  ||ffi |      | _        |r%t	        t        j                  |fi |      | _        n| j                  dd        | j                          y Ndevicedtyper-   )r   r   r*   r+   r   torchemptyr,   r-   register_parameterreset_parameters)r   r*   r+   r-   r1   r2   factory_kwargsr   s          r   r   zLinear.__init__\   s    $*U;&(\;,G Z> Z[!%++l"Mn"MNDI##FD1r   c                 L   t        j                  | j                  t        j                  d             | j
                  dt        j                  | j                        \  }}|dkD  rdt        j                  |      z  nd}t        j                  | j
                  | |       y y )N   )ar   r
   )r	   kaiming_uniform_r,   mathsqrtr-   _calculate_fan_in_and_fan_outuniform_)r   fan_in_bounds       r   r6   zLinear.reset_parametersi   sx     	dkkTYYq\:99 ::4;;GIFA-3aZA		&))QEMM$))eVU3 !r   r   c                 X    t        j                  || j                  | j                        S r   )Flinearr,   r-   r!   s     r   r"   zLinear.forwards   s    xxt{{DII66r   c                 X    d| j                    d| j                   d| j                  d u S )Nzin_features=z, out_features=z, bias=)r*   r+   r-   r   s    r   
extra_reprzLinear.extra_reprv   s8    d../t?P?P>QQXY]YbYbjnYnXoppr   TNNr   Nr#   r$   r%   r&   __constants__int__annotations__r   boolr   r6   r"   strrH   r'   r(   s   @r   r   r   1   st    #J #N3MNIM$( C  s  $  -1 47V 7 7qC qr   r   c            	       6     e Zd Z	 	 ddedededdf fdZ xZS )NonDynamicallyQuantizableLinearNr*   r+   r-   r   c                 .    t         |   |||||       y )N)r-   r1   r2   r   )r   r*   r+   r-   r1   r2   r   s         r   r   z(NonDynamicallyQuantizableLinear.__init__   s     l &e 	 	5r   rI   )r#   r$   r%   rM   rO   r   r'   r(   s   @r   rR   rR      s0    IM$(5C 5s 5$ 5-15 5r   rR   c                        e Zd ZU dZg dZeed<   eed<   eed<   eed<   	 	 ddedededed	df
 fd
Z	ddZ
deded	efdZd	efdZ xZS )r   a  Applies a bilinear transformation to the incoming data: :math:`y = x_1^T A x_2 + b`.

    Args:
        in1_features: size of each first input sample
        in2_features: size of each second input sample
        out_features: size of each output sample
        bias: If set to False, the layer will not learn an additive bias.
            Default: ``True``

    Shape:
        - Input1: :math:`(*, H_{in1})` where :math:`H_{in1}=\text{in1\_features}` and
          :math:`*` means any number of additional dimensions including none. All but the last dimension
          of the inputs should be the same.
        - Input2: :math:`(*, H_{in2})` where :math:`H_{in2}=\text{in2\_features}`.
        - Output: :math:`(*, H_{out})` where :math:`H_{out}=\text{out\_features}`
          and all but the last dimension are the same shape as the input.

    Attributes:
        weight: the learnable weights of the module of shape
            :math:`(\text{out\_features}, \text{in1\_features}, \text{in2\_features})`.
            The values are initialized from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, where
            :math:`k = \frac{1}{\text{in1\_features}}`
        bias:   the learnable bias of the module of shape :math:`(\text{out\_features})`.
                If :attr:`bias` is ``True``, the values are initialized from
                :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, where
                :math:`k = \frac{1}{\text{in1\_features}}`

    Examples::

        >>> m = nn.Bilinear(20, 30, 40)
        >>> input1 = torch.randn(128, 20)
        >>> input2 = torch.randn(128, 30)
        >>> output = m(input1, input2)
        >>> print(output.size())
        torch.Size([128, 40])
    )in1_featuresin2_featuresr+   rU   rV   r+   r,   Nr-   r   c                 6   ||d}t         |           || _        || _        || _        t        t        j                  |||ffi |      | _        |r%t        t        j                  |fi |      | _	        n| j                  dd        | j                          y r/   )r   r   rU   rV   r+   r   r3   r4   r,   r-   r5   r6   )	r   rU   rV   r+   r-   r1   r2   r7   r   s	           r   r   zBilinear.__init__   s    $*U;(((\<,V iZh ij!%++l"Mn"MNDI##FD1r   c                    dt        j                  | j                  j                  d            z  }t	        j
                  | j                  | |       | j                  #t	        j
                  | j                  | |       y y )Nr
   )r<   r=   r,   sizer	   r?   r-   )r   rB   s     r   r6   zBilinear.reset_parameters   s_    DIIdkk..q122dkkE65199 MM$))eVU3 !r   input1input2c                 Z    t        j                  ||| j                  | j                        S r   )rD   bilinearr,   r-   )r   rZ   r[   s      r   r"   zBilinear.forward   s    zz&&$++tyyAAr   c                 ~    dj                  | j                  | j                  | j                  | j                  d u      S )Nz:in1_features={}, in2_features={}, out_features={}, bias={})formatrU   rV   r+   r-   rG   s    r   rH   zBilinear.extra_repr   s:    KRRt00$2C2CTYYVZEZ
 	
r   rI   rJ   rK   r(   s   @r   r   r      s    #J EMN]a$( S    3  VZ  -1 4Bf Bf B B
C 
r   r   c                   d     e Zd ZU dZeZeed<   eed<   	 	 d
dede	ddf fdZ
d fdZdd	Z xZS )r   a  A :class:`torch.nn.Linear` module where `in_features` is inferred.

    In this module, the `weight` and `bias` are of :class:`torch.nn.UninitializedParameter`
    class. They will be initialized after the first call to ``forward`` is done and the
    module will become a regular :class:`torch.nn.Linear` module. The ``in_features`` argument
    of the :class:`Linear` is inferred from the ``input.shape[-1]``.

    Check the :class:`torch.nn.modules.lazy.LazyModuleMixin` for further documentation
    on lazy modules and their limitations.

    Args:
        out_features: size of each output sample
        bias: If set to ``False``, the layer will not learn an additive bias.
            Default: ``True``

    Attributes:
        weight: the learnable weights of the module of shape
            :math:`(\text{out\_features}, \text{in\_features})`. The values are
            initialized from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, where
            :math:`k = \frac{1}{\text{in\_features}}`
        bias:   the learnable bias of the module of shape :math:`(\text{out\_features})`.
                If :attr:`bias` is ``True``, the values are initialized from
                :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where
                :math:`k = \frac{1}{\text{in\_features}}`


    r,   r-   Nr+   r   c                     ||d}t         |   ddd       t        di || _        || _        |rt        di || _        y y )Nr0   r   Fr    )r   r   r   r,   r+   r-   )r   r+   r-   r1   r2   r7   r   s         r   r   zLazyLinear.__init__   sN    $*U; 	Au%,>~>(.@@DI r   c                 d    | j                         s| j                  dk7  rt        |           y y y )Nr   )has_uninitialized_paramsr*   r   r6   )r   r   s    r   r6   zLazyLinear.reset_parameters   s0    ,,.43C3Cq3HG$& 4I.r   c                    | j                         rt        j                         5  |j                  d   | _        | j
                  j                  | j                  | j                  f       | j                  &| j                  j                  | j                  f       | j                          d d d        y y # 1 sw Y   y xY w)N)
rc   r3   no_gradshaper*   r,   materializer+   r-   r6   r!   s     r   initialize_parametersz LazyLinear.initialize_parameters   s    ((* (#(;;r? ''):):D<L<L(MN99(II))4+<+<*>?%%'( ( +( (s   BB77C rI   rJ   )r#   r$   r%   r&   r   cls_to_becomer   rN   rM   rO   r   r6   ri   r'   r(   s   @r   r   r      sJ    8 M""
  7;$(	AS 	A 	A-1	A'(r   r   )r<   typingr   r3   r   torch.nn.parameterr   r    r   rD   r	   moduler   lazyr   __all__r   r   rR   r   r   r    r   r   <module>rq      sm        @    !v 8FqV Fq\5f 5G
v G
T7(& 7(r   