0Pht dZddlZddlmZmZddlZddlmZddl m Z ddl m Z ddl mZmZdd lmZmZdd lmZdd lmZmZdd lmZmZmZdd lmZddlmZm Z m!Z!ddl"m#Z#ddl$m%Z&ddl$m'Z'm(Z(ddl)m*Z*dZ+dZ,dZ-e!ddgeedddge hddgdgeeddde dhgdgdgdd !d"dddd d d#d$Z.d"dddd d d#d%Z/Gd&d'eZ0dS)(zSpectral Embedding.N)IntegralReal)sparse)eigh)connected_components)eigshlobpcg) BaseEstimator _fit_context) rbf_kernel)NearestNeighborskneighbors_graph) check_arraycheck_random_statecheck_symmetric)_init_arpack_v0)Interval StrOptionsvalidate_params)_deterministic_vector_sign_flip) laplacian) parse_version sp_version) validate_datac|jd}tj|r|}t j|t }t j|t }d||<t|D]}|}t j |||||krnt j |d}| d|D]g}tj|r2||gddf } n||} t j || |h|S)aCFind the largest graph connected components that contains one given node. Parameters ---------- graph : array-like of shape (n_samples, n_samples) Adjacency matrix of the graph, non-zero weight means an edge between the nodes. node_id : int The index of the query node of the graph. Returns ------- connected_components_matrix : array-like of shape (n_samples,) An array of bool value indicating the indexes of the nodes belonging to the largest connected components of the given query node. r)dtypeT)outFN)shaperissparsetocsrnpzerosboolrangesum logical_orwherefilltoarrayravel) graphnode_idn_nodeconnected_nodesnodes_to_explore_last_num_componentindicesi neighborss d/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/manifold/_spectral_embedding.py_graph_connected_componentr7 sm([^F u hvT222Oxd333 $W 6]]MM,0022 o'7_MMMM !4!4!6!6 6 6 E(+,,Q/e$$$ M MAu%% %"1#qqq&M113399;; !!H M*I;K L L L L L M ctj|rBttdk}t |d|}t |\}}|dkSt |d|jdkS)a~Return whether the graph is connected (True) or Not (False). Parameters ---------- graph : {array-like, sparse matrix} of shape (n_samples, n_samples) Adjacency matrix of the graph, non-zero weight means an edge between the nodes. Returns ------- is_connected : bool True means the graph is fully connected and False means not. z1.11.3T accept_sparseaccept_large_sparser) rr rrrrr7r&r)r,r<n_connected_componentsr1s r6_graph_is_connectedr?MsuL )M(,C,CC ;N   %9$?$?!%***%337799U[^KKr8cx|jd}tj|s|r||jdd|dz<n|}|r|j|jk}||j|<tj |j|jz j }|dkr| }n| }|S)aMSet the diagonal of the laplacian matrix and convert it to a sparse format well suited for eigenvalue decomposition. Parameters ---------- laplacian : {ndarray, sparse matrix} The graph laplacian. value : float The value of the diagonal. norm_laplacian : bool Whether the value of the diagonal should be changed or not. Returns ------- laplacian : {array, sparse matrix} An array of matrix in a form that is well suited to fast eigenvalue decomposition, depending on the band width of the matrix. rNr=) rrr flattocoorowcoldatar"uniquesizetodiar!)rvaluenorm_laplaciann_nodesdiag_idxn_diagss r6 _set_diagrOms,oa G ?9 % %*  3-2IN>>gk> *OO%%  - } 5H',IN8 $)IMIM9::? a<<!))II"))I r8z array-likez sparse matrixr=leftclosedamgarpackr random_stateautoboolean adjacency n_components eigen_solverrV eigen_tolrK drop_firstTprefer_skip_nested_validationr[r\rVr]rKr^c Lt|}t|||||||S)aProject the sample on the first eigenvectors of the graph Laplacian. The adjacency matrix is used to compute a normalized graph Laplacian whose spectrum (especially the eigenvectors associated to the smallest eigenvalues) has an interpretation in terms of minimal number of cuts necessary to split the graph into comparably sized components. This embedding can also 'work' even if the ``adjacency`` variable is not strictly the adjacency matrix of a graph but more generally an affinity or similarity matrix between samples (for instance the heat kernel of a euclidean distance matrix or a k-NN matrix). However care must taken to always make the affinity matrix symmetric so that the eigenvector decomposition works as expected. Note : Laplacian Eigenmaps is the actual algorithm implemented here. Read more in the :ref:`User Guide `. Parameters ---------- adjacency : {array-like, sparse graph} of shape (n_samples, n_samples) The adjacency matrix of the graph to embed. n_components : int, default=8 The dimension of the projection subspace. eigen_solver : {'arpack', 'lobpcg', 'amg'}, default=None The eigenvalue decomposition strategy to use. AMG requires pyamg to be installed. It can be faster on very large, sparse problems, but may also lead to instabilities. If None, then ``'arpack'`` is used. random_state : int, RandomState instance or None, default=None A pseudo random number generator used for the initialization of the lobpcg eigen vectors decomposition when `eigen_solver == 'amg'`, and for the K-Means initialization. Use an int to make the results deterministic across calls (See :term:`Glossary `). .. note:: When using `eigen_solver == 'amg'`, it is necessary to also fix the global numpy seed with `np.random.seed(int)` to get deterministic results. See https://github.com/pyamg/pyamg/issues/139 for further information. eigen_tol : float, default="auto" Stopping criterion for eigendecomposition of the Laplacian matrix. If `eigen_tol="auto"` then the passed tolerance will depend on the `eigen_solver`: - If `eigen_solver="arpack"`, then `eigen_tol=0.0`; - If `eigen_solver="lobpcg"` or `eigen_solver="amg"`, then `eigen_tol=None` which configures the underlying `lobpcg` solver to automatically resolve the value according to their heuristics. See, :func:`scipy.sparse.linalg.lobpcg` for details. Note that when using `eigen_solver="amg"` values of `tol<1e-5` may lead to convergence issues and should be avoided. .. versionadded:: 1.2 Added 'auto' option. norm_laplacian : bool, default=True If True, then compute symmetric normalized Laplacian. drop_first : bool, default=True Whether to drop the first eigenvector. For spectral embedding, this should be True as the first eigenvector should be constant vector for connected graph, but for spectral clustering, this should be kept as False to retain the first eigenvector. Returns ------- embedding : ndarray of shape (n_samples, n_components) The reduced samples. Notes ----- Spectral Embedding (Laplacian Eigenmaps) is most useful when the graph has one connected component. If there graph has many components, the first few eigenvectors will simply uncover the connected components of the graph. References ---------- * https://en.wikipedia.org/wiki/LOBPCG * :doi:`"Toward the Optimal Preconditioned Eigensolver: Locally Optimal Block Preconditioned Conjugate Gradient Method", Andrew V. Knyazev <10.1137/S1064827500366124>` Examples -------- >>> from sklearn.datasets import load_digits >>> from sklearn.neighbors import kneighbors_graph >>> from sklearn.manifold import spectral_embedding >>> X, _ = load_digits(return_X_y=True) >>> X = X[:100] >>> affinity_matrix = kneighbors_graph( ... X, n_neighbors=int(X.shape[0] / 10), include_self=True ... ) >>> # make the matrix symmetric >>> affinity_matrix = 0.5 * (affinity_matrix + affinity_matrix.T) >>> embedding = spectral_embedding(affinity_matrix, n_components=2, random_state=42) >>> embedding.shape (100, 2) rb)r_spectral_embeddingrYs r6spectral_embeddingres>H&l33L !!!%   r8ct|}|dkr* ddlm}n"#t$r}t d|d}~wwxYw|d}|jd} |r|dz}t |stjdt||d \} } |dks#|d krtj | r | d |zkrt| d|} |d krdn|} | d z} t| jd|} t| dd} t| |dd| | \}}|j|dd }|r|| z }n#t"$r d }| d z} YnwxYw|dkrtj | stjdt| t$jt$jgd} t| d|} dtj| jdz}| |z } t-tdr.t/| tjrtj| } |t| d}| |z} |}|| jd|dzf}| |dddf<|| j}|d krdn|} t?| ||| d\}}|j}|r|| z }|jddkrt|d krBt| t$jt$jgd} | d |zdzkrStj | r| } tC| d\}}|jd|}|r|| z }nt| d|} || jd|dzf}| |dddf<|| j}|d krdn|} t?| || dd\}}|jd|}|r|| z }|jddkrttE|}|r|d|jS|d|jS)NrTr)smoothed_aggregation_solverz>The eigen_solver was set to 'amg', but pyamg is not available.rUr=zJGraph is not fully connected, spectral embedding may not work as expected.T)normed return_diagr rWcsrFr:?LM)ksigmawhichtolv0z$AMG works better for sparse matrices)rr;gh㈵> csr_array)r;)rH)Mrrlargest) check_finitei)rrrvmaxiter)#rpyamgrg ImportError ValueErrorrr?warningswarncsgraph_laplacianrr rOrrrT RuntimeErrorr"float64float32eyehasattr isinstancert csr_matrixaspreconditionerstandard_normalr+astyperr r*rr)rZr[r\rVr]rKr^rgerLrddrrrsr1 diffusion_map embedding diag_shiftmlruXs r6rdrd,ss **Iu  9 9 9 9 9 9 9   P    oa G(#a' y ) )  X   &.dMIr   8 # #++ $/6\9I/I/IiN;;  !F**!! C OI !3\BBB#EI %\Dcb    A}& (8b(89I +%N    $L OIII     y)) B M@ A A A bj"*5T   iN;; FJyq'9::: Z 6; ' ' 5Jy&BR,S,S 5))44I ( (Ye)T)T)T U UZ    ! !  ( (yq/A`. Parameters ---------- n_components : int, default=2 The dimension of the projected subspace. affinity : {'nearest_neighbors', 'rbf', 'precomputed', 'precomputed_nearest_neighbors'} or callable, default='nearest_neighbors' How to construct the affinity matrix. - 'nearest_neighbors' : construct the affinity matrix by computing a graph of nearest neighbors. - 'rbf' : construct the affinity matrix by computing a radial basis function (RBF) kernel. - 'precomputed' : interpret ``X`` as a precomputed affinity matrix. - 'precomputed_nearest_neighbors' : interpret ``X`` as a sparse graph of precomputed nearest neighbors, and constructs the affinity matrix by selecting the ``n_neighbors`` nearest neighbors. - callable : use passed in function as affinity the function takes in data matrix (n_samples, n_features) and return affinity matrix (n_samples, n_samples). gamma : float, default=None Kernel coefficient for rbf kernel. If None, gamma will be set to 1/n_features. random_state : int, RandomState instance or None, default=None A pseudo random number generator used for the initialization of the lobpcg eigen vectors decomposition when `eigen_solver == 'amg'`, and for the K-Means initialization. Use an int to make the results deterministic across calls (See :term:`Glossary `). .. note:: When using `eigen_solver == 'amg'`, it is necessary to also fix the global numpy seed with `np.random.seed(int)` to get deterministic results. See https://github.com/pyamg/pyamg/issues/139 for further information. eigen_solver : {'arpack', 'lobpcg', 'amg'}, default=None The eigenvalue decomposition strategy to use. AMG requires pyamg to be installed. It can be faster on very large, sparse problems. If None, then ``'arpack'`` is used. eigen_tol : float, default="auto" Stopping criterion for eigendecomposition of the Laplacian matrix. If `eigen_tol="auto"` then the passed tolerance will depend on the `eigen_solver`: - If `eigen_solver="arpack"`, then `eigen_tol=0.0`; - If `eigen_solver="lobpcg"` or `eigen_solver="amg"`, then `eigen_tol=None` which configures the underlying `lobpcg` solver to automatically resolve the value according to their heuristics. See, :func:`scipy.sparse.linalg.lobpcg` for details. Note that when using `eigen_solver="lobpcg"` or `eigen_solver="amg"` values of `tol<1e-5` may lead to convergence issues and should be avoided. .. versionadded:: 1.2 n_neighbors : int, default=None Number of nearest neighbors for nearest_neighbors graph building. If None, n_neighbors will be set to max(n_samples/10, 1). n_jobs : int, 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 ` for more details. Attributes ---------- embedding_ : ndarray of shape (n_samples, n_components) Spectral embedding of the training matrix. affinity_matrix_ : ndarray of shape (n_samples, n_samples) Affinity_matrix constructed from samples or precomputed. 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 n_neighbors_ : int Number of nearest neighbors effectively used. See Also -------- Isomap : Non-linear dimensionality reduction through Isometric Mapping. References ---------- - :doi:`A Tutorial on Spectral Clustering, 2007 Ulrike von Luxburg <10.1007/s11222-007-9033-z>` - `On Spectral Clustering: Analysis and an algorithm, 2001 Andrew Y. Ng, Michael I. Jordan, Yair Weiss `_ - :doi:`Normalized cuts and image segmentation, 2000 Jianbo Shi, Jitendra Malik <10.1109/34.868688>` Examples -------- >>> from sklearn.datasets import load_digits >>> from sklearn.manifold import SpectralEmbedding >>> X, _ = load_digits(return_X_y=True) >>> X.shape (1797, 64) >>> embedding = SpectralEmbedding(n_components=2) >>> X_transformed = embedding.fit_transform(X[:100]) >>> X_transformed.shape (100, 2) r=NrPrQ>rbf precomputednearest_neighborsprecomputed_nearest_neighborsrrVrSrWr[affinitygammarVr\r] n_neighborsn_jobs_parameter_constraintsr r)rrrVr\r]rrcv||_||_||_||_||_||_||_||_dSNr) selfr[rrrVr\r]rrs r6__init__zSpectralEmbedding.__init__vsD)   (("& r8ct}d|j_|jdv|j_|S)NT)rr)super__sklearn_tags__ input_tagsrrpairwise)rtags __class__s r6rz"SpectralEmbedding.__sklearn_tags__s?ww''))!%#'=5 $   r8cf|jdkr||_|jS|jdkr_t|j|jd|}||d}d||jzz|_|jS|jdkrtj |rtj dd |_n|j|jn*tt|jd d z d |_t ||jd|j|_d|j|jjzz|_|jS|jd krE|j|jnd|jd z |_t%||j|_|jS|||_|jS)a;Calculate the affinity matrix from data Parameters ---------- X : array-like of shape (n_samples, n_features) Training vector, where `n_samples` is the number of samples and `n_features` is the number of features. If affinity is "precomputed" X : array-like of shape (n_samples, n_samples), Interpret X as precomputed adjacency graph computed from samples. Y: Ignored Returns ------- affinity_matrix of shape (n_samples, n_samples) rr)rrmetric connectivity)rmodeg?rz`Nearest neighbors affinity currently does not support sparse input, falling back to rbf affinityrNr r=T) include_selfrrm)r)raffinity_matrix_rrrfitrrrr r|r}maxintr n_neighbors_rgamma_r )rrY estimatorrs r6_get_affinity_matrixz&SpectralEmbedding._get_affinity_matrixs& =M ) )$%D !( ( =; ; ;( ,T[c!ff %555OOL$'<,.+H$ID !( ( =/ / /q!! - # !& '3$$Sb11155! )9t(tDK)))%),)D,A,CC)%,, =E ! !(, (>$**C!'RS*DTDK$.q $D$D$DD !( ( $ a 0 0$$r8Tr_ct||dd}t|j}||}t ||j|j|j||_|S)aFit the model from data in X. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vector, where `n_samples` is the number of samples and `n_features` is the number of features. If affinity is "precomputed" X : {array-like, sparse matrix}, shape (n_samples, n_samples), Interpret X as precomputed adjacency graph computed from samples. y : Ignored Not used, present for API consistency by convention. Returns ------- self : object Returns the instance itself. rlr )r;ensure_min_samples)r[r\r]rV) rrrVrrdr[r\r] embedding_)rryrVaffinity_matrixs r6rzSpectralEmbedding.fitsq. $1 M M M)$*;<< 33A66- **n%     r8c:|||jS)aFit the model from data in X and transform X. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vector, where `n_samples` is the number of samples and `n_features` is the number of features. If affinity is "precomputed" X : {array-like, sparse matrix} of shape (n_samples, n_samples), Interpret X as precomputed adjacency graph computed from samples. y : Ignored Not used, present for API consistency by convention. Returns ------- X_new : array-like of shape (n_samples, n_components) Spectral embedding of the training matrix. )rr)rrrs r6 fit_transformzSpectralEmbedding.fit_transforms,  r8)r r)__name__ __module__ __qualname____doc__rrrcallablerrdict__annotations__rrrr rr __classcell__)rs@r6rrsFFR"(AtFCCCD J     (4D888$?'(#$?$?$?@@$GhtQV<<R>RS 1d6BBBDI"%$$D.%*8%8%8%8%t\555"""65"Hr8r)1rr|numbersrrnumpyr"scipyr scipy.linalgrscipy.sparse.csgraphrscipy.sparse.linalgrr baser r metrics.pairwiser r5rrutilsrrr utils._arpackrutils._param_validationrrr utils.extmathr utils.fixesrr~rrutils.validationrr7r?rOrerdrr8r6rs """"""""555555--------........)))))):::::::: ,+++++KKKKKKKKKK;;;;;;88888833333333,,,,,,***ZLLL@+++\"O4!(AtFCCCD#$?$?$?@@$G'(htQV<<R>RS$+ k#'   BBBB  BPi*i*i*i*i*Xrrrrr rrrrrr8