Ë
    øÿæi)  ã                   ó   — d Z ddgZddlZddlmZmZ ddlmZmZ 	 	 ddede	d	e	dz  d
edz  def
d„Z
	 	 	 ddede	dz  d	e	dz  d
edz  deeeef   f
d„Z	 	 	 ddede	dz  d	e	dz  d
edz  deeeef   f
d„Z	 	 	 ddede	dz  ded	e	deeeef   f
d„Zy)zBImplement various linear algebra algorithms for low rank matrices.Úsvd_lowrankÚpca_lowranké    N)Ú_linalg_utilsÚTensor)Úhandle_torch_functionÚhas_torch_functionÚAÚqÚniterÚMÚreturnc                 ó¼  — |€dn|}| j                  «       st        j                  | «      n| j                  }t        j                  }t        j                  | j                  d   ||| j                  ¬«      } || |«      }|�| |||«      z
  }t
        j                  j                  |«      j                  }t        |«      D ]–  }	 || j                  |«      }|�| ||j                  |«      z
  }t
        j                  j                  |«      j                  } || |«      }|�| |||«      z
  }t
        j                  j                  |«      j                  }Œ˜ |S )a…  Return tensor :math:`Q` with :math:`q` orthonormal columns such
    that :math:`Q Q^H A` approximates :math:`A`. If :math:`M` is
    specified, then :math:`Q` is such that :math:`Q Q^H (A - M)`
    approximates :math:`A - M`. without instantiating any tensors
    of the size of :math:`A` or :math:`M`.

    .. note:: The implementation is based on the Algorithm 4.4 from
              Halko et al., 2009.

    .. note:: For an adequate approximation of a k-rank matrix
              :math:`A`, where k is not known in advance but could be
              estimated, the number of :math:`Q` columns, q, can be
              chosen according to the following criteria: in general,
              :math:`k <= q <= min(2*k, m, n)`. For large low-rank
              matrices, take :math:`q = k + 5..10`.  If k is
              relatively small compared to :math:`min(m, n)`, choosing
              :math:`q = k + 0..2` may be sufficient.

    .. note:: To obtain repeatable results, reset the seed for the
              pseudorandom number generator

    Args::
        A (Tensor): the input tensor of size :math:`(*, m, n)`

        q (int): the dimension of subspace spanned by :math:`Q`
                 columns.

        niter (int, optional): the number of subspace iterations to
                               conduct; ``niter`` must be a
                               nonnegative integer. In most cases, the
                               default value 2 is more than enough.

        M (Tensor, optional): the input tensor's mean of size
                              :math:`(*, m, n)`.

    References::
        - Nathan Halko, Per-Gunnar Martinsson, and Joel Tropp, Finding
          structure with randomness: probabilistic algorithms for
          constructing approximate matrix decompositions,
          arXiv:0909.4061 [math.NA; math.PR], 2009 (available at
          `arXiv <http://arxiv.org/abs/0909.4061>`_).
    é   éÿÿÿÿ©ÚdtypeÚdevice)Ú
is_complexÚ_utilsÚget_floating_dtyper   ÚmatmulÚtorchÚrandnÚshaper   ÚlinalgÚqrÚQÚrangeÚmH)
r	   r
   r   r   r   r   ÚRÚXr   Ú_s
             úc/Volumes/fast/ai/experiments/voice-extract-mac/.venv/lib/python3.12/site-packages/torch/_lowrank.pyÚget_approximate_basisr$      s  € ðb �‰A E€EØ01·±´ŒF×%Ñ% aÔ(ÀAÇGÁG€EÜ�]‰]€Fä�‰�A—G‘G˜B‘K ¨%¸¿¹ÔA€Añ
 	ˆq�!‹€AØ€}Ø‘�q˜!“ÑˆÜ�‰�‰˜Ó×Ñ€AÜ�5Ž\ˆÙ�1—4‘4˜‹OˆØˆ=Ø‘F˜1Ÿ4™4 “OÑ#ˆAÜ�L‰L�O‰O˜AÓ× Ñ ˆÙ�1�a‹LˆØˆ=Ø‘F˜1˜a“LÑ ˆAÜ�L‰L�O‰O˜AÓ× Ñ ‰ð ð €Hó    c                 ó&  — t         j                  j                  «       se| |f}t        t	        t
        |«      «      j                  t         j                  t        d«      f«      s t        |«      rt        t        || |||¬«      S t        | |||¬«      S )aº  Return the singular value decomposition ``(U, S, V)`` of a matrix,
    batches of matrices, or a sparse matrix :math:`A` such that
    :math:`A \approx U \operatorname{diag}(S) V^{\text{H}}`. In case :math:`M` is given, then
    SVD is computed for the matrix :math:`A - M`.

    .. note:: The implementation is based on the Algorithm 5.1 from
              Halko et al., 2009.

    .. note:: For an adequate approximation of a k-rank matrix
              :math:`A`, where k is not known in advance but could be
              estimated, the number of :math:`Q` columns, q, can be
              chosen according to the following criteria: in general,
              :math:`k <= q <= min(2*k, m, n)`. For large low-rank
              matrices, take :math:`q = k + 5..10`.  If k is
              relatively small compared to :math:`min(m, n)`, choosing
              :math:`q = k + 0..2` may be sufficient.

    .. note:: This is a randomized method. To obtain repeatable results,
              set the seed for the pseudorandom number generator

    .. note:: In general, use the full-rank SVD implementation
              :func:`torch.linalg.svd` for dense matrices due to its 10x
              higher performance characteristics. The low-rank SVD
              will be useful for huge sparse matrices that
              :func:`torch.linalg.svd` cannot handle.

    Args::
        A (Tensor): the input tensor of size :math:`(*, m, n)`

        q (int, optional): a slightly overestimated rank of A.

        niter (int, optional): the number of subspace iterations to
                               conduct; niter must be a nonnegative
                               integer, and defaults to 2

        M (Tensor, optional): the input tensor's mean of size
                              :math:`(*, m, n)`, which will be broadcasted
                              to the size of A in this function.

    References::
        - Nathan Halko, Per-Gunnar Martinsson, and Joel Tropp, Finding
          structure with randomness: probabilistic algorithms for
          constructing approximate matrix decompositions,
          arXiv:0909.4061 [math.NA; math.PR], 2009 (available at
          `arXiv <https://arxiv.org/abs/0909.4061>`_).

    N)r
   r   r   )r   ÚjitÚis_scriptingÚsetÚmapÚtypeÚissubsetr   r   r   r   Ú_svd_lowrank)r	   r
   r   r   Ú
tensor_opss        r#   r   r   U   s}   € ôj �9‰9×!Ñ!Ô#Ø˜�Vˆ
Ü”3”t˜ZÓ(Ó)×2Ñ2Ü�\‰\œ4 ›:Ð&ô
ä  Ô,Ü(Ü˜Z¨¨a°uÀôð ô ˜˜Q e¨qÔ1Ð1r%   c                 óæ  — |€dn|}| j                   dd  \  }}t        j                  }|�|j                  | j	                  «       «      }||k  r| j
                  } |�|j
                  }t        | |||¬«      } ||j
                  | «      }|�| ||j
                  |«      z
  }t        j                  j                  |d¬«      \  }	}
}|j
                  }|j                  |	«      }	||k  r||	}}	|	|
|fS )Né   éþÿÿÿ©r   r   F)Úfull_matrices)
r   r   r   Úbroadcast_toÚsizer   r$   r   r   Úsvd)r	   r
   r   r   ÚmÚnr   r   ÚBÚUÚSÚVhÚVs                r#   r-   r-   •   sì   € ð ˆY‰˜A€AØ�7‰7�2�3ˆ<�D€A€qÜ�]‰]€FØ€}Ø�N‰N˜1Ÿ6™6›8Ó$ˆð 	ˆ1‚uØ�D‰DˆØˆ=Ø—‘ˆAä˜a ¨%°1Ô5€AÙˆq�t‰t�Q‹€AØ€}Ø‘�q—t‘t˜Q“ÑˆÜ�|‰|×Ñ °ÐÓ7�H€A€qˆ"Ø
�‰€AØ	�‰�‹€Aàˆ1‚uØ�!ˆ1ˆàˆa�ˆ7€Nr%   Úcenterc           	      ó°  — t         j                  j                  «       s=t        | «      t         j                  ur"t        | f«      rt        t        | f| |||¬«      S | j                  dd \  }}|€t        d||«      }n/|dk\  r|t        ||«      k  st        d|› dt        ||«      › �«      ‚|dk\  st        d|› d	�«      ‚t        j                  | «      }|st        | ||d¬
«      S t        j                  | «      �r6t        | j                  «      dk7  rt        d«      ‚t         j                   j#                  | d¬«      |z  }|j%                  «       d   }t        j&                  dt        |«      |j(                  |j*                  ¬«      }	||	d<   t        j,                  |	|j/                  «       |df|| j*                  ¬«      }
t        j0                  | j                  dd d|fz   || j*                  ¬«      }t         j                   j3                  |
|«      j4                  }t        | |||¬
«      S | j7                  dd¬«      }t        | |z
  ||d¬
«      S )a×  Performs linear Principal Component Analysis (PCA) on a low-rank
    matrix, batches of such matrices, or sparse matrix.

    This function returns a namedtuple ``(U, S, V)`` which is the
    nearly optimal approximation of a singular value decomposition of
    a centered matrix :math:`A` such that :math:`A \approx U \operatorname{diag}(S) V^{\text{H}}`

    .. note:: The relation of ``(U, S, V)`` to PCA is as follows:

                - :math:`A` is a data matrix with ``m`` samples and
                  ``n`` features

                - the :math:`V` columns represent the principal directions

                - :math:`S ** 2 / (m - 1)` contains the eigenvalues of
                  :math:`A^T A / (m - 1)` which is the covariance of
                  ``A`` when ``center=True`` is provided.

                - ``matmul(A, V[:, :k])`` projects data to the first k
                  principal components

    .. note:: Different from the standard SVD, the size of returned
              matrices depend on the specified rank and q
              values as follows:

                - :math:`U` is m x q matrix

                - :math:`S` is q-vector

                - :math:`V` is n x q matrix

    .. note:: To obtain repeatable results, reset the seed for the
              pseudorandom number generator

    Args:

        A (Tensor): the input tensor of size :math:`(*, m, n)`

        q (int, optional): a slightly overestimated rank of
                           :math:`A`. By default, ``q = min(6, m,
                           n)``.

        center (bool, optional): if True, center the input tensor,
                                 otherwise, assume that the input is
                                 centered.

        niter (int, optional): the number of subspace iterations to
                               conduct; niter must be a nonnegative
                               integer, and defaults to 2.

    References::

        - Nathan Halko, Per-Gunnar Martinsson, and Joel Tropp, Finding
          structure with randomness: probabilistic algorithms for
          constructing approximate matrix decompositions,
          arXiv:0909.4061 [math.NA; math.PR], 2009 (available at
          `arXiv <http://arxiv.org/abs/0909.4061>`_).

    )r
   r>   r   r1   Nr0   r   zq(=z>) must be non-negative integer and not greater than min(m, n)=zniter(=z) must be non-negative integerr2   r   z8pca_lowrank input is expected to be 2-dimensional tensor)r1   )Údimr   é   T)r@   Úkeepdim)r   r'   r(   r+   r   r   r   r   r   ÚminÚ
ValueErrorr   r   r-   Ú	is_sparseÚlenÚsparseÚsumÚindicesÚzerosr   r   Úsparse_coo_tensorÚvaluesÚonesÚmmÚmTÚmean)r	   r
   r>   r   r7   r8   r   ÚcÚcolumn_indicesrI   ÚC_tÚ	ones_m1_tr   ÚCs                 r#   r   r   ·   s#  € ôD �9‰9×!Ñ!Ô#Ü�‹7œ%Ÿ,™,Ñ&Ô+=¸q¸dÔ+CÜ(Ü˜a˜T 1¨°&Àôð ð �W‰W�R�Sˆ\�F€Qˆà€yÜ��1�a‹L‰Ø�1Šf˜œc ! Q›išÜØ�!�ÐRÔSVÐWXÐZ[ÓS\ÐR]Ð^ó
ð 	
ð �QŠJÜ˜7 5 'Ð)GÐHÓIÐIä×%Ñ% aÓ(€EáÜ˜A˜q¨°Ô6Ð6ä×Ñ˜ÕÜˆq�w‰w‹<˜1ÒÜÐWÓXÐXÜ�L‰L×Ñ˜Q EÐÓ*¨QÑ.ˆàŸ™› Q™ˆÜ—+‘+ØÜ�ÓØ ×&Ñ&Ø!×(Ñ(ô	
ˆð $ˆ�‰
Ü×%Ñ%Ø�Q—X‘X“Z ! Q ¨u¸Q¿X¹Xô
ˆô —J‘J˜qŸw™w s¨˜|¨q°!¨fÑ4¸EÈ!Ï(É(ÔSˆ	Ü�L‰L�O‰O˜C Ó+×.Ñ.ˆÜ˜A˜q¨°Ô3Ð3à�F‰F�u dˆFÓ+ˆÜ˜A ™E 1¨E°TÔ:Ð:r%   )r   N)r0   r   N)NTr   )Ú__doc__Ú__all__r   r   r   r   Útorch.overridesr   r   Úintr$   Útupler   r-   Úboolr   © r%   r#   Ú<module>r]      si  ðÙ Hà˜-Ð
(€ó ß 1ß Eð Øñ	GØðGà
ðGð �‰:ðGð ��}ð	Gð
 óGðX ØØñ	=2Øð=2à
ˆT�zð=2ð �‰:ð=2ð ��}ð	=2ð
 ˆ6�6˜6Ð!Ñ"ó=2ðD ØØñ	Øðà
ˆT�zðð �‰:ðð ��}ð	ð
 ˆ6�6˜6Ð!Ñ"óðH ØØñ	n;Øðn;à
ˆT�zðn;ð ðn;ð ð	n;ð
 ˆ6�6˜6Ð!Ñ"ôn;r%   