scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/utils/check.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in April 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import warnings
+from typing import Union, Optional
+
+import numpy as np
+from scipy import sparse
+
+
+def has_nonnegative_entries(input_matrix: Union[sparse.csr_matrix, np.ndarray]) -> bool:
+    """True if the array has non-negative entries."""
+    if type(input_matrix) == sparse.csr_matrix:
+        return np.all(input_matrix.data >= 0)
+    else:
+        return np.all(input_matrix >= 0)
+
+
+def is_weakly_connected(adjacency: sparse.csr_matrix) -> bool:
+    """Check whether a graph is weakly connected.
+    Parameters
+    ----------
+    adjacency:
+        Adjacency matrix of the graph.
+    """
+    n_cc = sparse.csgraph.connected_components(adjacency, (not is_symmetric(adjacency)), 'weak', False)
+    return n_cc == 1
+
+
+def check_connected(adjacency: sparse.csr_matrix):
+    """Check is a graph is weakly connected and return an error otherwise."""
+    if is_weakly_connected(adjacency):
+        return
+    else:
+        raise ValueError('The graph is expected to be connected.')
+
+
+def check_nonnegative(input_matrix: Union[sparse.csr_matrix, np.ndarray]):
+    """Check whether the array has non-negative entries."""
+    if not has_nonnegative_entries(input_matrix):
+        raise ValueError('Only nonnegative values are expected.')
+
+
+def has_positive_entries(input_matrix: np.ndarray) -> bool:
+    """True if the array has positive entries."""
+    if type(input_matrix) != np.ndarray:
+        raise TypeError('Entry must be a dense NumPy array.')
+    else:
+        return np.all(input_matrix > 0)
+
+
+def check_positive(input_matrix: Union[sparse.csr_matrix, np.ndarray]):
+    """Check whether the array has positive entries."""
+    if not has_positive_entries(input_matrix):
+        raise ValueError('Only positive values are expected.')
+
+
+def is_proba_array(input_matrix: np.ndarray) -> bool:
+    """True if each line of the array has non-negative entries which sum to 1."""
+    if len(input_matrix.shape) == 1:
+        return has_nonnegative_entries(input_matrix) and np.isclose(input_matrix.sum(), 1)
+    elif len(input_matrix.shape) == 2:
+        n_row, n_col = input_matrix.shape
+        err = input_matrix.dot(np.ones(n_col)) - np.ones(n_row)
+        return has_nonnegative_entries(input_matrix) and np.isclose(np.linalg.norm(err), 0)
+    else:
+        raise TypeError('Entry must be one or two-dimensional array.')
+
+
+def is_square(input_matrix: Union[sparse.csr_matrix, np.ndarray]) -> bool:
+    """True if the matrix is square."""
+    return input_matrix.shape[0] == input_matrix.shape[1]
+
+
+def check_square(input_matrix: Union[sparse.csr_matrix, np.ndarray]):
+    """Check whether a matrix is square and return an error otherwise."""
+    if is_square(input_matrix):
+        return
+    else:
+        raise ValueError('The adjacency matrix is expected to be square.')
+
+
+def is_symmetric(input_matrix: sparse.csr_matrix) -> bool:
+    """True if the matrix is symmetric."""
+    return sparse.csr_matrix(input_matrix - input_matrix.T).nnz == 0
+
+
+def check_symmetry(input_matrix: sparse.csr_matrix):
+    """Check whether a matrix is symmetric and return an error otherwise."""
+    if not is_symmetric(input_matrix):
+        raise ValueError('The input matrix is expected to be symmetric.')
+
+
+def make_weights(distribution: str, adjacency: sparse.csr_matrix) -> np.ndarray:
+    """Array of weights from a matrix and a desired distribution.
+
+   Parameters
+   ----------
+   distribution:
+       Distribution for node sampling. Only ``'degree'`` or ``'uniform'`` are accepted.
+   adjacency:
+       The adjacency matrix of the neighbors.
+
+   Returns
+   -------
+   node_weights: np.ndarray
+       Weights of nodes.
+    """
+    n = adjacency.shape[0]
+    distribution = distribution.lower()
+    if distribution == 'degree':
+        node_weights_vec = adjacency.dot(np.ones(adjacency.shape[1]))
+    elif distribution == 'uniform':
+        node_weights_vec = np.ones(n)
+    else:
+        raise ValueError('Unknown distribution of node weights.')
+    return node_weights_vec
+
+
+def check_format(input_matrix: Union[sparse.csr_matrix, sparse.csc_matrix, sparse.coo_matrix, sparse.lil_matrix,
+                                     np.ndarray]) -> sparse.csr_matrix:
+    """Check whether the matrix is a NumPy array or a Scipy sparse matrix and return
+    the corresponding Scipy CSR matrix.
+    """
+    formats = {sparse.csr_matrix, sparse.csc_matrix, sparse.coo_matrix, sparse.lil_matrix, np.ndarray}
+    if type(input_matrix) not in formats:
+        raise TypeError('The input matrix must be in Scipy sparse format or Numpy ndarray format.')
+    input_matrix = sparse.csr_matrix(input_matrix)
+    if input_matrix.nnz == 0:
+        raise ValueError('The input matrix is empty.')
+    return input_matrix
+
+
+def check_is_proba(entry: Union[float, int], name: str = None):
+    """Check whether the number is non-negative and less than or equal to 1."""
+    if name is None:
+        name = 'Probabilities'
+    if type(entry) not in [float, int]:
+        raise TypeError('{} must be floats (or ints if 0 or 1).'.format(name))
+    if entry < 0 or entry > 1:
+        raise ValueError('{} must be between 0 and 1.'.format(name))
+
+
+def check_damping_factor(damping_factor: float):
+    """Check if the damping factor has a valid value."""
+    if damping_factor < 0 or damping_factor >= 1:
+        raise ValueError('A damping factor must have a value in [0, 1[.')
+
+
+def check_weights(weights: Union['str', np.ndarray], adjacency: Union[sparse.csr_matrix, sparse.csc_matrix],
+                  positive_entries: bool = False) -> np.ndarray:
+    """Check whether the weights are a valid distribution for the adjacency and return a probability vector.
+
+    Parameters
+    ----------
+    weights:
+        Probabilities for node sampling in the null model. ``'degree'``, ``'uniform'`` or custom weights.
+    adjacency:
+        The adjacency matrix of the graph.
+    positive_entries:
+        If true, the weights must all be positive, if False, the weights must be non-negative.
+
+    Returns
+    -------
+    node_weights: np.ndarray
+        Valid weights of nodes.
+    """
+    n = adjacency.shape[0]
+    if type(weights) == np.ndarray:
+        if len(weights) != n:
+            raise ValueError('The number of node weights must match the number of nodes.')
+        else:
+            node_weights_vec = weights
+    elif type(weights) == str:
+        node_weights_vec = make_weights(weights, adjacency)
+    else:
+        raise TypeError(
+            'Node weights must be a known distribution ("degree" or "uniform" string) or a custom NumPy array.')
+
+    if positive_entries and not has_positive_entries(node_weights_vec):
+        raise ValueError('All weights must be positive.')
+    else:
+        if np.any(node_weights_vec < 0) or node_weights_vec.sum() <= 0:
+            raise ValueError('Node weights must be non-negative with positive sum.')
+
+    return node_weights_vec
+
+
+def get_probs(weights: Union['str', np.ndarray], adjacency: Union[sparse.csr_matrix, sparse.csc_matrix],
+              positive_entries: bool = False) -> np.ndarray:
+    """Check whether the weights are a valid distribution for the adjacency
+    and return a normalized probability vector.
+    """
+    weights = check_weights(weights, adjacency, positive_entries)
+    return weights / np.sum(weights)
+
+
+def check_random_state(random_state: Optional[Union[np.random.RandomState, int]]):
+    """Check whether the argument is a seed or a NumPy random state. If None, 'numpy.random' is used by default."""
+    if random_state is None:
+        return np.random.RandomState()
+    elif type(random_state) == int:
+        return np.random.RandomState(random_state)
+    elif type(random_state) == np.random.RandomState:
+        return random_state
+    else:
+        raise TypeError('To specify a random state, pass the seed (as an int) or a NumPy random state object.')
+
+
+def check_n_neighbors(n_neighbors: int, n_seeds: int):
+    """Set the number of neighbors so that it does not exceed the number of labeled samples."""
+    if n_neighbors > n_seeds:
+        warnings.warn(Warning("The number of neighbors cannot exceed the number of seeds. Changed accordingly."))
+        n_neighbors = n_seeds
+    return n_neighbors
+
+
+def check_labels(labels: np.ndarray):
+    """Check labels of the seeds for semi-supervised algorithms."""
+
+    classes: np.ndarray = np.unique(labels[labels >= 0])
+    n_classes: int = len(classes)
+
+    if n_classes < 2:
+        raise ValueError('There must be at least two distinct labels.')
+    else:
+        return classes, n_classes
+
+
+def check_n_jobs(n_jobs: Optional[int] = None):
+    """Parse the ``n_jobs`` parameter for multiprocessing."""
+    if n_jobs == -1:
+        return None
+    elif n_jobs is None:
+        return 1
+    else:
+        return n_jobs
+
+
+def check_adjacency_vector(adjacency_vectors: Union[sparse.csr_matrix, np.ndarray],
+                           n: Optional[int] = None) -> sparse.csr_matrix:
+    """Check format of new samples for predict methods"""
+    adjacency_vectors = check_format(adjacency_vectors)
+    if n is not None and adjacency_vectors.shape[1] != n:
+        raise ValueError('The adjacency vector must be of length equal to the number nodes in the graph.')
+    return adjacency_vectors
+
+
+def check_n_clusters(n_clusters: int, n_row: int, n_min: int = 0):
+    """Check that the number of clusters"""
+    if n_clusters > n_row:
+        raise ValueError('The number of clusters exceeds the number of rows.')
+    if n_clusters < n_min:
+        raise ValueError('The number of clusters must be at least {}.'.format(n_min))
+    else:
+        return
+
+
+def check_min_size(n_row, n_min):
+    """Check that an adjacency has the required number of rows and returns an error otherwise."""
+    if n_row < n_min:
+        raise ValueError('The graph must contain at least {} nodes.'.format(n_min))
+    else:
+        return
+
+
+def check_dendrogram(dendrogram):
+    """Check the shape of a dendrogram."""
+    if dendrogram.ndim != 2 or dendrogram.shape[1] != 4:
+        raise ValueError("Dendrogram has incorrect shape.")
+    else:
+        return
+
+
+def check_min_nnz(nnz, n_min):
+    """Check that an adjacency has the required number of edges and returns an error otherwise."""
+    if nnz < n_min:
+        raise ValueError('The graph must contain at least {} edge(s).'.format(n_min))
+    else:
+        return
+
+
+def check_n_components(n_components, n_min) -> int:
+    """Check the number of components"""
+    if n_components > n_min:
+        warnings.warn(Warning("The dimension of the embedding cannot exceed {}. Changed accordingly.".format(n_min)))
+        return n_min
+    else:
+        return n_components
+
+
+def check_scaling(scaling: float, adjacency: sparse.csr_matrix, regularize: bool):
+    """Check the scaling factor"""
+    if scaling < 0:
+        raise ValueError("The 'scaling' parameter must be non-negative.")
+
+    if scaling and (not regularize) and not is_weakly_connected(adjacency):
+        raise ValueError("Positive 'scaling' is valid only if the graph is connected or with regularization."
+                         "Call 'fit' either with 'scaling' = 0 or positive 'regularization'.")
+
+
+def has_boolean_entries(input_matrix: np.ndarray) -> bool:
+    """True if the array has boolean entries."""
+    if type(input_matrix) != np.ndarray:
+        raise TypeError('Entry must be a dense NumPy array.')
+    else:
+        return input_matrix.dtype == 'bool'
+
+
+def check_boolean(input_matrix: np.ndarray):
+    """Check whether the array has positive entries."""
+    if not has_boolean_entries(input_matrix):
+        raise ValueError('Only boolean values are expected.')
+
+
+def check_vector_format(vector_1: np.ndarray, vector_2: np.ndarray):
+    """Check whether the inputs are vectors of same length."""
+    if len(vector_1.shape) > 1 or len(vector_2.shape) > 1:
+        raise ValueError('The arrays must be 1-dimensional.')
+    if vector_1.shape[0] != vector_2.shape[0]:
+        raise ValueError('The arrays do not have the same length.')
+
+
+def has_self_loops(input_matrix: sparse.csr_matrix) -> bool:
+    """True if each node has a self loop."""
+    return all(input_matrix.diagonal().astype(bool))
+
+
+def add_self_loops(adjacency: sparse.csr_matrix) -> sparse.csr_matrix:
+    """Add self loops to adjacency matrix.
+
+    Parameters
+    ----------
+    adjacency : sparse.csr_matrix
+        Adjacency matrix of the graph.
+
+    Returns
+    -------
+    sparse.csr_matrix
+        Adjacency matrix of the graph with self loops.
+    """
+    n_row, n_col = adjacency.shape
+
+    if is_square(adjacency):
+        adjacency = sparse.diags(np.ones(n_col), format='csr') + adjacency
+    else:
+        tmp = sparse.eye(n_row)
+        tmp.resize(n_row, n_col)
+        adjacency += tmp
+
+    return adjacency

sknetwork/utils/co_neighbor.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on October 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.embedding.svd import SVD, GSVD
+from sknetwork.linalg.normalization import normalize
+from sknetwork.utils.check import check_format
+from sknetwork.utils.knn import KNNDense
+
+
+def co_neighbor_graph(adjacency: Union[sparse.csr_matrix, np.ndarray], normalized: bool = True, method='knn',
+                      n_neighbors: int = 5, n_components: int = 8) -> sparse.csr_matrix:
+    """Compute the co-neighborhood adjacency.
+
+    * Graphs
+    * Digraphs
+    * Bigraphs
+
+    :math:`\\tilde{A} = AF^{-1}A^T`,
+
+    where F is a weight matrix.
+
+    Parameters
+    ----------
+    adjacency:
+        Adjacency of the input graph.
+    normalized:
+        If ``True``, F is the diagonal in-degree matrix :math:`F = \\text{diag}(A^T1)`.
+        Otherwise, F is the identity matrix.
+    method:
+        Either ``'exact'`` or ``'knn'``. If 'exact' the output is computed with matrix multiplication.
+        However, the density can be much higher than in the input graph and this can trigger Memory errors.
+        If ``'knn'``, the co-neighborhood is approximated through KNNDense-search in an appropriate spectral embedding
+        space.
+    n_neighbors:
+        Number of neighbors for the KNNDense search. Only useful if ``method='knn'``.
+    n_components:
+        Dimension of the embedding space. Only useful if ``method='knn'``.
+
+    Returns
+    -------
+    adjacency : sparse.csr_matrix
+        Adjacency of the co-neighborhood.
+    """
+    adjacency = check_format(adjacency).astype(float)
+    method = method.lower()
+    if method == 'exact':
+        if normalized:
+            forward = normalize(adjacency.T).tocsr()
+        else:
+            forward = adjacency.T
+        return adjacency.dot(forward)
+
+    elif method == 'knn':
+        if normalized:
+            algo = GSVD(n_components, regularization=None)
+        else:
+            algo = SVD(n_components, regularization=None)
+        embedding = algo.fit_transform(adjacency)
+        knn = KNNDense(n_neighbors, undirected=True)
+        knn.fit(embedding)
+        return knn.adjacency_
+    else:
+        raise ValueError('method must be "exact" or "knn".')

sknetwork/utils/format.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in April 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union, Tuple, Optional
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.linalg.sparse_lowrank import SparseLR
+from sknetwork.utils.check import check_format, is_square, is_symmetric
+from sknetwork.utils.seeds import stack_seeds, get_seeds
+
+
+def check_csr_or_slr(adjacency):
+    """Check if input is csr or SparseLR and raise an error otherwise."""
+    if type(adjacency) not in [sparse.csr_matrix, SparseLR]:
+        raise TypeError('Input must be a scipy CSR matrix or a SparseLR object.')
+
+
+def directed2undirected(adjacency: Union[sparse.csr_matrix, SparseLR],
+                        weighted: bool = True) -> Union[sparse.csr_matrix, SparseLR]:
+    """Adjacency matrix of the undirected graph associated with some directed graph.
+
+    The new adjacency matrix becomes either:
+
+    :math:`A+A^T` (default)
+
+    or
+
+    :math:`\\max(A,A^T)`
+
+    If the initial adjacency matrix :math:`A` is binary, bidirectional edges have weight 2
+    (first method, default) or 1 (second method).
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix.
+    weighted :
+        If ``True``, return the sum of the weights in both directions of each edge.
+
+    Returns
+    -------
+    new_adjacency :
+        New adjacency matrix (same format as input).
+    """
+    check_csr_or_slr(adjacency)
+    if type(adjacency) == sparse.csr_matrix:
+        if weighted:
+            if adjacency.data.dtype == float:
+                data_type = float
+            else:
+                data_type = int
+            new_adjacency = adjacency.astype(data_type)
+            new_adjacency += adjacency.T
+        else:
+            new_adjacency = (adjacency + adjacency.T).astype(bool)
+        new_adjacency.tocsr().sort_indices()
+        return new_adjacency
+    else:
+        if weighted:
+            new_tuples = [(y, x) for (x, y) in adjacency.low_rank_tuples]
+            return SparseLR(directed2undirected(adjacency.sparse_mat), adjacency.low_rank_tuples + new_tuples)
+        else:
+            raise ValueError('This function only works with ``weighted=True`` for SparseLR objects.')
+
+
+def bipartite2directed(biadjacency: Union[sparse.csr_matrix, SparseLR]) -> Union[sparse.csr_matrix, SparseLR]:
+    """Adjacency matrix of the directed graph associated with a bipartite graph
+    (with edges from one part to the other).
+
+    The returned adjacency matrix is:
+
+    :math:`A  = \\begin{bmatrix} 0 & B \\\\ 0 & 0 \\end{bmatrix}`
+
+    where :math:`B` is the biadjacency matrix.
+
+    Parameters
+    ----------
+    biadjacency :
+        Biadjacency matrix of the graph.
+
+    Returns
+    -------
+    adjacency :
+        Adjacency matrix (same format as input).
+    """
+    check_csr_or_slr(biadjacency)
+    n_row, n_col = biadjacency.shape
+    if type(biadjacency) == sparse.csr_matrix:
+        adjacency = sparse.bmat([[None, biadjacency], [sparse.csr_matrix((n_col, n_row)), None]], format='csr')
+        adjacency.sort_indices()
+        return adjacency
+    else:
+        new_tuples = [(np.hstack((x, np.zeros(n_col))), np.hstack((np.zeros(n_row), y)))
+                      for (x, y) in biadjacency.low_rank_tuples]
+        return SparseLR(bipartite2directed(biadjacency.sparse_mat), new_tuples)
+
+
+def bipartite2undirected(biadjacency: Union[sparse.csr_matrix, SparseLR]) -> Union[sparse.csr_matrix, SparseLR]:
+    """Adjacency matrix of a bigraph defined by its biadjacency matrix.
+
+    The returned adjacency matrix is:
+
+    :math:`A  = \\begin{bmatrix} 0 & B \\\\ B^T & 0 \\end{bmatrix}`
+
+    where :math:`B` is the biadjacency matrix of the bipartite graph.
+
+    Parameters
+    ----------
+    biadjacency:
+        Biadjacency matrix of the graph.
+
+    Returns
+    -------
+    adjacency :
+        Adjacency matrix (same format as input).
+    """
+    check_csr_or_slr(biadjacency)
+    if type(biadjacency) == sparse.csr_matrix:
+        adjacency = sparse.bmat([[None, biadjacency], [biadjacency.T, None]], format='csr')
+        adjacency.sort_indices()
+        return adjacency
+    else:
+        n_row, n_col = biadjacency.shape
+        new_tuples = []
+        for (x, y) in biadjacency.low_rank_tuples:
+            new_tuples.append((np.hstack((x, np.zeros(n_col))), np.hstack((np.zeros(n_row), y))))
+            new_tuples.append((np.hstack((np.zeros(n_row), y)), np.hstack((x, np.zeros(n_col)))))
+        return SparseLR(bipartite2undirected(biadjacency.sparse_mat), new_tuples)
+
+
+def get_adjacency(input_matrix: Union[sparse.csr_matrix, np.ndarray], allow_directed: bool = True,
+                  force_bipartite: bool = False, force_directed: bool = False)\
+        -> Tuple[sparse.csr_matrix, bool]:
+    """Check the input matrix and return a proper adjacency matrix.
+    Parameters
+    ----------
+    input_matrix :
+        Adjacency matrix of biadjacency matrix of the graph.
+    allow_directed :
+        If ``True`` (default), allow the graph to be directed.
+    force_bipartite : bool
+        If ``True``, return the adjacency matrix of a bipartite graph.
+        Otherwise (default), do it only if the input matrix is not square or not symmetric
+        with ``allow_directed=False``.
+    force_directed :
+        If ``True`` return :math:`A  = \\begin{bmatrix} 0 & B \\\\ 0 & 0 \\end{bmatrix}`.
+        Otherwise (default), return :math:`A  = \\begin{bmatrix} 0 & B \\\\ B^T & 0 \\end{bmatrix}`.
+    """
+    input_matrix = check_format(input_matrix)
+    bipartite = False
+    if force_bipartite or not is_square(input_matrix) or not (allow_directed or is_symmetric(input_matrix)):
+        bipartite = True
+    if bipartite:
+        if force_directed:
+            adjacency = bipartite2directed(input_matrix)
+        else:
+            adjacency = bipartite2undirected(input_matrix)
+    else:
+        adjacency = input_matrix
+    return adjacency, bipartite
+
+
+def get_adjacency_seeds(input_matrix: Union[sparse.csr_matrix, np.ndarray], allow_directed: bool = True,
+                        force_bipartite: bool = False, force_directed: bool = False,
+                        seeds: Optional[Union[dict, np.ndarray]] = None,
+                        seeds_row: Optional[Union[dict, np.ndarray]] = None,
+                        seeds_col: Optional[Union[dict, np.ndarray]] = None,
+                        default_value: float = -1,
+                        which: Optional[str] = None) \
+        -> Tuple[sparse.csr_matrix, np.ndarray, bool]:
+    """Check the input matrix and return a proper adjacency matrix with seeds.
+    Parameters
+    ----------
+    input_matrix :
+        Adjacency matrix of biadjacency matrix of the graph.
+    allow_directed :
+        If ``True`` (default), allow the graph to be directed.
+    force_bipartite : bool
+        If ``True``, return the adjacency matrix of a bipartite graph.
+        Otherwise (default), do it only if the input matrix is not square or not symmetric
+        with ``allow_directed=False``.
+    force_directed :
+        If ``True`` return :math:`A  = \\begin{bmatrix} 0 & B \\\\ 0 & 0 \\end{bmatrix}`.
+        Otherwise (default), return :math:`A  = \\begin{bmatrix} 0 & B \\\\ B^T & 0 \\end{bmatrix}`.
+    seeds :
+        Values of seed nodes in initial state (dictionary or vector). Negative values ignored.
+    seeds_row, seeds_col :
+        Values of rows and columns for bipartite graphs. Negative values ignored.
+    default_value :
+        Value of non-seed nodes (default = -1).
+    which :
+        Which seed values.
+        If ``'probs'``, return a probability distribution.
+        If ``'labels'``, return distinct integer values if all are equal.
+    """
+    input_matrix = check_format(input_matrix)
+    if seeds_row is not None or seeds_col is not None:
+        force_bipartite = True
+    adjacency, bipartite = get_adjacency(input_matrix, allow_directed=allow_directed,
+                                         force_bipartite=force_bipartite, force_directed=force_directed)
+    if bipartite:
+        if seeds is None:
+            seeds = stack_seeds(input_matrix.shape, seeds_row, seeds_col, default_value=default_value)
+        else:
+            seeds = stack_seeds(input_matrix.shape, seeds, default_value=default_value)
+    else:
+        seeds = get_seeds(input_matrix.shape, seeds, default_value=default_value)
+    if which == 'probs':
+        if seeds.sum() > 0:
+            seeds /= seeds.sum()
+    elif which == 'labels':
+        if len(set(seeds[seeds >= 0])) == 1:
+            seeds = np.arange(len(seeds))
+    return adjacency, seeds, bipartite