def predict(
self, adjacency_vectors: Union[sparse.csr_matrix,
np.ndarray]) -> np.ndarray:
"""Predict the embedding of new rows, defined by their adjacency vectors.
Parameters
----------
adjacency_vectors :
Adjacency vectors of nodes.
Array of shape (n_col,) (single vector) or (n_vectors, n_col)
Returns
-------
embedding_vectors : np.ndarray
Embedding of the nodes.
"""
self._check_fitted()
n_row, _ = self.embedding_row_.shape
n_col, _ = self.embedding_col_.shape
adjacency_vectors = check_adjacency_vector(adjacency_vectors, n_col)
empty_block = sparse.csr_matrix((adjacency_vectors.shape[0], n_row))
adjacency_vectors = sparse.bmat([[empty_block, adjacency_vectors]],
format='csr')
embedding_vectors = Spectral.predict(self, adjacency_vectors)
return embedding_vectors
def predict(self, adjacency_vectors: Union[sparse.csr_matrix, np.ndarray]) -> np.ndarray:
"""Predict the embedding of new rows, defined by their adjacency vectors.
Parameters
----------
adjacency_vectors :
Adjacency row vectors.
Array of shape (n_col,) (single vector) or (n_vectors, n_col)
Returns
-------
embedding_vectors : np.ndarray
Embedding of the nodes.
"""
self._check_fitted()
if self.embedding_col_ is not None:
n = len(self.embedding_col_)
else:
n = len(self.embedding_)
adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
check_nonnegative(adjacency_vectors)
membership = membership_matrix(self.labels_)
return normalize(adjacency_vectors).dot(membership)
def predict(self, adjacency_vectors: Union[sparse.csr_matrix, np.ndarray]) -> np.ndarray:
"""Predict the embedding of new rows, defined by their adjacency vectors.
Parameters
----------
adjacency_vectors :
Adjacency vectors of nodes.
Array of shape (n_col,) (single vector) or (n_vectors, n_col)
Returns
-------
embedding_vectors : np.ndarray
Embedding of the nodes.
"""
self._check_fitted()
embedding = self.embedding_
n = embedding.shape[0]
adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
embedding_vectors = normalize(adjacency_vectors).dot(embedding)
if embedding_vectors.shape[0] == 1:
embedding_vectors = embedding_vectors.ravel()
return embedding_vectors
def predict(
self, adjacency_vectors: Union[sparse.csr_matrix,
np.ndarray]) -> np.ndarray:
"""Predict the embedding of new nodes, defined by their adjacency vectors.
Parameters
----------
adjacency_vectors :
Adjacency vectors of nodes.
Array of shape (n_col,) (single vector) or (n_vectors, n_col)
Returns
-------
embedding_vectors : np.ndarray
Embedding of the nodes.
"""
self._check_fitted()
n = self.embedding_.shape[0]
adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
check_nonnegative(adjacency_vectors)
membership = membership_matrix(self.labels_)
return adjacency_vectors.dot(membership)
def predict(
self, adjacency_vectors: Union[sparse.csr_matrix,
np.ndarray]) -> np.ndarray:
"""Predict the embedding of new nodes, defined by their adjacency vectors.
Parameters
----------
adjacency_vectors :
Adjacency vectors of nodes.
Array of shape (n_col,) (single vector) or (n_vectors, n_col)
Returns
-------
embedding_vectors : np.ndarray
Embedding of the nodes.
"""
self._check_fitted()
eigenvectors = self.eigenvectors_
eigenvalues = self.eigenvalues_
n = eigenvectors.shape[0]
adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
check_nonnegative(adjacency_vectors)
# regularization
if self.regularization_:
adjacency_vectors = RegularizedAdjacency(adjacency_vectors,
self.regularization_)
# projection in the embedding space
averaging = normalize(adjacency_vectors, p=1)
embedding_vectors = averaging.dot(eigenvectors)
if not self.barycenter:
if self.normalized_laplacian:
factors = 1 - eigenvalues
else:
# to be modified
factors = 1 - eigenvalues / (adjacency_vectors.sum() + 1e-9)
factors_inv_diag = diag_pinv(factors)
embedding_vectors = factors_inv_diag.dot(embedding_vectors.T).T
if self.equalize:
embedding_vectors = diag_pinv(np.sqrt(eigenvalues)).dot(
embedding_vectors.T).T
if self.normalized:
embedding_vectors = normalize(embedding_vectors, p=2)
if embedding_vectors.shape[0] == 1:
embedding_vectors = embedding_vectors.ravel()
return embedding_vectors
def predict(
self, adjacency_vectors: Union[sparse.csr_matrix,
np.ndarray]) -> np.ndarray:
"""Predict the embedding of new rows, defined by their adjacency vectors.
Parameters
----------
adjacency_vectors :
Adjacency vectors of nodes.
Array of shape (n_col,) (single vector) or (n_vectors, n_col)
Returns
-------
embedding_vectors : np.ndarray
Embedding of the nodes.
"""
self._check_fitted()
singular_vectors_right = self.singular_vectors_right_
singular_values = self.singular_values_
n_row, _ = self.embedding_row_.shape
n_col, _ = self.embedding_col_.shape
adjacency_vectors = check_adjacency_vector(adjacency_vectors, n_col)
self._check_adj_vector(adjacency_vectors)
# regularization
if self.regularization_:
adjacency_vectors = RegularizedAdjacency(adjacency_vectors,
self.regularization_)
# weighting
weights_row = adjacency_vectors.dot(np.ones(n_col))
diag_row = diag_pinv(np.power(weights_row, self.factor_row))
diag_col = diag_pinv(np.power(self.weights_col_, self.factor_col))
adjacency_vectors = safe_sparse_dot(
diag_row, safe_sparse_dot(adjacency_vectors, diag_col))
# projection in the embedding space
averaging = adjacency_vectors
embedding_vectors = diag_row.dot(averaging.dot(singular_vectors_right))
# scaling
embedding_vectors /= np.power(singular_values, self.factor_singular)
if self.normalized:
embedding_vectors = normalize(embedding_vectors, p=2)
if embedding_vectors.shape[0] == 1:
embedding_vectors = embedding_vectors.ravel()
return embedding_vectors
def predict(
self, adjacency_vectors: Union[sparse.csr_matrix,
np.ndarray]) -> np.ndarray:
"""Predict the embedding of new nodes, defined by their adjacency vectors.
Parameters
----------
adjacency_vectors :
Adjacency vectors of nodes.
Array of shape (n_col,) (single vector) or (n_vectors, n_col)
Returns
-------
embedding_vectors : np.ndarray
Embedding of the nodes.
"""
self._check_fitted()
eigenvectors = self.eigenvectors_
eigenvalues = self.eigenvalues_
n = eigenvectors.shape[0]
adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
check_nonnegative(adjacency_vectors)
# regularization
if self.regularization_:
adjacency_vectors = RegularizedAdjacency(adjacency_vectors,
self.regularization_)
# projection in the embedding space
averaging = normalize(adjacency_vectors, p=1)
embedding_vectors = averaging.dot(eigenvectors)
embedding_vectors = diag_pinv(eigenvalues).dot(embedding_vectors.T).T
if self.scaling:
eigenvalues_inv_diag = diag_pinv((1 - eigenvalues)**self.scaling)
embedding_vectors = eigenvalues_inv_diag.dot(embedding_vectors.T).T
if self.normalized:
embedding_vectors = normalize(embedding_vectors, p=2)
if embedding_vectors.shape[0] == 1:
embedding_vectors = embedding_vectors.ravel()
return embedding_vectors
def predict(
self, adjacency_vectors: Union[sparse.csr_matrix,
np.ndarray]) -> np.ndarray:
"""Predict the embedding of new nodes, when possible (otherwise return 0).
Each new node is defined by its adjacency row vector.
Parameters
----------
adjacency_vectors :
Adjacency vectors of nodes.
Array of shape (n_col,) (single vector) or (n_vectors, n_col)
Returns
-------
embedding_vectors : np.ndarray
Embedding of the nodes.
Example
-------
>>> from sknetwork.embedding import Spectral
>>> from sknetwork.data import karate_club
>>> spectral = Spectral(n_components=3)
>>> adjacency = karate_club()
>>> adjacency_vector = np.arange(34) < 5
>>> _ = spectral.fit(adjacency)
>>> len(spectral.predict(adjacency_vector))
3
"""
self._check_fitted()
# input
if self.bipartite:
n = len(self.embedding_col_)
else:
n = len(self.embedding_)
adjacency_vectors = check_adjacency_vector(adjacency_vectors, n)
check_nonnegative(adjacency_vectors)
if self.bipartite:
shape = (adjacency_vectors.shape[0], self.embedding_row_.shape[0])
adjacency_vectors = sparse.csr_matrix(adjacency_vectors)
adjacency_vectors = sparse.hstack(
[sparse.csr_matrix(shape), adjacency_vectors], format='csr')
embedding = np.vstack([self.embedding_row_, self.embedding_col_])
else:
embedding = self.embedding_
eigenvalues = self.eigenvalues_
# regularization
if self.regularized:
regularization = np.abs(self.regularization)
else:
regularization = 0
normalizer = Normalizer(adjacency_vectors, regularization)
# prediction
embedding_vectors = normalizer.dot(embedding)
if self.normalized_laplacian:
norm_vec = 1 - eigenvalues
norm_vec[norm_vec > 0] = 1 / norm_vec[norm_vec > 0]
embedding_vectors *= norm_vec
else:
norm_matrix = sparse.csr_matrix(
1 - np.outer(normalizer.norm_diag.data, eigenvalues))
norm_matrix.data = 1 / norm_matrix.data
embedding_vectors *= norm_matrix.toarray()
# shape
if len(embedding_vectors) == 1:
embedding_vectors = embedding_vectors.ravel()
return embedding_vectors