T OPOLOGY A DAPTIVE G RAPH C ONVOLUTIONAL N ETWORKS
Anonymous authors
Paper under double-blind review
A BSTRACT
Convolution acts as a local feature extractor in convolutional neural networks (CNNs).
However, the convolution operation is not applicable when the input data is supported on an irregular graph such as with social networks, citation networks, or knowledge graphs.
This paper proposes the topology adaptive graph convolutional network (TAGCN), a novel graph convolutional network that generalizes CNN architectures to graph-structured data and provides a systematic way to design a set of ﬁxed-size learnable ﬁlters to perform convolutions on graphs.
The topologies of these ﬁlters are adaptive to the topology of the graph when they scan the graph to perform convolution, replacing the square ﬁlter for the grid-structured data in traditional CNNs.
The outputs are the weighted sum of these ﬁlters’ outputs, extraction of both vertex features and strength of correlation between vertices.
It can be used with both directed and undirected graphs.
The proposed TAGCN not only inherits the properties of convolutions in CNN for grid-structured data, but it is also consistent with convolution in traditional signal processing.
We apply
TAGCN to semi-supervised learning problems for graph vertex classiﬁcation; experiments on a number of data sets demonstrate that our method outperforms the existing graph convolutional neural networks and achieves state-of-the-art performance for each data set tested.
I NTRODUCTION
Convolutional neural network (CNN) architectures exhibit state-of-the-art performance on a variety of learning tasks dealing with 1D, 2D, and 3D grid-structured data such as acoustic signals, images, and videos, in which convolution serves as a feature extractor (LeCun et al., 2015).
However, the (usual) convolution operation is not applicable when applying CNN to data that is supported on an arbitrary graph rather than on a regular grid structure, since the number of neighbors of each vertex on the graph varies, and it is difﬁcult to design a ﬁxed-size ﬁlter scanning over the graph-structured data for feature extraction.
Recently, there has been an increasing interest in graph CNNs (Bruna et al., 2014; Defferrard et al., 2016; Kipf & Welling, 2017; Monti et al., 2017; Levie et al., 2017), attempting to generalize deep learning methods to graph-structured data, speciﬁcally focusing on the design of graph CNN .
In this paper, we propose the topology adaptive graph convolutional network (TAGCN), a uniﬁed convolutional neural network to learn nonlinear representations for the graph-structured data.
It slides a set of ﬁxed-size learnable ﬁlters on the graph simultaneously, and the output is the weighted sum of these ﬁlters’ outputs, which extract both vertex features and strength of correlation between vertices.
Each ﬁlter is adaptive to the topology of the local region on the graph where it is applied.
TAGCN uniﬁes ﬁltering in both the spectrum and vertex domains; and applies to both directed and undirected graphs.
In general, the existing graph CNNs can be grouped into two types: spectral domain techniques and vertex domain techniques.
In Bruna et al.
(2014), CNNs have been generalized to graph-structured data, where convolution is achieved by a pointwise product in the spectrum domain according to the convolution theorem.
Later, Defferrard et al.
(2016) and Levie et al.
(2017) proposed spectrum ﬁltering based methods that utilize Chebyshev polynomials and Cayley polynomials, respectively.
It is still not clear how to keep the vertex local property when ﬁltering in the spectrum domain.
Moreover, the assumption of symmetric adjacency matrix in these spectrum based methods restrict the application to undirected graphs.
Kipf & Welling (2017) simpliﬁed this spectrum method and obtained a ﬁlter in the vertex domain, which achieves state-of-the-art performance.
Other researchers (Atwood & Towsley, 2016; Monti et al., 2017) worked on designing feature propagation models in the vertex domain for graph CNNs.
Yang et al.
; Dai et al.
; Grover & Leskovec (2016);
Du et al.
(2016) study transforming graph-structured data to embedding vectors for learning problems.
Nevertheless, it still remains open how to extend CNNs from grid-structured data to arbitrary graph-structured data with local feature extraction capability.
In this paper, rather than designing a feature propagation model, we focus on implementing convolution in the vertex domain with a general ﬁxed-size ﬁlter adaptive to the graph local topology for feature exaction, which gives us the freedom to choose the size of local regions and leads to a nice nonlinearity representation capability.
Detailed comparison with existing methods can be found in Section 3.
In this paper, we present TAGCN to design convolutional deep architectures in the graph vertex domain for graph-structured data.
Our TAGCN method shows a systematic way to design a set of ﬁxed-size ﬁlters that is adaptive to the input graph topology when performing convolution on the graph.
Our contributions are as follows:
• We propose a general K -localized ﬁlter for graph convolution in the vertex domain to extract local features on a set of size- 1 up to size- K receptive ﬁelds.
The topologies of these ﬁlters are adaptive to the topology of the graph as they scan the graph to perform convolution.
It replaces the ﬁxed square ﬁlters in traditional CNNs for the input gridstructured data volumes in traditional CNNs.
Thus, our convolution deﬁnition that we use in the convolution step for the vertex domain is consistent with convolution in traditional CNNs.
• TAGCN uses the graph convolution theorem Sandryhaila & Moura (2013) (the Fourier transform of a convolution is the pointwise product of graph Fourier transforms) that shows the equivalence of performing ﬁltering in the spectrum or vertex domains.
This is consistent with convolution in signal processing.
Moreover, it applies to both directed and undirected graphs.
• We contrast TAGCN with recently proposed graph CNN including both spectrum ﬁltering methods (Bruna et al., 2014; Defferrard et al., 2016) and vertex domain propagation methods (Kipf & Welling, 2017; Monti et al., 2017; Atwood & Towsley, 2016), evaluating their performances on three commonly used data sets for graph vertices classiﬁcation.
Our experimental tests show that TAGCN outperforms consistently all other approaches for each of these data sets.
G RAPH POLYNOMIAL BASED CONVOLUTION ON GRAPHS
We use boldface uppercase and lowercase letters to represent matrices and vectors, respectively.
The information and their relationship on a graph G can be represented by G =
( V , E , ¯ A ) , where V is the set of vertices
, E is the set of edges, and ¯ A is the weighted adjacency matrix of the graph; the graph can be weighted or unweighted, directed or undirected.
We assume there is no isolated vertex in G .
If G is a directed weighted graph, the weight ¯ A n,m is on the directed edge from vertex m to n .
The entry ¯ A n,m reveals the dependency between node n and m and can take arbitrary real or complex values.
The graph convolution is general and can be adapted to graph CNNs for particular tasks.
In this paper, we focus on the vertex semisupervised learning problem, where we have access to limited labeled vertices, and the task is to classify the remaining unlabeled vertices.
2. G RAPH CONVOLUTION
Without loss of generality, we demonstrate graph convolution on the (cid:96) -th hidden layer.
The results apply to any other hidden layers.
Suppose on the (cid:96) -th hidden layer, the input feature map for each vertex of the graph has C (cid:96) features.
We collect the (cid:96) -th hidden layer input data on all vertices for the c -th feature by the vector x ( (cid:96) )
c ∈ R N (cid:96) , where c = 1 , 2 , . . .
C (cid:96) and N (cid:96) is the number of vertices 1 .
The components of x ( (cid:96) ) c are indexed by vertices of the data graph representation G =
( V , E , ¯ A ) 2 .
Let
G
[Equation]
) c
[Equation]
f ∈ R N (cid:96)
[Equation]
N (cid:96) denote the f -th graph ﬁlter.
The graph convolution is the matrix-vector product, i.e., G ( (cid:96) )
c,f x ( (cid:96) )
c .
Then the f -th output feature map is
[Equation]
where b ( (cid:96) )
f is a learnable bias, and 1 N (cid:96) is the N (cid:96) dimension vector of all ones.
We design G ( (cid:96) )
c,f such that G ( (cid:96) )
c,f x ( (cid:96) )
c is a meaningful convolution on a graph with arbitrary topology.
In the recent theory on graph signal processing (Sandryhaila & Moura, 2013), the graph shift is deﬁned as a local operation that replaces a graph signal at a graph vertex by a linear weighted combination of the values of the graph signal at the neighboring vertices:
[Equation]
The graph shift ¯ A extends the time shift in traditional signal processing to graph-structured data.
Following Sandryhaila & Moura (2013), a graph ﬁlter G ( (cid:96) )
c,f is shift-invariant, i.e., the shift ¯ A and the ﬁlter G ( (cid:96) ) c,f commute, ¯ A ( G ( (cid:96) )
c,f x ( (cid:96) ) c ) =
G ( (cid:96) )
c,f ( ¯ Ax ( (cid:96) ) c ) , if under appropriate assumption G ( (cid:96) )
c,f is a polynomial in A ,
[Equation]
In (2), the g ( (cid:96) ) c,f,k are the graph ﬁlter polynomial coefﬁcients; the quantity A
= D − 12 ¯ AD − 12 is the normalized adjacency matrix of the graph, and D = diag
[ d ] with the i th component being d ( i ) =
(cid:80)
j A
i,j .
We adopt the normalized adjacency matrix to guarantee that all the eigenvalues of A are inside the unit circle, and therefore G ( (cid:96) )
c,f is computationally stable.
The next subsection shows we will adopt 1 × C (cid:96) , 2 × C (cid:96) , . . .
, and K × C (cid:96) ﬁlters sliding on the graph-structured data.
This fact coincides with GoogLeNet (Szegedy et al., 2015), in which a set of ﬁlters with different sizes are used in each convolutional layer.
Following the CNN architecture, an additional nonlinear operation, e.g, rectiﬁed linear unit (ReLU) is used after every graph convolution operation:
[Equation]
where σ ( · ) denotes the ReLU activation function applied to the vertex values.
In the following subsection, we demonstrate that convolution operator shown in (2) exhibits the nice properties of a square ﬁlter in traditional CNNs and generalize the convolution theorem from classical signal processing to signal processing on graphs (Sandryhaila & Moura, 2013).
2. F ILTER DESIGN FOR TAGCN CONVOLUTIONAL LAYER
In traditional CNN, a K × K × C (cid:96) ﬁlter scans over the input grid-structured data for feature extraction.
For image classiﬁcation problems, the value K varies for different CNN architectures and tasks to achieve better performance.
For example, in VGG-Verydeep-16 CNN model (Simonyan &
Zisserman, 2015), only 3 × 3 × C (cid:96) ﬁlters are used; in ImageNet CNN model (Krizhevsky et al., 2012), 11 × 11 × C (cid:96) ﬁlters are adopted; and in GoogLeNet (Szegedy et al., 2015), rather than using the same size ﬁlter in each convolutional layer, different size ﬁlters, for example, 1 × 1 × C (cid:96) , 3 × 3 × C (cid:96) and 5 × 5 × C (cid:96) ﬁlters, are concatenated in each convolution layer.
Similarly, we propose a general K -localized ﬁlter for graph CNN.
For a graph-structured data, we cannot use a square ﬁlter window since the graph topology is no longer a grid.
In the following, we demonstrate that the convolution operation G ( (cid:96) )
c,f x ( (cid:96) )
c with G ( (cid:96) )
c,f a polynomial ﬁlter G ( (cid:96) )
c,f = (cid:80) Kk
=
g ( (cid:96) )
c,f,k A k is equivalent to using a set of ﬁlters with ﬁlter size from up to K .
Each k -size ﬁlter, which is used for local feature extraction on the graph, is k -localized in the vertex domain.
Deﬁne a path of length m on a graph G as a sequence v = ( v 0 , v 1 , ..., v m ) of vertices v k ∈ V such that each step of the path ( v k , v k +1 ) corresponds to an (directed) edge of the graph, i.e., ( v k , v k +1 ) ∈
E .
Here one path may visit the same vertex or cross the same edge multiple times.
The following adjacency matrix A is one such example:
[Equation]
 
[Equation] [Equation]
[Equation] [Equation]
[Equation]
· · ·   .
Since A is asymmetric, it represents a directed graph, given in Fig.
In this example, there are 6 different length 3 -paths on the graph from vertex 2 to vertex 1 , namely, (2 , 1 , 4 , 1) , (2 , 1 , 2 , 1) , (2 , 1 , 5 , 1) , (2 , 3 , 2 , 1) , (2 , 4 , 2 , 1) , and (2 , 4 , 5 , 1) .
We further deﬁne the weight of a path to be the product of the edge weights along the path, i.e., φ ( p 0 ,m ) =
(cid:81) mk =
A v k − 1 ,v k , where p 0 ,m = ( v 0 , v 1 , . . .
v m ) .
For example, the weight of the path (2 , 1 , 4 , 1) is 1 × 1 × 2 = 2 .
Then, the ( i, j ) th entry of A k in (2), denoted by ω ( p kj,i ) , can be interpreted as the sum of the weights of all the length- k paths from j to i , which is
[Equation]
In the above example, it can be easily veriﬁed that A 31 , 2 = 18 by summing up the weights of all the above six paths from vertex 2 to vertex 1 with length 3 .
Then, the i th component of A k x ( (cid:96) )
c is the weighted sum of the input features of each vertex x
( (cid:96) )
c that are length-
k paths away to vertex i .
Here, k is deﬁned as the ﬁlter size .
The output feature map is a vector with each component given by the size- k ﬁlter sliding on the graph following a ﬁxed order of the vertex indices.
The output at the i -th component can be written explicitly as (cid:80)
[Equation]
j ) .
This weighted sum is similar to the dot product for convolution for a grid-structured data in traditional
CNNs.
Finnaly, the output feature map is a weighted sum of convolution results from ﬁlters with different sizes, which is
[Equation]
The above equation shows that each neuron in the graph convolutional layer is connected only to a local region (local vertices and edges) in the vertex domain of the input data volume, which is adaptive to the graph topology.
The strength of correlation is explicitly utilized in ω ( p kj,i ) .
Fig.summarizes the graph convolution operation at each neuron.
We refer to this method as topology adaptive graph convolutional network (TAGCN).
In Fig.
2, we show TAGCN with an example of 2 -size ﬁlter sliding from vertex 1 (ﬁgure on the lefthand-side) to vertex 2 (ﬁgure on the right-hand-side).
The ﬁlter is ﬁrst placed at vertex 1 .
Since paths (1 , 2 , 1) (5 , 4 , 1) and so on (paths with red glow) are all 2 -length paths to vertex 1 , they are covered by this 2 -size ﬁlter.
Since paths (2 , 3) and (7 , 3) are not on any 2 -length path to vertex 1 , they are not covered by this ﬁlter.
Further, when this 2-size ﬁlter moves to vertex 2 , paths (1 , 5) , (4 , 5) and (6 , 5) are no longer covered, but paths (2 , 3) and (7 , 3) are ﬁrst time covered and contribute to the convolution with output at vertex 2 .
Further, y ( (cid:96) ) f ( i ) is the weighted sum of the input features of vertices in x ( (cid:96) )
c that are within k -paths away to vertex i , for k = 0 , 1 , . . .
K , with weights given by the products of components of A k and g ( (cid:96) )
c,f,k .
Thus the output is the weighted sum of the feature map given by the ﬁltered results from 1 -size up to K -size ﬁlters.
It is evident that the vertex convolution on the graph using K th order polynomials is K -paths localized.
Moreover, different vertices on the graph share g ( (cid:96) )
c,f,k .
The above local convolution and weight sharing properties of the convolution (3) on a graph are very similar to those in traditional CNN.
2. S PECTRUM RESPONSE OF TAGCN
In classical signal processing (Oppenheim & Schafer, 2009), the convolution in the time domain is equivalent to multiplication in the spectrum domain.
This relationship is known as the convolution theorem.
Sandryhaila & Moura (2013) showed that the graph ﬁltering deﬁned in the vertex domain satisﬁes the generalized convolution theorem naturally and can also interpret spectrum ﬁltering for both directed and undirected graphs.
Recent work (Bruna et al., 2014; Defferrard et al., 2016) used the convolution theorem for undirected graph-structured data and designed a spectrum graph ﬁltering.
Assume that the adjacency matrix A for a graph is diagonalizable, i.e., A = F − 1 JF with J a diagonal matrix.
The components on the diagonal of J are eigenvalues of A , and the column vectors of F −are the right eigenvectors of A ; the row vectors of F are the left eigenvectors of A 4 .
By diagonalizing
A in (2) for TAGCN, we obtain
[Equation]
The expression on the left-hand-side of the above equation represents the ﬁltering/convolution on the vertex domain.
Matrix F deﬁnes the graph Fourier transform (Sandryhaila & Moura, 2013; 2014), and Fx ( (cid:96) )
c is the input feature spectrum map, which is a linear mapping from the input feature on the vertex domain to the spectrum domain.
The polynomial (cid:80) Kk =0 g (
[Equation]
) c,f,k J k is the spectrum of the graph ﬁlter.
Relation (4), which is equation (27) in Sandryhaila & Moura (2013) generalizes the classical convolution theorem to graph-structured data: convolution/ﬁltering on the vertex domain becomes multiplication in the spectrum domain.
When the graph is in the 1D cyclic form, as shown in Fig.
3, the corresponding adjacency matrix is of the form
[Equation]
The eigendecomposition of A is
[Equation]
where DFT is the discrete Fourier transform matrix.
The convolution operator deﬁned in (2) is consistent with that in classical signal processing.
2. C OMPUTATION COMPLEXITY OF THE CONVOLUTION OPERATION
Equation (4) shows that TAGCN is equivalent to performing graph convolution either on the vertex domain or on the spectrum domain.
We next show that it is preferred to implement TAGCN in the vertex domain.
To obtain F , F − 1 and J , the eigendecomposition for a diagonalizable matrix is in general O ( N 3 ) .
If the graph is directed, A may only be block diagonalizable, needing the Jordan decomposition, which is sensitive to round-off errors.
Additional matrix and vector multiplications may be needed to project the ﬁltered out results from the spectrum domain back to the vertex domain.
In contrast, ﬁltering directly in the vertex domain that involves powers of the graph adjacency matrix with N vertices and M edges can be computed in O ( MN ) by performing a breadth-ﬁrst search starting from each vertex to determine the distances to all other vertices Hammack et al.
For a sparse graph, which is often the case in practical problems, M (cid:28) N .
Since the motivation for performing graph convolution is to detect local features for graph-structured data, the optimal K usually is very small.
The experiments section shows that a ﬁlter size K = 2 leads to the best performance is selected for the data sets and speciﬁc tasks tested.
In summary, using polynomial ﬁlters in the vertex domain rather than in the spectrum domain saves signiﬁcantly computational costs.
R ELATION WITH OTHER EXISTING FORMULATIONS
In this section, we show the connections and differences between the proposed TAGCN and existing methods.
In general, there are two types of graph convolution operators for the CNN architecture.
One deﬁnes the convolution in the spectrum domain, whose output feature map is the multiplication of the inverse Fourier transform matrix with the ﬁltered results in the spectrum domain (Bruna et al., 2014; Defferrard et al., 2016; Levie et al., 2017).
By doing further approximations based on this spectrum domain operator, a simpliﬁed convolution was obtained in Kipf & Welling (2017).
The other deﬁnes convolution by a feature propagation model in the vertex domain such as MoNet in
Monti et al.
and the diffusion CNN (DCNN) in Atwood & Towsley (2016).
We investigate in detail each alternative.
In Bruna et al.
(2014); Defferrard et al.
; Levie et al.
(2017), the convolution operation was deﬁned using the convolution theorem and ﬁltering operation in the spectrum domain by computing the eigendecomposition of the normalized Laplacian matrix of the graph.
The Laplacian matrix
L is deﬁned as L = D − A with the further assumption that A is symmetric to guarantee that L is positive semi-deﬁnite.
The convolution deﬁned by the multiplication in the spectrum domain is approximated by Defferrard et al.
(2016) by
[Equation]
where T k [ · ] is the k th order Chebyshev polynomial.
We refer later to this method as ChebNet for performance comparison.
Note that the Laplacian matrix can be seen as a differentiator operator.
It is not clear how to keep the vertex local property when ﬁltering in the spectrum domain via the
Laplacian matrix.
Moreover, the assumption of symmetric adjacency matrix restricts the application to undirected graphs.
In Kipf & Welling (2017), a graph convolutional network (GCN) was obtained by simplifying the spectrum method in Defferrard et al.
In particular, they start from (5) and make the assumptions that λ max = 2 , K = 1 , and θ
= θ 1 = θ .
Then a simpler convolution operator that does not depend on the spectrum knowledge is obtained as
[Equation]
Note that I + D − 12 AD − 12 is a matrix with eigenvalues in [0 , 2] .
A renormalization trick is adopted here by letting (cid:101)
A =
A + I
and (cid:101)
D i,i = (cid:80) j (cid:101)
A i,j .
Finally, the convolutional operator is
[Equation]
It is interesting to observe that this method though obtained by simplifying the spectrum method has a better performance than the spectrum method (Defferrard et al., 2016).
The reason may be because the simpliﬁed form is equivalent to propagating vertex features on the graph, which can be seen as a special case of our TAGCN method, though there are other important differences.
Simonovsky & Komodakis (2017) proposed the edge convolution network (ECC) to extend the convolution operator from regular grids to arbitrary graphs.
The convolution operator is deﬁned similarly to (6) as
[Equation]
with Θ ( (cid:96) )
j,i is the weight matrix that needs to be learned.
A mixture model network (MoNet) was proposed in Monti et al.
(2017), with convolution deﬁned as
[Equation]
where κ f is a Gaussian kernel with κ f = exp (cid:110) − 12 ( u − µ f ) T Σ − 1 f ( u − µ f ) (cid:111) and g f is the weight coefﬁcient for each Gaussian kernel κ f .
It is further assumed that Σ f is a 2 × 2 diagonal matrix.
GCN, ECC, and MoNet all design a propagation model on the graph; their differences are on the weightings used by each model.
[Table]
Atwood & Towsley (2016) proposed a diffusion CNN (DCNN) method that considers a diffusion process over the graph.
The transition probability of a random walk on a graph is given by P =
D − 1 A , which is equivalent to the normalized adjacency matrix.
[Table]
By comparing the above methods with TAGCN in (3), it can be concluded that GCN, ECC and
MoNet can be seen as a special case of TAGCN because in (3) the item with k = 1 can be seen as an information propagation term.
However, the strength of the correlation between vertices that are taken into account in ω ( p kj,i ) in (3) can not be utilized in the GCN, ECC and MoNet methods.
Further, the TAGCN method is a systematic way to design a set of ﬁxed size ﬁlters that is adaptive to the input graph topology when performing convolution on the graph.
Compared with existing spectrum methods (Bruna et al., 2014; Defferrard et al., 2016; Levie et al., 2017), TAGCN satisﬁes the convolution theorem as shown in the previous subsection and implemented in the vertex domain, which avoids performing costly and practically numerical unstable eigendecompositions.
We further compare the number of weights that need to be learned in each hidden layer for these different methods in Table 1.
As we show later, K = 2 is selected in our experiments using cross validation.
Thus we have a moderate number of weights to be learned.
In the following, we show that our method achieves the best performance for each of those commonly used graph-structured data sets.
E XPERIMENTS
The proposed TAGCN is general and can be ﬁt to the general graph CNN architectures for different tasks.
In the experiments, we focus on the vertex semisupervised learning problem, where we have access to only a few labeled vertices, and the task is to classify the remaining unlabeled vertices.
To compare the performance of TAGCN with that of existing methods, we extensively evaluate TAGCN on three graph-structured datasets, including the Cora, Citesser and Pubmed datasets.
The datasets split and experiments setting closely follow the standard criteria in Yang et al.
4. D ATASETS
TAGCN is evaluated on three data sets coming from citation networks: Citeseer, Cora, and Pubmed.
We closely follow the data set split and experimental setup in Yang et al.
Each data set consists of a certain classes of documents, yet only a few documents are labeled.
The task is to classify the documents in the test set with these limited number of labels.
In each data set, the vertices are the documents and the edges are the citation links.
Each document is represented by sparse bagof-words feature vectors, and the citation links between documents are provided.
Detailed statistics of these three data sets are summarized in Table 2.
It shows the number of nodes and edges that corresponding to documents and citation links.
Classes for the graph vertices shows the number of document classes in each data set.
Also, the number of features at each vertex is given.
Label rate denotes the number of labeled documents that are used for training divided by the total number of documents in each data set.
[Table] [Table]
4. E XPERIMENTAL SETTINGS
We construct a graph for each data set with nodes representing documents and undirected edgeslinking two papers if there is a citation relationship.
We obtain the adjacency matrix ¯ A with 0 andcomponents and further obtain the normalized matrix A .
In the following experiments
[Table]
we design a TAGCN with two hidden layers (obtained from cross validation) for the semi-supervised node classiﬁcation.
In each hidden layer, the proposed TAGCN is applied for convolution, followed by a ReLU activation.
16 hidden units (ﬁlters) are designed for each hidden layer, and dropout is applied after each hidden layer.
The softmax activation function is applied to the output of the second hidden layer for the ﬁnal classiﬁcation.
For ablation study, we evaluate the performance of TAGCN with different kernel size from 1 to 4.
To investigate the performance for different number of parameters, we also design a TAGCN with 8 ﬁlters for each hidden layer and compare its classiﬁcation accuracy with all the baselines and TAGCN withﬁlters.
We train our model using Adam (Kinga & Ba, 2015) with a learning rate of 0 . 01 and early stopping with a window size of 20 .
Hyperparameters of the networks (ﬁlter size, dropout rate, and number of hidden layers) are selected by cross validation.
To make a fair comparison, we closely follow the same split of training, validation, and testing sets as in Kipf & Welling (2017)
; Yang et al.
(2016), i.e., 500 labeled examples for hyperparameters (ﬁlter size, dropout rate, and number of hidden layers) optimization and cross-entropy error is used for classiﬁcation accuracy evaluation.
The performance results of the proposed TAGCN method are an average over 100 runs with random initializations (Glorot & Bengio, 2010).
4. Q UANTITATIVE EVALUATIONS
We compare the classiﬁcation accuracy with other recently proposed graph CNN methods as well as a graph embedding method known as Planetoid Yang et al.
The quantitative results are summarized in Table 3.
Reported numbers denote classiﬁcation accuracy in percent.
Results for
Planetoid, GCN, and ChebNet are taken from Kipf & Welling (2017), and results for DCNN and
MoNet are taken from Monti et al.
All the experiments for different methods are based on the same data statistics shown in Table 2.
The datasets split and experiments settings closely follow the standard criteria in Yang et al.
; Kipf & Welling (2017).
Table 3 shows that our method
[Table]
outperforms all the recent state-of-the-art methods by obvious margins for all the three datasets.
These results verify the efﬁcacy of the proposed TAGCN.
For ablation study, we further compare the performance of different ﬁlter sizes from K = 1 to
K = 4 in Table 4.
It shows that the performances for ﬁlter size K = 2 are always better than that for other ﬁlter sizes.
The value K = 1 gives the worst classiﬁcation accuracy.
This further validates that a local feature extraction is more important than just propagating features among neighbors on the graph.
In Table 4, we also compare the performance of different number of ﬁlters, which reﬂects different number of network parameters.
Note, we also choose ﬁler size K = 2 and ﬁlter number
F (cid:96) = 8 that results in the same number of network parameters as that in GCN, MoNet, ECC and
DCNN according to Table 1.
It shows that the classiﬁcation accuracy using 8 ﬁlters is comparable with that using 16 ﬁlters in each hidden layer for TAGCN.
Moreover, TAGCN with 8 ﬁlters can still achieve higher accuracy than GCN, MoNet, ECC and DCNN methods.
C ONCLUSIONS
We have deﬁned a novel graph convolutional network that rearchitects the CNN architecture for graph-structured data.
The proposed method, known as TAGCN, is adaptive to the graph topology as the ﬁlter scans the graph.
Moreover, TAGCN inherits properties of the convolutional layer in classical CNN, i e., local feature extraction and weight sharing.
It can further extract the strength of correlation between vertices in the ﬁltering region.
On the other hand, by the convolution theorem,
TAGCN that implements in the vertex domain offers implement in the spectrum domain unifying graph CNN in both the spectrum domain and the vertex domain.
TAGCN is consistent with convolution in traditional signal processing.
These nice properties lead to better performance in classiﬁcation accuracy on different graph-structured datasets for semi-supervised graph vertex classiﬁcation problems.