DDGK: Learning Graph Representations for Deep Divergence Graph Kernels

TL;DR

This paper introduces Deep Divergence Graph Kernels, an unsupervised neural network approach that learns graph representations and alignments without domain knowledge or supervision, enabling effective graph comparison and classification.

Contribution

It proposes a novel unsupervised method combining graph encoding and cross-graph attention to learn graph similarities without supervision or domain-specific features.

Findings

Achieves competitive results on graph classification tasks.

Learns meaningful unsupervised alignments between graphs.

Provides interpretability through attention-based sub-structure alignment.

Abstract

Can neural networks learn to compare graphs without feature engineering? In this paper, we show that it is possible to learn representations for graph similarity with neither domain knowledge nor supervision (i.e.\ feature engineering or labeled graphs). We propose Deep Divergence Graph Kernels, an unsupervised method for learning representations over graphs that encodes a relaxed notion of graph isomorphism. Our method consists of three parts. First, we learn an encoder for each anchor graph to capture its structure. Second, for each pair of graphs, we train a cross-graph attention network which uses the node representations of an anchor graph to reconstruct another graph. This approach, which we call isomorphism attention, captures how well the representations of one graph can encode another. We use the attention-augmented encoder's predictions to define a divergence score for each pair of graphs. Finally, we construct an embedding space for all graphs using these pair-wise divergence scores. Unlike previous work, much of which relies on 1) supervision, 2) domain specific knowledge (e.g. a reliance on Weisfeiler-Lehman kernels), and 3) known node alignment, our unsupervised method jointly learns node representations, graph representations, and an attention-based alignment between graphs. Our experimental results show that Deep Divergence Graph Kernels can learn an unsupervised alignment between graphs, and that the learned representations achieve competitive results when used as features on a number of challenging graph classification tasks. Furthermore, we illustrate how the learned attention allows insight into the the alignment of sub-structures across graphs.

Tables

Table 1. Table 1 . Values used during our grid search for DDGK graph representations learning hyper-parameters.

Hyper-Parameter	Values
Node embedding	$2,4,8,16,32$
Encoder layers	$1,2,3,4$
Learning rate	${10}^{-4}$, ${10}^{-3}$, ${10}^{-2}$, ${10}^{-1}$, $1$
Encoding epochs	$100,300,600$
Scoring epochs	$100,300,600$
Node preserving loss coefficient	$0,0.25,0.5,1.0,1.5,2.0$
Edge preserving loss coefficient	$0,0.25,0.5,1.0,1.5,2.0$

Table 2. Table 2 . Statistics of the chemo- and bio-informatics datasets.

	# Graphs	Average Nodes	Average Edges	# Labels	# Node Labels	# Edge Labels
D&D	$1178$	$284$	$716$	$2$	$89$	$-$
NCI1	$4110$	$30$	$32$	$2$	$37$	$-$
PTC	$344$	$14$	$15$	$2$	$18$	$4$
MUTAG	$188$	$18$	$20$	$2$	$7$	$4$

Table 3. Table 3 . Average accuracy in ten-fold cross validation on our graph classification task. Methods are grouped by their level of supervision during the similarity metric learning, whether they use algorithm insights the Weisfeiler-Lehman algorithm, and whether they use feature engineering (e.g. graph motifs, random walks, etc.). Baseline results taken from (Niepert et al . , 2016a ; Kriege et al . , 2016 ; Taheri et al . , 2018 ) (missing results are missing from these works). We note that DDGK performs surprisingly competitively for an unsupervised method with no hard-coded insights.

Method		Unsupervised	No Weisfeiler-Lehman	No Feature Engineering	D&D	NCI1	PTC	MUTAG
PSCN	(Niepert et al., 2016a)				$76.27\pm 2.64$	$76.34\pm 1.68$	$62.29\pm 5.68$	$88.95\pm 4.37$
DGCNN	(Zhang et al., 2018)				$-$	$74.44\pm 0.40$	$58.59\pm 2.40$	$85.83\pm 1.60$
SP Kernel	(Borgwardt and Kriegel, 2005)	✓			$79.00\pm 0.60$	$74.50\pm 0.30$	$58.90\pm 2.20$	$83.00\pm 1.40$
WL Kernel	(Kriege et al., 2016)	✓			$79.00\pm 0.40$	$85.80\pm 0.20$	$61.30\pm 1.40$	$86.00\pm 1.70$
WL-OA	(Kriege et al., 2016)	✓			$79.20\pm 0.40$	$\text{86.10}\pm 0.20$	$63.60\pm 1.50$	$86.00\pm 1.70$
DGK	(Yanardag and Vishwanathan, 2015)	✓			$-$	$80.30\pm 0.40$	$60.10\pm 2.50$	$87.40\pm 2.70$
graph2vec	(Narayanan et al., 2017)	✓			$-$	$73.22\pm 1.90$	$60.17\pm 6.90$	$83.15\pm 9.20$
S2S-N2N-PP	(Taheri et al., 2018)	✓			$-$	$83.72\pm 0.40$	$\text{64.54}\pm 1.10$	$89.86\pm 1.10$
node2vec	(Grover and Leskovec, 2016)	✓	✓		$-$	$61.91\pm 0.30$	$55.60\pm 1.40$	$82.01\pm 1.00$
DDGK	(this paper)	✓	✓	✓	$\text{83.14}\pm 2.72$	$68.10\pm 2.30$	$63.14\pm 6.57$	$\text{91.58}\pm 6.74$

Equations

$$k_{\times }(G_1,G_2)=e^T(I-\lambda A_{\times }{)}^{-1}e,$$

$$k(G_1,G_2)=||\Psi (G_1)-\Psi (G_2)|{|}^2$$

$$\Psi (G{)}_i=\sum _{v_j\in V_T}{f}_{g_i}(v_j),$$

$$J(\theta )=\sum _i\sum _{\begin{array}{c}j\\ e_{ij}\in E\end{array}}\log \mathrm{Pr}(v_j\mid v_i,\theta ).$$

$$\mathrm{Pr}(v_j\mid u_i)=\frac{e^{{\mathcal{M}}_{T\to S}(v_j,u_i)}}{{\sum }_{v_k\in V_S}{e}^{{\mathcal{M}}_{T\to S}(v_k,u_i)}}.$$

$$\mathrm{Pr}(u_j\mid \mathcal{N}(v_i))=\frac{1}{1+e^{-{\mathcal{M}}_{S\to T}(u_j,\mathcal{N}(v_i))}}.$$

$$Q_n(y_i|u_j)=\sum _k{\mathcal{M}}_{T\to S}(y_i|v_k)\mathrm{Pr}(v_k\mid u_j).$$

$$L=\frac{1}{|V_T|}\sum _j^{|V_T|}\sum _i\mathrm{Pr}(y_i\mid u_j)\log (Q_n(y_i|u_j)),$$

$${\mathcal{D}}^{\prime }(T\Vert S)=\sum _{v_i\in V_T}\sum _{\begin{array}{c}j\\ e_{ji}\in E_T\end{array}}-\log \mathrm{Pr}(v_j\mid v_i,H_S)$$

$$\mathcal{D}(S\Vert T)={\mathcal{D}}^{\prime }(S\Vert T)-{\mathcal{D}}^{\prime }(S\Vert S),$$

$$\Psi (G_T)=[\mathcal{D}(T\Vert S_0),\mathcal{D}(T\Vert S_1),\dots ,\mathcal{D}(T\Vert S_N)]$$

$$J(\theta )=\sum _{e_{ij}\in E}\log \mathrm{Pr}(v_i\mid e_{ij},\theta )+\log \mathrm{Pr}(v_j\mid e_{ij},\theta )$$

$$J(\theta)=\sum_{\begin{subarray}{c}(v_{1},v_{2},\cdots,v_{i})\\ \thicksim RandomWalk(G,E,V)\end{subarray}}\log\Pr\big{(}v_{j}\mid(v_{1},v_{2},\cdots,v_{i},\theta)\big{)}$$

Full text

Unlike previous work, much of which relies on 1) supervision, 2) domain specific knowledge (e.g. a reliance on Weisfeiler-Lehman kernels), and 3) known node alignment, our unsupervised method jointly learns node representations, graph representations, and an attention-based alignment between graphs.

Our experimental results show that Deep Divergence Graph Kernels can learn an unsupervised alignment between graphs, and that the learned representations achieve competitive results when used as features on a number of challenging graph classification tasks. Furthermore, we illustrate how the learned attention allows insight into the the alignment of sub-structures across graphs.

Graph Kernels; Graph Neural Networks; Representation Learning; Similarity and Search

††copyright: rightsretained††journalyear: 2019††copyright: iw3c2w3††conference: Proceedings of the 2019 World Wide Web Conference; May 13–17, 2019; San Francisco, CA, USA††booktitle: Proceedings of the 2019 World Wide Web Conference (WWW’19), May 13–17, 2019, San Francisco, CA, USA††doi: 10.1145/3308558.3313668††isbn: 978-1-4503-6674-8/19/05

1. Introduction

Deep learning methods have achieved tremendous success in domains where the structure of the data is known a priori. For example domains like speech and language have intrinsic sequential structure to exploit, while computer vision applications have spatial structure (images) and perhaps temporal structure (videos). In all these cases, our intuition guides us to build models and learning algorithms based on the structure of the data. For example, translation invariant convolution networks might search for shapes regardless of their physical position in an image, or recurrent neural networks might share a common latent representation of a concept across distant time steps or diverse domains such as languages. In contrast, graph learning represents a more general class of problems because the structure of the data is free from any constraints. A neural network model must learn to solve both the desired task at hand (e.g. node classification) and to represent the structure of the problem itself – that of the graph’s nodes, edges, attributes, and communities.

Despite the challenges, there has been a recent surge of interest in applying neural network models to such graph-structured data (Perozzi et al., 2014; Kipf and Welling, 2016; Hamilton et al., 2017; Velickovic et al., 2017; Zhu et al., 2018). While initial approaches like DeepWalk (Perozzi et al., 2014) focused on generic representations of graph primitives (e.g. a graph’s nodes (Perozzi et al., 2014) or edges (Abu-El-Haija et al., 2017)), present approaches ignore learning general graph and node representations in favor of maximizing accuracy on a set of narrow classification tasks. These approaches, broadly referred to as Graph Neural Networks (GNNs), seek to leverage the structure between data items as a scaffolding to perform computation (e.g. message passing, gradient updates, etc). The parameters and the activations, use the structure during training, but are tuned primarily to classify the graph’s nodes, edges, and/or attributes.

While much effort has focused on unsupervised learning of node representations (Perozzi et al., 2014; Grover and Leskovec, 2016; Cao et al., 2016; Tsitsulin et al., 2017), edge representations (Abu-El-Haija et al., 2017), or latent community structure (Cavallari et al., 2017; Wang et al., 2017; Zheng et al., 2016), relatively little work has focused on the unsupervised learning of representations for entire graphs – a problem of practical interest in domains such as information retrieval, biology, and natural language processing (Gilmer et al., 2017; Battaglia et al., 2018). In cases where GNNs have been applied to the task of learning similarity between graphs, the approaches considered generally come in two flavors: an end-to-end supervised graph classification or graph representation learning.

In supervised graph classification, the task is to solve an end-to-end whole-graph classification problem (i.e. the problem of assigning a label to the entire graph). These supervised approaches (Niepert et al., 2016a; Zhang et al., 2018; Tixier et al., 2018; Morris et al., 2018) learn an intermediate representation of an entire graph as a precondition in order to solve the classification task. This learned representation can be used to compare similarity between graphs, but is heavily biased towards maximizing performance on the classification task of interest.

The second class of approaches focuses on the more general problem of learning graph representations (Taheri et al., 2018). While much exciting progress has been made in this area, the existing approaches suffer from one or more of the following limitations. First, many existing methods rely on feature engineering, such as the graph’s clustering coefficient, its motif distribution, or its spectral decomposition, to represent graphs (Berlingerio et al., 2012; Yanardag and Vishwanathan, 2015; Tsitsulin et al., 2018). By limiting the features that they consider, these methods are limited to composing only known graph signals. Second, many of these approaches (Niepert et al., 2016a; Zhang et al., 2018) have sought to encode algorithmic heuristics from the graph isomorphism literature (especially the intuition encoded in the Weisfeiler Lehman algorithm (Shervashidze et al., 2011)). Relying heavily on existing heuristics to solve a hard problem raises an important question: how well can a learning-only approach solve a classic algorithmic problem? Finally, other work in this area of graph similarity assumes that identical nodes in both graphs share the same id (i.e. the alignment is already given). While this can be useful for calculating a similarity score, we find the general problem more compelling.

In this work, we propose a method of learning graph representations driven by the similarity between a pair of graphs as measured by the divergence in their structures. We show the representations learned through our method, Deep Divergence Graph Kernels (DDGK), capture the attributes of graphs by using them as features for several classification problems. In addition, we show that our representations capture the local similarity of graph pairs and the global similarity across families of graphs.

DDGK has three key differentiators. First, it makes no assumptions about the structure of the matching problem. In order to solve the matching problem, we propose an attention mechanism: isomorphism attention to align the nodes across graph pairs. Second, DDGK does not rely on any existing heuristics for graph similarity. Instead, we learn the kernel method jointly with the node representation and alignment networks. This allows the model the freedom to learn representations that best preserve the graph, and does not impose artificial oversights. Finally, as an unsupervised method, the representations it learns emphasize structural similarity, and does not correlate with a downstream labeling tasks. This is especially useful for ranking tasks where labeling may not be available.

To summarize, our main contributions are:

• •

Deep Divergence Graph Kernels: A novel method for learning unsupervised representations of graphs and their nodes. Our kernel is learnable and does not depend on feature engineering or domain knowledge.

• •

Isomorphism Attention: A cross-graph attention mechanism to probabilisticly align representations of nodes between graph pairs. These attention networks allow for great interpretablity of graph structure and discoverablilty of similar substructures.

• •

Experimental results: We show that DDGK both encodes graph structure to distinguish families of graphs, and when used as features, the learned representations achieve competitive results on challenging graph classification problems like predicting the functional roles of proteins.

2. Learning Graph Representations

In this section, we lay out the problem definition of representing graphs and the connection between our representations and the kernel framework.

2.1. Problem Definition

A graph is defined to be a tuple $G=(V,E)$, where $V$ is the set of vertices and $E$ is the set of edges, $E\subseteq(V\times V)$. A graph $G$ can have an attribute vector $Y$ for each of its nodes or edges. We denote the attributes of node $v_{i}$ as $y_{i}$, and denote the attributes of an edge ($v_{i}$, $v_{j}$) as $y_{ij}$.

Given a family of graphs $G_{0}$, $G_{1}$, $\dots$, $G_{N}$ we aim to learn a continuous representation for each graph $\Psi(G)\in\mathbb{R}^{N}$ that encodes its attributes and its structure. For this representation to be useful, it has to be comparable to other graph representations. However, it is likely that our method of graph encoding will produce one of many equally good representations each time we run it. For example we can get two different, but equal, representations by permuting the dimensions of the first one. Those representations are not comparable given they exist in two different spaces.

To avoid this problem, we seek to develop an equivalence class across all possible encodings of a graph. Essentially, two encodings of a graph are equivalent if they lead to the same pair-wise similarity scores when used to compare the graph to all other graphs in the set. We note that this issue arises when working with embedding based representations across domains, and several equivalence methods have been proposed (Artetxe et al., 2016; Yin and Shen, 2018).

2.2. Embedding Based Kernels

In this work, we study the development of graph kernels, which are functions to compute the pairwise similarity between graphs. Specifically, given two graphs $G_{1}$, $G_{2}$, a classic example of a kernel defined over graph pairs is the geometric random walk kernel (Borgwardt et al., 2005) as shown in Eq. 1:

[TABLE]

where $A_{\times}$ is the adjacency matrix of the product graph of $G_{1}$ and $G_{2}$, and $\lambda$ is a hyper-parameter which encodes the importance of each step in the random walk. We aim to learn an embedding based kernel function $k()$ as a similarity metric for graph pairs, defined as the following:

[TABLE]

For a dataset of $N$ source111In this paper, we use source and anchor interchangeably when referring to the encoded graph. graphs $\mathcal{S}$ and $M$ target graphs ($\mathcal{T})$, for any member of the target graph set we define the $i^{th}$ dimension of the representation $\Psi(G\in\mathcal{T})\in\mathbb{R}^{N}$ to be:

[TABLE]

where $g_{i}\in\mathcal{S}$ and $f_{g_{i}}()$ is a predictor of some structural property of the graph $G$ but parameterized by the graph $g_{i}$. We note that the source and target graphs sets ($\mathcal{S},\mathcal{T}$) could be disjoint, overlapping, or equal.

3. Learning to Align Graph Representations

We propose to learn a graph representation by comparing it to a population of graphs. To compare the similarity of a pair of graphs (source, target), we rely on deep neural networks to measure the divergence between their structure and attributes. First, we learn the structure of the source graph by passing it through a graph encoder. Second, to measure how much the target graph diverges from the source graph, we use the source graph encoder to predict the structure of the target graph. If the pair is similar, we expect the source graph encoder to correctly predict the target graph’s structure. In this section, we develop the three key components necessary to learn the similarity between a pair of graphs.

First, in Section 3.1, we discuss encoding graphs. The quality of the graph representation depends on the extent to which the encoder of each source graph is able to discover its structure.

Second, in Section 3.2, we propose a cross-graph attention mechanism to learn a soft alignment between graphs. This is necessary because a target graph may not share its vertex ids with any of the source graphs – indeed, they could even have differing number of nodes! Therefore, we need to learn an alignment between the nodes of the target graph and each source graph. This leads to an alignment that is not necessarily a one-to-one correspondence.

Third, in Section 3.3 we introduce additional constraints on the cross-graph attention learning. For example, let us assume that $v_{i}\in V_{G_{1}}$ is assigned to $u_{j}\in V_{G_{2}}$. While both $v_{i}$ and $u_{j}$ may be structurally similar, they may belong to different node classes as indicated by their attributes. These attributes may be of significant importance to the nature of the graph. For instance, swapping one element for another in a graph representing a molecule could drastically change its chemical structure.

We will see how these pairwise alignments can produce divergence scores suitable for Graph Kernels in Section 4.

3.1. Graph Encoding

To learn the structure of a graph, we train an encoder capable of reconstructing such structure given partial or distorted information. In this paper, we choose a Node-To-Edges encoder (Figure 2) for its simplicity, but we note that additional choices are certainly possible (see Section 7 for more discussion).

Node-To-Edges Encoder

In this setup, an encoder is given a single vertex and it is expected to predict its neighbors. This can be modeled as a multilabel classification task since the predictions are not mutually exclusive. Specifically, we are maximizing the following objective function $J(\theta)$,

[TABLE]

Each vertex $v_{i}$ in the graph is represented by one-hot encoding vector $\vec{v_{i}}$. Then to embed the vertex we multiply its encoding vector with a linear layer $\mathbf{E}\in\mathbb{R}^{|V|\times d}$ resulting in an embedded vertex $\mathbf{e}_{v_{i}}\in\mathbb{R}^{d}$, where $|V|$ is the number of vertices in the graph, and $d$ is the size of the embedding space.

For graphs with a large number of nodes, we can replace this multiplication with a table lookup, extracting one row from the embedding matrix. This embedding vector represents the feature set given to the encoder tasked with predicting all adjacent vertices. Our encoder $H$, is implemented as a fully connected deep neural network (DNN) with an output layer of size $|V|$ and trained as a multilabel classifier.

3.2. Cross-Graph Attention

So far, we have developed a utility to encode individual graphs. However, we seek to develop a method which can compare pairs of graphs, which may differ in size (differing node sets) and structure (differing edge sets). For this to happen we need a method of learning an alignment between the graphs. Ideally this method will operate in the absence of a direct mapping between nodes.

In other areas, attention models have been proposed to align structured data. For example, attention models have been proposed to align pairs of images and text (Xu et al., 2015), pairs of sentences for translation (Vaswani et al., 2017), and pairs of speech and transcription (Chorowski et al., 2015). Inspired by these efforts, we formalize the problem of aligning two graphs as that of attention. We propose an attention mechanism, isomorphism attention, that aligns the nodes of a target graph against those of a source graph.

3.2.1. Isomorphism Attention

Given two graphs $S$ (source graph) and $T$ (target graph), we propose a model that allows bi-directional mapping across the pair’s nodes. This requires two separate attention networks. The first network allows nodes in the target graph to attend to the nodes in the source graph. The second network, allows neighborhood representations in the source graph to attend to neighborhoods in the target graph.

We denote the first attention network as ($\mathcal{M}_{T\rightarrow S}$), which assigns every node in the target graph $(u_{i}\in T)$ a probability distribution over the nodes of the source graph $(v_{j}\in S)$. This attention network will allow us to pass the nodes of the target graph as an input to the source graph encoder. We implement this attention network using a multiclass classifier,

[TABLE]

The second network is a reverse attention network ($\mathcal{M}_{S\rightarrow T}$) which aims to learn how to map a neighborhood’s representation in the source graph to a neighborhood in the target graph. By adding both attention networks to the source graph encoder, we will be able to construct a target graph encoder that is able to predict the neighbors of each node – but utilizing the structure of the source graph. We implement the reverse attention as a multilabel classifier,

[TABLE]

Figure 3 shows the attention network ($\mathcal{M}_{T\rightarrow S}$) receiving a one-hot encoding vector representing a node ($u_{i}$) in the target graph and mapping it onto the most structurally similar node ($v_{j}$) from the source graph. The source graph encoder, then, predicts the neighbors of $v_{j}$, $\mathcal{N}(v_{j})$. The reverse attention network ($\mathcal{M}_{S\rightarrow T}$), takes $\mathcal{N}(v_{j})$ and maps them to the neighbors of $u_{i}$, $\mathcal{N}(u_{i})$.

Both attention networks may be implemented as linear transformations $\mathbf{W}_{A}\in\mathbb{R}^{|V_{Q}|\times|V_{P}|}$. In the case that either $|V_{P}|$ or $|V_{Q}|$ are prohibitively large, the attention network parameters can be decreased by substituting a DNN with hidden layers of fixed size. This will reduce the attention network size from $\Theta(|V_{P}|\times|V_{Q}|)$ to $\Theta(|V_{P}|+|V_{Q}|)$.

3.3. Attributes Consistency

Labeled graphs are not defined only by their structures, but also by the attributes of their nodes and edges. The attention network assigns each node in the target graph a probability distribution over the nodes of the source graph. There might be several, equally good, nodes in the source graph with similar structural features. However, these nodes may differ in their attributes. To learn an alignment that preserves nodes and edges attributes, we add regularizing losses to the attention and reverse-attention networks.

More specifically, we refer to the nodes as $v$ and $u$ for the source and target graphs, respectively. We refer to the set of attributes as $\mathcal{Y}$ and the distribution of attributes over the graph nodes as $(Q_{n}=\Pr(y_{i}\mid u))$. Given that the attention network $\mathcal{M}_{T\rightarrow S}$ learns the distribution $\Pr(u_{k}\mid v_{j})$, we can calculate a probability distribution over the attributes as inferred by the attention process as the following:

[TABLE]

We define, the attention regularizing loss over the nodes attributes to be the average cross entropy loss between the observed distribution of attributes and the inferred one (See Eq. 8).

[TABLE]

where $|V_{T}|$ is the number of nodes in the target graph.

For preserving edge attributes over nodes, we define $Q_{e}(y_{i}\mid u)=\Pr(y_{i}\mid u)$ to be the normalized attributes count over all edges connected to the node $u$. For instance, if a node $u$ has 5 edges with 2 of them colored red and the other three colored yellow, $Q_{e}(red\mid u)=0.4$ By replacing $Q_{n}$ with $Q_{e}$ in Equations 7 and 8, we create a regularization loss for edge attributes.

We also introduce these regularization losses for reverse attention networks. Reverse attention networks maps a neighborhood in the source graph to a neighborhood in the target graph. The distribution of attributes over a node’s neighborhood will be the frequency of each attribute occurrence in the neighborhood normalized by the number of attributes appearing in the neighborhood. For edges, the node’s neighborhood edges are the edges appearing at 2-hops distance from the node. Similarly, we can define the probability of the edges attributes by normalizing their frequencies over the total number of attributes of edges connected to the neighborhood.

4. Deep Divergence Graph Kernels

So far, we have proposed a method for learning representations of graphs, and an attention mechanism for aligning graphs based on a set of encoded graph representations. Here we discuss our proposed method for using the alignment to construct a graph kernel based on divergence scores. First, in Section 4.1, we show how we can utilize the divergence scores to construct a full graph representation. Divergence is driven by the target graph structure and attribute prediction error as calculated using a source graph encoder. Next we introduce DDGK, our method for learning graph representations for Deep Divergence Graph Kernels in Section 4.3. Then in Section 4.4 we discuss how we train these representations. Finally we discuss the scalability of this approach in Section 4.5.

4.1. Graph Divergence

In Section 3 we presented a method to align two graphs by using a source graph encoder, augmented with attention layers, to encode a target graph. Here, we propose to use the ability of the augmented encoder at predicting the structure of the target graph as a measure of those graphs similarity. To explain, let us assume the trivial case where both the source and target graphs are identical. First, we train the source graph encoder. Second, we augment it with attention networks and train it to predict the structure of the target graph. The attention networks will (ideally) learn the identity function. Therefore, the source graph encoder is able to encode the target graph as accurately as encoding itself. We would reasonably conclude that these graphs are similar.

We aim to learn a metric that measures the divergence score between a pair of graphs $\{S,T\}$. If two graphs are similar, we expect their divergence to be correspondingly low. We refer to the encoder trained on a graph $S$ as $H_{S}$ and the divergence score given to the target graph $T$ to be

[TABLE]

Given that $H_{S}$ is not a perfect predictor of the graph $S$ structure, we can safely assume that $\mathcal{D}^{\prime}(S\;\|\;S)\neq 0$. To rectify this problem we define

[TABLE]

which sets $\mathcal{D}(S\;\|\;S)$ to zero.

We note that this definition is not symmetric (as $\mathcal{D}(T\;\|\;S)$ might not necessarily equal to $\mathcal{D}(S\;\|\;T)$). If symmetry is required, we can define $\mathcal{D}(S,T)=\mathcal{D}(S\;\|\;T)+\mathcal{D}(T\;\|\;S)$.

4.2. Graph Embedding

Given a set of source graphs, we can establish a vector space where each dimension corresponds to one graph in the source set. Target graphs are represented as points in this vector space where the value of the $i_{th}$ dimension for a given target graph $T_{j}$ is $\mathcal{D}(T_{j}\;\|\;S_{i})$.

More formally, for a set of $N$ source graphs we can define our target graph representation to be:

[TABLE]

To create a kernel out of our graph embeddings, we use the Euclidean distance measure as outlined in Eq 2. This distance measure will guarantee a positive definite kernel (Haasdonk and Bahlmann, 2004; Wu et al., 2018).

4.3. Algorithm : DDGK

We present pseudo-code for DDGK in Algorithm 1. The algorithm has two parts. First, a Node-To-Edges encoder is trained for all source graphs (Algorithm 1 line 1 and line 1). Second, cross-graph attentions are learned for all target-source graph pairs (Algorithm 1 line 1, line 1 and line 1). We implement DDGK using a deep neural network for its Node-To-Edges encoder and linear transformations for its isomorphism attention.

4.4. Training

We implement our models using TensorFlow (TensorflowTeam, 2015), calculate our gradients using backpropagation, and update our parameters using Adam (Kingma and Ba, 2014). We train each source graph on its adjacency matrix for a constant number of iterations.

4.4.1. Target Graph Encoding

Here, the augmented encoder has to predict the neighboring vertices for each vertex in the target graph with the help of the attention and reverse-attention layers. To learn the augmented target graph encoder (which consists of the source graph encoder with the additional attention layers), we use the following procedure:

1. (1)

First, freeze the parameters of the source graph encoder. 2. (2)

Second, add two additional networks, one for attention and another for reverse attention mapping between the target graph nodes to the source graph nodes and vice versa. 3. (3)

Third, add the regularizing losses to preserve the nodes or edges attributes if they are available. 4. (4)

Fourth, train the augmented encoder on the input, which is the adjacency matrix of the target graph, and a node attribute and/or edge attribute matrix (if available).

Finally, once the training of the attention layers is done, we use the augmented encoder to compute the divergence between the graph pair as discussed in 4.1.

4.5. Scalability

We start by defining the following quantities: $N$ the number of source graphs in the dataset, $M$ the number of target graphs in the dataset, $V$ the average number of nodes, $\tau{}$ the number of epochs to encode source graphs, $\rho{}$ the number of epochs to encode target graphs, $l$ the number of encoder hidden layers, $m$ the number of attention hidden layers, and $d$ the embedding and hidden layer size

Our method relies on pairwise similarity, therefore, we will have $M\times N$ computations that each involves scoring a target graph against one source graph. Training a source graph encoder requires $\tau{}$ steps that each involves $2\times V\times d+l\times d^{2}$ computations. In addition to running the source graph encoder, the target graph alignment learns the attention networks which represents $\rho{}\times(2\times d\times V+m\times d^{2})$. If we define $T=max(\rho{},\tau{})$, $k=max(l,m)$, and $M=N$ then the total computation cost is $\Theta(N^{2}\times T\times(V\times d+k\times d^{2})$. Because $V$ is likely much larger than $d^{2}$, we interpret the computational complexity as $O(TN^{2}V)$.

In Section 5.4, we explore the effect of sampling to hasten DDGK’s runtime on large datasets. We show that not all $M\times N$ comparisons are necessary to achieve high performance: empirically, it seems that less than $20\%$ of source graphs are required, significantly speeding our approach.

5. Experiments

In this section, we demonstrate our method through a series of qualitative and quantitative experiments. First, we show how our attention based alignment works under different conditions. Then, we show how our representations are capable of capturing the structure of the space of graphs by applying hierarchical clustering on the kernel space. Finally, we show that the learned graph embeddings represent a sufficient feature set to predict the graph label on several challenging classification problems in real-world biological datasets.

5.1. Cross-Graph Attention

In this qualitative experiment, we seek to understand how two graphs are related to each other. Comparing different patterns between different graphs is an important application in domains such as biology.

Figure 4(a) shows two identical unlabeled barbell graphs. Each graph consists of two rings of size $5$ connected with the edge ([math], $5$) and ($10$, $15$). The upper graph represents the target graph while the lower one represents the source graph. The edges connecting the source and target graphs represent the strongest attention weights for each node in the target graph. The heatmap shows the full attention matrix for more thorough analysis. Aligning these identical graphs is an easy task for the naked eye. However, our method can find many possible symmetries to exploit while still achieving perfect predictions. For example, nodes in the left ring can attend to the right ring of the source graph and vice versa.

Figure 4(b) shows the previous setup with labeled graph nodes. This introduces a regularizing loss to preserve the node attributes. The attention heat map shows significant weights for the upper left and lower rights quadrants. The right ring does not attend to nodes in the left ring anymore, and vice versa. Still we can see the method exploiting symmetries within the same ring.

Finally, by also adding edge labels, the alignment problem is constrained enough that the attention heatmap is concentrated along the diagonal (See Figure 4(c)). We can observe that the attention edges correspond in a one-to-one relationship between the target and source graphs. This synthetic experiment shows the effect of attribute preserving losses on learning the alignment between graphs.

5.2. Hierarchical Clustering

To understand the global structure of the graph embedding space, we explore it qualitatively using hierarchical clustering. First, we create a dataset which is a composition of 6 different families of graphs. Three graph families are mutated graphs and three families are subset of a larger set of realistic graphs. From each family we sample 5 graphs, creating a universe of 30 graphs. Then, we embed the graphs using our method constructing a graph embedding space. Finally, we cluster the embeddings according to their pairwise euclidean distances.

5.2.1. Mutated Graphs

For these datasets we start with a known graph and generate a sequence of mutations to produce a family of graphs. In particular, we consider the following graphs.

• •

C. Elegans (Watts and Strogatz, 1998): represents the neural network of the C. Elegans worm.

• •

Karate Club (Zachary, 1977): social network of friendships between 34 members of a karate club.

• •

Word Network (Newman, 2006): adjacency network of common adjectives and nouns in the novel David Copperfield by Charles Dickens.

In order to generate a family $G_{1}\cdots G_{k}$ for each original graph $G_{0}$, we employ the following mutation procedure. At each of the $k$ time steps, there is a $p=0.5$ chance of performing an edge deletion or addition. For additions, we select the two nodes to connect from any unlinked nodes according to the preferential attachment model characterized by $G_{0}$ (Chung et al., 2006). For deletions, we select an edge at random and remove it. We run this procedure for 4 times with $k=50$ time steps, creating a family of 5 related graphs. The initial seed for any of these mutations is denoted by the suffix “-0”.

5.2.2. Realistic Graphs

We randomly pick 5 graphs from three of the real-world families of graphs we consider (D&D, PTC, and NCI1). See Section 5.3.2 for more information about these graphs.

Figure 5 shows the result of clustering the pairwise distances between our graph embeddings. We are able to retrieve perfect clusters of {c-elegans, words} where there are clusters of size of 5 that consist only of graphs of the same type. For {NCI1, D&D}, we can cluster 4 graphs out of 5 before adding a graph which is out of the family.

5.3. Graph Classification

Our learned graph representations respect both attributes and structure. They can be used for graph classification tasks where the graph structure, node attributes, and/or edge attributes convey meaning or function. To demonstrate this, we use DDGK representations of several chemo- and bio- informatics datasets as features for classification tasks. We report our results against both unsupervised and supervised methods.

5.3.1. Hyper-parameters Search

To choose DDGK hyperparameters (See Table 1), we perform grid searches for each dataset. We create splits of each dataset to avoid over-fitting, they are: {train, dev, test}. We use the scikit-learn SVM (Pedregosa et al., 2011) as our classifier, and we vary the kernel choices between {linear, rbf, poly, sigmoid} and the regularization coefficient $C$ between $10$ and $10^{9}$. We choose the hyper-parameters of both DDGK and the classifier that maximize the accuracy on the dev dataset.

5.3.2. Datasets

Four benchmark graph classification datasets from chemo- and bio-informatics domains are used. The datasets include D&D, NCI1, PTC and MUTAG. All datasets include node labels. The PTC and MUTAG datasets also include edge labels. Table 2 shows network statistics for each dataset. The datasets:

• •

D&D (Dobson and Doig, 2003): contains 1178 proteins labeled as enzymes or non-enzymes.

• •

NCI1 (Wale and Karypis, 2006): contains 4110 chemical compounds labeled as active or inactive against non-small cell lung cancer.

• •

PTC (Toivonen et al., 2003): contains 344 chemical compounds labeled according to their carcinogenicity in male rats.

• •

MUTAG (Debnath et al., 1991): contains 188 mutagenic aromatic and heteroaromatic compounds labeled according to their mutagenic effect on a specific gram negative bacterium.

5.3.3. Results

The results of these experiments are presented in Table 3. We see that DDGK is quite competitive, with higher average performance on both the D&D and MUTAG datasets than any of the baselines. This is especially surprising given that the supervised methods have additional information available to them. We note that DDGK achieves its strong results without engineered features, or access to information from Weisfeiler-Lehman kernels. For PTC, we also see that DDGK attains competitive performance against all other methods, only being outperformed by 2 of the 9 baselines. Finally, on NCI1, we see that DDGK performs better than the method using the most similar kind of information (node2vec), but find that baselines using the WL kernel perform best on this dataset (indeed, the WL kernel itself takes the top two spots). We find this dependence quite interesting, and will seek to characterize it better in future work.

5.4. Dimension Sampling

So far, we have been setting the source graphs set to be equal to the target graphs set. This pairwise computation is quite expensive for large datasets. To reduce the computational complexity of our method, we study the effect of sub-sampling the dimensions of our graph embedding space on the quality of graph classification.

To do that, we construct a source graph set that is a subset of the original graph set. We learn divergence scores for all target graphs against this subset. We use the reduced embeddings as features to predict graph categories. Figure 6 shows that we are able to achieve stable and competitive results with less than 20% of the graphs being used as source graphs.

6. Related Work

The main differences between our proposed method and previous work can be summarized as follows:

1. (1)

We are an unsupervised method, taking only a graph as input. 2. (2)

We use no domain-specific information about what primitives are important in a graph, using only the edges. 3. (3)

We use no algorithmic insights from the literature in graph isomorphism (e.g. the Weisfeiler-Lehman kernel). 4. (4)

We assume nothing about the mapping of node ids between graphs, instead learning the alignment.

While many approaches exist that contain at least one of these differentiators, we are, to the best of our knowledge, the only proposed method that meets all four of these conditions. In this section we will briefly cover related work in graph similarity and other applications of neural networks to graph representation.

6.1. Unsupervised Graph Similarity

We divide our brief survey of the literature into three kinds of unsupervised methods for graph similarity. The first seeks to explicitly define a kernel over graph features, or use the intuition from such a kernel as part of the representation learning process. The second focuses on the representation of individual elements of the graph, learning primitives that maximize some kind of reconstruction of the graph. The third group of work constructs a similarity function between graphs by an explicit vector of statistical features constructed by the graph.

Traditional Graph Kernels: There has been considerable work done on unsupervised methods for graph kernel learning. Initial efforts in the area focused on theoretical views of the problem, defining graph similarity via the Graph Edit Distance (Gao et al., 2010) or the size of the Maximum Common Subgraph (Bunke et al., 2002) between graphs. Unfortunately these problems are both NP-Complete in the general case, require a known correspondence between the nodes of the two graphs of interest.

Many approaches are built around the graph similarity measure computed by the Weisfeiler-Lehman (WL) subtree graph kernel (Shervashidze et al., 2011; Kriege et al., 2016). At its core, the WL algorithm collapses the labels of a node’s neighbors into a ordered sequence, and then hashes that sequence into a new label for the node. This process repeats iteratively to average information over the neighborhood together. Other functions that use different types of predefined features for graph similarity, such as shortest-paths kernels (Borgwardt and Kriegel, 2005), and random walk kernels (Kashima et al., 2003) have also been proposed, but their naive implementations suffer from high asymptotic complexity ($O(n^{4})$ and $O(n^{6})$, respectively). Faster implementations of these kernels have been proposed (Borgwardt et al., 2007; Kang et al., 2012). Some unsupervised methods also focus on extending the algorithm intuition of these classic approaches to the problem. For instance (Taheri et al., 2018) learns a representation for each position in a WL ordering jointly while learning a graph representation.

Unlike all of these approaches, our method deliberately avoids algorithmic insights. Our proposed isomorphism attention mechanism allows capturing higher-order structure between graphs (beyond immediate neighborhoods).

Node embedding methods: Since DeepWalk (Perozzi et al., 2014) proposed embedding the nodes via a sequence of random walks, the problem of node representation learning has received considerable attention (Perozzi et al., 2017; Grover and Leskovec, 2016; Chen et al., 2018b; Tsitsulin et al., 2017; Bojchevski and Günnemann, 2017; Abu-El-Haija et al., 2018; Epasto and Perozzi, 2019). In general, all of these methods utilize insights about similarity functions which are important to the graph. While these methods seek the best way to represent nodes, the representations are learned independently between graphs, which makes them generally unsuitable for graph similarity computations. For more information on this area, we recommend recent surveys in the area (Chen et al., 2018a; Cui et al., 2018). Unlike these methods, our goal is to learn representations of graphs, not of nodes.

Graph statistics: Finally, another family of unsupervised graph similarity measures define a hand-engineered feature vector to compute graph similarity. The NetSmilie method (Berlingerio et al., 2012) operates by constructing a fixed size feature value of graph statistics and uses this as a similarity embedding over graphs. Similarly, DetlaCon (Koutra et al., 2013) defines the similarity over two graphs with known node-to-node mapping via the similarity in their propagation of belief, and (Papadimitriou et al., 2010) proposes a number of similarity measures over directed web graphs.

Unlike these methods, DDGK does not explicitly engineer its features for the problem. Instead, the similarity is learned function directly from the edges present in the adjacency matrix, with no assumptions about which features are important for the application task.

6.2. Supervised Graph Similarity

The first class of supervised methods uses some supervision to inform a similarity function constructed over different hand-engineered graph features.

A number of supervised approaches also utilize intuitions from the Weisfeiler-Lehman graph kernel. Patchy-SAN (Niepert et al., 2016b) proposes an approach for convolutional operations on graph structured data. The core of their method uses the ordering from the WL kernel to order the nodes of a rooted subgraph into a sequence, and then apply standard 1-dimensional convolutional filters. This approach is further generalized by (Zhang et al., 2018), who use the WL ordering to sort a graph sample in a pooling layer. Another branch of work has focused on extending the Graph Convolutional Networks (GCNs) proposed by (Kipf and Welling, 2016) to perform supervised classification of graphs. Proposed extensions include a pooling architecture that learns a soft clustering of the graph (Ying et al., 2018), or a two-tower model which frames graph similarity as link prediction between GCN representations (Bai et al., 2018). Interestingly, it has been shown that many of these methods are not necessarily more expressive than the original Weisfeiler-Lehman subtree kernel itself (Morris et al., 2018).

Unlike all of these approaches, our method learns representations of graphs without supervision — we use no labels about the class label of a graph, and no external information about which pairs of graphs are related. Our proposed isomorphism attention mechanism allows capturing higher-order structure between graphs (beyond immediate neighborhoods).

7. Extensions & Future Work

Here we briefly discuss a number of areas of future investigation for our method.

7.1. Graph Encoders

Given the choice of input and reconstructed output, several additional graph encoders are possible, in addition to the Nodes-To-Edges encoder which we used in this work. To mention a few options:

Edge-To-Nodes Encoder

This encoder is trained to predict the source and destination vertices given a specific edge. Similar to the Node-To-Edges encoder, this could be expressed as a multilabel classification task with the following objective function,

[TABLE]

Note that the number of edges in a graph could grow quadratically, therefore, iterating over the edges is more expensive than the nodes.

Neighborhood Encoder

In this case, the encoder is trained to predict a set of vertices or edges that are beyond the immediate neighbors. Random walks could serve as a mechanism to calculate a neighborhood around a specific node or edge. Given a partial random walk, the encoder has to predict the vertices that could have been visited within a specific number of hops.

[TABLE]

7.2. Attention Mechanism

We proposed a simple attention mechanism which uses node-to-node alignment. As we discussed in Section 4.5, we could replace the linear layer with a deep neural network to reduce the size of the model if scability is an issue. While node-to-node alignment enhances the interpretability of our models, subgraph alignment could lead to better and easier understanding of how two graphs are similar. Hierarchical attention models (Yang et al., 2016) could lead to higher levels of abstractions which could learn community structure and which communities are similar across a pair of graphs. Hierarchy has already been used within the context of learning better node embeddings, for example (Ying et al., 2018) showed that a better understanding of the graph substructure can lead to better graph classification. Therefore, we believe extending the work beyond node-to-node alignment will significantly improve our results.

7.3. Regularization

We proposed attribute based losses to regularize our isomorphism attention mechanism. The graph encoder capacity was adjusted according to the source graph size. However, the source graph encoder could still suffer from overfitting which would reduce its utility in recognizing similar target graphs. Therefore, further research is necessary to understand the relation between the encoder training characteristics and the quality of the generated divergence scores

7.4. Feature Engineering

In this work we have focused on developing an approach for representing graphs that operated without any feature engineering or algorithmic insights. While this willful ignorance has allowed us to design a new paradigm for graph similarity, we suspect that there are many fruitful combinations of this idea with other approaches for graph classification. For example, the graph embeddings we learn could be used as additional features for approaches based on learning supervised classifiers over graphs.

8. Conclusion

In this work, we have shown that neural networks can learn powerful representations of graphs without explicit feature engineering. Our proposed method, Deep Divergence Graph Kernels, learns an encoder for each graph to capture its structure, and uses a novel isomorphism preserving attention mechanism to align node representations across graphs without the use of supervision. We show that representing graphs by their divergence from different source graphs provides a powerful embedding space over families of graphs. Our proposed model is both flexible and amenable to extensions. We illustrate this by proposing extensions to handle many commonly occurring varieties of graphs, including graphs with attributed nodes, and graphs with attributed edges.

Our experimental analysis shows that despite being trained with only the graph’s edges (and no feature engineering) the learned representations encode a variety of local and global information. When the representations produced by DDGK are used as features for graph classification methods, we find them to be competitive with challenging baselines which use at least one of graph labels, engineered features, or the Weisfeiler-Lehman framework. In addition to being powerful, DDGK models are incredibly informative. The learned isomorphism attention weights allow a level of insight into the alignment between a pair of graphs, which is not possible with other deep learning methods developed for graph similarity.

Unsupervised representation learning for graphs is an important problem, and we believe that the method of Deep Divergence Graph Kernels we have introduced here is an exciting step forward in this area. As future work, we will investigate 1) enhanced method for choosing informative source from the space of all graphs, 2) improving the architecture of our encoders and attention models, 3.) making it easier to reproduce research results in the area of graph similarity, and 4) making graph similarity models even easier to understand.