PRUNED GRAPH SCATTERING TRANSFORMS
Year: 2020

Abstract:
Graph convolutional networks (GCNs) have achieved remarkable performance in a variety of network science learning tasks. However, theoretical analysis of such approaches is still at its infancy. Graph scattering transforms (GSTs) are non-trainable deep GCN models that are amenable to generalization and stability analyses. The present work addresses some limitations of GSTs by introducing a novel so-termed pruned (p)GST approach. The resultant pruning algorithm is guided by a graph-spectrum-inspired criterion, and retains informative scattering features on-the-fly while bypassing the exponential complexity associated with GSTs. It is further established that pGSTs are stable to perturbations of the input graph signals with bounded energy. Experiments showcase that i) pGST performs comparably to the baseline GST that uses all scattering features, while achieving significant computational savings; ii) pGST achieves comparable performance to state-of-the-art GCNs; and iii) Graph data from various domains lead to different scattering patterns, suggesting domain-adaptive pGST network architectures.

heading: 1 INTRODUCTION
text: The abundance of graph-structured data calls for advanced learning techniques, and complements nicely standard machine learning tools that cannot be directly applied to irregular data domains. Permeating the benefits of deep learning to the graph domain, graph convolutional networks (GCNs) provide a versatile and powerful framework to learn from complex graph data (Bronstein et al., 2017). GCNs and variants thereof have attained remarkable success in social network analysis, 3D point cloud processing, recommender systems and action recognition. However, researchers have recently reported inconsistent perspectives on the appropriate designs for GCN architectures. For example, experiments in social network analysis have argued that deeper GCNs marginally increase the learning performance (Wu et al., 2019), whereas a method for 3D point cloud segmentation achieves state-ofthe-art performance with a 56-layer GCN network (Li et al., 2019). These ‘controversial’ empirical findings motivate theoretical analysis to understand the fundamental performance factors and the architecture design choices for GCNs.
Aiming to bestow GCNs with theoretical guarantees, one promising research direction is to study graph scattering transforms (GSTs). GSTs are non-trainable GCNs comprising a cascade of graph filter banks followed by nonlinear activation functions. The graph filter banks are mathematically designed and are adopted to scatter an input graph signal into multiple channels. GSTs extract scattering features that can be utilized towards graph learning tasks (Gao et al., 2019), with competitive performance especially when the number of training examples is small. Under certain conditions on the graph filter banks, GSTs are endowed with energy conservation properties (Zou & Lerman, ∗This work was mainly done while V. N. Ioanndis was working at Mitsubishi Electric Research Laboratories.
2019), as well as stability meaning robustness to graph topology deformations (Gama et al., 2019a). However, GSTs are associated with exponential complexity in space and time that increases with the number of layers. This discourages deployment of GSTs when a deep architecture is needed. Furthermore, stability should not come at odds with sensitivity. A filter’s output should be sensitive to and “detect” perturbations of large magnitude. Lastly, graph data in different domains (social networks, 3D point clouds) have distinct properties, which encourages GSTs with domain-adaptive architectures.
The present paper develops a data-adaptive pruning framework for the GST to systematically retain important features. Specifically, the contribution of this work is threefold.
C1. We put forth a pruning approach to select informative GST features that we naturally term pruned graph scattering transform (pGST). The pruning decisions are guided by a criterion promoting alignment (matching) of the input graph spectrum with that of the graph filters. The optimal pruning decisions are provided on-the-fly, and alleviate the exponential complexity of GSTs.
C2. We prove that the pGST is stable to perturbations of the input graph signals. Under certain conditions on the energy of the perturbations, the resulting pruning patterns before and after the perturbations are identical and the overall pGST is stable.
C3. We showcase with extensive experiments that: i) the proposed pGSTs perform similarly and in certain cases better than the baseline GSTs that use all scattering features, while achieving significant computational savings; ii) The extracted features from pGSTs can be utilized towards graph classification and 3D point cloud recognition. Even without any training on the feature extraction step, the performance is comparable to state-of-the-art deep supervised learning approaches, particularly when training data are scarce; and iii) By analyzing the pruning patterns of the pGST, we deduce that graph signals in different domains call for different network architectures; see Fig. 1.

heading: 2 RELATED WORK
text: GCNs rely on a layered processing architecture comprising trainable graph convolution operations to linearly combine features per graph neighborhood, followed by pointwise nonlinear functions applied to the linearly transformed features (Bronstein et al., 2017). Complex GCNs and their variants have shown remarkable success in graph semi-supervised learning (Kipf & Welling, 2017; Veličković et al., 2018) and graph classification (Ying et al., 2018). To simplify GCNs, (Wu et al., 2019) has shown that by employing a single-layer linear GCN the performance in certain social network learning tasks degrades only slightly. On the other hand, (Li et al., 2019) has developed a 56-layer GCN that achieves state-of-the-art performance in 3D point cloud segmentation. Hence, designing GCN architectures guided by properties of the graph data is a highly motivated research question.
Towards theoretically explaining the success of GCNs, recent works study the stability properties of GSTs with respect to metric deformations of the domain (Gama et al., 2019b;a; Zou & Lerman, 2019). GSTs generalize scattering transforms (Bruna & Mallat, 2013; Mallat, 2012) to non-Euclidean
domains. GSTs are a cascade of graph filter banks and nonlinear operations that is organized in a tree-structured architecture. The number of extracted scattering features of a GST grows exponentially with the number of layers. Theoretical guarantees for GSTs are obtained after fixing the graph filter banks to implement a set of graph wavelets. The work in (Zou & Lerman, 2019) establishes energy conservation properties for GSTs given that certain energy-preserving graph wavelets are employed, and also prove that GSTs are stable to graph structure perturbations; see also (Gama et al., 2019b) that focuses on diffusion wavelets. On the other hand, (Gama et al., 2019a) proves stability to relative metric deformations for a wide class of graph wavelet families. These contemporary works shed light into the stability and generalization capabilities of GCNs. However, stable transforms are not necessarily informative, and albeit highly desirable, a principled approach to selecting informative GST features remains still an uncharted venue.

heading: 3 BACKGROUND
text: Consider a graph G := {V, E} with node set V := {vi}Ni=1, and edge set E := {ei}Ei=1. Its connectivity is described by the graph shift matrix S ∈ RN×N , whose (n, n′)th entry Snn′ is nonzero if (n, n′) ∈ E or if n = n′. A typical choice for S is the adjacency or the Laplacian matrix. Further, each node can be also associated with a few attributes. Collect attributes across all nodes in the matrix X := [x1, . . . ,xF ] ∈ RN×F , where each column xf ∈ RN is a ‘graph signal.’ Graph Fourier transform. A Fourier transform corresponds to the expansion of a signal over bases that are invariant to filtering; here, this graph frequency basis is the eigenbasis of the graph shift matrix S. Henceforth, S is assumed normal with S = VΛV>, where V ∈ RN×N forms the graph Fourier basis, and Λ ∈ RN×N is the diagonal matrix of corresponding eigenvalues λ0, . . . , λN−1. These eigenvalues represent graph frequencies. The graph Fourier transform (GFT) of x ∈ RN is x̂ = V>x ∈ RN , while the inverse transform is x = Vx̂. The vector x̂ represents the signal’s expansion in the eigenvector basis and describes the graph spectrum of x. The inverse GFT reconstructs the graph signal from its graph spectrum by combining graph frequency components weighted by the coefficients of the signal’s graph Fourier transform. GFT is a tool that has been popular for analyzing graph signals in the graph spectral domain.
Graph convolution neural networks. GCNs permeate the benefits of CNNs from processing Euclidean data to modeling graph structured data. GCNs model graph data through a succession of layers, each of which consists of a graph convolution operation (graph filter), a pointwise nonlinear function σ(·), and oftentimes also a pooling operation. Given a graph signal x ∈ RN , the graph convolution operation diffuses each node’s information to its neighbors according to the graph shift matrix S, as Sx. The nth entry [Sx]n = ∑ n′∈Nn Snn′xn′ is a weighted average of the one-hop neighboring features. Successive application of S will increase the reception field, spreading the information across the network. Hence, a Kth order graph convolution operation (graph filtering) is
h(S)x := K∑ k=0 wkS kx = Vĥ(Λ)x̂ (1)
where the graph filter h(·) is parameterized by the learnable weights {wk}Kk=0, and the graph filter in the graph spectral domain is ĥ(Λ) = ∑K k=0 wkΛ
k. In the graph vertex domain, the learnable weights reflect the influences from various orders of neighbors; and in the graph spectral domain, those weights adaptively adjust the focus and emphasize certain graph frequency bands. GCNs employ various graph filter banks per layer, and learn the parameters that minimize a predefined learning objective, such as classification, or regression.
Graph scattering transforms. GSTs are the nontrainable counterparts of GCNs, where the parameters of the graph convolutions are selected based on mathematical designs. GSTs process the input at each layer by a sequential application of graph filter banks {hj(S)}Jj=1, an elementwise nonlinear function σ(·), and a pooling operator U . At the first layer, the input graph signal x ∈ RN constitutes the first scattering feature vector z(0) := x. Next, z(0) is processed by the graph filter banks and σ(·) to generate {z(j)}Jj=1 with z(j) := σ(hj(S)z(0)). At the second layer, the same operation is repeated per j. The resulting computation structure is a tree with J branches at each non-leaf node; see also Fig. 2. The `th layer of the tree includes J` nodes. Each tree node at layer ` in the scattering transform is indexed by the path p(`) of the sequence of ` graph convolutions applied to the input
graph signal x, i.e. p(`) := (j(1), j(2), . . . , j(`)).1 The scattering feature vector at the tree node indexed by (p(`), j) at layer `+ 1 is
z(p(`),j) = σ(hj(S)z(p(`))) (2)
where the variable p(`) holds the list of indices of the parent nodes ordered by ancestry, and all path p(`) in the tree with length ` are included in the path set P(`) with |P(`)| = 2`. The nonlinear transformation function σ(·) disperses the graph frequency representation through the spectrum, and endows the GST with increased discriminating power (Gama et al., 2019a). By exploiting the sparsity of the graph, the computational complexity of (2) is O(KE), where E = |E| is the number of edges in G.2 Each scattering feature vector z(p(`)) is summarized by an aggregation operator U(·) to obtain a scalar scattering coefficient as φ(p(`)) := U(z(p(`))), where U(·) is typically an average or sum operator that effects dimensionality reduction of the extracted features. The scattering coefficient at each tree node reflects the activation level at a certain graph frequency band.
These scattering coefficients are collected across all tree nodes to form a scattering feature map Φ(x) := { {φ(p(`))}p(`)∈P(`) }L `=0 (3)
where |Φ(x)| = ∑L
`=0 J `. The GST operation resembles a forward pass of a trained GCN. This is
why several works study GST stability under perturbations of S in order to understand the working mechanism of GCNs (Zou & Lerman, 2019; Gama et al., 2019a;b).

heading: 4 PRUNED GRAPH SCATTERING TRANSFORMS
text: While the representation power of GST increases with the number of layers, the computational and space complexity of the transform also increase exponentially with the number of layers due to its scattering nature. Hence, even if informative features are available at deeper GST layers, the associated exponential complexity of extracting such features is prohibitive with the existing GST architectures. On the other hand, various input data (social networks, 3D point clouds) may have distinct properties, leading to different GST feature maps. In some cases, only a few tree nodes in deep layers are informative; and in other cases, tree nodes in shallow layers carry significant information; see Fig. 1. This requires a customized GST to adaptively choose significant tree nodes.
Alleviating GST limitations, we introduce a pruned graph scattering transform (pGST) to systematically retain informative tree nodes without additional complexity. Our novel pGST alleviates the exponential complexity and adapts GST to different input data. Furthermore, pGST offer a practical mechanism to understand the architecture of GCNs. Based on the pruning patterns, the proposed pGST suggests when a deeper GCN is desirable, and when a shallow one will suffice. Pruning the wavelet packets has been traditionally employed for compression in image processing
1A tree node is fully specified by its corresponding path. 2Any analytical function h(S) can be written as a polynomial of S with maximum degree N − 1 (Horn &
Johnson, 2012).
applications (Xiong et al., 2002), where the pruning is guided by a rate-distortion optimallity criterion. In this work, we consider a graph spectrum inspired criterion. Intuitively, each tree node in the GSTs reflects a unique subband in the graph spectrum. When the subband of a tree node does not have a sufficient overlap with the the graph spectrum of a graph signal, this tree node cannot capture the property of this graph signal, and should be pruned.
For example, consider a smooth graph signal x, where connected nodes have similar signal values, that has a sparse (low-rank) representation in the graph spectral domain that is, x̂ := V>x ∈ RN and [x̂]n = 0 for n ≥ b. The graph spectrum of the jth graph filtered output is then
V>hj(S)x = diag (ĥj(λ))x̂ = [ĥj(λ1)x̂1, ĥj(λ2)x̂2, . . . , ĥj(λN )x̂N ] >
where λn is the nth eigenvalue of S and each frequency x̂n is weighted by the corresponding transformed eigenvalue ĥj(λn). Hence, if the support of the graph spectrum {ĥj(λn)}n is not included in the support of [x̂]n then the jth graph filter output will not capture any information; that is, hj(S)x = 0N ; see Fig. 2. Thus, identifying such graph filters and pruning the corresponding tree nodes will result to a parsimonius and thus computationally efficient GST.
Pruning criterion. Motivated by the aforementioned observation, we introduce a pruning criterion to select the scattering branches per tree node by maximizing the alignment between the graph spectrum of the graph filters and the scattering feature. At the tree node p, the optimization problem is
max {f(p,j)}Jj=1 J∑ j=1
( N∑
n=1
( ĥj(λn) 2 − τ ) [ẑ(p)] 2 n ) f(p,j) (4)
s. t. f(p,j) ∈ {0, 1}, j = 1, . . . , J
where ẑ(p) := Vz(p) is the graph spectrum of the scattering feature vector z(p); τ is a user-specific threshold; and, f(p,j) stands for the pruning assignment variable indicating whether node (p, j) is active (f(p,j) = 1) or it should be pruned (f(p,j) = 0). The objective in (4) promotes retaining tree nodes that maximize the alignment of the graph spectrum of ẑ(p) with that of ĥj(λ). The threshold τ introduces a minimum spectral value to locate those tree nodes whose corresponding graph spectral response is small, i.e. ĥj(λn)2 τ . Note that criterion (4) is evaluated per tree node p, thus allowing for a flexible and scalable design.
The optimization problem in (4) is nonconvex since f(p,j) is a discrete variable. Furthermore, recovering ẑ(p) requires an eigendecomposition of the Laplacian matrix that incursO(N3) complexity. Nevertheless, by exploiting the structure in (4), we develop an efficient pruning algorithm that achieves the maximum of (4), as summarized in the following theorem.
Theorem 1. The optimal pruning assignment variables { f∗(p,j) } j of (4) is given as follows
f∗(p,j) =  1 if ‖z(p,j)‖ 2 ‖z(p)‖2 > τ,
0 if ‖z(p,j)‖ 2
‖z(p)‖2 < τ .
, j = 1, . . . , J (5)
The optimal variables f∗(p,j) are given by comparing the energy of the input z(p) to that of the output z(p,j) per graph filter j that can be evaluated at a low complexity of O(N). Our pruning criterion leads to a principled and scalable algorithm to selecting the GST tree nodes to be pruned. The pruning objective is evaluated at each tree node p, and pruning decisions are made on-the-fly. Hence, when f∗(p) = 1, tree node p is active and the graph filter bank will be applied to z(p), expanding the tree to the next layer; otherwise, the GST will not be expanded further at tree node p, which can result to exponential savings in computations. An example of such a pruned tree is depicted in Fig. 2. Evidently, the hyperparameter τ controls the input-to-output energy ratio. A large τ corresponds to an aggressively pruned scattering tree, while a small τ amounts to a minimally pruned scattering tree. The pGST is then defined as
Ψ(x) := { φ(p) } p∈T
where T is the set of active tree nodes T := {p ∈ P| f∗(p) = 1}.
Our pruning approach provides a concise version of GSTs and effects savings in computations as well as memory. Although the worst-case complexity of pGST is still exponential, a desirable complexity can be effected by properly selecting τ . As a byproduct, the scattering patterns of pGSTs reveal the appropriate depths and widths of the GSTs for different input data; see also Fig. 1. The pruning approach so far is an unsupervised one, since no input data labels are assumed available.

heading: 5 STABILITY AND SENSITIVITY OF PGST
text: In this section, we prove the stability of pGST to perturbations of the input graph signal. To establish the ensuing results, we consider graph wavelets that form a frame with frame bounds A and B (Hammond et al., 2011). Specifically, for any graph signal x ∈ RN , it holds that, A2‖x‖2 ≤ ∑J j=1 ‖hj(S)x‖2 ≤ B2‖x‖2. In the graph vertex domain, the scalar frame bounds A and B characterize the numerical stability of recovering a graph signal x from {hj(S)x}j . In the graph spectral domain, they reflect the ability of the graph filter bank to amplify x along each graph frequency. Tight frame bounds, satisfying A2 = B2, are of particular interest because such wavelets lead to enhanced numerical stability and faster computations (Shuman et al., 2015). The frame property of the graph wavelet plays an instrumental role in proving GST stability to perturbations of the underlying graph structure (Gama et al., 2019a;b; Zou & Lerman, 2019).
Consider a perturbed graph signal x̃ given by
x̃ := x + δ ∈ RN (6)
where δ ∈ RN is the perturbation vector. Such an additive model (6) may represent noise in the observed feature or adversarial perturbations. We are interested in studying how and under which conditions our pGST is affected by such perturbations. A stable transformation should have a similar output under small input perturbations.
Before establishing that our pGST is stable, we first show that GST is stable to small perturbations of the input graph signal3.
Lemma 1. Consider the GST Φ(·) with L layers and J graph filters; and suppose that the graph filter bank forms a frame with bound B, while x and x̃ are related via (6). It then holds that
‖Φ(x)−Φ(x̃)‖2√ |Φ(x)| ≤ √√√√∑L`=0(B2J)`∑L `=0 J ` ‖δ‖2 . (7)
The squared difference of the GSTs is normalized by the number of scattering features in Φ(·), that is |Φ(x)| = ∑L `=1 J
`. The bound in (7) relates to the frame bound of the wavelet filter bank. Notice that for tight frames with B = 1, then the normalized stability bound (7) is tight. Let T̃ be the structure of the pruned tree for Ψ(x̃). The following lemma asserts that the pGST offers the same pruned tree for the original and the perturbed inputs.
Lemma 2. Let z̃p denote the perturbed scattering feature at the tree node p and δp := zp − z̃p. If for all p ∈ P and j = 1, . . . , J , it holds that∣∣‖hj(S)zp‖2 − τ‖zp‖2∣∣ > ‖hj(S)δp‖2 + τ ∣∣‖zp‖2 − ‖z̃p‖2∣∣. (8) Then, we obtain
1. The pruning transform will output the same tree for Ψ(x) and Ψ(x̃); that is, T = T̃ ; and, 2. With g(x) := ‖hj(S)x‖2 − τ‖x‖2, a necessary condition for (8) is
|g(zp)| > g(δp) . (9)
According to (9), Lemma 2 can be interpreted as a signal-to-noise ratio (SNR) condition because under g(δp) > 0, it is possible to write (9) as |g(zp)|/g(δp) > 1. Lemma 2 provides a per-layer and branch condition for pGST to output the same scattering tree for the original or the perturbed signal. By combining Lemmas 1 and 2, we arrive at the following stability result for the pGST network.
3Prior art deals with GST stability to structure perturbations (Gama et al., 2019a;b; Zou & Lerman, 2019).
Theorem 2. Consider the pGST transform Ψ(·) with L layers and J graph filters; and suppose that the graph filter bank forms a frame with bound B, while x and x̃ are related via (6). The pGST is stable to bounded perturbations δ, in the sense that
‖Ψ(x)−Ψ(x̃)‖2√ |Ψ(x)| ≤ √√√√∑L`=0 F`B2`∑L `=0 F` ‖δ‖2
where F` := |P(`)∪T | is the number of active scattering features at layer `, and |Ψ(x)| = ∑L
`=0 F` the number of retained scattering features.

heading: 6 EXPERIMENTS
text: This section evaluates the performance of our pGST in various graph classification tasks. Graph classification amounts to predicting a label yi given xi and Si for the ith graph. Our pGST extracts Ψ(xi), which is utilized as a feature vector for predicting yi. During training, the structure of the pGST T is determined, which is kept fixed during validation and testing. The parameter τ is selected via cross-validation. Our goal is to provide tangible answers to the following research questions.
RQ1 How does the proposed pGST compare to GST? RQ2 How does pGST compare to state-of-the-art GCN approaches for graph classification? RQ3 What are the appropriate scattering patterns for various graph data?
Appendix A includes additional experiments on ablation studies over the effect of the parameters J, L, τ .
pGST vs. GST. To address RQ1, we reproduce the experiments of two tasks in (Gama et al., 2019a): authorship attribution and source localization. For the scattering transforms, we consider three implementations of graph filter banks: the diffusion wavelets (DS) in (Gama et al., 2019b), the monic cubic wavelets (MCS) in (Hammond et al., 2011) and the tight Hann wavelets (THS) in (Shuman et al., 2015).4 The scattering transforms use J = 5 filters, L = 5 layers, and τ = 0.01. The extracted features from GSTs are subsequently utilized by a linear support vector machine (SVM) classifier.
Authorship attribution amounts to determining if a certain text was written by a specific author. Each text is represented by a graph with N = 244, where words (nodes) are connected based on their relative positions in the text, and x is a bag-of-words representation of the text; see also (Gama et al., 2019b). Fig. 3 (a) reports the classification accuracy for the authorship attribution task as the number of training samples (texts) increases. GSTs utilize ∑5 `=1 5
` = 781 scattering coefficients, while pGSTs rely only on |T | = 61 for PDS, |T | = 30 for PMCS, and |T | = 80 for PTHS. Evidently, the proposed pGST achieves comparable performance as the baseline GST, whereas pGST uses only a subset of features (12.8%, 3.8% and 10.2% respectively). The SVM classifier provides a coefficient that weighs each scattering scalar. The magnitude of each coefficient shows the importance of the corresponding scattering feature in the classification. Fig. 3 (d) depicts the percentage of features
4PDS, PMCS, PTHS denote the pruned versions of these transforms.
2 4 6
0.7
0.8
0.9
Network depthL
C la
ss ifi
ca tio
n ac
cu ra
cy
MCS PMCS POINTNET POINTNET++ 3DSHAPENETS VOXNET
(a) Tr./test : 9843/2468
2 3 4 5
0.6
0.65
0.7
0.75
Network depthL
C la
ss ifi
ca tio
n ac
cu ra cy (b) Tr./test : 615/11703
Figure 4: 3D point cloud classification.
Method Data Set
ENZYMES D&D COLLAB PROTEINS
K er
ne l SHORTEST-PATH 42.32 78.86 59.10 76.43
WL-OA 60.13 79.04 80.74 75.26
PATCHYSAN – 76.27 72.60 75.00
G N
N s GRAPHSAGE 54.25 75.42 68.25 70.48 ECC 53.50 74.10 67.79 72.65 SET2SET 60.15 78.12 71.75 74.29 SORTPOOL 57.12 79.37 73.76 75.54 DIFFPOOL-DET 58.33 75.47 82.13 75.62 DIFFPOOL-NOLP 62.67 79.98 75.63 77.42 DIFFPOOL 64.23 81.15 75.50 78.10
Sc at
te ri
ng GSC 53.88 76.57 76.88 74.03 GST 59.84 79.28 77.32 76.23
PGST (Ours) 60.25 81.27 78.40 78.57
Table 1: Graph classification accuracy.
after prunning retained in the top-2|T | most important GST features given by the SVM classifier. It is observed, that although pGST does not take into account the labels, the retained features are indeed informative for classification.
Source localization amounts to recovering the source of a rumor given a diffused signal over a Facebook subnetwork with N = 234; see the detailed settings in (Gama et al., 2019b). Fig. 3 (b) shows the classification accuracy of the scattering transforms for increasing SNR in dB. In accordance to Lemma 1 and Theorem 2, both pGST and GST are stable for a wide range of SNR. Furthermore, the performance of pGST matches the corresponding GST, while the pGST uses only a subset of features. Fig. 3 (c) depicts the runtime of the different scattering approaches, where the computational advantage of the pruned methods is evident.
Graph classification. Towards answering RQ2, the proposed pGST is compared with the following state-of-the-art approaches.5 The kernel methods shortest-path (Borgwardt & Kriegel, 2005), and Weisfeiler-Lehman optimal assignment (WL-OA) (Kriege et al., 2016); the deep learning approaches PatchySan (Niepert et al., 2016), GraphSage (Hamilton et al., 2017), edge-conditioned filters in CCNs (ECC) (Simonovsky & Komodakis, 2017), Set2Set (Vinyals et al., 2015), SortPool (Zhang et al., 2018), and DiffPool (Ying et al., 2018); and the geometric scattering classifier (GSC) (Gao et al., 2019). Results are presented with protein data sets D&D, Enzymes and Proteins, and the scientific collaboration data set Collab. Detailed description of the datasets is included in the Appendix. We perform 10-fold cross validation and report the classification accuracy averaged over the 10 folds. The gradient boosting classifier is employed for pGST and GST with parameters chosen based on the performance on the validation set. The graph scattering transforms use the MC wavelet with L = 5, J = 5 and τ = 0.01. Table 1 lists the classification accuracy of the proposed and competing approaches. Even without any training on the feature extraction step, the performance of pGST is comparable to the state-of-the-art deep supervised learning approaches across all datasets. GST and pGST outperform also GSC, since the latter uses a linear SVM to classify the scattering features.
Point cloud classification. We further test pGST in classifying 3D point clouds. Given a point cloud, a graph can be created by connecting points (nodes) to their nearest neighbors based on their Euclidian distance. Each node is also associated with 6 scalars denoting its x-y-z coordinates and RGB colors. For this experiment, GSTs are compared against PointNet++ (Qi et al., 2017a;b), 3dShapeNets (Wu et al., 2015) and VoxNet (Maturana & Scherer, 2015), that are state-of-the-art deep learning approaches. Fig. 4 reports the classification accuracy for the ModelNet40 dataset (Wu et al., 2015) for increasing L. In Fig. 4 (a) 9,843 clouds are used for training and 2,468 for testing using the gradient boosting classifier; whereas, in Fig. 4 (b) only 615 clouds are used for training and the rest for testing using a fully connected neural network classifier with 3 layers. The scattering transforms use an MC wavelet with J = 5 for Fig. 4 (a) and J = 9 for Fig. 4 (b). Fig. 4 showcases that scattering transforms are competitive to state-of-the-art approaches, while pGST outperforms GST. This may be attributed to overfitting effects, since a large number of GST features is not informative. Furthermore, the exponential complexity associated with GSTs prevents their application for L = 6. Fig. 4 (b) shows that when the training data are scarce, GST and pGST outperform the PointNet++, which requires a large number of training data to optimize over the network parameters.
5For the competing approaches we report the 10-fold cross-validation numbers reported by the original authors; see also (Ying et al., 2018).
Scattering patterns. Towards answering RQ3, we depict the scattering structures of pGSTs, with a MC wavelet, J = 3 and L = 5, for the Collab, Proteins, and ModelNet40 datasets in Fig. 1. Evidently, graph data from various domains require an adaptive scattering architecture. Specifically, most tree nodes for the academic collaboration dataset are pruned, and hence most informative features are in the shallow layers. This is consistent with the study in (Wu et al., 2019), which experimentally shows that deeper GCNs do not contribute as much for social network data. These findings are further supported by the small-world phenomenon in social networks, which suggests the diameter of social networks is small (Watts & Strogatz, 1998). On the other hand, the tree nodes for a 3D point cloud are minimally pruned, which is in line with the work in (Li et al., 2019) that showcases the advantage of deep GCNs in 3D point clouds classification. For the protein datasets, additional experiments are performed in Appendix A.4 that corroborate the pGST insights regarding the required number of GCN layers.

heading: 7 CONCLUSIONS
text: This paper developed a novel approach to pruning the graph scattering transform. The proposed pGST relies on a graph-spectrum-based data-adaptive criterion to prune non-informative features on-the-fly, and effectively reduce the computational complexity of GSTs. Furthermore, when the input signal is perturbed, the stability of pGST is established. Experiments demonstrate that i) the performance gains of pGSTs relative to GSTs; ii) pGST is competitive in a variety of graph classification tasks; and (iii) graph data from different domains exhibit unique pruned scattering patterns, which calls for adaptive network architectures.
Acknowlegdments. This work was supported by Mitsubishi Electric Research Laboratories, the Doctoral Dissertation Fellowship of the University of Minnesota, and the NSF grants 171141, and 1500713.

heading: A ADDITIONAL EXPERIMENTS
text: Dataset characteristics. The characteristics of the Datasets used in Table 1 are shown in Table 2. Notice that the nodes in the Collab dataset did not have any features, and hence x was selected as the vector that holds the node degrees.
A.1 ABLATION STUDY
Fig. 5 reports how the pGST is affected by varying the threshold τ in the task of source localization, with J = 6 and L = 5. Fig. 5 (a) shows the classification accuracy that generally decreases at τ increases since the number of active features |T | decreases; cf. Fig. 5 (b). Fig. 5 (c) reports the runtime in seconds of the approaches. Fig. 6 showcases the classification performance of the pGST with τ = 0.01 for varying L with J = 3 on the left and for varying J with L = 3 on the right. It is observed, that the classification performance generally increases with L and J .

heading: B PROOF OF THEOREM 1
text: First, the objective in (4) is rewritten as
J∑ j=1
( N∑
n=1
( ĥj(λn) 2 − τ ) [ẑ(p)] 2 n ) fj = J∑ j=1 ẑ>(p) ( diag (ĥj(λ)) 2 − τI ) ẑ(p)fj (10)
that follows by definition. By introducing the scalars αj := ẑ>(p)(diag (ĥj(λ)) 2 − τI)ẑ(p) for j = 1, . . . , J , (4) can be rewritten as
max fj J∑ j=1 αjfj (11)
s. t. fj ∈ {0, 1}, j = 1, . . . , J.
The optimization problem in (11) is nonconvex since fj is a discrete variable. However, maximizing the sum in (11) amounts to setting fj = 1 for the positive αj over j. Such an approach leads to the optimal pruning assignment variables as follows
f∗j =
{ 1 if αj > 0,
0 if αj < 0. , j = 1, . . . , J (12)
The rest of the proof focuses on rewriting αj as follows
αj =ẑ > (p)(diag (ĥj(λ)) 2 − τI)ẑ(p) (13)
=‖diag (ĥj(λ))ẑ(p)‖2 − τ‖ẑ(p)‖2 (14)
Furthermore, since V is orthogonal matrix it holds that ‖ẑ(p)‖2 = ‖V>z(p)‖2 = ‖z(p)‖2 and it follows
‖diag (ĥj(λ))ẑ(p)‖2 =‖hj(S)z(p)‖2 (15) =‖σ(hj(S)z(p))‖2
=‖z(p,j)‖2 (16)
where the second line follows since σ(·) is applied elementwise and does not change the norm.

heading: C PROOF OF LEMMA 1
text: By definition (3) it holds
‖Φ(x)−Φ(x̃)‖2 = L∑
`=0 ∑ p(`)∈P(`) |φ(p(`)) − φ̃(p(`))|2 (17)
Hence, it is well motivated to bound each term of the sum in (17) as follows
|φ(p(`)) − φ̃(p(`))| =|U(z(p(`)) − U(z̃(p(`)))| (18) ≤‖U‖‖z(p(`)) − z̃(p(`))‖ (19)
where (19) follows since the norm is a sub-multiplicative operator. Next we will show the following recursive bound
‖z(p(`)) − z̃(p(`))‖ =‖σ(hj(`)(S)z(p(`−1)))− σ(hj(`)(S)z̃(p(`−1)))‖ (20) ≤‖σ()‖‖hj(`)(S)z(p(`−1)) − hj(`)(S)z̃(p(`−1))‖ (21) ≤‖hj(`)(S)z(p(`−1)) − hj(`)(S)z̃(p(`−1))‖ (22) ≤‖hj(`)(S)‖‖z(p(`−1)) − z̃(p(`−1))‖ (23)
where (21), (23) follow since the norm is a sub-multiplicative operator and (22) follows since the nonlinearity is nonexpansive, i.e. ‖σ()‖ < 1. Hence, by applying (23) ` − 1 times the following condition holds
‖z(p(`)) − z̃(p(`))‖ ≤ ‖hj(`)(S)‖‖hj(`−1)(S)‖ · · · ‖hj(1)(S)‖‖x− x̃‖ (24)
and by further applying the frame bound and (6) it follows that
‖z(p(`)) − z̃(p(`))‖ ≤ B`‖δ‖ (25)
Combining (19), (25) and the average operator property ‖U‖ = 1 it holds that
|φ(p(`)) − φ̃(p(`))| ≤ B`‖δ‖ (26)
By applying the bound (26) for all entries in the right hand side of (17) it follows that
‖Φ(x)−Φ(x̃)‖2 ≤ L∑
`=0 ∑ p(`)∈P(`) B2l‖δ‖2 (27)
By factoring out ‖δ‖ and observing that the sum in the right side of (27) does not depend on the path index p it follows that
‖Φ(x)−Φ(x̃)‖2 ≤
( L∑
`=0
|P(`)|B2` ) ‖δ‖2 (28)
Finally, since the cardinality of the paths at ` is |P(`)| = J` and ∑L
`=0(B 2J)` =( (B2J)L ) / ( B2J − 1 ) it holds
‖Φ(x)−Φ(x̃)‖ ≤
√ (B2J)L
B2J − 1 ‖δ‖ (29)

heading: D PROOF OF LEMMA 2
text: We will prove the case for ` = 0, where zp(0) = x, since the same proof holds for any `. First, we adapt (8) to the following∣∣‖hj(S)x‖2 − τ‖x‖2∣∣ > ‖hj(S)δ‖2 + τ ∣∣‖x‖2 − ‖x̃‖2∣∣. (30) The proof will examine two cases and will follow by contradiction. For the first case, consider that branch j is pruned in Ψ(x) and not pruned in Ψ(x̃), i.e. (j) ∈ T and (j) /∈ T̃ . By applying (5) for z(j) = σ(hj(S)x) there exists C ≥ 0 such that
‖hj(S)x‖2
‖x‖2 ≤τ − C (31)
‖hj(S)x‖2 ≤τ‖x‖2 − C‖x‖2 (32)
Furthermore, from (5) it holds for z̃(j) = σ(hj(S)x̃) that
‖hj(S)x̃‖2
‖x̃‖2 > τ (33)
By applying (6) to (33), and using the triangular inequality it follows that
‖hj(S)x‖2 + ‖hj(S)δ‖2 ≥ τ‖x̃‖2 (34)
Next, by applying (32) it holds that
τ‖x‖2 − C‖x‖2 + ‖hj(S)δ‖2 ≥τ‖x̃‖2 (35) τ(‖x‖2 − ‖x̃‖2) + ‖hj(S)δ‖2 ≥C‖x‖2. (36)
Next, by utilizing (30) and the absolute value property |a| ≥ a to upper-bound the left side of (36) it follows that
‖hj(S)x‖2 − τ‖x‖2 >C‖x‖2. (37)
Finally, by applying (32) the following is obtained
0 > 2C‖x‖2 (38)
which implies that C < 0. However, this contradicts (31) since C ≥ 0. Following a symmetric argument we can complete the proof for the other case.

Review summaries:
A scattering transform on graphs consists in the cascade of wavelets, modulus non-linearity and a low-pass filter. The wavelets and the low-pass are designed in the spectral domain, which is computationally extensive. Instead to compute any cascades of wavelets, this paper proposes to prune scattering paths which have the lowest energy. This is simple, and numerically efficient.

In this paper, the authors developed graph scattering transforms (GST) with a pruning algorithm, with the aim to reduce the running time and space cost, improve robustness to perturbations on input graph signal, and encourage flexibility for domain adaption. To this end, pruned graph scattering transform (pGST) was proposed based on the alignment between graph spectrum of the graph filters and the scattering feature. The intuition is to consider tree nodes as subbands in the graph spectrum and prune tree nodes that do not have sufficient overlap with the graph spectrum of a graph signal. The pruning problem was formulated as an optimization problem, and a solution was developed with theoretical analysis. Moreover, the analysis on the stability and sensitivity to perturbations were provided. Overall, the algorithm development is solid. The experimental results demonstrate the proposed pGST can outperform GST on graph classification task with less running time. Comparing with some supervised GNN methods, the proposed pGST can still achieve comparable results on several datasets.