Original: D E SC O :
Revised: D E SC O :

Original: T OWARDS
Revised: T OWARDS

Original: S CALABLE
Revised: S CALABLE

Original: D EEP
Revised: D EEP

Original: S UBGRAPH
Revised: S UBGRAPH

Original: C OUNTING
Revised: C OUNTING

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Subgraph counting is the problem of determining the number of a given query graph in a large target graph.
Revised: Subgraph counting is the problem of determining the number of a given query graph in a large target graph.

Original: Despite being a #P problem, subgraph counting is a crucial graph analysis method in domains ranging from biology and social science to risk management and software analysis.
Revised: Despite being a #P problem, subgraph counting is a crucial graph analysis method in domains ranging from biology and social science to risk management and software analysis.

Original: However, existing exact counting methods take combinatorially long runtime as target and query sizes increase.
Revised: However, existing exact counting methods take combinatorially long runtime as target and query sizes increase.

Original: Existing approximate heuristic methods and neural approaches fall short in accuracy due to high label dynamic range, limited model expressive power, and inability to predict the distribution of subgraph counts in the target graph.
Revised: Existing approximate heuristic methods and neural approaches fall short in accuracy due to high label dynamic range, limited model expressive power, and inability to predict the distribution of subgraph counts in the target graph.

Original: Here we propose
Revised: Here we propose

Original: DeSCo, a neural deep subgraph counting framework, which aims to accurately predict the count and distribution of query graphs on any given target graph.
Revised: DeSCo, a neural deep subgraph counting framework, which aims to accurately predict the count and distribution of query graphs on any given target graph.

Original: DeSCo uses canonical partition to divide the large target graph into small neighborhood graphs and predict the canonical count objective on each neighborhood.
Revised: DeSCo uses canonical partition to divide the large target graph into small neighborhood graphs and predict the canonical count objective on each neighborhood.

Original: The proposed partition method avoids missing or double-counting any patterns of the target graph.
Revised: The proposed partition method avoids missing or double-counting any patterns of the target graph.

Original: A novel subgraph-based heterogeneous graph neural network is then used to improve the expressive power.
Revised: A novel subgraph-based heterogeneous graph neural network is then used to improve the expressive power.

Original: Finally, gossip correction improves counting accuracy via prediction propagation with learnable weights.
Revised: Finally, gossip correction improves counting accuracy via prediction propagation with learnable weights.

Original: Compared with state-of-the-art approximate heuristic and neural methods.
Revised: Compared with state-of-the-art approximate heuristic and neural methods.

Original: DeSCo achieves 437 × improvement in the mean squared error of count prediction and benefits from the polynomial runtime complexity.
Revised: DeSCo achieves 437 × improvement in the mean squared error of count prediction and benefits from the polynomial runtime complexity.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Given a query graph and a target graph, the problem of subgraph counting is to count the number of patterns , defined as subgraphs of the target graph, that are graph-isomorphic to the query graph Ribeiro et al.
Revised: Given a query graph and a target graph, the problem of subgraph counting is to count the number of patterns , defined as subgraphs of the target graph, that are graph-isomorphic to the query graph Ribeiro et al.

Original: Subgraph counting is crucial for domains including biology Takigawa & Mamitsuka (2013)
Revised: Subgraph counting is crucial for domains including biology Takigawa & Mamitsuka (2013)

Original: ; Sol ´ e & Valverde (2008); Adamcsek et al.
Revised: ; Sol ´ e & Valverde (2008); Adamcsek et al.

Original: ; Bascompte & Meli ´ an (2005); Bader & Hogue (2003), social science Uddin et al.
Revised: ; Bascompte & Meli ´ an (2005); Bader & Hogue (2003), social science Uddin et al.

Original: ; Prell & Skvoretz (2008); Kalish & Robins (2006); Wasserman et al.
Revised: ; Prell & Skvoretz (2008); Kalish & Robins (2006); Wasserman et al.

Original: , risk management Ribeiro et al.
Revised: , risk management Ribeiro et al.

Original: (2017); Akoglu & Faloutsos (2013), and software analysis Valverde & Sol´e (2005)
Revised: (2017); Akoglu & Faloutsos (2013), and software analysis Valverde & Sol´e (2005)

Original: ; Wu et al.
Revised: ; Wu et al.

Original: While being an essential method in graph and network analysis, subgraph counting is a #P-complete problem Valiant (1979).
Revised: While being an essential method in graph and network analysis, subgraph counting is a #P-complete problem Valiant (1979).

Original: Due to the computational complexity, existing exact counting algorithms are restricted to small query graphs with no more than 5 vertices Pinar et al.
Revised: Due to the computational complexity, existing exact counting algorithms are restricted to small query graphs with no more than 5 vertices Pinar et al.

Original: ; Ortmann &
Revised: ; Ortmann &

Original: Brandes (2017); Ahmed et al. (2015).
Revised: Brandes (2017); Ahmed et al. (2015).

Original: The commonly used VF2 Cordella et al.
Revised: The commonly used VF2 Cordella et al.

Original: (2004) algorithm fails to even count a single query of 5-node chain within a week’s time budget on a large target graph Astro Leskovec et al.
Revised: (2004) algorithm fails to even count a single query of 5-node chain within a week’s time budget on a large target graph Astro Leskovec et al.

Original: with nineteen thousand nodes.
Revised: with nineteen thousand nodes.

Original: Luckily, approximate counting of query graphs is sufficient in many real-world use cases Iyer et al.
Revised: Luckily, approximate counting of query graphs is sufficient in many real-world use cases Iyer et al.

Original: ; Kashtan et al.
Revised: ; Kashtan et al.

Original: ; Ribeiro & Silva (2010).
Revised: ; Ribeiro & Silva (2010).

Original: Approximation methods can scale to large targets by substructure sampling, random walk, and color-based sampling, allowing estimation of the frequency of query graph occurrences.
Revised: Approximation methods can scale to large targets by substructure sampling, random walk, and color-based sampling, allowing estimation of the frequency of query graph occurrences.

Original: Very recently, Graph Neural Networks (GNNs) are employed as a deep learning-based approach to subgraph counting Zhao et al.
Revised: Very recently, Graph Neural Networks (GNNs) are employed as a deep learning-based approach to subgraph counting Zhao et al.

Original: Liu et al.
Revised: Liu et al.

Original: ; Chen et al.
Revised: ; Chen et al.

Original: The target graph and the query graph are embedded via a GNN, which predicts the motif count through a regression task.
Revised: The target graph and the query graph are embedded via a GNN, which predicts the motif count through a regression task.

Original: However, there exist several major challenges with existing heuristic and GNN approaches: 1)
Revised: However, there exist several major challenges with existing heuristic and GNN approaches: 1)

Original: The number of possible query graph structures and subgraph counts both grow combinatorially with respect to the graph size Sloane (2014); Read & Wilson (1998), resulting in large approximation error Ribeiro et al.
Revised: The number of possible query graph structures and subgraph counts both grow combinatorially with respect to the graph size Sloane (2014); Read & Wilson (1998), resulting in large approximation error Ribeiro et al.

Original: The count can have high dynamic range from zero to millions, making the task much harder than most graph regression tasks which only predict a single-digit number with a small upperbound.
Revised: The count can have high dynamic range from zero to millions, making the task much harder than most graph regression tasks which only predict a single-digit number with a small upperbound.

Original: The expressive power of commonly used message passing GNNs is limited by the Weisfeiler-Lehman (WL) test Leman & Weisfeiler (1968);
Revised: The expressive power of commonly used message passing GNNs is limited by the Weisfeiler-Lehman (WL) test Leman & Weisfeiler (1968);

Original: Chen et al.
Revised: Chen et al.

Original: Xu et al.
Revised: Xu et al.

Original: Certain structures are not distinguishable with these GNNs, let alone counting them, resulting in the same count prediction for different queries.
Revised: Certain structures are not distinguishable with these GNNs, let alone counting them, resulting in the same count prediction for different queries.

Original: Furthermore, most existing approximate heuristic and
Revised: Furthermore, most existing approximate heuristic and

Original: GNN methods only focus on estimating the total count of a query in the target graph Bressan et al.
Revised: GNN methods only focus on estimating the total count of a query in the target graph Bressan et al.

Original: Liu et al.
Revised: Liu et al.

Original: ; Chen et al.
Revised: ; Chen et al.

Original: (2020), but not the distribution of occurrences of the patterns, as shown in Figure 1.
Revised: (2020), but not the distribution of occurrences of the patterns, as shown in Figure 1.

Original: Yet such distribution information is crucial in various applications Yin et al.
Revised: Yet such distribution information is crucial in various applications Yin et al.

Original: ; Tsourakakis et al.
Revised: ; Tsourakakis et al.

Original: ; Benson et al.
Revised: ; Benson et al.

Original: ; Faust (2010); Holland & Leinhardt (1976).
Revised: ; Faust (2010); Holland & Leinhardt (1976).

Original: Proposed work .
Revised: Proposed work .

Original: To resolve the above challenges, we propose DeSCo, a GNN-based model that learns to predict both pattern counts and distribution on any target graph.
Revised: To resolve the above challenges, we propose DeSCo, a GNN-based model that learns to predict both pattern counts and distribution on any target graph.

Original: The main idea of DeSCo is to leverage and organize local information of neighborhood patterns to predict query count and distribution in the entire target graph.
Revised: The main idea of DeSCo is to leverage and organize local information of neighborhood patterns to predict query count and distribution in the entire target graph.

Original: DeSCo first uses canonical partition to decompose the target graph into small neighborhoods without missing and double-counting any patterns.
Revised: DeSCo first uses canonical partition to decompose the target graph into small neighborhoods without missing and double-counting any patterns.

Original: The local information is then encoded using a GNN with subgraph-based heterogeneous message passing .
Revised: The local information is then encoded using a GNN with subgraph-based heterogeneous message passing .

Original: Finally, we perform gossip correction to improve counting accuracy.
Revised: Finally, we perform gossip correction to improve counting accuracy.

Original: Our contributions are three-fold.
Revised: Our contributions are three-fold.

Original: Canonical partition .
Revised: Canonical partition .

Original: Firstly, we propose a novel divide-and-conquer scheme called canonical partition to decompose the problem into subgraph counting for individual neighborhoods.
Revised: Firstly, we propose a novel divide-and-conquer scheme called canonical partition to decompose the problem into subgraph counting for individual neighborhoods.

Original: The canonical partition ensures that no pattern will be double counted or missed over all neighborhoods.
Revised: The canonical partition ensures that no pattern will be double counted or missed over all neighborhoods.

Original: The algorithm allows the model to make accurate predictions even with the high dynamic range of labels and enables subgraph count distribution prediction for the first time.
Revised: The algorithm allows the model to make accurate predictions even with the high dynamic range of labels and enables subgraph count distribution prediction for the first time.

Original: Figure 1 demonstrates DeSCo’s
Revised: Figure 1 demonstrates DeSCo’s

Original: predictions on the query graph count distribution of a citation network.
Revised: predictions on the query graph count distribution of a citation network.

Original: The count hotspots of different queries can indicate citation patterns of different scientific communities Gao & Lafferty (2017);
Revised: The count hotspots of different queries can indicate citation patterns of different scientific communities Gao & Lafferty (2017);

Original: Yang et al.
Revised: Yang et al.

Original: (2015), which shed light on the research impact of works in this network.
Revised: (2015), which shed light on the research impact of works in this network.

Original: Subgraph-based heterogeneous message passing .
Revised: Subgraph-based heterogeneous message passing .

Original: Secondly, we propose a general approach to enhance the expressive power of any MPGNNs by encoding the subgraph structure through heterogeneous message passing.
Revised: Secondly, we propose a general approach to enhance the expressive power of any MPGNNs by encoding the subgraph structure through heterogeneous message passing.

Original: The message type is determined by whether the edge presents in a certain subgraph, e.g., a triangle.
Revised: The message type is determined by whether the edge presents in a certain subgraph, e.g., a triangle.

Original: We theoretically prove that its expressive power can exceed the upper bound of that of MPGNNs.
Revised: We theoretically prove that its expressive power can exceed the upper bound of that of MPGNNs.

Original: We show that this architecture outperforms expressive GNNs, including
Revised: We show that this architecture outperforms expressive GNNs, including

Original: GIN Xu et al.
Revised: GIN Xu et al.

Original: and
Revised: and

Original: ID-GNN You et al.
Revised: ID-GNN You et al.

Original: Gossip correction .
Revised: Gossip correction .

Original: We overcome the challenge of accurate count prediction by utilizing two inductive biases of the counting problem: homophily and antisymmetry.
Revised: We overcome the challenge of accurate count prediction by utilizing two inductive biases of the counting problem: homophily and antisymmetry.

Original: Real-world graphs share similar patterns among adjacent nodes, as shown in Figure 1.
Revised: Real-world graphs share similar patterns among adjacent nodes, as shown in Figure 1.

Original: Furthermore, since canonical count depends on node indices, exists antisymmetry due to canonical partition.
Revised: Furthermore, since canonical count depends on node indices, exists antisymmetry due to canonical partition.

Original: Therefore, propose a gossip correction phase, featuring a learnable gate for propagation to leverage the inductive biases.
Revised: Therefore, propose a gossip correction phase, featuring a learnable gate for propagation to leverage the inductive biases.

Original: To demonstrate the effectiveness of DeSCo, we compare it against state-of-the-art exact and approximate heuristic methods for subgraph counting as well as recent GNN-based approaches Cordella et al.
Revised: To demonstrate the effectiveness of DeSCo, we compare it against state-of-the-art exact and approximate heuristic methods for subgraph counting as well as recent GNN-based approaches Cordella et al.

Original: ; Bressan et al.
Revised: ; Bressan et al.

Original: ; Chen et al.
Revised: ; Chen et al.

Original: ; Liu et al.
Revised: ; Liu et al.

Original: (2020), in terms of both performance and runtime efficiency.
Revised: (2020), in terms of both performance and runtime efficiency.

Original: Experiments show that DeSCo enables large-scale subgraph counting that was not possible for exact methods.
Revised: Experiments show that DeSCo enables large-scale subgraph counting that was not possible for exact methods.

Original: Compared with heuristic and neural methods, DeSCo achieves more than two orders of magnitude improvement in the mean squared error of count prediction.
Revised: Compared with heuristic and neural methods, DeSCo achieves more than two orders of magnitude improvement in the mean squared error of count prediction.

Original: To the best of our knowledge, it is also the first method to enable accurate count distribution prediction.
Revised: To the best of our knowledge, it is also the first method to enable accurate count distribution prediction.

Original: Furthermore, the model excels in both accuracy and runtime efficiency for larger queries, with the highest percentage of valid predictions and up to two orders of magnitude speedup over heuristic methods.
Revised: Furthermore, the model excels in both accuracy and runtime efficiency for larger queries, with the highest percentage of valid predictions and up to two orders of magnitude speedup over heuristic methods.

Original: Our code is available at https://anonymous.4open science r
Revised: Our code is available at https://anonymous.4open science r

Original: /DeSCo-6BD  R ELATED W ORKS
Revised: /DeSCo-6BD  R ELATED W ORKS

Original: There has been an extensive line of work to solve the subgraph counting problem.
Revised: There has been an extensive line of work to solve the subgraph counting problem.

Original: Exact counting algorithms .
Revised: Exact counting algorithms .

Original: Exact methods generally count subgraphs by searching through all possible node combinations and finding the matching pattern.
Revised: Exact methods generally count subgraphs by searching through all possible node combinations and finding the matching pattern.

Original: Early methods usually focus on improving the matching phase Wernicke & Rasche (2006); Cordella et al.
Revised: Early methods usually focus on improving the matching phase Wernicke & Rasche (2006); Cordella et al.

Original: ; Milo et al.
Revised: ; Milo et al.

Original: Recent approaches emphasize pruning the search space and avoiding double counting Demeyer et al.
Revised: Recent approaches emphasize pruning the search space and avoiding double counting Demeyer et al.

Original: ; Mawhirter et al.
Revised: ; Mawhirter et al.

Original: ; Shi et al.
Revised: ; Shi et al.

Original: ; Mawhirter & Wu (2019).
Revised: ; Mawhirter & Wu (2019).

Original: However, exact methods still scale poorly in terms of query size (often no more than five nodes) despite much efforts Pinar et al.
Revised: However, exact methods still scale poorly in terms of query size (often no more than five nodes) despite much efforts Pinar et al.

Original: ; Chen & Qian (2020).
Revised: ; Chen & Qian (2020).

Original: Approximate heuristic methods .
Revised: Approximate heuristic methods .

Original: To further scale up the counting problem, approximate counting algorithms sample from the target graph to estimate pattern counts.
Revised: To further scale up the counting problem, approximate counting algorithms sample from the target graph to estimate pattern counts.

Original: Strategies like path sampling Wang et al.
Revised: Strategies like path sampling Wang et al.

Original: ; Jha et al.
Revised: ; Jha et al.

Original: (2015), random walk Yang et al.
Revised: (2015), random walk Yang et al.

Original: ; Saha & Hasan (2015), substructure sampling Fu et al.
Revised: ; Saha & Hasan (2015), substructure sampling Fu et al.

Original: (2020); Iyer et al.
Revised: (2020); Iyer et al.

Original: (2018), and color coding Bressan et al.
Revised: (2018), and color coding Bressan et al.

Original: (2021; 2018) are used to narrow the sample space and provides better error bound.
Revised: (2021; 2018) are used to narrow the sample space and provides better error bound.

Original: However, large and rare queries are hard to find in the vast sample space, leading to large approximation error Bressan et al.
Revised: However, large and rare queries are hard to find in the vast sample space, leading to large approximation error Bressan et al.

Original: GNN-based approaches .
Revised: GNN-based approaches .

Original: Recently, GNNs have also been used to attempt subgraph counting.
Revised: Recently, GNNs have also been used to attempt subgraph counting.

Original: Liu et al.
Revised: Liu et al.

Original: (2020) uses GNNs to embed the query and target graph, and predict subgraph counts via embeddings.
Revised: (2020) uses GNNs to embed the query and target graph, and predict subgraph counts via embeddings.

Original: Chen et al.
Revised: Chen et al.

Original: (2020) theoretically analyzes the expressive power of GNNs for counting and proposes an expressive GNN architecture.
Revised: (2020) theoretically analyzes the expressive power of GNNs for counting and proposes an expressive GNN architecture.

Original: Zhao et al.
Revised: Zhao et al.

Original: (2021) proposes an active learning scheme for the problem.
Revised: (2021) proposes an active learning scheme for the problem.

Original: Unfortunately, large target graphs have extremely complex structures and a high dynamic range of pattern count, so accurate prediction remains challenging.
Revised: Unfortunately, large target graphs have extremely complex structures and a high dynamic range of pattern count, so accurate prediction remains challenging.

Original:  P RELIMINARY
Revised:  P RELIMINARY

Original: Let G t
Revised: Let G t

Original: =
Revised: =

Original: ( V t , E t ) be a large target graph with vertices V t and edges E t .
Revised: ( V t , E t ) be a large target graph with vertices V t and edges E t .

Original: Let G q
Revised: Let G q

Original: =
Revised: =

Original: ( V q , E q ) be the query graph of interest.
Revised: ( V q , E q ) be the query graph of interest.

Original: The subgraph counting problem C ( G q , G t ) is to calculate the size of the set of patterns P =
Revised: The subgraph counting problem C ( G q , G t ) is to calculate the size of the set of patterns P =

Original: { G p | G p ⊆
Revised: { G p | G p ⊆

Original: G t } in the target graph G t that are isomorphic to the query graph G q , that is, ∃ bijection f : V p (cid:55)→ V q such that
Revised: G t } in the target graph G t that are isomorphic to the query graph G q , that is, ∃ bijection f : V p (cid:55)→ V q such that

Original: ( f ( v ) , f ( u ))
Revised: ( f ( v ) , f ( u ))

Original: ∈
Revised: ∈

Original: E q iff ( v, u ) ∈
Revised: E q iff ( v, u ) ∈

Original: E p , denoted as G p ∼ = G q .
Revised: E p , denoted as G p ∼ = G q .

Original: Subgraph counting includes induced and non-induced counting depending on whether the pattern
Revised: Subgraph counting includes induced and non-induced counting depending on whether the pattern

Original: G p is restricted to induced subgraph Ribeiro et al.
Revised: G p is restricted to induced subgraph Ribeiro et al.

Original: A G p =
Revised: A G p =

Original: ( V p , E p ) is induced subgraph of G t if ∀ e ∈ E t ↔ e ∈ E p , denoted as G p ⊆
Revised: ( V p , E p ) is induced subgraph of G t if ∀ e ∈ E t ↔ e ∈ E p , denoted as G p ⊆

Original: G t .
Revised: G t .

Original: Without loss of generality, we focus on the connected, induced subgraph counting problem, following modern mainstream graph processing frameworks Hagberg et al.
Revised: Without loss of generality, we focus on the connected, induced subgraph counting problem, following modern mainstream graph processing frameworks Hagberg et al.

Original: Peixoto (2014) and real-world applications Wong et al.
Revised: Peixoto (2014) and real-world applications Wong et al.

Original: Milo et al.
Revised: Milo et al.

Original: It is also possible to obtain non-induced occurrences from induced ones with a transformation Floderus et al.
Revised: It is also possible to obtain non-induced occurrences from induced ones with a transformation Floderus et al.

Original: Our approach can easily support graphs with node features and edge directions.
Revised: Our approach can easily support graphs with node features and edge directions.

Original: But to compare with heuristic methods that only support simple graphs, we use undirected graphs without node features to investigate the ability to capture graph topology.
Revised: But to compare with heuristic methods that only support simple graphs, we use undirected graphs without node features to investigate the ability to capture graph topology.

Original:  D E SC O F RAMEWORK
Revised:  D E SC O F RAMEWORK

Original: In this section, we introduce the pipeline of DeSCo.
Revised: In this section, we introduce the pipeline of DeSCo.

Original: To perform subgraph counting, DeSCo first performs canonical partition to decompose the target graph to many canonical neighborhood graphs.
Revised: To perform subgraph counting, DeSCo first performs canonical partition to decompose the target graph to many canonical neighborhood graphs.

Original: Then, neighborhood counting uses the subgraph-based heterogeneous GNN to embed the query and neighborhood graphs and performs a regression task to predict the canonical count on each neighborhood.
Revised: Then, neighborhood counting uses the subgraph-based heterogeneous GNN to embed the query and neighborhood graphs and performs a regression task to predict the canonical count on each neighborhood.

Original: Finally, gossip correction propagates neighborhood count predictions over the target graph.
Revised: Finally, gossip correction propagates neighborhood count predictions over the target graph.

Original: We will first introduce the model objective before elaborating on each step.
Revised: We will first introduce the model objective before elaborating on each step.

Original: 4. C ANONICAL C OUNT O BJECTIVE
Revised: 4. C ANONICAL C OUNT O BJECTIVE

Original: The canonical count is used as a local count prediction objective for the GNN and gossip correction, after decomposing the target into small neighborhoods without missing or double-counting patterns.
Revised: The canonical count is used as a local count prediction objective for the GNN and gossip correction, after decomposing the target into small neighborhoods without missing or double-counting patterns.

Original: Canonical node .
Revised: Canonical node .

Original: We use randomly assigned node indices on the target graph to break the symmetry of patterns.
Revised: We use randomly assigned node indices on the target graph to break the symmetry of patterns.

Original: We assign the match of a k-node pattern to its canonical node based on the index.
Revised: We assign the match of a k-node pattern to its canonical node based on the index.

Original: Formally, the canonical node v c is the node with the largest node index in the pattern: v c = max
Revised: Formally, the canonical node v c is the node with the largest node index in the pattern: v c = max

Original: I V p .
Revised: I V p .

Original: The number of patterns that share the same canonical node is called the canonical count C c on this node as shown in Figure 3 (c).
Revised: The number of patterns that share the same canonical node is called the canonical count C c on this node as shown in Figure 3 (c).

Original: Note how the match of a k-node pattern is only attributed to the canonical node, since the other k-1 nodes do not satisfy v = max I V p .
Revised: Note how the match of a k-node pattern is only attributed to the canonical node, since the other k-1 nodes do not satisfy v = max I V p .

Original: It also suggests that the node with a relatively larger node index will result in a larger canonical count.
Revised: It also suggests that the node with a relatively larger node index will result in a larger canonical count.

Original: This characteristic will be utilized by gossip correction discussed in Section 4.4.
Revised: This characteristic will be utilized by gossip correction discussed in Section 4.4.

Original: Definition 4.1 (canonical count) .
Revised: Definition 4.1 (canonical count) .

Original: [Equation]
Revised: [Equation]

Original: We prove the following Lemma in Appendix A.1.
Revised: We prove the following Lemma in Appendix A.1.

Original: Lemma 4.1.
Revised: Lemma 4.1.

Original: The subgraph count of query in target equals the summation of the canonical count of query in target over all target nodes.
Revised: The subgraph count of query in target equals the summation of the canonical count of query in target over all target nodes.

Original: [Equation]
Revised: [Equation]

Original: Lemma 4.1 allows the decomposition of the counting problem into multiple neighborhood canonical counting objectives.
Revised: Lemma 4.1 allows the decomposition of the counting problem into multiple neighborhood canonical counting objectives.

Original: We use the following canonical partition for the decomposition.
Revised: We use the following canonical partition for the decomposition.

Original: 4. C ANONICAL P ARTITION
Revised: 4. C ANONICAL P ARTITION

Original: Based on Lemma 4.1, we define canonical partition that decomposes the target graph.
Revised: Based on Lemma 4.1, we define canonical partition that decomposes the target graph.

Original: Figure 3 (a), (b) shows an example of the canonical neighborhood, obtained by a partition function P defined as:
Revised: Figure 3 (a), (b) shows an example of the canonical neighborhood, obtained by a partition function P defined as:

Original: [Equation]
Revised: [Equation]

Original: D ( G t , v i , v c ) means the shortest distance between v
Revised: D ( G t , v i , v c ) means the shortest distance between v

Original: i and v c on G t .
Revised: i and v c on G t .

Original: We further prove:
Revised: We further prove:

Original: Theorem 1.
Revised: Theorem 1.

Original: The subgraph count of query in target equals the summation of the canonical count of query in canonical neighborhoods over all target nodes.
Revised: The subgraph count of query in target equals the summation of the canonical count of query in canonical neighborhoods over all target nodes.

Original: Canonical neighborhoods are acquired with partition P , given any d greater than the diameter of query.
Revised: Canonical neighborhoods are acquired with partition P , given any d greater than the diameter of query.

Original: [Equation]
Revised: [Equation]

Original: Definition 4.2 (Canonical partition) .
Revised: Definition 4.2 (Canonical partition) .

Original: Given target graph G t , canonical partition iterates over all nodes v of the target G t and partition it into a set of canonical neighborhoods G v c .
Revised: Given target graph G t , canonical partition iterates over all nodes v of the target G t and partition it into a set of canonical neighborhoods G v c .

Original: [Equation]
Revised: [Equation]

Original: Missing count or double counting are avoided with Theorem 1 and Definition 4.2, which is detailedly proven in Appendix A.2.
Revised: Missing count or double counting are avoided with Theorem 1 and Definition 4.2, which is detailedly proven in Appendix A.2.

Original: In practice, we set d as the maximum diameter of query graphs to meet the requirements of Theorem.1.
Revised: In practice, we set d as the maximum diameter of query graphs to meet the requirements of Theorem.1.

Original: See Appendix A.3 for implementation of P ( G t , v c , d ) .
Revised: See Appendix A.3 for implementation of P ( G t , v c , d ) .

Original: Appendix A. shows that canonical partition reduces the complexity of the problem by dozens of magnitude.
Revised: Appendix A.3 shows that canonical partition reduces the complexity of the problem by a dozen orders of magnitude.

Original: After canonical partition, DeSCo uses a GNN to predict the canonical count for each decomposed neighborhood.
Revised: After canonical partition, DeSCo uses a GNN to predict the canonical count for each decomposed neighborhood.

Original: This divide-and-conquer scheme not only greatly reduces the complexity of each GNN prediction, but also makes it possible to predict the count distribution over the entire graph.
Revised: This divide-and-conquer scheme not only greatly reduces the complexity of each GNN prediction, but also makes it possible to predict the count distribution over the entire graph.

Original: 4. N EIGHBORHOOD C OUNT P REDICTION
Revised: 4. N EIGHBORHOOD C OUNT P REDICTION

Original: After canonical partition, GNNs are used to predict the canonical count C c ( G q , G v c , v c ) on any canonical neighborhood G v c .
Revised: After canonical partition, GNNs are used to predict the canonical count C c ( G q , G v c , v c ) on any canonical neighborhood G v c .

Original: The canonical neighborhood and the query are separately embedded using GNNs.
Revised: The canonical neighborhood and the query are separately embedded using GNNs.

Original: The embeddings are passed to a multilayer perceptron to predict the canonical count.
Revised: The embeddings are passed to a multilayer perceptron to predict the canonical count.

Original: To strengthen the expressive power of the GNN used in neighborhood count, we propose a general
Revised: To strengthen the expressive power of the GNN used in neighborhood count, we propose a general

Original: Subgraph-based Heterogeneous Message Passing (SHMP), which incorporates topological information through node and edge types.
Revised: Subgraph-based Heterogeneous Message Passing (SHMP), which incorporates topological information through node and edge types.

Original: The canonical node of the neighborhood is treated as a special node type.
Revised: The canonical node of the neighborhood is treated as a special node type.

Original: SHMP further uses small subgraph structures to categorize edges into different edge types, and use different learnable weights for each edge type.
Revised: SHMP further uses small subgraph structures to categorize edges into different edge types, and use different learnable weights for each edge type.

Original: [Figure]
Revised: [Figure]

Original: While embedded better expressive
Revised: While embedded better expressive

Original: SHMP the gossip model balance the influence of homophily and antisymmetry by controlling message directions.
Revised: SHMP the gossip model balance the influence of homophily and antisymmetry by controlling message directions.

Original: Definition 4.3 (subgraph-based heterogeneous message passing) .
Revised: Definition 4.3 (subgraph-based heterogeneous message passing) .

Original: The SHMP uses the following equation 6 to compute each node’s representation at layer k .
Revised: The SHMP uses the following equation 6 to compute each node’s representation at layer k .

Original: Here ϕ kh denotes the message function of the h-th edge type.
Revised: Here ϕ kh denotes the message function of the h-th edge type.

Original: N h ( i ) denotes nodes that connect to node i with the h-th edge type.
Revised: N h ( i ) denotes nodes that connect to node i with the h-th edge type.

Original: A GG and
Revised: A GG and

Original: A GG ′ are the permutation invariant aggregation function such as sum, mean, or max.
Revised: A GG ′ are the permutation invariant aggregation function such as sum, mean, or max.

Original: [Equation]
Revised: [Equation]

Original: Note that MP defined by major GNN frameworks Fey & Lenssen (2019); Wang et al.
Revised: Note that MP defined by major GNN frameworks Fey & Lenssen (2019); Wang et al.

Original: (2019) is just a special case of SHMP if only one edge type is derived with the subgraph structure.
Revised: (2019) is just a special case of SHMP if only one edge type is derived with the subgraph structure.

Original: We theoretically prove that SHMP can exceed the upper bound of MP in terms of expressiveness in Appendix B.1.
Revised: We theoretically prove that SHMP can exceed the upper bound of MP in terms of expressiveness in Appendix B.1.

Original: For example, Figure 4(a) demonstrates that triangle-based heterogeneous message passing has better expressive power.
Revised: For example, Figure 4(a) demonstrates that triangle-based heterogeneous message passing has better expressive power.

Original: Regular MPGNNs fail to distinguish different d-regular graphs G 1 and
Revised: Regular MPGNNs fail to distinguish different d-regular graphs G 1 and

Original: G 2 because of their identical type I messages and embeddings, which is a common problem of
Revised: G 2 because of their identical type I messages and embeddings, which is a common problem of

Original: MPGNNs You et al.
Revised: MPGNNs You et al.

Original: SHMP, however, can discriminate the two graphs by giving different embeddings.
Revised: SHMP, however, can discriminate the two graphs by giving different embeddings.

Original: The edges are first categorized into two edge types based on whether they exist in any triangles (edges are colored purple if they exist in any triangles).
Revised: The edges are first categorized into two edge types based on whether they exist in any triangles (edges are colored purple if they exist in any triangles).

Original: Since no triangles exist in G 2 , all of its nodes still receive type I messages.
Revised: Since no triangles exist in G 2 , all of its nodes still receive type I messages.

Original: While some nodes of G 1 now receive type II messages with two purple messages and one gray message in each layer.
Revised: While some nodes of G 1 now receive type II messages with two purple messages and one gray message in each layer.

Original: As a result, the model acquires not only the adjacency information between the message sender and receiver, but also information among their neighbors.
Revised: As a result, the model acquires not only the adjacency information between the message sender and receiver, but also information among their neighbors.

Original: Such subgraph structural information improves expressiveness by incorporating high-order information in both the query and the target.
Revised: Such subgraph structural information improves expressiveness by incorporating high-order information in both the query and the target.

Original: 4. G OSSIP C ORRECTION
Revised: 4. G OSSIP C ORRECTION

Original: Given the count predictions ˆ C c output by the GNN, DeSCo uses gossip correction to improve the prediction quality, enforcing different homophily and antisymmetry inductive biases for different queries.
Revised: Given the count predictions ˆ C c output by the GNN, DeSCo uses gossip correction to improve the prediction quality, enforcing different homophily and antisymmetry inductive biases for different queries.

Original: Gossip correction uses another GNN to model the error of neighborhood count.
Revised: Gossip correction uses another GNN to model the error of neighborhood count.

Original: It uses the predicted ˆ C c as input, and the canonical counts C c as the supervision for corresponding nodes in the target graph.
Revised: It uses the predicted ˆ C c as input, and the canonical counts C c as the supervision for corresponding nodes in the target graph.

Original: Motivation .
Revised: Motivation .

Original: Two different inductive biases are used to improve the accuracy.
Revised: Two different inductive biases are used to improve the accuracy.

Original: Homophily .
Revised: Homophily .

Original: Since the neighborhoods of adjacent nodes share much common graph structure, they tend to have similar canonical counts as shown in Figure1.
Revised: Since the neighborhoods of adjacent nodes share much common graph structure, they tend to have similar canonical counts as shown in Figure1.

Original: This is called the homophily of canonical counts.
Revised: This is called the homophily of canonical counts.

Original: 2) Antisymmetry .
Revised: 2) Antisymmetry .

Original: As mentioned in Section4.1, for nodes with similar neighborhood structures, the one with a larger node index has a larger canonical count, resulting in antisymmetry of canonical counts.
Revised: As mentioned in Section4.1, for nodes with similar neighborhood structures, the one with a larger node index has a larger canonical count, resulting in antisymmetry of canonical counts.

Original: See the example target graph in Figure 2, which satisfies the inductive biases.
Revised: See the example target graph in Figure 2, which satisfies the inductive biases.

Original: Appendix C further shows that homophily and antisymmetry are mutually exclusive for different queries, which corresponds to our gossip model design in Figure 4(b).
Revised: Appendix C further shows that homophily and antisymmetry are mutually exclusive for different queries, which corresponds to our gossip model design in Figure 4(b).

Original: Gossip correction with learnable gates .
Revised: Gossip correction with learnable gates .

Original: As shown in Figure 4(b), The proposed gossip model multiplies a learnable gate P for the message sent from the node with the smaller index, and 1 − P from the reversed one.
Revised: As shown in Figure 4(b), The proposed gossip model multiplies a learnable gate P for the message sent from the node with the smaller index, and 1 − P from the reversed one.

Original: P is learned from the query embedding.
Revised: P is learned from the query embedding.

Original: For different queries, P ranges from 0 to 1 to balance the influence of homophily and antisymmetry .
Revised: For different queries, P ranges from 0 to 1 to balance the influence of homophily and antisymmetry .

Original: When P → 0 . 5 , messages from the smaller indexed node and the reversed one are weighed equally.
Revised: When P → 0 . 5 , messages from the smaller indexed node and the reversed one are weighed equally.

Original: So it simulates undirected message passing that stress homophily by taking the average of adjacent node values.
Revised: So it simulates undirected message passing that stress homophily by taking the average of adjacent node values.

Original: When the gate value moves away from 0.5, the message from a certain end of the edge is strengthened.
Revised: When the gate value moves away from 0.5, the message from a certain end of the edge is strengthened.

Original: For example, when P → 1 , the node values only accumulate from nodes with smaller indices to nodes with larger ones.
Revised: For example, when P → 1 , the node values only accumulate from nodes with smaller indices to nodes with larger ones.

Original: So that it simulates directed message passing that stress antisymmetry of the transitive partial order of node indices.
Revised: So that it simulates directed message passing that stress antisymmetry of the transitive partial order of node indices.

Original: The messages of MPGNNs are multiplied with g ji on both edge directions.
Revised: The messages of MPGNNs are multiplied with g ji on both edge directions.

Original: With the learnable gates, the model now better utilizes the mutually exclusive inductive biases for better error correction.
Revised: With the learnable gates, the model now better utilizes the mutually exclusive inductive biases for better error correction.

Original: [Equation]
Revised: [Equation]

Original: Final count prediction .
Revised: Final count prediction .

Original: The gossip-corrected neighborhood count is a more accurate estimation of the canonical count and distribution.
Revised: The gossip-corrected neighborhood count is a more accurate estimation of the canonical count and distribution.

Original: The summation of the (corrected) neighborhood count is the unbiased estimation of subgraph count on the whole target graph as Theorem 1 states.
Revised: The summation of the (corrected) neighborhood count is the unbiased estimation of subgraph count on the whole target graph as Theorem 1 states.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We compare the performance of DeSCo with state-of-the-art approximate heuristic and neural subgraph counting methods.
Revised: We compare the performance of DeSCo with state-of-the-art approximate heuristic and neural subgraph counting methods.

Original: The runtime advantage is also demonstrated with popular exact methods.
Revised: The runtime advantage is also demonstrated with popular exact methods.

Original: Extensive ablation studies further show the benefit of each component of DeSCo.
Revised: Extensive ablation studies further show the benefit of each component of DeSCo.

Original: 5. E XPERIMENTAL S ETUP
Revised: 5. E XPERIMENTAL S ETUP

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: Datasets .
Revised: Datasets .

Original: We use real-world datasets from various domains as the target graphs, including chemistry(MUTAG Debnath et al.
Revised: We use real-world datasets from various domains as the target graphs, including chemistry(MUTAG Debnath et al.

Original: (1991), COX2 Rossi & Ahmed (2015)), biology(ENZYMES Borgwardt et al.
Revised: (1991), COX2 Rossi & Ahmed (2015)), biology(ENZYMES Borgwardt et al.

Original: and citation networks(CiteSeer Giles et al.
Revised: and citation networks(CiteSeer Giles et al.

Original: (1998), Cora McCallum et al.
Revised: (1998), Cora McCallum et al.

Original: We also generate a large synthetic dataset with mixed graph generators Holme & Kim (2002); Albert & Barab ´ asi (2000); Watts & Strogatz (1998); Erd ˝ os et al.
Revised: We also generate a large synthetic dataset with mixed graph generators Holme & Kim (2002); Albert & Barab ´ asi (2000); Watts & Strogatz (1998); Erd ˝ os et al.

Original: (1960) to cover diverse graph characteristics.
Revised: (1960) to cover diverse graph characteristics.

Original: All the datasets are treated as undirected graphs without node or edge features in alignment with the setting of the approximate heuristic method Bressan et al.
Revised: All the datasets are treated as undirected graphs without node or edge features in alignment with the setting of the approximate heuristic method Bressan et al.

Original: The standard query graphs include all non-isomorphic, connected, undirected graphs with node size 3 − 5 .
Revised: The standard query graphs include all non-isomorphic, connected, undirected graphs with node size 3 − 5 .

Original: The ground truth total counts and canonical counts of these queries are generated with the exact counting method on all the target graphs from the above datasets.
Revised: The ground truth total counts and canonical counts of these queries are generated with the exact counting method on all the target graphs from the above datasets.

Original: Pretraining .
Revised: Pretraining .

Original: To perform subgraph counting on any target graph, we first pre-train all the neural methods with the target-query pairs from the synthetic dataset and the standard queries of size 3 − 5 .
Revised: To perform subgraph counting on any target graph, we first pre-train all the neural methods with the target-query pairs from the synthetic dataset and the standard queries of size 3 − 5 .

Original: The neural baselines are trained and tested with the total subgraph count objective.
Revised: The neural baselines are trained and tested with the total subgraph count objective.

Original: After pretraining, DeSCo can be evaluated by predicting the total count in alignment with the baselines.
Revised: After pretraining, DeSCo can be evaluated by predicting the total count in alignment with the baselines.

Original: Unless specified, the trained models are directly tested with standard queries and the targets from unseen, real-world datasets.
Revised: Unless specified, the trained models are directly tested with standard queries and the targets from unseen, real-world datasets.

Original: Therefore, in our evaluation, DeSCo only needs to be trained once from scratch across common datasets and tasks.
Revised: Therefore, in our evaluation, DeSCo only needs to be trained once from scratch across common datasets and tasks.

Original: Baselines .
Revised: Baselines .

Original: For neural-based approaches, we adopt state-of-the-art subgraph counting GNNs,
Revised: For neural-based approaches, we adopt state-of-the-art subgraph counting GNNs,

Original: LRP Chen et al.
Revised: LRP Chen et al.

Original: (2020) and DIAMNet Liu et al.
Revised: (2020) and DIAMNet Liu et al.

Original: For the approximate heuristic counting method, we choose the state-of-the-art color-based sampling method MOTIVO Bressan et al.
Revised: For the approximate heuristic counting method, we choose the state-of-the-art color-based sampling method MOTIVO Bressan et al.

Original: It uses color coding to greatly narrow the sample space with efficient c++ implementation.
Revised: It uses color coding to greatly narrow the sample space with efficient c++ implementation.

Original: For exact counting methods, we consider VF2 Cordella et al.
Revised: For exact counting methods, we consider VF2 Cordella et al.

Original: and IMSM Sun & Luo (2020).
Revised: and IMSM Sun & Luo (2020).

Original: VF2 is widely used in major graph processing frameworks Hagberg et al.
Revised: VF2 is widely used in major graph processing frameworks Hagberg et al.

Original: Peixoto (2014).
Revised: Peixoto (2014).

Original: [Figure]
Revised: [Figure]

Original: IMSM is a common framework that combines optimizations from multiple exact counting methods He & Singh (2008); Bonnici et al.
Revised: IMSM is a common framework that combines optimizations from multiple exact counting methods He & Singh (2008); Bonnici et al.

Original: ; Bhattarai et al.
Revised: ; Bhattarai et al.

Original: ; Han et al.
Revised: ; Han et al.

Original: Refer to
Revised: Refer to

Original: Appendix D.3 and E for the configuration details of the baselines.
Revised: Appendix D.3 and E for the configuration details of the baselines.

Original: Evaluation metric .
Revised: Evaluation metric .

Original: We follow the previous works Chen et al.
Revised: We follow the previous works Chen et al.

Original: ; Liu et al.
Revised: ; Liu et al.

Original: and use mean square error (MSE) of total subgraph count prediction as our evaluation metric.
Revised: and use mean square error (MSE) of total subgraph count prediction as our evaluation metric.

Original: The MSE values of each query size are normalized by dividing the variance of the ground truth counts.
Revised: The MSE values of each query size are normalized by dividing the variance of the ground truth counts.

Original: 5. N EURAL C OUNTING
Revised: 5. N EURAL C OUNTING

Original: Table 3 summarizes the normalized MSE for predicting the subgraph count of twenty-nine standard query graphs on datasets consisting of many target graphs.
Revised: Table 3 summarizes the normalized MSE for predicting the subgraph count of twenty-nine standard query graphs on datasets consisting of many target graphs.

Original: With canonical partition, neighborhood counting, and gossip correction, DeSCo demonstrates 437 × improvements against the best baseline on average.
Revised: With canonical partition, neighborhood counting, and gossip correction, DeSCo demonstrates 437 × improvements against the best baseline on average.

Original: This demonstrates that neural subgraph counting is truly reliable in real-world problems, even for smaller queries of size 3 − 5 .
Revised: This demonstrates that neural subgraph counting is truly reliable in real-world problems, even for smaller queries of size 3 − 5 .

Original: The relative count error under the q-error metric is also discussed in Appendix G. DeSCo also highlights the accurate count distribution prediction for the first time.
Revised: The relative count error under the q-error metric is also discussed in Appendix G.1. DeSCo also highlights the accurate count distribution prediction for the first time.

Original: The distribution prediction realizes 0 .
Revised: The distribution prediction realizes 0 .

Original: 23 normalized MSE as discussed in Appendix 
Revised: 23 normalized MSE as discussed in Appendix F

Original: [Table]
Revised: [Table]

Original: 5. S CALIBILITY
Revised: 5. S CALIBILITY

Original: Generalization .
Revised: Generalization .

Original: Obtaining ground truth for large queries and targets via exact counting is extremely expensive and can take months, so we only test scalable queries and targets with the following setting in Section 5.3.
Revised: Obtaining ground truth for large queries and targets via exact counting is extremely expensive and can take months, so we only test scalable queries and targets with the following setting in Section 5.3.

Original: Here we demonstrate that with minimal pre-training, the model is able to generalize and make reliable predictions for larger queries and targets.
Revised: Here we demonstrate that with minimal pre-training, the model is able to generalize and make reliable predictions for larger queries and targets.

Original: Large queries .
Revised: Large queries .

Original: For each query size between 6 to 13 , we select two queries that frequently appear in ENZYMES.
Revised: For each query size between 6 to 13 , we select two queries that frequently appear in ENZYMES.

Original: A smaller synthetic dataset with 2048 graphs is used to generate the ground truth for these sixteen queries.
Revised: A smaller synthetic dataset with 2048 graphs is used to generate the ground truth for these sixteen queries.

Original: All the models are pre-trained with standard queries.
Revised: All the models are pre-trained with standard queries.

Original: All the models, except for DeSCo(zero-shot), are fine-tuned with larger queries on the small synthetic dataset.
Revised: All the models, except for DeSCo(zero-shot), are fine-tuned with larger queries on the small synthetic dataset.

Original: DeSCo(zeroshot) is used to show the generalization power of DeSCo for unseen queries.
Revised: DeSCo(zeroshot) is used to show the generalization power of DeSCo for unseen queries.

Original: The distributions of the square error of each query-target pair are shown in Figure 5.
Revised: The distributions of the square error of each query-target pair are shown in Figure 5.

Original: The square errors are normalized with the variance of all ground truth counts.
Revised: The square errors are normalized with the variance of all ground truth counts.

Original: Large target .
Revised: Large target .

Original: We also test the models on large target graphs shown in Table 2.
Revised: We also test the models on large target graphs shown in Table 2.

Original: The maximum ground truth count of standard queries goes up to 3 .
Revised: The maximum ground truth count of standard queries goes up to 3 .

Original: 8 × 10 6 and 3 .
Revised: 8 × 10 6 and 3 .

Original: 3 × 10 7 on CiteSeer and Cora, thus a hard task.
Revised: 3 × 10 7 on CiteSeer and Cora, thus a hard task.

Original: When directly tested, LRP and DIAMNet overflow normal float precision.
Revised: When directly tested, LRP and DIAMNet overflow normal float precision.

Original: So we tune all the models on one graph and test on the other to simulate transfer learning between graphs from the same domain.
Revised: So we tune all the models on one graph and test on the other to simulate transfer learning between graphs from the same domain.

Original: LRP either exceeds 32GB GPU memory in tuning, or predicts infinite caused by overflow.
Revised: LRP either exceeds 32GB GPU memory in tuning, or predicts infinite caused by overflow.

Original: 5. A BLATION S TUDY
Revised: 5. A BLATION S TUDY

Original: We explore the effectiveness of each component of DeSCo through the ablation study by removing each component.
Revised: We explore the effectiveness of each component of DeSCo through the ablation study by removing each component.

Original: Ablation of canonical partition .
Revised: Ablation of canonical partition .

Original: We remove the canonical partition of DeSCo and train it with the objective of subgraph count on the whole target, the same as other neural baselines.
Revised: We remove the canonical partition of DeSCo and train it with the objective of subgraph count on the whole target, the same as other neural baselines.

Original: This demonstrates the effectiveness of the divide-and-conquer scheme of canonical partition.
Revised: This demonstrates the effectiveness of the divide-and-conquer scheme of canonical partition.

Original: [Table]
Revised: [Table]

Original: Ablation of subgraph-based heterogeneous message passing .
Revised: Ablation of subgraph-based heterogeneous message passing .

Original: We use our proposed SHMP to improve the performance of GraphSAGE by transforming its standard message passing to heterogeneous message passing.
Revised: We use our proposed SHMP to improve the performance of GraphSAGE by transforming its standard message passing to heterogeneous message passing.

Original: We use triangle as the subgraph to categorize heterogeneous edges as shown in Figure 4(a).
Revised: We use triangle as the subgraph to categorize heterogeneous edges as shown in Figure 4(a).

Original: Note how SHMP outperforms expressive GNNs, including GIN and ID-GNN.
Revised: Note how SHMP outperforms expressive GNNs, including GIN and ID-GNN.

Original: [Table]
Revised: [Table]

Original: Ablation of gossip correction .
Revised: Ablation of gossip correction .

Original: The normalized MSE of direct summation of neighborhood counts and the summation after gossip correction are compared to show the effectiveness of gossip correction.
Revised: The normalized MSE of direct summation of neighborhood counts and the summation after gossip correction are compared to show the effectiveness of gossip correction.

Original: We use ENZYMES and Cora to do the ablation study since the error of other graphs is already very low with only canonical partition and neighborhood counting.
Revised: We use ENZYMES and Cora to do the ablation study since the error of other graphs is already very low with only canonical partition and neighborhood counting.

Original: [Table]
Revised: [Table]

Original: 5. R UNTIME C OMPARISON
Revised: 5. R UNTIME C OMPARISON

Original: DeSCo benefits from polynomial time complexity: O ( E 3 / 2 t
Revised: DeSCo benefits from polynomial time complexity: O ( E 3 / 2 t

Original: [Equation]
Revised: [Equation]

Original: ¯ E n ))
Revised: ¯ E n ))

Original: + O ( E
Revised: + O ( E

Original: 3 / 2 q + V q ) .
Revised: 3 / 2 q + V q ) .

Original: In contrast, both the exact methods VF2, IMSM, and the approximate heuristic method MOTIVO suffer from exponentially growing runtime with regard to the query size in practice.
Revised: In contrast, both the exact methods VF2, IMSM, and the approximate heuristic method MOTIVO suffer from exponentially growing runtime with regard to the query size in practice.

Original: Experiments show that DeSCo scales to much larger queries than the exact methods and achieves up to 120 × speedup over the approximate heuristic method for large queries.
Revised: Experiments show that DeSCo scales to much larger queries than the exact methods and achieves up to 120 × speedup over the approximate heuristic method for large queries.

Original: The detailed runtime comparison is discussed in Appendix E.
Revised: The detailed runtime comparison is discussed in Appendix E.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: We propose DeSCo, a neural network based framework for scalable subgraph counting.
Revised: We propose DeSCo, a neural network based framework for scalable subgraph counting.

Original: With canonical partition, subgraph-based heterogeneous message passing, and gossip correction, DeSCo accurately predicts counts for both large queries and targets.
Revised: With canonical partition, subgraph-based heterogeneous message passing, and gossip correction, DeSCo accurately predicts counts for both large queries and targets.

Original: It demonstrates two magnitudes of improvements in mean square error and runtime efficiency.
Revised: It demonstrates two magnitudes of improvements in mean square error and runtime efficiency.

Original: It additionally provides the important locational distribution of patterns that previous works cannot.
Revised: It additionally provides the important locational distribution of patterns that previous works cannot.

Original: A C ANONICAL P ARTITION A. P ROOF OF L EMMA 4. 
Revised: A C ANONICAL P ARTITION A. P ROOF OF L EMMA 4.

Original: Proof.
Revised: Proof.

Original: Following the notions from Section 3, given a query graph G q and a target graph G t , the node-induced count is defined as the number of G t ’s node-induced subgraph, pattern, G p that is isomorphic to G q .
Revised: Following the notions from Section 3, given a query graph G q and a target graph G t , the node-induced count is defined as the number of G t ’s node-induced subgraph, pattern, G p that is isomorphic to G q .

Original: We denote the set of all G p as M .
Revised: We denote the set of all G p as M .

Original: [Equation]
Revised: [Equation]

Original: Assuming that G q has k nodes.
Revised: Assuming that G q has k nodes.

Original: Then, under the node-induced definition, given G t , we can use the k-node set V p
Revised: Then, under the node-induced definition, given G t , we can use the k-node set V p

Original: = { v | v ∈ G p } of G p to represent the pattern.
Revised: = { v | v ∈ G p } of G p to represent the pattern.

Original: We can decompose the set of all patterns M into many subsets M c based on the maximum node index of each G p ∈ M .
Revised: We can decompose the set of all patterns M into many subsets M c based on the maximum node index of each G p ∈ M .

Original: [Equation]
Revised: [Equation]

Original: This maximum-index decomposition is exclusive and complete: every G p has a single corresponding maximum node index.
Revised: This maximum-index decomposition is exclusive and complete: every G p has a single corresponding maximum node index.

Original: So we have the following properties:
Revised: So we have the following properties:

Original: [Equation]
Revised: [Equation]

Original: Thus, the node-induced count in Equation 9 can be rewritten using the inclusion-exclusion principle.
Revised: Thus, the node-induced count in Equation 9 can be rewritten using the inclusion-exclusion principle.

Original: [Equation]
Revised: [Equation]

Original: = | V |
Revised: = | V |

Original: [Equation]
Revised: [Equation]

Original: c
Revised: c

Original: [Equation]
Revised: [Equation]

Original: | M c | + | V |− 1 (cid:88) k
Revised: | M c | + | V |− 1 (cid:88) k

Original: = ( − 1) k   (cid:88) 

Revised: = ( − 1) k   (cid:88)

Original: ≤
Revised: ≤

Original: i 0 ≤··· i k ≤| V |−| M
Revised: i 0 ≤··· i k ≤| V |−| M

Original: i
Revised: i

Original: [Equation]
Revised: [Equation]

Original: According to the definition of canonical count in Equation 1, C c ( G q , G t , v c ) =
Revised: According to the definition of canonical count in Equation 1, C c ( G q , G t , v c ) =

Original: | M c | .
Revised: | M c | .

Original: Thus,
Revised: Thus,

Original: Lemma 4.1 is proven with Equation 13.
Revised: Lemma 4.1 is proven with Equation 13.

Original: A. P ROOF OF T HEOREM
Revised: A. P ROOF OF T HEOREM

Original: Proof.
Revised: Proof.

Original: By the definition of M c in Equation 10, we have a corollary.
Revised: By the definition of M c in Equation 10, we have a corollary.

Original: Corollary 1.1.
Revised: Corollary 1.1.

Original: Denote v c ’s index as c , D as the shortest path length between two nodes.
Revised: Denote v c ’s index as c , D as the shortest path length between two nodes.

Original: Any graph in M c has node v c and has the same graph-level property with G q , e.g., diameter.
Revised: Any graph in M c has node v c and has the same graph-level property with G q , e.g., diameter.

Original: [Equation]
Revised: [Equation]

Original: The distance between v c and any nodes of G p in M c is bounded by max v i ,v j ∈ V q D ( G q , v i , v j ) as shown in corollary 1.1.
Revised: The distance between v c and any nodes of G p in M c is bounded by max v i ,v j ∈ V q D ( G q , v i , v j ) as shown in corollary 1.1.

Original: So we can further know that graphs in M c are node-induced subgraphs of v c ’s d-hop ego-graph.
Revised: So we can further know that graphs in M c are node-induced subgraphs of v c ’s d-hop ego-graph.

Original: [Equation]
Revised: [Equation]

Original: Given Equation 10, it is also clear that all graphs in M c have smaller node indices than c .
Revised: Given Equation 10, it is also clear that all graphs in M c have smaller node indices than c .

Original: [Equation]
Revised: [Equation]

Original: With Equation 15 and 16, we know that all the graphs in M c are subgraphs of P ( G t , v c , d ) defined in Equation 3.
Revised: With Equation 15 and 16, we know that all the graphs in M c are subgraphs of P ( G t , v c , d ) defined in Equation 3.

Original: Thus, with respect to Equation 8, we can redefine M c as follows.
Revised: Thus, with respect to Equation 8, we can redefine M c as follows.

Original: [Equation]
Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: Combining Equation 13 with Equation 17, Theorem 1 is proven.
Revised: Combining Equation 13 with Equation 17, Theorem 1 is proven.

Original: A. I MPLEMENTATION OF C ANONICAL P ARTITION
Revised: A. I MPLEMENTATION OF C ANONICAL P ARTITION

Original: V c ← { v c } , V front ← { v c } while depth < d do
Revised: V c ← { v c } , V front ← { v c } while depth < d do

Original: V add ← { v | v ∈ (cid:83) v i ∈ V front { v j | ( v i , v
Revised: V add ← { v | v ∈ (cid:83) v i ∈ V front { v j | ( v i , v

Original: j ) ∈
Revised: j ) ∈

Original: E t } , v ≤ v c }
Revised: E t } , v ≤ v c }

Original: V front ← V add \ V c
Revised: V front ← V add \ V c

Original: V c ← V c ∪ V front end while
Revised: V c ← V c ∪ V front end while

Original: G c ← ( V c , E c ) s .
Revised: G c ← ( V c , E c ) s .

Original: t .
Revised: t .

Original: G c ⊆
Revised: G c ⊆

Original: G t
Revised: G t

Original: The canonical partition is implemented using an index-restricted breadth-first search (BFS).
Revised: The canonical partition is implemented using an index-restricted breadth-first search (BFS).

Original: Compared with regular BFS, it restricts the frontier nodes to have smaller indices than that of the canonical node.
Revised: Compared with regular BFS, it restricts the frontier nodes to have smaller indices than that of the canonical node.

Original: The time complexity of canonical partition equals to the BFS on each neighborhood
Revised: The time complexity of canonical partition equals to the BFS on each neighborhood

Original: G n =
Revised: G n =

Original: ( V n , E n ) , which is (cid:80) O
Revised: ( V n , E n ) , which is (cid:80) O

Original: ( V n + E n )
Revised: ( V n + E n )

Original: =
Revised: =

Original: O ( V t × ( ¯ V n + ¯ E n )) .
Revised: O ( V t × ( ¯ V n + ¯ E n )) .

Original: A. C OMPLEXITY B ENEFIT OF C ANONICAL P ARTITION
Revised: A. C OMPLEXITY B ENEFIT OF C ANONICAL P ARTITION

Original: We discuss the computational benefit of the canonical partition method in this section.
Revised: We discuss the computational benefit of the canonical partition method in this section.

Original: Search space reduction .
Revised: Search space reduction .

Original: Canonical partition uses the divide-and-conquer scheme to bring about drastic search space reduction.
Revised: Canonical partition uses the divide-and-conquer scheme to bring about drastic search space reduction.

Original: We denote the complexity of searching and counting all subgraphs on size V t target graph as S ( V t ) .
Revised: We denote the complexity of searching and counting all subgraphs on size V t target graph as S ( V t ) .

Original: Canonical partition divides the original problem into subproblems with the total search space of (cid:80) i ∈ V t S ( V n i ) , where V n i stands for the size of canonical neighborhoods.
Revised: Canonical partition divides the original problem into subproblems with the total search space of (cid:80) i ∈ V t S ( V n i ) , where V n i stands for the size of canonical neighborhoods.

Original: Thanks to the sparse nature of real-world graphs, V n i s are generally small, even for huge target graphs.
Revised: Thanks to the sparse nature of real-world graphs, V n i s are generally small, even for huge target graphs.

Original: So with canonical partition, the search space is drastically reduced.
Revised: So with canonical partition, the search space is drastically reduced.

Original: We conduct experiments on real-world graphs to show how canonical partition fundamentally reduces the search space.
Revised: We conduct experiments on real-world graphs to show how canonical partition fundamentally reduces the search space.

Original: Figure 6 shows the computational complexity with different assumptions on the form of S. VF2 Cordella et al.
Revised: Figure 6 shows the computational complexity with different assumptions on the form of S. VF2 Cordella et al.

Original: (2004) claims that the asymptotic complexity for the problem ranges from O ( V 2 ) to O ( V !
Revised: (2004) claims that the asymptotic complexity for the problem ranges from O ( V 2 ) to O ( V !

Original: × V ) in best and worst cases.
Revised: × V ) in best and worst cases.

Original: Under such assumptions of S, the average worst-case complexity is reduced by a factor of 1 / 10 70 with canonical partition, while the average best-case complexity stays in the same magnitude.
Revised: Under such assumptions of S, the average worst-case complexity is reduced by a factor of 1 / 10 70 with canonical partition, while the average best-case complexity stays in the same magnitude.

Original: Empirically, we observe exponential runtime growth of the subgraph counting problem.
Revised: Empirically, we observe exponential runtime growth of the subgraph counting problem.

Original: Thus, under the assumption that S ( V ) = 2 V , the average complexity is also reduced drastically by a factor of 1 / 10 11 with canonical partition.
Revised: Thus, under the assumption that S ( V ) = 2 V , the average complexity is also reduced drastically by a factor of 1 / 10 11 with canonical partition.

Original: Redundant match elimination .
Revised: Redundant match elimination .

Original: Canonical partition, along with the canonical count definition, eliminates the redundant automorphic match of the query graph.
Revised: Canonical partition, along with the canonical count definition, eliminates the redundant automorphic match of the query graph.

Original: Previous works Mawhirter &
Revised: Previous works Mawhirter &

Original: 1E+ 1E+ 1E+ 1E+ 1E+ 1E+ 1E+ 1E+ 1E+ c o m p l e x i t y ( b i g
Revised: 1E+ 1E+ 1E+ 1E+ 1E+ 1E+ 1E+ 1E+ 1E+ c o m p l e x i t y ( b i g

Original: O )
Revised: O )

Original: MUTAG
Revised: MUTAG

Original: COX
Revised: COX

Original: ENZYMES w/o P w P w P
Revised: ENZYMES w/o P w P w P

Original: VF2 complexity range 2 V complexityw/o P
Revised: VF2 complexity range 2 V complexityw/o P

Original: [Figure]
Revised: [Figure]

Original: O (
Revised: O (

Original: ) complexity estimates the empirically observed average
Revised: ) complexity estimates the empirically observed average

Original: Wu (2019); Shi et al.
Revised: Wu (2019); Shi et al.

Original: (2020) have shown that the automorphism of the query graph can cause a large amount of redundant count.
Revised: (2020) have shown that the automorphism of the query graph can cause a large amount of redundant count.

Original: For example, the triangle query graph G q has three symmetric nodes.
Revised: For example, the triangle query graph G q has three symmetric nodes.

Original: We denote the triangle pattern as G p ⊆
Revised: We denote the triangle pattern as G p ⊆

Original: G t and the bijection R 3 (cid:55)→ R 3 as f : ( v p 0 , v p 1 , v p 2 ) (cid:55)→ ( v q 0 , v q 1 , v q 2 ) .
Revised: G t and the bijection R 3 (cid:55)→ R 3 as f : ( v p 0 , v p 1 , v p 2 ) (cid:55)→ ( v q 0 , v q 1 , v q 2 ) .

Original: For the same pattern, there exist six bijections { f : ( v p 0 , v p 1 , v p 2 ) (cid:55)→ ( v q i , v q j , v q k ) | ( i, j, k ) ∈ Perm (1 , 2 , 3) } where Perm (
Revised: For the same pattern, there exist six bijections { f : ( v p 0 , v p 1 , v p 2 ) (cid:55)→ ( v q i , v q j , v q k ) | ( i, j, k ) ∈ Perm (1 , 2 , 3) } where Perm (

Original: Canonical partition eliminates such redundant bijections by adding asymmetry, the canonical node.
Revised: Canonical partition eliminates such redundant bijections by adding asymmetry, the canonical node.

Original: As discussed in Equation 1, by attributing the count to only one canonical node, the bijection f c can be rewritten as a R 3 (cid:55)→ R function, f c : ( v p 0 , v p 1 , v p 2 ) (cid:55)→ max I ( v q 0 , v q 1 , v q 2 ) .
Revised: As discussed in Equation 1, by attributing the count to only one canonical node, the bijection f c can be rewritten as a R 3 (cid:55)→ R function, f c : ( v p 0 , v p 1 , v p 2 ) (cid:55)→ max I ( v q 0 , v q 1 , v q 2 ) .

Original: It means that each query corresponds to only one bijection instead of six, thus preventing double counting and reducing the computational complexity.
Revised: It means that each query corresponds to only one bijection instead of six, thus preventing double counting and reducing the computational complexity.

Original: Reduction in the dynamic range of labels .
Revised: Reduction in the dynamic range of labels .

Original: Canonical partition also reduces the dynamic range of the subgraph count labels, which makes the regression task easier for the neural network as discussed in Section 1.
Revised: Canonical partition also reduces the dynamic range of the subgraph count labels, which makes the regression task easier for the neural network as discussed in Section 1.

Original: The detailed statistics of the dynamic range are shown in Appendix D.2.
Revised: The detailed statistics of the dynamic range are shown in Appendix D.2.

Original: The canonical partition reduces the dynamic range of labels to 1 / 3 on average in Figure 9.
Revised: The canonical partition reduces the dynamic range of labels to 1 / 3 on average in Figure 9.

Original: B E XPRESSIVE P OWER OF SHMP
Revised: B E XPRESSIVE P OWER OF SHMP

Original: B. T HEORETICAL C OMPARISON WITH R EGULAR M ESSAGE P ASSING
Revised: B. T HEORETICAL C OMPARISON WITH R EGULAR M ESSAGE P ASSING

Original: Previous work Xu et al.
Revised: Previous work Xu et al.

Original: (2018) has shown that the expressive power of existing message passing
Revised: (2018) has shown that the expressive power of existing message passing

Original: GNNs is upper-bounded by the 1-WL test, and such bound can be achieved with the Graph Isomorphism Network (GIN).
Revised: GNNs is upper-bounded by the 1-WL test, and such bound can be achieved with the Graph Isomorphism Network (GIN).

Original: We prove the expressive power of SHMP with the following Lemma.
Revised: We prove the expressive power of SHMP with the following Lemma.

Original: Lemma B.1.
Revised: Lemma B.1.

Original: The SHMP version of GIN has stronger expressive power than the 1-WL test.
Revised: The SHMP version of GIN has stronger expressive power than the 1-WL test.

Original: By setting ∀ ϕ
Revised: By setting ∀ ϕ

Original: kh
Revised: kh

Original: =
Revised: =

Original: ϕ k and A GG ′
Revised: ϕ k and A GG ′

Original: =
Revised: =

Original: A GG , SHMP from Equation 6 becomes an instance of GIN, which proves that SHMP-GIN is at least as expressive as GIN or the 1-WL test.
Revised: A GG , SHMP from Equation 6 becomes an instance of GIN, which proves that SHMP-GIN is at least as expressive as GIN or the 1-WL test.

Original: The examples in Figure 7 and Table 7 further prove that one layer of triangle-based SHMP-GIN can distinguish certain graphs that the 1-WL test cannot.
Revised: The examples in Figure 7 and Table 7 further prove that one layer of triangle-based SHMP-GIN can distinguish certain graphs that the 1-WL test cannot.

Original: Thus, SHMP-GIN has stronger expressive power than the 1-WL test, exceeding the upper bound of regular message passing neural networks.
Revised: Thus, SHMP-GIN has stronger expressive power than the 1-WL test, exceeding the upper bound of regular message passing neural networks.

Original: B. E XPERIMENTS ON R EGULAR G RAPHS
Revised: B. E XPERIMENTS ON R EGULAR G RAPHS

Original: To further illustrate the expressive power of SHMP, we show the number of graph pairs that are
Revised: To further illustrate the expressive power of SHMP, we show the number of graph pairs that are

Original: WL indistinguishable but SHMP distinguishable in Table 7.
Revised: WL indistinguishable but SHMP distinguishable in Table 7.

Original: We collect all the connected, d-regular graphs of sizes six to twelve from the House of Graphs Brinkmann et al.
Revised: We collect all the connected, d-regular graphs of sizes six to twelve from the House of Graphs Brinkmann et al.

Original: Among thesegraphs, 654 pairs of graphs are indistinguishable by the 1-WL test, even with infinite iterations.
Revised: Among thesegraphs, 654 pairs of graphs are indistinguishable by the 1-WL test, even with infinite iterations.

Original: In comparison, only 208 pairs are indistinguishable by the triangle-based SHMP with a single layer.
Revised: In comparison, only 208 pairs are indistinguishable by the triangle-based SHMP with a single layer.

Original: So 68% of typical fail cases of the 1-WL test are easily solved with SHMP.
Revised: So 68% of typical fail cases of the 1-WL test are easily solved with SHMP.

Original: Some examples are shown in Figure 7.
Revised: Some examples are shown in Figure 7.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: Number
Revised: Number

Original: [Table]
Revised: [Table]

Original: WL
Revised: WL

Original: [Table]
Revised: [Table]

Original: SHMP
Revised: SHMP

Original: [Table]
Revised: [Table]

Original: B. D ISCUSSION ON S UBSTRUCTURE E NHANCED GNN S
Revised: B. D ISCUSSION ON S UBSTRUCTURE E NHANCED GNN S

Original: Previous substructure enhanced GNNs Morris et al.
Revised: Previous substructure enhanced GNNs Morris et al.

Original: ; Nikolentzos et al.
Revised: ; Nikolentzos et al.

Original: (2020) focus on the idea of high-order abstractions of the graph.
Revised: (2020) focus on the idea of high-order abstractions of the graph.

Original: However, the direct instantiation of all high-order substructures poses significant runtime overhead, which is unfriendly for the large-scale subgraph counting problem.
Revised: However, the direct instantiation of all high-order substructures poses significant runtime overhead, which is unfriendly for the large-scale subgraph counting problem.

Original: For example, Morris et al.
Revised: For example, Morris et al.

Original: (2019) has to add k-combinatorially many nodes to represent the corresponding k-order substructure.
Revised: (2019) has to add k-combinatorially many nodes to represent the corresponding k-order substructure.

Original: This results in massive memory overhead and heavy message passing computation.
Revised: This results in massive memory overhead and heavy message passing computation.

Original: Though both of them use the three-node substructure information, experiments show that the five-layer DeSCo is 3.51 × faster than the five-layer 1-2-3-GNN Morris et al.
Revised: Though both of them use the three-node substructure information, experiments show that the five-layer DeSCo is 3.51 × faster than the five-layer 1-2-3-GNN Morris et al.

Original: (2019) when embedding the same COX2 dataset.
Revised: (2019) when embedding the same COX2 dataset.

Original: In contrast, DeSCo’s subgraph-based heterogeneous message passing (SHMP) focuses on the idea of distinguishing different local graph structures.
Revised: In contrast, DeSCo’s subgraph-based heterogeneous message passing (SHMP) focuses on the idea of distinguishing different local graph structures.

Original: By categorizing the messages on the original graph, DeSCo efficiently uses the same amount of message passing computation as traditional MPGNNs, while providing better expressive power.
Revised: By categorizing the messages on the original graph, DeSCo efficiently uses the same amount of message passing computation as traditional MPGNNs, while providing better expressive power.

Original: C H OMOPHILY AND A NTISYMMETRY A NALYSIS
Revised: C H OMOPHILY AND A NTISYMMETRY A NALYSIS

Original: Example and observation .
Revised: Example and observation .

Original: The homophily and the antisymmetry are two important inductive biases for the canonical count.
Revised: The homophily and the antisymmetry are two important inductive biases for the canonical count.

Original: The target graph in Figure 2 serves as a vivid example.
Revised: The target graph in Figure 2 serves as a vivid example.

Original: The numbers in the green square indicate the canonical count value of each node.
Revised: The numbers in the green square indicate the canonical count value of each node.

Original: On the one hand, note that the adjacent nodes 3, 5, and 6 have the same count value of 2.
Revised: On the one hand, note that the adjacent nodes 3, 5, and 6 have the same count value of 2.

Original: Adjacent nodes 0, 1, and 2 also have the same value, 0.
Revised: Adjacent nodes 0, 1, and 2 also have the same value, 0.

Original: This homophily inductive bias suggests that taking an average of the adjacent node values can reduce the prediction error of individual nodes.
Revised: This homophily inductive bias suggests that taking an average of the adjacent node values can reduce the prediction error of individual nodes.

Original: On the other hand, though node 1 and nodehave similar neighborhood graph structures, node 5 with a larger node index has a higher canonical
Revised: On the other hand, though node 1 and nodehave similar neighborhood graph structures, node 5 with a larger node index has a higher canonical

Original: 1.0 homophily ratio 0.
Revised: 1.0 homophily ratio 0.

Original: i n d e x - c o un t c o rr e l a t i o n count value.
Revised: i n d e x - c o un t c o rr e l a t i o n count value.

Original: It corresponds to the definition of canonical count as discussed in Section 4.1.
Revised: It corresponds to the definition of canonical count as discussed in Section 4.1.

Original: This antisymmetry inductive bias suggests that the embedding phase for two structurally similar nodes with different node indices should also be different.
Revised: This antisymmetry inductive bias suggests that the embedding phase for two structurally similar nodes with different node indices should also be different.

Original: Quantization .
Revised: Quantization .

Original: We quantify the homophily and the antisymmetry inductive biases.
Revised: We quantify the homophily and the antisymmetry inductive biases.

Original: For homophily, we treat the canonical count as the node label and use the homophily ratio from Zhu et al.
Revised: For homophily, we treat the canonical count as the node label and use the homophily ratio from Zhu et al.

Original: (2021) to quantify how similar the count is between adjacent nodes.
Revised: (2021) to quantify how similar the count is between adjacent nodes.

Original: The homophily ratio ranges from 0 to 1.
Revised: The homophily ratio ranges from 0 to 1.

Original: The higher the homophily ratio is, the more similar the labels will be between adjacent nodes.
Revised: The higher the homophily ratio is, the more similar the labels will be between adjacent nodes.

Original: For antisymmetry, we use the Pearson correlation coefficient r Benesty et al.
Revised: For antisymmetry, we use the Pearson correlation coefficient r Benesty et al.

Original: (2009) between the node index and its canonical count as the quantification metric.
Revised: (2009) between the node index and its canonical count as the quantification metric.

Original: We quantify the different homophily and antisymmetry for different queries on the ENZYMES target graph.
Revised: We quantify the different homophily and antisymmetry for different queries on the ENZYMES target graph.

Original: Key insight .
Revised: Key insight .

Original: As shown in Figure 8, the key insight is that homophily and the antisymmetry generally have negative correlation r = − 0 .
Revised: As shown in Figure 8, the key insight is that homophily and the antisymmetry generally have negative correlation r = − 0 .

Original: So the emphasis on one should suppress the other.
Revised: So the emphasis on one should suppress the other.

Original: Based on such observation, we design the gossip correction model with learnable gates to imitate the mutually exclusive relation between the two inductive biases for different queries.
Revised: Based on such observation, we design the gossip correction model with learnable gates to imitate the mutually exclusive relation between the two inductive biases for different queries.

Original: As shown in Figure 4(b), the proposed learnable gate balances the influence of homophily and antisymmetry by controlling the direction of message passing.
Revised: As shown in Figure 4(b), the proposed learnable gate balances the influence of homophily and antisymmetry by controlling the direction of message passing.

Original: The gate value is trained to adapt for different queries to imitate different extents of homophily and antisymmetry .
Revised: The gate value is trained to adapt for different queries to imitate different extents of homophily and antisymmetry .

Original: D E XPERIMENTAL S ETUP D. S YNTHETIC D ATASET
Revised: D E XPERIMENTAL S ETUP D. S YNTHETIC D ATASET

Original: The DeSCo can be pre-trained once and be directly applied to any targets.
Revised: The DeSCo can be pre-trained once and be directly applied to any targets.

Original: So we generate a synthetic dataset with 6400 graphs, along with the ground truth count of all twenty-nine standard queries (queries of sizes 3, 4, 5).
Revised: So we generate a synthetic dataset with 6400 graphs, along with the ground truth count of all twenty-nine standard queries (queries of sizes 3, 4, 5).

Original: The synthetic dataset generates each graph with a generator from the generator pool.
Revised: The synthetic dataset generates each graph with a generator from the generator pool.

Original: The pool consists of four different graph generators: the Erd˝os-R´enyi (ER) model Erd˝os et al.
Revised: The pool consists of four different graph generators: the Erd˝os-R´enyi (ER) model Erd˝os et al.

Original: (1960), the WattsStrogatz (WS) model Watts & Strogatz (1998), the Extended Barab´asi-Albert (Ext-BA) model Albert & Barab ´ asi (2000), and the Power Law (PL) cluster model Holme & Kim (2002).
Revised: (1960), the WattsStrogatz (WS) model Watts & Strogatz (1998), the Extended Barab´asi-Albert (Ext-BA) model Albert & Barab ´ asi (2000), and the Power Law (PL) cluster model Holme & Kim (2002).

Original: The expected graph size n of each generator is uniformly chosen from 5 to 50.
Revised: The expected graph size n of each generator is uniformly chosen from 5 to 50.

Original: An additional 2% PL model is used to generate very large graphs with 50 to 250 nodes.
Revised: An additional 2% PL model is used to generate very large graphs with 50 to 250 nodes.

Original: To generate an n-node graph, for the ER model, the edges are added with Beta probability distribution p ∼ 0 .
Revised: To generate an n-node graph, for the ER model, the edges are added with Beta probability distribution p ∼ 0 .

Original: 8 Beta (1 . 3 , 1 . 3 n/ log 2 n − 1 . 3) .
Revised: 8 Beta (1 . 3 , 1 . 3 n/ log 2 n − 1 . 3) .

Original: For the WS model, each node connects to
Revised: For the WS model, each node connects to

Original: K ∼ n Beta (1 . 3 , 1 . 3 n/ log 2 n − 1 . 3) neighborhoods, with a rewiring probability p ∼ Beta (2 , 2) .
Revised: K ∼ n Beta (1 . 3 , 1 . 3 n/ log 2 n − 1 . 3) neighborhoods, with a rewiring probability p ∼ Beta (2 , 2) .

Original: For the Ext-BA model, the edges are attached to each node with uniform probability distribution m ∼ U (1 , 2 log 2 n ) .
Revised: For the Ext-BA model, the edges are attached to each node with uniform probability distribution m ∼ U (1 , 2 log 2 n ) .

Original: The probability of adding edges and rewiring both conform to the clapped exponential distribution p ∼ max(0 .
Revised: The probability of adding edges and rewiring both conform to the clapped exponential distribution p ∼ max(0 .

Original: 2 , E (20)) .
Revised: 2 , E (20)) .

Original: For the PL model, the edges are attached to each node with uniform distribution m ∼ U (1 , 2 log 2 n ) .
Revised: For the PL model, the edges are attached to each node with uniform distribution m ∼ U (1 , 2 log 2 n ) .

Original: The triangle is added with p ∼ U (0 , 0 . 5) .
Revised: The triangle is added with p ∼ U (0 , 0 . 5) .

Original: [Figure]
Revised: [Figure]

Original: Figure 9 shows all twenty-nine standard queries discussed in Section 5.1.
Revised: Figure 9 shows all twenty-nine standard queries discussed in Section 5.1.

Original: They form the complete set of all non-isomorphic, connected, undirected graphs with three to five nodes.
Revised: They form the complete set of all non-isomorphic, connected, undirected graphs with three to five nodes.

Original: Figure 10 shows all sixteen large query graphs discussed in Section 5.3.
Revised: Figure 10 shows all sixteen large query graphs discussed in Section 5.3.

Original: They are frequent subgraphs with six to thirteen nodes in the ENZYMES dataset.
Revised: They are frequent subgraphs with six to thirteen nodes in the ENZYMES dataset.

Original: The figures also show the dynamic range (DR) of the ground truth count of these queries on the target graphs from the ENZYMES dataset.
Revised: The figures also show the dynamic range (DR) of the ground truth count of these queries on the target graphs from the ENZYMES dataset.

Original: The canonical counts’ dynamic range on the corresponding neighborhoods is also shown.
Revised: The canonical counts’ dynamic range on the corresponding neighborhoods is also shown.

Original: Note how canonical partition reduces the dynamic range of the regression task for GNNs.
Revised: Note how canonical partition reduces the dynamic range of the regression task for GNNs.

Original: G !
Revised: G !

Original: DR G "
Revised: DR G "

Original: DR G #
Revised: DR G #

Original: G !
Revised: G !

Original: DR G "
Revised: DR G "

Original: DR G #
Revised: DR G #

Original: G !
Revised: G !

Original: DR G "
Revised: DR G "

Original: DR G #
Revised: DR G #

Original: G !
Revised: G !

Original: DR G "
Revised: DR G "

Original: DR G #
Revised: DR G #

Original: G !
Revised: G !

Original: DR G "
Revised: DR G "

Original: DR G #
Revised: DR G #

Original: G !
Revised: G !

Original: DR G "
Revised: DR G "

Original: DR G #
Revised: DR G #

Original: D. H YPER - PARAMETER C ONFIGURATIONS
Revised: D. H YPER - PARAMETER C ONFIGURATIONS

Original: DeSCo configurations .
Revised: DeSCo configurations .

Original: For DeSCo’s canonical partition stage, we set d = 4 for all the tasks according to Theorem 1.
Revised: For DeSCo’s canonical partition stage, we set d = 4 for all the tasks according to Theorem 1.

Original: For DeSCo’s neighborhood counting stage, it contains two GNNs to encode target and query graphs into embedding vectors, and a regression model to predict canonical count based on the vectors.
Revised: For DeSCo’s neighborhood counting stage, it contains two GNNs to encode target and query graphs into embedding vectors, and a regression model to predict canonical count based on the vectors.

Original: For the GNN encoders, we use the triangle-based message passing variant of GraphSAGE as shown in Table 8.
Revised: For the GNN encoders, we use the triangle-based message passing variant of GraphSAGE as shown in Table 8.

Original: The SHMP GNN has 8 layers with a feature size of 64.
Revised: The SHMP GNN has 8 layers with a feature size of 64.

Original: The canonical node of the neighborhood is marked with a special node type.
Revised: The canonical node of the neighborhood is marked with a special node type.

Original: The adjacent matrix A is used to find the triangle and define the heterogeneous edge type with Equation 18.
Revised: The adjacent matrix A is used to find the triangle and define the heterogeneous edge type with Equation 18.

Original: [Equation]
Revised: [Equation]

Original: For the Multilayer perceptron (MLP) of neighborhood counting, we use two fully-connected linear layers with 256 hidden feature size and LeakyReLu activation.
Revised: For the Multilayer perceptron (MLP) of neighborhood counting, we use two fully-connected linear layers with 256 hidden feature size and LeakyReLu activation.

Original: For the gossip correction stage, we use a two-layer GNN with 64 hidden feature size and a learnable gate as described in Equation 7.
Revised: For the gossip correction stage, we use a two-layer GNN with 64 hidden feature size and a learnable gate as described in Equation 7.

Original: The learnable gate is a two-layer, 64-hidden-size MLP that takes the query embedding vector from the neighborhood counting stage and outputs the gate values for each GNN layer.
Revised: The learnable gate is a two-layer, 64-hidden-size MLP that takes the query embedding vector from the neighborhood counting stage and outputs the gate values for each GNN layer.

Original: The neighborhood counting prediction is expanded to 64 dimensions with a Linear layer and concatenated with the query embedding as the input for the two-layer GNN.
Revised: The neighborhood counting prediction is expanded to 64 dimensions with a Linear layer and concatenated with the query embedding as the input for the two-layer GNN.

Original: Neural baseline configurations .
Revised: Neural baseline configurations .

Original: We follow the configurations of the official implementations of neural baselines and adapt them to our settings.
Revised: We follow the configurations of the official implementations of neural baselines and adapt them to our settings.

Original: They both contain two GNN encoders and a regression model like DeSCo’s neighborhood counting model.
Revised: They both contain two GNN encoders and a regression model like DeSCo’s neighborhood counting model.

Original: For LRP, we follow the official configurations for the ZINC dataset to use a deep LRP-7-1 graph embedding layer with 8 layers and hidden dimension 8.
Revised: For LRP, we follow the official configurations for the ZINC dataset to use a deep LRP-7-1 graph embedding layer with 8 layers and hidden dimension 8.

Original: The regression model is the same as DeSCo.
Revised: The regression model is the same as DeSCo.

Original: For DIAMNet, we follow the official configurations for the MUTAG dataset to use GIN with feature size 128 as GNN encoders.
Revised: For DIAMNet, we follow the official configurations for the MUTAG dataset to use GIN with feature size 128 as GNN encoders.

Original: The number of GNN layers is expanded from 3 to 5.
Revised: The number of GNN layers is expanded from 3 to 5.

Original: The regression model is DIAMNet with 3 recurrent steps, 4 external memories, and 4 attention heads.
Revised: The regression model is DIAMNet with 3 recurrent steps, 4 external memories, and 4 attention heads.

Original: Training details .
Revised: Training details .

Original: We use C c ← log 2 ( C c +1) normalization for the ground truth canonical count C c to ease the high dynamic range problem.
Revised: We use C c ← log 2 ( C c +1) normalization for the ground truth canonical count C c to ease the high dynamic range problem.

Original: When evaluating the MSE of predictions, ˆ C c ← 2 ˆ C c − is used to undo the normalization.
Revised: When evaluating the MSE of predictions, ˆ C c ← 2 ˆ C c − is used to undo the normalization.

Original: We use the SmoothL1Loss with β = 1 . 0 from PyTorch Paszke et al.
Revised: We use the SmoothL1Loss with β = 1 . 0 from PyTorch Paszke et al.

Original: as the loss function to perform the regression task of neighborhood counting and gossip correction.
Revised: as the loss function to perform the regression task of neighborhood counting and gossip correction.

Original: [Equation]
Revised: [Equation]

Original: We use the Adam optimizer for neighborhood counting and gossip correction and set the learning rate to 0 .
Revised: We use the Adam optimizer for neighborhood counting and gossip correction and set the learning rate to 0 .

Original: We align the computational resources when training different neural methods.
Revised: We align the computational resources when training different neural methods.

Original: DeSCo and DIAMNet have similar training efficiency, so DeSCo’s neighborhood counting model and DIAMNet are both trained for 300 epochs.
Revised: DeSCo and DIAMNet have similar training efficiency, so DeSCo’s neighborhood counting model and DIAMNet are both trained for 300 epochs.

Original: After training the neighborhood counting model, DeSCo’s gossip correction model is trained for 50 epochs with little resource consumption.
Revised: After training the neighborhood counting model, DeSCo’s gossip correction model is trained for 50 epochs with little resource consumption.

Original: In contrast, LRP is much slower.
Revised: In contrast, LRP is much slower.

Original: Even given twice training time, it can only be trained for 50 epochs.
Revised: Even given twice training time, it can only be trained for 50 epochs.

Original: Approximate heuristic configurations .
Revised: Approximate heuristic configurations .

Original: For the MOTIVO baseline, we follow the official setting and use 10 7 samples for each dataset.
Revised: For the MOTIVO baseline, we follow the official setting and use 10 7 samples for each dataset.

Original: If the dataset has many graphs, the samples are evenly distributed on each target graph.
Revised: If the dataset has many graphs, the samples are evenly distributed on each target graph.

Original: E R UNTIME C OMPARISION
Revised: E R UNTIME C OMPARISION

Original: We use Intel Xeon Gold 6226R CPU with 2.90GHz frequency and NVIDIA GeForce RTX
Revised: We use Intel Xeon Gold 6226R CPU with 2.90GHz frequency and NVIDIA GeForce RTX

Original: GPU for runtime tests.
Revised: GPU for runtime tests.

Original: Method configurations .
Revised: Method configurations .

Original: For the exact method VF2 Cordella et al.
Revised: For the exact method VF2 Cordella et al.

Original: (2004), we use the Python implementation from the graph processing framework Hagberg et al.
Revised: (2004), we use the Python implementation from the graph processing framework Hagberg et al.

Original: and use Python’s concurrent standard library to enable multiprocessing on four CPU cores.
Revised: and use Python’s concurrent standard library to enable multiprocessing on four CPU cores.

Original: For the exact method IMSM Sun & Luo (2020), we use the official c++ implementation with four CPU cores.
Revised: For the exact method IMSM Sun & Luo (2020), we use the official c++ implementation with four CPU cores.

Original: We use the IMSMrecommended method configurations: GQL He & Singh (2008) as the filtering method, RI Bonnici et al.
Revised: We use the IMSMrecommended method configurations: GQL He & Singh (2008) as the filtering method, RI Bonnici et al.

Original: as the ordering method, and LFTJ Bhattarai et al.
Revised: as the ordering method, and LFTJ Bhattarai et al.

Original: ; Han et al.
Revised: ; Han et al.

Original: as the enumeration method.
Revised: as the enumeration method.

Original: The failing set pruning optimization is also enabled.
Revised: The failing set pruning optimization is also enabled.

Original: For the heuristic approximate method MOTIVO Bressan et al.
Revised: For the heuristic approximate method MOTIVO Bressan et al.

Original: (2019), we use the official c++ implementation with four
Revised: (2019), we use the official c++ implementation with four

Original: CPU cores.
Revised: CPU cores.

Original: For the neural method DeSCo, we use the Python implementation with one CPU core and one GPU core.
Revised: For the neural method DeSCo, we use the Python implementation with one CPU core and one GPU core.

Original: Experiment setup .
Revised: Experiment setup .

Original: All the methods are set to count the induced subgraphs in the ENZYMES dataset.
Revised: All the methods are set to count the induced subgraphs in the ENZYMES dataset.

Original: Note that IMSM can only perform non-induced subgraph counting.
Revised: Note that IMSM can only perform non-induced subgraph counting.

Original: So VF2, MOTIVO, and DeSCo are set to perform induced subgraph counting tasks, while IMSM performs non-induced tasks for runtime comparison.
Revised: So VF2, MOTIVO, and DeSCo are set to perform induced subgraph counting tasks, while IMSM performs non-induced tasks for runtime comparison.

Original: For query sizes no larger than five nodes, the standard queries from
Revised: For query sizes no larger than five nodes, the standard queries from

Original: Section 5.1 are used.
Revised: Section 5.1 are used.

Original: For query sizes larger than five, the same thirty queries of each size are selected for VF2 and DeSCo.
Revised: For query sizes larger than five, the same thirty queries of each size are selected for VF2 and DeSCo.

Original: We cannot assign specific queries for MOTIVO, so it is set to output the count of any thirty queries of each size.
Revised: We cannot assign specific queries for MOTIVO, so it is set to output the count of any thirty queries of each size.

Original: Runtime results .
Revised: Runtime results .

Original: Figure 11(a) shows the runtime of each method with four minutes’ time-bound.
Revised: Figure 11(a) shows the runtime of each method with four minutes’ time-bound.

Original: The data loading and graph format conversion time is ignored for all methods.
Revised: The data loading and graph format conversion time is ignored for all methods.

Original: For the exact methods,
Revised: For the exact methods,

Original: VF2 and IMSM, the runtime grows exponentially because of the exponentially growing possible matches of each query size.
Revised: VF2 and IMSM, the runtime grows exponentially because of the exponentially growing possible matches of each query size.

Original: For the approximate heuristic method MOTIVO, the exponential growth is mostly because of the build-up phase before sampling.
Revised: For the approximate heuristic method MOTIVO, the exponential growth is mostly because of the build-up phase before sampling.

Original: While greatly reducing the sampling space,
Revised: While greatly reducing the sampling space,

Original: MOTIVO’s build-up phase needs to color the nodes of the target graph and count colorful trees for each node, which has exponential time complexity with regard to the query size.
Revised: MOTIVO’s build-up phase needs to color the nodes of the target graph and count colorful trees for each node, which has exponential time complexity with regard to the query size.

Original: For DeSCo, the queries and targets are independently embedded, and queries are relatively small compared with targets.
Revised: For DeSCo, the queries and targets are independently embedded, and queries are relatively small compared with targets.

Original: Thus, DeSCo can easily scale for large queries.
Revised: Thus, DeSCo can easily scale for large queries.

Original: For example, scaling the query size fromto 13 only poses 57% additional overhead on the total runtime.
Revised: For example, scaling the query size fromto 13 only poses 57% additional overhead on the total runtime.

Original: We further extend the time budget for
Revised: We further extend the time budget for

Original: MOTIVO to 60 minutes and find that DeSCo achieves 15 × , 53 × , and 120 × speedup over MOTIVO for size 13 to 15 queries, respectively.
Revised: MOTIVO to 60 minutes and find that DeSCo achieves 15 × , 53 × , and 120 × speedup over MOTIVO for size 13 to 15 queries, respectively.

Original: As Figure 11(b) shows, currently DeSCo’s triangle finding in neighborhood counting takes the majority of the runtime, which can be easily substituted with other efficient implementations, e.g., Donato et al.
Revised: As Figure 11(b) shows, currently DeSCo’s triangle finding in neighborhood counting takes the majority of the runtime, which can be easily substituted with other efficient implementations, e.g., Donato et al.

Original: (2018), to further speed up DeSCo.
Revised: (2018), to further speed up DeSCo.

Original: Asymptotic complexity .
Revised: Asymptotic complexity .

Original: For the proposed DeSCo’s three-step pipeline, assuming the average canonical neighborhood G n of the target graph G t has V n nodes and E n edges.
Revised: For the proposed DeSCo’s three-step pipeline, assuming the average canonical neighborhood G n of the target graph G t has V n nodes and E n edges.

Original: The time complexity for canonical partition is the index-restricted breadth-first search starting from all the target
Revised: The time complexity for canonical partition is the index-restricted breadth-first search starting from all the target

Original: 9 10 11 12r un t i m e ( s e c ond ) query size
Revised: 9 10 11 12r un t i m e ( s e c ond ) query size

Original: VF
Revised: VF

Original: IMSM
Revised: IMSM

Original: MOTIVO
Revised: MOTIVO

Original: DeSCo (a) runtime comparison 22% 11% 38% 29% 67% canonicalpartition gossipcorrection findtriangles
Revised: DeSCo (a) runtime comparison 22% 11% 38% 29% 67% canonicalpartition gossipcorrection findtriangles

Original: SHMP neighborhoodcounting
Revised: SHMP neighborhoodcounting

Original: [Figure]
Revised: [Figure]

Original: So the overall time complexity of DeSCo is O ( E 3 / 2 t + V t × ( ¯ V n + ¯ E n ))
Revised: So the overall time complexity of DeSCo is O ( E 3 / 2 t + V t × ( ¯ V n + ¯ E n ))

Original: + O ( E
Revised: + O ( E

Original: 3 / 2 q + V q ) .
Revised: 3 / 2 q + V q ) .

Original: In realworld graphs, the common contraction of neighborhoods Weber (2019) makes ¯ V n and ¯ E n relatively small.
Revised: In realworld graphs, the common contraction of neighborhoods Weber (2019) makes ¯ V n and ¯ E n relatively small.

Original: So the major asymptotic complexity comes from the triangle counting on the target graph which only has polynomial time complexity.
Revised: So the major asymptotic complexity comes from the triangle counting on the target graph which only has polynomial time complexity.

Original: In contrast, for the heuristic approximate method MOTIVO, the build-up phase alone has time complexity O ( a V q × E t ) for some a > 0 .
Revised: In contrast, for the heuristic approximate method MOTIVO, the build-up phase alone has time complexity O ( a V q × E t ) for some a > 0 .

Original: So it suffers from exponential runtime growth.
Revised: So it suffers from exponential runtime growth.

Original: For exact method VF2, the time complexity is O ( V 2 ) to O ( V !
Revised: For exact method VF2, the time complexity is O ( V 2 ) to O ( V !

Original: × V ) where V = max { V t , V q } .
Revised: × V ) where V = max { V t , V q } .

Original: In practice, we generally observe exponential runtime growth.
Revised: In practice, we generally observe exponential runtime growth.

Original: Experiments of Figure 11 confirms the above analysis.
Revised: Experiments of Figure 11 confirms the above analysis.

Original: F C OUNT D ISTRIBUTION P REDICTION
Revised: F C OUNT D ISTRIBUTION P REDICTION

Original: To the best of our knowledge, DeSCo is the first approximate method that predicts the subgraph count distribution over the whole target graph.
Revised: To the best of our knowledge, DeSCo is the first approximate method that predicts the subgraph count distribution over the whole target graph.

Original: We use the canonical count of each node as the ground truth for the distribution prediction accuracy analysis.
Revised: We use the canonical count of each node as the ground truth for the distribution prediction accuracy analysis.

Original: The canonical count represents the number of pattern s in each node’s neighborhood while avoiding missing or double counting as discussed in Section 4.1.
Revised: The canonical count represents the number of pattern s in each node’s neighborhood while avoiding missing or double counting as discussed in Section 4.1.

Original: Following the setup in Section 5.1, we use all the size 3 − 5 standard query graphs to test the distribution performance of DeSCo on different target graphs.
Revised: Following the setup in Section 5.1, we use all the size 3 − 5 standard query graphs to test the distribution performance of DeSCo on different target graphs.

Original: The normalized
Revised: The normalized

Original: MSE is the mean square error of the canonical count prediction of each (query, target graph node) pair divided by the variance of the (query, target graph node) pair’s true canonical count.
Revised: MSE is the mean square error of the canonical count prediction of each (query, target graph node) pair divided by the variance of the (query, target graph node) pair’s true canonical count.

Original: The MAE is the mean absolute error of the canonical count prediction of each (query, target graph node) pair.
Revised: The MAE is the mean absolute error of the canonical count prediction of each (query, target graph node) pair.

Original: [Table]
Revised: [Table]

Original: Experiments show DeSCo achieves a low 0 .
Revised: Experiments show DeSCo achieves a low 0 .

Original: 23 normalized MSE for the count distribution prediction task.
Revised: 23 normalized MSE for the count distribution prediction task.

Original: A visualization of DeSCo’s distribution prediction on the CiteSeer dataset is also shown in
Revised: A visualization of DeSCo’s distribution prediction on the CiteSeer dataset is also shown in

Revised: G A DDITIONAL R ESULTS A NALYSIS FOR L ARGE Q UERIES

Revised: To give an even more in-depth understanding of the performance for large queries, we additionally provide the results with more evaluation metrics.

Original: G Q- ERROR A NALYSIS
Revised: G. Q- ERROR A NALYSIS

Original: Definition .
Revised: Definition .

Original: Given the ground truth subgraph count C of query G q in target G t , as well as the estimated count ˆ C .
Revised: Given the ground truth subgraph count C of query G q in target G t , as well as the estimated count ˆ C .

Original: We use the definition of q-error from previous work Zhao et al.
Revised: We use the definition of q-error from previous work Zhao et al.

Original: [Equation]
Revised: [Equation]

Original: The q-error quantifies the factor that the estimation differs from the true count.
Revised: The q-error quantifies the factor that the estimation differs from the true count.

Original: The more it is close to 1 , the better estimation.
Revised: The more it is close to 1 , the better estimation.

Original: In Zhao et al.
Revised: In Zhao et al.

Original: (2021), there is also an alternative form of q-error used in figures to show the systematic bias of predictions.
Revised: (2021), there is also an alternative form of q-error used in figures to show the systematic bias of predictions.

Original: [Equation]
Revised: [Equation]

Original: We follow the previous settings and use Equation 21 in our visualization.
Revised: We follow the previous settings and use Equation 21 in our visualization.

Original: Experimental results .
Revised: Experimental results .

Original: We reassess the performance of DeSCo on large queries from Figure 5, and show the box plot in Figure 12.
Revised: We reassess the performance of DeSCo on large queries from Figure 5, and show the box plot in Figure 12.

Original: The data that C = 0 is ignored for mathematic correctness.
Revised: The data that C = 0 is ignored for mathematic correctness.

Original: The box of MOTIVO on MUTAG is too close to zero to be shown in the figure.
Revised: The box of MOTIVO on MUTAG is too close to zero to be shown in the figure.

Original: DeSCo’s q-error is the closest to 1 with minimal spread.
Revised: DeSCo’s q-error is the closest to 1 with minimal spread.

Original: It shows how DeSCo excels in systematic error and consistency compared with the baselines.
Revised: It shows how DeSCo excels in systematic error and consistency compared with the baselines.

Original: [Figure]
Revised: [Figure]

Original: Limitations of q-error .
Revised: Limitations of q-error .

Original: Despite the advantage of demonstrating relative error, the q-error metric also has obvious limitations, thus not being chosen as the major evaluation metric.
Revised: Despite the advantage of demonstrating relative error, the q-error metric also has obvious limitations, thus not being chosen as the major evaluation metric.

Original: In Zhao et al.
Revised: In Zhao et al.

Original: , the authors assume C ≥ 1 and ˆ C ≥ 1 .
Revised: , the authors assume C ≥ 1 and ˆ C ≥ 1 .

Original: However, this assumption may not hold, given that the query graph may not (or is predicted to) exist in the target graph, especially for larger queries.
Revised: However, this assumption may not hold, given that the query graph may not (or is predicted to) exist in the target graph, especially for larger queries.

Original: The zero or near-zero denominators greatly influence the average q-error.
Revised: The zero or near-zero denominators greatly influence the average q-error.

Original: It causes the overestimation of the subgraph existence problem instead of the subgraph counting problem.
Revised: It causes the overestimation of the subgraph existence problem instead of the subgraph counting problem.

Revised: G. MSE A NALYSIS

Revised: Definition .

Revised: We follow the same setting in Figure 5 and show the normalized MSE for predicting the subgraph count of large queries.

Revised: Note that in a few cases, the tested large queries of a certain size may not exist in the target graph.

Revised: For example, the two size-thirteen queries in Figure 10 do not exist in the CiteSeer dataset.

Revised: To prevent divide-by-zero in normalization, the MSE is normalized by the variance of ground truth counts of all large queries, instead of being normalized for each query size.

Revised: Experimental results .

Revised: The experimental results are shown in Table 9.

Revised: DeSCo demonstrates the lowest MSE on all tested target graphs.

Revised: [Table]