PLANETALIGN: A Comprehensive Python Library for Benchmarking Network Alignment

This paper introduces PLANETALIGN, a comprehensive Python library that streamlines the development and benchmarking of network alignment methods by providing 18 datasets, 14 algorithms, extensible APIs, and a standardized evaluation pipeline to facilitate systematic comparative studies.

The Gist

Imagine you have two different libraries. One is a massive, chaotic library in New York, and the other is a smaller, organized library in Tokyo. Both libraries contain millions of books, but they are organized differently, have different covers, and even the titles are in different languages.

The Problem: Finding the "Same" Book
Your goal is to figure out which book in the New York library is the exact same story as a book in the Tokyo library. Maybe you want to combine their catalogs, or maybe you want to see how a story changes when it moves from one culture to another. This is called Network Alignment. In the real world, this isn't just about books; it's about matching users across Facebook and Twitter, matching proteins in different species to find cures, or matching traffic sensors in different cities.

For a long time, researchers have been trying to build "super-matching algorithms" to do this. But there was a big problem: everyone was using their own ruler. One researcher measured success with a ruler made of wood, another with a ruler made of plastic, and they were measuring different things. It was impossible to say, "Algorithm A is actually better than Algorithm B," because they weren't playing by the same rules.

The Solution: PLANETALIGN
This paper introduces PLANETALIGN, which is like a universal, all-in-one "Matchmaker's Toolkit" for computer scientists.

Think of it as a giant, open-source toolbox that anyone can use to test their matching ideas fairly. Here is what makes it special, using some simple analogies:

1. The "All-You-Can-Eat" Dataset Buffet 🍽️

Before, if you wanted to test your matching algorithm, you had to go find your own data, clean it, and hope it was good.

• PLANETALIGN comes with a pre-prepared feast. It includes 18 different datasets (the "ingredients") covering everything from social media and scientific papers to biological proteins and power grids.
• The Analogy: Imagine a cooking competition where every chef used to bring their own weird, unmeasured ingredients. PLANETALIGN is like a kitchen that provides every chef with the exact same high-quality, pre-weighed ingredients so the judges can truly see who is the best cook.

2. The "Gym" for Algorithms 🏋️‍♂️

The toolkit includes 14 different matching methods (the "athletes"). Some are old-school methods that rely on simple rules (like "if two people have the same friends, they are likely the same person"). Others are modern, high-tech methods that use deep learning (like "let's analyze the entire structure of the network to find hidden patterns").

• The Analogy: PLANETALIGN is a gym where you can put all these different athletes on the same track, run them through the same obstacles, and see who actually wins. It doesn't just let them run; it times them and measures their energy usage.

3. The "Fair Judge" (Standardized Scoring) ⚖️

This is the most important part. The toolkit has a built-in referee that ensures everyone is judged on the same criteria:

• Accuracy: How many matches did you get right?
• Speed: How fast did you finish?
• Memory: How much computer brainpower did you use?
• Robustness: What happens if we add some "noise" or "lies" to the data? (Like if a user on Twitter lies about their age, does the algorithm get confused?)
• The Analogy: In the past, judges might have given points for style, then for speed, then for how loud the crowd cheered. PLANETALIGN is a judge with a stopwatch and a calculator that only cares about the facts.

4. The "Easy-Button" for Developers 🛠️

Usually, building these matching systems is like trying to assemble a complex piece of IKEA furniture without the instructions.

• PLANETALIGN provides "Lego-like" blocks. If a researcher wants to build a new matching algorithm, they don't have to start from scratch. They just snap their new idea onto the existing framework.
• The Analogy: It's like a video game modding kit. You don't need to code the whole game engine; you just design a new character or a new weapon, plug it in, and the game runs it for you.

What Did They Discover? (The Plot Twist) 🕵️‍♀️

Using this new toolkit, the authors ran massive experiments and found some surprising things:

1. The "Transportation" Winners: The best-performing algorithms were a new type called Optimal Transport (OT) methods.

   • The Metaphor: Imagine you have a pile of sand in one shape and you want to turn it into a different shape. Old methods tried to match individual grains of sand one by one (which is slow and easy to mess up). The new OT methods look at the whole pile and figure out the most efficient way to move the entire mass to the new shape. It's like using a bulldozer instead of a spoon. These methods were consistently the "champions."

2. The Speed vs. Accuracy Trade-off: Some methods were super fast but not very accurate. Others were incredibly accurate but took forever to run.

   • The Metaphor: It's like the difference between a race car (fast but expensive to build) and a tank (slow but unstoppable). The toolkit helps you decide which one you need for your specific job.

3. The "Noise" Problem: When the data was messy (full of errors or lies), many of the fancy modern algorithms fell apart.

   • The Metaphor: Some algorithms are like a house of cards; a little wind (noise) blows them over. The best ones are like a fortress; they can handle the storm.

Why Should You Care?

Even if you aren't a computer scientist, this matters because Network Alignment is the glue holding the digital world together.

• It helps doctors find cures by matching proteins across species.
• It helps police catch criminals by linking accounts across different banking systems.
• It helps social media companies recommend friends you might know from real life.

PLANETALIGN is the tool that ensures the people building these systems are doing it right, fairly, and efficiently. It's the difference between a chaotic free-for-all and a professional, scientific competition that pushes technology forward.

In short: They built the ultimate "test track" for network matching, proved that a new type of "transportation" math works best, and gave everyone the keys to build better, faster, and smarter matching systems for the future.

Technical Summary

1. Problem Definition

Network Alignment (NA) is the task of identifying node correspondences across two or more different networks (e.g., aligning users across Facebook and Twitter, or proteins across different species). This task is foundational for downstream multi-network learning tasks such as cross-domain recommendation, fraud detection, biological homology discovery, and knowledge graph fusion.

Despite the growing interest in NA, the field suffers from a lack of standardized benchmarks. Existing efforts are fragmented, often limited to:

• Single domains (e.g., only biological or only social networks).
• Narrow method categories (ignoring recent advances like Optimal Transport).
• Inconsistent evaluation (lack of standardized dataset splits, metrics, and reproducibility).

The paper addresses the need for a unified, comprehensive, and extensible library to facilitate the systematic development, comparison, and benchmarking of NA methods.

2. Methodology: The PLANETALIGN Library

The authors introduce PLANETALIGN, an open-source, PyTorch-based Python library designed to unify the NA research ecosystem. Its methodology is built on three core pillars:

A. Comprehensive Data and Method Collection

PLANETALIGN integrates a wide spectrum of resources to ensure broad applicability:

• Datasets: It includes 18 datasets spanning 6 distinct domains:
  • Social Networks (e.g., Foursquare-Twitter, Douban)
  • Publication Networks (e.g., ACM-DBLP, Cora, ArXiv)
  • Biological Networks (e.g., SacchCere, PPI, GGI)
  • Knowledge Graphs (e.g., DBP15K variants)
  • Infrastructure Networks (e.g., Italy power grid, Airport, PeMS08)
  • Communication Networks (e.g., Phone-Email, Arenas)
  • Note: The library supports both real-world and synthetic datasets (generated via edge perturbation) and handles both plain and attributed networks.
• Algorithms: It implements 14 state-of-the-art NA methods categorized into three paradigms:
  • Consistency-based: IsoRank, FINAL.
  • Embedding-based: IONE, REGAL, CrossMNA, NetTrans, WAlign, BRIGHT, NeXtAlign, WLAlign.
  • Optimal Transport (OT)-based: SLOTAlign, PARROT, HOT, JOENA.

B. Unified and Extensible APIs

The library is designed for ease of use and development:

• Standardized Interface: Users can initialize datasets and algorithms with single-line API calls.
• Customizability: It provides base classes (BaseData, BaseModel) allowing researchers to easily integrate custom datasets and algorithms with minimal code.
• Workflow Management: Includes built-in logging, training monitoring, and visualization tools for tracking metrics like loss, time, and memory usage.

C. Standardized Evaluation Pipeline

PLANETALIGN enforces reproducibility through:

• Metrics: Supports classical effectiveness metrics (Hits@K, MRR) alongside efficiency metrics (runtime, peak memory) and robustness evaluations (noise injection).
• Reproducibility: Uses unified APIs for dataset splitting (train/test) with fixed random seeds to ensure fair comparisons.
• Benchmark Settings: Supports diverse scenarios including semi-supervised, unsupervised, plain, and attributed network alignment.

3. Key Contributions

1. First Comprehensive NA Library: PLANETALIGN is the first library to unify datasets across 6 domains, methods across 3 algorithmic categories (including the latest OT-based methods), and evaluation dimensions (effectiveness, scalability, robustness).
2. Extensible Architecture: It lowers the barrier to entry for developing new NA methods by providing reusable utility functions (e.g., Random Walk with Restart, anchor-based embeddings) and a modular code structure.
3. Efficiency Optimization: The library's implementations of existing algorithms are optimized to be up to 3x faster than official implementations while maintaining comparable or superior effectiveness.
4. Systematic Empirical Analysis: The authors conducted extensive experiments using the library to derive new insights into the strengths and limitations of current NA approaches.

4. Key Results and Insights

Through extensive benchmarking on 18 datasets, the authors revealed several critical findings:

• Superiority of Optimal Transport (OT): OT-based methods (specifically PARROT and JOENA) consistently outperform consistency-based and embedding-based methods across all domains in terms of Hits@K and MRR.
  • Reasoning: OT methods solve a globally constrained optimization problem that naturally encourages one-to-one alignment, whereas embedding methods often suffer from space disparity issues, and consistency methods rely on local assumptions that may be sub-optimal.
• Scalability Trade-offs:
  • Embedding-based methods face a "two-out-of-three" trade-off between effectiveness, time efficiency, and memory efficiency. For instance, methods using neural networks (like BRIGHT) are fast but memory-heavy, while those using transductive embeddings (like IONE) are memory-efficient but slow to retrain.
  • OT-based methods can achieve scalability similar to consistency-based methods if they employ efficient optimization techniques (e.g., convex approximation, proximal point methods).
• Robustness to Noise:
  • Different methods exhibit distinct sensitivities to noise types (edge, attribute, supervision).
  • Consistency-based methods are generally most robust to edge noise.
  • OT-based methods (PARROT, JOENA) show the best overall robustness, particularly against attribute noise and supervision noise, due to their ability to integrate multiple signals effectively.
• Sensitivity to Supervision: Most NA methods rely heavily on the quantity and quality of anchor pairs (supervision). While attributes help in low-supervision regimes, increasing supervision remains crucial for high performance. This highlights the need for future research in self-supervised and active alignment.

5. Significance

PLANETALIGN significantly advances the Network Alignment community by:

• Standardizing Research: It eliminates the "apples-to-oranges" comparisons caused by inconsistent datasets and evaluation protocols, providing a gold standard for benchmarking.
• Accelerating Innovation: By providing a modular, efficient, and well-documented framework, it allows researchers to focus on novel algorithmic ideas rather than data preprocessing and boilerplate code.
• Guiding Future Directions: The empirical insights suggest that future work should focus on integrating multiple paradigms (consistency, embedding, and OT) to improve robustness and developing self-supervised/active learning approaches to reduce reliance on expensive anchor labels.

The source code is publicly available at https://github.com/yq-leo/PlanetAlign, fostering open collaboration and further development in multi-network learning.