U
    3dq                  
   @   s"  d Z ddlmZmZ ddlZddlmZmZm	Z	 ddl
mZmZ ddlmZ ddlmZmZmZmZ dd	lmZm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" ddl#m$Z$ d%ddZ%d&ddZ&d'ddZ'dddddddddd 	d!d"Z(G d#d$ d$eeeeZ)dS )(zLocally Linear Embedding    )IntegralRealN)svdqrsolve)eye
csr_matrix)eigsh   )BaseEstimatorTransformerMixin_UnstableArchMixinClassNamePrefixFeaturesOutMixin)check_random_statecheck_array)_init_arpack_v0)Interval
StrOptions)_eigh)stable_cumsum)check_is_fitted)FLOAT_DTYPES)NearestNeighborsMbP?c                 C   s   t | td} t |td}t |td}|j\}}| jd |ks@ttj||f| jd}tj|| jd}t	|D ]\}}	||	 }
|
| |  }t
||j}t|}|dkr|| }n|}|jdd|d   |7  < t||dd}|t| ||ddf< ql|S )a  Compute barycenter weights of X from Y along the first axis

    We estimate the weights to assign to each point in Y[indices] to recover
    the point X[i]. The barycenter weights sum to 1.

    Parameters
    ----------
    X : array-like, shape (n_samples, n_dim)

    Y : array-like, shape (n_samples, n_dim)

    indices : array-like, shape (n_samples, n_dim)
            Indices of the points in Y used to compute the barycenter

    reg : float, default=1e-3
        Amount of regularization to add for the problem to be
        well-posed in the case of n_neighbors > n_dim

    Returns
    -------
    B : array-like, shape (n_samples, n_neighbors)

    Notes
    -----
    See developers note for more information.
    dtyper   N   pos)Zassume_a)r   r   intshapeAssertionErrornpemptyr   ones	enumeratedotTtraceflatr   sum)XYindicesreg	n_samplesn_neighborsBviindACGr'   Rw r9   D/tmp/pip-unpacked-wheel-zrfo1fqw/sklearn/manifold/_locally_linear.pybarycenter_weights   s&    


r;   c           	      C   s   t |d |d| }|j} |j}|j| ddddddf }t| | ||d}td|| d |}t|	 |	 |f||fdS )	a-  Computes the barycenter weighted graph of k-Neighbors for points in X

    Parameters
    ----------
    X : {array-like, NearestNeighbors}
        Sample data, shape = (n_samples, n_features), in the form of a
        numpy array or a NearestNeighbors object.

    n_neighbors : int
        Number of neighbors for each sample.

    reg : float, default=1e-3
        Amount of regularization when solving the least-squares
        problem. Only relevant if mode='barycenter'. If None, use the
        default.

    n_jobs : int or None, default=None
        The number of parallel jobs to run for neighbors search.
        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
        for more details.

    Returns
    -------
    A : sparse matrix in CSR format, shape = [n_samples, n_samples]
        A[i, j] is assigned the weight of edge that connects i to j.

    See Also
    --------
    sklearn.neighbors.kneighbors_graph
    sklearn.neighbors.radius_neighbors_graph
    r   r/   n_jobsF)return_distanceNr-   r   )r   )
r   fit_fit_XZn_samples_fit_
kneighborsr;   r!   Zaranger   Zravel)	r*   r/   r-   r=   Zknnr.   r3   dataZindptrr9   r9   r:   barycenter_kneighbors_graphT   s    !rD   r   arpackư>d   c              
   C   s0  |dkr,| j d dkr(|| dk r(d}nd}|dkrt| j d |}z t| || d|||d\}}	W n0 tk
r }
 ztd	|
 |
W 5 d
}
~
X Y nX |	d
d
|d
f t||d
 fS |dkr t| dr|  } t	| ||| d fdd\}}	t
t|}|	d
d
|f t|fS td| d
S )a0  
    Find the null space of a matrix M.

    Parameters
    ----------
    M : {array, matrix, sparse matrix, LinearOperator}
        Input covariance matrix: should be symmetric positive semi-definite

    k : int
        Number of eigenvalues/vectors to return

    k_skip : int, default=1
        Number of low eigenvalues to skip.

    eigen_solver : {'auto', 'arpack', 'dense'}, default='arpack'
        auto : algorithm will attempt to choose the best method for input data
        arpack : use arnoldi iteration in shift-invert mode.
                    For this method, M may be a dense matrix, sparse matrix,
                    or general linear operator.
                    Warning: ARPACK can be unstable for some problems.  It is
                    best to try several random seeds in order to check results.
        dense  : use standard dense matrix operations for the eigenvalue
                    decomposition.  For this method, M must be an array
                    or matrix type.  This method should be avoided for
                    large problems.

    tol : float, default=1e-6
        Tolerance for 'arpack' method.
        Not used if eigen_solver=='dense'.

    max_iter : int, default=100
        Maximum number of iterations for 'arpack' method.
        Not used if eigen_solver=='dense'

    random_state : int, RandomState instance, default=None
        Determines the random number generator when ``solver`` == 'arpack'.
        Pass an int for reproducible results across multiple function calls.
        See :term:`Glossary <random_state>`.
    autor      
   rE   denseg        )sigmatolmaxiterv0a	  Error in determining null-space with ARPACK. Error message: '%s'. Note that eigen_solver='arpack' can fail when the weight matrix is singular or otherwise ill-behaved. In that case, eigen_solver='dense' is recommended. See online documentation for more information.Ntoarrayr   T)Zsubset_by_indexZoverwrite_azUnrecognized eigen_solver '%s')r   r   r	   RuntimeError
ValueErrorr!   r)   hasattrrP   r   Zargsortabs)Mkk_skipeigen_solverrM   max_iterrandom_staterO   Zeigen_valuesZeigen_vectorseindexr9   r9   r:   
null_space~   sF    *     &

  
r]   rH   standard-C6?-q=)	r-   rX   rM   rY   methodhessian_tolmodified_tolrZ   r=   c          ;   	   C   s  |dkrt d| |dkr(t d| t|d |d}||  |j} | j\}}||krbt d||krzt d||f |d	krt d
|dk}|dkrt||||d}|rt|jd|ji| }|j| 	 }n:|j| |j | 
 }|jdd|jd	 d   d7  < n|dkrH||d  d }||| krDt d|j| |d dd}|ddddf }tj|d| | ftjd}d|ddd	f< tj||ftjd}||k}t|D ]v}| ||  }||d	8 }|rt|d	dd	 }n,t||j}t|d dddddf }|ddd|f |dddd| f< d| }t|D ]V}|dd||d f |dd||f  |dd||| | f< ||| 7 }qXt|\}}|dd|d df }|d	}d|tt||k < || }t|| || \} }!|| |!f  t||j7  < q|rt|}n|dkrv||k rdt d|j| |d dd}|ddddf }t|||f}"t||}#t||#g}$||k}|r
t|D ]4}| ||  | |  }%t|%dd\|"|< |$|< }&q|$dC }$njt|D ]`}| ||  | |  }%t|%|%j}'t|'\}(})|(ddd |$|< |)dddddf |"|< qd|$d }t|"d	ddt|}*|*ddd|#f  |$|dddf    < |*dd|#df  |dddf   < t||f}+t|D ]}t|"| |*| |+|< q|+|+ddddf  }+|$dd|df d|$ddd|f d },t|,}-tj|t d}.t!|$d}/|/ddddf |/ddddf  d }0t|D ]$}t"|0|dddf |-|.|< q|.||# 7 }.tj||ftjd}t|D ]F}|.| }1|"|dd||1 df }2tj#$|2d	t%|1 }3t&|1|3t|2jt| }4tj#$|4}5|5|	k r|4d	9 }4n|4|5 }4|2dt't|2|4|4  d|3 |+|dddf   }6t|| || \} }!|| |!f  t|6|6j7  < |6d}7|||| f  |78  < ||| |f  |78  < |||f  |17  < q|rt|}n^|dkr|j| |d dd}|ddddf }t||f}||k}t|D ]
}| ||  }8|8|8d	8 }8|rt|8ddd	 }9n,t|8|8j}t|d dddddf }9t||d f}|9ddd|f |ddddf< dt%| |ddd	f< t||j}:t|| || \} }!|| |!f  |:8  < ||| || f  d7  < qt(||d||||
dS )ac  Perform a Locally Linear Embedding analysis on the data.

    Read more in the :ref:`User Guide <locally_linear_embedding>`.

    Parameters
    ----------
    X : {array-like, NearestNeighbors}
        Sample data, shape = (n_samples, n_features), in the form of a
        numpy array or a NearestNeighbors object.

    n_neighbors : int
        Number of neighbors to consider for each point.

    n_components : int
        Number of coordinates for the manifold.

    reg : float, default=1e-3
        Regularization constant, multiplies the trace of the local covariance
        matrix of the distances.

    eigen_solver : {'auto', 'arpack', 'dense'}, default='auto'
        auto : algorithm will attempt to choose the best method for input data

        arpack : use arnoldi iteration in shift-invert mode.
                    For this method, M may be a dense matrix, sparse matrix,
                    or general linear operator.
                    Warning: ARPACK can be unstable for some problems.  It is
                    best to try several random seeds in order to check results.

        dense  : use standard dense matrix operations for the eigenvalue
                    decomposition.  For this method, M must be an array
                    or matrix type.  This method should be avoided for
                    large problems.

    tol : float, default=1e-6
        Tolerance for 'arpack' method
        Not used if eigen_solver=='dense'.

    max_iter : int, default=100
        Maximum number of iterations for the arpack solver.

    method : {'standard', 'hessian', 'modified', 'ltsa'}, default='standard'
        standard : use the standard locally linear embedding algorithm.
                   see reference [1]_
        hessian  : use the Hessian eigenmap method.  This method requires
                   n_neighbors > n_components * (1 + (n_components + 1) / 2.
                   see reference [2]_
        modified : use the modified locally linear embedding algorithm.
                   see reference [3]_
        ltsa     : use local tangent space alignment algorithm
                   see reference [4]_

    hessian_tol : float, default=1e-4
        Tolerance for Hessian eigenmapping method.
        Only used if method == 'hessian'.

    modified_tol : float, default=1e-12
        Tolerance for modified LLE method.
        Only used if method == 'modified'.

    random_state : int, RandomState instance, default=None
        Determines the random number generator when ``solver`` == 'arpack'.
        Pass an int for reproducible results across multiple function calls.
        See :term:`Glossary <random_state>`.

    n_jobs : int or None, default=None
        The number of parallel jobs to run for neighbors search.
        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
        for more details.

    Returns
    -------
    Y : array-like, shape [n_samples, n_components]
        Embedding vectors.

    squared_error : float
        Reconstruction error for the embedding vectors. Equivalent to
        ``norm(Y - W Y, 'fro')**2``, where W are the reconstruction weights.

    References
    ----------

    .. [1] Roweis, S. & Saul, L. Nonlinear dimensionality reduction
        by locally linear embedding.  Science 290:2323 (2000).
    .. [2] Donoho, D. & Grimes, C. Hessian eigenmaps: Locally
        linear embedding techniques for high-dimensional data.
        Proc Natl Acad Sci U S A.  100:5591 (2003).
    .. [3] `Zhang, Z. & Wang, J. MLLE: Modified Locally Linear
        Embedding Using Multiple Weights.
        <https://citeseerx.ist.psu.edu/doc_view/pid/0b060fdbd92cbcc66b383bcaa9ba5e5e624d7ee3>`_
    .. [4] Zhang, Z. & Zha, H. Principal manifolds and nonlinear
        dimensionality reduction via tangent space alignment.
        Journal of Shanghai Univ.  8:406 (2004)
    )rH   rE   rK   zunrecognized eigen_solver '%s')r^   hessianmodifiedltsazunrecognized method '%s'r   r<   z>output dimension must be less than or equal to input dimensionzHExpected n_neighbors <= n_samples,  but n_samples = %d, n_neighbors = %dr   zn_neighbors must be positiverK   r^   )r/   r-   r=   formatNrd   r
   z^for method='hessian', n_neighbors must be greater than [n_components * (n_components + 3) / 2]Fr/   r>   r   )Zfull_matricesre   z1modified LLE requires n_neighbors >= n_componentsTr   rf   g      ?)rW   rX   rM   rY   rZ   ))rR   r   r@   rA   r   rD   r   rg   r&   ZtocsrrP   r(   rB   r!   r"   Zfloat64zerosrangeZmeanr   r%   r   r   r)   whererT   Zmeshgridr   minZ	transposer#   Zmedianr   r   ZsearchsortedZlinalgZnormsqrtfullouterr]   );r*   r/   n_componentsr-   rX   rM   rY   ra   rb   rc   rZ   r=   ZnbrsNZd_inZM_sparseWrU   Zdp	neighborsZYiZuse_svdr2   ZGiUZCijrV   Qr7   r8   SZnbrs_xZnbrs_yVZnevZevalsZX_nbrs_ZC_nbrsZevivitmpZw_regrhoetaZs_rangeZevals_cumsumZ	eta_rangeZs_iZViZalpha_ihZnorm_hZWiZWi_sum1Xir1   ZGiGiTr9   r9   r:   locally_linear_embedding   sB   n


   &
  (D
"

  

,(4

," 

6

  $ r   c                   @   s  e Zd ZU dZeeddddgeeddddgeeddddgeddd	hgeeddddgeeddddged
dddhgeeddddgeeddddgeddddhgdgdegdZe	e
d< ddddddd
ddddddddZdd Zd%dd Zd&d!d"Zd#d$ ZdS )'LocallyLinearEmbeddinga  Locally Linear Embedding.

    Read more in the :ref:`User Guide <locally_linear_embedding>`.

    Parameters
    ----------
    n_neighbors : int, default=5
        Number of neighbors to consider for each point.

    n_components : int, default=2
        Number of coordinates for the manifold.

    reg : float, default=1e-3
        Regularization constant, multiplies the trace of the local covariance
        matrix of the distances.

    eigen_solver : {'auto', 'arpack', 'dense'}, default='auto'
        The solver used to compute the eigenvectors. The available options are:

        - `'auto'` : algorithm will attempt to choose the best method for input
          data.
        - `'arpack'` : use arnoldi iteration in shift-invert mode. For this
          method, M may be a dense matrix, sparse matrix, or general linear
          operator.
        - `'dense'`  : use standard dense matrix operations for the eigenvalue
          decomposition. For this method, M must be an array or matrix type.
          This method should be avoided for large problems.

        .. warning::
           ARPACK can be unstable for some problems.  It is best to try several
           random seeds in order to check results.

    tol : float, default=1e-6
        Tolerance for 'arpack' method
        Not used if eigen_solver=='dense'.

    max_iter : int, default=100
        Maximum number of iterations for the arpack solver.
        Not used if eigen_solver=='dense'.

    method : {'standard', 'hessian', 'modified', 'ltsa'}, default='standard'
        - `standard`: use the standard locally linear embedding algorithm. see
          reference [1]_
        - `hessian`: use the Hessian eigenmap method. This method requires
          ``n_neighbors > n_components * (1 + (n_components + 1) / 2``. see
          reference [2]_
        - `modified`: use the modified locally linear embedding algorithm.
          see reference [3]_
        - `ltsa`: use local tangent space alignment algorithm. see
          reference [4]_

    hessian_tol : float, default=1e-4
        Tolerance for Hessian eigenmapping method.
        Only used if ``method == 'hessian'``.

    modified_tol : float, default=1e-12
        Tolerance for modified LLE method.
        Only used if ``method == 'modified'``.

    neighbors_algorithm : {'auto', 'brute', 'kd_tree', 'ball_tree'},                           default='auto'
        Algorithm to use for nearest neighbors search, passed to
        :class:`~sklearn.neighbors.NearestNeighbors` instance.

    random_state : int, RandomState instance, default=None
        Determines the random number generator when
        ``eigen_solver`` == 'arpack'. Pass an int for reproducible results
        across multiple function calls. See :term:`Glossary <random_state>`.

    n_jobs : int or None, default=None
        The number of parallel jobs to run.
        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
        for more details.

    Attributes
    ----------
    embedding_ : array-like, shape [n_samples, n_components]
        Stores the embedding vectors

    reconstruction_error_ : float
        Reconstruction error associated with `embedding_`

    n_features_in_ : int
        Number of features seen during :term:`fit`.

        .. versionadded:: 0.24

    feature_names_in_ : ndarray of shape (`n_features_in_`,)
        Names of features seen during :term:`fit`. Defined only when `X`
        has feature names that are all strings.

        .. versionadded:: 1.0

    nbrs_ : NearestNeighbors object
        Stores nearest neighbors instance, including BallTree or KDtree
        if applicable.

    See Also
    --------
    SpectralEmbedding : Spectral embedding for non-linear dimensionality
        reduction.
    TSNE : Distributed Stochastic Neighbor Embedding.

    References
    ----------

    .. [1] Roweis, S. & Saul, L. Nonlinear dimensionality reduction
        by locally linear embedding.  Science 290:2323 (2000).
    .. [2] Donoho, D. & Grimes, C. Hessian eigenmaps: Locally
        linear embedding techniques for high-dimensional data.
        Proc Natl Acad Sci U S A.  100:5591 (2003).
    .. [3] `Zhang, Z. & Wang, J. MLLE: Modified Locally Linear
        Embedding Using Multiple Weights.
        <https://citeseerx.ist.psu.edu/doc_view/pid/0b060fdbd92cbcc66b383bcaa9ba5e5e624d7ee3>`_
    .. [4] Zhang, Z. & Zha, H. Principal manifolds and nonlinear
        dimensionality reduction via tangent space alignment.
        Journal of Shanghai Univ.  8:406 (2004)

    Examples
    --------
    >>> from sklearn.datasets import load_digits
    >>> from sklearn.manifold import LocallyLinearEmbedding
    >>> X, _ = load_digits(return_X_y=True)
    >>> X.shape
    (1797, 64)
    >>> embedding = LocallyLinearEmbedding(n_components=2)
    >>> X_transformed = embedding.fit_transform(X[:100])
    >>> X_transformed.shape
    (100, 2)
    r   Nleft)closedr   rH   rE   rK   r^   rd   re   rf   ZbruteZkd_treeZ	ball_treerZ   )r/   rq   r-   rX   rM   rY   ra   rb   rc   neighbors_algorithmrZ   r=   _parameter_constraints   r
   r   rF   rG   r_   r`   c                C   sL   || _ || _|| _|| _|| _|| _|| _|| _|	| _|| _	|
| _
|| _d S )N)r/   rq   r-   rX   rM   rY   ra   rb   rc   rZ   r   r=   )selfr/   rq   r-   rX   rM   rY   ra   rb   rc   r   rZ   r=   r9   r9   r:   __init__  s    zLocallyLinearEmbedding.__init__c                 C   s   t | j| j| jd| _t| j}| j|td}| j	| t
| j| j| j| j| j| j| j| j| j|| j| jd\| _| _| jjd | _d S )N)r/   	algorithmr=   r   )r*   r/   rq   rX   rM   rY   ra   rb   rc   rZ   r-   r=   r   )r   r/   r   r=   nbrs_r   rZ   _validate_datafloatr@   r   rq   rX   rM   rY   ra   rb   rc   r-   
embedding_Zreconstruction_error_r   Z_n_features_out)r   r*   rZ   r9   r9   r:   _fit_transform  s.    
z%LocallyLinearEmbedding._fit_transformc                 C   s   |    | | | S )ay  Compute the embedding vectors for data X.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            Training set.

        y : Ignored
            Not used, present here for API consistency by convention.

        Returns
        -------
        self : object
            Fitted `LocallyLinearEmbedding` class instance.
        )_validate_paramsr   r   r*   yr9   r9   r:   r@     s    
zLocallyLinearEmbedding.fitc                 C   s   |    | | | jS )a  Compute the embedding vectors for data X and transform X.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            Training set.

        y : Ignored
            Not used, present here for API consistency by convention.

        Returns
        -------
        X_new : array-like, shape (n_samples, n_components)
            Returns the instance itself.
        )r   r   r   r   r9   r9   r:   fit_transform  s    
z$LocallyLinearEmbedding.fit_transformc                 C   s   t |  | j|dd}| jj|| jdd}t|| jj|| jd}t	|j
d | jf}t|j
d D ]$}t| j||  j|| ||< qd|S )a  
        Transform new points into embedding space.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            Training set.

        Returns
        -------
        X_new : ndarray of shape (n_samples, n_components)
            Returns the instance itself.

        Notes
        -----
        Because of scaling performed by this method, it is discouraged to use
        it together with methods that are not scale-invariant (like SVMs).
        F)resetrh   r?   r   )r   r   r   rB   r/   r;   rA   r-   r!   r"   r   rq   rk   r%   r   r&   )r   r*   r3   weightsZX_newr2   r9   r9   r:   	transform"  s      "z LocallyLinearEmbedding.transform)N)N)__name__
__module____qualname____doc__r   r   r   r   r   dict__annotations__r   r   r@   r   r   r9   r9   r9   r:   r   *  s@   
 

r   )r   )r   N)r   rE   rF   rG   N)*r   Znumbersr   r   Znumpyr!   Zscipy.linalgr   r   r   Zscipy.sparser   r   Zscipy.sparse.linalgr	   baser   r   r   r   utilsr   r   Zutils._arpackr   Zutils._param_validationr   r   Zutils.fixesr   Zutils.extmathr   Zutils.validationr   r   rt   r   r;   rD   r]   r   r   r9   r9   r9   r:   <module>   sP   
6
+         
Q  b
