Can Hybrid Geometric Scattering Networks Help Solve the Maximum Clique Problem?
Abstract
We propose a geometric scattering-based graph neural network (GNN) for approximating solutions of the NP-hard maximum clique (MC) problem.
We construct a loss function with two terms, one which encourages the network to find highly connected nodes and the other which acts as a surrogate for the constraint that the nodes form a clique.
We then use this loss to train an efficient GNN architecture that outputs a vector representing the probability for each node to be part of the
MC and apply a rule-based decoder to make our final prediction.
The incorporation of the scattering transform alleviates the so-called oversmoothing problem that is often encountered in GNNs and would degrade the performance of our proposed setup.
Our empirical results demonstrate that our method outperforms representative GNN baselines in terms of solution accuracy and inference speed as well as conventional solvers like Gurobi with limited time budgets.
Furthermore, our scattering model is very parameter efficient with only ∼ 0.1% of the number of parameters compared to previous GNN baseline models.
Introduction
The success of Graph Neural Networks (GNNs) for a variety of machine learning tasks [Scarselli et al., 2008, Gori et al., 2005, Kipf and Welling, 2016, Gilmer et al., 2017] has sparked interests in using GNNs to solve graph combinatorial optimization (CO) problems [Li et al., 2018a, Karalias and
Loukas, 2020].
For example, Joshi et al.
[2019] introduces a GNN-based method for approximately solving the travelling salesman problem (TSP), while Karalias and Loukas [2020] approximate solutions of the maximum clique (MC) problem.
Solving such problems in an end-to-end fashion via
GNNs is challenging for several reasons.
First of all, many CO problems are provably either NP-hard or NP-complete.
Therefore, learning CO solvers in a supervised or semi-supervised fashion can be computationally infeasible since the cost of generating the ground truth labels grows exponentially with the problem size.
Second, the solution to the CO problems must satisfy a number of constraints
[Figure]
or limitations (e.g. belonging to a clique).
Although these constraints can be imposed during training time, there is still no guarantee that these constraints are still satisfied at test time.
Furthermore, solving graph combinatorial problems largely depends on the expressive power of GNNs.
Many
GNNs aggregate information via local averaging, which can be interpreted as a smoothing operation.
This degrades the expressive power of GNNs and results in the so-called oversmoothing problem [Li et al., 2018b] where neighboring nodes have similar representations and are difficult to distinguish from each other.
This is problematic if a node that is not in the solution set borders many points that are in the solution set.
The purpose of this paper is to use a geometric scattering-based GNN to fast approximate the solution of the maximum clique (MC) problem, that is to find the largest complete subgraph contained within a large graph G .
This problem has many applications including pattern recognition and knowledge discovery.
For instance, finding the maximum clique of the related connection graphs can be used to handle object recognition tasks [Horaud and Skordas, 1989].
It is also tightly related to biological applications, such as helping to solve genome-scale elucidation of biological networks [Zhang et al., 2005].
Our use of geometric scattering, rather than a more traditional GNN is motivated by recent work [Wenkel et al., 2022] showing that the geometric scattering transform can help overcome the oversmoothing problem via the use of band-pass wavelet filters in conjunction with GCN-type filters.
This is particularly important in the context of the MC problem because it is critical to distinguish a point which connects to many members of the clique from an actual member of the clique.
As we shall show, our method, which utilizes band-pass wavelet filters is able to better detect the border between the MC and the rest of the graph.
This parallels the traditional use of wavelets as edge detectors in image processing [Grossmann, 1988].
Our method uses a two-phase strategy shown in Figure 1.
We first use an unsupervised learning model to generate an efficient representation of how likely each node is to be part of the maximum clique.
Then, this representations is fed into a constraint-preserving decoder to generate the maximum clique.
Ideally, given a graph G with n nodes, we would build a representation p ∈ [0 , 1] n where the nodes in the maximum clique are assigned the value 1 (True) while all other nodes are assigned(False), so that we can ‘cut’ the MC from the graph via O ( n ) operations.
In practice, we will build a representation which assigns large probabilities to the maximum clique nodes and small probabilities to the other nodes.
This will allow us to extract the maximum clique by choosing the vertices where p
[Figure]
is large.
As illustrated in Figure 2, this approach works best if p is not excessively smooth.
However, so-called oversmoothing is a known limitation of many GNN models [Li et al., 2018b].
Figure 2 (a) presents a situation where oversmoothing does not occur.
The signal p is much larger on the nodes (1 , 2 , 3 , 4 , 6) , which form the maximum clique, than it is on the other nodes (5 , 7 , 8) .
Therefore, the decoder can easily find the MC by, e.g., setting a threshold.
Figure 2 (b), on the other hand, illustrates a situation in which oversmoothing occurs and p exhibits less variability.
Indeed, there are no blue colored nodes at all.
In this setting, it is nearly impossible to distinguish node 7 , which does not belong to the maximum clique, from the nodes 1 , 6 , and therefore extracting the MC from p is difficult if not impossible.
Background and Related Work 2.1 Graph Signal Processing
Consider a graph G =
( V, E ) with a set of nodes (or vertices) V :=
{ v 1 , . .
. , v n } and a set of undirected edges E ⊂ V × V .
For a function x : V → R defined on V , we will, in minor abuse of notation identify x with the vector x , where x [ i ] =
x ( v i ) .
We let W ∈ R n × n denote the adjacency matrix of G and define the symmetric normalized grah Laplacian by L : =
I n − D − 1 / 2 W D 1 / 2 , where d i :=
(cid:80) n j =1 W [ v i , v j ] is the degree of the node v i and D :=
diag( d 1 , ..., d n ) ∈ R n × n is the degree matrix.
We will let q i
and λ i denote the (normalized) eigenvectors and eigenvalues of L with
L q i =
λ i q i , and make use of the eigendecomposition L = Q Λ Q ⊤ , where Q is the orthogonal matrix whose i -th column is the normalized eigenvector q i , and Λ :=
diag( λ 1 , ..., λ n ) .
Notably, the eigenvectors q 1 , . . .
q n can be seen as a generalization of Fourier modes in the context of graph domains with the corresponding eigenvalues representing the increasing frequencies 0 ≤ λ 1 ≤ · · · ≤ λ n ≤ 2 .
This link may be established by viewing frequency as a measure of variation, in particular the variation of (degree-normalized)
Fourier modes across edges is
[Equation]
for ˜ q
i :=
D − 1 / 2 q i .
The graph Fourier transform of a signal vector x is then defined as by ˆ x
[ i ] = ⟨ x , q i ⟩ and the inverse Fourier is given by x = (cid:80) ni
=
ˆ x
[ i ] q i .
Compactly written, we have ˆ x =
Q ⊤ x and x = Q
ˆ x .
In the Euclidean setting, it is known that convolution in the spatial domain corresponds to multiplication in the Fourier domain.
This fact has motivated work such as Shuman et al.
[2016], which defines the convolution of a signal x with a filter g to be the unique vector verifying ( (cid:91) g ⋆ x )
[ i ]
= ˆ g
[ i ] ˆ x
[ i ] , which implies that
[Equation]
where (cid:98) G :=
diag( ˆ g ) =
diag( ˆ g [1] , . .
, ˆ g [ n ]) .
When incorporating this notion of convolution into a graph neural network, a common choice [e.g., Defferrard et al., 2016] is to require the coefficients ˆ g [ i ] to be polynomials of the eigenvalues
λ
i , i ∈ [ n ] , i.e., ˆ g [ i ] := (cid:80) k γ k λ ki in which case we have (cid:98) G = (cid:80) k γ k Λ k .
This allows one to implement convolution in the spatial domain by verifying that g
⋆ x = (cid:80) k γ k L k x .
In particular, the entire method may be implemented without the need to diagonalize a matrix which is extremely expensive for large graphs.
2.2 Graph Convolutional Networks
In Kipf and Welling [2016], the authors set ˆ g [ i ] :
= θ (2 − λ i ) , where θ is a real number, which yields
[Equation]
As the eigenvalues of the above convolutional filter lie in [0,2] and could lead to vanishing or exploding gradients, the authors then apply a renormalization trick which replaces I n + D − 1 / 2 W D − 1 / 2 with
A :=
( D + I ) − 1 / 2 ( W + I )
[Equation]
D + I ) − 1 / 2 .
The layer-wise propagation rule of GCN is then defined by
[Equation]
where x ℓ − 1 i ∈ R n is the i -th feature vector in layer ℓ − 1 , θ ℓij are a trainable parameters, x ℓj is the j -th feature activation vector in layer ℓ and σ ( · ) is a nonlinear activation function.
We can summarize this in matrix notation as
[Equation]
where Θ ℓ ∈ R N ℓ − 1 × N ℓ is the weight-matrix of layer ℓ and X ℓ ∈ R n × N ℓ contains the activations output by layer ℓ .
The GCN model updates node features at every node by averaging over the node features of the node itself and its neighbors, which enforces similarity throughout node neighborhoods.
This makes nodes increasingly difficult to discriminate for ‘deeper’ models and is widely referred to as the oversmoothing problem [Li et al., 2018b].
From a graph spectral theory perspective, oversmoothing is related to low-pass filtering as the filter in Eq.
1 puts larger weights on the lowfrequency spectrum (as 0 ≤ λ i ≤ 2 ).
This motivates the idea of using GCN-type low-pass filters in conjunction with band-pass filters, that can be implemented, for example, using graph scattering [Min et al., 2020], which we discuss in the following.
2.3 Graph Scattering
The graph scattering transform [Gama et al., 2019, Zou and Lerman, 2019, Gao et al., 2019] is a wavelet-based model for machine learning on graphs.
Unlike the one-hop localized low-pass filters used in GCN, which aim to promote smoothness between neighboring nodes, these wavelets are band-pass filters, which in turn incorporate long-range dependencies through the large spatial support of the used aggregations.
The scattering transform is based upon raising the lazy random walk matrix
[Equation]
to different powers in order to capture the diffusion geometry of the graph G at various time scales.
In particular, subtracting such powers allows us to detect changes in these diffusion geometries.
Following the lead of Coifman and Maggioni [2006], for k ∈ N 0 , we define a wavelet matrix Ψ k ∈ R n × n at scale 2 k by
[Equation]
Intuitively, at every node, these diffusion wavelets can be seen as a comparison operation that calculates the difference of the averaged features of two neighborhoods of different sizes (namely sizes 2 k − 1 and 2 k ).
The geometric scattering transform is constructed through an alternating cascade on wavelet filters and pointwise nonlinearities σ : R → R , a so-called scattering path p :=
( k 1 , . . .
, k m ) that outputs
[Equation]
Model
Our method is centered around three main components, (i) a hybrid scattering-GCN model M (Sec. 3.1-3.3) that transforms a small set of simple node-level statistics represented by the matrix
X ∈ R n × d to a probability vector p ∈ [0 , 1] n representing the probabilities that each node is part of the maximum clique, (ii) an easy-to-optimize unsupervised loss function L (Sec. 3.4) that is small for “good” probability vectors p ⋆ ; and (iii) a rule-based decoder D (Sec. 3.5) that maps the probability vector to the maximum clique C ⋆ ⊂ V of G .
[Equation]
3.1 Embedding Module
The input of our model is a node feature matrix X ∈ R n × d , containing d features for each node.
In our experiments, we set d = 3 and let the features be the eccentricity, the clustering coefficient, and the logarithm of the degree of each node.
The encoder transforms the node features to d h -dimensional embeddings H 0 using a multi-layer perceptrone (MLP) m
emb : R d → R d h , i.e., H 0 :
= m emb ( X ) , which will be used as the input to the diffusion module introduced in the next subsection.
3.2 Diffusion Module
The diffusion module consists of a cascade of K ∈ N aggregation (or diffusion) layers with operations that are chosen for each node via an attention mechanism.
Our network is based upon the framework introduced in Wenkel et al.
However, an important deviation is to store the initial node representation H 0 and every intermediate node representation H ℓ , 1 ≤ ℓ ≤ K , in a list of readouts .
In each layer ℓ , every node has access to node representations from set a of filters F that contains a selection of low-pass and band-pass filters.
Similar to Wenkel et al.
[2022], our band-pass filters f low ,r are modified GCN filters that have the form
[Equation]
and are parameterized by the power r ≥ 1 of the matrix A .
Similarly, we define the scattering filter f band ,k of order k according to
[Equation]
Next, we want to obtain data-driven scores s f ( v ) that determine the importance of filter f ∈ F for node v ∈ V .
We set H ℓf := f
( H ℓ − 1 ) and calculate the scores via an attention mechanism, setting
[Equation]
(7) where ∥ denotes the concatenation operation.
The attention mechanism, at every node, calculates the dot product of a learned attention vector a ℓ ∈ R 2 d h with the filtered node representation of the node concatenated to its previous representation.
We further deviate from the model in Wenkel et al.
[2022] by rewiring the nonlinearity σ ( · ) in Eq. 7.
They apply it after the multiplication with the attention vector a ℓ similar to the traditional graph attention mechanism [Veliˇckovi´c et al., 2018].
In contrast, we apply it before the multiplication with the attention vector following the lead of Brody et al.
[2021], who showed this constitutes an even more expressive attention mechanism.
The i -th entry of s ℓf ∈ R n then contains the importance score of filter f for node v i .
We normalize the scores across the filters using the softmax function, i.e., α f ( v ) =
softmax F ( s f ( v )) , and store the resulting scores in attention vectors α ℓf ∈ R n , f ∈ F .
We then update node representations via
[Equation]
where ⊙ is the element-wise multiplication (applied separately to each column of H ℓ f ).
Notably, the softmax function enforces that every node is likely to focus mostly on one single filter.
We note that the method is compatible with multi-head attention but omit further details as it is not necessary for the present experiments.
Finally, we transform the aggregated node representations via an MLP m ℓ : R d h → R d h , i.e., H ℓ := m ℓ ( H ℓ agg ) .
We repeat the above process for K ∈ N iterations (or layers) and store the intermediate representations in a list of readouts R = { H ℓ } Kℓ =0 .
3.3 Output Module
In the output module, we combine the information from the list of readouts R .
We first concatenate the readouts horizontally to
[Equation]
where H cat ∈ R n × d h ( K +1) and then transform H cat to a vector h ∈ R n using an MLP m out :
R d h ( K +1)
→ R , i.e., h :
= m out ( H cat ) .
Finally, to obtain a vector of probabilities, we apply min-max normalization, i.e., p :=
( h − min( h ) · 1 n ) / (max( h ) − min( h )) , and interpret the i -th entry of p as the probability that node v
3.4 Training Loss
We now derive an unsupervised training loss for the maximum clique problem, which was also obtained by a different derivation in the work of Karalias and Loukas [2020].
Letting Ω denote the set of cliques of a graph G =
( V, E ) , we note that the task of finding the maximum clique is equivalent to identifying the clique C ∈ Ω that contains the most edges, i.e., maximizes the objective function
[Equation]
where w u,v = 1 if node u and v are connected otherwise 0.
Our approach relies on producing a vector p such that p v ≈ 1 if v is in the maximum clique and p v ≈ 0 otherwise.
We consider the vector x ∈ R n where x v = 1 if v is in the maximum clique and x v = 0 otherwise.
We then model x v as a Bernoulli random variable where P ( x v = 1) =
p v .
Our goal then becomes to maximize the expectation
[Equation]
Maximizing Eq.
9 encourages p to be large on highly connected nodes.
However, we also want the support of p to be concentrated within a clique.
This naturally motivates the constrained optimization problem of minimizing
[Equation]
subject to: supp( p ) is contained in a clique .
However, the constraint that p is contained in a clique is hard to enforce directly.
In order to construct a surrogate, we consider the complement graph G =
( V , E ) .
The vertices of G are taken to be the same as G , i.e., V = V , while the edges are defined by the rule that for u ̸ = v there is an edge between u and v in G if and only if there is not an edge between them in G , i.e.,
E = { ( u, v ) ∈
V × V : u ̸ = v }\ E .
We denote the adjacency matrix of G by W = ( w u,v ) u,v ∈ V , and note that
[Equation]
otherwise
[Equation]
In particular, W has zeros on the diagonal and can be computed from W via W = 1 n × n − ( I + W ) .
The following Lemma indicates that a second loss term L 2 ( p ) :
= p ⊤ W p can be used to ensure that mass is primarily concentrated in a set of nodes that form a clique.
Lemma 1. Consider a graph G =
( V, E ) , a signal p ≥ 0 and define supp( p ) :
= { v ∈ V : p v > 0 } .
Then, L 2 ( p ) =
p ⊤ W p =
if and only if there exists a clique C ⊂ V such that the support of p is contained in C .
Proof.
We first assume p ⊤ W p = 0 and suppose for the sake of a contradiction that there exists no clique C ⊂ V with supp( p ) ⊂ C .
Then, there exist at least two nodes u 0 , v 0 ∈ supp( p ) with { u 0 , v 0 } ̸∈ E .
Now, p ⊤ W p = (cid:80) { u,v }̸∈ E p
u
p v ≥ p u 0 p v 0 > 0 , which is a contradiction.
For the opposite direction, we assume that there exists a clique C ⊂ V such that supp( p )
⊂
C .
Hence, every pair of distinct nodes in supp( p ) is connected by an edge and consequently w u,v = 0 for all u, v ∈ supp( p ) .
Thus, p ⊤ W p = (cid:80) u,v ∈ V w u,v p u p v =
(cid:80) u,v ∈ supp( p ) w u,v p
u p v = 0 .
In light of Eq.
9 and Lemma 1, we now define our training loss as
[Equation]
We note that the loss function decomposes into two terms.
The first term, L 1 , encourages the allocation of mass at highly connected nodes, while the second term L 2 encourages most of the mass of p to be contained in a clique.
Moreover, β is a hyper-parameter which is used to balance the contributions of the two terms.
As mentioned, an almost identical loss function was already used in Karalias and Loukas [2020] with further details discussed in Appendix C.
Similar to many other GNN applications it is desirable to use the sparsity of the graph G and hence also W .
We note that, although a sparse W signifies a dense W , we can efficiently evaluate the second loss term as p
[Equation]
Algorithm
In order to extract the maximum clique from p , we use a greedy decoder detailed in in Alg. 1.
Our algorithm creates a set Ω
= { ˆ C j } κj =1 of κ cliques and then selects the ˆ C j with largest cardinality.
To construct each ˆ C j , we first create a sorting function π : V → { 1 , . .
, | V |} which puts the nodes in descending order, so p π − 1 (1) ≥ . . .
≥ p π − 1 ( n ) .
Each ˆ C j starts as a single node π − 1 ( j ) .
We then consider τ − j additional candidate, π − 1 ( j + 1) , . .
, π − 1 ( τ ) and accept each candidate node v canditate if ˆ C j ∪ { v candidate } forms a clique.
This is tested by verifying that x ⊤ W x = 0 for x := (cid:80) v ∈ ˆ C j ∪{ v candidate } 1 v .
We remark that in order for our decoder to predict the true maximum clique exactly, we must choose the parameters τ and κ such that there exists a j , 1 ≤ j ≤ κ , such that
[Equation]
≤ τ for all v i in the MC.
On simple datasets, such as IMDB, it suffices to set κ = 1 .
More complex datasets such as Twitter require larger values of κ .
Importantly, we note that the ˆ C j can be computed in parallel, so increasing the value of κ does not create major scalability issues.
We note that setting the hyperparameters of the decoder requires some prior knowledge of the largest sizes of the maximum cliques present in the data, which we tune using the validation set.
Results 4.1 Baselines
We compare our hybrid scattering model against other neural network-based methods, an integer programming-based solver and a traditional heuristic.
For the the neural networks, Erdös’
GNN [Karalias and Loukas, 2020] and RUN-CSP [Toenshoff et al., 2021], the authors provide two implementations, one optimized towards computational speed (fast), and the other optimized for best approximation score (accurate).
The integer programming-based solver, Gurobi 9.0 [Gurobi Optimization, LLC, 2022], is in general more accurate than neural network based methods.
However, it is slower on larger graphs.
In order to highlight the contribution of our hybrid scattering model, we also provide results for a pure low-pass model, which only uses GCN-type filters [Kipf and Welling, 2016] followed by our decoder module.
Finally, we compare to a traditional heuristic [Grosso et al., 2008], a local search procedure with η 1 random restarts, where the initial clique is modified and possibly improved by neighbourhood search operations until some termination condition occurs.
The heuristic is iterated for a maximum of η 2 iterations.
We denote the method for different hyperparameter configurations as Heuristic( η 1 , η 2 ) .
4.2 Datasets
We evaluate our model on three popular real-world graph learning datasets, namely IMDB, COLLAB [Yanardag and Vishwanathan, 2015] and TWITTER [Yan et al., 2008].
To further explore how our model performs relative to other methods on more challenging and larger graphs, we introduce two new datasets consisting of graphs generated according to the approach in Xu et al.
The
We set the number of samplers, κ , equal to 1, 1 and 10 on IMDB COLLAB and TWITTER respectively.
We provide results for Gurobi 9.0 with 4 different time budgets, and for Heuristic with different hyperparameter settings
[Table]
first dataset (SMALL) contains graphs of slightly larger size ( ∼ 180 nodes on average) compared to the TWITTER dataset ( ∼ 132 nodes on average)
[Table]
which is the real-world dataset containing the largest graphs.
The second dataset (LARGE) contains significantly larger graphs ( ∼ 1324 nodes on average), that constitute by far the biggest challenge.
In each of the two datasets, we have three different classes of hardness (easy, medium and hard) that are retained for different hardness parameters (0.2, 0.5 and 0.8) following the approach in Xu et al.
More details on the dataset statistics can be found in
Table 3 in Appendix B.
4.3 Evaluation
To evaluate the different models, we use average test approximation score and the average time needed to approximate the maximum clique across the graphs of a dataset measured in seconds per graph (s/G).
We note that the time requirement of Gurobi 9.0 can exceed the indicated time limit as it only affects a subroutine of the method.
On the real-world datasets and the proposed dataset with small graphs, the approximation score of a given graph is computed by dividing the size of the clique found by the algorithm by the size of the true MC, i.e., if the MC of a graph has size 10 and the algorithm returns a clique of size 9, it would be given a score of 90%.
We then average these scores across all graphs in each dataset.
On the proposed dataset with larger graphs, the MC size is unknown because it is virtually impossible to specify.
Instead, we use the predicted MC size from
Gurobi 9.0 (0.1s) as a target.
Notably, this allows for approximation ratios larger than 100% to arise.
Such cases signify that the corresponding model found a better (larger) clique than Gurobi 9.0 (0.1s).
4.4 Experiments
We first look at the three real-world datasets and provide results in Table 1.
For the IMDB dataset, our hybrid approach and most other methods (except RUN-CSP) solve the MC problem with a perfect (100%) approximation score.
However, our model significantly outperforms the other neural network-based models (Erdös’ GNN and RUN-CSP) with respect to computation time (although the highly optimized Gurobi solver is slightly faster than our method on this dataset due to the small graph size).
On COLLAB, our model almost reaches perfect performance (99.9%) in 0.029 s/G, outperforming the other neural network based methods in both speed and approximation score.
Some versions of the Gurobi solver are able to achieve 99.9% and 100% approximation scores, however, they are slower than our method on this dataset.
The TWITTER dataset is the most challenging of the considered real-world datasets.
Here, our method achieves the second highest accuracy among neural networks with 95.2% compared to 98.7% for RUN-CSP (accurate).
However, our method is nearly seven times faster than RUN-CSP (0.05 s/G vs 0.34 s/G).
Similarly, while there are several versions of Gurobi which achieve higher levels of accuracy than our method, all of these methods need at least 0.34 s/G.
In principle, one could utilize faster versions of Gurobi, but those methods would achieve lower accuracies.
For example, Gurobi 9.0 (0.1s) requires four times the time per graph compared to our method (0.21 s/G vs 0.05 s/G) while achieving a much lower accuracy (80.3% vs 95.2%).
Figure 3 illustrates the differences between our hybrid scattering model and the low-pass GCN-based model[Kipf and Welling, 2016] and helps explain why the scattering-based model performs better across all three datasets.
It shows that the probability vector p generated by our hybrid scattering model is a more discriminative representation than the one produced by the low-pass model.
When using the low-pass model, most nodes are assigned high probabilities (marked in red).
The decoder cannot tell which nodes have higher priorities given such a smooth output.
This leads to the decoder accepting nodes which are not part of the MC.
If the new clique is not a sub-clique of the MC, this in turn can lead to the decoder rejecting nodes which are part of the MC.
The scattering model on the other hand produces a less smooth representation.
The nodes outside the MC are assigned lower probabilities so that our decoder can successfully find the MC.
This is consistent with previous work [Wenkel et al., 2022] showing that the graph scattering transform helps to alleviate the oversmoothing problem in node classification.
We emphasize that both models are trained with the same loss function and a the same rule-based decoder to predict the maximum clique.
Therefore, the differences illustrated in Figure 3 are the direct result of using a hybrid scattering model.
More comparison between the scattering model and low-pass model can be found in Appendix E.
To further explore how our model performs on harder graphs, we now look at the newly proposed datasets generated according to the methodology of Xu et al.
Here, we present the results of the most challenging LARGE dataset, shown in Tab. 2, while the discussion of the results on the
SMALL dataset can be found in Appendix D.
Our hybrid scattering model outperforms the other neural network approaches across all three difficulties (easy, medium and hard) in terms of approximation ratio and inference time.
The gap in approximation ratio is larger on medium and hard samples, highlighting the utility of our model for more complex graphs.
At the same time, our model is extremely efficient, exhibiting much lower inference times than the other neural networks (with the exception of GCN, which is a modified version of our hybrid model with band-pass filters removed), e.g., inferring the MC on
LARGE-hard 12 times faster than RUN-CSP (accurate), the closest competing neural network.
When given sufficiently large time budgets, Gurobi and the heuristic [Xu et al., 2005] can achieve higher approximation ratios, however at a significantly higher time cost.
For example, on LARGE-hard, only Gurobi 9.0 (50.0s) and Heuristic(5 , 100) outperform our approach, however using on average 131 and 49 times longer to infer the MC, respectively.
[Table]
Overall, across all considered datasets, we remark that our hybrid model provides considerable speedup compared to both the other neural networks and to Gurobi for large graphs.
We also note that our model takes fewer parameters than the Erdös’ GNN model.
Erdös’ GNN model uses a multihead
GNN (8 heads, with 64 hidden units per head) for each layer, whereas the MLPs used in our method have 8 hidden units on all three datasets, without using any multi-head attention mechanism.
This in turn suggests that the use of both GCN filters and scattering filters combined yields powerful feature extractors that help learn informative node representations with relatively few parameters.
In fact, the Erdös’ GNN model contains 1,880,709 parameters for each dataset, while our model contains 1,297 parameters for Twitter, 705 for IMDB and 1,001 for COLLAB, respectively.
We only use around 0.07%, 0.04% and 0.05% of the parameter counts that Erdös’ model takes and achieve better performance in terms of both running time and accuracy.
Furthermore, since the K -layer
GCN-type model has time complexity O
( K | E | d + Knd 2 ) , where d is the number of hidden units, it is important to reduce the hidden units number per layer because the time complexity is quadratic w.r.t.
d .
As mentioned before, our scattering model only uses 8 hidden units (without multi-head attention), which results in lower time complexity and thus faster inference.
Conclusion
In this paper, we show the expressive power of GNNs can be critical for solving graph CO problems.
Our results suggest that low-pass models that generally enforce smoothness over graph neighborhoods due to oversmoothing, make the nodes indistinguishable, which leads to unfavorable node representations for the MC problem.
Inspired by the geometric scattering transform, we propose an efficient scattering-based GNN to overcome the oversmoothing problem.
We use a two-term loss function (previously derived by a different method in Karalias and Loukas [2020]), which encourages our network to find a set of nodes that are both highly connected and contained within a clique, which in conjunction mimic the otherwise hard to optimize problem of finding maximum cliques.
Our model produces efficient node representations that enable us to approximate the maximum clique at a fast speed using a constrain-preserving greedy decoder.
Overall, our performance is competitive with other neural network-based methods on common benchmark datasets, while largely reducing the number of parameters and computation time.
When run on larger and more complex graphs, our hybrid scattering model outperforms other neural network approaches.
Acknowledgements
We would like to thank Yiwei Bai for discussions.
This work was partially funded by Fin-ML
CREATE graduate studies scholarship for PhD [Frederik Wenkel]; IVADO (Institut de valorisation des données) grant PRF-2019-3583139727, FRQNT (Fonds de recherche du Québec - Nature et technologies) grant 299376, Canada CIFAR AI Chair; and NIH (National Institutes of Health) grant
NIGMS-R01GM135929 [Guy Wolf].
The content provided here is solely the responsibility of the authors and does not necessarily represent the official views of the funding agencies.