P RUNED G RAPH S CATTERING T RANSFORMS
A BSTRACT
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-ﬂy 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 signiﬁcant 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.
I NTRODUCTION
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 beneﬁts 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 ﬁndings 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 ﬁlter banks followed by nonlinear activation functions.
The graph ﬁlter 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 ﬁlter banks, GSTs are endowed with energy conservation properties (Zou & Lerman,
[Figure]
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 ﬁlter’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.
Speciﬁcally, 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 ﬁlters.
The optimal pruning decisions are provided on-the-ﬂy, 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 signiﬁcant computational savings; ii)
The extracted features from pGSTs can be utilized towards graph classiﬁcation 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.
R ELATED WORK
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; Veliˇckovi´c et al., 2018) and graph classiﬁcation (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 ﬁlter 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 ﬁxing the graph ﬁlter 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.
B ACKGROUND
Consider a graph G :=
{V , E} with node set V :
= { v i } Ni =1 , and edge set E := { e i } Ei =1 .
Its connectivity is described by the graph shift matrix S ∈ R N × N , whose ( n, n (cid:48) )
th entry S nn (cid:48) is nonzero if ( n, n (cid:48) )
∈ E or if n = n (cid:48) .
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 :=
[ x 1 , . .
, x F ] ∈ R N × F , where each column x f ∈ R N is a ‘graph signal .’
Graph Fourier transform .
A Fourier transform corresponds to the expansion of a signal over bases that are invariant to ﬁltering; here, this graph frequency basis is the eigenbasis of the graph shift matrix S .
Henceforth, S is assumed normal with S =
VΛV (cid:62) , where V ∈ R N × N forms the graph
Fourier basis, and Λ ∈ R N × N is the diagonal matrix of corresponding eigenvalues λ 0 , . . .
, λ N − 1 .
These eigenvalues represent graph frequencies.
The graph Fourier transform (GFT) of x ∈ R N is (cid:98) x
= V (cid:62) x ∈ R N , while the inverse transform is x = V (cid:98) x .
The vector (cid:98) 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 coefﬁcients 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 beneﬁts 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 ﬁlter), a pointwise nonlinear function σ ( · ) , and oftentimes also a pooling operation.
Given a graph signal x ∈ R N , the graph convolution operation diffuses each node’s information to its neighbors according to the graph shift matrix S , as Sx .
The n th entry [ Sx ] n = (cid:80) n (cid:48) ∈N n S nn (cid:48)
x n (cid:48) is a weighted average of the one-hop neighboring features.
Successive application of S will increase the reception ﬁeld, spreading the information across the network.
Hence, a K th order graph convolution operation (graph ﬁltering) is
[Equation]
(1) where the graph ﬁlter h ( · ) is parameterized by the learnable weights { w k } Kk =0 , and the graph ﬁlter in the graph spectral domain is (cid:98) h ( Λ )
=
(cid:80) Kk =
w k Λ k .
In the graph vertex domain, the learnable weights reﬂect the inﬂuences 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 ﬁlter banks per layer, and learn the parameters that minimize a predeﬁned learning objective, such as classiﬁcation, 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 ﬁlter banks { h j ( S ) } Jj =1 , an elementwise nonlinear function σ ( · ) , and a pooling operator U .
At the ﬁrst layer, the input graph signal x ∈ R N constitutes the ﬁrst scattering feature vector z (0) :
= x .
Next, z (0) is processed by the graph ﬁlter banks and σ ( · ) to generate { z ( j ) }
Jj =1 with z ( j ) :
= σ ( h j ( 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.
The (cid:96) th layer of the tree includes J (cid:96) nodes.
Each tree node at layer (cid:96) in the scattering transform is indexed by the path p ( (cid:96) ) of the sequence of (cid:96) graph convolutions applied to the input
GFTsof x ,h 1 ( S ) ,h 2 ( S ) ,h 3 ( S )  60 .
n thentry (cid:98) x
h 1 ( λ ) h 2 ( λ ) h 3 ( λ ) z (1) z (2) z (3) z (1 , 1) z (1 , 2)
z (1 , 3) z (2 , 1) z (2 , 2) z (2 , 3) z (3 , 1) z (3 , 2) z
(3 , 3) h 1 ( S )
h 2 ( S ) h 3 ( S ) h 1 ( S ) h 1 ( S ) h 1 ( S )
z (0) =
x graph signal x , i.e. p
[Equation]
The scattering feature vector at the tree node indexed by ( p ( (cid:96) ) , j ) at layer (cid:96) + 1 is
[Equation]
[Equation] ) where the variable p ( (cid:96) ) holds the list of indices of the parent nodes ordered by ancestry, and all path p ( (cid:96) ) in the tree with length (cid:96) are included in the path set P ( (cid:96) ) with |P ( (cid:96) )
| = 2 (cid:96) .
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 .
Each scattering feature vector z ( p ( (cid:96) ) ) is summarized by an aggregation operator U ( · ) to obtain a scalar scattering coefﬁcient as φ ( p ( (cid:96) ) ) :
=
U ( z ( p ( (cid:96) ) ) ) , where U ( · ) is typically an average or sum operator that effects dimensionality reduction of the extracted features.
The scattering coefﬁcient at each tree node reﬂects the activation level at a certain graph frequency band.
These scattering coefﬁcients are collected across all tree nodes to form a scattering feature map
[Equation]
where | Φ ( x ) | = (cid:80) L(cid:96)
=
J (cid:96) .
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).
P RUNED G RAPH S CATTERING T RANSFORMS
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 signiﬁcant information; see Fig.
This requires a customized GST to adaptively choose signiﬁcant 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 sufﬁce.
Pruning the wavelet packets has been traditionally employed for compression in image processing 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 reﬂects a unique subband in the graph spectrum.
When the subband of a tree node does not have a sufﬁcient 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, (cid:98) x :=
V (cid:62) x ∈ R N and [ (cid:98) x ] n = 0 for n ≥ b .
The graph spectrum of the j th graph ﬁltered output is then
[Equation]
where λ n is the n th eigenvalue of S and each frequency (cid:98) x n is weighted by the corresponding transformed eigenvalue (cid:98)
h j ( λ n ) .
Hence, if the support of the graph spectrum { (cid:98) h j ( λ n ) } n is not included in the support of [ (cid:98) x ] n then the j th graph ﬁlter output will not capture any information; that is, h j ( S ) x = 0 N ; see Fig. 2.
Thus, identifying such graph ﬁlters and pruning the corresponding tree nodes will result to a parsimonius and thus computationally efﬁcient 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 ﬁlters and the scattering feature.
At the tree node p , the optimization problem is
[Equation]
where (cid:98) z ( p ) :=
Vz ( p ) is the graph spectrum of the scattering feature vector z ( p ) ; τ is a user-speciﬁc 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 (cid:98)
z ( p ) with that of (cid:98) h
j ( λ ) .
The threshold τ introduces a minimum spectral value to locate those tree nodes whose corresponding graph spectral response is small, i.e. (cid:98)
h j ( λ n ) 2 (cid:28) τ .
Note that criterion (4) is evaluated per tree node p , thus allowing for a ﬂexible and scalable design.
The optimization problem in (4) is nonconvex since f ( p,j ) is a discrete variable.
Furthermore, recovering (cid:98) z ( p ) requires an eigendecomposition of the Laplacian matrix that incurs O ( N 3 ) complexity.
Nevertheless, by exploiting the structure in (4), we develop an efﬁcient pruning algorithm that achieves the maximum of (4), as summarized in the following theorem.
Theorem 1.
The optimal pruning assignment variables (cid:110) f ∗ ( p,j ) (cid:111)
j of (4) is given as follows
[Equation]
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 ﬁlter 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-ﬂy.
Hence, when f ∗ ( p ) = 1 , tree node p is active and the graph ﬁlter 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.
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 deﬁned as
[Equation]
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.
S TABILITY AND SENSITIVITY OF P GST
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).
Speciﬁcally, for any graph signal x ∈ R N , it holds that, A 2 (cid:107) x (cid:107) 2 ≤ (cid:80)
Jj =1 (cid:107) h
j ( S ) x (cid:107) 2 ≤ B 2 (cid:107) x
(cid:107) 2 .
In the graph vertex domain, the scalar frame bounds
A and B characterize the numerical stability of recovering a graph signal x from { h j ( S ) x } j .
In the graph spectral domain, they reﬂect the ability of the graph ﬁlter bank to amplify x along each graph frequency.
Tight frame bounds, satisfying A 2 = B 2 , 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
[Equation]
where δ ∈ R N 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 ﬁrst show that GST is stable to small perturbations of the input graph signal 3 .
Lemma 1.
Consider the GST Φ ( · ) with L layers and J graph ﬁlters; and suppose that the graph ﬁlter bank forms a frame with bound B , while x and ˜ x are related via (6) .
It then holds that
[Equation]
The squared difference of the GSTs is normalized by the number of scattering features in Φ ( · ) , that is | Φ ( x ) |
= (cid:80) L(cid:96)
=
1 J (cid:96) .
The bound in (7) relates to the frame bound of the wavelet ﬁlter 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 :=
z p − ˜ z p .
If for all p ∈ P and j = 1 , . . .
, J , it holds that
[Equation]
Then, we obtain
The pruning transform will output the same tree for Ψ ( x ) and Ψ (˜ x ) ; that is, T = ˜ T ; and, 2.
With g ( x ) := (cid:107) h j ( S ) x (cid:107) 2 − τ (cid:107) x (cid:107) 2 , a necessary condition for (8) is | g
[Equation]
z p ) | > g ( δ p ) . 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 ( z p )
| /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.
[Figure] [Figure]
C l a ss i ﬁ ca ti on acc u r ac
y
DS
MCS
THS
P DS
P MCS
P THS (a) Authorship   100 0 .0 .0 .
SNR
C l a ss i ﬁ ca ti on acc u r ac y (b) Facebook
Authorship Facebook 10 −10 −
S ec ond s (c) Runtime
Authorship
Facebook
P c t o f p r un e d f ea t u r e s i n t op - 2 | T | (d) Feature overlap
Theorem 2.
Consider the pGST transform Ψ ( · ) with L layers and J graph ﬁlters; and suppose that the graph ﬁlter 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
[Equation]
where F (cid:96) := |P
( (cid:96) )
∪T | is the number of active scattering features at layer (cid:96) , and | Ψ ( x ) | = (cid:80) L(cid:96)
=
F (cid:96) the number of retained scattering features.
E XPERIMENTS
This section evaluates the performance of our pGST in various graph classiﬁcation tasks.
Graph classiﬁcation amounts to predicting a label y
i given x i and S i for the i th graph.
Our pGST extracts Ψ ( x i ) , which is utilized as a feature vector for predicting y i .
During training, the structure of the pGST T is determined, which is kept ﬁxed 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 classiﬁcation?
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 ﬁlter 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).
The scattering transforms use J = 5 ﬁlters, L = 5 layers, and τ = 0 .
The extracted features from GSTs are subsequently utilized by a linear support vector machine (SVM) classiﬁer.
Authorship attribution amounts to determining if a certain text was written by a speciﬁc 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 classiﬁcation accuracy for the authorship attribution task as the number of training samples (texts) increases.
GSTs utilize (cid:80) 5 (cid:96) =1 5 (cid:96) =
781 scattering coefﬁcients, while pGSTs rely only on |T | = 61 for P DS, |T | = 30 for P MCS, and |T | = 80 for P THS.
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 classiﬁer provides a coefﬁcient that weighs each scattering scalar. The magnitude of each coefﬁcient shows the importance of the corresponding scattering feature in the classiﬁcation. Fig.
3 (d) depicts the percentage of features
Networkdepth L
C l a ss i ﬁ ca ti on acc u r ac
y
MCS P MCS P OINTNET P OINTNET ++ 3DS HAPE
[Figure]
ETS
[Figure] OX N ET [Figure] Tr./test : 9843/    5 0 .
[Figure] [Figure] [Figure] L
C l a ss i ﬁ [Figure] ti [Figure]
u
[Figure]
y
[Figure]
Method
Data Set
E NZYMES D&D C OLLAB P ROTEINS
K e r n e l S HORTEST - PATH 42.
76.43 WL-OA 60.
P ATCHY S AN – 76.
GNN s
G RAPH S AGE 54.
70.48 ECC 53.
72.65 S ET 2 SET 60.
74.29 S ORT P OOL 57.
75.54 D IFF P OOL -D ET 58.
75.62 D IFF P OOL -N O LP 62.
77.42 D IFF P OOL 64.
S ca tt e r i ng GSC 53.
74.03 GST 59.
P GST (Ours) 60.
after prunning retained in the top- 2 |T | most important GST features given by the SVM classiﬁer.
It is observed, that although pGST does not take into account the labels, the retained features are indeed informative for classiﬁcation.
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 classiﬁcation 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 classiﬁcation .
Towards answering RQ2, the proposed pGST is compared with the following state-of-the-art approaches.
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 ﬁlters 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 classiﬁer (GSC) (Gao et al., 2019).
Results are presented with protein data sets D&D, Enzymes and Proteins, and the scientiﬁc collaboration data set Collab.
Detailed description of the datasets is included in the Appendix.
We perform 10-fold cross validation and report the classiﬁcation accuracy averaged over the 10 folds.
The gradient boosting classiﬁer 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 classiﬁcation 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 classiﬁcation .
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 classiﬁcation 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 classiﬁer; whereas, in Fig.
4 (b) only 615 clouds are used for training and the rest for testing using a fully connected neural network classiﬁer 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 overﬁtting 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.
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.
Evidently, graph data from various domains require an adaptive scattering architecture.
Speciﬁcally, 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 ﬁndings 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 classiﬁcation.
For the protein datasets, additional experiments are performed in Appendix A.4 that corroborate the pGST insights regarding the required number of
GCN layers.
C ONCLUSIONS
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-ﬂy, 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 classiﬁcation 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.
A A DDITIONAL EXPERIMENTS
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
[Figure]
and hence x was selected as the vector that holds the node degrees.
[Figure]
A. A BLATION 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 classiﬁcation 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 classiﬁcation 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 classiﬁcation performance generally increases with L and J .
B P ROOF OF T HEOREM
First, the objective in (4) is rewritten as
[Equation]
that follows by deﬁnition.
By introducing the scalars α
[Equation] − τ I ) (cid:98) z ( p ) for j = 1 , . .
, J , (4) can be rewritten as
[Equation]
The optimization problem in (11) is nonconvex since f j is a discrete variable.
However, maximizing the sum in (11) amounts to setting f j = 1 for the positive α j over j .
Such an approach leads to the optimal pruning assignment variables as follows
[Equation]
The rest of the proof focuses on rewriting α j as follows
[Equation]
[Equation]
Furthermore, since V is orthogonal matrix it holds that (cid:107) (cid:98) z
( p ) (cid:107)
= (cid:107) V (cid:62) z ( p ) (cid:107)
= (cid:107) z
( p ) (cid:107)
and it follows
[Equation]
where the second line follows since σ ( · ) is applied elementwise and does not change the norm.
C P ROOF OF L EMMA
By deﬁnition (3) it holds
[Equation]
[Equation] Hence, it is well motivated to bound each term of the sum in (17) as follows
[Equation]
where (19) follows since the norm is a sub-multiplicative operator.
Next we will show the following recursive bound
[Equation]
where (21), (23) follow since the norm is a sub-multiplicative operator and (22) follows since the nonlinearity is nonexpansive, i [Equation] e. (cid:107) σ () (cid:107) < 1 .
Hence, by applying (23) (cid:96) − 1 times the following condition holds
[Equation]
and by further applying the frame bound and (6) it follows that
[Equation]
Combining (19), (25) and the average operator property (cid:107) U (cid:107) = {+
+} it holds that
[Equation] [Equation]
By applying the bound (26) for all entries in the right hand side of (17) it follows that
[Equation]
[Equation]
By factoring out (cid:107) δ (cid:107) and observing that the sum in the right side of (27) does not depend on the path index p it follows that
[Equation]
[Equation]
Finally, since the cardinality of the paths at (cid:96) is |P
( (cid:96) )
| =
J [Equation] and (cid:80) L(cid:96)
[-=
-]=
[Equation] ( B [Equation] = (cid:0) ( B 2 J ) L (cid:1) / (cid:0) B 2 J − 1 (cid:1) it holds
[Equation]
D P ROOF OF L EMMA
We will prove the case for (cid:96) = 0 , where z p (0) =
x , since the same proof holds for any (cid:96) .
First, we adapt (8) to the following
[Equation]
The proof will examine two cases and will follow by contradiction.
For the ﬁrst 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 ) =
σ ( h j ( S ) x ) there exists C ≥ 0 such that
[Equation]
[Equation]
[Equation]
Furthermore, from (5) it holds for ˜ z
( j ) =
σ ( h j ( S )˜ x ) that
[Equation]
By applying (6) to (33), and using the triangular inequality it follows that
[Equation]
Next, by applying (32) it holds that
[Equation]
Next, by utilizing (30) and the absolute value property | a | ≥ a to upper-bound the left side of (36) it follows that
[Equation]
Finally, by applying (32) the following is obtained
[Equation]
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.