U Xe;M@sddlZddlmZddlZddlZddlZddlmZddl m Z ddl m Z ddl mZddlmZmZddlmZmZd ifd d Zd id d dfddZd id dfddZd idd dfddZd id dd dfddZdS)N)warn) TruncatedSVD)SpectralEmbedding)pairwise_distances)_VALID_METRICS)pairwise_special_metricSPECIAL_METRICS)SPARSE_SPECIAL_METRICSsparse_named_distancesZ euclideancCs<|dkrtjj||fddStj||jdftjd}|dkrtj||ftjd}|dd} | dkrptj} n,| d krtj} n| d krtj } n t d | t |D]T} ||| k} t | d|D]4} | | dd|| kf} | || | f<| || | f<qqn t |D]}|||kjd d ||<qt j |rDtd|}|tkr^t|||d}n|tkr|t|t||d}nt|rt j |rddtttt@D}z ||}Wntk rtdYnXt|fd|i|}nt|fd|i|}t|d }t|d|d|}||}|S)aProvide a layout relating the separate connected components. This is done by taking the centroid of each component and then performing a spectral embedding of the centroids. Parameters ---------- data: array of shape (n_samples, n_features) The source data -- required so we can generate centroids for each connected component of the graph. n_components: int The number of distinct components to be layed out. component_labels: array of shape (n_samples) For each vertex in the graph the label of the component to which the vertex belongs. dim: int The chosen embedding dimension. metric: string or callable (optional, default 'euclidean') The metric used to measure distances among the source data points. metric_kwds: dict (optional, default {}) Keyword arguments to be passed to the metric function. If metric is 'precomputed', 'linkage' keyword can be used to specify 'average', 'complete', or 'single' linkage. Default is 'average' Returns ------- component_embedding: array of shape (n_components, dim) The ``dim``-dimensional embedding of the ``n_components``-many connected components. Nsize$@ZdtypeZ precomputedlinkageZaverageZcompleteZsinglezPUnrecognized linkage '%s'. Please choose from 'average', 'complete', or 'single'rZaxiszlForcing component centroids to dense; if you are running out of memory then consider increasing n_neighbors.)metrickwdscSsi|]}t||qS)r ).0krr,lib/python3.8/site-packages/umap/spectral.py rsz$component_layout..zPMulticomponent layout for custom sparse metrics is not implemented at this time.r) n_componentsZaffinity random_state)nprandomemptyshapefloat64zerosgetZmeanmaxmin ValueErrorrangescipysparseZ isspmatrixrZtoarrayrrr callablesetSKLEARN_PAIRWISE_VALID_METRICSr keysKeyErrorNotImplementedErrorrZexpr fit_transform)datarcomponent_labelsdimrr metric_kwdsZcomponent_centroidsZdistance_matrixrZc_iZdm_iZc_jZdistlabelZfunction_to_name_mappingZ metric_nameZaffinity_matrixcomponent_embeddingrrrcomponent_layouts+           r6rc  Cstj|jd|ftjd} |d|kr>t|||||||d} nLtt|d} tt| t | || fg}t || gd|} t |D]}| ||kddf }|dd||kf}t| |g| }||dkd}|jdd|ks|jd|dkrD|j| ||jd|fd | || ||k<qtd||||||| | d }|tt|}||9}|| || ||k<q| S) ahSpecialised layout algorithm for dealing with graphs with many connected components. This will first find relative positions for the components by spectrally embedding their centroids, then spectrally embed each individual connected component positioning them according to the centroid embeddings. This provides a decent embedding of each component while placing the components in good relative positions to one another. Parameters ---------- data: array of shape (n_samples, n_features) The source data -- required so we can generate centroids for each connected component of the graph. graph: sparse matrix The adjacency matrix of the graph to be embedded. n_components: int The number of distinct components to be layed out. component_labels: array of shape (n_samples) For each vertex in the graph the label of the component to which the vertex belongs. dim: int The chosen embedding dimension. metric: string or callable (optional, default 'euclidean') The metric used to measure distances among the source data points. metric_kwds: dict (optional, default {}) Keyword arguments to be passed to the metric function. init: string, either "random" or "tsvd" Indicates to initialize the eigensolver. Use "random" (the default) to use uniformly distributed random initialization; use "tsvd" to warm-start the eigensolver with singular vectors of the Laplacian associated to the largest singular values. This latter option also forces usage of the LOBPCG eigensolver; with the former, ARPACK's solver ``eigsh`` will be used for smaller Laplacians. tol: float, default chosen by implementation Stopping tolerance for the numerical algorithm computing the embedding. maxiter: int, default chosen by implementation Number of iterations the numerical algorithm will go through at most as it attempts to compute the embedding. Returns ------- embedding: array of shape (n_samples, dim) The initial embedding of ``graph``. rrrrr3g@Nr7rZlowZhighr r0graphr2rrr3inittolmaxiter)rrrZfloat32r6intZceilZhstackZeyer!Zvstackr&ZtocsrZtocscZtocoorr$uniform_spectral_layoutr#abs)r0r;rr1r2rrr3r<r=r>resultZmeta_embeddingrbaser4Zcomponent_graphZ distancesZ data_ranger5Z expansionrrrmulti_component_layoutsX@  " (    rEc Cst||||||d||d S)a Given a graph compute the spectral embedding of the graph. This is simply the eigenvectors of the laplacian of the graph. Here we use the normalized laplacian. Parameters ---------- data: array of shape (n_samples, n_features) The source data graph: sparse matrix The (weighted) adjacency matrix of the graph as a sparse matrix. dim: int The dimension of the space into which to embed. random_state: numpy RandomState or equivalent A state capable being used as a numpy random state. tol: float, default chosen by implementation Stopping tolerance for the numerical algorithm computing the embedding. maxiter: int, default chosen by implementation Number of iterations the numerical algorithm will go through at most as it attempts to compute the embedding. Returns ------- embedding: array of shape (n_vertices, dim) The spectral embedding of the graph. rr:rA)r0r;r2rrr3r=r>rrrspectral_layouts)rGc Cst||||||d|||d S)a Given a graph, compute the spectral embedding of the graph. This is simply the eigenvectors of the Laplacian of the graph. Here we use the normalized laplacian and a truncated SVD-based guess of the eigenvectors to "warm" up the eigensolver. This function should give results of similar accuracy to the spectral_layout function, but may converge more quickly for graph Laplacians that cause spectral_layout to take an excessive amount of time to complete. Parameters ---------- data: array of shape (n_samples, n_features) The source data graph: sparse matrix The (weighted) adjacency matrix of the graph as a sparse matrix. dim: int The dimension of the space into which to embed. random_state: numpy RandomState or equivalent A state capable being used as a numpy random state. metric: string or callable (optional, default 'euclidean') The metric used to measure distances among the source data points. Used only if the multiple connected components are found in the graph. metric_kwds: dict (optional, default {}) Keyword arguments to be passed to the metric function. If metric is 'precomputed', 'linkage' keyword can be used to specify 'average', 'complete', or 'single' linkage. Default is 'average'. Used only if the multiple connected components are found in the graph. method: str (optional, default None, values either 'eigsh' or 'lobpcg') Name of the eigenvalue computation method to use to compute the spectral embedding. If left to None (or empty string), as by default, the method is chosen from the number of vectors in play: larger vector collections are handled with lobpcg, smaller collections with eigsh. Method names correspond to SciPy routines in scipy.sparse.linalg. tol: float, default chosen by implementation Stopping tolerance for the numerical algorithm computing the embedding. maxiter: int, default chosen by implementation Number of iterations the numerical algorithm will go through at most as it attempts to compute the embedding. Returns ------- embedding: array of shape (n_vertices, dim) The spectral embedding of the graph. tsvd) r0r;r2rrr3r<methodr=r>rF) r0r;r2rrr3rIr=r>rrrtswspectral_layout=s@rJc  Cs|jd} tjj|\} } | dkrz+(?ms).*not reaching the requested toleranceerror)categorymessageactionF)Zlargestr=r>z1Method should either be None, 'eigsh' or 'lobpcg'zSpectral initialisation failed! The eigenvector solver failed. This is likely due to too small an eigengap. Consider adding some noise or jitter to your data. Falling back to random initialisation!g$r r9)'rr'r(ZcsgraphZconnected_componentsrErZsqrtZasarraysumZsqueezeZidentityr ZspdiagsZissparser#r? isinstancer GeneratorZ RandomStateZ default_rngZnormalrr/r%ZlinalgZnormrKZoneswarningscatch_warningsfilterwarnings UserWarningrLZargsortZ ArpackErrorrr@)r0r;r2rrr3r<rIr=r>Z n_samplesrlabelsZsqrt_degIDLrZnum_lanczos_vectorsgenXZ eigenvaluesZ eigenvectorsorderrrrrAsD    "       rA)rVrZnumpyrZ scipy.sparser'Zscipy.sparse.csgraphZsklearn.decompositionrZsklearn.manifoldrZsklearn.metricsrZsklearn.metrics.pairwiserr+Zumap.distancesrrZ umap.sparser r r6rErGrJrArrrrsL        { ; S