Gated Graph Convolutional Recurrent Neural Networks

TL;DR

This paper introduces Gated Graph Convolutional Recurrent Neural Networks (GCRNNs) designed for graph-based problems like earthquake epicenter detection and weather prediction, offering improved performance and parameter efficiency.

Contribution

It presents a novel GCRNN architecture with a gated variation, enhancing graph sequence modeling with fewer parameters and better accuracy than existing methods.

Findings

GCRNNs outperform existing GNNs and graph recurrent models in experiments.

GCRNNs use convolutional filter banks to keep parameters independent of graph size.

Gated GCRNNs further improve performance with a time-gating mechanism.

Abstract

Graph processes model a number of important problems such as identifying the epicenter of an earthquake or predicting weather. In this paper, we propose a Graph Convolutional Recurrent Neural Network (GCRNN) architecture specifically tailored to deal with these problems. GCRNNs use convolutional filter banks to keep the number of trainable parameters independent of the size of the graph and of the time sequences considered. We also put forward Gated GCRNNs, a time-gated variation of GCRNNs akin to LSTMs. When compared with GNNs and another graph recurrent architecture in experiments using both synthetic and real-word data, GCRNNs significantly improve performance while using considerably less parameters.

Tables

Table 1. Table I : Test accuracy and # of parameters for each model in the epicenter placement problem for 30s and 60s waves.

	30-second wave		60-second wave
Architecture	Accuracy (%)	Param.	Accuracy (%)	Param.
GCRNN	$33.33$	$14,880$	$32.93$	$58,560$
Gated GCRNN	$38.32$	$29,520$	$39.12$	$116,640$
GNN	$28.34$	$14,880$	$30.74$	$58,560$

Equations

$$[\mathbf{S}\mathbf{x}{]}_i=\sum _{j=1}^N[\mathbf{S}{]}_{ij}[\mathbf{x}{]}_j=\sum _{j\in {\mathcal{N}}_i}{s}_{ij}{x}_j.$$

$${\mathbf{X}}_t=\left[{\mathbf{x}}_t^1,\dots ,{\mathbf{x}}_t^F\right]=\left[\begin{array}{c}({\tilde{\mathbf{x}}}_t^1{)}^{\mathsf{T}}\\ ⋮\\ ({\tilde{\mathbf{x}}}_t^N{)}^{\mathsf{T}}\end{array}\right].$$

$${\mathbf{h}}_t=\sigma \left(\mathbf{A}{\mathbf{x}}_t+\mathbf{B}{\mathbf{h}}_{t-1}\right),$$

$${\mathbf{h}}_{t}=\sigma\big{(}{\mathbf{A}}({\mathbf{S}}){\mathbf{x}}_{t}+{\mathbf{B}}({\mathbf{S}}){\mathbf{h}}_{t-1}\big{)}\ .$$

$${\mathbf{h}}_t^d=\sigma \left(\sum _{f=1}^F{\mathbf{A}}^{df}(\mathbf{S}){\mathbf{x}}_t^f+\sum _{d^{\prime }=1}^D{\mathbf{B}}^{d{d}^{\prime }}(\mathbf{S}){\mathbf{h}}_{t-1}^{d^{\prime }}\right),$$

$${\mathbf{A}}^{df}(\mathbf{S})=\sum _{k=0}^{K-1}{a}_k^{df}{\mathbf{S}}^k,{\mathbf{B}}^{d{d}^{\prime }}(\mathbf{S})=\sum _{k=0}^{K-1}{b}_k^{d{d}^{\prime }}{\mathbf{S}}^k,$$

$${\mathbf{H}}_t=\left[{\mathbf{h}}_t^1,\dots ,{\mathbf{h}}_t^D\right]=\left[\begin{array}{c}({\tilde{\mathbf{h}}}_t^1{)}^{\mathsf{T}}\\ ⋮\\ ({\tilde{\mathbf{h}}}_t^N{)}^{\mathsf{T}}\end{array}\right],$$

$${\hat{\mathbf{y}}}_t^g=\rho \left(\sum _{d=1}^D{\mathbf{C}}^{gd}(\mathbf{S}){\mathbf{h}}_t^d\right),{\mathbf{C}}^{gd}(\mathbf{S})=\sum _{k=0}^{K-1}{c}_k^{gd}{\mathbf{S}}^k,$$

$${\widehat{\tilde{\mathbf{y}}}}_t^i=\mathbf{C}{\tilde{\mathbf{h}}}_t^i$$

$${\mathbf{h}}_{t}^{d}=\sigma\bigg{(}\alpha_{t}\sum_{f=1}^{F}{\mathbf{A}}_{d}^{f}({\mathbf{S}}){\mathbf{x}}_{t}^{f}+\beta_{t}\sum_{d^{\prime}=1}^{D}{\mathbf{B}}_{d}^{d^{\prime}}({\mathbf{S}}){\mathbf{h}}_{t-1}^{d^{\prime}}\bigg{)}\ ,$$

$${\mathbf{\mu }}_t^u=\xi \left(\sum _{f=1}^F{\mathbf{\Gamma }}^{uf}(\mathbf{S}){\mathbf{x}}_t^f+\sum _{u=1}^U{\mathbf{\Delta }}^{u{u}^{\prime }}(\mathbf{S}){\mathbf{\mu }}_{t-1}^{u^{\prime }}\right),$$

$${\alpha }_t=\mathrm{sigmoid}({\mathbf{\omega }}^{\mathsf{T}}[({\mathbf{\mu }}_t^1{)}^{\mathsf{T}},\dots ,({\mathbf{\mu }}_t^U{)}^{\mathsf{T}}{]}^{\mathsf{T}}).$$

$${\mathbf{\nu }}_t^v=\eta \left(\sum _{f=1}^F{\mathbf{\Phi }}^{vf}(\mathbf{S}){\mathbf{x}}_t^f+\sum _{v^{\prime }=1}^V{\mathbf{\Psi }}^{v{v}^{\prime }}(\mathbf{S}){\mathbf{\nu }}_{t-1}^{v^{\prime }}\right).$$

$${\beta }_t=\mathrm{sigmoid}({\mathbf{\tau }}^{\mathsf{T}}[({\mathbf{\nu }}_t^1{)}^{\mathsf{T}},\dots ,({\mathbf{\nu }}_t^V{)}^{\mathsf{T}}{]}^{\mathsf{T}})$$

$${\mathbf{x}}_t=\mathbf{S}{\mathbf{x}}_{t-1}+{\mathbf{w}}_t,$$

Full text

I Introduction

The availability of ever-growing volumes of data — often referred to as big data — has propelled the use of neural network architectures in both engineering and less traditional fields, such as medicine [1] and business consulting [2]. But learning from large datasets comes with a challenge: it requires complex models with many parameters which, on the one hand, are time and memory-intensive and, on the other, increase the risk of overfitting. To get around these issues, a lot of effort has been put into designing architectures that exploit the underlying structure of data using an amenable number of parameters. The first example are Convolutional Neural Networks (CNNs) [3], which use banks of convolutional filters whose number of parameters is independent of the size of the input to extract shared features across grid-like signals (e.g. images). Then, there are Graph Convolutional Neural Networks (GNNs) [4, 5, 6, 7], which achieve the same purpose on graph data using graph convolutional filters also known as linear shift-invariant graph filters (LSI-GFs) [8]. A third example are Recurrent Neural Networks (RNNs) [9], designed to process sequential data through the addition of a state or memory variable that stores past information.

The sequences processed by RNNs are usually temporal processes, but they are rarely one-dimensional, i.e., they do not vary only in time. In particular, we will be interested in sequences that are best represented by graph processes [10]. Graph processes model a variety of important problems; some illustrative examples are weather prediction from data collected at weather station networks [11] and identifying the epicenter of an earthquake from seismic waves [12].

To deal with these scenarios, we introduce a Graph Convolutional Recurrent Neural Network (GCRNN) architecture where the hidden state is a graph signal computed from the input and the previous state using banks of graph convolutional filters and, as such, stored individually at each node. In addition to being local, in GCRNNs the number of parameters to learn is independent of time because the graph filters that process the input and the state are the same at every time instant. GCRNNs can take in graph processes of any duration, which gives control over how frequently gradient updates occur. They can also learn many different representations: a signal (whether supported on a graph or not) or a sequence of signals; a class label or a sequence of labels. While other graph-based recurrent architectures have been proposed in [13, 14, 15], they are limited to representing sequences of graph signals and, in general, problem specific (most commonly to traffic forecasting). A fourth graph recurrent formulation has been introduced in [16], but it uses recurrence as a way of re-introducing the input data at each layer to capture multiple types of diffusion, and as such does not operate on graph processes. In this architecture, the number of learnable parameters also depends on the number of recurrent layers.

Our GCRNN architecture is further extended to include time gating variables analogous to the input and forget gates of Long Short Term Memory units (LSTMs) [9], which are also implemented using GCRNNs. The objective of gating is twofold: on the input side, to control the importance given to new information, and on the state side, how much of the stored past information the model should “forget”.

GCRNNs’ ability to learn both graph and time dependencies and the importance of the gating mechanism for long input sequences are demonstrated in experiments on synthetic and real-world data. GCRNNs are compared with basic GNNs and with the DCRNN, a gated graph recurrent architecture from the existing literature [13]. Numerical results show that: (i) GCRNNs largely improve upon GNNs when processing sequential graph data, and (ii) our model uses considerable less parameters and achieves better performance than the DCRNN.

II Graph Processes

Let ${\mathcal{G}}=({\mathcal{V}},{\mathcal{E}},{\mathcal{W}})$ be a graph where ${\mathcal{V}}$ is a set of $N$ nodes, ${\mathcal{E}}\subseteq{\mathcal{V}}\times{\mathcal{V}}$ is the set of edges and ${\mathcal{W}}:{\mathcal{E}}\to{\mathbb{R}}$ is a function that assigns weights to each edge. The topology of the graph ${\mathcal{G}}$ can be described by a matrix ${\mathbf{S}}\in{\mathbb{R}}^{N\times N}$ that captures the sparsity pattern of its structure, i.e., $[{\mathbf{S}}]_{ij}=s_{ij}$ can be nonzero only if $(j,i)\in{\mathcal{E}}$ or $j=i$. Typical choices for this matrix in the literature are the adjacency [17], the Laplacian [18], the random walk [19] and their normalized counterparts [6, 4]. We define the neighborhood of node $i$ as ${\mathcal{N}}_{i}=\{j\in{\mathcal{V}}:(j,i)\in{\mathcal{E}}\}$, and use the expression local operations to refer to operations that can be computed by successive interactions of a node $i$ with its neighborhood ${\mathcal{N}}_{i}$.

We model data as graph signals: a graph signal ${\mathbf{x}}:{\mathcal{V}}\to{\mathbb{R}}$ is such that each element $[{\mathbf{x}}]_{i}=x_{i}$ corresponds to the value of the graph signal at node $i\in{\mathcal{V}}$. The most basic interaction between the graph signal ${\mathbf{x}}$ and the graph ${\mathcal{G}}$ is given by the operation ${\mathbf{S}}{\mathbf{x}}$, where, for each $i=1,\ldots,N$, we have

[TABLE]

The operation described by (1) is local, because its output can be computed by interacting only with ${\mathcal{N}}_{i}$ due to the sparsity pattern of ${\mathbf{S}}$. The matrix ${\mathbf{S}}$ has the effect of shifting around the graph the information contained in its nodes and is henceforth called the graph shift operator (GSO).

We are interested in graph signals that change with time over the same graph support, typically known as graph processes [10]. A graph process $\{{\mathbf{x}}_{t}\}_{t\in{\mathbb{N}}_{0}}$ is a sequence of graph signals ${\mathbf{x}}_{t}\in{\mathbb{R}}^{N}$, which are all defined over the same graph support, ${\mathbf{x}}_{t}:{\mathcal{V}}\to{\mathbb{R}}$. More often than not, there exists some dependency relationship between graph signals at different time instants. This (causal) dependency can be described, generically, by ${\mathbf{x}}_{t}=f({\mathbf{x}}_{t-1},{\mathbf{x}}_{t-2},\ldots)$ for some function $f$ that in practice is usually unknown.

The graph process is typically accompanied by some target representation ${\mathcal{Y}}$ relevant to the task at hand, which gives rise to pairs $(\{{\mathbf{x}}_{t}\},{\mathcal{Y}})$. In regression problems, the target representation is usually another sequence $\{{\mathbf{y}}_{t}\}$, while in classification problems it is a single element ${\mathbf{y}}$ characterizing the sequence over some time interval. The general objective of learning over sequences is to obtain a meaningful estimate $\hat{{\mathcal{Y}}}$ of the target representation ${\mathcal{Y}}$ using $\{{\mathbf{x}}_{t}\}$. To do this, we propose a novel architecture that we call the Graph Convolutional Recurrent Neural Network (GCRNN).

To enhance the descriptive capabilities of our data model, in what follows we consider sequences comprised of $F$ different features ${\mathbf{x}}_{t}^{f}$ for $f=1,\ldots,F$, where each ${\mathbf{x}}_{t}^{f}\in{\mathbb{R}}^{N}$ is a graph signal. A more compact representation is given by the matrix ${\mathbf{X}}_{t}\in{\mathbb{R}}^{N\times F}$, where each column ${\mathbf{x}}_{t}^{f}\in{\mathbb{R}}^{N}$ is a graph signal ($f=1,\ldots,F$) and each row ${\tilde{\mathbf{x}}}_{t}^{i}\in{\mathbb{R}}^{F}$ gathers the feature values collected at a single node ($i=1,\ldots,N$)

[TABLE]

While we have defined a local operation on ${\mathbf{x}}_{t}^{f}$ as one that respects the sparsity of the graph [cf. (1)], we note that any operation on ${\tilde{\mathbf{x}}}_{t}^{i}$ can be called local as well, since it involves values that are already available at that node.

III Graph Convolutional Recurrent

Neural Networks

A recurrent neural network (RNN) approximates the temporal dependencies of a sequence $\{{\mathbf{x}}_{t}\}$ using a hidden Markov model, i.e. ${\mathbf{x}}_{t+1}\approx g({\mathbf{x}}_{t},{\mathbf{h}}_{t})$ for some function $g$ and some hidden state sequence $\{{\mathbf{h}}_{t}\}$. The hidden state sequence is

[TABLE]

where ${\mathbf{A}}$ and ${\mathbf{B}}$ are linear transforms and $\sigma$ is a nonlinear function, so as to endow the RNN (3) with higher descriptive power. The representation estimate $\hat{{\mathcal{Y}}}$ can then be obtained from these hidden states. For instance, in a regression problem, we would have ${\hat{\mathbf{y}}}_{t}=\rho({\mathbf{C}}{\mathbf{h}}_{t})$ with $\rho$ a nonlinear function and ${\mathbf{C}}$ a linear transform, and in a classification problem, ${\hat{\mathbf{y}}}=\rho({\mathbf{C}}{\mathbf{h}}_{T})$ for the state ${\mathbf{h}}_{T}$ computed after some interval $T$.

The parameters of the linear transforms ${\mathbf{A}}$, ${\mathbf{B}}$ and ${\mathbf{C}}$ can be learned by minimizing some loss function ${\mathcal{L}}({\mathcal{Y}},\hat{{\mathcal{Y}}})$ over a training set ${\mathcal{T}}=\{(\{{\mathbf{x}}_{t}\},{\mathcal{Y}})\}$. We note that the learned linear transforms are the same for all $t$, giving the RNN (3) enough flexibility to adapt to sequences of different length. Likewise, the number of parameters is independent of the length of the sequence. The hidden state ${\mathbf{h}}_{t}$ is expected to store all the past information that is relevant for estimating the target representation.

The knowledge that the sequence $\{{\mathbf{x}}_{t}\}$ is comprised of graph signals defined over the same graph ${\mathcal{G}}$ with GSO ${\mathbf{S}}$ can be exploited by forcing the linear transforms ${\mathbf{A}}$ and ${\mathbf{B}}$ to account for this structure,

[TABLE]

We name model (4) a Graph Recurrent Neural Network (GRNN). A particularly compelling parametrization of the linear transforms ${\mathbf{A}}({\mathbf{S}})$ and ${\mathbf{B}}({\mathbf{S}})$ is given by banks of linear shift-invariant graph filters (LSI-GFs). LSI-GFs don the GRNN model (4) with convolutional characteristics, since they are permutation-invariant local operations and make the number of learnable parameters independent of the size of the graph. More precisely, let the hidden state be described by $D$ features, where each feature ${\mathbf{h}}_{t}^{d}\in{\mathbb{R}}^{N}$ is a graph signal. We define the Graph Convolutional Recurrent Neural Network (GCRNN) as

[TABLE]

where ${\mathbf{A}}^{df}({\mathbf{S}})$ and ${\mathbf{B}}^{dd^{\prime}}({\mathbf{S}})$ are the LSI-GFs

[TABLE]

for $d,d^{\prime}=1,\ldots,D$ and $f=1,\ldots,F$. The filter taps $\{a_{k}^{df}\}_{k=0}^{K-1}$ and $\{b_{k}^{dd^{\prime}}\}_{k=0}^{K-1}$ are the learnable parameters of the linear transform. Note that there are $DFK+D^{2}K$ such parameters and that their number is independent of the sequence length and of the size of the graph $N$. Another primary feature of GCRNNs is that the LSI-GFs (6) are local operations, since they can be computed by $K-1$ successive interactions with the neighbors of each node. The capacity of GCRNNs can be further increased (while maintaining the convolutional characteristics) by using graph convolutional neural networks [5] with several layers in place of ${\mathbf{A}}({\mathbf{S}})$ and ${\mathbf{B}}({\mathbf{S}})$ in (4).

Describing the hidden states ${\mathbf{h}}_{t}^{d}$ as a collection of $D$ graph signals lets us again exploit the graph structure in the computation of the target representation $\hat{{\mathcal{Y}}}$. Let ${\mathbf{H}}_{t}\in{\mathbb{R}}^{N\times D}$ be a matrix where the hidden states ${\mathbf{h}}_{t}^{d}\in{\mathbb{R}}^{N}$ are its columns,

[TABLE]

and where the rows of ${\mathbf{H}}_{t}$ collect the $D$ features at node $i$, ${\tilde{\mathbf{h}}}_{t}^{i}\in{\mathbb{R}}^{D}$ for $i=1,\ldots,N$. The estimated representation is computed as ${\hat{\mathbf{y}}}_{t}=\rho({\mathbf{C}}({\mathbf{S}}){\mathbf{H}}_{t})$ for the regression problem and ${\hat{\mathbf{y}}}=\rho({\mathbf{C}}({\mathbf{S}}){\mathbf{H}}_{T})$ for the classification problem. Operation ${\mathbf{C}}({\mathbf{S}})$ can be replaced by a graph convolutional neural network to exploit locality, followed by a fully connected layer to adapt dimensions when mapping ${\mathbf{H}}_{t}$ to ${\hat{\mathbf{y}}}_{t}$ or ${\hat{\mathbf{y}}}$.

The regression problem where the target representation sequence $\{{\mathbf{y}}_{t}\}$ is a sequence of graph signals ${\mathbf{y}}_{t}^{g}\in{\mathbb{R}}^{N}$, with $g=1,\ldots,G$ denoting different features, is of particular interest, as it allows for two possible local models to compute ${\hat{\mathbf{y}}}_{t}^{g}$. The first possibility is to apply a LSI-GF to ${\mathbf{h}}_{t}^{d}$,

[TABLE]

which demands $K-1$ successive interactions with the neighbors of each node. This requires $DGK$ learnable parameters. Alternatively, the second possibility is to estimate the target features at each node by applying a linear transformation to its own features,

[TABLE]

where ${\mathbf{C}}\in{\mathbb{R}}^{G\times D}$, for each $i=1,\ldots,N$. This alternative entails no neighbor interactions since ${\tilde{\mathbf{h}}}_{t}^{i}$ is stored at node $i$, and requires only $DG$ parameters if the same linear transform ${\mathbf{C}}$ is learned for all nodes.

IV Gating

Deeper RNNs allow taking long term dependencies into account, but this often comes with the challenge of vanishing gradients as long term interactions get exponentially smaller weights at each training step [9]. This is addressed by time gating mechanisms such as the input and forget gates of Long Short-Term Memory units (LSTMs) and the reset and update gates of Gated Recurrent Units (GRUs). These gates are essentially variables taking values between 0 and 1 — each one estimated by their own neural network model — that multiply either or both the input and the state to control the amount of information passed through with time.

Time gating can be readily extended to the context of graph processes. Based on the GCRNN model (5), we define a time-gated architecture as follows,

[TABLE]

where the parameter $\alpha_{t}\in[0,1]$ is the external input gate, and $\beta_{t}\in[0,1]$ is the forget gate. We call model (10) a Gated Graph Convolutional Recurrent Neural Network (GGCRNN). Note that $\alpha_{t}$ adjusts the importance given to the external inputs $\{{\mathbf{x}}_{t}^{f}\}_{f=1}^{F}$ at time $t$ and $\beta_{t}$ controls how much the GGCRNN (10) will forget (or, equivalently, remember) from the hidden states $\{{\mathbf{h}}_{t}^{d}\}_{d=1}^{D}$.

Each gate is calculated as the output of a new GCRNN (5) followed by a fully connected layer. To ensure that $\alpha_{t}$ and $\beta_{t}$ are well within the unit interval, a sigmoid activation function follows the fully connected layer computations. More precisely, let $\boldsymbol{\mu}_{t}^{u}\in{\mathbb{R}}^{N}$ be the $U$ graph signals that describe the state of the input gate (alternatively, let $\tilde{\boldsymbol{\mu}}_{t}^{i}\in{\mathbb{R}}^{U}$ be the $U$ internal values stored at node $i$ that determine the state of the input gate). These states are updated as

[TABLE]

where $\xi$ is a nonlinear function, and $\boldsymbol{\Gamma}^{uf}({\mathbf{S}})$ and $\boldsymbol{\Delta}^{uu^{\prime}}({\mathbf{S}})$ are LSI-GFs, cf. (6). The value $\alpha_{t}\in[0,1]$ of the input gate is then calculated by projecting the states $\{\boldsymbol{\mu}_{t}^{u}\}_{u=1}^{U}$ of the input gate onto a learned vector $\boldsymbol{\omega}\in{\mathbb{R}}^{NU}$ and applying a sigmoid

[TABLE]

Analogously, let $\boldsymbol{\nu}_{t}^{v}\in{\mathbb{R}}^{N}$ be $V$ graph signals that make up the state of the forget gate. These states are updated as

[TABLE]

with $\eta$ a nonlinear function, and $\boldsymbol{\Phi}^{vf}({\mathbf{S}})$ and $\boldsymbol{\Psi}^{vv^{\prime}}({\mathbf{S}})$ collections of LSI-GFs, cf. (6). Then, the forget gate $\beta_{t}\in[0,1]$ is computed as

[TABLE]

for some learned $\boldsymbol{\tau}\in{\mathbb{R}}^{NV}$.

Notice that $\alpha_{t}$ and $\beta_{t}$ are the same for every node and every feature, but vary with time. This allows exploiting local operations through the graph filters $\boldsymbol{\Gamma}$, $\boldsymbol{\Delta}$, $\boldsymbol{\Phi}$ and $\boldsymbol{\Psi}$, and keeps the number of learnable parameters under control.

V Numerical Experiments

In this section, we present numerical results obtained using multiple variations of our GCRNN architecture in a synthetic experiment — ten-step prediction — and a classification problem involving real seismic data. All simulated architectures consist of a 1-layer GCRNN (5) or GGCRNN (10) and an output neural network mapping the state ${\mathbf{H}}$ to the target representation ${\mathbf{Y}}$, which is either a GNN or a localized multi-layer perceptron that mixes each node’s local features individually, cf. (9). In all graph filters, the GSO is the adjacency matrix. The activation function in the GCRNNs is always the hyperbolic tangent, and in the intermediate layers of the output neural network it is the ReLU. In all experiments, the LSI-GFs (6) have $K=4$ filter taps. If a GCRNN is gated, the GCRNNs used to compute its input and forget gates have state variables with $U=V=D$ features and $K$ filter taps as well, and are always followed by output neural networks that are full MLPs with a total of $ND$ parameters. All architectures were optimized using ADAM [20] with decaying factors $\beta_{1}=0.9$ and $\beta_{2}=0.999$.

Ten-step prediction. In this experiment, we consider a stochastic block model (SBM) graph ${\mathcal{G}}$ with $N=20$ nodes, 4 communities and intra and inter-community edge probabilities of $0.8$ and $0.2$, respectively. Let ${\mathbf{S}}$ be the GSO of ${\mathcal{G}}$. Given an initial graph signal ${\mathbf{x}}_{0}\in{\mathbb{R}}^{N}$, $0\leq[{\mathbf{x}}_{0}]_{i}\leq 1$, the diffused signals ${\mathbf{x}}_{t},t=1,2,\ldots$, are generated as

[TABLE]

where ${\mathbf{w}}_{t}$ is a zero mean gaussian noise that can be correlated both in time and in between nodes. In particular, we chose $\sigma_{\text{time}}^{2}=0.01$ for the variance across time and $\sigma_{\text{nodes}}^{2}=0.01$ for the variance across nodes. Likewise, we set the crosscorrelation factors across time and nodes to $\rho_{\text{time}}=\rho_{\text{nodes}}=0.1$. Fixing the input sequence length to $T=10$, the $10$-step prediction problem consists of estimating ${\mathbf{x}}_{10},{\mathbf{x}}_{11},\dots,{\mathbf{x}}_{19}$ from ${\mathbf{x}}_{0},{\mathbf{x}}_{1},\dots,{\mathbf{x}}_{9}$.

We consider 4 GCRNN architectures. The first two are a GCRNN and a Gated GCRNN with $D=10$ state features whose output neural network is a 1-layer GNN with $K=4$ filter taps and without fully connected layers. The total number of parameters in these architectures are $480$ and $1,760$ ($480$ for the main GCRNN architecture, and $640$ for those of each gate) respectively. The baseline for comparison is a GNN with 2 convolutional layers and no fully connected layer containing $480$ parameters, the same as the non-gated GCRNN.

The other two architectures are a GCRNN and a Gated GCRNN where the output neural network is a localized MLP, consisting of the same $D$-parameter MLP per node. These were compared with the Diffusion Convolutional Recurrent Neural Network (DCRNN) from [13] with $1$ recurrent layer, $10$ recurrent units and diffusion length $4$. The number of parameters of the simple GCRNN, the Gated GCRNN and the DCRNN were $450$, $1,730$ and $3,370$ respectively.

All of these architectures were used to simulate the 10-step prediction problem in $10$ rounds, with $10$ different graphs and dataset realizations. In all rounds, the training, validation and test sets comprised $10,000$, $2,400$ and $200$ samples, respectively. All models were trained to optimize the L1 loss (mean absolute error) in 5 training epochs, with batch size 100 and learning rate $0.001$ for the GCRNNs followed by GNNs and $0.005$ for those followed by localized perceptrons. The average test losses and corresponding standard deviations for each architecture are shown in Figure 1. The main takeaway from Figure 1(a) is that the GCRNN, even when not gated and containing the same number of parameters as the GNN, achieves a considerably smaller loss than the non-recurrent GNN, which attests to the importance of the recurrence mechanism in processing time sequences. In Figure 1(b), although the difference among the average test losses achieved by each architecture is minimal, both GCRNN architectures have about a half or less of the $3,370$ parameters of the DCRNN (with the simple GCRNN counting as little as $450$ parameters), and present a much smaller variance as well.

Earthquake epicenter placement on a seismograph network. The second numerical experiment is a classification problem based on data from GeoNet [21], a geological hazard database from New Zealand, and the Incorporated Research Institutions for Seismology (IRIS) database [22], which contains data for 8 active seismographs in the country in the timeframe of analysis. By gathering the origin times of all earthquakes registered by GeoNet between 12/25/2018 and 02/25/2019, we obtain seismic wave readings at these seismographs $30\text{s}$ and $60\text{s}$ before each earthquake, sampled at $2\text{Hz}$. We then construct a 3 nearest-neighbor seismograph network from the seismographs’ coordinates, and from the earthquakes’ epicenter coordinates we generate labels corresponding to the nearest sensor to the earthquake’s epicenter. In this setting, the objective is to accurately predict the closest node to the epicenter of an earthquake from seismic waves collected at the network’s nodes immediately before the shock.

The experiment is conducted twice, once for the $30\text{s}$ and once for $60\text{s}$ duration wave. This results in input sequences with length $T=60$ and $T=120$ respectively. We consider 2 GCRNNs. They are: (i) a GCRNN followed by a GNN with 1 convolutional layer mapping the state features to a single feature, and (ii) its gated version. The number of state features are $60$ and $120$ for the $30\text{s}$ and $60\text{s}$ experiments respectively. In the GCRNNs, the input sequences are used to process a state variable of same length, but only the last state is fed into the output GNN for label prediction. The baseline is a GNN with 1 convolutional layer. Because GNNs cannot process sequences, each element of the sequence is interpreted as an input feature. The convolutional layer of this GNN maps $T$ input features to $T+2$ features, which comes down to $4T(T+2)$ parameters because the number of filter taps is always 4. This GNN was chosen to make for a reasonable comparison with the non-gated GCRNN, which has $4T^{2}+8T$ parameters.

Out of the $2,503$ earthquakes that happened in the two months to which we restrict our analysis, around $80\%$ were used for training and $20\%$ for testing each model. We optimize a cross-entropy loss with learning rate $0.001$ over 10 training epochs and in batches of 100. Test accuracy for each model and each experiment are reported in Table I, as well as the number of parameters in the convolutional layers of each architecture.

Even though all models achieve higher accuracy than random placement, the GCRNN architectures outperform a GNN with same number of parameters as the non-gated GCRNN. Table I also illustrates the importance of the gating mechanism as input sequences grow longer: the percentage difference in the test accuracy achieved by the gated GCRNN and the non-gated GCRNN is 23.8% bigger in the case of the 60-second wave.

VI Conclusions

We introduced Graph Convolutional Recurrent Neural Networks (GCRNNs) as NN architectures specifically tailored to deal with problems involving graph processes. Their primary feature is the use of banks of graph convolutional filters to implement the recurrence relationship. Thus, the number of parameters is independent of time and of the size of the graph. We have further extended this architecture to Gated GCRNNs (GGCRNNs) with input and forget gates that are akin to those of LSTMs. Numerical results obtained in a synthetic regression problem show that GCRNNs largely improve performance with respect to GNNs when the graph signals are part of a graph process. As for Gated GCRNNs, their ability to take long term dependencies into account was demonstrated in a real world experiment with different input sequence lengths.