DSCM: A Dominance-Based Subgraph Counting Method

Abstract

Graphs are widely used to represent vertices and their relationships, with the subgraph counting problem being a crucial challenge in network analysis. Originating from subgraph matching, this problem aims to efficiently determine the number of subgraphs in a data graph that are isomorphic to a given query graph. Since this task is NP-hard, existing approaches are typically divided into exact and approximate methods. Exact methods compute the precise number of isomorphic subgraphs but incur prohibitive computational costs on large graphs. Approximate methods, often based on Graph Neural Networks (GNNs), estimate the subgraph count more efficiently but tend to suffer when there is a large size discrepancy between the data graph and the query graph, leading to inaccurate vertex matching. To address these limitations, we propose a domination-based subgraph counting method (DSCM), which improves vertex matching by using a vertex dominance embedding method. This approach, combined with an attention mechanism, accurately computes subgraph counts. Experimental results show that DSCM outperforms existing methods, providing an efficient solution for subgraph counting in large graphs.

1. Introduction

Graphs are a fundamental data structure for modeling entities and the relationships among them, and they are extensively applied in real-world scenarios. Subgraph isomorphism matching focuses on identifying all occurrences in a data graph $G$ that are structurally equivalent to a given query graph $q$. This problem is a core task in a wide range of applications, such as information retrieval [1], computer vision [2,3,4], natural language processing [5], chemical informatics [6], and bioinformatics [7,8].

An example of subgraph matching is shown in Figure 1. The color of each node indicates its label. The matching subgraphs of query graph $q$ on the data graph $G$ are {$u_1\to v_1,\mathrm{ }{\mathrm{ }u}_2\to v_5,\mathrm{ }{u}_3\to v_6,\mathrm{ }{u}_4\to v_9,\mathrm{ }{u}_5\to v_{10}$} and {$u_1\to v_4,\mathrm{ }{u}_2\to v_9,\mathrm{ }{u}_3\to v_{10},\mathrm{ }{u}_4\to v_5,\mathrm{ }{u}_5\to v_6$}.

Figure 1. Example of subgraph matching.

Existing subgraph counting techniques are generally categorized into exact and approximate methods [9]. Exact approaches aim to compute the precise number of subgraphs that are isomorphic to a given query. These methods can be further classified into enumeration-based techniques [10,11,12,13,14,15,16] and analysis-based techniques [17,18,19,20,21,22,23,24,25,26]. Enumeration-based algorithms explicitly traverse all candidate subgraph instances in the data graph that match the query structure to derive an exact count. While such approaches ensure full accuracy, they often suffer from prohibitive computational overhead due to the exponential growth of the search space. As a result, enumeration-based methods are typically practical only for graphs of limited size or with relatively simple structures.

Analysis-based exact subgraph matching algorithms determine the number of matches by exploiting theoretical insights and structural properties of both the query graph and the data graph. Rather than explicitly enumerating all candidates, these approaches rely on graph-theoretic analysis to infer the exact count of isomorphic subgraphs. Although they are generally more applicable to large-scale or structurally complex graphs than enumeration-based techniques, they still involve substantial computational overhead to achieve precise results.

Approximate subgraph counting aims to efficiently estimate the number of subgraphs in a data graph that are isomorphic to a given query graph. This approach is especially valuable for large-scale or highly complex graphs, where exact counting becomes computationally prohibitive. By trading a small loss in precision for significant gains in efficiency, approximate methods can deliver near-accurate estimates within acceptable time and resource constraints. Existing approximate counting techniques are commonly classified into five categories: random enumeration [27,28], generalized enumeration [29,30,31,32,33], path-based sampling [34,35], random walk-based methods [36,37,38,39] and color-coding approaches [40]. Despite their efficiency advantages, many of these methods suffer from limited accuracy and poor scalability when applied to large graphs.

With the rapid progress of graph neural networks in recent years, a number of deep learning-based methods have been introduced for approximate subgraph counting [41,42,43,44,45]. Most of these approaches treat subgraph counting as a regression problem, where graph neural networks are used to derive representations of the query graph and the data graph, and the final count is inferred from these embeddings. However, the extracted representations primarily reflect local or intrinsic structural characteristics of individual vertices, while the explicit correspondence between the query and data graphs is insufficiently modeled. To address this limitation, we present a subgraph counting framework that incorporates vertex dominance and substructure dominance, enabling direct modeling of matching relationships between the query and data graphs. By explicitly embedding these relationships into the feature extraction process, the proposed method achieves notably improved counting accuracy.

Our main contributions are summarized as follows:

• We propose a dominance-based subgraph counting model, which consists of the vertex dominance embedding network and the subgraph counting prediction network.
• To accurately capture the matching relationships between vertices in the data graph and the query graph, we design a dedicated vertex dominance embedding network capable of precisely modeling these relationships. This network is trained independently to ensure high-quality feature extraction.
• To enhance the accuracy of subgraph count prediction, we generate multiple substructures from the vertices of the query graph. By modeling the matching relationships between these substructures and the data graph, referred to as substructure dominance relationships, our method produces more reliable subgraph count results.
• We conduct extensive experiments across a wide range of real-world datasets, and the results demonstrate that our method significantly outperforms existing state-of-the-art approaches.

2. Preliminaries

In this section, we first introduce the fundamental concepts of subgraph matching and subgraph counting, and then we discuss existing subgraph counting methods. Finally, we explain the basic principles of graph neural networks.

2.1. Problem Statement

In this work, we use labeled undirected graphs as a running example to introduce the proposed subgraph counting method. Extending the method to unlabeled or directed graphs only requires minor adjustments to the model inputs.

Definition 1

(Graph). A graph is represented by $G=(V,E,L)$, where $V$ is a set of vertices, $E$ is a set of edges between, and L is a label function that associates each vertex $v\in V$ with a set of labels.

Definition 2

(Subgraph). A subgraph $G\prime$ of G is a graph $G\prime =(V\prime ,E\prime ,L\prime )$, where $V\prime \subseteq V$ and $E\prime \subseteq E$.

Definition 3

(Subgraph Isomorphism). Given a query graph $q=\{V_q,E_q,L_q\}$ and a data graph $G=\{V_G,E_G,L_G\}$, $q$ is subgraph isomorphism to $G$ if and only if there is an injective mapping f:  $V\left(q\right)\to V\left(G\right)$ such that:

• $\forall u\in V_q$, we have  $L_q\left(u\right)=L_G\left(f\right(u\left)\right)$ where  $f\left(u\right)\in V_G$.
• $\forall (u,V)\in E_q,\exists (f(v))\in E_G$.

Definition 4

(Subgraph Counting). Given a query graph q and a data graph G, the subgraph counting is to calculate the number of subgraph in G that are isomorphic to q, denoted by $c\left(q\right)$.

2.2. Deep Learning-Based Subgraph Counting Methods

Existing deep learning-based approaches to subgraph counting typically employ neural models—most notably graph neural networks—to derive representations of the query graph and the data graph, and then estimate the number of isomorphic subgraphs by learning from the similarity between these representations.

NSIC [41] proposes DIAMNet, which incorporates an intermediate caching mechanism based on a recurrent neural network; however, this design does not explicitly encode graph structural information. LSS [42] addresses subgraph counting by decomposing the query graph into a collection of substructures, assigning importance weights to them via self-attention, and aggregating the weighted representations to produce the final estimate. An active learning scheme is further employed to improve generalization. Nevertheless, LSS does not consider the structural properties of the data graph, requiring retraining whenever the underlying data graph is modified.

NeuroSC [43] builds upon LSS by utilizing the GraphQL algorithm to incorporate structural information from the data graph. It identifies candidate vertex sets through structural queries and constructs multiple candidate subgraphs for matching against the query graph. Despite this improvement, the data-graph pruning strategy is not jointly optimized within the neural training process. COUNT-GNN [44] focuses on propagating and aggregating features centered on edges during representation learning, whereas RGIN-GP [45] integrates meta-learning techniques with subgraph counting to enhance prediction accuracy, particularly in scenarios with limited training samples.

In summary, existing deep learning-based subgraph counting methods primarily extract features from the structural properties of individual vertices, and they process the data graph and query graph independently. As a result, they fail to explicitly model the vertex-wise matching relationships between the query graph and the data graph. To address this limitation, we propose a vertex-dominance embedding network that directly captures these matching relationships and thus enables more accurate subgraph counting.

2.3. Graph Neural Network

Graph Neural Networks (GNNs) constitute a family of deep learning models tailored for graph-structured data, including social networks, molecular graphs, and transportation systems. In contrast to conventional neural networks, GNNs perform computation directly on graph topologies, enabling effective representation of both vertices and their relational dependencies. Among the various GNN variants, Graph Convolutional Networks (GCNs) are among the most commonly adopted architectures.

The GCN model uses the structure of the graph to aggregate the neighbor vertex information, and then updates the vertex representation through a non-linear activation function. Its core operation, the spatial graph convolution layer, is denoted as follows:

$$H^{l+1}=f(\widehat{A}{H}^l{W}^l)\mathrm{ }$$

(1)

where $\widehat{A}={\tilde{D}}^{-{\displaystyle \frac{1}{2}}}\tilde{A}{\tilde{D}}^{-{\displaystyle \frac{1}{2}}}(\tilde{A}=A+I_N,{\tilde{D}}_{ii}=\sum {\tilde{A}}_{ii})\in R^{N\times N}$. ($N$ is the number of vertices) is a normalized adjacency matrix, $H^l\in R^{N\times D\prime }$ is vertex-level embedding of $l$-th GCN layer ($H^0\mathrm{ }=\mathrm{ }X$, $X$ is vertices feature matrix), $W^l\in R^{D^l\times D^{l+1}}$ is a learnable weights of l-th GCN layer, and f is a non-linear activation function.

3. Method

In this section, we first conduct an overview of our proposed model, then provide a detailed introduction to the details of the model, and finally introduce the training method of this model.

3.1. Model Overview

The overall architecture of the proposed DSCM model is shown in Figure 2. DSCM consists of two main components: a vertex dominance embedding network and a subgraph counting prediction network.

Figure 2. Structure of DSCM model.

The vertex dominance embedding network captures both the structural information of the graph and the matching relationships between vertices, and encodes them into embedding representations for the data graph and the query graph. The subgraph counting prediction network then decomposes the query graph into multiple substructures, enabling a more fine-grained characterization of how the query structure influences the subgraph count, thereby more accurately predicting subgraph counts.

3.2. Vertex Dominance Embedding Network

The purpose of the vertex dominance embedding network is to obtain the embedding representation of each vertex in both the query graph and the data graph, and these embeddings should effectively reflect the matching relationships between the vertices.

To capture this matching relationship, we refer to the idea in [46], where if there is a matching relationship between vertex $i$ in the query graph q and vertex $j$ in the data graph $G$, the embedding of vertex $i$ is dominated by the embedding of vertex $j$. We define this as vertex domination.

Definition 5

(Vector Dominance). Given two vectors $A=(a_1,a_2,\cdots ,a_n)$ and $B=(b_1,b_2,\cdots ,b_n)$, if A is said to be dominated by B, it must satisfy:

• $\forall 1\le i\le n,a_i\le b_i.$
• $\exists 1\le j\le n,a_j<b_j.$

Based on the definition of vector dominance, we provide the definition of vertex dominance.

Definition 6

(Vertex Dominance). Given a data In the two-dimensional G and a query graph q, if a vertex $v_j$ in the data graph G matches with a vertex $u_i$ in the query graph q, the vertices ${\tilde{u}}_i$ and ${\tilde{v}}_j$ represent the embeddings of vertices $u_i$ and $v_j$ obtained through the vertex dominance embedding network, the vertex ${\tilde{v}}_j$ must dominate the vertex ${\tilde{u}}_i$.

An example of vertex dominance embedding is shown in Figure 3, where the vertex $u_1$ in the query graph $q$ matches with vertices $v_1$ and $v_4$ in the data graph $G$. In the two-dimensional embedding space, the embedding of $u_1$ (denoted as ${\tilde{u}}_1$) is located at the bottom-left corner of the embeddings of $v_1$ (denoted as ${\tilde{v}}_1$) and $v_4$ (denoted as ${\tilde{v}}_4$), meaning the embedding of vertex ${\tilde{u}}_1$ is dominated by the embedding of vertex ${\tilde{v}}_1$ and ${\tilde{v}}_4$. On the contrary, there is no matching relationship between vertex $u_1$ and vertex $v_9$, so there is no dominant relationship between their embedding ${\tilde{u}}_1$ and vertex ${\tilde{v}}_9$.

Figure 3. Example of vertex dominance embedding.

The vertex dominance embedding network obtains the features of each vertex in the query graph $q$ and data graph $G$ through the graph attention network. The representation of the $t$-th layer of vertex $i$ is as follows:

$$h_i^t=\sigma \left({\sum }_{j\in N_i}\alpha \left(h_i^{t-1},h_j^{t-1}\right)w^{t-1}{h}_j^{t-1}\right)\mathrm{ }$$

(2)

where $h_i^t$ represents the representation of vertex $i$ in $t$-th layer. $N_i$ represents the neighboring vertices of vertex $i$, $\alpha$ represents the importance weight of vertex $j$ to vertex $i$, $w^{t-1}$ represents the weight of the $(t-1)$-th layer.

We use the max margin loss function to train the vertex dominance embedding network. The loss function is as follows:

$${Loss}_1=\sum _{(u_i,\mathrm{ }{v}_j)\in D}{‖\mathrm{m}\mathrm{a}\mathrm{x}(0,\mathrm{ }e\left(v_j\right)-e(u_i\left)\right)‖}_2^2\mathrm{ }$$

(3)

where $e\left(v_j\right)$ is the embedding of vertex $v_j$, $e\left(u_i\right)$ is the embedding of vertex $u_i$, and ${\left|\right|·\left|\right|}_2$ is the $L_2$-norm.

Using the vertex dominance embedding network, we compute embeddings for individual vertices in both the data graph and the query graph, which together form their respective graph-level representations.

Notably, when applied to large or structurally complex graphs, the proposed model does not require an increase in embedding dimensionality with graph scale. This is because the method captures potential vertex correspondences through dominance relationships, rather than relying on high-dimensional embeddings to encode complete structural information.

3.3. Subgraph Counting Prediction Network

The vertex dominance embedding network produces feature representations for both the data graph and the query graph that implicitly encode vertex-level correspondence information. Building upon these representations, we further investigate the matching relationships between substructures in the query graph and those in the data graph, a concept referred to as substructure dominance.

Definition 7

(Substructure Dominance). If there is a matching relationship between vertices $v_x$, $v_y$, $v_z$ in the data graph G and vertices $u_i$, $u_j$, $u_k$ in the query graph q, respectively, then the embeddings of the substructure composed of $v_x$, $v_y$, $v_z$ in the data graph must dominate the embeddings of the substructure composed of $u_i$, $u_j$, $u_k$ in the query graph.

For example, in Figure 3, since the embedding of vertices $u_1$, $u_2$, and $u_3$ are dominated by the embedding of vertices $v_1$, $v_5$, and $v_6$, respectively, the embedding of the substructure composed of vertices $u_1$, $u_2$, and $u_3$ is necessarily dominated by the embedding of the substructure composed of vertices $v_1$, $v_5$, and $v_6$.

Therefore, we decompose the query graph $q$ into substructures, thereby further exploring the matching relationships that exist between the query graph and the data graph.

Within the subgraph counting prediction network, we begin by performing a breadth-first search from each vertex in the query graph $q$ to extract its corresponding substructures. A self-attention mechanism is then employed to quantify the contribution of each substructure to the final count estimation. The query graph representation is subsequently obtained by aggregating the substructure embeddings through a weighted summation.

We use the mean square error to train the subgraph counting prediction network. The loss function is as follows:

$$Loss=\mathrm{ }{\displaystyle \frac{1}{m}}{\sum }_{i=1}^m{(y_i-{\widehat{y}}_i)}^2$$

(4)

where $m$ represents the number of query graphs. $y_i$ represents the true values of subgraph counts, ${\widehat{y}}_i$ represents the predicted subgraph counts by the DSCM model.

3.4. Model Training

To further enhance the accuracy of subgraph counting, we adopt a joint training approach for the DSCM model. We first train the vertex dominance embedding network until the model converges. The purpose of this step is to capture the matching relationship features of vertices in the query graph and data graph, providing a foundation for subsequent subgraph counting networks. Afterwards, we fix the parameters of the vertex dominated embedding network and train the subgraph counting prediction network until it converges. The purpose of this step is to accurately predict the number of isomorphic subgraphs by utilizing the embedding information of vertices. Finally, we conduct joint training on the parameters of both the vertex dominance embedding network and the subgraph counting prediction network. At this stage, the parameters of both networks are adjusted simultaneously to further improve the overall model’s performance and accuracy. Joint training ensures the collaborative operation of the two networks, thereby enabling more accurate subgraph counting.

4. Experiments

4.1. Experimental Setup

Environment. The models in this paper are implemented using Python 3.11 language. The computer used for the experiments is configured with an Intel Core i7-12700KF CPU, an NVIDIA RTX4080 graphics card, and 16 GB of RAM.

Datasets. In this paper, we employ four public datasets in the field of subgraph matching. The information of the datasets and the statistics of the query graphs are presented in Table 1 and Table 2, respectively. For each dataset, query graphs are generated by randomly sampling connected induced subgraphs of sizes 4, 8, 16, and 24. Multiple queries are extracted for each size to ensure structural diversity. A connectedness constraint is enforced during sampling so that all query graphs represent valid and meaningful local patterns of the original data graph.

Table 1. Data graph statistics.

Datasets	|V|	|E|	|E|
yeast	3112	12,519	71
human	4674	86,282	44
hprd	9460	34,998	307
dblp	317,080	1,049,866	15

Table 2. Query graph statistics.

Datasets	Number of Query Graphs	Size of Query Graphs	Range of Subgraph Match Counts
yeast	800	{4, 8, 16, 24}	[100, 1011]
human	800	{4, 8, 16, 24}	[100, 1011]
hprd	800	{4, 8, 16, 24}	[100, 104]
dblp	800	{4, 8, 16, 24}	[103, 108]

Baselines. We compare the algorithm proposed in this paper with the state-of-the-art algorithms NeurSC, LSS, and COUNT-GNN, as well as the algorithm that performs subgraph counting using only GNNs.

Experimental parameters. We used the Adam optimizer with an initial learning rate of 0.001. The training was conducted for 200 epochs with a batch size of 32. The embedding dimensions of all GNN layers were set within the range of 64–256, and ReLU was used as the activation function for all network components.

4.2. Experimental Analysis

4.2.1. Effectiveness of Subgraph Counting

With the increase in the number of query graph vertices, the experimental results of subgraph counting on different datasets are shown in Figure 4, Figure 5, Figure 6 and Figure 7. In particular, circles denote outliers in figures.

Figure 4. Counting effect of yeast dataset.

Figure 5. Counting effect of human dataset.

Figure 6. Counting effect of hprd dataset.

Figure 7. Counting effect of dblp dataset.

As shown in Figure 4, on the yeast dataset, the proposed DSCM model consistently maintains good stability as the number of query graph vertices increases, whereas the GCN model exhibits the largest fluctuations and NeurSC shows minor fluctuations. In comparison, COUNT-GNN presents noticeably higher variance with increasing query sizes, while LSS demonstrates moderate fluctuations but still performs less stably than DSCM.

As shown in Figure 5, the DSCM model and the NeurSC model exhibit similar performance. This is because, compared with the yeast dataset, the human dataset has a denser structure, enabling these two complex models to more effectively extract structural information from the data graph. In comparison, COUNT-GNN shows higher error values and larger variance, while LSS achieves moderate but less stable performance, both of which indicate weaker structural modeling capability on the human dataset.

As shown in Figure 6, on the hprd dataset, the DSCM model consistently maintains good stability and low error values. In contrast, the NeurSC model performs poorly when the query graph contains four vertices but achieves performance comparable to DSCM on larger query graphs. Meanwhile, COUNT-GNN exhibits noticeably larger fluctuations, and LSS performs more stably but remains less accurate, suggesting limited generalization ability for both models on this challenging dataset.

As shown in Figure 7, the above conclusion is further confirmed. However, since the dblp dataset is relatively large, when the query graph contains 24 vertices, the error of the NeurSC model increases significantly compared with that on the 16-vertex query graph. On the dblp dataset, the DSCM model maintains its error within a small fluctuation range as the query graph size increases. In contrast, due to the large scale of the hprd and dblp datasets, the performance of the GCN model is far inferior to that of the NeurSC and DSCM models. Meanwhile, COUNT-GNN exhibits consistently higher error values across all query sizes, and LSS shows moderate but unstable performance, both of which indicate limited robustness on large-scale datasets such as dblp.

4.2.2. Ablation Experiments

We conduct ablation studies to verify the effectiveness of each component of the proposed method. The experimental results are shown in Figure 8, Figure 9, Figure 10 and Figure 11. It can be observed that removing the vertex-dominant embedding and the structure-dominant embedding leads to a significant increase in the subgraph counting mean error, with the impact of the vertex-dominant embedding being more pronounced.

Figure 8. Ablation experiment of yeast dataset.

Figure 9. Ablation experiment of human dataset.

Figure 10. Ablation experiment of hprd dataset.

Figure 11. Ablation experiment of human dataset.

5. Conclusions

In this paper, we study an NP-complete problem, subgraph isomorphism counting, by DL techniques. To more accurately extract the feature representations of the data graph and the query graph, we proposed a domination-based subgraph counting model, referred to as DSCM. In the process of computing embeddings for vertices in data and query graphs, we introduced the concept of vertex dominance to precisely calculate the matching relationships between vertices. Subsequently, in computing subgraph counts, we combined subgraph dominance and attention mechanisms to accurately determine the number of subgraphs. Finally, we compared DSCM model with the most advanced subgraph counting methods on multiple real datasets from various aspects. Extensive experimental results demonstrate the effectiveness of our method.