Benchmark Results

We benchmarked 8 algorithms across 5 real-world datasets plus 1 scale test. Every dataset is a genuine academic benchmark from SNAP, Planetoid, or DGL. Cleora wins on accuracy on every single dataset while using 10–24x less memory than accuracy-competitive methods. Dense and random-walk methods fail catastrophically on larger graphs.

ego-Facebook (4,039 nodes, 18 Louvain communities)

Facebook ego network from SNAP (~4K nodes, ~88K edges). Community labels detected via Louvain. All 8 algorithms benchmarked with 256-dimensional embeddings:

Cora (2,708 nodes, 7 classes)

Citation network from Planetoid (Yang et al., 2016). 2,708 ML papers across 7 subject areas, 10,858 citation edges:

CiteSeer (3,312 nodes, 6 classes)

Citation network from Planetoid. 3,312 CS papers across 6 subject areas, 9,464 citation edges:

PubMed (19,717 nodes, 3 classes)

Citation network from Planetoid. 19,717 diabetes papers across 3 categories, 88,676 citation edges:

PPI (3,890 nodes, 50 classes)

Protein-protein interaction graph. 3,890 proteins, 76,584 edges, 50 functional classes:

roadNet-CA (1,965,206 nodes, speed/memory only)

California road network from SNAP (~2M nodes, ~5.5M edges). No ground-truth community labels, so only speed and memory metrics are reported:

When to Use What

Methodology

Datasets

All datasets are downloaded from their canonical academic sources at runtime. No synthetic data is used.

• ego-Facebook (4,039 nodes, 88,234 edges) — from SNAP. Labels: Louvain community detection (18 communities, seed=42).
• Cora (2,708 nodes, 5,429 edges, 7 classes) — from Planetoid (Yang et al., ICML 2016). Labels: paper category.
• CiteSeer (3,312 nodes, 4,732 edges, 6 classes) — from Planetoid. Labels: paper category.
• PubMed (19,717 nodes, 44,338 edges, 3 classes) — from Planetoid. Labels: paper category.
• PPI (3,890 nodes, 76,584 edges, 50 classes) — from DGL (Zitnik & Leskovec, Bioinformatics 2017). Labels: protein functional class.
• roadNet-CA (1,965,206 nodes, 5,533,214 edges) — from SNAP. Scale test only, no classification labels.

Input Representation

All algorithms operate on pure graph topology — the adjacency structure only. No node features, no attribute vectors, no side information. Every algorithm receives the identical edge list and nothing else. This tests each method's ability to extract structure from connectivity alone.

Algorithms & Parameters

• Eight algorithms compared: Cleora, ProNE, RandNE, HOPE, NetMF, GraRep, DeepWalk, and Node2Vec.
• All algorithms produce 256-dimensional embeddings.
• Cleora uses 40 iterations with left Markov normalization and interleaved whitening.
• All competing algorithms use their default hyperparameters with no dataset-specific tuning.

Classifier & Evaluation Protocol

Every algorithm is evaluated with the identical classifier on the identical data split. No algorithm receives a different or more powerful evaluator.

• Classifier: Nearest Centroid with cosine similarity. For each class, the centroid is the L2-normalized mean of training embeddings. Test nodes are assigned to the class of the nearest centroid. This is not an MLP, not logistic regression, and not a learned classifier — it is a parameter-free geometric assignment.
• Train/test split: 80/20 random split, deterministic seed=42, applied identically to all algorithms.
• Metrics: Accuracy and Macro F1 (unweighted average across all classes).
• Runs: Single deterministic run per algorithm per dataset (seed=42). Deterministic seeding ensures exact reproducibility.

Hardware & Resource Constraints

• All benchmarks run on a single shared vCPU core with approximately 3 GB RAM in a constrained Replit cloud environment.
• Timing: wall-clock time from graph load to embedding output.
• Memory: peak allocation tracked via Python's tracemalloc.
• Timeout: 90 seconds. Any algorithm exceeding this is marked "Timed Out."
• OOM: process killed by the OS when exceeding available memory.
• Competitors that fail here may succeed on larger hardware — but that is the point: Cleora delivers state-of-the-art results under extreme resource constraints where other algorithms cannot even complete.

pip install pycleora

python -c "
import pycleora
from pycleora import SparseMatrix, datasets, metrics

ds = datasets.load_dataset('cora')
graph = SparseMatrix.from_iterator(iter(ds['edges']), ds['columns'])
emb = pycleora.embed(graph)
print(metrics.node_classification_scores(graph, emb, ds['labels']))
"