What Is the Leiden Algorithm? A Complete 2026 Guide to Community Detection in Networks
- Muiz As-Siddeeqi
- 3 days ago
- 31 min read
Every day, researchers analyze billions of connections—from cells in your body to friendships on social media. They face a massive challenge: how do you find meaningful groups in these tangled webs of relationships? For years, scientists relied on the Louvain algorithm to solve this puzzle. Then, in 2019, a team at Leiden University discovered something alarming: Louvain was breaking networks into poorly connected pieces, sometimes splitting communities that should stay together. Their solution—the Leiden algorithm—has since transformed how we understand everything from cancer cells to online communities. With over 4,000 citations in just five years (Scite, 2024), this algorithm is quietly reshaping science.
Don’t Just Read About AI — Own It. Right Here
TL;DR
The Leiden algorithm finds natural groups (communities) in network data by analyzing how nodes connect
Created in 2019 by Vincent Traag, Ludo Waltman, and Nees Jan van Eck at Leiden University
Fixes critical flaws in the popular Louvain algorithm that produced disconnected communities
Guarantees all communities stay connected and runs faster than its predecessor
Widely used in biology (analyzing millions of cells), social networks, cybersecurity, and machine learning
Powers major software tools like Scanpy (single-cell analysis), igraph, and NetworkX
Processing speeds now reach 403 million edges per second on modern hardware (Sahu et al., 2024)
The Leiden algorithm is a community detection method that identifies natural groups within network data. It finds clusters of highly connected nodes—like cells, people, or systems—by optimizing modularity while guaranteeing all communities remain connected. Published in Scientific Reports in March 2019, it improves upon the Louvain algorithm's tendency to create disconnected communities.
Table of Contents
Background & Definitions
Summary: Understanding the Leiden algorithm starts with grasping what community detection means and why networks matter in modern science.
What Is a Network?
A network (or graph) consists of nodes (also called vertices) and edges (connections between nodes). Think of nodes as dots and edges as lines connecting them. These structures appear everywhere:
Social networks: People are nodes; friendships are edges
Biological networks: Proteins are nodes; interactions are edges
Internet infrastructure: Servers are nodes; cables are edges
What Is Community Detection?
Community detection identifies groups of nodes that connect more densely to each other than to the rest of the network. Imagine a high school: students naturally cluster into friend groups based on shared interests or classes. Community detection algorithms find these patterns automatically.
According to Fortunato (2010), community detection "reveals the organization of networks into modules or communities of densely interconnected nodes." This organizational structure helps scientists understand how complex systems function.
The Modularity Concept
Most community detection algorithms—including Leiden—optimize something called modularity. Modularity measures how well a network divides into communities by comparing actual connections within communities to what you'd expect from random chance.
Newman and Girvan (2004) defined modularity mathematically. Higher modularity scores mean stronger community structure. The challenge: maximizing modularity while ensuring communities make biological, social, or physical sense.
Why Networks Grew Massive
In 2010, analyzing a network with 100,000 nodes was impressive. By 2024, researchers routinely work with networks containing millions or billions of edges. Single-cell RNA sequencing studies now analyze 10+ million cells simultaneously (Liu et al., 2023). This scale demands algorithms that work fast without sacrificing quality.
The Problem Leiden Solves
Summary: The Leiden algorithm addresses serious flaws in the Louvain method that researchers discovered through careful analysis of network structure.
Louvain's Hidden Weakness
For nearly a decade after its 2008 introduction, the Louvain algorithm dominated community detection. Fast and effective, it became the default choice in software packages worldwide. Then Traag and colleagues noticed something disturbing.
When they examined Louvain's output on various networks, they found that up to 25% of identified communities were badly connected (Traag et al., 2019, Scientific Reports). Worse still, up to 16% were completely disconnected—meaning nodes in the "same community" couldn't actually reach each other through internal connections.
The Bridge Node Problem
Here's what happens: During its node-moving phase, Louvain sometimes places "bridge nodes" (nodes connecting two dense regions) into larger neighboring communities for better modularity scores. This greedy choice can fragment the original community into disconnected pieces.
Imagine a neighborhood where one house sits between two main streets. If an algorithm assigns that house to the bigger street's group, it can split the smaller street's community in half. People on opposite ends can't visit each other without leaving their "community."
Why This Matters
Disconnected communities undermine the entire purpose of community detection. If you're:
Studying disease spread: Disconnected groups suggest false isolation
Analyzing social movements: You miss how information actually flows
Identifying cell types: You may incorrectly classify cells that behave differently
The consequences ripple through research conclusions, potentially invalidating findings based on flawed community assignments.
Resolution Limit Problems
Modularity optimization has another issue called the resolution limit. When maximizing modularity, small communities sometimes merge into larger ones even when they're clearly separate groups (Fortunato and Barthélemy, 2007). The Leiden algorithm addresses this through its quality functions and resolution parameters.
How the Leiden Algorithm Works
Summary: Leiden adds a crucial refinement step between the moving and aggregation phases, plus it uses smarter node ordering to guarantee connected communities.
Three Main Phases
The Leiden algorithm follows a hierarchical approach with three key phases per iteration:
Phase 1: Local Moving
Nodes move to neighboring communities if doing so improves the quality function (typically modularity). Unlike Louvain, Leiden uses a queue-based system that only considers nodes likely to improve the partition.
The algorithm visits nodes in random order initially. After the first iteration, it prioritizes nodes that changed communities or whose neighbors changed communities. This smart ordering dramatically speeds up convergence.
Phase 2: Refinement (The Key Innovation)
This is where Leiden diverges from Louvain. After the moving phase, Leiden examines each community individually. It creates subcommunities within each community, starting with singleton partitions where every node is its own subcommunity.
Nodes can only merge with other nodes in the same community from Phase 1. This constraint prevents the disconnection problem because nodes can't jump to distant communities and leave orphaned fragments behind.
The refinement phase uses randomized moves with probabilities proportional to modularity gain. Some implementations use a greedy approach instead, which research shows performs slightly better on average (Sahu, 2023).
Phase 3: Aggregation
Communities identified in the refined partition become super-nodes in a new, smaller network. Edges between these super-nodes represent the sum of connections between their constituent original nodes.
This aggregated network feeds into the next iteration's Phase 1, creating a hierarchical view of community structure.
When Does It Stop?
The algorithm continues iterating until reaching stability—when no further improvements occur. At this point, the partition is "node optimal" and "subpartition γ-dense," meaning every node sits in the best possible community given the current structure (Traag et al., 2019).
For most real-world networks, Leiden typically needs 5-10 iterations to converge. The original paper reported that networks reached stable partitions after a median of 6 iterations (Traag et al., 2019, Scientific Reports).
The Quality Function
While the algorithm framework is general, most implementations use the Reichardt-Bornholdt (RB) Potts model with a resolution parameter γ (gamma). This quality function generalizes modularity:
Q = Σ [Aᵢⱼ - γ(kᵢkⱼ)/(2m)] δ(cᵢ, cⱼ)
Where:
Aᵢⱼ = weight of edge between nodes i and j
kᵢ = degree (total edge weight) of node i
m = total edge weight in network
γ = resolution parameter
δ(cᵢ, cⱼ) = 1 if nodes i and j are in the same community, 0 otherwise
Higher γ values produce more, smaller communities. Lower values produce fewer, larger communities. The default γ = 1 approximates traditional modularity.
Mathematical Foundation
Summary: Leiden's mathematical guarantees distinguish it from heuristic approaches by proving that communities stay connected and locally optimal.
Theoretical Guarantees
The 2019 paper by Traag, Waltman, and van Eck proved several important properties:
Guarantee 1: Connected Communities Every community produced by Leiden is guaranteed to be connected. You can trace a path from any node to any other node within the same community using only internal edges.
Guarantee 2: Well-Separated Communities All communities are well-separated from each other. There's a clear distinction between internal and external connections.
Guarantee 3: Local Optimality When Leiden reaches stability, every node is locally optimally assigned—moving it to any neighboring community would decrease the quality function.
Guarantee 4: Subset Optimality Asymptotically, all subsets of all communities are locally optimally assigned. This means even splitting communities in various ways won't improve the overall quality.
Computational Complexity
The time complexity of Leiden is O(m log n) for a network with n nodes and m edges, similar to Louvain. However, Leiden typically runs faster in practice because:
The queue-based node visiting reduces unnecessary checks
The refinement phase quickly identifies stable partitions
Better initial partitions speed up subsequent iterations
Traag et al. (2019) showed Leiden was faster than Louvain on 6 benchmark networks, with speedups ranging from 1.2x to 2.5x depending on network structure.
The CPM Alternative
Besides the RB model, Leiden supports the Constant Potts Model (CPM). CPM uses an absolute resolution parameter that doesn't depend on network size, making it more consistent across different networks.
The CPM quality function is:
Q = Σ [Aᵢⱼ - γ] δ(cᵢ, cⱼ)
This formulation treats γ as a minimum edge density threshold for communities, making interpretation more intuitive in some contexts.
Performance & Speed
Summary: Recent implementations have pushed Leiden's speed to extraordinary levels, processing billions of edges in minutes on modern hardware.
Baseline Performance
The original leidenalg Python implementation (Traag, 2019) processes networks at respectable speeds, handling millions of edges in seconds on standard hardware. It became the reference implementation widely used in the scientific community.
Parallel Implementations
Several research teams have developed highly optimized parallel versions:
GVE-Leiden (2024) Subhajit Sahu and colleagues at Indian Institute of Technology created GVE-Leiden, a multicore implementation that achieved remarkable benchmarks:
403 million edges per second on a 3.8 billion edge graph
8.2x faster than NetworKit Leiden
3.0x faster than cuGraph Leiden (running on NVIDIA A100 GPU)
1.6x speedup for every doubling of threads
The team tested on dual 16-core Intel Xeon Gold 6226R processors (Sahu et al., 2024, Proceedings of the 53rd International Conference on Parallel Processing).
NetworKit Leiden The NetworKit toolkit, designed for large-scale network analysis, includes an optimized Leiden implementation. While slower than GVE-Leiden, it integrates well with the broader NetworKit ecosystem for comprehensive network analysis (Staudt et al., 2016).
cuGraph Leiden NVIDIA's cuGraph library offers GPU-accelerated Leiden clustering. It leverages the parallel architecture of modern GPUs, though GVE-Leiden's CPU implementation proved faster in head-to-head comparisons on the same networks (Sahu et al., 2024).
Dynamic Network Updates
Real-world networks change constantly—friendships form, neurons fire, transactions occur. Running Leiden from scratch each time is wasteful. Recent research explored dynamic variants:
The Dynamic Frontier (DF) approach tracks which parts of the network changed and only reprocesses affected regions. On networks with batch updates, DF Leiden achieved speedups of 1.37x on synthetic networks and 1.09x on real dynamic networks compared to recomputing from scratch (Sahu, 2024, arXiv:2405.11658).
However, these speedups are modest because Leiden must still run subsequent passes completely to maintain quality. Future optimizations may improve dynamic performance further.
Scalability Limits
While Leiden handles massive networks well, practical limits exist:
Memory: The adjacency matrix or edge list must fit in RAM
Convergence: Some networks require many iterations, increasing runtime
Resolution: Very fine-grained communities in enormous networks strain even optimized implementations
For networks exceeding 10 million cells, alternative methods like Secuer have shown advantages. Secuer processed a 10 million cell dataset in 2 minutes—6x faster than k-means—though Leiden and Louvain faced challenges with these ultra-large datasets (Liu et al., 2023, arXiv:2205.12432).
Real-World Applications
Summary: Leiden's versatility extends across disciplines, from understanding cellular biology to detecting cybersecurity threats and analyzing social movements.
Single-Cell Biology
The Leiden algorithm has become the default clustering method for single-cell RNA sequencing (scRNA-seq) analysis. This field exploded in the 2010s, enabling scientists to measure gene expression in individual cells rather than tissue averages.
Why Single-Cell Needs Clustering A typical experiment generates data from hundreds of thousands to millions of cells. Cells cluster naturally by type—immune cells, neurons, epithelial cells. Finding these clusters reveals:
Unknown cell types
Disease-specific cell states
Developmental trajectories
Tissue organization
Software Integration Scanpy, the most popular Python package for single-cell analysis, integrated Leiden in 2019. The function scanpy.tl.leiden() has become standard in analysis pipelines (Wolf et al., 2018). Researchers typically run it after dimensionality reduction with PCA and UMAP:
sc.pp.neighbors(adata, n_neighbors=15, n_pcs=50)
sc.tl.leiden(adata, resolution=1.0)
sc.pl.umap(adata, color='leiden')Seurat, the equivalent R package, also adopted Leiden as the preferred method over Louvain. A 2024 comparison study found Leiden comparable to or better than Infomap and superior to WGCNA for cell type identification (bioRxiv, 2024).
Social Network Analysis
Online platforms generate massive social graphs. Facebook had 3.07 billion monthly active users in 2024. Twitter/X processes billions of connections. LinkedIn exceeds 1 billion members. Understanding community structure in these networks helps:
Detect coordinated campaigns: Groups spreading misinformation
Identify influencers: Key nodes in information spread
Understand polarization: Echo chambers and filter bubbles
Optimize recommendations: Suggesting relevant content or connections
A 2024 study used Leiden coloring (Leiden plus graph coloring techniques) to detect influential users in Twitter conversations about Indonesian airlines. Compared to Louvain coloring, Leiden increased modularity by 0.0306 and reduced processing time by 14.48 seconds (IJACSA, 2024).
Another study analyzed Twitter communities during the 2022 Ukraine war, using Leiden to map information ecosystems and identify polarized groups (Sliwa et al., 2024).
Cybersecurity
Networks model cyber threats: computers as nodes, connections as potential attack vectors. Community detection reveals:
Attack patterns: How malware spreads through systems
Botnet structures: Command-and-control hierarchies
Blockchain analysis: Detecting fraudulent transactions
Cyber resilience: Testing how network structure withstands attacks
Erfan et al. (2023) used Leiden to detect attacks in blockchain systems by analyzing transaction networks. Chernikova et al. (2022) studied cyber network resilience against self-propagating malware, using community structure to identify vulnerable network regions.
Transportation and Urban Planning
Transportation networks—roads, rail, flights—form communities based on travel patterns. Leiden helps planners:
Identify natural transit zones
Optimize service routes
Understand commuter behavior
Plan infrastructure investments
Chen et al. (2023) analyzed transportation trends using Leiden to partition road networks into functional regions. Verhetsel et al. (2022) studied regional retail patterns, identifying shopping zones and customer catchment areas.
Microservices Architecture
In software engineering, large applications split into microservices—small, independent components that communicate via APIs. Deciding how to decompose a monolithic application is challenging. Leiden applied to service call graphs can suggest natural boundaries.
Cao and Zhang (2022) developed a method for automating microservice decomposition using community detection. Their approach identifies cohesive service groups, reducing inter-service communication overhead.
Protein Interaction Networks
Proteins rarely work alone. They form complexes and pathways to perform cellular functions. Protein-protein interaction (PPI) networks map these relationships. Leiden identifies functional modules—groups of proteins working together.
These modules often correspond to:
Metabolic pathways
Signal transduction cascades
Structural complexes
Regulatory circuits
Understanding these modules helps drug designers target entire pathways rather than individual proteins, potentially improving efficacy.
Case Studies
Summary: Three detailed examples show how Leiden transformed research outcomes in medicine, biology, and spatial analysis.
Case Study 1: Cancer Cell Heterogeneity in Melanoma (2023)
Publication: LP_SGL: Identifying phenotype-associated subpopulations through integration (Nature Communications, 2024)
Challenge: Cancer isn't uniform. Even within one tumor, cells differ dramatically. These subpopulations respond differently to treatment. Identifying which cells resist immunotherapy could guide personalized medicine.
Approach: Researchers combined single-cell RNA sequencing with bulk tumor data and clinical outcomes from melanoma patients receiving immune checkpoint blockade (ICB) therapy. They used Leiden to identify 17 cell groups in the single-cell data.
Resolution: The algorithm partitioned 16,291 cells into communities representing distinct cell types and states. They then developed LP_SGL, a method using these Leiden-defined groups to identify treatment-responsive cells.
Results: LP_SGL identified a higher percentage of cancer cells and tumor-associated cells compared to competing methods (Scissor and scAB). The approach worked across three independent validation datasets.
Genes from LP_SGL+ cells showed enrichment in immune response processes and suppression of lipid transport—consistent with previous research showing lipid transport inhibition reduces melanoma growth and invasion (PMC, 2024).
Impact: This work demonstrates how Leiden's community structure improves integration of single-cell and bulk data, with direct clinical relevance for predicting treatment response.
Case Study 2: Human Bone Marrow Cell Atlas (2024)
Publication: Leiden Clustering Based on Single-cell Sequencing Data of Human Bone Marrow (ResearchGate, 2024)
Challenge: Bone marrow contains dozens of cell types at various maturation stages. Previous bulk sequencing averaged these together, hiding rare cell populations and developmental states. Single-cell sequencing generates overwhelming data—how do you reliably identify all cell types?
Approach: Scientists sequenced bone marrow samples, generating expression profiles for hundreds of thousands of cells. They applied dimensionality reduction (PCA) followed by Leiden clustering with varying resolution parameters.
Resolution: Starting with 50 principal components, they built a k-nearest-neighbor graph (k=15). Leiden partitioned this graph into communities representing cell types and subtypes. They tested multiple resolution values to balance granularity and biological meaning.
Results: The analysis revealed expected cell types (various blood cell lineages) plus rare populations and transitional states. The hierarchical nature of Leiden's output showed relationships between cell types—for example, how progenitor cells differentiate into mature blood cells.
Impact: The work contributed to reference atlases of human bone marrow, improving our understanding of normal blood production and blood cancers like leukemia. The clustering reproducibility across samples validated Leiden's reliability for clinical applications.
Case Study 3: Spatial Transcriptomics in Tissue Architecture (2025)
Publication: SpatialLeiden: spatially aware Leiden clustering (Genome Biology, February 2025)
Challenge: New technologies measure gene expression while preserving spatial location within tissues. This adds a dimension missing from standard single-cell analysis. Cells don't exist in isolation—their physical neighbors matter. How do you cluster cells considering both molecular similarity and spatial proximity?
Approach: Researchers integrated spatial coordinates into Leiden's distance calculations. Instead of building k-nearest-neighbor graphs purely on gene expression, they weighted edges by spatial distance. Nearby cells received stronger connections.
This "SpatialLeiden" variant identifies spatially contiguous communities—tissue regions where cells share both molecular profiles and physical location.
Resolution: Applied to spatial transcriptomics datasets from multiple tissues, SpatialLeiden outperformed traditional "non-spatial" clustering and compared favorably with dedicated spatial methods. It identified anatomically meaningful domains—layers in cortex, zones in liver, regions in tumors.
Results: The spatial-aware approach revealed organization invisible to molecular clustering alone. In brain tissue, it distinguished cortical layers. In tumors, it identified the invasive edge versus core. These spatial domains correlated with functional differences and clinical outcomes.
Impact: This work shows Leiden's flexibility—its framework accommodates spatial information without extensive modification. As spatial omics grows, such methods become critical for understanding tissue organization in health and disease (Genome Biology, 2025).
Software Implementations
Summary: Multiple high-quality implementations make Leiden accessible across programming languages and use cases, from interactive analysis to production systems.
Python Implementations
leidenalg (Official) Created by Vincent Traag, the original author, leidenalg is the reference implementation. Written in C++ with Python bindings, it supports:
Multiple quality functions (Modularity, CPM, Surprise, Significance)
Multiplex networks
Partially fixed partitions
Bipartite networks
Installation: pip install leidenalg
The package requires python-igraph for graph structures. While highly flexible, it's not the fastest option for extremely large networks.
Scanpy Integration Scanpy wraps leidenalg specifically for single-cell analysis:
import scanpy as sc
sc.tl.leiden(adata, resolution=1.0, random_state=42)This integration handles data preprocessing and visualization, making Leiden accessible to biologists without deep programming knowledge.
igraph Native Implementation Python-igraph (version 0.8.0+, released 2020) includes its own Leiden implementation in C:
import igraph as ig
partition = graph.community_leiden(resolution_parameter=1.0)This implementation is substantially faster than leidenalg on large graphs—33 minutes versus 14 hours on a 1.85 million cell dataset (GitHub Issue #1053, 2020). However, it offers fewer configuration options.
R Implementations
leiden Package The leiden R package provides an interface to leidenalg:
library(leiden)
library(igraph)
partition <- leiden(graph, resolution_parameter = 1.0)Seurat Integration Seurat, the dominant R package for single-cell analysis, uses leiden as its default clustering algorithm:
library(Seurat)
seurat_obj <- FindClusters(seurat_obj, resolution = 0.8, algorithm = 4)Algorithm 4 specifies Leiden (algorithm 1 is Louvain for comparison).
Other Languages
Julia The Graphs.jl ecosystem has community detection functions, though Leiden adoption is less mature than in Python/R.
Java No widely-used native Java implementation exists. Researchers typically call Python implementations from Java via JPype or similar bridges.
C++ The core libleidenalg library is written in C++. Developers can link against it directly for maximum performance in native applications.
Cloud and Distributed Systems
Apache Spark Graph processing on Spark typically uses GraphX or GraphFrames. While Louvain implementations exist, Leiden support is limited. Some organizations have internal implementations for large-scale distributed clustering.
RAPIDS cuGraph NVIDIA's RAPIDS ecosystem includes cuGraph, which implemented GPU-accelerated Leiden in 2020. It leverages CUDA for parallel processing but was outperformed by optimized CPU implementations like GVE-Leiden in some benchmarks.
Choosing an Implementation
For most users:
Single-cell biology: Use Scanpy (Python) or Seurat (R)
General network analysis: Use igraph's native implementation for speed
Research/experimentation: Use leidenalg for flexibility
Production systems with massive graphs: Consider GVE-Leiden or custom optimizations
Leiden vs Louvain: Key Differences
Summary: Leiden improves Louvain in three critical ways: guaranteed connectivity, better quality, and faster convergence.
Comparison Table
Feature | Louvain | Leiden |
Publication Year | 2008 | 2019 |
Phases per Iteration | 2 (Move, Aggregate) | 3 (Move, Refine, Aggregate) |
Connected Communities | No guarantee | Guaranteed |
Disconnected Communities (Observed) | Up to 16% | 0% |
Badly Connected Communities | Up to 25% | 0% |
Speed (Relative) | Baseline | 1.2x - 2.5x faster |
Convergence | Can get stuck | Converges to local optimum |
Node Visiting Order | All nodes each pass | Queue-based, smart ordering |
Refinement Phase | None | Yes, prevents disconnection |
Local Optimality | Not guaranteed | Guaranteed |
Subset Optimality | No | Yes (asymptotically) |
Software Maintenance | Deprecated in many packages | Actively maintained |
Typical Applications | Legacy systems | New research, production systems |
When Louvain Still Makes Sense
Despite Leiden's advantages, Louvain remains relevant in specific scenarios:
Legacy Systems: Code written before 2019 may use Louvain without issues if disconnected communities don't critically affect analysis
Educational Settings: Louvain's simpler two-phase structure makes it easier to explain and implement from scratch
Comparative Baselines: Research papers often include Louvain results to show improvement
Non-Critical Applications: If approximate community structure suffices and runtime is paramount, Louvain's simplicity might edge out Leiden in very specific optimization scenarios
However, for new projects, Leiden is the clear choice. Its guarantees eliminate an entire class of potential errors, and it typically runs faster anyway.
Migration Path
Organizations using Louvain can migrate smoothly:
Python (Scanpy): Change sc.tl.louvain(adata) to sc.tl.leiden(adata). Parameters are largely compatible.
R (Seurat): Change algorithm = 1 (Louvain) to algorithm = 4 (Leiden) in FindClusters().
igraph: Replace graph.community_multilevel() with graph.community_leiden().
Results will differ slightly due to algorithm changes, but community structure should be similar if the network has clear communities. Leiden typically finds slightly more refined partitions with better modularity scores.
Pros and Cons
Summary: Leiden offers substantial advantages with minimal downsides, though some limitations exist in specific use cases.
Advantages
1. Guaranteed Connected Communities This is the biggest win. Disconnected communities are nonsensical in most applications. Leiden eliminates this problem completely through its refinement phase.
2. Faster Than Louvain Despite adding a refinement step, Leiden typically runs faster due to its smarter node visiting strategy. Empirical tests across various networks showed 20-150% speedups (Traag et al., 2019).
3. Better Quality Partitions Leiden consistently finds partitions with higher modularity scores. The refinement phase lets the algorithm escape local optima that trap Louvain.
4. Theoretical Guarantees The mathematical proofs ensure you know what you're getting: connected communities that are locally optimal. This predictability matters for reproducible research.
5. Active Development The algorithm is actively maintained and optimized. New implementations continue emerging, with performance improvements arriving regularly.
6. Wide Software Support Integration in Scanpy, Seurat, igraph, NetworkX, and other major tools makes adoption frictionless.
7. Flexible Quality Functions Support for modularity, CPM, and other quality functions lets users tailor the algorithm to their specific network properties.
8. Scalability Modern implementations handle graphs with billions of edges. Parallel and GPU versions push these limits further.
Disadvantages
1. Hard Partitions Only Leiden assigns each node to exactly one community. Many real-world networks have overlapping communities—people belong to multiple social groups, proteins participate in multiple pathways. Other methods (like mixed-membership models) handle this better.
2. Resolution Parameter Sensitivity Choosing the right resolution parameter γ requires domain knowledge and experimentation. Too high produces excessive tiny communities; too low merges distinct groups. No automatic, universally optimal value exists.
3. Still Has Resolution Limit While Leiden addresses some resolution limit issues through CPM and other quality functions, the fundamental problem persists. Very small communities in very large networks may still merge inappropriately.
4. Randomization Sensitivity Leiden's refinement phase uses randomness. Different random seeds can produce slightly different results, though stable networks usually show minimal variation. Setting random_state (Python) or seed values (R) ensures reproducibility.
5. No Hierarchical Output by Default While the algorithm works hierarchically internally, most implementations return a flat partition. Users wanting a dendrogram must track intermediate steps themselves.
6. Computational Cost for Massive Graphs Even with optimizations, networks exceeding 10 million nodes can strain memory and time budgets. Specialized methods may perform better at these scales.
7. Limited Theoretical Understanding of Some Properties While core guarantees are proven, some aspects (like exact conditions for finding global optima) remain less well understood theoretically.
When to Choose Alternatives
Overlapping communities needed: Use methods like OSLOM, BIGCLAM, or mixed-membership stochastic blockmodels
Hierarchical structure critical: Use hierarchical clustering methods or dendrogram-based approaches
Extremely dense graphs: Consider spectral methods or matrix factorization approaches
Temporal dynamics: Specialized dynamic community detection methods may capture evolution better
Specific structure known: If you know communities follow a particular generative model (e.g., stochastic blockmodel), use model-based inference
Common Pitfalls
Summary: Avoiding these mistakes prevents wasted time and ensures Leiden produces meaningful, interpretable results.
Pitfall 1: Using Default Resolution Blindly
The Problem: The default resolution parameter (γ = 1) might not suit your network. It often produces too many or too few communities.
The Solution: Test multiple resolution values. Plot modularity and number of communities against resolution. Look for stability regions where small parameter changes produce consistent communities.
For single-cell data, biologists typically test resolution between 0.4 and 2.0, choosing values that produce biologically meaningful cell type counts (typically 10-50 cell types for most tissues).
Example:
resolutions = [0.4, 0.6, 0.8, 1.0, 1.2, 1.5, 2.0]
for res in resolutions:
sc.tl.leiden(adata, resolution=res, key_added=f'leiden_{res}')
# Compare results visuallyPitfall 2: Forgetting to Build the Graph First
The Problem: Leiden operates on graphs, not raw data matrices. Forgetting to construct a k-nearest-neighbor (kNN) graph or adjacency matrix causes errors.
The Solution: In Scanpy: Always run sc.pp.neighbors() before sc.tl.leiden(). This builds the kNN graph based on dimensionality-reduced data (PCA, UMAP, etc.).
In R Seurat: Run FindNeighbors() before FindClusters().
The choice of k (number of neighbors) affects community structure. Smaller k creates more, smaller communities; larger k creates fewer, larger ones.
Pitfall 3: Ignoring Data Preprocessing
The Problem: Leiden clustering is garbage-in, garbage-out. Poor data quality leads to poor communities.
The Solution: For single-cell data:
Filter low-quality cells and genes
Normalize for library size
Log-transform (usually log(count + 1))
Select highly variable genes
Scale/center data
Run PCA to reduce dimensionality
For network data:
Remove isolated nodes
Handle missing edges appropriately
Consider edge weighting schemes
Verify node labels and metadata
Pitfall 4: Over-Interpreting Small Differences
The Problem: Due to randomization, running Leiden twice can produce slightly different results. Users sometimes over-interpret which specific nodes shifted between communities.
The Solution: Set a random seed for reproducibility. For critical analyses, run Leiden multiple times with different seeds and look for stable communities—groups that consistently stay together across runs.
Consensus clustering combines multiple runs to identify robust community structure:
from sklearn.metrics import adjusted_rand_score
# Run 10 times and measure stability
partitions = []
for i in range(10):
sc.tl.leiden(adata, resolution=1.0, random_state=i, key_added=f'leiden_{i}')
partitions.append(adata.obs[f'leiden_{i}'])
# Calculate pairwise ARI to measure consistencyPitfall 5: Mistaking Communities for Ground Truth
The Problem: Leiden finds structure in any network, even random ones. High modularity doesn't guarantee biological or social meaning.
The Solution: Validate communities through:
External data (known cell types, social groups, functional modules)
Enrichment analysis (do communities share meaningful properties?)
Visual inspection (do communities look sensible in embeddings?)
Domain expert review
In biology, differential expression analysis should reveal marker genes for each cluster. In social networks, communities should correspond to actual organized groups. If validation fails, communities may be algorithmic artifacts.
Pitfall 6: Applying to Inappropriate Networks
The Problem: Leiden assumes certain network properties. It works poorly on:
Trees (no community structure to find)
Complete graphs (everyone connects to everyone)
Networks without assortative structure (where similar nodes don't cluster)
Directed acyclic graphs (DAGs) with strong hierarchy
The Solution: Before clustering, assess whether your network has community structure. Calculate the modularity of random partitions. If random partitions score nearly as high as Leiden's partition, the network may lack meaningful communities.
For directed networks, consider whether to treat edges as undirected or use specialized methods that respect direction.
Advanced Topics
Summary: Power users can leverage Leiden's flexibility for specialized applications and fine-tune performance for their specific needs.
Resolution Parameter Selection
Beyond trial-and-error, several principled approaches exist:
Stability Analysis: Plot the number of communities versus resolution. Look for "plateaus" where resolution changes don't dramatically alter community count. These stable regions often correspond to meaningful structure.
Modularity Optimization: Run Leiden across many resolution values and plot modularity scores. The maximum usually indicates a good partition, though multiple local maxima may exist.
Cross-Validation: For networks with metadata (like cell types), use cross-validation. Hide labels for a subset of nodes, cluster, then check if recovered communities match known groups.
Multiplex Networks
Real systems often have multiple types of relationships. In social networks: friendship, family, colleagues. In biology: protein-protein interaction, gene co-expression, shared pathways.
Leiden supports multiplex optimization, finding communities consistent across multiple network layers. This is more robust than analyzing layers separately.
The leidenalg package provides:
optimiser = la.Optimiser()
optimiser.optimise_partition_multiplex([partition1, partition2, ...])Each layer can have different quality functions and weights.
Partially Fixed Partitions
Sometimes you know certain nodes should stay together (or apart). Leiden allows fixing subsets of the partition:
# Fix nodes 0-100 to stay in their current communities
fixed_nodes = [True] * 100 + [False] * (n_nodes - 100)
optimiser.optimise_partition(partition, fixed_nodes=fixed_nodes)This is useful when incorporating prior knowledge or iteratively refining large clusterings.
Bipartite Networks
Networks with two node types (e.g., users and products, genes and diseases) have special structure. Leiden can be adapted for bipartite networks, though this requires careful quality function selection.
The Barber modularity for bipartite networks reformulates the quality function to respect the two-mode structure.
Quality Function Customization
Advanced users can define custom quality functions. Requirements:
Fast evaluation (called billions of times)
Differentiable with respect to node moves (for greedy optimization)
Meaningful interpretation
Most custom functions are variations of modularity or CPM, adjusting for network-specific null models.
Hierarchical Leiden
By tracking partitions at each aggregation level, you can construct a dendrogram showing hierarchical community structure. This reveals nested organization—communities within communities.
Implementation requires storing intermediate partitions and building parent-child relationships between communities across levels.
Dynamic Graph Tracking
For streaming networks, maintaining community assignments without full recomputation improves efficiency. The Dynamic Frontier approach (Sahu, 2024) tracks affected nodes and their neighborhoods, updating only necessary parts.
Trade-offs exist between update frequency, batch size, and accuracy. Small frequent updates may accumulate drift; large infrequent updates reduce efficiency gains.
Future Outlook
Summary: Leiden continues evolving, with improvements focusing on scale, speed, specialized structures, and integration with machine learning.
Trends Through 2026
Continued Performance Optimization The race for faster implementations continues. Current focus areas include:
Better GPU utilization
Distributed algorithms for clusters
Approximate algorithms trading quality for speed
Specialized hardware (FPGAs, TPUs)
Ultra-Large Scale As networks approach trillions of edges (e.g., global social networks, brain connectomes), even Leiden struggles. Future work will likely focus on sampling, approximation, and hierarchical preprocessing.
Integration with Deep Learning Graph neural networks (GNNs) learn representations from network structure. Combining Leiden's community detection with GNN embeddings could produce powerful hybrid methods:
Use Leiden to initialize GNN architectures
Incorporate community assignments as features
Joint optimization of communities and embeddings
Research in this direction is active as of 2024-2025.
Probabilistic Variants Current Leiden is deterministic (given a random seed). Probabilistic versions could quantify uncertainty in community assignments, producing confidence intervals for node memberships.
This would help researchers understand which communities are robust versus which are ambiguous.
Emerging Applications
Digital Twin Networks As organizations build digital twins of physical systems (manufacturing plants, supply chains, infrastructure), community detection identifies functional units and bottlenecks. Leiden's speed makes real-time analysis feasible.
Metaverse and Virtual Worlds Virtual environments generate massive social graphs. Understanding community structure helps design better spaces, moderate content, and create targeted experiences.
Climate Networks Climate scientists model teleconnections—distant regions with correlated weather patterns—as networks. Community detection reveals regional climate zones and helps predict extreme events.
Brain Connectomics Mapping complete brain connectivity at cellular resolution is a grand challenge. As techniques improve, we'll have networks with billions of neurons and trillions of synapses. Leiden (or its successors) will help identify functional modules and understand information flow.
Research Directions
Better Resolution Selection Automated methods for choosing resolution parameters remain an open problem. Machine learning approaches might learn optimal parameters from labeled examples.
Handling Negative Edges Some networks have negative relationships (enemies, inhibitory connections). Incorporating signed graphs into Leiden requires rethinking quality functions.
Temporal Dynamics Current work on dynamic graphs treats communities as evolving independently. Temporal models where community structure at time t depends on time t-1 could capture realistic evolution patterns.
Explainability Why did Leiden assign node X to community Y? Providing interpretable explanations—especially for biologists and social scientists—would increase trust and adoption.
Long-Term Vision
By 2030, we may see:
Real-time community detection on global-scale networks
Hybrid quantum-classical algorithms leveraging quantum computing's parallelism
Unified frameworks handling multiple network types (temporal, multiplex, signed, hypergraphs)
Community detection as a service in cloud platforms, abstracting implementation complexity
Integration into decision-making systems (recommender systems, fraud detection, treatment planning)
The fundamentals Traag and colleagues established in 2019 will likely persist, but implementations and applications will grow far beyond the original vision.
FAQ
1. What is the Leiden algorithm used for?
The Leiden algorithm identifies natural groups (communities) within network data. It clusters highly connected nodes—representing entities like cells, people, proteins, or websites—into communities where internal connections are stronger than external ones. Primary applications include analyzing biological networks (especially single-cell data), social networks, infrastructure systems, and machine learning on graphs.
2. Who created the Leiden algorithm?
Vincent Traag, Ludo Waltman, and Nees Jan van Eck at Leiden University in the Netherlands developed the Leiden algorithm. They published the method in Scientific Reports on March 26, 2019 (DOI: 10.1038/s41598-019-41695-z). The paper has received over 4,000 citations as of 2024 (Scite).
3. How does Leiden differ from the Louvain algorithm?
Leiden improves Louvain by adding a crucial refinement phase between the move and aggregate steps. This refinement prevents the disconnected communities that plagued Louvain—up to 16% of Louvain's communities were disconnected. Leiden guarantees all communities stay connected and runs 20-150% faster despite the extra phase (Traag et al., 2019, Scientific Reports).
4. Is Leiden deterministic or stochastic?
Leiden contains randomness in its refinement phase (probabilistic node moves) and initial node ordering. Running it twice with different random seeds can produce slightly different results. However, setting a fixed random seed ensures reproducibility. The overall community structure usually remains stable, though individual borderline nodes may shift between similar communities.
5. What programming languages support Leiden?
Python (via leidenalg, igraph, Scanpy), R (via leiden package, Seurat), and Julia all have Leiden implementations. Python has the most mature ecosystem. Java users typically call Python implementations via bridges. The core algorithm is written in C++, allowing integration into any language with C bindings.
6. How do I choose the resolution parameter?
Start with the default (γ = 1.0) and test values around it. Higher resolution produces more, smaller communities; lower resolution produces fewer, larger ones. Plot community count versus resolution. Look for stable ranges where small parameter changes don't dramatically alter results. For biological data, validate against known cell types. For social data, compare to ground-truth groups if available.
7. Can Leiden handle weighted graphs?
Yes. Leiden naturally handles edge weights through its quality function. Weighted edges contribute proportionally to modularity calculations. In practice, most implementations accept weighted adjacency matrices or weighted edge lists directly. Weights typically represent connection strength, interaction frequency, or similarity scores.
8. How long does Leiden take to run?
Runtime depends on network size, density, and implementation. The optimized GVE-Leiden processes 403 million edges per second (Sahu et al., 2024). For typical single-cell datasets (100,000 cells, 1.5 million edges), runtime ranges from seconds to a few minutes on standard laptops. Networks with 10+ million nodes may require specialized hardware or distributed implementations.
9. Does Leiden work on directed graphs?
Most Leiden implementations treat directed graphs as undirected by default, symmetrizing the adjacency matrix. The theoretical guarantees hold for undirected graphs. For purely directed graphs where direction matters critically, specialized methods may be more appropriate, though Leiden can provide reasonable results as an approximation.
10. What is modularity?
Modularity measures how well a network divides into communities. It compares the actual number of edges within communities to the expected number if edges were placed randomly. Scores range from -1 to +1, with higher values indicating stronger community structure. Values above 0.3 typically indicate significant structure. Leiden maximizes modularity (or related quality functions) while ensuring communities stay connected.
11. Can Leiden find overlapping communities?
No. Leiden produces a hard partition—each node belongs to exactly one community. For overlapping communities (e.g., people in multiple social groups), use dedicated methods like mixed-membership stochastic blockmodels, link communities, or clique percolation methods. Leiden's hard partitioning is a fundamental design choice stemming from its modularity optimization framework.
12. How do I validate Leiden's results?
Validation depends on your domain:
Biology: Check if communities match known cell types using marker genes. Calculate silhouette scores or adjusted Rand index.
Social networks: Compare to ground-truth groups if available. Examine homophily (do community members share attributes?).
General: Inspect community connectivity in visualizations. Calculate internal versus external edge density. Run sensitivity analysis with different parameters.
External validation against known labels provides the strongest evidence, but not all networks have ground truth.
13. What's the maximum network size Leiden can handle?
Practical limits depend on available RAM and patience. Standard implementations comfortably handle networks with millions of nodes and tens of millions of edges on typical workstations. Optimized parallel implementations (GVE-Leiden) process billions of edges on server hardware. Beyond 10 million nodes, specialized methods or distributed algorithms become necessary. Memory usage is the primary constraint, roughly O(n + m) for n nodes and m edges.
14. Why does Leiden sometimes produce singletons?
Singleton communities (one node alone) arise when a node connects weakly to all neighbors. If moving it to any neighbor's community decreases quality, Leiden leaves it isolated. This usually indicates outliers or bridge nodes connecting distinct regions. Consider these special cases—they may represent noise, boundary phenomena, or genuinely unique entities. Adjust resolution or preprocessing to reduce singletons if they're problematic.
15. How does Leiden handle missing data?
Leiden operates on the network you provide—it doesn't impute missing edges. If your underlying data has missing values:
Biological data: Filter low-quality cells/genes before building the kNN graph
Social data: Decide whether absent edges mean "no connection" or "unknown"
General: Consider imputation methods before constructing the network
The quality of Leiden's output directly depends on the quality of the input network, so thoughtful preprocessing is critical.
16. Can I run Leiden incrementally as the network changes?
Yes, though with limitations. Dynamic variants (DF Leiden, DS Leiden) track network changes and update communities incrementally. They achieve modest speedups (1.1-1.4x) over recomputing from scratch (Sahu, 2024, arXiv:2405.11658). For maximum quality, full recomputation is safest. For streaming applications where speed matters more than perfection, dynamic methods are worthwhile.
17. What's the difference between CPM and modularity in Leiden?
Modularity compares internal edge density to a configuration model expectation. CPM (Constant Potts Model) uses an absolute resolution parameter independent of network size. CPM's γ directly sets a minimum edge density threshold for communities, making it more interpretable in some contexts. Both produce valid partitions; choose based on whether relative (modularity) or absolute (CPM) density thresholds better match your problem.
18. How reproducible are Leiden results?
Leiden is reproducible if you set the random seed. In Python Scanpy: sc.tl.leiden(adata, random_state=42). In R Seurat, set the seed before running: set.seed(42); FindClusters(...). Without fixing the seed, repeated runs produce similar but not identical results. Stable networks show minimal variation; ambiguous structures show more. For publications, always report the random seed used.
19. Does Leiden work on spatial networks?
Standard Leiden treats networks abstractly, ignoring spatial coordinates. However, researchers have developed spatial variants (SpatialLeiden) that incorporate physical distance into edge weights or graph construction. These methods identify spatially contiguous communities—useful for geographic data, tissue imaging, and urban networks (Genome Biology, 2025).
20. Where can I learn more about Leiden implementation details?
Primary resources:
Original paper: Traag et al., 2019, Scientific Reports (DOI: 10.1038/s41598-019-41695-z)
Official Python docs: https://leidenalg.readthedocs.io
Scanpy tutorial: https://scanpy-tutorials.readthedocs.io
Author's GitHub: https://github.com/vtraag/leidenalg
Comparative analyses: Search Google Scholar for "Leiden algorithm performance" or "Leiden algorithm applications"
For troubleshooting, the GitHub issues pages often contain valuable discussions of edge cases and optimizations.
Key Takeaways
Leiden fixes Louvain's critical flaw: It guarantees all communities stay connected, eliminating the disconnected communities that plagued up to 16% of Louvain's output
Superior performance on all metrics: Leiden runs faster (1.2-2.5x speedups), produces higher quality partitions, and provides mathematical guarantees absent in Louvain
Three-phase algorithm: Local moving, refinement (the innovation), and aggregation work together to prevent fragmentation while optimizing modularity
Dominant in biology: Scanpy, Seurat, and other single-cell analysis tools adopted Leiden as the standard, processing millions of cells routinely
Broad applicability: From social networks to cybersecurity, transportation to protein interactions, Leiden's framework adapts across domains
Highly optimized implementations: Modern versions process 403 million edges per second, making billion-edge networks tractable (GVE-Leiden, 2024)
Over 4,000 citations in five years: Rapid adoption reflects both technical superiority and pressing need for reliable community detection
Resolution parameter controls granularity: Higher γ produces more, smaller communities; lower γ produces fewer, larger ones; choosing wisely requires domain knowledge
Hard partitions only: Each node belongs to exactly one community—overlapping community methods needed for more complex membership patterns
Continues evolving: Active research on parallelization, dynamic networks, spatial variants, and integration with machine learning promises further improvements
Actionable Next Steps
Install the necessary software
Python users: pip install scanpy leidenalg igraph
R users: install.packages(c("Seurat", "leiden", "igraph"))
Test installation by running simple examples from documentation
Load your network data
For biology: Prepare count matrix, quality control, normalization
For social/general networks: Build adjacency matrix or edge list
Ensure data format matches your chosen library's expectations
Build the graph
Biology: scanpy.pp.neighbors(adata, n_neighbors=15, n_pcs=50)
General: Convert to igraph object: graph = igraph.Graph.Adjacency(matrix)
Verify graph properties: node count, edge count, connectedness
Run Leiden with default settings first
Scanpy: scanpy.tl.leiden(adata, resolution=1.0, random_state=42)
Seurat: FindClusters(seurat_obj, resolution=0.8, algorithm=4, random.seed=42)
igraph: partition = graph.community_leiden(resolution_parameter=1.0)
Visualize results
Biology: scanpy.pl.umap(adata, color='leiden')
General: Use network visualization tools (Gephi, Cytoscape, igraph plotting)
Check if communities look sensible at first glance
Test multiple resolution parameters
Try range from 0.4 to 2.0 in increments of 0.2
Plot number of communities vs resolution
Identify stable regions
Validate communities
Biology: Differential expression analysis to find marker genes
Social networks: Compare to known groups or metadata
Calculate internal metrics: silhouette score, modularity
Optimize if needed
Adjust resolution based on validation results
Consider alternative quality functions (CPM) if modularity seems inappropriate
Test different graph construction parameters (k in kNN)
Document your workflow
Record all parameters: resolution, random seed, graph construction settings
Save intermediate results
Note software versions for reproducibility
Consult experts for complex cases
Post questions on Biostars (biology), Stack Overflow (programming), or relevant domain forums
Share minimal reproducible examples
Cite the original Leiden paper in publications
Glossary
Adjacency Matrix: A square matrix representing a network where entry (i,j) equals 1 (or edge weight) if nodes i and j connect, 0 otherwise.
Aggregation Phase: Step where communities become super-nodes in a coarser network for the next iteration.
Community: A group of nodes more densely connected to each other than to the rest of the network. Also called cluster or module.
Constant Potts Model (CPM): A quality function for community detection using an absolute resolution parameter independent of network size.
Disconnected Community: A community where some nodes cannot reach others via internal paths—a serious defect Leiden eliminates.
Edge: A connection between two nodes in a network. May be directed (one-way) or undirected (two-way), weighted or unweighted.
Graph: Mathematical structure consisting of nodes (vertices) and edges (links). Used interchangeably with "network."
k-Nearest Neighbor (kNN) Graph: A graph where each node connects to its k most similar nodes based on some distance metric.
Local Moving Phase: Algorithm step where individual nodes move to neighboring communities if doing so improves quality.
Louvain Algorithm: Popular 2008 community detection method improved by Leiden. Prone to creating disconnected communities.
Modularity: Quality metric measuring strength of network's division into communities. Compares internal density to random expectation.
Node: A point in a network representing an entity (person, cell, website). Also called vertex.
Partition: A division of network nodes into non-overlapping communities.
Quality Function: Mathematical formula measuring how "good" a partition is. Leiden optimizes quality functions like modularity or CPM.
Refinement Phase: Leiden's innovation—a step that subdivides communities to prevent disconnection after node moving.
Resolution Limit: Problem where small, distinct communities merge when maximizing modularity. Related to finite network size.
Resolution Parameter (γ/gamma): Controls community detection granularity. Higher values produce more, smaller communities.
Scanpy: Leading Python package for single-cell RNA sequencing analysis, includes Leiden implementation.
Seurat: Leading R package for single-cell RNA sequencing analysis, includes Leiden implementation.
Single-Cell RNA Sequencing (scRNA-seq): Technology measuring gene expression in individual cells, generating massive datasets requiring clustering.
Singleton Community: A community containing only one node, often indicating outliers or bridge nodes.
UMAP: Uniform Manifold Approximation and Projection—dimensionality reduction technique for visualization, often used before Leiden.
Sources & References
Blondel, V. D., Guillaume, J. L., Lambiotte, R., & Lefebvre, E. (2008). Fast unfolding of communities in large networks. Journal of Statistical Mechanics: Theory and Experiment, 2008(10), P10008. https://doi.org/10.1088/1742-5468/2008/10/P10008
Cao, Y., & Zhang, W. (2022). Automating microservice decomposition. 2nd International Conference on Artificial Intelligence, Automation, and High-Performance Computing (AIAHPC). IEEE.
Chen, L., Wang, H., & Liu, Y. (2023). Identifying transportation trends using community detection. Transportation Research Procedia, 63, 2392-2400.
Chernikova, A., Gozzi, N., Boboila, S., Angadi, P., Loughner, J., Wilden, M., Perra, N., Eliassi-Rad, T., & Oprea, A. (2022). Cyber network resilience against self-propagating malware attacks. European Symposium on Research in Computer Security. Springer, 531-550.
Du, A., Robinson, M. D., & Soneson, C. (2018). A systematic performance evaluation of clustering methods for single-cell RNA-seq data. F1000Research, 7. https://doi.org/10.12688/f1000research.15666.1
Erfan, M., et al. (2023). Detecting attacks in blockchain systems using community detection. IEEE Conference Proceedings.
Fortunato, S. (2010). Community detection in graphs. Physics Reports, 486(3-5), 75-174. https://doi.org/10.1016/j.physrep.2009.11.002
Fortunato, S., & Barthélemy, M. (2007). Resolution limit in community detection. Proceedings of the National Academy of Sciences, 104(1), 36-41.
Freytag, S., Tian, L., Lönnstedt, I., Ng, M., & Bahlo, M. (2018). Comparison of clustering tools in R for medium-sized 10x Genomics single-cell RNA-sequencing data. F1000Research, 7. https://doi.org/10.12688/f1000research.15809.1
Heumos, L., et al. (2023). Best practices for single-cell analysis across modalities. Nature Reviews Genetics, 24(8), 550-572.
La Morgia, M., et al. (2021). Detecting disinformation networks on Telegram. Digital Threats: Research and Practice.
Leiden Coloring Algorithm for Influencer Detection. (2024). International Journal of Advanced Computer Science and Applications (IJACSA), 15(12). https://doi.org/10.14569/IJACSA.2024.0151233
Liu, C., Zhang, Y., & Wang, X. (2023). Secuer: Ultrafast, scalable and accurate clustering of single-cell RNA-seq data. arXiv:2205.12432. https://arxiv.org/abs/2205.12432
Newman, M. E. J. (2006). Finding community structure in networks using the eigenvectors of matrices. Physical Review E, 74(3), 036104.
Newman, M. E. J., & Girvan, M. (2004). Finding and evaluating community structure in networks. Physical Review E, 69(2), 026113.
Sahu, S. (2023). GVE-Leiden: Fast Leiden algorithm for community detection in shared memory setting. arXiv:2312.13936. https://arxiv.org/abs/2312.13936
Sahu, S. (2024). DF Louvain: Fast incrementally expanding approach for community detection on dynamic graphs. arXiv:2404.19634. https://arxiv.org/abs/2404.19634
Sahu, S. (2024). A starting point for dynamic community detection with Leiden algorithm. arXiv:2405.11658. https://arxiv.org/abs/2405.11658
Sahu, S., Kothapalli, K., & Banerjee, D. S. (2024). Fast Leiden algorithm for community detection in shared memory setting. Proceedings of the 53rd International Conference on Parallel Processing, 11-20. https://doi.org/10.1145/3673038.3673146
Scite.ai. (2024). Citation analysis: From Louvain to Leiden. Retrieved January 2026 from https://scite.ai/reports/from-louvain-to-leiden-guaranteeing-J1QZ1JG
Single Cell Explorer, collaboration-driven tools to leverage large-scale single cell RNA-seq data. (2019). BMC Genomics, 20. https://doi.org/10.1186/s12864-019-6053-y
Sliwa, J., et al. (2024). Analyzing Twitter communities during the 2022 Ukraine war. Social Network Analysis and Mining, 14(1).
SpatialLeiden: spatially aware Leiden clustering. (2025). Genome Biology, 26. https://doi.org/10.1186/s13059-025-03489-7 (Published February 7, 2025)
Staudt, C. L., Sazonovs, A., & Meyerhenke, H. (2016). NetworKit: A tool suite for large-scale complex network analysis. Network Science, 4(4), 508-530.
Traag, V. A., Waltman, L., & van Eck, N. J. (2019). From Louvain to Leiden: guaranteeing well-connected communities. Scientific Reports, 9(1), 5233. https://doi.org/10.1038/s41598-019-41695-z (Published March 26, 2019)
Verhetsel, A., et al. (2022). Analyzing regional retail patterns using community detection. Urban Studies, 59(12), 2541-2558.
Weber, L. M., & Robinson, M. D. (2016). Comparison of clustering methods for high-dimensional single-cell flow and mass cytometry data. Cytometry Part A, 89(12), 1084-1096.
Wolf, F. A., Angerer, P., & Theis, F. J. (2018). SCANPY: large-scale single-cell gene expression data analysis. Genome Biology, 19(1), 15. https://doi.org/10.1186/s13059-017-1382-0
Zhou, L., et al. (2023). Examining linguistic variations in memes using community detection. Computational Linguistics, 49(3), 567-589.
Zhuang, D., Chang, J., & Li, M. (2019). DynaMo: Dynamic community detection by incrementally maximizing modularity. IEEE Transactions on Knowledge and Data Engineering, 33(5), 1934-1945.
$50
Product Title
Product Details goes here with the simple product description and more information can be seen by clicking the see more button. Product Details goes here with the simple product description and more information can be seen by clicking the see more button
$50
Product Title
Product Details goes here with the simple product description and more information can be seen by clicking the see more button. Product Details goes here with the simple product description and more information can be seen by clicking the see more button.
$50
Product Title
Product Details goes here with the simple product description and more information can be seen by clicking the see more button. Product Details goes here with the simple product description and more information can be seen by clicking the see more button.
Comments