def run_leiden(
graph: sp.coo_matrix,
directed: bool,
partition_type: Optional[Type[MutableVertexPartition]],
resolution_parameter: float,
n_iterations: int,
seed: Optional[int],
use_weights: bool,
kargs,
) -> Tuple[np.ndarray, float]:
"""
Wrapper for leiden community detection
Args:
graph (sp.coo_matrix): Affinity matrix
directed (bool): See below in 'cluster()'
partition_type (Optional[Type[MutableVertexPartition]]): See below in 'cluster()'
resolution_parameter (float): See below in 'cluster()'
n_iterations (int): See below in 'cluster()'
seed (Optional[int]): See below in 'cluster()'
use_weights (bool): See below in 'cluster()'
kargs: See below in 'cluster()'
Returns:
communities, Q (Tuple[np.ndarray, float]): See below in 'cluster()'
"""
# convert resulting graph from scipy.sparse.coo.coo_matrix to Graph object
# get indices of vertices
edgelist = np.vstack(graph.nonzero()).T.tolist()
g = ig.Graph(max(graph.shape), edgelist, directed=directed)
# set vertices as weights
g.es["weights"] = graph.data
if not partition_type:
partition_type = leidenalg.RBConfigurationVertexPartition
if resolution_parameter:
kargs["resolution_parameter"] = resolution_parameter
if use_weights:
kargs["weights"] = np.array(g.es["weights"]).astype("float64")
kargs["n_iterations"] = n_iterations
kargs["seed"] = seed
print("Running Leiden optimization", flush=True)
tic_ = time.time()
communities = leidenalg.find_partition(
g,
partition_type=partition_type,
**kargs,
)
Q = communities.q
print(
"Leiden completed in {} seconds".format(time.time() - tic_),
flush=True,
)
communities = np.asarray(communities.membership)
return communities, Q
def _build_feat_tensor(self,
feat_matrix: sp.coo_matrix,
device: Optional[T.device] = T.device('cpu')):
feat_index_list = feat_matrix.nonzero()
feat_index_array: np.ndarray = np.vstack(feat_index_list)
feat_index = T.tensor(feat_index_array.tolist(),
dtype=T.long,
device=device)
feat_value = T.tensor(feat_matrix.data, dtype=T.double, device=device)
feat_tensor = T.sparse_coo_tensor(feat_index,
feat_value,
size=feat_matrix.shape,
device=device)
return feat_tensor