LAGO

Dynamic Community Detection for Temporal Networks

LAGO detects communities (modules) that evolve over time in fine-grained temporal networks (link streams). Unlike static methods, it finds groups that form, merge, split, and dissolve as interactions happen.

No time window needed. Traditional approaches require aggregating interactions into snapshots (e.g., daily or hourly networks), losing temporal precision and forcing you to choose an arbitrary window size. LAGO works directly on the raw timestamped data—no aggregation, no information loss.

A link stream with 5 nodes showing two dynamic communities (blue and green) that evolve over time.

Installation

pip install dcd-lago           # Core library (no dependencies)
pip install dcd-lago[viz]      # With visualization (numpy, pandas, matplotlib, scikit-learn)

Quick Start

from lago import LinkStream, lago_modules

# Create a temporal network
ls = LinkStream()
ls.add_links([
    (0, 1, 0), (1, 2, 0), (0, 2, 0),  # Triangle at t=0
    (0, 1, 1), (1, 2, 1),              # Path at t=1
    (3, 4, 0), (3, 4, 1), (3, 4, 2),   # Pair at t=0,1,2
    (2, 3, 2),                          # Bridge at t=2
])

# Detect temporal communities
communities = lago_modules(ls)

# Explore results
for module in communities.iter_modules():
    print(f"Community {module.label}: nodes {module.nodes}, duration {module.duration}")

Note: LAGO works on discrete integer timestamps. For best results, normalize your timestamps so that the smallest time gap is 1 (e.g., divide all timestamps by their GCD).

Features

Usage Examples

Evaluate Community Quality

from lago import longitudinal_modularity

result = longitudinal_modularity(ls, communities, lex="MM")
print(f"Quality score: {result.value:.4f}")

Visualize Results

from lago.viz import LongitudinalModulesPlot

plot = LongitudinalModulesPlot(communities, linkstream=ls, width=1200, height=600)
plot.configure_nodes(auto_ordering=True)
plot.configure_edges(show_activity=True)
plot.configure_modules(color_palette="tab10")
plot.draw()
plot.save("communities.png", dpi=150)

Explore Results

# Track a specific node
trajectory = communities.get_node_trajectory(node=0)
print(f"Node 0 was in communities: {trajectory}")

# Get community membership at a specific time
membership = communities.get_nodes_modules_membership_at_time(time=1)
print(f"At t=1: {membership}")

# Save/load results
communities.to_json("results.json")

Key Parameters

lago_modules()

longitudinal_modularity()

Performance

Nothing to configure: pip install dcd-lago gives the fastest implementation your platform supports.

• From a binary wheel, the hot modules of the search and the metric's counting kernel come compiled (Cython). From a source install they are compiled when a C compiler is available and run as pure Python otherwise. Both give the same results, bit for bit — the pure-Python sources are the reference and ship alongside the compiled modules.
• lago_modules is deterministic: the same input and parameters give the same modules, in any process. seed selects the exploration order, nb_iter tries several orders and keeps the best, and n_jobs runs those in parallel processes (memory and platform notes in the docstring).
• To see what is running: lago.accel.core_name() is "compiled" or "python", lago.accel.backend_name is "cython" or "python" for the metric kernel. LAGO_CORE=python forces the pure sources. In a checkout, python setup.py build_ext --inplace builds the compiled modules next to the sources.

Against release 1.1.0: 8× (pure Python) to 12× (compiled) on small streams over every parameter combination, 6–109× on streams of 4k–96k interactions, JM at the speed of MM — see docs/BENCHMARK_PYPI_VS_CURRENT.md.

Documentation

📖 Guides

• Getting Started — Concepts and first steps
• API Reference — Complete function documentation
• Changelog — What changed in each release
• Performance notes — How the implementation is optimised and verified; the compiled build

📁 Examples (examples/)

• LinkStream Types — Weighted, directed, continuous, delayed, k-partite networks
• Community Detection — Using lago_modules and exploring results
• Modularity — Computing and understanding quality scores
• Visualization — Creating publication-ready plots

💡 Practical Guides

• Real-World Preprocessing — Working with names and date strings

The examples are Jupyter notebooks (Getting Started is a page); run jupyter notebook in the examples folder.

📄 Papers

• LAGO Method (ICDM) — Algorithm details and experiments
• Longitudinal Modularity (EPJ Data Science) — Quality function theory

Citation

If you use LAGO in your research, please cite:

LAGO Method:

@INPROCEEDINGS{11391928,
  author={Brabant, Victor and Bonifati, Angela and Cazabet, Rémy},
  booktitle={2025 IEEE International Conference on Data Mining (ICDM)}, 
  title={Discovering Communities in Continuous-Time Temporal Networks by Optimizing L-Modularity}, 
  year={2025},
  volume={},
  number={},
  pages={1065-1074},
  keywords={Accuracy;Network analyzers;Benchmark testing;Market research;Data mining;Optimization;Guidelines;temporal networks;community detection;dynamic communities;link stream;modularity},
  doi={10.1109/ICDM65498.2025.00115}}

Longitudinal Modularity:

@article{Brabant2025lmod,
    title={Longitudinal modularity, a modularity for link streams},
    author={Brabant, Victor and Asgari, Yasaman and Borgnat, Pierre and Bonifati, Angela and Cazabet, Rémy},
    journal={EPJ Data Science},
    volume={14},
    number={1},
    year={2025},
    doi={10.1140/epjds/s13688-025-00529-x},
}

Contributing

Questions, suggestions, or issues? Please open a GitHub issue.

Acknowledgements

We thank Jean-Loup Guillaume for the discussions that helped improve this project.

License

MIT License — see LICENSE.txt