603 lines
24 KiB
Python
603 lines
24 KiB
Python
"""Spectral Embedding."""
|
|
|
|
# Author: Gael Varoquaux <gael.varoquaux@normalesup.org>
|
|
# Wei LI <kuantkid@gmail.com>
|
|
# License: BSD 3 clause
|
|
|
|
|
|
import warnings
|
|
|
|
import numpy as np
|
|
from scipy import sparse
|
|
from scipy.linalg import eigh
|
|
from scipy.sparse.linalg import eigsh
|
|
from scipy.sparse.csgraph import connected_components
|
|
from scipy.sparse.csgraph import laplacian as csgraph_laplacian
|
|
|
|
from ..base import BaseEstimator
|
|
from ..utils import (
|
|
check_array,
|
|
check_random_state,
|
|
check_symmetric,
|
|
)
|
|
from ..utils._arpack import _init_arpack_v0
|
|
from ..utils.extmath import _deterministic_vector_sign_flip
|
|
from ..utils.fixes import lobpcg
|
|
from ..metrics.pairwise import rbf_kernel
|
|
from ..neighbors import kneighbors_graph, NearestNeighbors
|
|
from ..utils.validation import _deprecate_positional_args
|
|
from ..utils.deprecation import deprecated
|
|
|
|
|
|
def _graph_connected_component(graph, node_id):
|
|
"""Find 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.
|
|
"""
|
|
n_node = graph.shape[0]
|
|
if sparse.issparse(graph):
|
|
# speed up row-wise access to boolean connection mask
|
|
graph = graph.tocsr()
|
|
connected_nodes = np.zeros(n_node, dtype=bool)
|
|
nodes_to_explore = np.zeros(n_node, dtype=bool)
|
|
nodes_to_explore[node_id] = True
|
|
for _ in range(n_node):
|
|
last_num_component = connected_nodes.sum()
|
|
np.logical_or(connected_nodes, nodes_to_explore, out=connected_nodes)
|
|
if last_num_component >= connected_nodes.sum():
|
|
break
|
|
indices = np.where(nodes_to_explore)[0]
|
|
nodes_to_explore.fill(False)
|
|
for i in indices:
|
|
if sparse.issparse(graph):
|
|
neighbors = graph[i].toarray().ravel()
|
|
else:
|
|
neighbors = graph[i]
|
|
np.logical_or(nodes_to_explore, neighbors, out=nodes_to_explore)
|
|
return connected_nodes
|
|
|
|
|
|
def _graph_is_connected(graph):
|
|
""" 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.
|
|
"""
|
|
if sparse.isspmatrix(graph):
|
|
# sparse graph, find all the connected components
|
|
n_connected_components, _ = connected_components(graph)
|
|
return n_connected_components == 1
|
|
else:
|
|
# dense graph, find all connected components start from node 0
|
|
return _graph_connected_component(graph, 0).sum() == graph.shape[0]
|
|
|
|
|
|
def _set_diag(laplacian, value, norm_laplacian):
|
|
"""Set 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.
|
|
"""
|
|
n_nodes = laplacian.shape[0]
|
|
# We need all entries in the diagonal to values
|
|
if not sparse.isspmatrix(laplacian):
|
|
if norm_laplacian:
|
|
laplacian.flat[::n_nodes + 1] = value
|
|
else:
|
|
laplacian = laplacian.tocoo()
|
|
if norm_laplacian:
|
|
diag_idx = (laplacian.row == laplacian.col)
|
|
laplacian.data[diag_idx] = value
|
|
# If the matrix has a small number of diagonals (as in the
|
|
# case of structured matrices coming from images), the
|
|
# dia format might be best suited for matvec products:
|
|
n_diags = np.unique(laplacian.row - laplacian.col).size
|
|
if n_diags <= 7:
|
|
# 3 or less outer diagonals on each side
|
|
laplacian = laplacian.todia()
|
|
else:
|
|
# csr has the fastest matvec and is thus best suited to
|
|
# arpack
|
|
laplacian = laplacian.tocsr()
|
|
return laplacian
|
|
|
|
|
|
@_deprecate_positional_args
|
|
def spectral_embedding(adjacency, *, n_components=8, eigen_solver=None,
|
|
random_state=None, eigen_tol=0.0,
|
|
norm_laplacian=True, drop_first=True):
|
|
"""Project 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 <spectral_embedding>`.
|
|
|
|
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
|
|
Determines the random number generator used for the initialization of
|
|
the lobpcg eigenvectors decomposition when ``solver`` == 'amg'. Pass
|
|
an int for reproducible results across multiple function calls.
|
|
See :term: `Glossary <random_state>`.
|
|
|
|
eigen_tol : float, default=0.0
|
|
Stopping criterion for eigendecomposition of the Laplacian matrix
|
|
when using arpack eigen_solver.
|
|
|
|
norm_laplacian : bool, default=True
|
|
If True, then compute 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
|
|
|
|
* Toward the Optimal Preconditioned Eigensolver: Locally Optimal
|
|
Block Preconditioned Conjugate Gradient Method
|
|
Andrew V. Knyazev
|
|
https://doi.org/10.1137%2FS1064827500366124
|
|
"""
|
|
adjacency = check_symmetric(adjacency)
|
|
|
|
try:
|
|
from pyamg import smoothed_aggregation_solver
|
|
except ImportError as e:
|
|
if eigen_solver == "amg":
|
|
raise ValueError("The eigen_solver was set to 'amg', but pyamg is "
|
|
"not available.") from e
|
|
|
|
if eigen_solver is None:
|
|
eigen_solver = 'arpack'
|
|
elif eigen_solver not in ('arpack', 'lobpcg', 'amg'):
|
|
raise ValueError("Unknown value for eigen_solver: '%s'."
|
|
"Should be 'amg', 'arpack', or 'lobpcg'"
|
|
% eigen_solver)
|
|
|
|
random_state = check_random_state(random_state)
|
|
|
|
n_nodes = adjacency.shape[0]
|
|
# Whether to drop the first eigenvector
|
|
if drop_first:
|
|
n_components = n_components + 1
|
|
|
|
if not _graph_is_connected(adjacency):
|
|
warnings.warn("Graph is not fully connected, spectral embedding"
|
|
" may not work as expected.")
|
|
|
|
laplacian, dd = csgraph_laplacian(adjacency, normed=norm_laplacian,
|
|
return_diag=True)
|
|
if (eigen_solver == 'arpack' or eigen_solver != 'lobpcg' and
|
|
(not sparse.isspmatrix(laplacian) or n_nodes < 5 * n_components)):
|
|
# lobpcg used with eigen_solver='amg' has bugs for low number of nodes
|
|
# for details see the source code in scipy:
|
|
# https://github.com/scipy/scipy/blob/v0.11.0/scipy/sparse/linalg/eigen
|
|
# /lobpcg/lobpcg.py#L237
|
|
# or matlab:
|
|
# https://www.mathworks.com/matlabcentral/fileexchange/48-lobpcg-m
|
|
laplacian = _set_diag(laplacian, 1, norm_laplacian)
|
|
|
|
# Here we'll use shift-invert mode for fast eigenvalues
|
|
# (see https://docs.scipy.org/doc/scipy/reference/tutorial/arpack.html
|
|
# for a short explanation of what this means)
|
|
# Because the normalized Laplacian has eigenvalues between 0 and 2,
|
|
# I - L has eigenvalues between -1 and 1. ARPACK is most efficient
|
|
# when finding eigenvalues of largest magnitude (keyword which='LM')
|
|
# and when these eigenvalues are very large compared to the rest.
|
|
# For very large, very sparse graphs, I - L can have many, many
|
|
# eigenvalues very near 1.0. This leads to slow convergence. So
|
|
# instead, we'll use ARPACK's shift-invert mode, asking for the
|
|
# eigenvalues near 1.0. This effectively spreads-out the spectrum
|
|
# near 1.0 and leads to much faster convergence: potentially an
|
|
# orders-of-magnitude speedup over simply using keyword which='LA'
|
|
# in standard mode.
|
|
try:
|
|
# We are computing the opposite of the laplacian inplace so as
|
|
# to spare a memory allocation of a possibly very large array
|
|
laplacian *= -1
|
|
v0 = _init_arpack_v0(laplacian.shape[0], random_state)
|
|
_, diffusion_map = eigsh(
|
|
laplacian, k=n_components, sigma=1.0, which='LM',
|
|
tol=eigen_tol, v0=v0)
|
|
embedding = diffusion_map.T[n_components::-1]
|
|
if norm_laplacian:
|
|
embedding = embedding / dd
|
|
except RuntimeError:
|
|
# When submatrices are exactly singular, an LU decomposition
|
|
# in arpack fails. We fallback to lobpcg
|
|
eigen_solver = "lobpcg"
|
|
# Revert the laplacian to its opposite to have lobpcg work
|
|
laplacian *= -1
|
|
|
|
elif eigen_solver == 'amg':
|
|
# Use AMG to get a preconditioner and speed up the eigenvalue
|
|
# problem.
|
|
if not sparse.issparse(laplacian):
|
|
warnings.warn("AMG works better for sparse matrices")
|
|
# lobpcg needs double precision floats
|
|
laplacian = check_array(laplacian, dtype=np.float64,
|
|
accept_sparse=True)
|
|
laplacian = _set_diag(laplacian, 1, norm_laplacian)
|
|
|
|
# The Laplacian matrix is always singular, having at least one zero
|
|
# eigenvalue, corresponding to the trivial eigenvector, which is a
|
|
# constant. Using a singular matrix for preconditioning may result in
|
|
# random failures in LOBPCG and is not supported by the existing
|
|
# theory:
|
|
# see https://doi.org/10.1007/s10208-015-9297-1
|
|
# Shift the Laplacian so its diagononal is not all ones. The shift
|
|
# does change the eigenpairs however, so we'll feed the shifted
|
|
# matrix to the solver and afterward set it back to the original.
|
|
diag_shift = 1e-5 * sparse.eye(laplacian.shape[0])
|
|
laplacian += diag_shift
|
|
ml = smoothed_aggregation_solver(check_array(laplacian,
|
|
accept_sparse='csr'))
|
|
laplacian -= diag_shift
|
|
|
|
M = ml.aspreconditioner()
|
|
X = random_state.rand(laplacian.shape[0], n_components + 1)
|
|
X[:, 0] = dd.ravel()
|
|
_, diffusion_map = lobpcg(laplacian, X, M=M, tol=1.e-5,
|
|
largest=False)
|
|
embedding = diffusion_map.T
|
|
if norm_laplacian:
|
|
embedding = embedding / dd
|
|
if embedding.shape[0] == 1:
|
|
raise ValueError
|
|
|
|
if eigen_solver == "lobpcg":
|
|
# lobpcg needs double precision floats
|
|
laplacian = check_array(laplacian, dtype=np.float64,
|
|
accept_sparse=True)
|
|
if n_nodes < 5 * n_components + 1:
|
|
# see note above under arpack why lobpcg has problems with small
|
|
# number of nodes
|
|
# lobpcg will fallback to eigh, so we short circuit it
|
|
if sparse.isspmatrix(laplacian):
|
|
laplacian = laplacian.toarray()
|
|
_, diffusion_map = eigh(laplacian)
|
|
embedding = diffusion_map.T[:n_components]
|
|
if norm_laplacian:
|
|
embedding = embedding / dd
|
|
else:
|
|
laplacian = _set_diag(laplacian, 1, norm_laplacian)
|
|
# We increase the number of eigenvectors requested, as lobpcg
|
|
# doesn't behave well in low dimension
|
|
X = random_state.rand(laplacian.shape[0], n_components + 1)
|
|
X[:, 0] = dd.ravel()
|
|
_, diffusion_map = lobpcg(laplacian, X, tol=1e-15,
|
|
largest=False, maxiter=2000)
|
|
embedding = diffusion_map.T[:n_components]
|
|
if norm_laplacian:
|
|
embedding = embedding / dd
|
|
if embedding.shape[0] == 1:
|
|
raise ValueError
|
|
|
|
embedding = _deterministic_vector_sign_flip(embedding)
|
|
if drop_first:
|
|
return embedding[1:n_components].T
|
|
else:
|
|
return embedding[:n_components].T
|
|
|
|
|
|
class SpectralEmbedding(BaseEstimator):
|
|
"""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 <spectral_embedding>`.
|
|
|
|
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
|
|
Determines the random number generator used for the initialization of
|
|
the lobpcg eigenvectors when ``solver`` == 'amg'. Pass an int for
|
|
reproducible results across multiple function calls.
|
|
See :term: `Glossary <random_state>`.
|
|
|
|
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.
|
|
|
|
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 <n_jobs>`
|
|
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_neighbors_ : int
|
|
Number of nearest neighbors effectively used.
|
|
|
|
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
|
|
"""
|
|
@_deprecate_positional_args
|
|
def __init__(self, n_components=2, *, affinity="nearest_neighbors",
|
|
gamma=None, random_state=None, eigen_solver=None,
|
|
n_neighbors=None, n_jobs=None):
|
|
self.n_components = n_components
|
|
self.affinity = affinity
|
|
self.gamma = gamma
|
|
self.random_state = random_state
|
|
self.eigen_solver = eigen_solver
|
|
self.n_neighbors = n_neighbors
|
|
self.n_jobs = n_jobs
|
|
|
|
def _more_tags(self):
|
|
return {'pairwise': self.affinity in ["precomputed",
|
|
"precomputed_nearest_neighbors"]}
|
|
|
|
# TODO: Remove in 1.1
|
|
# mypy error: Decorated property not supported
|
|
@deprecated("Attribute _pairwise was deprecated in " # type: ignore
|
|
"version 0.24 and will be removed in 1.1 (renaming of 0.26).")
|
|
@property
|
|
def _pairwise(self):
|
|
return self.affinity in ["precomputed",
|
|
"precomputed_nearest_neighbors"]
|
|
|
|
def _get_affinity_matrix(self, X, Y=None):
|
|
"""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)
|
|
"""
|
|
if self.affinity == 'precomputed':
|
|
self.affinity_matrix_ = X
|
|
return self.affinity_matrix_
|
|
if self.affinity == 'precomputed_nearest_neighbors':
|
|
estimator = NearestNeighbors(n_neighbors=self.n_neighbors,
|
|
n_jobs=self.n_jobs,
|
|
metric="precomputed").fit(X)
|
|
connectivity = estimator.kneighbors_graph(X=X, mode='connectivity')
|
|
self.affinity_matrix_ = 0.5 * (connectivity + connectivity.T)
|
|
return self.affinity_matrix_
|
|
if self.affinity == 'nearest_neighbors':
|
|
if sparse.issparse(X):
|
|
warnings.warn("Nearest neighbors affinity currently does "
|
|
"not support sparse input, falling back to "
|
|
"rbf affinity")
|
|
self.affinity = "rbf"
|
|
else:
|
|
self.n_neighbors_ = (self.n_neighbors
|
|
if self.n_neighbors is not None
|
|
else max(int(X.shape[0] / 10), 1))
|
|
self.affinity_matrix_ = kneighbors_graph(X, self.n_neighbors_,
|
|
include_self=True,
|
|
n_jobs=self.n_jobs)
|
|
# currently only symmetric affinity_matrix supported
|
|
self.affinity_matrix_ = 0.5 * (self.affinity_matrix_ +
|
|
self.affinity_matrix_.T)
|
|
return self.affinity_matrix_
|
|
if self.affinity == 'rbf':
|
|
self.gamma_ = (self.gamma
|
|
if self.gamma is not None else 1.0 / X.shape[1])
|
|
self.affinity_matrix_ = rbf_kernel(X, gamma=self.gamma_)
|
|
return self.affinity_matrix_
|
|
self.affinity_matrix_ = self.affinity(X)
|
|
return self.affinity_matrix_
|
|
|
|
def fit(self, X, y=None):
|
|
"""Fit 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
|
|
|
|
Returns
|
|
-------
|
|
self : object
|
|
Returns the instance itself.
|
|
"""
|
|
|
|
X = self._validate_data(X, accept_sparse='csr', ensure_min_samples=2,
|
|
estimator=self)
|
|
|
|
random_state = check_random_state(self.random_state)
|
|
if isinstance(self.affinity, str):
|
|
if self.affinity not in {"nearest_neighbors", "rbf", "precomputed",
|
|
"precomputed_nearest_neighbors"}:
|
|
raise ValueError(("%s is not a valid affinity. Expected "
|
|
"'precomputed', 'rbf', 'nearest_neighbors' "
|
|
"or a callable.") % self.affinity)
|
|
elif not callable(self.affinity):
|
|
raise ValueError(("'affinity' is expected to be an affinity "
|
|
"name or a callable. Got: %s") % self.affinity)
|
|
|
|
affinity_matrix = self._get_affinity_matrix(X)
|
|
self.embedding_ = spectral_embedding(affinity_matrix,
|
|
n_components=self.n_components,
|
|
eigen_solver=self.eigen_solver,
|
|
random_state=random_state)
|
|
return self
|
|
|
|
def fit_transform(self, X, y=None):
|
|
"""Fit 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
|
|
|
|
Returns
|
|
-------
|
|
X_new : array-like of shape (n_samples, n_components)
|
|
"""
|
|
self.fit(X)
|
|
return self.embedding_
|