Modeling Graphs with Vertex Replacement Grammars

TL;DR

This paper introduces a revised vertex replacement grammar, CNRG, which efficiently models large graphs by capturing their hierarchical structure, enabling realistic graph generation that preserves original network properties.

Contribution

It presents a novel variant of VRG called CNRG, capable of extracting hierarchical graph models from large datasets, improving upon previous limitations of graph grammar formalisms.

Findings

CNRGs can be efficiently extracted from hierarchical clusterings.

Graphs generated from CNRGs resemble original networks in properties.

CNRGs provide a succinct yet faithful graph representation.

Abstract

One of the principal goals of graph modeling is to capture the building blocks of network data in order to study various physical and natural phenomena. Recent work at the intersection of formal language theory and graph theory has explored the use of graph grammars for graph modeling. However, existing graph grammar formalisms, like Hyperedge Replacement Grammars, can only operate on small tree-like graphs. The present work relaxes this restriction by revising a different graph grammar formalism called Vertex Replacement Grammars (VRGs). We show that a variant of the VRG called Clustering-based Node Replacement Grammar (CNRG) can be efficiently extracted from many hierarchical clusterings of a graph. We show that CNRGs encode a succinct model of the graph, yet faithfully preserves the structure of the original graph. In experiments on large real-world datasets, we show that graphs generated from the CNRG model exhibit a diverse range of properties that are similar to those found in the original networks.

Tables

Table 1. Table 1 : Datasets

Name		$\left|V\right|$	$\left|E\right|$
EuCore Emails		$986$	$16,687$
PolBlogs		$1,222$	$16,717$
OpenFlights		$2,905$	$15,645$
ArXiv GrQc		$4,158$	$13,428$
Gnutella		$6,299$	$20,776$
WikiVote		$7,066$	$100,736$
PGP		$10,680$	$24,316$

Table 2. Table 2 : Model Size Comparison. Lower is better.

Graph	$DL\left(Model\right)/DL\left(H\right)$
	SUBDUE	SlashBurn	VoG	CNRG
Karate	$3.546$	$1.119$	$1.080$	$0.704$
Dolphins	$4.348$	$1.336$	$1.026$	$0.43$
LesMis	$3.546$	$1.05$	$0.875$	$0.924$
EuCore	–	$5.54$	$0.986$	$0.182$
PolBlogs	–	$0.873$	$0.881$	$0.388$
OpenFlights	–	$0.888$	$0.869$	$0.412$
GrQc	–	$1.154$	$0.851$	$0.133$
PGP	–	$1.196$	$0.911$	$0.232$
Gnutella	–	$1.045$	$0.967$	$0.306$
WikiVote	–	$0.839$	$0.843$	$0.525$

Table 3. Table 3 : Graph generation performance. Graphs generated by CNRG closely match the original graph and are consistently the best or close to the best performing model. Lower is better; best results are indicated by boldface.

	EuCore			PolBlogs			OpenFlights
	GCD	$\lambda$-dist	DeltaCon	GCD	$\lambda$-dist	DeltaCon	GCD	$\lambda$-dist	DeltaCon
ChungLu	0.409	0.803	6661	0.466	1.234	8020	1.1116	0.614	14142
HRG	0.229	8.091	7841	1.196	4.407	8872	1.2442	2.761	15860
DC-SBM	0.180	2.057	5736	0.262	4.186	8023	0.8414	3.534	11450
BTER	-	-	-	0.352	7.505	8444	0.832	4.936	13269
Kronecker	0.3164	11.802	4840	1.302	14.31	6140	1.83	10.459	8589
VRG	0.233	4.969	5793	0.212	4.276	7436	0.2832	3.581	11473
	GrQc			PGP			Gnutella
	GCD	$\lambda$-dist	DeltaCon	GCD	$\lambda$-dist	DeltaCon	GCD	$\lambda$-dist	DeltaCon
ChungLu	2.657	0.389	21607	2	0.64	18503	1.02	0.42	34451
HRG	1.99	4.41	12153	-	-	-	2	5	20755
DC-SBM	2.065	2.202	14456	1.39	2.29	15216	-	-	-
BTER	2.231	0.439	14066	1.61	0.832	15161	1.10	0.474	32692
Kronecker	3.87	5.468	13173	2.882	3.54	12320	3.31	5.96	22145
VRG	1.067	0.723	13528	0.448	1.329	12257	0.41	0.20	30616

Equations

$$\lambda \text{-distance}(\hat{H},H)=\sqrt{\sum _i{\left(\widehat{s_i}-s_i\right)}^2}\text{,}$$

Full text

Index terms—vertex replacement grammar, graph model, graph generators

1 Introduction

We consider the task of identifying the informative and interesting patterns found in graphs. Because of their ability to represent natural phenomena, graphs have been studied extensively in various computing and scientific scenarios. Arguably the most prescient task in the study of graphs is the identification, extraction, and representation of the small substructures that, in aggregate, describe the underlying phenomenon encoded by the graph. These extracted models contain the LEGO-like building blocks of real-world graphs, and their overarching goal is to enable in-depth scientific analysis and make predictions about the data.

Because of the prevalence of relevant data and the importance of this line of inquiry, there exists a large body of prior work in graph mining. Rooted in data mining and knowledge discovery, subgraph mining methods have been developed to identify frequently occurring subgraphs [Grahne and Zhu, 2005, Jiang et al., 2013]. Unfortunately, these early methods have a so-called “combinatorial explosion” problem [Thoma et al., 2010] wherein the search space grows exponentially with the pattern size. This causes computational headaches and can also return a massive result set that hinders real-world applicability. Recent work that heuristically mines graphs for prominent or representative subgraphs have been developed in response, but are still limited by their choice of heuristic [Yan and Han, 2002, Nijssen and Kok, 2005, Lin et al., 2014, Sun et al., 2012]. Alternatively, researchers characterize a network by counting small subgraphs called graphlets and therefore forfeit any chance of finding larger, more interesting structures [Pržulj, 2007, Marcus and Shavitt, 2012, Ahmed et al., 2015].

Graph generators, like frequent subgraph mining, also find distinguishing characteristics of networks, but go one step further by generating new graphs that “look like” the original graph(s). What a graph looks like includes local graph properties like the counts of frequent subgraphs, but can also include global graph properties like the degree distribution, clustering coefficient, diameter, and assortativity metrics among many others. Early graph generators had parameters that could be tuned to generate graphs with specific desirable properties. Additional work in exponential random graphs [Robins et al., 2007], Kronecker graphs [Leskovec et al., 2010, Chakrabarti et al., 2004], Chung-Lu graphs [Chung and Lu, 2002], Stochastic Block Models (SBMs) [Karrer and Newman, 2011], and their many derivatives [Pfeiffer et al., 2012, Mussmann et al., 2014, Baldesi et al., 2018, Mussmann et al., 2015, Kolda et al., 2014] create a model from some example graph in order to generate a new graph that has many of the same properties as the original graph.

These graph models look for small pre-defined patterns or frequently reoccurring patterns, even though interesting and useful information may be hidden in latent and infrequent patterns. Principled strategies for extracting these complex patterns are needed to discover the precise mechanisms that govern network structure and growth.

Recent advances in neural networks have produced graph generators based on recurrent neural networks [You et al., 2018], variational autoencoders [Simonovsky and Komodakis, 2018], and generative adversarial networks Bojchevski et al. [2018] each of which have their advantages and disadvantages, which we explore later. Generally speaking, these neural network models are excellent at generating faithful graphs but struggle to provide a descriptive (i.e., explainable) model from which in-depth scientific or data analysis can be performed.

The present work describes CNRG: a Clustering-based Node Replacement Grammar (pronounced: ”synergy“) a variant of a vertex replacement grammar (VRG), which contains graphical rewriting rules that can match and replace graph fragments similar to how a context-free grammar (CFG) rewrites characters in a string. These graph fragments represent a succinct description of the building blocks of the network, and the rewiring rules of the CNRG describe the instructions about how the graph is pieced together.

Prior work has investigated the relationship between graph theory and formal language theory by extracting Hyperedge Replacement Grammars (HRGs) from the tree decomposition of a graph [Aguiñaga et al., 2016]. The HRG framework can extract patterns from small samples of the graph and can generate networks that have properties that match those of the original graph [Aguiñaga et al., 2018]. In their typical use-case, HRGs are used to represent and generate graph patterns through hyperedge rewriting rules, where a nonterminal edge in the graph is matched with a left-hand-side (LHS) rule in the HRG and replaced with its corresponding right-hand-side (RHS). The composition of an HRG-rule is entirely dependent on the graph’s tree decomposition. Unfortunately, finding an optimal tree decomposition is both NP-complete and non-unique. Heuristic tree decomposition algorithms exist but still do not scale to even moderately sized graphs. Furthermore, non-tree like graphs (i.e., graphs with high treewidth) will produce large, clunky grammar rules that are difficult to interpret.

Like HRGs, VRGs have previously been used to model graph processes and generate graphs. Rather than replacing nonterminal (hyper)edges with RHS-subgraphs, a VRG replaces vertices with RHS-subgraphs. VRGs represent an interesting complement to HRGs, but there currently does not exist a means by which to extract a VRG from a graph automatically. Instead, graph modelers must craft these grammars by hand, which is a time-consuming process and introduces human bias into the process. We desire an automatic, scalable, and interpretable extraction algorithm that compactly models the various structures found in the graph.

The present work describes such an algorithm111Source code can be found in the Github repository. that automatically extracts a CNRG from any graph. Critically, the extraction algorithm does not require a tree decomposition. This permits the extractor to be both scalable and immune to problems arising with non-treelike graphs. The output of the CNRG extractor is a graph model with CFG-like production rules. We show that the graph model is able to compress the graph better than state-of-the-art graph summarization models and generate graphs more faithfully than many state-of-the-art graph generation methods.

2 Preliminaries

We begin with a short introduction to the graph grammar formalism and define important terms that are used throughout the remainder of the present work.

Labeled multigraphs.  A labeled multigraph is a $4$-tuple $H=\langle V,E,\kappa,L\rangle$ where $V$ is the set of vertices; $E\subseteq V\times V$ is the set of edges; $\kappa:E\mapsto\mathbb{Z}^{+}$ is a function assigning multiplicity to edges; $L$ is the set of labels on nodes and edges. By default, each edge has a multiplicity value of 1. Although the CNRG model can be used for directed graphs, the present work treats all graphs as undirected for clarity of prose and illustration. We use the terms node and vertex interchangeably in the present work.

Clustering-based Node Replacement Grammars (CNRGs).  A CNRG is a $4$-tuple $G=\langle\Sigma,\Delta,\mathcal{P},\mathcal{S}\rangle$ where $\Sigma$ is the alphabet of node labels; $\Delta\subseteq\Sigma$ is the alphabet of terminal node labels; $\mathcal{P}$ is a finite set of productions rules of the form $X\rightarrow(R,f)$, where $X$ is the LHS consisting of a nonterminal node (i.e., $X\in\Sigma\setminus\Delta$) with a size $\omega$, and the tuple $(R,f)$ represent the RHS, where $R$ is a labeled multigraph with terminal and possibly nonterminal nodes, and $f\in\mathbb{Z}^{+}$ is the frequency of the rule, i.e., the number of times the rule appears in the grammar, and $\mathcal{S}$ is the starting graph which is a non-terminal of size [math]. This formulation is similar to node label controlled (NLC) grammar  [Rozenberg, 1997], except that the CNRG used in the present work does not keep track of specific rewiring conditions. Instead, every internal node in $R$ is labeled by the number of boundary edges to which it was adjacent in the original graph. The sum of the boundary degrees is, therefore, equivalent to $\omega$, which is also equivalent to the label of the LHS.

A CNRG can be extracted from any graph or hypergraph and may not be unique. That is, one graph may produce many different CNRGs. The goal of the present work is to extract CNRGs that capture the high-order structure of the graph. The example in Fig. 1 shows an example graph and an example grammar that can be extracted from it. In this example, the original graph appears to have a regular structure akin to a recursively arranged triangle of triangles. The extracted grammar represents this triangle of triangles pattern, which is represented by the grammar rules.

Like their HRG cousins [Aguiñaga et al., 2016], the extracted CNRG may also be used to generate graphs that are similar to (or contain similar high-level structures as) the original graph.

Model size.  One way to compare the conciseness of a grammar is by analyzing its size. For this task, we define a description length (abbreviated as $DL$) for graphs and grammars following prior work. Given a labeled multigraph $H$ defined above, we compute its size in the following way. Let $\lg(\cdot)$ denote $\log_{2}(\cdot)$. Our approach is similar to that of Cook and Holder [1993] except that (i) we use Elias $\gamma$ [Elias, 1975] encoding instead of the Quinlan & Rivest encoding [Quinlan and Rivest, 1989], and (ii) we directly encode the multiplicity matrix $M$ instead of encoding a binary adjacency matrix $A$ and its associated multiplicity matrix $M$ separately. First, $\lg|V|$ and $\lg|L|$ bits are required to encode the number of vertices and the number of labels in $H$ respectively. Hence, the total number of bits required to encode all the labeled vertices $(v)$ is $v=\lg|V|+|V|\cdot\lg|L|$ bits. Second, let $M$ be a $|V|\times|V|$ multiplicity matrix where $M_{ij}=\kappa(i,j)$ for $(i,j)\in E$, and [math] otherwise. We add $1$ to each element of $M$ to use the $\gamma$-code, which can only encode positive integers. Hence, the total number of bits required to encode all the labeled edges $(e)$ is $e=\lg|E|+\lg|L|\cdot\sum_{ij}|\gamma\text{-code}(M_{ij})|$ bits. Therefore, the description length $(DL(H))$ of the graph $H$ is $DL(H)=(v+e)$ bits.

Like the graph $H$, the CNRG $G$ is also given a description length. Each rule ($P$) is of the form $X\rightarrow(R,f)$, where $X$ is a nonterminal of size $\omega$, $R$ is a labeled (multi)graph, and $f$ is the frequency. We encode the nonterminal size $\omega$ and the frequency $f$ using the $\gamma$-code. Mathematically, the description length $(DL(l_{P}))$ of the LHS is given by $DL(l_{P})=|\gamma\text{-code}(\omega)|+|\gamma\text{-code}(f)|$ bits.

Similarly, we define a description length $(DL(r_{P}))$ for the RHS. The labeled (multi)graph $R$ is encoded similar to $H$; additionally, we have to include the $\gamma$-encoding of the individual boundary degrees (abbreviated as b_deg) of the nodes in $V_{R}$. So, we have $DL(r_{P})=|\gamma\text{-code}(R)|$ $+\sum_{v\in V_{R}}|\gamma\text{-code}(\text{b\_deg}(v))|$ bits. Therefore, the description length $(DL(G))$ of the CNRG $G$ is given by $DL(G)=\sum_{P}(DL(l_{P})+DL(r_{P}))$ bits.

With these definitions formally stated we can more-concretely restate the task: given a (multi)graph $H$, we seek to extract a CNRG $G$ that succinctly and thoroughly encodes $H$. A byproduct of extracting such a graph grammar is that the production rules may also serve as a succinct representation of the constituent structures found in the original graph.

3 Extracting Vertex Replacement Grammars

As discussed earlier, many possible CNRGs can represent the same original graph. An optimal CNRG ought to represent the original graph succinctly (i.e., with as few bits as possible) and faithfully (i.e., without losing any information). Unfortunately, such an optimal lossless compression is not possible in all cases. Instead, we assume that $H$ can be clustered hierarchically [Ravasz and Barabási, 2003] and that regular substructures can be extracted as rules.

The remainder of this section describes the details of several CNRG extraction methods and uses the minimum description length principle to extract a grammar.

3.1 Hierarchical Graph Clustering

We begin with a labeled (multi)graph $H$. We first compute a dendrogram from $H$ using a hierarchical clustering algorithm. We explored the Leiden method [Traag et al., 2019], the Louvain method [Blondel et al., 2008], recursive spectral bipartion [Hagen and Kahng, 1992], and hierarchical spectral $k$-means [Ng et al., 2002]; however, any hierarchical clustering method may be used here.

As a running example, we introduce a 9-node, 16-edge undirected graph in Fig. 2(A). Applying the recursive spectral clustering algorithm on this graph results in the dendrogram shown in Fig. 2(B). Non-leaf nodes of the dendrogram are represented as $\eta_{i}$, and the leaves are nodes from the original graph. We see that the dendrogram computed from the example graph correctly separates the left and right sides of the graph. A similar dendrogram is produced when other clustering algorithms are applied.

3.2 Rule Extraction

Given an initial dendrogram $D$ computed by applying a hierarchical clustering algorithm on $H$, the next step is to generate a graph grammar $G$. The summary of the rule extraction process is as follows: (a) create production rules from $D$, (b) find the best scoring rule and add it to the grammar $G$, (c) contract the respective subgraphs to create a reduced graph $H^{\prime}$, and update $D$ to reflect those changes. Finally, set $H\leftarrow H^{\prime}$ and repeat until $D$ is empty.

Creating a Grammar Rule.  Each internal node $\eta\in D$ corresponds to a grammar rule $r_{\eta}:X\rightarrow(R,f)$. Let $V_{\eta}$ represent the leaf nodes in the subtree rooted at $\eta$, which correspond to nodes in graph $H$. Let $b_{\eta}$ represent the set of boundary edges, i.e., edges in $H$ which have exactly one endpoint in $V_{\eta}$, and let $\omega=|b_{\eta}|$. $b_{\eta}$ is used to compute the boundary degrees of the nodes in $V_{\eta}$.

We set $X$ to be a nonterminal node of size $\omega$ as the LHS of the new production rule. The RHS of the new production rule in the CNRG formalism is a labeled multigraph $R\subseteq H$ with rule frequency $f$. Let $R=\langle V_{R},E_{R},\kappa_{R},L_{R}\rangle$ where $V_{R}=V_{\eta}$; $E_{R}=\{(u,v)\ |\ u\in V_{\eta}\land v\in V_{\eta}\land(u,v)\in E\}$; $\kappa_{R}(e)=k$, where $k$ is the multiplicity of edge $e\in E_{R}$; $L_{R}=\{\text{\small{internal node}, \small{internal edge}}\}$. If this newly generated rule already exists in the grammar, then the frequency of that rule will be incremented by $1$ (instead of storing duplicate rules). Note that this leads to the creation of a many-to-one mapping between the non-leaf nodes of the dendrogram and the rules. Finally, each subtree, and consequently, each rule, is assigned a score $(s_{\eta})$ which is used for selection. The details of the scoring functions are discussed in Sec. 3.3.

Returning to the running example, Fig. 3 shows all possible rules that can be constructed from the dendrogram introduced in Fig. 2(B). Considering every possible production rule at every step becomes computationally intractable for medium and large-sized graphs. We also observe that certain internal nodes towards the top of the dendrogram cover many leaf nodes and therefore tend to create production rules with large RHSs. Production rules with large RHSs do not align with our aim of finding small, but topologically meaningful building blocks of the graph. So, to prune the search space and restrict the size of the RHS of the rules, we introduce a subtree restriction parameter $\mu$ that removes subtrees larger than $\mu$ from consideration.

Selecting the Best Scoring Rule.  From all rules $r_{\eta}$, we pick the rule $r_{\eta}^{\ast}$ with the minimum score and add it to the $G$, updating the necessary alphabet $\Sigma$, terminal nodes $\Delta$, and production rules $\mathcal{P}$ as needed. Note that multiple subtrees of the dendrogram may correspond to the same rule. For example, in Fig. 3 subtrees $\eta_{3},\eta_{4},\eta_{7}$, and $\eta_{8}$ all correspond to the same rule.

Updating the Data Structures. Once a production rule is created from the dendrogram, the next step is to create $H^{\prime}$ by contracting $H$ by removing the RHS subgraph and inserting the new nonterminal node.

Let $H^{\prime}=H$ initially. For a selected $\eta^{\ast}$, we remove $V_{\eta}$ from $H^{\prime}$, and insert a new nonterminal node $X$ labeled with $\omega$ (from the first step). We connect $X$ to the rest of the graph through the set of boundary edges in $R$ where edges that were connected to $V_{\eta}$ are redirected to connect to $X$. Note, this may lead to the creation of multi-edges in the new graph. $H^{\prime}$ is now strictly smaller than $H$ and contains new nonterminal nodes.

With a new (smaller) $H^{\prime}$, it may be prudent to re-run the clustering algorithm and draw a new dendrogram. However, in our initial experiments, we found that re-clustering is time consuming and rarely results in significant changes to the dendrogram. Instead, we simply modify $D$ by replacing the subtrees in $\eta^{\ast}$ with nonterminal nodes $X$ labeled with $\omega$. Scores are also updated as needed based on the new graph.

Finally, we set $H\leftarrow H^{\prime}$ and repeat this process until the dendrogram is empty.

3.3 Scoring Functions

The choice of scoring function directly impacts the choice of $\eta^{*}$, which directly impacts the extracted CNRG. Again note that we ignore all $\eta$ where $|V_{\eta}|>\mu$. The simplest case is to set $s_{\eta}=|V_{\eta}|-\mu$. But this simple case results in many ties which need to be broken. For this task we consider three policies:

• •

Random tiebreaking. Pick $\eta^{\ast}$ at random from candidates equi-distant to $\mu$.

• •

Greedy DL. Break ties by picking $\eta^{\ast}$ that minimizes the overall DL of the grammar. Minimizing the DL of the grammar is akin to finding a rule that already exists in the grammar, or by selecting the rule that has the smallest description length among all candidates according to the description length calculation described in Sec. 2. This is more computationally expensive than other policies because it requires the DL computation for each candidate $\eta$. Among $\eta$’s with equal DL, ties are broken arbitrarily.

• •

Greedy Level. Break ties by picking $\eta^{\ast}$ that is at the highest level in the dendrogram. This results in the creation of fewer rules, because a larger portion of the dendrogram, and consequently the graph, is contracted at each step. Among subtrees with equal level, ties are broken arbitrarily.

• •

Greedy level + DL. Break ties by picking $\eta^{\ast}$ using the Greedy Level policy first and then by using the DL.

Previous work suggests that crude two-part MDL [Grünwald, 2007] is a useful principle for selecting model parameters [Koutra et al., 2015, Cook and Holder, 1993]. Therefore, the next policies to select $\eta^{\ast}$ mimic this. Specifically, let $s_{\eta}=DL(r_{\eta})+DL(H\,|\,r_{\eta})$, which is the sum of the DL of the rule and the DL of $H$ compressed by $r_{\eta}$ respectively.

Based on this idea, our next task is to calculate $DL(H\,|\,r_{\eta})$. One important consideration is the case where multiple subtrees map to the same rule. Again consider the example from Fig. 3 where the subtrees $\eta_{3}(\text{f, g}),\eta_{4}(\text{h, i}),\eta_{7}(\text{c, d}),$ and $\eta_{8}(\text{a, b})$ are all encoded in the same rule $r$. With this in mind, two strategies are evident to us: local MDL and global MDL. In the local MDL strategy, we calculate the scores of each $\eta$ independently, without regard to other subtrees which result in identical rules. In the global strategy, we recognize that identical rules can be compressed together and therefore calculate $DL(H\,|\,r_{\eta})$ such that all isomorphic $r_{\eta}$’s are compressed and stored simultaneously. In global MDL strategy, $\eta^{\ast}$ is not a single rule, but rather a set of isomorphic rules that are compressed together.

We hypothesize that the global MDL strategy will perform best, but requires significantly more time to select $\eta^{\ast}$. Fig. 4 shows complete CNRGs extracted using the Local (A) and Global (B) MDL strategies. The differences in this small example are subtle. It is unclear which is better.

4 Generating Graphs from Vertex Replacement Grammars

The grammar $G$ encodes information about the original graph $H$ in a way that can be used to generate new graphs. How similar are these newly generated graphs to the original graph? Do they contain similar structures and similar global properties? In this section, we describe how to repeatedly apply rules to generate these graphs.

We use a stochastic graph generating process to generate graphs. Simply put, this process repeatedly replaces nonterminal nodes with the RHSs of production rules until no nonterminals remain.

Formally, a new graph $H^{\prime}$ starts with $\mathcal{S}$, a single nonterminal node labeled with 0. From the current graph, we randomly select a nonterminal and probabilistically (according to each rule’s frequency) select a rule from $G$ with an LHS matching the label $\omega$ of the selected nonterminal node. We remove the nonterminal node from $H^{\prime}$, which breaks exactly $\omega$ edges. Next, we introduce the RHS subgraph to the overall graph randomly rewiring broken edges respecting the boundary degrees of the newly introduced nodes. For example, a node with boundary degree of $3$ expects to be connected with exactly $3$ randomly chosen broken edges. This careful but random rewiring helps preserve topological features of the original network. After the RHS rule is applied, the new graph $\hat{H}$ will be larger and may have additional nonterminal nodes. We set $H^{\prime}=\hat{H}$ and repeat this process until no more nonterminals exist.

An example of this generation process is shown in Fig. 5 using the rules from Fig. 4(A). We begin with 0 and apply $r_{1}$ to generate a multigraph with two nonterminal nodes and two edges. Next, we (randomly) select the nonterminal on the right and replace it with $r_{2}$ containing four terminal nodes and 6 new edges. There is one remaining nonterminal, which is replaced with $r_{3}$ containing two terminal nodes, one nonterminal node, and 5 edges. Finally, the last nonterminal node is replaced with $r_{4}$ containing three terminal nodes and three edges. The edges are rewired to satisfy the boundary degrees, and we see that $\hat{H}=H$. In this way, the graph generation algorithm creates new graphs. The previous example conveniently picked rules that would lead to an isomorphic copy of the original graph; however, a stochastic application of rules and random rewiring of broken edges is likely to generate various graph configurations.

5 Methodology and Results

Our next task is to evaluate the CNRG model size and its graph generation performance. For size, we measure how the CNRG’s description length compares with other graph models. For performance, we measure the accuracy of the stochastic graph generator by comparing the generated graphs with the original graph.

The goal of the first part of this section is to explore the parameter space for CNRG extraction and generation performance. After we select appropriate parameters, we will compare against existing methods.

5.1 Datasets

Datasets were selected based on their variety and size. Our implementation of the CNRG extractor is memory bound at $O(|V|+|E|)$, but it is computationally very fast. The computational complexity of the extractor varies with the choice of clustering algorithm and extractor policy; the graph generation is in $O(|V|+|E|)$. The CNRG extractor can scale to extremely large graphs. Alternative graph models are unable to scale to the largest available graphs, so we selected graphs that could be compared against existing models.

We selected five medium-sized graphs from various sources. They are listed in Tab. 1 and were downloaded from KONECT [Kunegis, 2013] and SNAP [Leskovec and Krevl, 2014].

5.2 Selecting CNRG Parameters

To measure model size, we must first select from the many parameters of the extraction model: clustering algorithm, boundary information, extractor selection heuristic, and RHS size ($\mu$).

The methodology is as follows. We extract a CNRG for each combination of the clustering algorithm, scoring function, and $\mu\in\{2,3,\ldots,10\}$, which equates to 300 different CNRG models for each dataset. To permit statistical tests and confidence intervals, this process is repeated five times for a total of 1,500 CNRG models for each graph.

For $k$-way recursive Spectral algorithm, we use $k=\sqrt{n/2}$ [Liu et al., 2015]. The random hierarchical clustering method split the graph into two (nearly) equally-sized but random clusters in a top-down fashion.

Model Size. We define the size of the CNRG as the number of rules present in the grammar and its overall complexity. The number of rules is simply the count of the number of distinct production rules. Usually, the grammar size is sufficient to make decisions about the model. Smaller is better.

The description length (DL) measures the size and complexity of the grammar. CNRGs extracted from graphs of different sizes should not be compared in absolute terms – a large graph will almost certainly have a larger CNRG than a small graph. In order to perform an apples to apples comparison across different dataset sizes, we measure model size using the reciprocal compression ratio: $\textrm{DL}(G)/\textrm{DL}(H)$, where $\textrm{DL}(G)$ is the description length of the CNRG and $\textrm{DL}(H)$ is the description length of the original graph. Lower is better.

Model Performance. We define the performance of a model as its ability to generate a graph $\hat{H}$ that is similar to the original graph $H$. There are many ways to compare $\hat{H}$ with $H$. In the present work we use the spectral distance ($\lambda$-distance) [Wilson and Zhu, 2008] and DeltaCon [Koutra et al., 2016].

The $\lambda$-distance compares the spectrum of a graph, which is typically defined as the set of eigenvalues $s=\{\lambda_{1},\lambda_{2},\ldots,\lambda_{|V|}\}$ are are ordered by their magnitude $\lambda_{1}\geq\lambda_{2}\geq\ldots\geq\lambda_{|V|}$. The graph spectrum permits a distance to be calculated:

[TABLE]

where the list of eigenvalues may be zero-padded if they are not the same size.

DeltaCon measures the difference in node affinities using a belief propagation algorithm. The use of belief propagation implicitly models the diffusion of information throughout the graph and should be able to measure global and local graph structures.

In addition, we count the number of three and four node graphlets [Ahmed et al., 2015] that are present in the graph and directly compare these counts. The graphlet correlation distance (GCD) is also used to measure the rank correlation of graphlet orbital counts between nodes in each graph [Pržulj, 2007, Marcus and Shavitt, 2012, Hočevar and Demšar, 2014].

Because these are all distance metrics, lower is better.

Selecting a Clustering Method. First, we consider the selection of a clustering method. We used Random, Leiden, Louvain, recursive spectral bipartition (i.e., Conductance), and hierarchical spectral $k$-means (i.e., Spectral) clustering methods. Each clustering method was applied to each dataset using all available datasets, $\mu$-values and $\eta^{\ast}$ selection policies. Each unique configuration was repeated 5 times.

The model size and $\lambda$-distance for each graph is plotted in Fig. 6. We observe that Spectral clustering results in remarkably good graph generation, but bad compression. Conversely, Conductance clustering results in remarkably good graph compression, but bad graph generation performance.

As is typical, we generally observe a trade-off between compression and model performance. The Leiden clustering method appears to perform the best in both metrics consistently; so we select Leiden clustering for further analysis.

Selecting an $\eta^{\ast}$ policy. Our next task is to find the $\eta^{\ast}$ selection policy that performs best. Using only the Leiden clustering method, we group all runs (across all $\mu$ values) and plot the mean reciprocal compression ratio and $\lambda$-distance in Fig. 7. 95% confidence intervals are drawn as error bars.

We observe that the choice of $\eta^{\ast}$ selection policy has minimal effect on the model size and the generation performance. We select Greedy Level + DL and Local MDL because they performed (slightly) better than the other methods, but also because they are much faster to compute than the Global MDL.

Selecting a $\mu$ Value. Next, we compare model size and generation performance results for various values of $\mu$. Recall that $\mu$ is an upper bound for the number of nodes that appear within a subtree of $\eta^{\ast}$; i.e., $\mu$ is the maximum number of nodes that can appear in any extracted RHS.

We select $\mu$ by following the pattern as before. Using the Leiden clustering method and Greedy Level + DL and Local MDL $\eta^{\ast}$ selection policies, we plot the mean reciprocal compression ratio and $\lambda$-distance in Fig. 8. 95% confidence intervals are drawn as error bars.

We observe little difference between the $\eta^{\ast}$ selection policies. However, the size-to-performance trade-off becomes evident again as $\mu$ varies from small to large. Small values of $\mu$ more complex models but more accurate models, while larger values produce less complex models but less accurate models; however, there are quickly diminishing returns as $\mu$ increases.

We select a $\mu$=4 because it appears to generate reasonably small models with reasonable accuracy.

In summary, based on the decisions highlighted in this section we select a parameterization for the CNRG that uses Leiden clustering, the Greedy Level + DL for the $\eta^{\ast}$ selection policy, and $\mu=4$. We will use these values throughout the remainder of the present work unless otherwise specified.

5.3 Graph Model Size

Next, we compare the model size of CNRG, parameterized as above, in bits against three other graph models: the Vocabulary-based summarization of Graphs (VoG) [Koutra et al., 2015], SlashBurn [Lim et al., 2014], and SUBDUE [Ketkar et al., 2005]. Like the CNRG model, VoG, SlashBurn, and SUBDUE maintain an encoding of the graph, but their models are constructed in very different ways. VoG summarizes graphs using a fixed vocabulary of structures. SlashBurn recursively splits a graph into hubs and spokes connected only by the hubs. SUBDUE creates a node-grammar model, similar in principle to the CNRG model, by finding substructures that maximally reduce the size (bits) of the graph after each selection. These models are useful for graph summarizing and graph understanding, but do not generate graphs; thus, they can only be compared to CNRGs by their model size. Each of the models was run with their default settings.

SUBDUE was unable to process the even the smallest of our graph datasets, so we included three graphs: Karate, Dolphins, and LesMis, representing well known small graphs, in Tab. 2. These results show that CNRG almost always produces the best model sizes among the other models. This confirms our hypothesis that CNRG compresses the original graph better than the state-of-the-art methods.

5.4 Graph Generation Performance

Here we show that the CNRG model represents not only a succinct encoding of the original graph but also a faithful one as well. Keeping a tree ordering over production rules in the CNRG will permit a generation close or isomorphic to the original graph. This is an interesting, but not particularly useful outcome of the CNRG model. Instead, we ask how well the CNRG model generates new graphs. Are these graphs similar to the original graph? How does the CNRG accuracy compare to other graph models at generating graphs?

Graph generators have been studied intently for several years. The idea being that we only truly understand a graph if we can generate it faithfully. Practically speaking, graph generators are often used to create null models for statistical purposes. In a similar vein, graph generators are frequently used to find anomalous patterns in real-world graphs.

Setup. We compare CNRG graph generation against many of the state-of-the-art graph generators. We consider the properties that characterize some real-world networks and compare the distribution of graphs generated using the Kronecker graph model [Leskovec et al., 2010], the Block Two-Level Erdős-Rényi (BTER) model [Kolda et al., 2014], Chung-Lu’s configuration model [Chung and Lu, 2002], the degree corrected Stochastic Block Model (DC-SBM) [Karrer and Newman, 2011], and the stochastic Hyperedge Replacement Grammar (HRG) model [Aguiñaga et al., 2016, 2018].

Like CNRGs, these other graph models learn parameters that can be used to approximately recreate the original graph or a graph of some other size such that the generated graph holds many of the same properties as the original graph. The generated graphs are likely not isomorphic to the original graph. We can, however, still judge how closely the generated graph resembles the original graph by comparing several of their local and global graph properties.

Exponential Random Graph Models (ERGMs) are another type of graph model that learns a robust graph model from user-defined features of a graph [Robins et al., 2007]. Unfortunately, this model does not scale well and is prone to model degeneracy. Neural network graph models like GraphVAE [Simonovsky and Komodakis, 2018] and GraphRNN [You et al., 2018] are currently limited in their scalability. Generative adversarial networks (GANs) have been shown to scale to medium-sized graphs and perform on-par with existed methods; however, the model size of NetGAN is many times larger than the graph size [Bojchevski et al., 2018]. We attempted to compare these methods but were unable to because of problems with either model degeneracy or scalability.

The main purpose of node embedding models like LINE [Tang et al., 2015], node2vec [Grover and Leskovec, 2016], VGAE [Kipf and Welling, 2016], and others [Goyal and Ferrara, 2018] is to learn vector representations of the nodes. They are not well equipped to generate graphs and cannot be compared for this task.

Evaluation. We generate 5 graphs using each model on each dataset and compare each generated graph with the original. To measure how well the local structures are preserved in the generated graph, we counted the number of size-2, 3, and 4 node graphlets [Ahmed et al., 2015] and compared those values to the number of graphlets present in the original graph. The (mean average) difference in graphlet counts is indicated as a heatmap in Fig. 3. CNRG consistently outperforms the other models at this task.

GCD, $\lambda$-distance, and DeltaCon metrics are indicated in Tab. 3 where bold indicates the best (mean average) performance for each dataset and metric. Across all metrics, the CNRG model performs consistently well, especially in the graphlet counts and GCD metrics. The ChungLu model does a very good job at capturing the $\lambda$-distance; this is expected because ChungLu directly (and only) models the node degree, which is highly correlated with the eigenvalues.

6 Discussion

The present work describes CNRG, a variant of the vertex replacement grammar model inspired by the context-free grammar formalism widely used in compilers and natural language processing. We described how a CNRG can be extracted from a hierarchical clustering of a graph and then show that the model succinctly encodes the structures present in the original graph. Starting with an empty graph, if we apply CNRG rules stochastically, then the CNRG model can generate a new graph. We show that the newly generated graphs contain global and local topographical features that are similar to the original graph.

A potentially significant benefit from the CNRG model stems from its ability to directly encode local substructures and patterns in the RHSs of the grammar rules. Encoding these local graphlet-like structures is probably the reason that the CNRG model performed so well at the graphlet counting task and the GCD metric. Forward applications of CNRGs may allow scientists to identify previously unknown patterns in graph datasets representing important natural or physical phenomena [Pennycuff et al., 2018]. Further investigation into the nature of the extracted rules and their meaning (if any) is a top priority.

We also plan to investigate differences between the grammars extracted from different types of graphs. What are the implications of finding two graphs that have a significant overlap in their extracted grammars? What about graphs that seem similar on the surface, but have little overlap in their grammar? Another area of study that we are particularly interested in is learning a temporal grammar from the dynamical processes of an evolving graph. Additional applications of CNRGs are possible on multi-level, multi-layer, and labeled graphs and their various applications.

Acknowledgements. We thank David Chiang for his guidance on this work. This research is supported by a grant from the US National Science Foundation (#1652492).