A Multi-scale Graph Signature for Persistence Diagrams based on Return Probabilities of Random Walks

1 Introduction

Persistent homology is a commonly used tool in the field of Topological Data Analysis, which is designed to track topological changes as data is examined at different scales. Its main descriptor is the persistence diagram (PD), often represented as a multiset of birth and death pairs of topological features. Since it can encode topological and geometrical properties of the data, it is potentially complementary to features retrieved by other classical descriptors. Applications of PD have been found in different fields, from signal analysis to 3D shape classification [perea2015sliding, buchet2018persistent, li2014persistence, carriere2015stable, saggar2018towards, suh2019persistent, pranav2017topology, kannan2019persistent].

A recent line of research is primarily aimed at leveraging PD in the task of graph classification. Given a graph signature on vertices of the graph, one can construct a sublevel filtration from the nested sequence of increasing subgraphs. The PDs obtained from this filtration process can be used in machine learning tasks by constructing a kernel, such as sliced Wasserstein kernel [carriere2017sliced] and Fisher kernel [le2018persistence]

, or associating them to a vector space, such as persistence landscape

[bubenik2015statistical] and persistence image [adams2017persistence]. However, kernel methods require evaluation for each pair of graphs thus do not scale well to the size of the dataset, and vectorization methods are usually non-parametric or have a few trainable parameters, resulting in suffering from being agnostic to the type of application. For more scalability and flexibility, a deep learning model that operates on sets can be used directly on PDs [hofer2017deep, carriere2019perslay].

In this paper, we focus on graph classification using PDs from a deep learning perspective. A majority of prior works rely on a scalar node descriptor, such as node degree [hofer2017deep] or heat kernel signature [carriere2019perslay], to construct the filtration, where the choice is often empirical. However, a multi-dimensional embedding is usually preferred to describe a graph node. While multi-dimensional persistence has been studied [carlsson2009theory, lesnick2015theory], it exhibits an essentially different character from its one-dimensional version and is often complicated to generalize corresponding concepts, such as persistence diagrams, making it nontrivial to utilize them in downstream models. Instead, we explore the potential of leveraging multiple PDs for each data sample based on a family of multi-scale graph signatures: the $k$ -step return probabilities of random walks, where $k$ is the number of random steps from a starting node, indicating the size of the local structure being explored. For example, 2-hop random walk can help to capture the neighborhood size of surrounding nodes, while 3-hop can capture circles in the graph. The idea is that different scales help the model capture more information about its neighborhood, which in turn can help improve the model’s performance. The return probability feature has been used as a node structural role descriptor to construct a kernel for graph classification [zhang2018retgk]. We show that with an appropriate application and model architecture, it can also be useful in topology-based approaches.

Our contributions are as follows. First, we propose a family of scalar graph signatures based on the return probability of random walks to construct multiple PDs per data sample. The PDs are padded to a fixed size and stacked together to form a multi-channel input. Second, we introduce RPNet, a deep neural network architecture designed to learn from the proposed features. We demonstrate our method on a wide range of benchmark datasets and observe that it often outperforms other persistence diagram-based and neural network-based approaches, while being competitive with state-of-the-art graph kernel methods.

The rest of this paper is organized as follows. Section 2 and Section 3 briefly go through some related work and background. Section 4 describes our proposed graph signature and network architecture. Section 5 and Section 6 present our experiments and results. Finally, we discuss future directions in Section 7.

2 Related Works

Since PDs have an unusual structure for machine learning approaches, many techniques have been proposed to map them into machine learning compatible representations. A popular technique is vectorization. For instance, Bubenik et al. [bubenik2015statistical] propose mapping persistence barcodes into a Banach space, referred to as persistence landscape. Adams et al. [adams2017persistence] propose persistence image, which is a discretization of the persistence surface. Another approach is constructing a kernel from PDs. For example, the sliced Wasserstein kernel [carriere2017sliced], or persistence Fisher kernel [le2018persistence] are designed to work on PDs. Rieck et al. [rieck2019persistent] define a kernel constructed from a vector representation of persistence diagram through the Weisfeiler-Lehman subtree feature. While these methods make it much easier to deploy machine learning techniques, they are pre-defined and thus often suboptimal to a specific task.

Learning representation has been investigated to provide a task-optimal representation in the vector space for PDs. Hofer et al. [hofer2017deep] and Carriere et al. [carriere2019perslay] propose a deep learning architecture designed to handle sets of points in PDs. Zhao et al. [zhao2019learning] propose a weighted kernel for persistence image. These methods have been proven to perform well on a wide range of benchmarks.

In these works, a specific node descriptor is usually required for the filtration process. Some of the simple choices include node degree [hofer2017deep] or the node attributes if available [rieck2019persistent]. More complicated descriptors include the heat kernel signature [carriere2019perslay]

, Ricci-curvature & Jaccard-index

[zhao2019learning]. For non-attributed graphs, [rieck2019persistent] uses a stabilization procedure based on node degree to leverage more topological information.

Our work employs a similar approach in [hofer2017deep, carriere2019perslay] to propose a deep learning architecture that contains pooling layers to learn from multiset inputs. Different from prior works, our architecture is able to handle multiple PDs for each data sample, each computed from a node descriptor in the proposed family of graph signatures.

3 Background

We briefly mention the concepts and refer interested readers to [edelsbrunner2010computational, aktas2019persistence] for more detailed definitions of homology.

3.1 Simplices and Simplicial Complexes

Simplices

are higher dimensional analogs of points, line segments, and triangles, such as a tetrahedron. Formally, an $i$ -simplex $σ$ is the convex hull of $i + 1$ affinely independent points, i.e., a set of all convex combinations $λ_{0} v_{0} + λ_{1} v_{1} + \dots + λ_{i} v_{i}$ where $λ_{0} + λ_{1} + \dots + λ_{i} = 1$ and $λ_{j} \leq 1$ for all $j \in {0, 1, \dots, i} .$ For example, a 0-simplex is a single point $a_{0}$ (the vertex), a 1-simplex is a line segment $(a_{0}, a_{1})$ (the edge), and a 2-simplex is a triangle $(a_{0}, a_{1}, a_{2})$ with its interior (Figure 1). Simplices are the building blocks of simplicial complexes.

Figure 1: Examples of simplices. From left to right: a vertex, an edge, a triangle, and a tetrahedron

Simplicial Complexes

A simplicial complex is a finite collection of simplices $K$ such that (1) given a simplex $σ \in K$ , a face $τ \leq σ$ implies $τ \in K$ , and (2) two simplices $σ_{0}, σ_{1} \in K$ implies $σ_{0} \cap σ_{1}$ is either empty or a common face of both. The dimension of $K$ is the maximum dimension of any of its simplices. The first condition states that if a simplex is in $K$ , then its faces are also in $K$ . For the second condition, we are only allowed to glue simplices by their common faces to avoid no improper intersections (Figure 2).

Figure 2: left: simplicial complex created by 0-, 1-, and 2-simplicies; middle: not a simplicial complex since the intersection of the two triangles is not an edge; right: not a simplicial complex because of missing an edge

3.2 Persistence Diagrams of Graphs

Figure 3: 0-dimensional and 1-dimensional persistent homology on a graph based on node-degree filtration. (a) Given an input graph, the persistence diagrams are computed by persistent homology; (b) More details on the computation: The growth process of the graph by time steps and its corresponding bar codes. At the first time step (time step 0), there is no node and edge. At the next time steps, nodes and edges start to appear. The bar codes represent the persistence diagrams (birth, death).

Consider a graph $G = (V, E)$ with $n$ nodes, $m$ edges and a node descriptor function $ω : V \to R$ . First, we use the descriptor to label the vertices in $G$ . These labels are used as threshold values to define the sublevel graph $G_{α} = (V_{α}, E_{α})$ where $α \in R$ , $V_{α} = {v \in V : ω (v) \leq α}$ and $E_{α} = {(u, v) \in E : u, v \in V_{α}}$ . This provides a nested family of simplicial complexes $G_{α_{0}} \subseteq G_{α_{1}} \subseteq . . . \subseteq G_{α_{n}} \subseteq G_{α_{n + 1}}$ where $α_{0} = - \infty$ , $α_{n + 1} = + \infty$ , $α_{1} \leq α_{2} \leq \dots \leq α_{n}$ are weights assigned nodes sorted in increasing order. $(G_{α_{i}})_{i = 0}^{n + 1}$ , starting with the empty graph and ending with the full graph $G$ , is called a filtration of $G$ . During this construction, some holes may appear and disappear; in other words, the time of appearance and disappearance of topological features such as loops, and connected components are recorded. When a component first appears, its birth is kept track of, and when it gets merged into another component, we record the death. Such homological features can be considered the graph feature. Specifically, these intervals are persistence diagram that consists of the birth and death time of the feature as points (birth, death) in $R^{2}$ . Figure 3 illustrates 0-dimensional and 1-dimensional persistence barcodes and the corresponding persistence diagram of the filtration on a simple input graph. For each vertex $v_{i}$ , its node degree is used as the node descriptor $ω (v_{i}) = \sum_{j} A_{i, j}$ , where $A$ is the adjacency matrix of $G$ .

3.3 Return Probabilities of Random Walks

Consider an undirected graph $G = (V, E)$ . Let $A$ be the adjacency matrix of $G$ and $D$ be the degree matrix, i.e. a diagonal matrix with $D_{i, i} = \sum_{j} A_{i, j}$ .

A $k$ -step walk starting from node $v_{i}$ is a sequence of nodes ${v_{i}, v_{i + 1}, v_{i + 2}, \dots, v_{i + k}}$ , with $(v_{j}, v_{j + 1}) \in E$ , where $i \leq j < i + k$ . A random walk on $G$

is a Markov chain

(X_{0}, X_{1}, X_{2}, \dots)

, whose transition probabilities are

Pr (X_{i + 1} = v_{i + 1} ∣ X_{i} = v_{i}, \dots, X_{0} = v_{0}) = Pr (X_{i + 1} = v_{i + 1} ∣ X_{i} = v_{i}) = \frac{A_{i, j}}{D_{i, i}}

The transition probability matrix is calculated by $P = D^{- 1} A$ . The $k$ -hop transition probability matrix is $P^{k}$ , where $P_{i, j}^{k}$ denotes the transition probability in $k$ steps from node $v_{i}$ to $v_{j}$ . The return probability of random walks is defined as $P_{G, i} (k | i)$ , which is the probability to return the source node after $k$ hops. When $k = 0$ , all the probabilities are equal to $0$ .

A straightforward way to calculate a transition probability matrix $k$ requires $(k - 1) \times n \times n$ matrix multiplication of $P$ , which is $O ((k - 1) n^{3})$ in time complexity. We are only interested in the diagonal elements, thus the matrix can be computed more efficiently and the time complexity can be reduced to $O (n^{3} + (k + 1) n^{2})$ [zhang2018retgk]. The calculation of all the $k$ -hop transition probability matrix with $k \in {1, . . ., K}$ takes time $O (n^{3} + (K + 1) n^{2})$ , allowing computation to be scalable to large graphs.

3.4 Deep Learning with Sets

Most machine learning algorithms take fixed-size vectors as input. They are not designed for data in the form of sets. In contrast to vectors, sets are invariant to permutation and have a variable length. Thus, dealing with this type of input is a challenging and non-trivial task. There has been some research aimed at tackling this problem by employing permutation-invariant functions that have two desirable characteristics: invariant to the ordering of the inputs and ability to handle variable-size inputs [zaheer2017deep, rezatofighi2017deepsetnet, xu2018spidercnn]. Specifically, a permutation invariant function $L$ in $R^{p}$ is defined

L ({x_{1} \dots x_{n}}) = ρ (n \sum i = 1 ϕ (x_{i}))

where $ϕ : R^{p} \to R^{q}$ , $n$ is the number of points, and $ρ : R^{q} \to R^{q}$ . For example, average-pooling and sum-pooling are two pre-defined permutation invariant functions that are commonly used to handle sets [kipf2016semi, hamilton2017inductive, atwood2016diffusion].

4 Proposed Method

In this section, we describe our approach to using the return probabilities of random walks for topological graph representation and propose our neural network architecture, referred to as RPNet. Let $G = (V, E)$ be an undirected graph, where $V$ is the set of vertices and $E$ is the set of edges connecting two vertices, we define a set of $K$ descriptors ${RP}_{k}$ on $V$ , where ${RP}_{k} (v)$ represents the $(k + 1)$ -hop return probabilities of random walk starting from the vertex $v$ , with $k \in [1, K]$ . The higher value of $k$ , the larger a subgraph is considered. By definition:

{RP}_{k} (v_{i}) = {[(D^{- 1} A)^{k}]}_{i, i}^{- 1}

where $A$ is the adjacency matrix, $D$ is the degree matrix, and $v_{i}$ is the $i$ -th vertex in $G$ .

PDs Computation and Processing

Using the sublevel filtration based on each of $K$ node descriptors ${RP}_{k}$ , we can compute $K$ 0,1-dimensional PDs for each graph $G$ . We split points in these diagrams into three groups: 0-homology essential points (0-homology points whose death is infinite), 0-homology non-essential points (0-homology points whose death is finite) and 1-homology essential points (1-homology points whose death is infinite). Note that 1-homology does not disappear since we do not consider higher degree homology; therefore, 1-homology non-essential point (1-homology points whose death is finite) does not exist. We normalize these points to the range $[0, 1]$ by dividing them by the maximum coordinate (i.e., birth, death) value ( $+ \infty$ is also mapped to 1), and add a 3-dimensional one-hot vector characterizing each group. Thus, each point is represented by a vector in $R^{5}$ : birth, death, and 3-d one-hot vector. After this process, we obtain $K$ sets of 5-dimensional vectors. These sets can vary in size (for example, in Fig. 4, with $k = 1$ , the first set has 6 points (blue), while $k = 2$ gives 5 points (yellow)), thus we pad them to have the same number of elements, $L$ , in each set. The final resulting output is a feature $X \in R^{K \times L \times 5}$ for each graph $G$ . Figure 4 illustrates this process on a simple graph.

Figure 4: Procedure to generate and process $K$ (e.g., $K = 2$ ) persistence diagrams from a graph using return probabilities of random walks: We first use each return probability of random walk to label the nodes of the graph, which are used to generate pairs of (birth, death), then stack them together with 3-d one-hot vectors to obtain the features.

4.1 Network architecture

Figure 5: Overview architecture of RPNet - our proposed neural network

We propose RPNet, a neural network operating on the extracted features. The network consists of an encoder, a decoder, a point pooling layer, a diagram pooling layer, and a classification head. First, the encoder maps each point into a $d^{'}$ -dimensional space:

E_{point} = Encoder (X) \in R^{K \times L \times d^{'}}

Next, we concatenate the encoded feature $E_{point}$ with the 3-d one-hot vectors to obtain $E_{point}^{'} \in R^{K \times L \times (d^{'} + 3)}$ . We then pass it to a decoder to map each point into $d$ -dimensional space:

D_{point} = Decoder (E_{% point}^{'}) \in R^{K \times L \times d}

The point pooling layer performs sum pooling on points in each diagram, and the diagram pooling layer performs weighted pooling on diagrams for each graph.

X_{diagram} = L \sum l = 1 D_{point} [:, l, :]

X_{graph} = K \sum k = 1 softmax (w)_{k} X_{diagram} [k, :]

The classification head is a multi-layer perceptron on the embedding of each graph, followed by a softmax function to output the class probabilities.

Y = softmax (MLP (X_{graph}))

Our network is optimized with the cross-entropy loss. Figure 5 demonstrates the architecture of our proposed neural network.

5 Experiments

Setup

We use persistence diagrams up to degree 1 for each $k = 1, . . ., K$ as inputs to our model. We follow the conventional settings for graph classification as described in previous works [hofer2017deep, carriere2019perslay]

. Specifically, we perform a 10-fold cross-validation (9 folds for training and 1 fold for testing) for each run. We train each model for at most 500 epochs and report the average accuracy and standard deviation on the epochs that have the lowest loss of each fold. Training is terminated after 50 non-decreasing epoch losses. Adam optimizer

[kingma2014adam] is used with an initial learning rate between the range of 0.001 to 0.01, and a decay factor of 0.5 after every 25 epochs up to 6 times. For the encoder and decoder, we use several blocks of four following components: Linear Layer, Norm Layer (e.g., BatchNorm [ioffe2015batch], LayerNorm [ba2016layer]), Dropout [srivastava14a]

, and Activation Layer (e.g., ReLu

[agarap2018deep], ELU [clevert2015fast]) in that order. We fine-tune the number of blocks (from 2 to 5) and their dimensions in the encoder, along with the learning rate. We report the best scores for each variant of our models, denoted as RPNet-

K

, where

K \in {1, 2, 4, 8}

represents the number of return probabilities of random walks that are used to generate the multi-scale graph representation. It is worth noting that all the baselines we compare with follow the same setup, thus it is a fair comparison.

Datasets

	#graphs	avg #nodes	avg #edges	#classes
MUTAG	188	17.93	19.79	2
PROTEINS	1113	39.06	72.82	2
NCI1	4110	29.87	32.30	2
NCI109	4127	29.68	32.13	2
PTC_FM	349	14.11	14.48	2
PTC_FR	351	14.56	15.00	2
PTC_MM	336	13.97	14.32	2
PTC_MR	344	14.29	14.69	2
COX2	467	41.22	43.45	2
DHFR	756	42.43	44.54	2
REDDIT-BINARY	2000	429.6	497.8	2
IMDB-BINARY	1000	19.77	96.53	2
COLLAB	5000	74.49	2457.78	3
IMDB-MULTI	1500	13.00	65.94	3
REDDIT-5K	4999	508.5	594.9	5
REDDIT-12K	11929	391.4	456.9	12

Table 1: Descriptions of datasets used in our experiments

We evaluated our proposed method in graph classification tasks on 16 graph benchmark datasets from different domains such as small chemical compounds or protein molecules (e.g., COX2, PROTEIN), and social networks (e.g., REDDIT-BINARY, IMDB-M). We group these datasets into two categories: (1) Datasets with less than 1,000 graphs, or less than 100 vertices per graph on average, and (2) Datasets with more than 1,000 graphs and more than 100 vertices per graph on average. It is worth noting that while most of the datasets consist of an adjacency matrix, some bioinformatic datasets also provide categorical node attributes. The aggregate statistics of these datasets are provided in Table 1¹¹1More details can be found at https://ls11-www.cs.tu-dortmund.de/staff/morris/graphkerneldatasets.

	MUTAG	PROTEINS	NCI1	NCI109	PTC-MR	PTC-FR	PTC-MM	PTC-FM	COX2	DHFR
WL $^{1}$	82.1	-	82.2	82.5	-	-	-	-	-	-
RetGK $^{1}$	90.3 $\pm$ 1.1	75.8 $\pm$ 0.6	84.5 $\pm$ 0.2	-	62.5 $\pm$ 1.6	66.7 $\pm$ 1.4	65.6 $\pm$ 1.1	62.3 $\pm$ 1.0	-	-
GCAPS $^{2}$	-	76.4 $\pm$ 4.1	82.7 $\pm$ 2.4	81.1 $\pm$ 1.3	-	-	-	-	-	-
PersLay $^{2, 3}$	89.8 $\pm$ 0.9	74.8 $\pm$ 0.3	73.5 $\pm$ 0.3	69.5 $\pm$ 0.3	-	-	-	-	80.9 $\pm$ 1.0	80.3 $\pm$ 0.8
SV $^{1, 3}$	88.2 $\pm$ 1.0	72.6 $\pm$ 0.4	71.3 $\pm$ 0.4	69.8 $\pm$ 0.2	-	-	-	-	78.4 $\pm$ 0.4	78.8 $\pm$ 0.7
P-WL $^{1, 3}$	86.1 $\pm$ 1.4	75.3 $\pm$ 0.7	85.3 $\pm$ 0.1	84.8 $\pm$ 0.2	63.1 $\pm$ 1.5	67.3 $\pm$ 1.5	68.4 $\pm$ 1.2	64.5 $\pm$ 1.8	-	-
P-WLC $^{1, 3}$	90.5 $\pm$ 1.3	75.3 $\pm$ 0.4	85.5 $\pm$ 0.2	85.0 $\pm$ 0.3	64.0 $\pm$ 0.8	67.2 $\pm$ 1.1	68.6 $\pm$ 1.8	65.8 $\pm$ 1.2	-	-
RPNet-1	89.4 $\pm$ 4.0	74.5 $\pm$ 4.5	73.5 $\pm$ 1.1	70.7 $\pm$ 1.6	60.8 $\pm$ 5.3	66.7 $\pm$ 3.6	64.9 $\pm$ 5.5	63.3 $\pm$ 6.8	81.8 $\pm$ 3.0	76.3 $\pm$ 3.6
RPNet-2	90.9 $\pm$ 3.3	75.8 $\pm$ 3.3	73.9 $\pm$ 2.5	71.1 $\pm$ 1.7	60.7 $\pm$ 4.6	68.1 $\pm$ 7.3	66.7 $\pm$ 4.8	63.3 $\pm$ 5.3	82.4 $\pm$ 2.7	75.5 $\pm$ 4.0
RPNet-4	91.0 $\pm$ 3.4	75.4 $\pm$ 2.6	72.1 $\pm$ 1.8	70.0 $\pm$ 1.9	62.5 $\pm$ 6.1	66.7 $\pm$ 4.0	63.7 $\pm$ 4.9	64.5 $\pm$ 6.1	81.6 $\pm$ 3.5	81.3 $\pm$ 3.0
RPNet-8	91.0 $\pm$ 4.0	74.2 $\pm$ 2.8	72.6 $\pm$ 1.9	70.4 $\pm$ 1.6	59.6 $\pm$ 7.1	66.4 $\pm$ 4.6	65.5 $\pm$ 4.5	62.2 $\pm$ 7.8	79.9 $\pm$ 2.7	80.7 $\pm$ 2.6

Table 2: Classification results (accuracy and standard deviation) on dataset group 1. The best-performing results are highlighted in boldface. Note

^{1}

: graph kernel,

^{2}

: graph neural network,

^{3}

: method based on persistence homology. We use "-" to indicate that the dataset was not used in the baseline paper.

		COLLAB	RD-B	RD-M5K	RD-M12K	IMDB-B	IMDB-M
Neural Net	GCAPS	77.7 $\pm$ 2.5	87.6 $\pm$ 2.5	50.1 $\pm$ 1.7	-	71.7 $\pm$ 3.4	48.5 $\pm$ 4.1
	PersLay	76.4 $\pm$ 0.4	-	55.6 $\pm$ 0.3	47.7 $\pm$ 0.2	71.2 $\pm$ 0.7	48.8 $\pm$ 0.6
	DeepTopo	-	-	54.5	44.5
Ours	RPNet-1	69.2 $\pm$ 2.9	91.4 $\pm$ 1.8	56.9 $\pm$ 2.2	48.5 $\pm$ 0.8	69.6 $\pm$ 4.2	45.9 $\pm$ 3.9
	RPNet-2	70.0 $\pm$ 2.2	91.6 $\pm$ 2.0	57.6 $\pm$ 2.4	48.5 $\pm$ 1.0	68.3 $\pm$ 3.9	46.8 $\pm$ 3.1
	RPNet-4	71.8 $\pm$ 2.5	91.7 $\pm$ 1.9	57.2 $\pm$ 2.1	48.4 $\pm 1.0$	71.9 $\pm$ 4.4	47.7 $\pm$ 2.9
	RPNet-8	73.4 $\pm$ 1.8	90.4 $\pm$ 2.1	56.4 $\pm$ 2.1	48.3 $\pm$ 1.2	70.7 $\pm$ 3.8	48.9 $\pm$ 2.9
Graph Kernel	RetGK	81.0 $\pm$ 0.3	92.6 $\pm$ 0.3	56.1 $\pm$ 0.5	48.7 $\pm$ 0.2	71.9 $\pm$ 1.0	47.7 $\pm$ 0.2
	WKPI	-	-	59.5 $\pm$ 0.6	48.4 $\pm$ 0.5	75.1 $\pm$ 1.1	49.5 $\pm$ 0.4
	SV	79.6 $\pm$ 0.3	87.8 $\pm$ 0.3	53.1 $\pm$ 0.2	-	74.2 $\pm$ 0.9	49.9 $\pm$ 0.3

Table 3: Classification results (accuracy and standard deviation) on dataset group 2. The best performances of our methods and other methods are highlighted in boldface. Note: "-" indicates the dataset was not used in the baseline paper.

Baselines

We compare our results with WL subtree [shervashidze2011weisfeiler], RetGK [zhang2018retgk]; deep learning-based approaches GCAPS [verma2018graph], PersLay [carriere2019perslay], DeepTopo [hofer2017deep]; Kernel-based methods with topological features: SV [tran2018scale], P-WL and P-WLC [rieck2019persistent], WKPI [zhao2019learning]. For the above-mentioned baselines, we report their accuracies and standard deviations (if available) in the original papers, following the same evaluation setting. Some of our datasets were not used in certain papers (but used by others), we denote this by "-" or leave out the method if it did not use any of the datasets in the resulting table.

Implementation

Models are implemented in Pytorch

[paszke2019pytorch]. The calculation of persistence diagrams are performed by Dionysus ²²2https://mrzv.org/software/dionysus2 and Gudhi ³³3http://gudhi.gforge.inria.fr libraries.

6 Results

Dataset Group 1

Table 2 demonstrates the results on 10 graph datasets. Our method performs the best on 4 out of 10 datasets. On the other 6 datasets, it performs comparably with PersLay [carriere2019perslay], another persistence diagram based method.

Dataset Group 2

For large datasets, our method is ranked in the top 3 on most of the datasets as observed in Table 3. When compared against other methods in Neural Network family, it outperforms these methods on 5 out of 6 datasets.

Some baseline methods such as RetGK [zhang2018retgk] leverage node attributes (node labels) of the graph for classification purposes. Our results are promising considering that the approach does not use any node attributes as the features. When comparing the best model among our variants (i.e., different values of $K$ ), we observe that using more than 1 return probability of random walk achieves better results in most of the datasets. In particular, RPNet-1 performs the best only on 1 dataset, in a total of 16 datasets. This implies that our method benefits from using multiple PDs based on multi-scale graph signatures. On the other hand, while our variant with $K = 2$ (RPNet-2) works the best on small datasets in group 1, we observe that increasing $K$ (i.e., $K = 4$ and $K = 8$ ) gains some improvement on large datasets in group 2. Despite having high performance on most benchmarks, graph kernel methods require computing and storing evaluations for each pair of graphs in the dataset, making them intractable when dealing with datasets containing a large number of graphs. For example, the random walk kernel (RW) [vishwanathan2010graph] takes more than 3 days on NCI1 dataset [zhang2018end]

. Our approach can avoid the quadratic complexity with respect to the number of graphs required for graph kernels, and thus can easily apply to real-world graph datasets. It is also worth mentioning that our approach has higher variance compared with others, such as kernel methods. This high variance is a common problem when using deep learning approaches, which can be observed in deep learning baselines such as GCAPS

[verma2018graph].

Ablation experiments

In this section, we conduct some ablation study on our proposal’s architecture. We start with our RPNet-4, and then remove some of its components to study their efficiency. The comparison is shown in Table 4.

We can observe that removing 3-d one-hot vectors (1) and (2) decreases the accuracy by 6.4%, 6.6%, and 2.3% on NCI1, IMDB-M, PROTEINS respectively. The main efficiency mainly comes from one-hot vectors (1) as it contributes much more to the performance compared with one-hot vectors (2). This shows the importance of using one-hot vectors to keep the information about the type of persistence diagrams from the original graphs. Besides, we find that learning a set of weights to aggregate the diagram features is beneficial to the model. When compared with the average pooling as a baseline, we find that weighted diagram pooling improves approximately 1-3% accuracy on the 3 datasets.

According to the experimental results, incorporating all the three components into our model, in general, can also help to reduce the variance, allowing us to obtain more stable performance.

Dataset	one-hot (1)	one-hot (2)	weighted diagram pooling (3)	Accuracy $\pm$ std
NCI1			$✓$	65.7 $\pm$ 2.9
		$✓$	$✓$	66.6 $\pm$ 2.6
	$✓$		$✓$	70.8 $\pm$ 1.5
	$✓$	$✓$		70.7 $\pm$ 1.0
	$✓$	$✓$	$✓$	72.1 $\pm$ 1.8
IMDB-M			$✓$	41.1 $\pm$ 4.1
		$✓$	$✓$	41.2 $\pm$ 4.1
	$✓$		$✓$	43.4 $\pm$ 3.2
	$✓$	$✓$		44.3 $\pm$ 3.7
	$✓$	$✓$	$✓$	47.7 $\pm$ 2.9
PROTEINS			$✓$	73.1 $\pm$ 3.6
		$✓$	$✓$	73.1 $\pm$ 2.8
	$✓$		$✓$	73.1 $\pm$ 3.8
	$✓$	$✓$		72.3 $\pm$ 4.2
	$✓$	$✓$	$✓$	75.4 $\pm$ 2.6

Table 4: Ablation experiment results of our model’s architecture on 3 datasets NCI1, IMDB-M, PROTEINS. Note: one-hot (1)

denotes concatenation of the 3-d one-hot vectors with topological features extracted from the graph,

one-hot (2) denotes concatenation of the 3-d one-hot vectors with encoded features (after encoding step), and weighted diagram pooling (3) indicates using weighted sum to aggregate the diagrams, otherwise average pooling is employed. These components are indicated by (1), (2), and (3) in Fig. 5, respectively.

7 Conclusion

In this paper, we propose a family of multi-scale graph signatures for persistence diagrams based on return probabilities of random walks. We introduce RPNet, a deep neural network architecture to handle the proposed features and demonstrate its efficiency on a wide range of benchmark graph datasets. We show that our proposed method outperforms other persistent homology-based methods and graph neural networks while being on par with state-of-the-art graph kernels. There are some other interesting directions worth exploring. One of those is to employ a kernel-based approach with our multiset features. There has been some work on defining the distance between two persistence diagrams. It would be promising to build a kernel method working on the proposed multiscale representation. Besides, our approach does not make use of the node attributes, which may be critical to classifying graphs, such as chemical compounds where each node attribute represents a chemical element. Thus, another future direction is to investigate in detail how to incorporate the node attribute into our multi-scale graph signature. We are also interested in developing a theory for multi-dimensional persistent homology and using it for deep learning models in downstream tasks.

8 Acknowledgments

Approved for public release, 22-607

A Multi-scale Graph Signature for Persistence Diagrams based on Return Probabilities of Random Walks

A General Neural Network Architecture for Persistence Diagrams and Graph Classification

PersLay: A Neural Network Layer for Persistence Diagrams and New Graph Topological Signatures

PersLay: A Simple and Versatile Neural Network Layer for Persistence Diagrams

Optimisation of Spectral Wavelets for Persistence-based Graph Classification

Neural Approximation of Extended Persistent Homology on Graphs

A Stable Multi-Scale Kernel for Topological Machine Learning

Classification of Single-lead Electrocardiograms: TDA Informed Machine Learning

1 Introduction

2 Related Works