L EARNING G RAPH S TRUCTURE FROM C ONVOLUTIONAL M IXTURES
Anonymous authors
Paper under double-blind review
A BSTRACT
Machine learning frameworks such as graph neural networks typically rely on a given, ﬁxed graph to exploit relational inductive biases and thus effectively learn from network data.
However, when said graphs are (partially) unobserved, noisy, or dynamic, the problem of inferring graph structure from data becomes relevant.
In this paper, we postulate a graph convolutional relationship between the observed and latent graphs, and formulate the graph learning task as a network inverse (deconvolution) problem.
In lieu of eigendecomposition-based spectral methods or iterative optimization solutions, we unroll and truncate proximal gradient iterations to arrive at a parameterized neural network architecture that we call a Graph Deconvolution Network (GDN).
GDNs can learn a distribution of graphs in a supervised fashion, and perform link prediction or edge-weight regression tasks by adapting the loss function.
Since layers directly operate on, combine, and reﬁne graph objects (instead of node features), GDNs are inherently inductive and can generalize to larger-sized graphs after training.
We corroborate GDN’s superior graph recovery performance using synthetic data in supervised settings, as well as its ability to generalize to graphs orders of magnitude larger that those seen in training.
Using the Human Connectome Project-Young Adult neuroimaging dataset, we demonstrate the robustness and representation power of our model by inferring structural brain networks from functional connectivity.
I NTRODUCTION
Inferring graphs from data to uncover latent complex information structure is a timely challenge for geometric deep learning (Bronstein et al., 2017) and graph signal processing (Ortega et al., 2018).
But it is also an opportunity, since network topology inference advances (Dong et al., 2019; Mateos et al., 2019) could facilitate adoption of graph neural networks (GNNs) even when no input graph is available (Hamilton, 2020).
The problem is also relevant when a given graph is too noisy or perturbed beyond what stable (possibly pre-trained) GNN architectures can effectively handle (Gama et al., 2020a).
Early empirical evidence suggests that even when a graph is available, the structure could be further optimized for a downstream task (Kazi et al., 2020; Feizi et al., 2013), or else sparsiﬁed to boost computational efﬁciency and model interpretability (Spielman & Srivastava, 2011).
In this paper, we posit a convolutional model relating observed and latent undirected graphs and formulate the graph learning task as a supervised network inverse problem; see Section 2 for a formal problem statement.
This fairly general model is motivated by various practical domains outlined in
Section 3, such as identifying the structure of network diffusion processes (Segarra et al., 2017; Pasdeloup et al., 2018), as well as network deconvolution and denoising (Feizi et al., 2013).
We propose a parameterized neural network model, termed graph deconvolution network (GDN), which we train in a supervised fashion to learn the distribution of latent graphs.
The architecture is derived from the principle of algorithm unrolling used to learn fast approximate solutions to inverse problems (Gregor & LeCun, 2010; Sprechmann et al., 2015; Monga et al., 2021), an idea that is yet to be explored in the context of graph structure identiﬁcation.
Since layers directly operate on, combine, and reﬁne graph objects (instead of nodal features), GDNs are inherently inductive and can generalize to graphs of different size.
This allows the transfer of learning on small graphs to unseen larger graphs, which has signiﬁcant implications in domains like social networks and molecular biology (Yehudai et al., 2021).
Our experiments demonstrate that GDNs are versatile to accommodate link prediction or edge-weight regression aspects of learning the graph structure, and achieve superior performance over various competing alternatives.
Building on recent models of functional activity in the brain as a diffusion process over the underlying anatomical pathways (Abdelnour et al., 2014; Liang & Wang, 2017), we show the applicability of GDNs to infer brain structural connectivity from functional networks obtained from the Human Connectome Project-Young Adult (HCP-YA) dataset.
We also use
GDNs to predict Facebook ties from user co-location data, outperforming relevant baselines.
Related work.
Network topology inference has a long history in statistics (Dempster, 1972), with noteworthy contributions for probabilistic graphical model selection; see e.g. (Kolaczyk, 2009;
Friedman et al., 2008; Drton & Maathuis, 2017).
Recent advances were propelled by graph signal processing insights through the lens of signal representation (Dong et al., 2019; Mateos et al., 2019), exploiting models of network diffusion (Daneshmand et al., 2014), or else leveraging cardinal properties of network data such as smoothness (Dong et al., 2016;
Kalofolias, 2016) and graph stationarity (Segarra et al., 2017; Pasdeloup et al., 2018).
These works formulate (convex) optimization problems one has to solve for different graphs, and can lack robustness to signal model misspeciﬁcations.
Scalability is an issue for the spectral-based network deconvolution approaches in (Segarra et al., 2017; Feizi et al., 2013), that require computationally-expensive eigendecompositions of the input graph for each problem instance.
Moreover, none of these methods advocate a supervised learning paradigm to learn distributions over adjacency matrices.
When it comes to this latter objective, deep generative models (Liao et al., 2019; Wang et al., 2018; Li et al., 2018) are typically trained in an unsupervised fashion, with the different goal of sampling from the learnt distribution.
Most of these approaches learn node embeddings and are inherently transductive.
Recently, so-termed latent graph learning has been shown effective in obtaining better task-driven representations of relational data for machine learning (ML) applications (Wang et al., 2019;
Kazi et al., 2020;
Veli ˇ ckovi ´ c et al., 2020), or to learn interactions among coupled dynamical systems (Kipf et al., 2018).
Summary of contributions.
We introduce GDNs, a supervised learning model capable of recovering latent graph structure from observations of its convolutional mixtures, i.e., related graphs containing spurious, indirect relationships.
Our experiments on synthetic and real datasets demonstrate the effectiveness of GDNs for said task.
They also showcase the model’s versatility to incorporate domain-speciﬁc topology information about the sought graphs.
On synthetic data, GDNs outperform comparable methods on link prediction and edge-weight regression tasks across different randomgraph ensembles, while incurring a markedly lower (post-training) computational cost and inference time.
GDNs are inductive and learnt models transfer across graphs of different sizes.
We verify they exhibit minimal performance degradation even when tested on graphs 60 × larger.
Finally, using
GDNs we propose a novel ML pipeline to learn whole brain structural connectivity (SC) from functional connectivity (FC), a challenging and timely problem in network neuroscience.
Results on the high-quality HCP-YA imaging dataset show that GDN performs well on speciﬁc brain subnetworks that are known to be relatively less correlated with the corresponding FC due to ageing-related effects – a testament to the model’s robustness and expressive power.
Overall, results here support the promising prospect of using graph representation learning to integrate brain structure and function.
P ROBLEM F ORMULATION
In this work we study the following network inverse problem involving undirected and weighted graphs G ( V , E ) , where V = { 1 , . . .
, N } is the set of nodes (henceforth common to all graphs), and E ⊆
V × V collects the edges.
We get to observe a graph with symmetric adjacency matrix
A O ∈ R N × N + , that is related to a latent sparse, graph A L ∈ R N × N + of interest via the model
[Equation]
where I denotes the N × N identity matrix.
The analytic graph mapping in (1) is a polynomial in A L of possibly inﬁnite degree, yet the Cayley-Hamilton theorem asserts it can always be equivalently reparameterized as a polynomial of degree smaller than N .
Said matrix polynomials
H ( A ; h ) :
= (cid:80) Kk =
h k A k , K ≤ N − 1 , with coefﬁcients h :=
[ h 0 , . .
, h K ] (cid:62)
∈
R K +1 , are known as shift-invariant graph convolutional ﬁlters; see e.g., (Ortega et al., 2018; Gama et al., 2020b).
Going back to the model (1), we postulate that A O = H ( A L , h ) for some ﬁlter order K and its associated coefﬁcients h , such that we can think of the observed network as generated via a graph convolutional process acting on A L .
More pragmatically A O may correspond to a noisy observation of H ( A L , h ) , and this will be clear from the context when e.g., we estimate A O from data.
Recovery of the latent graph A L is a challenging endeavour since we do not know H ( A L ; h ) , namely the parameters K or h ; see Appendix A.1 for issues of model identiﬁability.
Suppose that
A L is a realization drawn from some distribution of sparse graphs, say, for e.g., random geometric graphs or structural brain networks from a homogeneous dataset.
Then given independent training samples T :
= { A ( i ) O , A ( i ) L } Ti =1 adhering to (1), our goal is to learn a judicious parametric mapping that predicts the graph adjacency matrix ˆ A L = Φ
[Equation]
O
[Equation]
Θ
[Equation]
by minimizing a loss function
[Equation]
The loss (cid:96) is chosen to accommodate the task at hand – hinge loss for link prediction or meansquared/absolute error for the more challenging edge-weight regression problem; see Appendix A.4.
M OTIVATING A PPLICATION D OMAINS
Here we outline several graph inference tasks that can be cast as the network inverse problem (1).
Latent graph structure identiﬁcation from diffused signals.
Our initial focus here is on identifying graphs that explain the structure of a class of network diffusion processes.
Formally, let x ∈ R N be a graph signal (i.e., a vector of nodal features) supported on a latent graph G with adjacency A L .
Further, let w be a zero-mean white signal with covariance matrix Σ w = E
[ ww (cid:62) ] = I .
We say that
A L represents the structure of the signal x if there exists a linear network diffusion process in G that generates the signal x from w , namely x = (cid:80) ∞ i =
α i A iL w = H
( A L , h ) w .
This is a fairly common generative model for random network processes (Barrat et al., 2008; DeGroot, 1974).
We think of the edges of G as direct (one-hop) relations between the elements of the signal x .
The diffusion described by H ( A L , h ) generates indirect relations.
In this context, the latent graph learning problem is to recover a sparse A L from a set X :=
{ x i } Pi =1 of P samples of x (Segarra et al., 2017).
Interestingly, from the model for x it follows that the signal covariance matrix Σ x = E (cid:2) xx (cid:62) (cid:3) =
H 2 is also a polynomial in A L (we used Σ w = I , and wrote H ← H ( A L , h ) for notational simplicity).
The connection with (1) should now be apparent with the identiﬁcation A O = Σ x .
In practice, given the signals in X one would estimate the covariance matrix, e.g. via the sample covariance ˆ Σ x , and then aim to recover the graph A L by tackling the aforementioned network inverse problem.
In this paper, we propose a fresh learning-based solution using training examples T :=
{ ˆ Σ ( i ) x , A ( i ) L } Ti =1 .
Network deconvolution and denoising.
The network deconvolution problem is to identify a sparse adjacency matrix A L that encodes direct dependencies, when given an adjacency matrix A O of indirect relationships.
The problem broadens the scope of e.g., signal deconvolution to networks and can be tackled by attempting to invert the mapping
A O =
A L ( I − A L ) − 1 = (cid:80) ∞
i =1 A iL .
This solution proposed in (Feizi et al., 2013) assumes a polynomial relationship as in (1), but for the particular case of a single-pole, single-zero graph ﬁlter with very speciﬁc ﬁlter coefﬁcients [cf. (1) with α 0 =
and α
i = 1 , i ≥ 1 ].
This way, the indirect dependencies observed in A O arise due to the higher-order convolutive mixture terms A 2 L + A 3 L + . . .
superimposed to the direct interactions in A L we wish to recover.
Our idea in this paper is to adopt a more general, data-driven learning approach in assuming that A O can be written as a polynomial in A L , but being agnostic to the form of the ﬁlter.
Unlike the problem outlined before, here A O need not be a covariance matrix.
Indeed,
A O could be a corrupted graph we wish to denoise, obtained via an upstream graph learning method.
Potential application domains for which supervised data T :
= { A ( i ) O , A ( i ) L } Ti =1 is available include bioinformatics [infer protein contact structure from mutual information graphs of the covariation of amino acid residues (Feizi et al., 2013)], social and information networks [e.g., learn to sparsify graphs (Spielman & Srivastava, 2011) to unveil the most relevant collaborations in a social network encoding co-authorship information (Segarra et al., 2017)], and epidemiology (such as contact tracing by deconvolving the graphs that model observed disease spread in a population).
In Section 5.
we experiment with social networks and the network neuroscience problem described next.
Inferring structural brain networks from functional MRI (fMRI) signals.
Brain connectomes encompass networks of brain regions connected by (statistical) functional associations (FC) or by anatomical white matter ﬁber pathways (SC).
The latter can be extracted from time-consuming tractography algorithms applied to diffusion MRI (dMRI), which are particularly fraught due to quality issues in the data (Yeh et al., 2021).
FC represents pairwise correlation structure between blood- oxygen-level-dependent (BOLD) signals measured by fMRI.
Deciphering the relationship between
SC and FC is a very active area of research (Abdelnour et al., 2014; Honey et al., 2009) and also relevant in studying neurological disorders, since it is known to vary with respect to healthy subjects in pathological contexts (Gu et al., 2021).
Traditional approaches go all the way from correlation studies (Greicius et al., 2008) to large-scale simulations of nonlinear cortical activity models (Honey et al., 2009).
More aligned with the problem addressed here, recent studies have shown that linear diffusion dynamics can reasonably model the FC-SC coupling (Abdelnour et al., 2014; Surampudi et al., 2018).
Using our notation, the ﬁndings in (Abdelnour et al., 2014) suggest that the covariance
A O = Σ x of the functional signals (i.e., the FC) is related to the the sparse SC graph A L via the model in (1).
Similarly, Liang & Wang (2017) contend the estimated FC can be represented as a weighted sum of the powers of the SC matrix, consisting of both direct and indirect effects along varying paths.
There is evidence that FC links tend to exist where there is no or little structural connection (Damoiseaux & Greicius, 2009), a characteristic naturally captured by (1).
These considerations motivate adopting the proposed graph learning method to infer SC patterns from fMRI signals (Section 5.2), a signiﬁcant problem for several reasons.
The ability to collect only FC and get informative estimates of SC open the door to large scale studies, previously constrained by the logistical, cost, and computational resources needed to acquire both modalities.
G RAPH D ECONVOLUTION N ETWORK
Here we present the proposed GDN model, a parameterized neural network architecture that we train in a supervised fashion to recover latent graph structure via network deconvolution.
In the sequel, we obtain conceptual iterations to tackle an optimization formulation of the network inverse problem (Section 4.1), unroll these iterations to arrive at the GDN model we train using graph data (Section 4.2), and describe architectural customizations to improve performance (Section 4.3).
4. M OTIVATION VIA ITERATIVE OPTIMIZATION
Going back to the inverse problem of recovering a sparse adjacency matrix A L from the mixture
A O in (1), if the graph convolutional ﬁlter H ( A ; h ) were known we could attempt to solve
[Equation]
where the regularization parameter λ > 0 trades off sparsity for reconstruction error.
The convex set
A := { A ∈ R N × N | diag ( A ) = 0 , A ij =
A ij ≥ 0 , ∀ i, j ∈ { 1 , . .
, N }} encodes the admissibility constraints on the adjacency matrix of an undirected graph: hollow diagonal, symmetric, with nonnegative edge weights.
The (cid:96) 1 norm encourages sparsity in the solution, being a convex surrogate of the edge-cardinality function that counts the number of non-zero entries in A .
Since A O is often a noisy observation or estimate of the polynomial H ( A L ; h ) , it is prudent to relax the equality (1) and minimize the squared residual errors instead.
The composite cost in (3) is a weighted sum of a non-smooth function (cid:107) A (cid:107) 1 and a continously differentiable function g ( A ) :
= 12 (cid:107) A O − H
( A ; h ) (cid:107) 2 F .
Notice though that g ( A ) is non-convex and its gradient is only locally Lipschitz continuous due to the graph ﬁlter H
( A ; h ) ; except when
K = 1 , but the afﬁne case is not interesting since A O is just a scaled version of A L .
By virtue of the polynomial structure of the non-convexity, provably convergent iterations can be derived using e.g., the Bregman proximal gradient method (Bolte et al., 2018) for judiciously chosen kernel generating distance; see also (Zhang & Hong, 2020).
But our end goal here is not to solve (3) iteratively, recall we cannot even formulate the problem because H ( A ; h ) is unknown.
To retain the essence of the problem structure and motivate a parametric model to learn approximate solutions, it sufﬁces to settle with conceptual proximal gradient (PG) iterations ( k henceforth denote iterations, A [0] ∈ A )
[Equation]
where τ is a step-size parameter in which we have absorbed λ .
These iterations implement a gradient descent step on g followed by the (cid:96) 1 norm’s proximal operator; for more on PG algorithms see (Parikh & Boyd, 2014).
Due to the non-negativity constraints in A , the (cid:96) 1 norm’s proximal operator takes the form of a τ -shifted ReLU on the off-diagonal entries of its matrix argument.
Also, the operator sets diag ( A [ k + 1]) = 0 .
In the next section, we unroll and truncate these iterations to arrive at the trainable GDN parametric model Φ( A O ; Θ ) .
4. L EARNING TO INFER GRAPHS VIA ALGORITHM UNROLLING
The idea of algorithm unrolling can be traced back to the seminal work of (Gregor & LeCun, 2010).
In the context of sparse coding, they advocated identifying iterations of PG algorithms with layers in a deep network of ﬁxed depth that can be trained from examples using backpropagation.
One can view this process as effectively truncating the iterations of an asymptotically convergent procedure, to yield a template architecture that learns to approximate solutions with substantial computational savings relative to the optimization algorithm.
Beyond parsimonious signal modeling, there has been a surge in popularity of unrolled deep networks for a wide variety of applications; see e.g., (Monga et al., 2021) for a recent tutorial treatment focused on signal and image processing.
However, to the best of our knowledge this approach is yet to be explored for latent graph learning.
Building on the algorithm unrolling paradigm, our idea is to design a non-linear, parameterized, feed-forward architecture that can be trained to predict the latent graph ˆ A L =
Φ( A O ; Θ ) .
To this end, we approximate the gradient ∇ g ( A ) by retaining only linear terms in A , and build a deep network by composing layer-wise linear ﬁlters and point-wise nonlinearites to capture higherorder interactions in the generative process H ( A ; h ) :
= (cid:80) Kk =
h k A k .
In more detail, we start by simplifying ∇ g ( A ) (derived in Appendix A.6) by dropping all higher-order terms in A , namely
[Equation]
Notice that ∇ A Tr (cid:2)
H 2 ( A ; h ) (cid:3) is a polynomial of degree 2 K − 1 .
Hence, we keep the linear term in A but drop the constant offset that is proportional to I , which is inconsequential to adjacency matrix updates with null diagonal.
An afﬁne approximation will lead to more benign optimization landscapes when it comes to training the resulting GDN model.
All in all, the PG iterations become
[Equation]
where A [0] ∈ A
and we deﬁned α :=
(1 − 2 τh 0 h 2 − τh 21 ) , β := τh 2 , and γ := τh 1 .
The latter parameter triplet encapsulates ﬁlter (i.e., mixture) coefﬁcients and the λ -dependent algorithm step-size, all of which are unknown in practice.
The GDN architecture is thus obtained by unrolling the algorithm (6) into a deep neural network; see Figure 1.
This entails mapping each individual iteration into a layer and stacking a prescribed number D of layers together to form Φ( A O ; Θ ) .
The unknown ﬁlter coefﬁcients are treated as learnable parameters Θ := { α, β, γ, τ } , which are shared across layers as in recurrent neural networks (RNNs).
The reduced number of parameters relative to most typical neural networks is a characteristic of unrolled networks (Monga et al., 2021).
In the next section, we will explore a few customizations to the architecture in order to broaden the model’s expressive power.
Given a training set T = { A ( i ) O , A ( i ) L } Ti =1 , learning is accomplished by using mini-batch stochastic gradient descent to minimize the task-dependent loss function L ( Θ ) in (2).
We adopt a hinge loss for link prediction and mean-squared/absolute error for the edge-weight regression task.
For link prediction, we also learn a threshold t ∈ R + to binarize the estimated edge weights and declare presence or absence of edges; see Appendix A.4 for all training-related details including those concerning loss functions.
The iterative reﬁnement principle of optimization algorithms naturally carries over to our GDN model during inference.
Indeed, we start with an initial estimate A [0] ∈ A and use a cascade of
D linear ﬁlters and point-wise non-linearities to reﬁne it to an output ˆ A L = Φ( A O ; Θ ) .
Matrix
A [0] is a hyperparameter we can select to incorporate prior information on the sought latent graph, or it could be learned; see Section 4.3.
The input graph A O to deconvolve is directly fed to all layers as in a residual neural network, and its role is also noteworthy.
First, the constant matrix γ A O − τ 11 (cid:62) deﬁnes non-uniform soft thresholds to effectively sparsify the ﬁlter output per layer.
Second, one can interpret α A
+ β ( A O A
+ AA O )
as a ﬁrst-order graph ﬁlter deﬁned on A O , which is used to process A – here viewed as a (graph) signal with N features per node to invoke this graph signal processing insight.
In its simplest rendition, the GDN architecture brings together elements of RNNs, ResNets and graph convolutional networks (GCNs) (Kipf & Welling, 2017) .
4. GDN ARCHITECTURE ADAPTATIONS
Here we outline several customizations and enhancements to the vainilla GDN architecture of the previous section, which we have empirically found to improve graph learning performance.
Incorporating prior information via algorithm initialization.
By viewing our method as an iterative reﬁnement of an initial graph A [0] , one can think of A [0] as a best initial guess, or prior , over
A L .
A simple strategy to incorporate prior information about some edge ( i, j ) , encoded in A ij that we view as a random variable, would be to set A [0] ij =
E
[ A ij ] .
This technique is adopted when training on the HCP-YA dataset in Section 5.2, by taking the prior A [0] to be the sample mean of all latent (i.e., SC) graphs in the training set.
This encodes our prior knowledge that there are strong similarities in the structure of the human brain across the population of healthy young adults.
When
A L is expected to be reasonably sparse, we can set A [0] = 0 , which is effective as we show in Table 1.
Recalling the connections drawn between GDNs and RNNs, then the prior A [0] plays a similar role to the initial RNN input and thus it could be learned.
In any case, the ability to seamlessly incorporate prior information to the model is an attractive feature of GDNs, and differentiates it from other methods trying to solve the network inverse problem.
Multi-Input Multi-Output (MIMO) ﬁlters.
So far, in each layer we have a single learned ﬁlter, which takes an N × N matrix as input and returns another N × N matrix at the output.
After going through the shifted ReLU nonlinearity, this reﬁned output adjacency matrix is fed to the input to the next layer; a process that repeats D times.
More generally, we can allow for multiple input channels (i.e., a tensor), as well as multiple channels at the output, by using the familiar convolutional neural network (CNN) methodology.
This way, each output channel has its own ﬁlter parameters associated with every input channel.
The j -th output channel applies its linear ﬁlters to all input channels, aggregating the results with a reduction operation (e.g., mean or sum), and applies a point-wise nonlinearity (here a shifted ReLU) to the output.
This allows the GDN model to learn many different ﬁlters, providing richer learned representations.
We denote this more expressive architecture as GDN-share- C , emphasizing the MIMO ﬁlter with C input and output channels and whose parameters are shared across layers.
Full details of MIMO ﬁlters are given in Appendix A.5.
Decoupling layer parameters.
Thus far, we have respected the parameter sharing constraint imposed by the unrolled PG iterations.
We now allow each layer to learn a decoupled MIMO ﬁlter, with its own set of parameters mapping from C kin input channels to C kout output channels.
As the notation suggests, C kin and C kout need not be equal.
By decoupling the layer structure, we allow
GDNs to compose different learned ﬁlters to create more abstract features (as with CNNs or GCNs).
Accordingly, it opens up the architectural design space to broader exploration, e.g., wider layers early and skinnier layers at the end.
Exploring this architectural space is beyond the scope of this paper and is left as future work.
In subsequent experiments, the GDN model for which intermediate layers k ∈ { 2 , . . .
, D − 1 } have
C = C
kin
=
C kout , i.e., a ﬂat architecture, is denoted as GDN- C .
E XPERIMENTS
We present experiments on link prediction and edge-weight regression tasks using synthetic data (Section 5.1), as well as real HCP-YA neuroimgaging and social network data (Section 5.2).
In the link-prediction task, performance is evaluated using error :
= incorrectly predicted edges total possible edges .
For regression, we adopt the mean-squared-error (MSE) or mean-absolute-error (MAE) as ﬁgures of merit.
In the synthetic data experiments we consider three test cases whereby the latent graphs are respectively drawn from ensembles of Erd˝os-R´enyi (ER), random geometric (RG), and Barab´asi-Albert
[Table]
(BA) random graph models.
We study an additional scenario where we use SCs from HCP-YA (referred to as the ‘pseudo-synthetic’ case because the latent graphs are real structural brain networks).
We compare GDNs against several relevant baselines: Network Deconvolution (ND) which uses a spectral approach to directly invert a very speciﬁc convolutive mixture (Feizi et al., 2013); Spectral Templates (SpecTemp) that advocates a convex optimization approach to recover sparse graphs from noisy estimates of A O ’s eigenvectors (Segarra et al., 2017); Graphical LASSO (GLASSO), a regularized MLE of the precision matrix for Gaussian graphical model selection (Friedman et al., 2008); least-squares ﬁtting of h followed by non-convex optimization to solve (3) (LSOpt); and
Hard Thresholding (Threshold) to assess how well a simple cutoff rule can perform.
Unless otherwise stated, in all the results that follow we use GDN(-share) models with D = 8 layers and train using the Adam optimizer (Kingma & Ba, 2015) with learning rate of 0.01 and batch size of 200.
5. L ATENT GRAPH STRUCTURE IDENTIFICATION FROM DIFFUSED SIGNALS
A set of latent graphs are either sampled from RG, ER, or the BA model, or taken as the SCs from the HCP-YA dataset.
In an attempt to make the latent graphs somewhat comparable, across all models we let N = 68 (as constrained by the regions of interest in the adopted brain atlas), we force connectivity, and edge sparsity levels in the range [0 . 5 , 0 . 6] when feasible (these are also typical SC values).
To generate each observation A ( i )
O , we simulated P = 50 standard Normal, white signals diffused over A ( i ) L ; from which we form the sample covariance ˆ Σ x as in Section 3.
We let K = 2 , and sample the ﬁlter coefﬁcients h ∈ R 3 in H ( A L ; h ) uniformly from the unit sphere.
To examine robustness to the realizations of h , we repeat this data generation process three times (resampling the ﬁlter coefﬁcients).
We thus create three different datasets for each graph domain (12 in total).
For the sizes of the training/validation/test splits, the pseudo-synthetic domain uses 913 / 50 / 100 and the synthetic domains use 913 / 500 / 500 .
All models on synthetics are trained using A [0] = 0 , while models on the SCs take their prior as the edge-wise mean across all SCs in the training split.
Table 1 tabulates the results for synthetic and pseudo-synthetic experiments.
For graph models that exhibit localized connectivity patterns (RG and SC), GDNs signiﬁcantly outperform the baselines on both tasks.
For the SC test case, GDN (GDN-share) reduces error relative to the mean prior by 27 .
48 ± 1 .
02 ± 1 .
73% ) and MSE by 37 .
34 ± 0 .
23 ± 0 .
Both GDN architectures show the ability to learn such local patterns, with the extra representational power of
GDNs (over GDN-share) providing an additional boost in performance.
All models struggle on BA and ER with GDNs showing better performance even for these cases.
Size generalization: Deploying on larger graphs.
Unlike CNNs and GNNs, GDNs learn the parameters of graph convolutions for the processing of graphs, not the signals supported on them.
GDNs are inductive and allow us to deploy the learnt model on larger graph size domains.
To test Most the extent to which GDNs generalize when N grows, we train four GDN models (GDN-share-1,
GDN-share-8, GDN-1, GDN-8) on RG graphs with size N = 68 , and tested them on RG graphs of size N =
[68 , 75 , 100 , 200 , 500 , 1000 , 2000 , 4000] , with 200 graphs of each size.
As graph sizes increase, we require more samples in the estimation of the sample covariance to maintain a constant signal-to-noise ratio.
To simplify the experiment and its interpretation, we disregard estimation and directly use the ensemble covariance A O ≡ Σ x as observation.
As before, we take a training/validation split of 913 / 500 .
Figure 2 shows all GDN models effectively generalize to graphs orders of magnitude larger than they were trained on, giving up only modest levels of performance as size increases.
For N = 4000 , all but one of GDN models performed better than any baseline did on the original 68 node graphs.
The GDN-share models maintain their top performance, with
GDN-share-1 even further reducing error as the domain gets larger.
This suggests that the GDNs without parameter sharing may be using their extra representational power to pick up on ﬁnite-size effects, which may disappear as N increases.
The shared layer constraint in GDN-share models acts as regularization: we avoid over-ﬁtting on a given size domain to better generalize to larger graphs.
Ablation studies.
The choice of prior can inﬂuence model performance, as well as reduce training time and the number of parameters needed.
When run on stochastic block model (SBM) graphs with
N = 21 nodes and 3 equally-sized communities (within block connection probability of 0 . 6 , and 0 .across blocks), for the link-prediction task GDNs attain an error of 16 .
8 ± 2 .
7 e - 2% , 16 . 0 ± 2 .
1 e - 2% , 14 . 5 ± 1 .
e - 2% , 14 . 3 ± 8 .
8 e - 2% using a zeros, ones, block diagonal, and learned prior, respectively.
The performance improves when GDNs are given an informative prior (here a block diagonal matrix matching the graph communities), with further gains when GDNs are allowed to learn A [0] .
We also study the effect of gradient truncation.
To derive GDNs we approximate the gradient ∇ g ( A ) by dropping all higher-order terms in A ( K = 1 ).
The case of K = 0 corresponds to further dropping the terms linear in A , leading to PG iterations
A [ k + 1] =
ReLU ( A [ k ] + γ
A
O − τ 11 (cid:62) )
[cf.
We run this simpliﬁed model with D = 8 layers and 8 channels per layer on the same
RG graphs presented in Table 1.
Lacking the linear term that facilitates information aggregation in the graph, the model is not expressive enough and yields a higher error (MSE) of 25 . 72 ± 1 .
3 e - 2% ( 1 . 7 e - 1 ±
7 e - 4 ) for the link-prediction (edge weight regression) task.
Models with K ≥ 2 result in unstable training, which motivates our choice of K = 1 in GDNs.
5. R EAL D ATA
HCP-YA neuroimaging dataset.
HCP represents a unifying paradigm to acquire high quality neuroimaging data across studies that enabled unprecedented quality of macro-scale human brain connectomes for analyses in different domains (Glasser et al., 2016).
We use the dMRI and resting state fMRI data from the HCP-YA dataset (Van Essen et al., 2013), consisting of 1200 healthy, young adults (ages: 22-36 years).
The SC and FC are projected on a common brain atlas, which is a grouping of cortical structures in the brain to distinct regions.
We interpret these regions as nodes in a brain graph.
For our experiments, we use the standard Desikan-Killiany atlas (Desikan et al., 2006) with N = 68 cortical brain regions.
The SC-FC coupling on this dataset is known to be the strongest in occipital lobe and vary with age, sex and cognitive health in other subnetworks (Gu et al., 2021).
Under the consideration of the variability in SC-FC coupling across the brain regions, we further group the cortical regions into 4 larger regions called ‘lobes’: frontal, parietal, temporal, and occipital (the locations of these lobes in the brain are included in Fig.
4 in Appendix A.7).
We aim to predict SC, derived from dMRI, using FC, constructed using BOLD signals acquired with fMRI.
From this data, we extracted a dataset of 1063 FC-SC pairs, T = { F C ( i ) , SC ( i ) } 1063 i =1 and use a training/validation/test split of 913 / 50 / 100 .
Taking the prior A [0] as the edgewise mean over all
SCs in the training split T train : A [0] ij = mean { SC (1) i,j , . .
, SC (913) i,j } and using it directly as a predictor on the test set (tuning a threshold with validation data), we achieve strong performance on link-prediction and edge-weight regression tasks on the whole brain (error = 12 .
25% , MAE = 0 . 0615 ).
At the lobe level, the prior achieves relatively higher accuracy in occipital (error = 98 .
71% , MAE = 0 .
056 ) and parietal (error = 93 .
63% MAE = 0.065) lobes as compared to temporal (error = 88 .
76% , MAE = 0 . 05 ) and frontal (error = 89 .
55% , MAE = 0 .
059 ) lobes; behavior which is unsurprising as SC in temporal and frontal lobes are affected by ageing and gender related variability in the dataset (Zimmermann et al., 2016).
GDNs reduced MAE by 7 . 62% , 7 . 07% , 1 .
58% , and 1 . 29% in the temporal, frontal, parietal, and occipital networks respectively and 7 .
95% over the entire brain network, all relative to the already strong mean prior.
The four lobe reductions are visualized in Figure 2.
Clearly, there was smaller room for improvement in performance over occipital and frontal lobes.
We observed the most signiﬁcant gains over temporal and frontal lobes.
In summary, our pseudo-synthetic experiments in Section 5.1 show that SCs are amenable to learning with GDNs when the SC-FC relationship satisﬁes (1), a reasonable model given the ﬁndings of (Abdelnour et al., 2014).
In general, SC-FC coupling can vary widely across both the population and within the sub-regions of an individuals brain for healthy subjects and in pathological contexts.
Therefore, our results on HCP-YA dataset could potentially serve as baselines that characterize healthy subjects, and expanding our work to study the deviations in ﬁndings on similar data in a pathological context would be of future interest.
When trained on the HCP-YA dataset, the GDN model exhibits robust performance over such regions with high variability in SC-FC coupling.
Friendship recommendation from physical co-location networks.
Here we use GDNs to predict
Facebook ties given human co-location data.
GDNs are well suited for this deconvolution problem since one can view friendships as direct ties, whereas co-location edges include indirect relationships due to casual encounters in addition to face-to-face contacts with friends.
A trained model could then be useful to augment friendship recommendation engines given co-location (behavioral) data.
The
Thiers13 dataset (G ´ enois & Barrat, 2018) monitored high school students, recording (i) physical co-location interactions with wearable sensors over 5 days; and (ii) social network information via survey.
From this we construct a dataset T of graph pairs, each with N = 120 nodes, where A O are co-location networks, i.e., weighted graphs where the weight of edge ( i, j ) represents the number of times student i and j came into physical proximity, and A L is the Facebook subgraph between the same students; further details are in Appendix A.7.
We trained a GDN- 11 , without MIMO ﬁlters, with learned A [0] using a training/validation/test split of 5000 / 1000 / 1000 .
We achieved a test error of 8 . 9 ± 1 .
5 e - 2% , a 12 . 98% reduction over next best performing baseline (results in Appendix A.7).
C ONCLUSIONS
In this work we proposed the GDN, an inductive model capable of recovering latent graph structure from observations of its convolutional mixtures.
By minimizing a task-dependent loss function,
GDNs learn ﬁlters to reﬁne initial estimates of the sought latent graphs layer by layer.
The unrolled architecture can seamlessly integrate domain-speciﬁc prior information about the unknown graph distribution.
Moreover, because GDNs: (i) are differentiable functions with respect to their parameters as well as their graph input; and (ii) offer explicit control on complexity (leading to fast inference times); one can envision GDNs as valuable components in larger (even online) end-toend graph representation learning systems.
This way, while our focus here has been exclusively on network topology identiﬁcation, the impact of GDNs can permeate to broader graph inference tasks.
Reproducibility statement.
Code for running these experiments has been included in a zipped directory with the submission and contains instructions for conﬁguring a system to run experiments presented above.
When randomness is involved, as is the case when constructing the synthetic datasets, sampling white signals for diffusion, constructing a random split of the HCP-YA data, or initializing the parameters of our model before training, we use a consistent and clearly deﬁned random seed, allowing others to reproduce the results presented.
For the derivation of the model, we provide further details in Appendix A.6 to supplement those shown in the main paper body (Section 4.1).
In Appendix A.7 we refer the readers to the HCP website, where one can download the HCPYA data, as well as references to the processing pipelines used to construct the FCs and SCs used in this paper.
The processed brain data was too large to include with the code, but is available upon request.
A A PPENDIX A. M ODEL I DENTIFIABILITY
Without any constraints on h and A L , the problem of recovering A L from A O = H
( A L ; h ) as in (1) is clearly non-identiﬁable.
Indeed, if the desired solution is A L (with associated polynomial coefﬁcients h ), there is always at least another solution A O corresponding to the identity polynomial mapping.
This is why adding structural constraints like sparsity on A L will aid model identiﬁability, especially when devoid of training examples.
It is worth mentioning that (1) implies the eigenvectors of A L and A O coincide.
So the eigenvectors of the sought latent graph are given once we observe A O , what is left to determine are the eigenvalues.
We have in practice observed that for several families of sparse, weighted graphs, the eigenvector information along with the constraint A L ∈
A are sufﬁcient to uniquely specify the graph.
Interestingly, this implies that many random weighted graphs can be uniquely determined from their eigenvectors.
This strong uniqueness result does not render our problem vacuous, since seldomly in practice one gets to observe A O (and hence its eigenvectors) error free.
If one were to formally study identiﬁability of (1) (say under some structural assumptions on
A L and/or the polynomial mapping), then one has to recognize the problem suffers from an inherent scaling ambiguity.
Indeed, if given A O = H ( A L ; h ) which means the pair A L and h
=
[ h 0 , h 1 , . . .
, h K ] (cid:62) is a solution, then for any positive scalar α one has that α A L and [ h 0 , h 1 /α, . . .
, h K / ( α K )] (cid:62) is another solution.
Accordingly, uniqueness claims can only be meaningful modulo this unavoidable scaling ambiguity.
But this ambiguity is lifted once we tackle the problem in a supervised learning fashion – our approach in this paper.
The training samples in
T :=
{ A ( i ) O , A ( i ) L } Ti =1 ﬁx the scaling, and accordingly the GDN can learn the mechanism or mapping of interest
A O
(cid:55)→ A L .
Hence, an attractive feature of the GDN approach is that by using data, some of the inherent ambiguities in (1) are naturally overcome.
In particular, the SpecTemp approach in (Segarra et al., 2017) relies on convex optimization and suffers from this scaling ambiguity, so it requires an extra (rather arbitrary) constraint to ﬁx the scale.
The network deconvolution approach in (Feizi et al., 2013) relies on a ﬁxed, known polynomial mapping, and while it does not suffer from these ambiguities it is limited in the graph convolutions it can model.
All in all, the inverse problem associated to (1) is just our starting point to motivate a trainable parametrized architecture ˆ A L =
Φ( A O ; Θ ) , that introduces valuable inductive biases to generate graph predictions.
The problem we end up solving is different (recall the formal statement in Section 2) because we rely on supervision using graph examples, thus rendering many of these challenging uniqueness questions less relevant.
A. G RAPH C ONVOLUTIONAL M ODEL IN C ONTEXT
To further elaborate on the relevance and breadth of applicability of the graph convolutional (or network diffusion) signal model x
= H
( A L ; h ) w , we would like to elucidate connections with related work for graph structure identiﬁcation.
Note that while we used the diffusion-based generative model for our derivations in Section 3, we do not need it as an actual mechanistic process.
Indeed, like in (1) the only thing we ask is for the data covariance
A
O = Σ x to be some analytic function of the latent graph A L .
This is not extraneous to workhorse statistical methods for topology inference, which (implicitly) make speciﬁc choices for these mappings, e.g. (i) correlation networks (Kolaczyk, 2009, Ch. 7) rely on the identity mapping Σ x = A L ; (ii) Gaussian graphical model selection methods, such as graphical lasso in (Yuan & Lin, 2007; Friedman et al., 2008), adopt
Σ x =
A − 1 L ; and (iii) undirected structural equation models x =
A L x + w which implies Σ x = ( I − A L ) − 2 (Mateos et al., 2019).
Accordingly, these models are subsumed by the general framework we put forth here.
A. I NCORPORATING P RIOR I NFORMATION
In Section 4.3 we introduce the concept of using prior information in the training of GDNs.
We do so by encoding information we may have about the unknown latent graph A L into A
[ O ] , the starting matrix which GDNs iteratively reﬁne.
If the A L ’s are repeated instances of a graph with ﬁxed nodes, as is the case with the SCs with respect to the 68 ﬁxed brain regions, a simple strategy to incorporate prior information about some edge A L i,j , now viewed as a random variable, would be A
i,j ← E
[ A
L i,j ] .
But there is more that can be done.
We also can estimate the variance Var( A L i,j ) , and use it during the training of a GDN, for example taking A 0 i,j ← N ( E [ A L i,j ] , Var( A L i,j )) , or even simpler, using a resampling technique and taking A 0 i,j to be a random sample in the training set.
By doing so, we force the GDN to take into account the distribution and uncertainty in the data, possibly leading to richer learned representations and better performance.
It also would act as a form of regularization, not allowing the model to converge on the naive solution of outputting the simple expectation prior, a likely local minimum in training space.
A. T RAINING
Training of the GDN model will be performed using stochastic (mini-batch) gradient descent to minimize a task-dependent loss function L ( Θ ) as in (2).
The loss is deﬁned either as (i) the edgewise squared/absolute error between the predicted graph and the true graph for regression tasks, or (ii) a hinge loss with parameter γ ≥ 0 , both averaged over a training set T :=
{ A ( i ) O , A ( i ) L } Ti =1 , namely
[Equation]
L − Φ( A ( i ) O ; Θ ) (cid:13)(cid:13)(cid:13) 2 2 , (cid:96) ( [Equation] i ) L
[Equation]
i ) O [Equation] )) mae :
= (cid:13)(cid:13)(cid:13) [Equation] i [Equation]
[Equation]
( i
[Equation] O [Equation] ) (cid:13)(cid:13)(cid:13) 1 ,
L ( Θ ) :
= 1 T (cid:88)
i ∈T (cid:96) u
( A ( i ) L , Φ( A ( i )
O ; Θ )) , u ∈ { hinge, mse, mae } .
Link prediction with GDNs and unbiased estimates of generalization.
In the edge-weight regression task, GDNs only use their validation data to determine when training has converged.
When performing link-prediction, GDNs have an additional use for this data: to choose the cutoff threshold t ∈ R + , determining which raw outputs (which are continuous) should be considered positive edge predictions, at the end of training .
We use the training set to learn the parameters (via gradient descent) and to tune t .
During the validation step, when then use this train-set-tuned- t on the validation data, giving an estimate of generalization error.
This is then used for early-stopping, determining the best model learned after training, etc.
We do not use the validation data to tune t during training.
Only after training has completed, do we tune t with validation data.
We train a handful of models this way, and the model which produces the best validation score (in this case lowest error) is the tested with the validationtuned- t , thus providing an unbiased estimate of generalization.
A. MIMO M ODEL A RCHITECTURE
MIMO ﬁlters.
Formally, the more expressive GDN architecture with MIMO (Multi-Input MultiOutput) ﬁlters is constructed as follows. At layer k of the neural network, we take a three-way tensor A k ∈ R C × N × N + and produce A k +1 ∈ R C × N × N + , where C is the common number of input and output channels. The assumption of having a common number of input and output channels can be relaxed, as we argue below.
By deﬁning multiplication between tensors T , B ∈ R C × N × N as batched matrix multiplication: [ TB ] j, : , : := T j, : , : B j, : , : , and tensor-vector addition and multiplication as T + v := T +[ v 1 11 (cid:62) ; . . . ; v C 11 (cid:62) ] and [ v T ] j, : , : := v j T j, : , : respectively for v ∈ R C , all operations extend naturally. Using these deﬁnitions, the j -th output slice of layer k is [Equation]
where · · · represents the mean reduction over the ﬁltered input channels and the parameters are α , β , γ ∈ R C × C , τ ∈ R C + . We now take Θ := { α , β , γ , τ } for a total of C × (3 C + 1) trainable parameters. We typically have a single prior matrix A [0] and are interested in predicting a single adjacency matrix ˆ A L . Accordingly, we construct a new tensor prior A [0] :=
[ A [0] , . . . ,
A [0]] ∈ R C × N × N and (arbitrarily) designate the ﬁrst output channel as our prediction ˆ A L =
Φ( A O ; Θ ) =
[ A k +1 ] 1 , : , : .
We can also allow each layer to learn a decoupled MIMO ﬁlter, with its own set of parameters mapping from C kin input channels to C kout output channels. As the notation suggests, C kin and C kout need not be equal. Layer k now has its own set of parameters Θ k
= ( α k , β k , γ k , τ k ) , where α k , β k , γ k ∈ R C kout × C kin and τ k ∈ R C kout + , for a total of C kout × (3 C kin + 1) trainable parameters. The tensor operations mapping inputs to outputs remains basically unchanged with respect to (7), except that the ﬁlter coefﬁcients will depend on k .
Processing at a generic layer k is depicted in Figure 3. Output channel j will use α k : ,j , β k : ,j , γ k : ,j ∈ R C kin and τ kj ∈ R + to ﬁlter all input channels i ∈ { 1 , · · · , C kin } , which are collected in the input tensor A k ∈ R C kin × N × N .
This produces a tensor of stacked ﬁltered input channels ∈
R C kin × N × N .
After setting the diagonal elements of all matrix slices in this tensor to 0 , then perform a mean reduction edgewise (over the ﬁrst mode/dimension) of this tensor, producing a single N × N matrix.
We then apply two pointwise/elementwise operations on this matrix: (i) subtract τ kj (this would be the ‘bias’ term in CNNs); and (ii) apply a point-wise nonlinearity (ReLU).
This produces an N × N activation stored in the j -th output channel. Doing so for all output channels j ∈ { 1 , · · · , C kout } , produces a tensor A k +1 ∈ R C kout × N × N .
Layer output normalization and zeroing diagonal.
The steps not shown in the main text are the normalization steps, a practical issue, and the setting of the diagonal elements to be 0 , a projection onto the set A of allowable adjacency matrices.
Deﬁne U j, : , : = α k : ,j A k + β k : ,j ( A O A k + A k A O ) + γ k : ,j A O ∈ R N × N as the j -th slice in the intermediate tensor
U ∈ R C kout × N × N used in the ﬁltering of A k .
Normalization is performed by dividing each matrix slice of U by the maximum magnitude element in that respective slice: U · , : , : / max (cid:12)(cid:12) U · , : , : (cid:12)(cid:12) .
Multiple normalization metrics were tried on the denominator, including the 99 th percentile of all values in U · , : , : , the Frobenius norm (cid:107) U · , : , : (cid:107) F , among others.
None seemed to work as well as the maximum magnitude element, which has the additional advantage of guaranteeing entries to be in [0 , 1] (after ReLU), which matches nicely with: (i) adjacency matrices of unweighted graphs; and (ii) makes it easy to normalize edge weights of a dataset of adjacencies: simply scale them to [0 , 1] .
In summary, the full procedure to produce [ A k +1 ] j, : , : is as follows:
[Equation]
force diagonal elements to
[Equation]
normalize entries per slice to be in [ − 1 , 1]
[Equation]
By normalizing in this way, we guarantee the intermediate matrix U j, : , : has entries in [ − 1 , 1] (before the ReLU).
This plays two important roles.
The ﬁrst one has to do with training stability and to appreciate this point consider what could happen if no normalization is used.
Suppose the entries of U j, : , : are orders of magnitude larger than entries of U l, : , : .
This can cause the model to push τ kj >> τ kl , leading to training instabilities and/or lack of convergence.
The second point relates to interpretability of τ .
Indeed, the proposed normalization allows us to interpret the learned values τ k ∈ R kout, + on a similar scale.
All the tresholds must be in [0 , 1] because: (i) anything abovewill make the output all 0 ; and (ii) we constrain it to be non-negative.
In fact we can now plot all τ values (from all layers) against one another, and using the same scale ( [0 , 1] ) interpret if a particular τ is promoting a lot of sparsity in the output ( τ close to 1 ) or not ( τ close to 0 ), by examining its magnitude.
A. G RADIENT USED IN P ROXIMAL G RADIENT I TERATIONS
Here we give mathematical details in the calculation of the gradient ∇ g ( A ) of the component function g ( A ) :
= 12 (cid:107) A O − H
( A ; h ) (cid:107) 2 F in the objective function of.
Let A ,
A O be symmetric N × N matrices and recall the graph ﬁlter H
( A ) :
= (cid:80) Kk =
h
k
A k (we drop the dependency in h to simply the notation).
Then
[Equation]
where in arriving at the second equality we relied on the cyclic property of the trace, and H 1 ( A ) is a matrix polynomial of order 2 K − 1 .
Note that in the context of the GDN model, powers of A will lead to complex optimization landscapes, and thus unstable training.
We thus opt to drop the higher-order terms and work with a ﬁrst-order approximation of ∇ g , namely
[Equation]
A. N OTES ON THE E XPERIMENTAL S ETUP
Synthetic graphs.
For the experiments presented in Table 1, the synthetic graphs of size N =are drawn from random graph models with the following parameters
• Random geometric graphs (RG): d = 2 , r = 0 .
• Erd˝os-R´enyi (ER): p = .
When sampling graphs to construct the datasets, we reject any samples which are not connected or have sparsity outside of a given range.
For RG and ER, that range is [0 . 5 , 0 . 6] , while in BA the range is [0 . 3 , 0 . 4] .
This is an attempt to make the RG and ER graphs similar to the brain SC graphs, which have an average sparsity of 0 . 56 , and all SCs are in sparsity range [0 . 5 , 0 . 6] .
Due to the sampling procedure of BA, it is not possible to produce graph in this sparsity range, so we lowered the range sightly.
We thus take SCs to be an SBM-like ensemble and avoid a repetitive experiment with randomly drawn SBM graphs.
Note that the sparsity ranges deﬁne the performance of the most naive of predictors: all ones/zeros.
In the RG/BA/SC, an all ones predictor achieves an average error of 44% = 1 − (average graph sparsity).
In the BAs, a naive all zeros predictor achieves 35% = 1 − (average graph sparsity).
This is useful to keep in mind when interpreting the results in Table 1.
Pseudo-synthetics.
The Pseudo-Synthetic datasets are those in which we diffuse synthetic signals over SCs from the HCP-YA dataset.
This is an ideal setting to test the GDN models: we have weighted graphs to perform edge-regression on (the others are unweighted), while having A O ’s that are true to our modeling assumptions.
Note that SCs have a strong community-like structure, corresponding dominantly to the left and right hemispheres as well as subnetworks which have a high degree of connection, e.g. the Occipital Lobe which has 0.96 sparsity - almost fully connected - while the full brain network has sparsity of 0 .
Error and MSE of the baselines in Table 1.
The edge weights returned by the baselines can be very small/large in magnitude and perform poorly when used directly in the regression task.
We thus also provide a scaling parameter, tuned during the hyperparameter search, which provides approximately an order of magnitude improvement in MSE in GLASSO and halved the MSE in Spectral Templates and Network Deconvolution.
In link-prediction, we also tune a hard thresholding parameter on top of each method to clean up noisy outputs from the baseline, only if it improved their performance (it does).
For complete details on the baseline implementation, see A.8.
Size generalization.
Something to note is that we do not tune the threshold (found during training on the small N = 68 graphs) on the larger graphs.
We go straight from training to testing on the larger domains.
Tuning the threshold using a validation set (of larger graphs) would represent an easier problem.
The model at no point, or in any way, is introduced to the data in the larger size domains for any form of training/tuning.
We decide to use the covariance matrix in this experiment, as opposed to the sample covariance matrix, as our A O ’s. This is for the simple reason that it would be difﬁcult to control the snr with respect to generalization error and would be secondary to the main thrust of the experiment.
When run with number of signals proportional to graph size, we see quite a similar trend, but due to time constraints, these results are not presented herein, but is apt for follow up work.
HCP data.
HCP-YA provides up to 4 resting state fMRI scanning sessions for each subject, each lasting 15 minutes.
We use the fMRI data which has been processed by the minimal processing pipeline (Van Essen et al., 2013).
For every subject, after pre-processing the time series data to be zero mean, we concatenate all available time-series together and compute the sample covariance matrix (which is what as used are A O in the brain data experiment 5.2).
Due to expected homogeneity in SCs across a healthy population, information about the SC in the test set could be leveraged from the SCs in the training set.
In plainer terms, the average SC in the training set is an effective predictor of SCs in the test set.
In our experiments, we take random split of the 1063 SCs into 913 / 50 / 100 training/validation/test sets, and report how much we improve upon this predictor.
Raw data available [Table]
Co-location and social networks among high school students.
The Thiers13 dataset (G´enois &
Barrat, 2018) followed students in a French high school in 2013 for 5 days, recording their interactions based on physical proximity (co-location) using wearable sensors as well as investigating social networks between students via survey.
The co-location study traced 327 students, while a subset of such students ﬁlled out the surveys (156).
We thus only consider the 156 students who have participated in both studies.
The co-location data is a sequence of time intervals, each interval lists which students were within a physical proximity to one another in such interval.
To construct the co-location network, we let vertices represent students and assign the weight on an edge between student i and student j to represent the (possibly 0) number of times over the 5 day period the two such students were in close proximity with one another.
The social network is the Facebook graph between students: vertex i and vertex j have an unweighted edge between them in the social network if student i and student j have are friends in Facebook.
Thus we now have a co-location network
A O, total and a social network A L, total .
To construct a dataset of graph pairs T
= { A O ( i ) , A L ( i ) } 7000 i
= we draw random subsets of N = 120 vertices (students).
For each vertex subset, we construct a single graph pair by restricting the vertex set in each network to the sampled vertices, and removing all edges which attach to any node not in the subset.
If either of the resulting graph pairs are not connected, the sample is not included.
The performance of the baselines on such a dataset is as follows:
Threshold ( 10 . 2 ± 1 .
8 e - 2% ), ND ( 10 . 6 ± 1 .
9 e - 2% )
, GLASSO (NA - could not converge for any of the α values tested), SpecTemps ( 10 . 7 ± 6 .
9 e - 2% ).
A. B ASELINES
In the broad context of network topology identiﬁcation, recent latent graph inference approaches such as DGCNN (Wang et al., 2019), DGM (Kazi et al., 2020), NRI (Kipf et al., 2018), or
PGN (Veliˇckovi´c et al., 2020) have been shown effective in obtaining better task-driven representations of relational data for machine learning applications, or to learn interactions among coupled dynamical systems.
However, because the proposed GDN layer does not operate over node features, none of these state-of-the-art methods are appropriate for tackling the novel network deconvolution problem we are dealing with here.
Hence, for the numerical evaluation of GDNs we chose the most relevant baseline models that we outline in Section 5, and further describe in the sequel.
We were as fair as possible in the comparison of GDNs to baseline models.
All baselines were optimized to minimize generalization error, which is what is presented in Table 1.
Many baseline methods aim to predict sparse graphs on their own, yet many fail to bring edge values fully to zero.
We thus provide a threshold, tuned for generalization error using a validation set, on top of each method only if it improved the performance of the method in link-prediction.
The edge weights returned by the baselines can be very small/large in magnitude and perform poorly when used directly in the the regression task.
We thus also provide a scaling parameter, tuned during the hyperparameter search, which provides approximately an order of magnitude improvement in MSE for GLASSO and halved the MSE for Spectral Templates and Network Deconvolution.
Hard Thresholding (Threshold).
The hard thresholding model consists of a single parameter τ , and generates graph predictions as follows
[Equation]
where I {·} is an indicator function, and τ denotes entry-wise inequality.
For the synthetic experiments carried out in Section 5.1 to learn the structure of signals generated via network diffusion,
A O is either a covariance matrix or a correlation matrix.
We tried both choices in our experiments, and reported the one that performed best in Table 1.
Graphical Lasso (GLASSO).
We found taking the absolute value of GLASSO improved its performance, and so we include that in the model.
We ﬁrst take the absolute value of the GLASSO output, and then hard thresholded it using τ .
[Equation]
There are two hyperparameters to tune for link-prediction (and a third, the scaling parameter described above, in regression).
α :
= nonnegative regularization parameter in GLASSO τ := nonnegative threshold used to map values into binray decisions on the existance of an edge
We used the sklearn GLASSO implementation found here: https://scikit-learn.org/ stable/modules/generated/sklearn.covariance.graphical_lasso.html
It is important to note that we do not use the typical cross-validation procedure seen with GLASSO.
Typically, GLASSO is used in unsupervised applications with only one graph being predicted from s observations.
In our application, we are predicting many graphs, each with s observations.
Thus the typical procedure of choosing α using the log-likelihood (the non-regularized part of the
GLASSO objective) over splits of the observed signals, not splits of the training set , results in worse performance (and a different α for each graph).
This is not surprising: exposing the training procedure to labeled data allows it to optimize for generalization.
We are judging the models on their ability to generalize to unseen graphs, and thus the typical procedure would provide an unfair advantage to our model.
While we tried both sample covariance and sample correlation matrices as
A O , we found that we needed the normalization that the sample correlation provides, along with an additional scaling by the maximum magnitude eigenvalue, in order to achieve numerical stability.
GLASSO can take a good amount of time to run, and so we limited the validaiton and test set sizes to an even 100 / 100 split.
With only 2 to 3 hyperparameters to tune, we found this was sufﬁcient (no signiﬁcant differences between validation and test performance in all runs, and when testing on larger graph sizes, no difference in generalization performance).
Network Deconvolution (ND).
The Network Deconvolution approach is “a general method for inferring direct effects from an observed correlation matrix containing both direct and indirect effects” (Feizi et al., 2013).
Network Deconvolution follows three steps: linear scaling to ensure all eigenvalues λ
i of A O fall in the interval λ i ∈ [ − 1 , 1] , eigen-decomposition of the scaled
A O = V diag ( λλλ ) V − 1 , and deconvolution by applying f ( λ i ) =
λ i
+ λ i to all eigenvalues.
We then construct our prediction as ˆ A L := V diag ( f ( λλλ ))
V − 1 .
In (Feizi et al., 2013), it is recommended a Pearson correlation matrix be constructed, which we followed.
We applied an extra hard thresholding on the output, tuned for best generalization error, to further increase performance.
For each result shown 500 graphs were used in the hyperparameter search and 500 were used for testing.
Spectral Templates (SpecTemp).
The Spectral Templates method consists of solving two convex optimizations problems multiple times.
We ﬁrst perform a binary search on (cid:15) ∈ R + over the interval [0 , 2] to ﬁnd (cid:15) min , which is the smallest value which allows a feasible solution to optimization problem (8).
[Equation]
Where V is the orthogonal eigenvector matrix V :
= [ v 1 , ..., v N ] and λλλ the corresponding eigenvalues of S : S = V diag ( λλλ ) V T .
S denotes the convex set of allowable adjacency matrices representing undirected graphs with no self-loops: hollow (zero diagonal), symmetric, with non-negative entries.
Note that ¯ λ ¯ λ ¯ λ ∈ R N is an optimization variable, while λλλ ∈ R N are the true eigenvalues of S (which are unknown and not used in the optimization).
With (cid:15) min in hand, we now run an iteratively re-weighted L1 norm problem with the aim of further pushing small edge weights to 0 .
Deﬁning W t [Equation] =
[Equation]
where γ, δ ∈ R + are appropriately chosen positive constants and S ∗ 0 :=
S ∗ ( (cid:15) min ) , we solve a sequence t = 1 , . . .
, T weighted L1 norm minimization problems.
[Equation]
If any of these iteratively-reweighted problems is infeasible S ∗ I is returned, where I ∈ { 0 , 1 , . .
, T } is the last successfully obtained solution.
Finally, a threshold τ is chosen with a validation set to map the output to binary decision over edges.
[Equation]
We solve these optimization problems using MOSEK solvers in CVXPY.
Solving such convex optimization problems can very computationally expensive/slow, and because there are only two hyperparameters, 100 graphs were used in the validation set, and 100 in the test set.
Least Squares plus Non-convex Optimization (LSOpt).
LSOpt consists of ﬁrst estimating the polynomial coefﬁcients in (1), and then using the found coefﬁcients in the optimization of (3), a non-convex problem.
Due to the collinearity between higher order matrix powers, ridge regression can be used in the estimation of the polynomial coefﬁcients.
If the true order K of the polynomial is not known ahead of time, one can allow ˆ h ∈ R N and add L1 regularization. With ˆ h in hand, we optimize (3), a non-convex problem due to the higher order powers of A , using Adam with a learning rate of . 01 and a validation set of size 50 to tune λ . We start with the most favorable setup, using the true h in the optimization of (3), skipping the least squares estimation step. Even in such a favorable setup the results were not in general competitive, and so instead of further degrading performance by estimating ˆ h , we report these optimistic estimates of generalization error.
A. S OURCE C ODE AND C ONFIGURATION
Code has been made available in a zipped directory with the submission.
Refer to the README for instructions on conﬁguring a system to run the code.
We rely on PyTorch heavily and use Conda to make our system as hardware-independant as possible.
GPUs were used to train the larger GDNs, which are available to use for free on Google Colab.
Development was done on Mac and Linux (Ubuntu) systems, and not tested on Windows machines.
The processed brain data was too large to include with the code, but is available upon request.