Edge-Centric Federated Subgraph Isomorphism Counting via Residual Graph Neural Networks

Abstract

Subgraph isomorphism counting is a fundamental yet computationally challenging task in graph analysis, with broad applications in bioinformatics and social network mining. With the tightening of data privacy regulations and the emergence of data silos, traditional centralized Graph Neural Network (GNN) approaches face significant deployment hurdles. Existing federated subgraph counting methods are primarily designed for database federation scenarios, focusing on exact queries and the privacy and security concerns of databases. However, this rigid focus on exactness and heavy cryptographic security severely limits their scalability and generalizability to complex, arbitrary query patterns. To bridge this gap, we propose a general Federated Edge-Centric Framework for Subgraph Isomorphism Counting (FedCount), shifting the paradigm from exact querying on federated databases to neural approximate counting under federated architectures. Rather than relying on heavy cryptographic techniques, we exclusively leverage the inherent structural isolation of federated learning as a lightweight empirical privacy measure. While this framework does not theoretically defend against advanced gradient-based inference attacks, it successfully prevents the direct leakage of raw graph topology and node features, achieving high-precision approximate counting without the prohibitive cryptographic overheads. Specifically, we introduce two key technical innovations to enhance local counting capability: (1) we integrate a provable edge encoding scheme into the interaction-based GNN architecture, explicitly modeling edge-to-edge interactions to break the expressiveness bottleneck of standard message passing; (2) we design a Residual Edge-Centric Readout mechanism that mitigates the gradient vanishing problem, enabling the effective training of deeper networks to capture high-order topological dependencies. Extensive experiments on multiple benchmark datasets demonstrate that our framework significantly outperforms existing distributed enumeration baselines in terms of generalization and efficiency, approaching the performance of centralized state-of-the-art models.

1. Introduction

Subgraph isomorphism counting [1], which aims to determine the occurrence frequency of a specific query pattern within a target graph, serves as a fundamental primitive in graph analysis with diverse applications. These range from discovering interaction motifs in social networks [2,3] to analyzing protein interaction structures in bioinformatics [4] and identifying specific functional motifs within brain connectivity networks in neuroscience [5]. Despite its significance, this task is computationally intractable; the underlying decision problem is known to be NP-Complete [6], rendering the counting variant #P-Complete. Consequently, traditional combinatorial algorithms [7,8] inherently suffer from exponential time complexity, making them prohibitive for large-scale graph data. To address this efficiency bottleneck, recent advancements have shifted towards data-driven approaches based on Graph Neural Networks (GNNs) [9,10]. By reformulating counting as a “learning-to-match” problem, these neural models have achieved remarkable success, offering superior scalability and robust generalization to unseen graphs compared to traditional heuristics.

However, the practical deployment of these centralized neural counting models faces significant hurdles in real-world scenarios. Driven by increasingly stringent data privacy regulations (e.g., HIPAA and GDPR) and institutional barriers, graph data is naturally distributed across isolated data silos. For instance, counting specific brain connectivity motifs associated with neurodegenerative disorders (e.g., Alzheimer’s disease) often requires aggregating patient data from multiple medical institutions, yet sharing raw brain graph data is strictly prohibited due to ethical and legal constraints. Federated learning (FL) [11] has emerged as the *de facto* paradigm to resolve this dilemma, enabling collaborative model training without exposing raw data. While federated graph learning (FGL) [12] has witnessed a surge in research, existing works predominantly focus on representation learning tasks such as node classification or link prediction. In stark contrast, federated subgraph isomorphism counting, despite being a core primitive of graph analysis, remains a largely unexplored frontier.

To address these privacy challenges, existing efforts have primarily resorted to database querying or cryptographic techniques to achieve exact counting in federated settings. For instance, Yuan et al. [13] designed a framework for subgraph matching over isolated graph databases, focusing on query decomposition and exact result assembly. For specific motifs like triangles, MAGO [3] leverages homomorphic encryption to ensure malicious security, while CARGO [14] and Sectric [15] combine Differential Privacy with Secure Multi-Party Computation. While these methods offer theoretical security guarantees, they suffer from fundamental utility bottlenecks in practice. First, limited applicability: most algorithms are hard-coded for simple, fixed motifs (e.g., triangles or cliques), lacking the flexibility to generalize to arbitrary, complex query patterns. Second, the accuracy–efficiency trade-off: noise injected by Differential Privacy significantly degrades the precision of regression-based counting tasks, while homomorphic encryption incurs prohibitive computational overheads. Consequently, there is an urgent need for a new federated counting paradigm that balances generalizability, computational efficiency, and privacy.

However, realizing such a general neural counting framework is non-trivial. Simply deploying existing GNN-based counting models (e.g., Count-GNN [10]) within a federated architecture faces two critical architectural hurdles. First, the expressiveness bottleneck of local models. Standard GNNs are theoretically bounded by the 1-Weisfeiler-Lehman (1-WL) test [16], failing to distinguish certain fundamental structural patterns. In a federated setting where local data is limited and heterogeneous, this lack of structural discriminability is amplified: if local models cannot generate high-quality structural embeddings, the aggregated global model inevitably converges to a suboptimal state. Second, the instability of training deep architectures. Capturing complex, high-order subgraph patterns requires stacking multiple network layers to achieve a sufficient receptive field. Yet, in federated learning, the naive parameter averaging strategy (e.g., FedAvg) often exacerbates the gradient vanishing problem in deep GNNs, leading to convergence failure or poor generalization. Consequently, empowering local models with stronger structural awareness and training stability is pivotal for achieving high-precision federated counting.

To surmount these hurdles, we propose FedCount, a general Federated Edge-Centric Framework for Subgraph Isomorphism Counting. Instead of devising intricate server-side aggregation protocols, our approach prioritizes fortifying the local learning backbone of clients to ensure that transmitted updates carry high-fidelity structural information. Specifically, we re-engineer the architecture of the local counting model: (1) we integrate the provable edge encoding scheme from ES-GNN [17] into the interaction-based GNN architecture. By explicitly modeling edge-to-edge interactions, this mechanism breaks the 1-WL expressiveness barrier, enabling local models to capture precise structural semantics; (2) we design a Residual Edge-Centric Readout mechanism. By introducing residual connections into the readout phase, we create direct pathways for gradient flow, effectively mitigating the vanishing gradient problem and ensuring robust convergence of deep networks even under the standard FedAvg protocol. Crucially, FedCount relies solely on the inherent structural isolation of the federated architecture to prevent the direct leakage of raw graph topology and node features. While this lightweight mechanism explicitly trades formal theoretical guarantees against advanced inference attacks (e.g., gradient leakage) for computational efficiency, it provides a practical privacy-utility balance, achieving high-precision counting without the severe utility loss associated with heavy cryptographic noise.

In summary, our main contributions are as follows:

• A General Federated Neural Counting Paradigm: We propose FedCount, the first general federated learning framework that shifts the subgraph counting task from the traditional “database-oriented exact querying” paradigm to a “neural-based approximate counting” paradigm. It enables efficient counting of arbitrary complex patterns while preventing the direct leakage of raw graph data through the structural isolation of the federated architecture.
• A Provably Expressive Federated Backbone: To address the expressiveness bottleneck and training instability of local models in federated settings, we innovatively integrate a provable edge encoding scheme with a Residual Edge-Centric Readout mechanism. This design theoretically breaks the 1-WL barrier and effectively mitigates the gradient vanishing problem in deep GNNs.
• Superior Generalization and Efficiency: Extensive experiments on multiple benchmark datasets demonstrate that FedCount significantly outperforms existing distributed enumeration baselines in terms of counting precision and generalization. It approaches the performance of centralized state-of-the-art (SOTA) models while maintaining low communication and computational overheads.

2. Related Work

This section details the evolution of subgraph counting methods from traditional combinatorial algorithms to modern neural models. It also outlines the landscape of federated graph learning, differentiating general representation learning from the specific task of federated subgraph counting.

2.1. Subgraph Isomorphism

Subgraph isomorphism counting, defined as determining the frequency of a query graph’s occurrences within a larger target graph, is a fundamental problem in graph analysis. Cook [6] proved that the subgraph isomorphism decision problem is NP-Complete. Consequently, the counting variant belongs to the #P-Complete complexity class, implying that the computational cost grows exponentially with the size of the query pattern and the target graph, posing significant algorithmic challenges.

To tackle this combinatorial explosion, early research focused on developing exact algorithms based on search space pruning. Ullmann [7] proposed the foundational algorithm employing a backtracking strategy, which recursively explores the state space while pruning branches that violate topological constraints. However, its factorial time complexity renders it intractable for large-scale graphs. To accelerate the matching process for complex queries, TurboISO [8] introduced the concept of neighborhood signatures to aggressively filter out unpromising candidate regions before matching. Building on this, Han et al. [18] harmonized dynamic programming with an adaptive matching order to minimize intermediate results. To avoid redundant computations across similar queries, Ribeiro et al. [19,20] developed G-Tries, a specialized prefix tree data structure that stores a collection of subgraphs. By sharing common substructures in the tree, G-Tries significantly accelerate network motif discovery. For the specific task of counting small graphlets (e.g., 3–5 nodes), Pinar et al. [21] and Pashanasangi et al. [22] leveraged vertex orbits and graph automorphism symmetry. By computing orbit relationships, these methods infer counts from a system of linear equations, drastically reducing the number of explicit isomorphism checks required. In the era of big data, single-machine algorithms face memory and runtime bottlenecks. Similarly, [23] uses the orbits of subgraphs to solve the problem, and designs a distributed system for counting arbitrary k-node pattern graphs. Afrati et al. [24] designed a multi-round MapReduce framework to decompose large graphs into manageable partitions for parallel enumeration. Similarly, Lai et al. [25] developed scalable distributed algorithms employing partial join optimization and compression techniques to minimize communication overhead. Despite their exactness, these distributed methods operate under the assumption of full access to the global graph topology, making them unsuitable for federated scenarios where data is siloed and privacy is paramount.

Driven by the need for efficiency and generalization, data-driven approaches based on Graph Neural Networks (GNNs) have emerged as a powerful alternative. Chen et al. [16] provided the first theoretical analysis of the expressive power of GNNs for counting, revealing that standard message passing is bounded by the 1-Weisfeiler-Lehman (1-WL) test and struggles to distinguish certain structural patterns. To transcend these limitations, Liu et al. [9] established the first framework for neural subgraph isomorphism counting, treating it as a regression task over graph embeddings. Zhao et al. [26] introduced a learned sketch-based approach that compresses structural information into compact signatures to efficiently estimate subgraph frequencies. Subsequently, Liu et al. [27] introduced a dual message passing mechanism, which encodes the query and target graphs separately to capture both local and global structural contexts. Wang et al. [28] further innovated by utilizing a Wasserstein discriminator to robustly estimate subgraph frequencies. Addressing the core challenge of accurate isomorphism matching, Yu et al. [10] proposed Count-GNN, which introduced a query–target interaction mechanism. By explicitly modeling the interaction between the query pattern and the target graph at the node level, Count-GNN significantly reduced estimation errors. Liu et al. Furthermore, addressing the challenge of data scarcity, Zhao et al. [29] developed a label-efficient framework optimized for learning subgraph counting queries with limited training samples. Ref. [30] incorporated graph kernel techniques into the neural counting paradigm to theoretically enhance the model’s expressiveness in capturing structural similarities. Fu et al. [31] proposed Desco, a scalable framework that improves generalization capabilities across distinct graph domains by leveraging subgraph decomposition techniques. Most recently, Yan et al. [17] proposed ES-GNN, which integrates a novel edge encoding scheme with provable substructure counting power. This method theoretically guarantees the ability to distinguish complex substructures beyond the 1-WL limit. To extend neural counting to non-deterministic settings, Ban et al. [32] designed a probabilistic framework to estimate motif frequencies in uncertain graphs where edge existence is stochastic. However, despite their advanced architectures, these models are designed for centralized training and cannot be directly deployed in federated environments without violating data privacy regulations.

2.2. Subgraph Federated Learning

Federated learning (FL) [11] has become the de facto standard for collaborative model training without sharing raw data. While federated graph machine learning (FGML) has been extensively surveyed [12], current works are predominantly focused on representation learning, leaving the structured task of “counting” largely unexplored.

Existing FGML works primarily address tasks like node classification and link prediction, where the main challenge is the missing crossgraph neighbor problem caused by graph partitioning. To mitigate this, FedSage+ [33] and FedDep [34] employ generative models to “hallucinate” missing neighbors, thereby restoring connectivity information. FedNI [35] utilizes network inpainting to assist prediction in population graphs, while FedCog [36] introduces a decoupled training strategy to handle coupled graphs efficiently. FedGCN [37] tries to strike a balance between availability and privacy and recover the lost edge information of graph data across clients. Baek et al. [38] proposed FedPub, which personalizes models based on functional similarity among clients. Recent advances in 2025 continue to refine these paradigms: FedStruct [39] proposes a decoupled architecture for graph classification, Fedlog [40] uses synthetic data from multiple clients to complete server-side model training, and FedLap [41] leverages spectral methods to handle system heterogeneity. However, the objective of these methods is to learn high-quality node embeddings for classification, rather than performing precise structural pattern matching and counting, which requires capturing higher-order topological interactions.

Current research on subgraph counting in federated environments, largely motivated by the database query setting, is driven by strict privacy requirements and thus often resorts to heavy cryptographic techniques for exact counting. Yuan et al. [13] designed a framework for subgraph matching over isolated graph databases, focusing on query decomposition rather than learning. For simple motifs like triangles, MAGO [3] achieves maliciously secure counting on decentralized social graphs using homomorphic encryption. Similarly, CARGO [14] and Sectric [15] combine Differential Privacy with Secure Multi-Party Computation to enable triangle counting without trusted servers.

While these cryptography-based methods offer strong privacy guarantees, they suffer from fundamental limitations that hinder their widespread adoption for general counting tasks. First, limited applicability: most methods are hard-coded for specific simple motifs (e.g., triangles or cliques) and lack the flexibility to generalize to arbitrary, complex query patterns required in many real-world applications. Second, accuracy–efficiency trade-off: techniques like Differential Privacy inevitably introduce noise that degrades counting precision—a critical issue for regression tasks—while homomorphic encryption incurs prohibitive computational and communication overheads when handling complex graph matching operations. Consequently, there remains a significant gap between those works and the application requirements: the lack of a general-purpose federated framework capable of learning to count arbitrary complex subgraphs with high precision and efficiency, while leveraging the inherent structural isolation of federated architectures to preserve privacy. This work aims to bridge this gap by exploring a neural-based federated counting paradigm.

3. Preliminary

3.1. Graph Notation

A graph is denoted by $\mathcal{G}=({\mathcal{V}}_{\mathcal{G}},{\mathcal{E}}_{\mathcal{G}},{\mathcal{X}}_{\mathcal{G}},{\mathcal{Y}}_{\mathcal{G}})$, where ${\mathcal{V}}_{\mathcal{G}}$ represents a set of nodes, ${\mathcal{E}}_{\mathcal{G}}\subseteq {\mathcal{V}}_{\mathcal{G}}\times {\mathcal{V}}_{\mathcal{G}}$ represents a set of edges, ${\mathcal{X}}_{\mathcal{G}}$ is a node label function that maps a node to node labels, and ${\mathcal{Y}}_{\mathcal{G}}$ is an edge label function that maps an edge to edge labels.

A graph $\mathcal{S}=({\mathcal{V}}_{\mathcal{S}},{\mathcal{E}}_{\mathcal{S}},{\mathcal{X}}_{\mathcal{S}},{\mathcal{Y}}_{\mathcal{S}})$ is a subgraph of $\mathcal{G}$ if ${\mathcal{V}}_{\mathcal{S}}\subseteq {\mathcal{V}}_{\mathcal{G}}$, ${\mathcal{E}}_{\mathcal{S}}\subseteq ({\mathcal{V}}_{\mathcal{S}}\times {\mathcal{V}}_{\mathcal{S}})\cap {\mathcal{E}}_{\mathcal{G}}$, and it preserves the labeling such that $\forall u,v\in {\mathcal{V}}_{\mathcal{S}},{\mathcal{X}}_{\mathcal{S}}\left(u\right)={\mathcal{X}}_{\mathcal{G}}\left(u\right),{\mathcal{X}}_{\mathcal{S}}\left(v\right)={\mathcal{X}}_{\mathcal{G}}\left(v\right)$, if $⟨u,v⟩\in {\mathcal{E}}_{\mathcal{S}}$ then ${\mathcal{Y}}_{\mathcal{S}}\left(⟨u,v⟩\right)={\mathcal{Y}}_{\mathcal{G}}\left(⟨u,v⟩\right)$ else ${\mathcal{Y}}_{\mathcal{S}}\left(⟨u,v⟩\right)=\varnothing$.

In our discussion, an undirected graph is regarded as a bidirectional graph, that is, the connecting edge between the two points $u,v$ in an undirected graph is split into $⟨u,v⟩$ and $⟨v,u⟩$.

3.2. Subgraph Isomorphism

Definition 1 (Graph Isomorphism).

A graph ${\mathcal{G}}_1$ is is isomorphic to another graph ${\mathcal{G}}_2$ if and only if there exists a bijective mapping function $\psi :{\mathcal{V}}_{{\mathcal{G}}_1}\to {\mathcal{V}}_{{\mathcal{G}}_2}$ such that:

• $\forall v\in {\mathcal{V}}_{{\mathcal{G}}_1},\psi \left(v\right)\in {\mathcal{V}}_{{\mathcal{G}}_2}$;
• ${\mathcal{X}}_{{\mathcal{G}}_1}\left(v\right)={\mathcal{X}}_{{\mathcal{G}}_2}\left(\psi \left(v\right)\right)$;
• $\forall ⟨u,v⟩\in {\mathcal{E}}_{{\mathcal{G}}_1},⟨\psi \left(u\right),\psi \left(v\right)⟩\in {\mathcal{E}}_{{\mathcal{G}}_2}$;
• ${\mathcal{Y}}_{{\mathcal{G}}_1}\left(⟨u,v⟩\right)={\mathcal{Y}}_{{\mathcal{G}}_2}\left(⟨\psi \left(u\right),\psi \left(v\right)⟩\right)$.

We denote that the two graphs ${\mathcal{G}}_1$ and ${\mathcal{G}}_2$ are isomorphic as ${\mathcal{G}}_1\simeq {\mathcal{G}}_2$. Theoretically, the graph isomorphism relation is transitive: if ${\mathcal{G}}_1\simeq {\mathcal{G}}_2$ and ${\mathcal{G}}_2\simeq {\mathcal{G}}_3$, then ${\mathcal{G}}_1\simeq {\mathcal{G}}_3$.

Definition 2 (Subgraph Isomorphism).

A pattern graph $\mathcal{Q}$ is subgraph isomorphic to a given input graph $\mathcal{G}$ if there exists a subgraph $\mathcal{S}$ of the input graph $\mathcal{G}$ which is isomorphic to pattern graph $\mathcal{Q}$.

3.3. Problem Definition

Given an input graph $\mathcal{G}$ and a query pattern $\mathcal{Q}$, the problem of subgraph isomorphism counting aims to determine the number of subgraphs in $\mathcal{G}$ that are isomorphic to $\mathcal{Q}$. In existing studies, subgraph counting approaches are generally categorized into two types: exact counting and approximate counting. Most existing learning-based methods focus on the approximate counting task. Following this paradigm, this paper also addresses the problem of approximate subgraph isomorphism counting.

We denote the count of subgraph isomorphisms as $c(\mathcal{G},\mathcal{Q})$. Typically, the query graph $\mathcal{Q}$ is significantly smaller than the input graph $\mathcal{G}$, satisfying $|{\mathcal{V}}_{\mathcal{Q}}|\ll |{\mathcal{V}}_{\mathcal{G}}|$ and $|{\mathcal{E}}_{\mathcal{Q}}|\ll |{\mathcal{E}}_{\mathcal{G}}|$. As this is a non-trivial #P-Complete problem, the search complexity and space consumption are often computationally prohibitive, making exact enumeration impractical for large graphs.

4. Proposed Approach

In this section, we present the technical details of FedCount. We first introduce the lightweight structural encoding scheme designed for privacy-preserving local counting. We then elaborate on the edge-centric Siamese encoder and the query-conditioned modulation mechanism, followed by the specific objective function used for optimization.

4.1. Framework Overview

We propose FedCount, a privacy-preserving framework designed for general subgraph isomorphism counting across distributed data silos. The framework consists of a central server and a set of K clients, denoted as $\mathcal{C}=\{C_1,C_2,\dots ,C_K\}$. Each client $C_k$ holds a private local input graph dataset ${\mathcal{D}}_k=\left\{({\mathcal{G}}_i,Q_j,c_{i,j})\right\}$, where each sample consists of a target graph ${\mathcal{G}}_i$ and the ground-truth count $c_{i,j}$ of a specific query pattern ${\mathcal{Q}}_j$. Crucially, the raw graph data in ${\mathcal{D}}_k$ never leaves the local device, preserving data sovereignty. The model is illustrated in Figure 1.

Figure 1. Overall framework of FedCount.

The collaborative training process follows a standard federated round, which iterates through the following three steps:

• Global Distribution: The server broadcasts the current global model parameters ${\mathbf{W}}_g^{\left(t\right)}$ and the query pattern $\mathcal{Q}$ to a selected subset of active clients.
• Local Update: Each client $C_k$ initializes its local model with ${\mathbf{W}}_g^{\left(t\right)}$ and performs local training on ${\mathcal{D}}_k$ to minimize the counting error. This step utilizes our proposed Edge-Centric Counting Model (detailed in Section 4.2, Section 4.3 and Section 4.4) to generate high-quality structural gradients.
• Aggregation: Clients upload their updated model updates (e.g., gradients or weights) to the server. The server then aggregates these updates to refine the global model for the next round, typically employing FedAvg [11] or FedSGD.

This architecture decouples model training from direct data access, leveraging the structural isolation of clients as a foundational privacy safeguard.

4.2. Local Structural Encoding

Standard GNNs often struggle to distinguish edge-induced subgraphs due to the limitation of the 1-WL test. While recent advanced methods like ESC-GNN [17] improve expressiveness by computing global all-pair distances, such operations are computationally prohibitive for large-scale graphs in federated settings. To balance efficiency and expressiveness, we propose a Lightweight Local Structural Encoding scheme.

We design a hierarchical feature construction strategy that differentiates between generalizable patterns and specific local instances:

• Generalizable Features (${\mathbf{x}}^{[l,d]}$): Used during the message passing phase. These features consist solely of node/edge Labels (l) and degrees (d). Since these attributes are invariant to node identities, they allow the GNN to learn universal structural patterns that are transferable across different graphs and clients.
• Specific Features (${\mathbf{x}}^{[e,l,d]}$): Used during the graph modulation phase (see Section 4.4). In addition to labels and degrees, these features incorporate Element Identifiers (e) (i.e., hashed node/edge IDs). This allows the modulation mechanism to distinguish and target specific local substructures within a given input graph.

Formally, let $\mathbf{emb}(·)$ denote the embedding lookup function. For an edge $⟨u,v⟩$, its initial representation ${\mathbf{h}}_{⟨u,v⟩}{>}^{\left(0\right)}$ is constructed by explicitly encoding the edge alongside its two endpoints:

$${\mathbf{h}}_{⟨u,v⟩}^{\left(0\right)}=\mathbf{emb}\left({\mathbf{x}}_u\right)\Vert \mathbf{emb}\left({\mathbf{x}}_{⟨u,v⟩}\right)\Vert \mathbf{emb}\left({\mathbf{x}}_v\right)$$

(1)

where ‖ denotes the concatenation operation and $\mathbf{x}$ corresponds to the feature set (${\mathbf{x}}^{[l,d]}$ or ${\mathbf{x}}^{[e,l,d]}$) required by the specific processing stage. This triplet encoding ensures that the edge representation strictly captures the 1-hop local structural context.

4.3. Edge-Level Encoder

To map the topological information of both the query pattern $\mathcal{Q}$ and the input graph $\mathcal{G}$ into a latent feature space, we employ a dual-branch framework. Specifically, all input graphs share a common Edge-Level Encoder, and all query patterns share a structurally identical encoder. While these two branches possess the same network architecture to ensure feature compatibility, their parameters can be either distinct or shared depending on the specific configuration.

4.3.1. Edge-to-Edge Message Passing

The core of our encoder is an edge-centric message passing mechanism designed to capture high-order structural interactions. For the l-th layer, the representation of an edge $⟨u,v⟩$, denoted as ${\mathbf{h}}_{⟨u,v⟩}^{\left(l\right)}$, is updated by aggregating messages from its neighboring edges $\mathcal{N}(⟨u,v⟩)$ (i.e., edges sharing a common node with $⟨u,v⟩$). The update rule is formulated as

$${\mathbf{h}}_{⟨u,v⟩}^{\left(l\right)}=\sigma \left({\mathbf{W}}_1^{\left(l\right)}{\mathbf{h}}_{⟨u,v⟩}^{(l-1)}+{\mathbf{W}}_2^{\left(l\right)}·\mathrm{AGG}\left(\{{\mathbf{h}}_k^{(l-1)}\mid k\in \mathcal{N}\left(⟨u,v⟩\right)\}\right)+{\mathbf{b}}^{\left(l\right)}\right)$$

(2)

where ${\mathbf{W}}_1^{\left(l\right)},{\mathbf{W}}_2^{\left(l\right)}$ are learnable weight matrices, ${\mathbf{b}}^{\left(l\right)}$ is the bias vector, and $\mathrm{AGG}(·)$ is a permutation-invariant aggregation function (e.g., Sum or Mean).

4.3.2. Residual Stacking for Deep Architectures

Capturing large-diameter subgraphs necessitates a deep network architecture. However, training deep GNNs in a federated setting is notoriously unstable due to the gradient vanishing problem. To mitigate this, we implement residual connections across layers. The output of the linear transformation is added to the input of the next layer:

$${\mathbf{h}}_{⟨u,v⟩}^{\left(l\right)}\leftarrow {\mathbf{h}}_{⟨u,v⟩}^{\left(l\right)}+{\mathbf{h}}_{⟨u,v⟩}^{(l-1)}$$

(3)

During the Edge-Level Encoder stage, by integrating the residual mechanism with edge-centric message passing, our encoder achieves robust performance in federated settings. Specifically, the residual connections facilitate direct gradient propagation to earlier layers, effectively mitigating the vanishing gradient problem inherent in deep architectures. This ensures the stable training of models capable of capturing large-diameter subgraphs, even under the periodic aggregation of FedAvg. Simultaneously, the edge-level encoding explicitly models high-order interactions between edges, enabling the network to capture complex topological semantics that are often overlooked by standard node-centric GNNs.

4.4. Query-Conditioned Matching Network

A core challenge in subgraph counting is that different query patterns activate distinct substructures within the same target graph. To address this, we adopt a query-conditioned graph modulation mechanism. Instead of using a static representation for the input graph $\mathcal{G}$, we utilize Feature-wise Linear Modulation (FiLM) to adaptively highlight edges in $\mathcal{G}$ that are structurally relevant to the current query $\mathcal{Q}$.

4.4.1. Query Graph Representation

First, we obtain a global representation vector ${\mathbf{h}}_{\mathcal{Q}}$ for the query graph. This is achieved by aggregating the final edge embeddings from the query branch encoder:

$${\mathbf{h}}_{\mathcal{Q}}=\sigma \left({\mathbf{W}}_{\mathcal{Q}}·{\mathrm{AGG}}_{e\in {\mathcal{E}}_{\mathcal{Q}}}\left({\mathbf{h}}_e^{\left(L\right)}\right)\right)$$

(4)

where ${\mathbf{W}}_{\mathcal{Q}}$ is a learnable projection matrix.

4.4.2. Query-Guided Modulation (FiLM)

We use ${\mathbf{h}}_{\mathcal{Q}}$ to modulate the edge representations of the input graph. Let ${\mathbf{h}}_{⟨u,v⟩}$ denote the embedding of an edge $⟨u,v⟩$ in $\mathcal{G}$ generated by the input branch encoder. We first project it via a linear transformation: ${\mathbf{h}}_{⟨u,v⟩}^{\prime }={\mathbf{W}}_{\mathcal{G}}{\mathbf{h}}_{⟨u,v⟩}$. Then, we compute the scaling factor ${\alpha }_{⟨u,v⟩}$ and shifting factor ${\beta }_{⟨u,v⟩}$ dynamically based on both the local edge feature and the global query context:

$$\begin{array}{cc}\hfill {\alpha }_{⟨u,v⟩}& ={\mathrm{FCL}}_{\alpha ,1}\left({\mathbf{h}}_{⟨u,v⟩}^{\prime }\right)+{\mathrm{FCL}}_{\alpha ,2}\left({\mathbf{h}}_{\mathcal{Q}}\right)\hfill \\ \hfill {\beta }_{⟨u,v⟩}& ={\mathrm{FCL}}_{\beta ,1}\left({\mathbf{h}}_{⟨u,v⟩}^{\prime }\right)+{\mathrm{FCL}}_{\beta ,2}\left({\mathbf{h}}_{\mathcal{Q}}\right)\hfill \end{array}$$

(5)

After that, the modulated edge representation ${\tilde{\mathbf{h}}}_{⟨u,v⟩}$ is obtained via an affine transformation:

$${\tilde{\mathbf{h}}}_{⟨u,v⟩}=({\alpha }_{⟨u,v⟩}+1)\odot {\mathbf{h}}_{⟨u,v⟩}^{\prime }+{\beta }_{⟨u,v⟩}$$

(6)

Such a mechanism allows the model to selectively amplify edges in $\mathcal{G}$ that match the structural pattern of $\mathcal{Q}$ while suppressing irrelevant ones. The final global representation of the input graph is aggregated as ${\mathbf{h}}_{\mathcal{G}}=\sigma \left(\mathrm{AGG}\left({\tilde{\mathbf{h}}}_{⟨u,v⟩}\right)\right)$.

4.4.3. Global Matching and Prediction

To predict the subgraph isomorphism count, we construct a comprehensive interaction feature vector ${\mathbf{z}}_{match}$ by capturing the relationship between the query and the modulated input graph:

$${\mathbf{z}}_{match}=\mathrm{LeakyReLU}\left(\mathrm{FCL}\left({\mathbf{h}}_{\mathcal{Q}}\Vert {\mathbf{h}}_{\mathcal{G}}\Vert ({\mathbf{h}}_{\mathcal{G}}-{\mathbf{h}}_{\mathcal{Q}})\Vert ({\mathbf{h}}_{\mathcal{G}}\odot {\mathbf{h}}_{\mathcal{Q}})\right)\right)$$

(7)

Finally, to assist the regression task with explicit size constraints, we concatenate graph size heuristics to the matching vector. The predicted count $\widehat{y}$ is computed as

$$\widehat{y}={\mathrm{FCL}}_{out}\left({\mathbf{z}}_{match}\Vert |{\mathcal{V}}_{\mathcal{G}}|\Vert |{\mathcal{V}}_{\mathcal{Q}}|\Vert {\displaystyle \frac{1}{|{\mathcal{V}}_{\mathcal{G}}|}}\Vert {\displaystyle \frac{1}{|{\mathcal{V}}_{\mathcal{Q}}|}}\right)$$

(8)

4.5. Optimization Objective

The training objective of FedCount is designed to ensure high counting precision while maintaining model generalization. The total local loss function ${\mathcal{L}}_{total}$ for a client is composed of three components: the prediction error, the modulation sparsity regularization, and the model parameter regularization.

Prediction Loss (${\mathcal{L}}_{pred}$). Since subgraph isomorphism counting is a regression task, we employ the Mean Absolute Error (MAE) loss to minimize the discrepancy between the predicted count ${\widehat{c}}_{i,j}$ and the ground-truth count $c_{i,j}$. MAE is chosen for its robustness to outliers compared to MSE:

$${\mathcal{L}}_{pred}={\displaystyle \frac{1}{\left|\mathcal{D}\right|}}\sum _{({\mathcal{G}}_i,{\mathcal{Q}}_j,c_{i,j})\in \mathcal{D}}|{\widehat{c}}_{i,j}-c_{i,j}|$$

(9)

Modulation Sparsity Loss (${\mathcal{L}}_{FiLM}$). To encourage the model to select only the most relevant substructures and suppress noise, we impose an L2 regularization on the Feature-wise Linear Modulation (FiLM) modulation parameters ($\alpha$ and $\beta$). This constraint promotes sparsity in the modulation mechanism, ensuring that the model does not over-activate irrelevant edges:

$${\mathcal{L}}_{FiLM}={\displaystyle \frac{1}{\left|\mathcal{D}\right|}}\sum _{i=1}^{\left|\mathcal{D}\right|}\sum _{⟨u,v⟩\in {\mathcal{E}}_{{\mathcal{G}}_i}}\left(\parallel {\alpha }_{⟨u,v⟩}{\parallel }_2^2+{\parallel {\beta }_{⟨u,v⟩}\parallel }_2^2\right)$$

(10)

Weight Regularization (${\mathcal{L}}_{reg}$). Standard L2 regularization is applied to the trainable model parameters $\Theta$ to prevent overfitting:

$${\mathcal{L}}_{reg}={\parallel \Theta \parallel }_2^2$$

(11)

Total Objective. The final objective function is a weighted sum of these three terms:

$${\mathcal{L}}_{total}={\mathcal{L}}_{pred}+{\lambda }_1{\mathcal{L}}_{FiLM}+{\lambda }_2{\mathcal{L}}_{reg}$$

(12)

where ${\lambda }_1$ and ${\lambda }_2$ are hyperparameters balancing the trade-off between counting accuracy and structural regularization.

4.6. Federated Training Protocol

Having defined the local counting model and the optimization objective, we now detail the collaborative training process. The goal of FedCount is to minimize the global loss function ${\mathcal{L}}_{global}$ across K distributed clients without accessing their private graph data ${\mathcal{D}}_k$.

Let $n_k=\left|{\mathcal{D}}_k\right|$ be the number of samples on client k, and $n={\sum }_{k=1}^K{n}_k$ be the total sample size. The global objective is formulated as the weighted average of local losses:

$$\underset{\mathbf{W}}{min}\mathcal{L}\left(\mathbf{W}\right)=\sum _{k=1}^K{\displaystyle \frac{n_k}{n}}{\mathcal{L}}_k\left(\mathbf{W}\right)$$

(13)

where ${\mathcal{L}}_k\left(\mathbf{W}\right)$ is the local objective function defined in Section 4.5. To solve this optimization problem, we implement two standard federated aggregation strategies: FedAvg and FedSGD.

4.6.1. Federated Averaging (FedAvg)

FedAvg [11] is the default protocol in our framework due to its communication efficiency. Instead of communicating every iteration, clients perform multiple epochs of local training before synchronizing with the server.

The process for communication round t is as follows:

• Server Broadcast: The server sends the current global model parameters ${\mathbf{W}}_t$ to a subset of selected clients ${\mathcal{S}}_t$.
• Local Update: Each client $k\in {\mathcal{S}}_t$ initializes local parameters ${\mathbf{W}}_k\leftarrow {\mathbf{W}}_t$ and performs E local epochs of SGD optimization on its private dataset ${\mathcal{D}}_k$ with learning rate $\eta$:

  $${\mathbf{W}}_k\leftarrow {\mathbf{W}}_k-\eta \nabla {\mathcal{L}}_k\left({\mathbf{W}}_k\right)\left(\mathrm{repeated}E\mathrm{times}\right)$$
• Aggregation: Clients upload their updated parameters ${\mathbf{W}}_k^{(t+1)}$. The server aggregates them to produce the new global model:

  $${\mathbf{W}}_{t+1}\leftarrow \sum _{k\in {\mathcal{S}}_t}{\displaystyle \frac{n_k}{n}}{\mathbf{W}}_k^{(t+1)}$$

4.6.2. Federated SGD (FedSGD)

FedSGD serves as a baseline strategy and can be viewed as a special case of FedAvg where the local epoch $E=1$ and the local batch size encompasses the entire local dataset (Full-Batch Gradient Descent).

In FedSGD, clients compute the exact gradients based on the current global model and upload them directly (or the equivalent one-step weight update) to the server.

The process for communication round t is:

• Server Broadcast: The server sends ${\mathbf{W}}_t$ to clients.
• Gradient Computation: Each client k computes the gradient over its local data:

  $${\mathbf{g}}_k=\nabla {\mathcal{L}}_k\left({\mathbf{W}}_t\right)$$
• Aggregation and Update: The server aggregates the gradients and updates the global model:

  $${\mathbf{W}}_{t+1}\leftarrow {\mathbf{W}}_t-\eta \sum _{k=1}^K{\displaystyle \frac{n_k}{n}}{\mathbf{g}}_k$$

While FedSGD provides more accurate gradient directions, it requires more frequent communication rounds compared to FedAvg to reach convergence. For a comprehensive overview of the proposed framework, the complete training procedure of FedCount, which integrates the local structural encoding, query-conditioned modulation, and federated aggregation, is summarized in Algorithm 1.

4.7. Theoretical Analysis

To rigorously evaluate the efficiency and security of FedCount, we provide a theoretical analysis regarding its computational complexity and privacy guarantees.

4.7.1. Complexity Analysis

The computational cost of FedCount primarily stems from the local client updates, as the server-side aggregation is negligible. Let $\left|\mathcal{V}\right|$ and $\left|\mathcal{E}\right|$ denote the number of nodes and edges in the input graph $\mathcal{G}$, and let $D_{avg}$ be the average degree.

Time Complexity

The generation of local structural encodings (Section 4.2) involves degree calculation and hashing, which costs $O\left(\right|\mathcal{V}|+|\mathcal{E}\left|\right)$. For the Edge-Level Encoder with L layers (Section 4.3), the message passing operation aggregates information from neighboring edges. The complexity is $O(L·|\mathcal{E}|·D_{avg})$. The query-conditioned modulation (Section 4.4) involves element-wise operations on edge features, costing $O\left(\right|\mathcal{E}|·d_{hidden})$. The total time complexity is linear with respect to the number of edges, i.e., $O\left(\right|\mathcal{E}\left|\right)$. In contrast, traditional exact subgraph enumeration algorithms (e.g., VF2, Ullmann) exhibit exponential complexity $O\left(\right|\mathcal{V}{|}^k)$ for a query of size k. This confirms that FedCount is scalable to large-scale graphs.

Space Complexity

Since FedCount operates on edge batches and avoids storing the full adjacency matrix in dense format, the space complexity is $O\left(\right|\mathcal{E}|+|\mathcal{V}\left|\right)$.

Algorithm 1: Federated training protocol for FedCount

Require:  Distributed datasets $\{{\mathcal{D}}_1,\dots ,{\mathcal{D}}_K\}$, Query set $\mathbb{Q}$, Global epochs T, Local epochs E, Learning rate $\eta$, Hyperparameters ${\lambda }_1,{\lambda }_2$. Ensure:  Trained global model parameters ${\mathbf{W}}_g$.   1: Server executes:   2: Initialize global model parameters ${\mathbf{W}}_g^{\left(0\right)}$.   3: for round $t=0,1,\dots ,T-1$ do   4:     Server selects a subset of clients ${\mathcal{S}}_t\subseteq \{1,\dots ,K\}$.   5:     Server samples a query batch ${\mathcal{Q}}_{batch}\sim \mathbb{Q}$.   6:     Broadcast ${\mathbf{W}}_g^{\left(t\right)}$ and ${\mathcal{Q}}_{batch}$ to all clients in ${\mathcal{S}}_t$.   7:     for each client $k\in {\mathcal{S}}_t$ in parallel do   8:         ${\mathbf{W}}_k^{(t+1)}\leftarrow \mathbf{ClientUpdate}(k,{\mathbf{W}}_g^{\left(t\right)},{\mathcal{Q}}_{batch})$   9:     end for 10:     Aggregation (FedAvg): 11:     ${\mathbf{W}}_g^{(t+1)}\leftarrow {\sum }_{k\in {\mathcal{S}}_t}{\displaystyle \frac{|{\mathcal{D}}_k|}{|{\mathcal{D}}_{{\mathcal{S}}_t}|}}{\mathbf{W}}_k^{(t+1)}$ 12: end for 13: return  ${\mathbf{W}}_g^{\left(T\right)}$ 14: Function $\mathbf{ClientUpdate}(k,\mathbf{W},{\mathcal{Q}}_{batch})$: 15: Initialize local model ${\mathbf{W}}_k\leftarrow \mathbf{W}$. 16: for local epoch $e=1,\dots ,E$ do 17:     for batch $\mathcal{B}\subseteq {\mathcal{D}}_k$ do 18:         1. Structural Encoding: Generate edge features ${\mathbf{h}}^{\left(0\right)}$ using Equation (1). 19:         2. Siamese Encoding: Extract deep features ${\mathbf{h}}^{\left(L\right)}$ via Residual GNN using Equations (2) and (3). 20:         3. Modulation: Compute $\alpha ,\beta$ and modulate input graph features via FiLM using Equation (5). 21:         4. Prediction: Compute $\widehat{y}$ and interaction features ${\mathbf{z}}_{match}$ using Equations (7) and (8). 22:         5. Optimization: 23:         Compute Loss: $\mathcal{L}\leftarrow {\mathcal{L}}_{MAE}+{\lambda }_1{\mathcal{L}}_{FiLM}+{\lambda }_2{\parallel {\mathbf{W}}_k\parallel }^2$ according to Equation (12) 24:         Update: ${\mathbf{W}}_k\leftarrow {\mathbf{W}}_k-\eta \nabla \mathcal{L}$ 25:     end for 26: end for 27: return  ${\mathbf{W}}_k$

4.7.2. Threat Model and Privacy Analysis

We explicitly define our threat model and acknowledge the boundaries of our privacy claims as below.

Threat Model

We assume an “honest-but-curious” server and participating clients. The primary privacy goal of FedCount is to strictly prevent the direct leakage of raw graph topology (adjacency matrix A) and original node/edge features (X) to the server or other clients.

Privacy via Structural Isolation

FedCount achieves this privacy goal primarily through three distinct, lightweight mechanisms:

• Data Locality: The raw graph topology (adjacency matrix A) and node features (X) never leave the local client. This satisfies the fundamental requirement of data residency.
• Gradient Obfuscation: Instead of sharing raw data, clients only upload model gradients $\nabla \mathbf{W}$ or parameter updates. Unlike reconstructing continuous images from gradients (which is feasible in some settings), reverse-engineering discrete graph structures from the gradients of a deep, residual GNN is significantly more challenging. Furthermore, the inherent “many-to-one” mapping of the subgraph counting task (where highly diverse graph topologies can map to the same scalar count) creates an immense solution space, making exact topology reconstruction computationally intractable for potential attackers.
• Structural Hashing: As introduced in Section 4.2, our lightweight encoding scheme hashes specific structural identities (e.g., node IDs). Even if an attacker intercepts the initial embeddings during transmission, they cannot reverse-engineer the original node mapping without the specific hash keys securely kept on local devices.

Privacy Limitations and Trade-Offs

However, we explicitly tone down the claim of absolute privacy. FedCount currently does not employ heavy cryptographic techniques and thus does not provide formal theoretical guarantees against advanced inference attacks. Specifically, our framework is still susceptible to model inversion, gradient leakage, and membership inference attacks during the aggregation stage.

While integrating additional privacy-preserving techniques could mitigate these risks, they introduce severe practical trade-offs for the subgraph counting task:

• Differential Privacy (DP): DP injects calibrated noise into the gradients. Since subgraph isomorphism counting is a highly sensitive regression task, the injected noise would drastically degrade the precise counting accuracy required by the model.
• Secure Aggregation/SMPC: While Secure Multi-Party Computation can prevent the server from inspecting individual gradients, it incurs prohibitive communication and computational overheads, largely negating the efficiency and scalability advantages of our lightweight edge-centric framework.

5. Experiments

5.1. Experimental Setup

5.1.1. Datasets

To comprehensively evaluate the performance and scalability of FedCount, we conduct experiments on four datasets: one real-world molecular dataset (MUTAG), two synthetic datasets (SMALL and LARGE), and a newly curated federated heterophilic social network dataset (SOCIAL). See Table 1 for the statistics of the datasets.

Table 1. Summary of datasets.

	SMALL	LARGE	MUTAG	SOCIAL
# Queries	75	122	24	72
# Graphs	6790	3240	188	4
# Triples	448,140	395,280	4512	288
A.($|{\mathcal{V}}_{\mathcal{Q}}|$)	5.20	8.43	3.50	6.25
A.($|{\mathcal{E}}_{\mathcal{Q}}|$)	6.80	12.23	2.50	8.11
A.($|{\mathcal{V}}_{\mathcal{G}}|$)	32.62	239.94	17.93	297.00
A.($|{\mathcal{E}}_{\mathcal{G}}|$)	76.34	559.68	39.58	436.56
A.($c(\mathcal{G},\mathcal{Q})$)	14.83	34.42	17.76	9.16
M.($\left|L\right|$)	16	64	7	6
M.($|L^{\prime }|$)	16	64	4	1

“#” means number, “A.” means average, “M.” means max.

Real-world Dataset (MUTAG). We utilize the MUTAG dataset, a standard benchmark consisting of mutagenic aromatic and nitro compounds. Each graph represents a molecule, where nodes correspond to atoms and edges represent chemical bonds. This dataset is employed to assess the model’s capability in capturing structural patterns in realistic scientific domains.

Synthetic Datasets (SMALL & LARGE). To systematically evaluate the model’s robustness across varying graph sizes and densities, we generate two synthetic datasets, denoted as SMALL and LARGE. We employ the generator proposed in [9] to generate random graphs. The specific generation parameters for pattern graphs $\mathcal{Q}$ and input graphs $\mathcal{G}$ are detailed in Table 2. The SMALL dataset is designed to evaluate fine-grained counting precision on smaller topologies, while the LARGE dataset tests the scalability of the framework on larger graphs with higher edge densities.

Table 2. Parameters for generating synthetic datasets.

	Parameters	SMALL	LARGE
Pattern graph $\mathcal{Q}$	$|V_{\mathcal{Q}}|$	$\{3,4,8\}$	$\{3,4,8,16\}$
	$|E_{\mathcal{Q}}|$	$\{2,4,8\}$	$\{2,4,8,16\}$
	$|L_{\mathcal{Q}}|$	$\{2,4,8\}$	$\{2,4,8,16\}$
	$|L_{\mathcal{Q}}^{\prime }|$	$\{2,4,8\}$	$\{2,4,8,16\}$
Input graph $\mathcal{G}$	$|V_{\mathcal{G}}|$	$\{8,16,32,64\}$	$\{64,128,256,512\}$
	$|E_{\mathcal{G}}|$	$\{8,16,\dots ,256\}$	$\{64,128,\dots ,2048\}$
	$|L_{\mathcal{G}}|$	$\{4,8,16\}$	$\{16,32,64\}$
	$|L_{\mathcal{G}}^{\prime }|$	$\{4,8,16\}$	$\{16,32,64\}$
Constraints	Max Counts	1024	4096

Heterophilic Social Networks (SOCIAL). To rigorously evaluate our framework’s generalizability across diverse graph domains and its robustness against extreme data heterogeneity (Non-IID), we construct a highly skewed federated dataset, denoted as SOCIAL, using four real-world heterophilic networks [42]: Citeseer, Cornell, Texas, and Wisconsin. Rather than utilizing these datasets for traditional node classification, we extract their raw topological structures for subgraph counting. To avoid the computationally prohibitive overhead of exact subgraph enumeration on disconnected noisy fragments, we strictly extract the maximum connected component from each dataset (discarding small isolated components that typically contain only 2–3 nodes). We then assign each component exclusively to a distinct client ($K=4$), generate diverse query patterns, and obtain ground-truth counts via the exact solver. This deliberate partitioning creates a highly challenging, extreme Non-IID federated environment characterized by highly skewed graph sizes and vastly different edge densities.

Ground-Truth Generation. The ground-truth subgraph counts are obtained using the VF2 algorithm [43], an exact subgraph isomorphism solver. To explicitly address the computational cost of generating these exact training labels (as discussed in our limitations), the total offline generation time can be systematically derived from our reported statistics. Specifically, the average running time per triplet can be calculated by dividing the total VF2 execution time on the datasets (reported in Table 3) by the number of dataset triples. The exact number of testing, training, and validation samples for each dataset can be precisely determined using the total triples listed in Table 1 combined with the dataset partitioning strategy detailed in Section 5.1.4. Consequently, the total offline label generation time is simply the average per-triplet time multiplied by the sum of the training and validation samples. It is worth noting that while acquiring these exact labels introduces a non-trivial one-time offline cost prior to training, this upfront cost is highly acceptable. The core advantage of our neural framework lies in its ability to completely bypass this exact matching phase during real-world deployment, reducing the subsequent online inference cost to near zero.

Table 3. Performance comparison with baselines.

Method	Setting	MUTAG			SMALL			LARGE			SOCIAL
		MAE	Q-Error	Time/s	MAE	Q-Error	Time/s	MAE	Q-Error	Time/s	MAE	Q-Error	Time/s
VF2 [43]	Exact	0	1	0.79	0	1	929.95	0	1	8365.03	0	1	629.30
DiamNet [9]	Approx.	6.81	2.67	0.67	16.62	2.40	50.32	42.28	6.73	67.15	104.65	59.48	1.21
Count-GNN [10]	Approx.	3.55	1.14	0.02	13.43	1.53	6.48	39.80	4.48	11.37	71.02	33.82	0.11
DeSCo [31]	Approx.	2.56	1.29	3.61	18.31	2.18	20.21	47.92	8.25	49.04	69.75	37.46	3.74
FedCount (Ours)	Approx.	2.29	1.30	0.02	10.08	1.53	6.81	36.75	4.69	12.37	64.34	23.09	0.11

5.1.2. Baselines

To thoroughly evaluate the performance of FedCount, we compare it against a standard exact solver and three state-of-the-art deep learning-based subgraph counting methods. It is important to note that all neural baselines are trained in a centralized setting, where they have direct access to the aggregated dataset. We use these centralized models to establish a performance upper bound for verifying the efficacy of our federated framework.

• VF2 [43]: A standard exact subgraph isomorphism algorithm based on a state-space search. It serves as the baseline for evaluating inference efficiency.
• DiamNet [9]: A neural counting framework that utilizes a Dynamic Intermedium Attention Memory Network. We implement it using RGIN (Relational Graph Isomorphism Network) as the backbone encoder to capture relational structures.
• Count-GNN [10]: A state-of-the-art method that introduces an edge-centric message passing scheme. It employs a query-conditioned graph modulation mechanism to adaptively match diverse query patterns.
• DeSCo [31]: A scalable framework designed for generalization. It utilizes a canonical partition strategy to decompose target graphs into neighborhoods, ensuring accurate counting on large-scale graphs.

For fairness, the centralized baselines are trained on the union of all the local datasets ${\bigcup }_k{\mathcal{D}}_k$, while FedCount is trained under the strict federated setting without data sharing.

5.1.3. Evaluation Metrics

To comprehensively assess the performance of FedCount, we employ two complementary metrics: Mean Absolute Error (MAE) and Q-error.

Mean Absolute Error (MAE). MAE measures the average magnitude of errors between the predicted counts ${\widehat{y}}_i$ and the ground-truth counts $y_i$. It is defined as

$$\mathrm{MAE}={\displaystyle \frac{1}{N}}\sum _{i=1}^N|{\widehat{y}}_i-y_i|$$

(14)

where N is the total number of test samples. Lower MAE indicates better accuracy.

Q-error. Since subgraph counts often span multiple orders of magnitude, we adopt Q-error to evaluate the relative quality of the predictions. It is defined as the maximum ratio between the prediction and the ground truth:

$$\mathrm{Q}-\mathrm{error}(y_i,{\widehat{y}}_i)=max\left({\displaystyle \frac{{\widehat{y}}_i+1}{y_i+1}},{\displaystyle \frac{y_i+1}{{\widehat{y}}_i+1}}\right)$$

(15)

Note that we add a smoothing term of 1 to handle zero counts. A perfect prediction yields a Q-error of 1.0. We report the mean Q-error across the test set.

5.1.4. Implementation Details

Data Partitioning Strategy

To simulate a realistic federated learning scenario and strictly enforce an inductive setting, we adopt a graph-wise partitioning strategy. We treat each input graph ${\mathcal{G}}_i$ as an atomic unit. Specifically, all the triples $\{({\mathcal{G}}_i,{\mathcal{Q}}_j,y_{ij})\mid \forall {\mathcal{Q}}_j\in \mathcal{Q}\}$ derived from the same input graph are assigned exclusively to the same data split or client. Based on this strategy, the datasets are split as follows:

• MUTAG: The input graphs are partitioned such that the resulting triples are divided into training, validation, and testing sets with a ratio of 1:1:1.
• Synthetic (SMALL and LARGE): We partition the input graphs to allocate 5000 samples for training and 1000 samples for validation. All remaining samples are reserved for testing to strictly evaluate generalization.
• SOCIAL: To simulate an extreme Non-IID scenario, the four maximum connected components (from Citeseer, Cornell, Texas, and Wisconsin) are assigned directly and exclusively to four distinct clients. For each client, the locally generated query triples are partitioned into training, validation, and testing sets, enforcing a strict federated evaluation on highly skewed graph sizes. We divide all triples into 1:1:1 as the training, validation, and testing sets.

In the federated setting, the training graphs are further distributed uniformly among K clients.

Training Setup

We implement FedCount using PyTorch 1.7.1 and DGL 0.4.3.post2. The model is trained using the Adam optimizer with a learning rate of ${10}^{-3}$ and weight decay of $5\times {10}^{-5}$ as default. The local batch size is set to 512. Unless otherwise stated, we set the number of clients $K=\{4,8,16\}$ and perform $E=2$ local epochs per communication round. All experiments are conducted on a server with an an Intel(R) Xeon(R) Platinum 8368Q CPU (2.60 GHz) and an NVIDIA L40 GPU with 48 GB of VRAM.

5.2. Results

5.2.1. Overall Performance

Table 3 presents the performance comparison. FedCount achieves the best accuracy across all datasets, consistently outperforming centralized baselines.

Performance on Standard Datasets. On the SMALL dataset, FedCount reduces the MAE by roughly 25% compared to Count-GNN (10.08 vs. 13.43). We attribute this superior performance to the regularization effect of federated learning, which prevents the model from overfitting to specific local structures, thereby learning more generalizable patterns than centralized training. Furthermore, FedCount maintains an exceptionally high inference speed (e.g., 0.02 s on MUTAG), comparable to the highly efficient Count-GNN and drastically outperforming the exact solver VF2.

Robustness on Extreme Non-IID Heterophilic Graphs (SOCIAL). The most striking contrast emerges on the newly introduced SOCIAL dataset, which simulates an extreme federated environment with highly skewed graph sizes and complex heterophilic topologies. Under this rigorous setting, traditional neural baselines exhibit severe performance degradation: DiamNet completely fails to generalize, yielding the highest MAE (104.65) and Q-error (59.48). As an early framework lacking explicit query–target interaction, its global graph pooling mechanism severely struggles on heterophilic graphs. Because connecting nodes possess vastly different features, the local structural semantics are easily over-smoothed or drowned out by heterophilic noise. DeSCo suffers from both poor accuracy (MAE 69.75) and high computational overhead (3.72 s, the slowest among neural methods). Its reliance on subgraph decomposition becomes a massive computational and structural bottleneck when processing highly skewed, irregular maximum connected components, proving it brittle in such extreme Non-IID scenarios. Count-GNN maintains fast inference (0.11 s) but suffers a significant drop in accuracy (MAE 71.02, Q-error 33.82). Although it utilizes edge-centric interactions, it is fundamentally a centralized architecture. When forced to learn across highly heterogeneous clients without our proposed deep residual stabilization, it inevitably falls victim to severe weight divergence and fails to align local topological insights. In stark contrast, FedCount demonstrates remarkable robustness. It achieves the lowest MAE (64.34) and specifically the lowest Q-error (23.09) among all approximate methods, while matching the optimal inference speed (0.11 s). Compared to the computationally prohibitive 629.30 s required by VF2 for exact counting on these massive connected components, FedCount provides a highly practical, privacy-preserving, and fast alternative for analyzing heterophilic data silos.

5.2.2. Ablation Study

To thoroughly evaluate the contributions of our proposed components and training strategies, we conduct ablation studies. For a fair and rigorous comparison, we fix the number of clients to $K=4$ across all datasets, strictly controlling the data distribution variables.

Impact of Architectural Enhancements

We first investigate the necessity of our proposed structural modifications: the lightweight structural encoding and the residual network connections. We compare our final model (FedCount) against a naively federated version of Count-GNN (Fed-CountGNN). As illustrated in Figure 2, the performance exhibits a clear trade-off highly dependent on graph complexity and data heterogeneity. On smaller and topologically simpler graphs (MUTAG and SMALL), the naive architecture performs adequately. In these cases, our deep residual modifications introduce a slight regularization overhead, causing a minor increase in MAE (e.g., from 9.57 to 10.08 on SMALL). However, as the topological complexity drastically increases on the LARGE dataset, the naive GNN struggles with over-smoothing and vanishing gradients, failing to capture complex isomorphism patterns. Here, our architectural enhancements demonstrate their crucial value, explicitly reducing the MAE from 39.17 to 36.75. More importantly, under the extreme Non-IID and heterophilic setting of the newly introduced SOCIAL dataset, the naive Fed-CountGNN suffers severe performance degradation, yielding an MAE of 70.38. In contrast, FedCount effectively mitigates this vulnerability, reducing the MAE to 64.34. This explicitly confirms that our residual connections and lightweight structural encodings are not just beneficial, but essential innovations for maintaining expressiveness when handling highly skewed, large-scale data silos.

Figure 2. Ablation of architectural enhancements ($K=4$). Fed-CountGNN refers to the naively federated baseline, while FedCount integrates residual connections and structural encodings.

Impact of Aggregation Strategy

Next, we evaluate the impact of different federated aggregation strategies on our proposed architecture: Model Averaging (FedAvg) and Gradient Averaging (FedSGD). As presented in Figure 3, we observe complex optimization dynamics that diverge from standard federated learning tasks, which are highly dependent on both graph size and client heterogeneity. On the MUTAG and SMALL datasets, FedAvg slightly outperforms FedSGD (e.g., MAE 10.08 vs. 10.29 on SMALL). This is because multiple local epochs allow for the sufficient exploration and extraction of local subgraph patterns when the topologies are relatively simple. Conversely, on the structurally deep but homogeneously distributed LARGE dataset, FedSGD achieves a massive performance advantage, reducing the MAE from 45.97 to 36.75. We attribute this to mitigating the weight divergence problem inherent in deep residual networks: strict global gradient synchronization provides a stable optimization path for complex counting objectives. Crucially, an intriguing phenomenon emerges on the extreme Non-IID SOCIAL dataset, where FedAvg regains the lead over FedSGD (MAE 64.34 vs. 67.65). This represents a classic manifestation of gradient conflict in extreme heterophilic settings. Because the four clients hold radically different social topologies (Citeseer, Cornell, Texas, and Wisconsin), their local gradients point in entirely divergent directions. Enforcing strict Gradient Averaging at every single step (FedSGD) causes severe gradient cancellation, hindering global convergence. FedAvg, by allowing multiple local steps, enables local models to learn meaningful representations of their uniquely heterophilic motifs before averaging, proving more robust in extreme Non-IID environments.

Figure 3. Comparison of aggregation strategies (FedAvg vs. FedSGD) on our proposed architecture ($K=4$).

5.2.3. Hyperparameter Analysis

Impact of the Learning Rate and Aggregation Strategy

To deeply understand the optimization dynamics of our framework, we investigate the model’s sensitivity to the local learning rate $\eta \in \{{10}^{-4},2\times {10}^{-4},5\times {10}^{-4},{10}^{-3}\}$ across all three datasets with a fixed client number ($K=4$). We plot the performance of FedAvg and FedSGD separately to uncover their distinct behaviors, as illustrated in Figure 4.

Figure 4. Joint analysis of the Learning Rate and Aggregation Strategy ($K=4$). The top row shows the high sensitivity of FedAvg, leading to divergence on LARGE graphs. The bottom row highlights the robustness of FedSGD across different learning rates. X-axes are in logarithmic scale.

The separated curves reveal a profound difference in optimization stability between the two federated strategies:

• The Sensitivity of FedAvg. As shown in Figure 4a,b, FedAvg exhibits extreme sensitivity to learning rate variations. While a large learning rate ($\eta ={10}^{-3}$) helps the simple MUTAG dataset converge efficiently (lowering MAE to 2.70), it causes catastrophic divergence on the LARGE dataset. The MAE explodes from 45.97 to 57.20, and the Q-error nearly doubles. This severe degradation occurs because taking multiple local steps with a large step size on highly complex graph topologies exacerbates weight divergence.
• The Robustness of FedSGD. In stark contrast, Figure 4c,d demonstrates the remarkable robustness of FedSGD. Across all learning rates, FedSGD maintains a tightly bounded error margin. Most notably, on the LARGE dataset, even at the highest learning rate, the MAE only fluctuates slightly to 39.65. This compelling evidence solidifies our earlier findings: by enforcing strict global gradient synchronization, FedSGD acts as an optimization stabilizer, neutralizing the gradient oscillations inherently caused by deep residual counting networks on large-scale topologies.

Impact of Client Numbers

We evaluate the scalability and robustness of our proposed framework by varying the number of federated clients $K\in \{4,8,16\}$ on the real-world MUTAG dataset. We plot both the Mean Absolute Error (MAE) and Q-error for FedAvg and FedSGD strategies, as shown in Figure 5.

Figure 5. Impact of client numbers (K) on the MUTAG dataset. Both FedAvg and FedSGD demonstrate excellent scalability, with performance remaining stable or improving as data fragmentation increases.

The results exhibit remarkable stability across varying degrees of data fragmentation. Surprisingly, rather than degrading, the performance generally improves or remains highly stable as the number of clients increases. For instance, as shown in Figure 5a, the MAE for FedAvg consistently drops from 2.70 at $K=4$ to 2.42 at $K=16$. Similarly, FedSGD experiences a sharp performance gain when increasing clients from 4 to 8, achieving the optimal MAE of 2.29 and an optimal Q-error of 1.30.

This phenomenon suggests that distributing the graph data among more clients introduces a beneficial regularization effect. During federated training, aggregating diverse local gradients prevents the global model from overfitting to the specific topological structures of a small number of participants. Both aggregation strategies maintain low error rates even when the dataset is highly partitioned at $K=16$, confirming the framework’s excellent scalability and practical applicability in real-world data silo scenarios.

6. Conclusions

In this paper, we introduced FedCount, a novel federated learning framework specifically designed for privacy-preserving subgraph counting. By thoughtfully integrating lightweight structural encodings and deep residual connections, FedCount effectively captures complex, long-range isomorphism patterns without ever requiring the centralized collection of sensitive graph data. Our extensive evaluations across both real-world molecular and synthetic graph datasets demonstrate that FedCount achieves highly competitive, and often superior, accuracy compared to state-of-the-art centralized baselines. This counter-intuitive performance gain highlights the beneficial implicit regularization effect of federated training on graph data. Furthermore, our in-depth analyses reveal that FedSGD acts as a mandatory optimization stabilizer for deep residual networks on large graphs, effectively mitigating severe weight divergence caused by Non-IID graph fragmentation.

Despite its effectiveness, FedCount has certain limitations that outline promising directions for future research. First, as an inherent trade-off of our lightweight design, while federated learning fundamentally protects raw data isolation, the exchanged model gradients or updates may still be susceptible to advanced privacy breaches, such as gradient inversion or membership inference attacks. Future work will explore integrating rigorous privacy-enhancing technologies (e.g., adaptive Differential Privacy or efficient Secure Aggregation), focusing on carefully balancing the trade-off between strict privacy guarantees, regression accuracy, and communication overhead.

Second, we acknowledge a practical limitation regarding the training phase: preparing the ground-truth counting labels for local datasets still depends on computationally expensive exact subgraph counting algorithms (e.g., VF2). While FedCount significantly accelerates approximate inference post-training, the initial cost of label generation remains a bottleneck. Future research could explore semi-supervised or self-supervised paradigms to reduce the reliance on exact counting labels.

Furthermore, extending our framework to efficiently handle dynamic graphs with temporally evolving structures, as well as addressing extreme structural heterogeneity (i.e., highly skewed degree distributions) across varied clients, represents an important avenue for deploying federated subgraph counting in complex, real-world environments.