[Paper Review] Efficiently Counting Vertex Orbits of All 5-vertex Subgraphs, by EVOKE

Noujan Pashanasangi, C. Seshadhri|arXiv (Cornell University)|Nov 24, 2019

Complex Network Analysis Techniques60 references4 citations

TL;DR

EVOKE is a scalable algorithm that efficiently computes exact vertex orbit counts (VOCs) for all 5-vertex subgraphs in large graphs, leveraging a generalized graph-cutting framework to relate larger subgraph counts to smaller ones through polynomial equations. It achieves up to hundreds of times faster performance than prior methods, processing graphs with tens of millions of edges in under an hour on commodity hardware, with only a small constant-factor overhead over total subgraph counting.

ABSTRACT

Subgraph counting is a fundamental task in network analysis. Typically, algorithmic work is on total counting, where we wish to count the total frequency of a (small) pattern subgraph in a large input data set. But many applications require local counts (also called vertex orbit counts) wherein, for every vertex $v$ of the input graph, one needs the count of the pattern subgraph involving $v$. This provides a rich set of vertex features that can be used in machine learning tasks, especially classification and clustering. But getting local counts is extremely challenging. Even the easier problem of getting total counts has received much research attention. Local counts require algorithms that get much finer grained information, and the sheer output size makes it difficult to design scalable algorithms. We present EVOKE, a scalable algorithm that can determine vertex orbits counts for all 5-vertex pattern subgraphs. In other words, EVOKE exactly determines, for every vertex $v$ of the input graph and every 5-vertex subgraph $H$, the number of copies of $H$ that $v$ participates in. EVOKE can process graphs with tens of millions of edges, within an hour on a commodity machine. EVOKE is typically hundreds of times faster than previous state of the art algorithms, and gets results on datasets beyond the reach of previous methods. Theoretically, we generalize a recent "graph cutting" framework to get vertex orbit counts. This framework generate a collection of polynomial equations relating vertex orbit counts of larger subgraphs to those of smaller subgraphs. EVOKE carefully exploits the structure among these equations to rapidly count. We prove and empirically validate that EVOKE only has a small constant factor overhead over the best (total) 5-vertex subgraph counter.

Motivation & Objective

• To address the challenge of computing exact vertex orbit counts (VOCs) for all 5-vertex subgraphs in large-scale graphs, which are critical for machine learning and network analysis.
• To overcome the scalability limitations of existing methods, which either fail to terminate on large graphs or rely on approximate or parallelized approaches requiring specialized hardware.
• To design an algorithm that computes VOCs efficiently by exploiting structural relationships between subgraph counts via a generalized graph-cutting framework.
• To demonstrate that computing fine-grained local subgraph features (VOCs) is as feasible as computing global subgraph counts, with only a small constant-factor performance penalty.

Proposed method

• EVOKE generalizes a recent graph-cutting framework to derive polynomial equations that relate vertex orbit counts of larger subgraphs to those of smaller subgraphs.
• It systematically exploits the algebraic structure of these equations to compute VOCs without enumerating all subgraphs, minimizing redundant computation.
• The algorithm processes orbits in parallel, with runtime distribution showing that only a few orbits (e.g., 5-clique, 5-cycle) dominate computation time, enabling effective load balancing.
• It supports both induced and non-induced subgraph counting, with exact results verified through extensive experiments.
• The method is implemented as a standalone package and validated on diverse real-world graphs, including social networks and web graphs.
• EVOKE’s design ensures minimal constant-factor overhead compared to the best-known total subgraph counter (ESC-5), as proven theoretically and validated empirically.

Experimental results

Research questions

• RQ1 Can exact vertex orbit counts for all 5-vertex subgraphs be computed efficiently at scale, beyond the reach of prior methods?
• RQ2 What is the theoretical and practical performance overhead of computing VOCs compared to global subgraph counting?
• RQ3 Can the graph-cutting framework be generalized to support vertex orbit counting, and how efficiently can it be exploited?
• RQ4 How does the runtime distribution across different orbits affect parallelization and overall performance?
• RQ5 Can VOCs reveal semantically meaningful insights about vertices in real-world networks, such as in citation or social graphs?

Key findings

• EVOKE processes graphs with up to 627 million edges (e.g., com-orkut) in under an hour on a commodity machine, far exceeding the scalability of prior tools like ORCA.
• The runtime ratio of EVOKE to ESCAPE (a state-of-the-art global counter) is consistently below 2 and never exceeds 4 across all datasets, validating the small constant-factor overhead.
• The 5-clique and 5-cycle orbits account for roughly half of the total runtime, indicating they are the most computationally expensive components.
• Parallelization of orbit computation yields a 1.5- to 2-fold speedup, confirming that the workload is naturally parallelizable across orbit types.
• VOC distributions vary significantly across graphs—e.g., Orbit 17 (center of 4-path) shows trillions of counts in web-google-dir, while Orbit 70 (5-clique minus edge) varies widely in tail behavior.
• Semantically meaningful vertices emerge from VOCs: the book "C4.5" has the highest count for the 4-path center orbit, and the VLDB 94 paper has the most 5-clique participations, confirming the method's interpretability.