ó ‡ˆ\c@ s@dZddlmZddlZddlZddlmZddlm Z ddl m Z m Z ddl mZddl mZd d lmZd d lmZd d lmZmZmZd d lmZd dlmZd dlmZd„Zd„Z d„Z!dddde#e#d„Z$defd„ƒYZ%dS(sSpectral Embeddingi˙˙˙˙(tdivisionN(tsparse(teigh(teigshtlobpcg(tconnected_components(t laplaciani(t BaseEstimator(tsix(tcheck_random_statet check_arraytcheck_symmetric(t_deterministic_vector_sign_flip(t rbf_kernel(tkneighbors_graphc C s1|jd}tj|ƒr+|jƒ}ntj|dtjƒ}tj|dtjƒ}t||`. Parameters ---------- adjacency : array-like or sparse matrix, shape: (n_samples, n_samples) The adjacency matrix of the graph to embed. n_components : integer, optional, default 8 The dimension of the projection subspace. eigen_solver : {None, 'arpack', 'lobpcg', or '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. random_state : int, RandomState instance or None, optional, default: None A pseudo random number generator used for the initialization of the lobpcg eigenvectors decomposition. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Used when ``solver`` == 'amg'. eigen_tol : float, optional, default=0.0 Stopping criterion for eigendecomposition of the Laplacian matrix when using arpack eigen_solver. norm_laplacian : bool, optional, default=True If True, then compute normalized Laplacian. drop_first : bool, optional, 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 : array, 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 * Toward the Optimal Preconditioned Eigensolver: Locally Optimal Block Preconditioned Conjugate Gradient Method Andrew V. Knyazev https://doi.org/10.1137%2FS1064827500366124 i˙˙˙˙(tsmoothed_aggregation_solvertamgs>The eigen_solver was set to 'amg', but pyamg is not available.tarpackRsKUnknown value for eigen_solver: '%s'.Should be 'amg', 'arpack', or 'lobpcg'iisJGraph is not fully connected, spectral embedding may not work as expected.tnormedt return_diagitktsigmagđ?twhichtLMttoltv0Ns$AMG works better for sparse matricesRt accept_sparsetcsrtMgę-™—q=tlargestgV瞯ŇRR=( R tpyamgR<t ImportErrort ValueErrortNoneR RR-twarningstwarntcsgraph_laplacianRRR+R;tuniformRtTt RuntimeErrorRR Rtfloat64taspreconditionertrandRRRRRR (t adjacencyt n_componentst eigen_solvert random_statet eigen_tolR7t drop_firstR<R8RtddRFtlambdast diffusion_mapt embeddingtmlRItX((sClib/python2.7/site-packages/sklearn/manifold/spectral_embedding_.pytspectral_embeddingˆs–M                            tSpectralEmbeddingcB s_eZdZdddddddd„Zed„ƒZdd„Zdd„Zdd„Z RS( sY Spectral embedding for non-linear dimensionality reduction. Forms an affinity matrix given by the specified function and applies spectral decomposition to the corresponding graph laplacian. The resulting transformation is given by the value of the eigenvectors for each data point. Note : Laplacian Eigenmaps is the actual algorithm implemented here. Read more in the :ref:`User Guide `. Parameters ----------- n_components : integer, default: 2 The dimension of the projected subspace. affinity : string or callable, default : "nearest_neighbors" How to construct the affinity matrix. - 'nearest_neighbors' : construct affinity matrix by knn graph - 'rbf' : construct affinity matrix by rbf kernel - 'precomputed' : interpret X as precomputed affinity matrix - 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, optional, default : 1/n_features Kernel coefficient for rbf kernel. random_state : int, RandomState instance or None, optional, default: None A pseudo random number generator used for the initialization of the lobpcg eigenvectors. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Used when ``solver`` == 'amg'. eigen_solver : {None, 'arpack', 'lobpcg', or 'amg'} 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. n_neighbors : int, default : max(n_samples/10 , 1) Number of nearest neighbors for nearest_neighbors graph building. n_jobs : int or None, optional (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_ : array, shape = (n_samples, n_components) Spectral embedding of the training matrix. affinity_matrix_ : array, shape = (n_samples, n_samples) Affinity_matrix constructed from samples or precomputed. 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) References ---------- - A Tutorial on Spectral Clustering, 2007 Ulrike von Luxburg http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.165.9323 - On Spectral Clustering: Analysis and an algorithm, 2001 Andrew Y. Ng, Michael I. Jordan, Yair Weiss http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.19.8100 - Normalized cuts and image segmentation, 2000 Jianbo Shi, Jitendra Malik http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.160.2324 itnearest_neighborscC sC||_||_||_||_||_||_||_dS(N(RZtaffinitytgammaR\R[t n_neighborstn_jobs(tselfRZRhRiR\R[RjRk((sClib/python2.7/site-packages/sklearn/manifold/spectral_embedding_.pyt__init__Źs      cC s |jdkS(Nt precomputed(Rh(Rl((sClib/python2.7/site-packages/sklearn/manifold/spectral_embedding_.pyt _pairwiseˇscC sL|jdkr||_|jS|jdkrŮtj|ƒrVtjdƒd|_qŮ|jd k rn|jntt |j ddƒdƒ|_ t ||j dt d |jƒ|_d |j|jj|_|jSn|jdkr3|jd k r|jnd |j d|_t|d |jƒ|_|jS|j|ƒ|_|jS(s1Calculate the affinity matrix from data Parameters ---------- X : array-like, 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, shape (n_samples, n_samples), Interpret X as precomputed adjacency graph computed from samples. Y: Ignored Returns ------- affinity_matrix, shape (n_samples, n_samples) RnRgs`Nearest neighbors affinity currently does not support sparse input, falling back to rbf affinitytrbfii it include_selfRkgŕ?gđ?RiN(Rhtaffinity_matrix_RRRPRQRjROtmaxtintRt n_neighbors_RRRkRTRitgamma_R (RlRdtY((sClib/python2.7/site-packages/sklearn/manifold/spectral_embedding_.pyt_get_affinity_matrixťs*   #  ,cC sÉt|ddd|ƒ}t|jƒ}t|jtjƒrj|jtd ƒkrtd|jƒ‚qn%t |jƒstd|jƒ‚n|j |ƒ}t |d |j d |j d |ƒ|_|S( sFit the model from data in X. Parameters ---------- X : array-like, 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, shape (n_samples, n_samples), Interpret X as precomputed adjacency graph computed from samples. Returns ------- self : object Returns the instance itself. tensure_min_samplesit estimatorRgRpRns]%s is not a valid affinity. Expected 'precomputed', 'rbf', 'nearest_neighbors' or a callable.sD'affinity' is expected to be an affinity name or a callable. Got: %sRZR[R\(RgRpRn(R R R\t isinstanceRhRt string_typestsetRNtcallableRxReRZR[t embedding_(RlRdtyR\taffinity_matrix((sClib/python2.7/site-packages/sklearn/manifold/spectral_embedding_.pytfitęs       cC s|j|ƒ|jS(s*Fit the model from data in X and transform X. Parameters ---------- X : array-like, 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, shape (n_samples, n_samples), Interpret X as precomputed adjacency graph computed from samples. Returns ------- X_new : array-like, shape (n_samples, n_components) (R‚R(RlRdR€((sClib/python2.7/site-packages/sklearn/manifold/spectral_embedding_.pyt fit_transforms N( t__name__t __module__t__doc__RORmtpropertyRoRxR‚Rƒ(((sClib/python2.7/site-packages/sklearn/manifold/spectral_embedding_.pyRfTsV   / ((&R†t __future__RRPtnumpyRtscipyRt scipy.linalgRtscipy.sparse.linalgRRtscipy.sparse.csgraphRRRRtbaseRt externalsRtutilsR R R t utils.extmathR tmetrics.pairwiseR R)RR*R-R;RORReRf(((sClib/python2.7/site-packages/sklearn/manifold/spectral_embedding_.pyts*   +  ,Ę