Graph Attention Auto-Encoders

TL;DR

Graph Attention Auto-Encoders (GATE) are a novel neural network architecture that effectively reconstructs both node attributes and graph structure, enabling unsupervised learning on graph-structured data with competitive results.

Contribution

Introducing GATE, a graph auto-encoder with self-attention mechanisms that reconstructs graph structure and node attributes without prior graph knowledge, supporting inductive learning.

Findings

Achieves competitive node classification performance

Outperforms some supervised baselines

Works for both transductive and inductive tasks

Abstract

Auto-encoders have emerged as a successful framework for unsupervised learning. However, conventional auto-encoders are incapable of utilizing explicit relations in structured data. To take advantage of relations in graph-structured data, several graph auto-encoders have recently been proposed, but they neglect to reconstruct either the graph structure or node attributes. In this paper, we present the graph attention auto-encoder (GATE), a neural network architecture for unsupervised representation learning on graph-structured data. Our architecture is able to reconstruct graph-structured inputs, including both node attributes and the graph structure, through stacked encoder/decoder layers equipped with self-attention mechanisms. In the encoder, by considering node attributes as initial node representations, each layer generates new representations of nodes by attending over their neighbors' representations. In the decoder, we attempt to reverse the encoding process to reconstruct node attributes. Moreover, node representations are regularized to reconstruct the graph structure. Our proposed architecture does not need to know the graph structure upfront, and thus it can be applied to inductive learning. Our experiments demonstrate competitive performance on several node classification benchmark datasets for transductive and inductive tasks, even exceeding the performance of supervised learning baselines in most cases.

Tables

Table 1. Table 1 . The main notations used in the paper.

Notations	Definitions
$N$	The number of nodes in the graph
$E$	The number of edges in the graph
$L$	The number of layers
$d^{\left(k\right)}$	The number of node representation dimensions in the $k^{\text{th}}$ encoder/decoder layer
$F$	The number of node features ($d^{\left(0\right)}=F$)
$P$	The number of iterations (i.e., epochs)
$𝐀\in {ℝ}^{N\times N}$	The adjacency matrix
${𝐇}^{\left(k\right)}\in {ℝ}^{d^{\left(k\right)}\times N}$	The node representation matrix generated by the $k^{\text{th}}$ encoder layer
${\widehat{𝐇}}^{\left(k\right)}\in {ℝ}^{d^{\left(k\right)}\times N}$	The node representation matrix reconstructed by the $k^{\text{th}}$ decoder layer
$𝐇\in {ℝ}^{d^{\left(L\right)}\times N}$	The node representation matrix ($𝐇={𝐇}^{\left(L\right)}={\widehat{𝐇}}^{\left(L\right)}$)
$𝐗\in {ℝ}^{F\times N}$	The node feature matrix (${𝐇}^{\left(0\right)}=𝐗$)
$\widehat{𝐗}\in {ℝ}^{F\times N}$	The reconstructed node feature matrix ( $\widehat{𝐗}={\widehat{𝐇}}^{\left(0\right)}$)
${𝐂}^{\left(k\right)}\in {ℝ}^{N\times N}$	The attention matrix in the $k^{\text{th}}$ encoder layer
${\widehat{𝐂}}^{\left(k\right)}\in {ℝ}^{N\times N}$	The attention matrix in the $k^{\text{th}}$ decoder layer
$𝐡_i^{}{}_{}{}^{\left(k\right)}\in {ℝ}^{d^{\left(k\right)}}$	The representation of node $i$ generated by the $k^{\text{th}}$ encoder layer
${\widehat{𝐡}}_i^{\left(k\right)}\in {ℝ}^{d^{\left(k\right)}}$	The representation of node $i$ reconstructed by the $k^{\text{th}}$ decoder layer
${𝐡}_i\in {ℝ}^{d^{\left(L\right)}}$	The representation of node $i$ (${𝐡}_i=𝐡_i^{}{}_{}{}^{\left(L\right)}={\widehat{𝐡}}_i^{\left(L\right)}$)
${𝐱}_i\in {ℝ}^F$	The features of node $i$ (${𝐡}_i^{\left(0\right)}={𝐱}_i$)
${\widehat{𝐱}}_i\in {ℝ}^F$	The reconstructed features of node $i$ (${\widehat{𝐱}}_i={\widehat{𝐡}}_i^{\left(0\right)}$)
${\alpha }_{ij}^{\left(k\right)}$	The attention coefficient indicating the relative relevance of neighboring node $j$ to node $i$ in the $k^{\text{th}}$ encoder layer
${\hat{\alpha }}_{ij}^{\left(k\right)}$	The attention coefficient indicating the relative relevance of neighboring node $j$ to node $i$ in the $k^{\text{th}}$ decoder layer
${𝒩}_i$	The neighborhood of node $i$, including itself

Table 2. Table 2 . The statistics of the benchmark datasets.

Dataset	Nodes	Edges	Features	Classes	Train/Val/Test Nodes
Cora	2,708	5,429	1,433	7	140/500/1,000
Citeseer	3,327	4,732	3,703	6	120/500/1,000
Pubmed	19,717	44,338	500	3	60/500/1,000

Table 3. Table 3 . Node classification accuracies on the Cora, Citeseer and Pubmed datasets. The first column shows the type of data used during training for each method. Data types are the node feature matrix 𝐗 𝐗 \mathbf{X} , adjacency matrix 𝐀 𝐀 \mathbf{A} , and labels 𝐘 𝐘 \mathbf{Y} .

Available Data	Method	Cora	Citeseer	Pubmed
$𝐗$	Raw features	$47.9\pm 0.4\%$	$49.4\pm 0.2\%$	$69.1\pm 0.3\%$
$𝐀$	DeepWalk (Perozzi et al. (Perozzi et al., 2014))	$67.2\%$	$43.2\%$	$65.3\%$
$𝐀$, $𝐘$	LP (Zhu et al. (Zhu and Ghahramani, 2002))	$68.0\%$	$45.3\%$	$63.0\%$
$𝐗$, $𝐀$	DeepWalk + features	$70.7\pm 0.6\%$	$51.4\pm 0.5\%$	$74.3\pm 0.9\%$
$𝐗$, $𝐀$	VGAE (Kipf & Welling (Kipf and Welling, 2016))	$72.4\pm 0.2\%$	$55.7\pm 0.2\%$	$71.6\pm 0.4$ %
$𝐗$, $𝐀$	GAE (Kipf & Welling (Kipf and Welling, 2016))	$81.8\pm 0.1\%$	$69.2\pm 0.9\%$	$78.2\pm 0.1\%$
$𝐗$, $𝐀$	DGI (Velickovic et al. (Veličković et al., 2019))	$82.3\pm 0.6\%$	$71.8\pm 0.7\%$	$76.8\pm 0.6\%$
$𝐗$, $𝐀$	GATE (ours)	$83.2\pm 0.6\%$	$71.8\pm 0.8\%$	$80.9\pm 0.3\%$
$𝐗$, $𝐀$, $𝐘$	Planetoid (Yang et al. (Yang et al., 2016))	$75.7\%$	$62.9\%$	$75.7\%$
$𝐗$, $𝐀$, $𝐘$	Chebyshev (Defferrard et al. (Defferrard et al., 2016))	$81.2\%$	$69.8\%$	$74.4\%$
$𝐗$, $𝐀$, $𝐘$	Monet (Monti et al. (Monti et al., 2017))	$81.7\pm 0.5\%$	—	$78.0\pm 0.3\%$
$𝐗$, $𝐀$, $𝐘$	GCN (Kipf & Welling (Kipf and Welling, 2017))	$81.5\%$	$70.3\%$	$79.0\%$
$𝐗$, $𝐀$, $𝐘$	StoGCN (Chen et al. (Chen et al., 2018b))	$82.0\pm 0.8\%$	$70.9\pm 0.2\%$	$79.0\pm 0.4\%$
$𝐗$, $𝐀$, $𝐘$	GAT (Velickovic et al. (Velickovic et al., 2018))	$83.0\pm 0.7\%$	$72.5\pm 0.7\%$	$79.0\pm 0.3\%$

Table 4. (a) Transductive

Available Data	Method	Cora	Citeseer	Pubmed
$𝐗$	Raw features	$47.9\pm 0.4\%$	$49.4\pm 0.2\%$	$69.1\pm 0.3\%$
$𝐀$	DeepWalk (Perozzi et al. (Perozzi et al., 2014))	$67.2\%$	$43.2\%$	$65.3\%$
$𝐀$, $𝐘$	LP (Zhu et al. (Zhu and Ghahramani, 2002))	$68.0\%$	$45.3\%$	$63.0\%$
$𝐗$, $𝐀$	DeepWalk + features	$70.7\pm 0.6\%$	$51.4\pm 0.5\%$	$74.3\pm 0.9\%$
$𝐗$, $𝐀$	VGAE (Kipf & Welling (Kipf and Welling, 2016))	$72.4\pm 0.2\%$	$55.7\pm 0.2\%$	$71.6\pm 0.4$ %
$𝐗$, $𝐀$	GAE (Kipf & Welling (Kipf and Welling, 2016))	$81.8\pm 0.1\%$	$69.2\pm 0.9\%$	$78.2\pm 0.1\%$
$𝐗$, $𝐀$	DGI (Velickovic et al. (Veličković et al., 2019))	$82.3\pm 0.6\%$	$71.8\pm 0.7\%$	$76.8\pm 0.6\%$
$𝐗$, $𝐀$	GATE (ours)	$83.2\pm 0.6\%$	$71.8\pm 0.8\%$	$80.9\pm 0.3\%$
$𝐗$, $𝐀$, $𝐘$	Planetoid (Yang et al. (Yang et al., 2016))	$75.7\%$	$62.9\%$	$75.7\%$
$𝐗$, $𝐀$, $𝐘$	Chebyshev (Defferrard et al. (Defferrard et al., 2016))	$81.2\%$	$69.8\%$	$74.4\%$
$𝐗$, $𝐀$, $𝐘$	Monet (Monti et al. (Monti et al., 2017))	$81.7\pm 0.5\%$	—	$78.0\pm 0.3\%$
$𝐗$, $𝐀$, $𝐘$	GCN (Kipf & Welling (Kipf and Welling, 2017))	$81.5\%$	$70.3\%$	$79.0\%$
$𝐗$, $𝐀$, $𝐘$	StoGCN (Chen et al. (Chen et al., 2018b))	$82.0\pm 0.8\%$	$70.9\pm 0.2\%$	$79.0\pm 0.4\%$
$𝐗$, $𝐀$, $𝐘$	GAT (Velickovic et al. (Velickovic et al., 2018))	$83.0\pm 0.7\%$	$72.5\pm 0.7\%$	$79.0\pm 0.3\%$

Table 5. (b) Inductive

Available Data	Method	Cora	Citeseer	Pubmed
$𝐗$, $𝐀$	GraphSAGE-LSTM (Hamilton et al. (Hamilton et al., 2017))	$50.1\pm 0.2\%$	$40.3\pm 0.2\%$	$77.1\pm 0.1\%$
$𝐗$, $𝐀$	GraphSAGE-pool (Hamilton et al. (Hamilton et al., 2017))	$57.5\pm 0.2\%$	$45.9\pm 0.2\%$	$79.9\pm 0.1\%$
$𝐗$, $𝐀$	VGAE (Kipf & Welling (Kipf and Welling, 2016))	$58.4\pm 0.4\%$	$55.4\pm 0.2\%$	$71.1\pm 0.2\%$
$𝐗$, $𝐀$	GraphSAGE-mean (Hamilton et al. (Hamilton et al., 2017))	$67.0\pm 0.2\%$	$52.8\pm 0.1\%$	$79.3\pm 0.1\%$
$𝐗$, $𝐀$	GraphSAGE-GCN (Hamilton et al. (Hamilton et al., 2017))	$74.3\pm 0.1\%$	$54.5\pm 0.1\%$	$77.5\pm 0.1\%$
$𝐗$, $𝐀$	GAE (Kipf & Welling (Kipf and Welling, 2016))	$80.5\pm 0.1\%$	$69.1\pm 0.9\%$	$78.1\pm 0.2\%$
$𝐗$, $𝐀$	GATE (ours)	$82.5\pm 0.5\%$	$71.5\pm 0.7\%$	$80.8\pm 0.3\%$
$𝐗$, $𝐀$, $𝐘$	Planetoid (Yang et al. (Yang et al., 2016))	$61.2\%$	$64.7\%$	$77.2\%$
$𝐗$, $𝐀$, $𝐘$	GAT (Velickovic et al. (Velickovic et al., 2018))	$76.4\pm 0.2\%$	$66.4\pm 0.2\%$	$77.7\pm 0.03\%$

Equations

$$e_{ij}^{(k)}=\text{Sigmoid}\left({{\mathbf{v}}_s^{(k)}}^T\sigma \left({\mathbf{W}}^{(k)}{\mathbf{h}}_i^{(k-1)}\right)+{{\mathbf{v}}_r^{(k)}}^T\sigma \left({\mathbf{W}}^{(k)}{\mathbf{h}}_j^{(k-1)}\right)\right)$$

$${\alpha }_{ij}^{(k)}=\frac{\text{exp}\left(e_{ij}^{(k)}\right)}{{\sum }_{l\in {\mathcal{N}}_i}\text{exp}\left(e_{il}^{(k)}\right)}$$

$${\mathbf{h}}_i^{(k)}=\sum _{j\in {\mathcal{N}}_i}{\alpha }_{ij}^{(k)}\sigma \left({\mathbf{W}}^{(k)}{\mathbf{h}}_j^{(k-1)}\right)$$

$${\hat{\alpha }}_{ij}^{(k)}=\frac{\text{exp}\left({\hat{e}}_{ij}^{(k)}\right)}{{\sum }_{l\in {\mathcal{N}}_i}\text{exp}\left({\hat{e}}_{il}^{(k)}\right)}$$

$${\hat{e}}_{ij}^{(k)}=\text{Sigmoid}\left({{\hat{\mathbf{v}}}_s^{(k)}}^T\sigma \left({\hat{\mathbf{W}}}^{(k)}{\hat{\mathbf{h}}}_i^{(k)}\right)+{{\hat{\mathbf{v}}}_r^{(k)}}^T\sigma \left({\hat{\mathbf{W}}}^{(k)}{\hat{\mathbf{h}}}_j^{(k)}\right)\right)$$

$${\hat{\mathbf{h}}}_i^{(k-1)}=\sum _{j\in {\mathcal{N}}_i}{\hat{\alpha }}_{ij}^{(k)}\sigma \left({\hat{\mathbf{W}}}^{(k)}{\hat{\mathbf{h}}}_j^{(k)}\right)$$

$$\sum _{i=1}^N{||{\mathbf{x}}_i-{\hat{\mathbf{x}}}_i||}_2$$

$$-\sum _{i=1}^N\sum _{j\in {\mathcal{N}}_i}\log \left(\frac{1}{1+\text{exp}(-{\mathbf{h}}_i^T{\mathbf{h}}_j)}\right)$$

$$\text{Loss}=\sum _{i=1}^N||{\mathbf{x}}_i-{\hat{\mathbf{x}}}_i|{|}_2-\lambda \sum _{j\in {\mathcal{N}}_i}\log \left(\frac{1}{1+\text{exp}(-{\mathbf{h}}_i^T{\mathbf{h}}_j)}\right)$$

$${\mathbf{C}}^{(k)}=\text{Softmax}\left(\text{Sigmoid}\left({\mathbf{M}}_s^{(k)}+{\mathbf{M}}_r^{(k)}\right)\right)$$

$${\mathbf{M}}_s^{(k)}=\mathbf{A}\odot \left({{\mathbf{v}}_s^{(k)}}^T\sigma \left({\mathbf{W}}^{(k)}{\mathbf{H}}^{(k-1)}\right)\right)$$

$${\mathbf{M}}_r^{(k)}=\mathbf{A}\odot {\left({{\mathbf{v}}_r^{(k)}}^T\sigma \left({\mathbf{W}}^{(k)}{\mathbf{H}}^{(k-1)}\right)\right)}^T$$

$${\mathbf{H}}^{(k)}=\sigma \left({\mathbf{W}}^{(k)}{\mathbf{H}}^{(k-1)}\right){\mathbf{C}}^{(k)}$$

$${\hat{\mathbf{C}}}^{(k)}=\text{Softmax}\left(\text{Sigmoid}\left({\hat{\mathbf{M}}}_s^{(k)}+{\hat{\mathbf{M}}}_r^{(k)}\right)\right)$$

$${\hat{\mathbf{M}}}_s^{(k)}=\mathbf{A}\odot \left({{\hat{\mathbf{v}}}_s^{(k)}}^T\sigma \left({\hat{\mathbf{W}}}^{(k)}{\hat{\mathbf{H}}}^{(k)}\right)\right)$$

$${\hat{\mathbf{M}}}_r^{(k)}=\mathbf{A}\odot {\left({{\hat{\mathbf{v}}}_r^{(k)}}^T\sigma \left({\hat{\mathbf{W}}}^{(k)}{\hat{\mathbf{H}}}^{(k)}\right)\right)}^T$$

$${\hat{\mathbf{H}}}^{(k-1)}=\sigma \left({\hat{\mathbf{W}}}^{(k)}{\hat{\mathbf{H}}}^{(k)}\right){\hat{\mathbf{C}}}^{(k)}$$

$$O(NFD+ED)$$

Full text

Attributed graph representation learning, attributed network embedding, unsupervised graph learning, inductive graph learning

††copyright: rightsretained††doi: 10.475/123_4††isbn: 123-4567-24-567/08/06††article: 4††price: 15.00

1. Introduction

Low-dimensional vector representations of nodes in graphs have demonstrated their utility in a broad range of machine learning tasks. Such tasks include node classification (Grover and Leskovec, 2016), recommender systems (Ying et al., 2018), community detection (Wang et al., 2017a), graph visualization (Perozzi et al., 2014; Tang et al., 2015), link prediction (Wei et al., 2017) and relational modeling (Schlichtkrull et al., 2018). Accordingly, there has been a surge of research to learn better node representations. However, most of the proposed methods (Grover and Leskovec, 2016; Belkin and Niyogi, 2002; He and Niyogi, 2004; Ahmed et al., 2013; Cao et al., 2015; Ou et al., 2016; Perozzi et al., 2014; Grover and Leskovec, 2016; Perozzi et al., 2016; Chamberlain et al., 2017; Tian et al., 2014; Wang et al., 2016; Tang et al., 2015; Cao et al., 2016; Chen et al., 2018a) only utilize the graph structure while nodes in real-world graphs usually come with a rich set of attributes (i.e. features). Typical examples are users in social networks, scientific articles in citation networks, protein molecules in biological networks and web pages on the Internet.

Significant efforts have been made (Huang et al., 2017b; Yang et al., 2016; Defferrard et al., 2016; Monti et al., 2017; Kipf and Welling, 2017; Velickovic et al., 2018; Hamilton et al., 2017) to utilize node attributes for graph representation learning. Nevertheless, the most successful methods, notably graph convolutional networks (Kipf and Welling, 2017) and graph attention networks (Velickovic et al., 2018), depend on label information, which is not available in many real-world applications. Moreover, the process of annotating data suffers from many limitations, such as annotators’ subjectivity, reproducibility, and consistency.

To avoid the challenges of annotating data, several unsupervised graph embedding methods (Kipf and Welling, 2016; Duran and Niepert, 2017; Pan et al., 2018; Veličković et al., 2019; Gao and Huang, 2018; Huang et al., 2017a; Yang et al., 2015) have been proposed, but these methods suffer from at least one of the three following problems. First, despite utilizing node features, some of these models (Kipf and Welling, 2016; Pan et al., 2018; Gao and Huang, 2018) heavily depend on the graph structure. This hinders their capability to fully exploit node features. Second, many (Gao and Huang, 2018; Huang et al., 2017a; Yang et al., 2015) are not capable of inductive learning, which is crucial to encounter unseen nodes (e.g., new users in social networks, recently published scientific articles and new web pages on the Internet). Third, even though some efforts have been made (Veličković et al., 2019; Hamilton et al., 2017) to address inductive learning tasks, they are not unified architectures for both transductive and inductive tasks.

Auto-encoders have recently become popular for unsupervised learning due to their ability to capture complex relationships between input’s attributes through stacked non-linear layers (Baldi, 2012; Bengio et al., 2013). However, conventional auto-encoders are not able to take advantage of explicit relations in structured data. To utilize relations in graph-structured data, several graph auto-encoders (Kipf and Welling, 2016; Wang et al., 2017b; Pan et al., 2018) have been proposed. Although the encoders in these models fully utilize graph-structured inputs, the decoders neglect to reconstruct either the graph structure or node attributes.

Another successful neural network paradigm is the attention mechanism (Bahdanau et al., 2014), which has been extremely useful in tackling many machine learning tasks (Chorowski et al., 2015; Chen et al., 2016; Wang et al., 2018), particularly sequence-based tasks (Vaswani et al., 2017; Luong et al., 2015; Dehghani et al., 2018; Rush et al., 2015). The state-of-the-art attention mechanism is self-attention or intra-attention, which computes the representation of an input (e.g., a set or sequence) by focusing on its most relevant parts. Self-attention has been successfully applied to a variety of tasks including machine translation (Vaswani et al., 2017), video classification (Wang et al., 2018) and question answering (Dehghani et al., 2018). Nonetheless, the majority of these efforts target supervised learning tasks, and few efforts (Devlin et al., 2018; He et al., 2017) are made to tackle unsupervised learning tasks. In graph representation learning, to our knowledge, the only proposed attention-based method uses supervised learning (Velickovic et al., 2018).

In this work, we present a novel graph auto-encoder to learn node representations within graph-structured data (i.e., attributed graphs) in an unsupervised manner. Our auto-encoder takes in and reconstructs node features by utilizing the graph structure through stacked encoder/decoder layers. In the encoder, node attributes are fed into stacked layers to generate node representations. By considering node features as initial node representations, each encoder layer generates new representations of nodes by utilizing neighbors’ representations according to their relevance, which is determined by a graph attention mechanism. In the decoder, we aim to reverse the entire encoding process to reconstruct node attributes. To this end, each decoder layer attempts to reverse the process of its corresponding encoder layer. Moreover, node representations are regularized to reconstruct the graph structure. To our knowledge, no auto-encoder is capable of reconstructing both node attributes and the graph structure. Our architecture can also be applied to inductive learning tasks since it doesn’t need to know the graph structure upfront.

Our key contributions are summarized as follows:

• •

We propose a novel graph auto-encoder for unsupervised representation learning on graph-structured data by reconstructing both node features and the graph structure.

• •

We utilize self-attention for unsupervised attributed graph representation learning.

• •

We present a unified neural architecture capable of both transductive and inductive learning.

The rest of the paper is organized as follows. We review related work in Section 2. In Section 3, we formally define the problem of unsupervised representation learning on graph-structured data. Section 4 presents the architecture of our proposed graph auto-encoder. In Section 5, we quantitatively and qualitatively evaluate GATE using several benchmark datasets for both transductive and inductive learning tasks. Section 6 concludes the paper.

2. Related Work

2.1. Graph Representation Learning

Most of the graph embedding methods fall into one of the following three categories: factorization based, random walk based, and auto-encoder based approaches.

Factorization based approaches are inspired by matrix factorization methods, which assume that the data lies in a low dimensional manifold. Laplacian Eigenmaps (Belkin and Niyogi, 2002) and LPP (He and Niyogi, 2004) rely on eigendecomposition to preserve the local manifold structure. Due to expensive eigendecomposition operations, these methods face difficulty to tackle large-scale graphs. To alleviate this problem, several techniques—notably the Graph Factorization (GF) (Ahmed et al., 2013), GraRep (Cao et al., 2015) and HOPE (Ou et al., 2016)—have been proposed. These methods differ mainly in their node similarity calculation. The graph factorization computes node similarity based on the first-order proximities directly extracted from the adjacency matrix. To capture more accurate node similarity, GraRep and HOPE utilize the high-order proximities obtained from different powers of the adjacency matrix and similarity measures (i.e., cosine similarity) respectively.

Random walk based approaches assume a pair of nodes to be similar if they are close in simulated random walks over the graph. Therefore, node similarity is stochastically computed in contrast to the deterministic approach used by factorization based methods. DeepWalk (Perozzi et al., 2014) and node2vec (Grover and Leskovec, 2016) are the most successful methods in this category and differ primarily in their random walk generation. DeepWalk simulates uniform random walks while node2vec relies on a biased random walk generation. Preozzi et al. (Perozzi et al., 2016) extend DeepWalk to encode multiscale node relationships in the graph. In contrast to DeepWalk and node2vec, which embed nodes in the Euclidean space, Chamberlan et al. (Chamberlain et al., 2017) utilize the hyperbolic space.

Factorization based and random walk based approaches adopt shallow models, which are incapable of capturing complex graph structures. To solve this problem, auto-encoder based approaches are proposed to capture non-linear graph structures by using deep neural networks. Tian et al. (Tian et al., 2014) present a stacked sparse auto-encoder to embed nodes by reconstructing the adjacency matrix. Moreover, Wang et al. (Wang et al., 2016) propose a stacked auto-encoder, which reconstructs the second-order proximities by using the first-order proximities as a regularization. Cao et al. (Cao et al., 2016) use stacked denoising auto-encoder to reconstruct the pointwise mutual information matrix.

Although the majority of graph embedding methods fall into one of the aforementioned categories, there are still some exceptions. For instance, LINE (Tang et al., 2015) is a successful shallow embedding method to preserve both the local and global graph structures. Another example is HARP (Chen et al., 2018a), which introduces a graph processing step coarsening a graph into smaller graphs at different levels of granularity, and then it embeds them from the smaller graph to the largest one (i.e., the original graph) by using one of the graph embedding methods (i.e., DeepWalk, node2vec, and LINE).

2.2. Attributed Graph Representation Learning

The graph embedding methods described in the previous section only utilize the graph structure to learn node representations. However, nodes in real-world graphs usually come with a rich set of attributes. To take advantage of node features, many attributed graph embedding methods have been proposed, which fall into two main categories: supervised and unsupervised approaches.

Supervised attributed graph embedding approaches embed nodes by utilizing label information. For example, Huang et al. (Huang et al., 2017b) propose a supervised method leveraging spectral techniques to project the adjacency matrix, node feature matrix, and node label matrix into a common vector space. Hamilton et al. (Hamilton et al., 2017) present four variants of GraphSAGE, a framework to compute node embeddings in an inductive manner. Many approaches address graphs with partial label information. For example, Graph Convolution Network (GCN) (Kipf and Welling, 2017) incorporates spectral convolutions into neural networks. Graph Attention Network (GAT) (Velickovic et al., 2018) utilizes an attention mechanism to determine the influence of neighboring nodes in final node representations.

The unsupervised attributed graph embedding methods address the lack of label information, which exists in many real-world applications. Yang et al. (Yang et al., 2015) and Huang et al. (Huang et al., 2017a) propose matrix factorization methods to combine the graph structure and node attributes. Moreover, Kipf et al. (Kipf and Welling, 2016) propose two graph auto-encoders utilizing graph convolution networks. Pan et al. (Pan et al., 2018) also introduce a graph-encoder based on an adversarial approach. For graph clustering, Wang et al. (Wang et al., 2017b) present a graph auto-encoder, which is able to reconstruct node features. However, these auto-encoders reconstruct either the graph structure or node attributes instead of both. To alleviate this limitation, Gao et al. (Gao and Huang, 2018) propose a framework consisting of two conventional auto-encoders, which reconstruct the graph structure and node attributes separately. These two auto-encoders are regularized in a way that their learned representations of neighboring nodes are similar. However, their framework does not fully leverage the graph structure due to the incapability of conventional auto-encoders in utilizing explicit relations in structured data. Most of the aforementioned unsupervised methods are not designed for inductive learning, which is crucial to encounter unseen nodes. Velivckovic et al. (Veličković et al., 2019) and Hamilton et al. (Hamilton et al., 2017) propose unsupervised models for tackling inductive tasks, but their models are not unified frameworks for both transductive and inductive tasks.

3. Problem Statement

In this section, we present the notations used in the paper and formally define the problem of unsupervised node representation learning on graph-structured data. We use bold upper-case letters for matrices (e.g., $\mathbf{X}$), bold lowercase letters for vectors (e.g., $\mathbf{x}$), and calligraphic fonts for sets (e.g., $\mathcal{N}$). Moreover, we represent the transpose of a matrix $\mathbf{X}$ as $\mathbf{X}^{T}$. The $i^{\text{th}}$ element of vector $\mathbf{x}$ is denoted by $\mathbf{x}_{i}$. $\mathbf{X}_{ij}$ denotes the entry of matrix $\mathbf{X}$ at the $i^{\text{th}}$ row and the $j^{\text{th}}$ column. Table 1 summarizes the main notations used in the paper.

In the attributed graph representation learning setup, we are provided with the node feature matrix $\mathbf{X}=[\mathbf{x}_{1},\mathbf{x}_{2},...,\mathbf{x}_{N}]$, where $N$ is the number of nodes in the graph and $\mathbf{x}_{i}\in\mathbb{R}^{F}$ corresponds to the $i^{\text{th}}$ column of matrix $\mathbf{X}$, denoting the features of node $i$. We are also given the adjacency matrix $\mathbf{A}\in\mathbb{R}^{N\times N}$, representing the relations between nodes. Even though the matrix $\mathbf{A}$ may consist of real numbers, in our experiments, we assume the graph is unweighted and includes self-loops, i.e., $\mathbf{A}_{ij}=1$ if there is an edge between node $i$ and node $j$ in the graph or $i$ equals $j$, and $\mathbf{A}_{ij}=0$ otherwise.

Given the node feature matrix $\mathbf{X}$ and the adjacency matrix $\mathbf{A}$, our objective is to learn node representations in the form of matrix $\mathbf{H}=[\mathbf{h}_{1},\mathbf{h}_{2},...,\mathbf{h}_{N}]$, where $\mathbf{h}_{i}\in\mathbb{R}^{D}$ corresponds to the $i^{\text{th}}$ column of matrix $\mathbf{H}$, denoting the representation of node $i$.

4. Architecture

In this section, we illustrate the architecture of the graph attention auto-encoder. First, we present the encoder and decoder to show how our auto-encoder reconstructs node features using the graph structure. Then, we describe the proposed loss function, which learns node representations by minimizing the reconstruction loss of node features and the graph structure. In the end, we present the matrix formulation of GATE, as well as its time and space complexities.

4.1. Encoder

The encoder in our architecture takes node features and generates node representations by using the graph structure through stacked layers. We use multiple encoder layers for two reasons. First, more layers make our model deeper, and hence increasing the learning capability. Second, they propagate node representations through the graph structure, resulting in richer node embeddings.

Each encoder layer generates new representations of nodes by utilizing their neighbors’ representations according to their relevance. To determine the relevance between nodes and their neighbors, we use a self-attention mechanism with shared parameters among nodes, following the work of Velickovic et al. (Velickovic et al., 2018). In the $k^{\text{th}}$ encoder layer, the relevance of a neighboring node $j$ to node $i$ is computed as follows:

[TABLE]

where $\mathbf{W}^{(k)}\in\mathbb{R}^{d^{(k)}\times d^{(k-1)}}$, $\mathbf{v}_{s}^{(k)}\in\mathbb{R}^{d^{(k)}}$, and $\mathbf{v}_{r}^{(k)}\in\mathbb{R}^{d^{(k)}}$ are the trainable parameters of the $k^{\text{th}}$ encoder layer, $\sigma$ denotes the activation function and Sigmoid represents the sigmoid function (i.e., $\text{Sigmoid }(x)=1/(1+\text{exp}^{-x})$).

To make the relevance coefficients of node $i$’s neighbors comparable, we normalize them by using the softmax function as follows:

[TABLE]

where $\mathcal{N}_{i}$ represents the neighborhood of node $i$ (i.e., a set of nodes connected to node $i$ according to the adjacency matrix $\mathbf{A}$, including node $i$ itself).

By considering node features as initial node representations (i.e., ${\mathbf{h}_{i}}^{(0)}=\mathbf{x}_{i}$, $\forall i\in\{1,2,..,N\}$), the $k^{\text{th}}$ encoder layer generates the representation of node $i$ in layer $k$ as follows:

[TABLE]

After applying $L$ encoder layers, we consider the output of the last layer as the final node representations (i.e., $\mathbf{h}_{i}=\mathbf{h}_{i}^{(L)}$, $\forall i\in\{1,2,..,N\}$).

4.2. Decoder

Our encoder is reminiscent of graph attention networks (Velickovic et al., 2018), which use supervised learning to embed nodes. Our main contribution is reversing the encoding process in order to learn node representations without any supervision. To this end, we use a decoder with the same number of layers as the encoder. Each decoder layer attempts to reverse the process of its corresponding encoder layer. In other words, each decoder layer reconstructs the representations of nodes by utilizing the representations of their neighbors according to their relevance. The normalized relevance (i.e., attention coefficient) of a neighboring node $j$ to node $i$ in the $k^{\text{th}}$ decoder layer is computed as follows:

[TABLE]

[TABLE]

where $\widehat{\mathbf{W}}^{(k)}\in\mathbb{R}^{d^{(k-1)}\times d^{(k)}}$, $\widehat{\mathbf{v}}_{s}^{(k)}\in\mathbb{R}^{d^{(k-1)}}$, and $\widehat{\mathbf{v}}_{r}^{(k)}\in\mathbb{R}^{d^{(k-1)}}$ are the trainable parameters of the $k^{\text{th}}$ decoder layer.

By considering the output of the encoder as the input of the decoder (i.e., $\widehat{\mathbf{h}}_{i}^{(L)}=\mathbf{h}_{i}^{(L)}$, $\forall i\in\{1,2,..,N\}$), the $k^{\text{th}}$ decoder layer reconstructs the representation of node $i$ in layer $k-1$ as follows:

[TABLE]

After applying $L$ decoder layers, we consider the output of the last layer as the reconstructed node features (i.e., $\widehat{\mathbf{x}_{i}}=\widehat{\mathbf{h}}_{i}^{(0)}$, $\forall i\in\{1,2,..,N\}$). Figure 1 illustrates the process of reconstructing node features in GATE through an example.

4.3. Loss Function

Graph-structured data include node features and the graph structure, and both should be encoded by high-quality node representations. We minimize the reconstruction loss of node features as follows:

[TABLE]

The absence of an edge between two nodes in the graph does not necessarily imply dissimilarity due to the possibility of feature similarity. Thus, we minimize the reconstruction loss of the graph structure by making the representations of neighboring nodes similar. We accomplish this by minimizing the following equation:

[TABLE]

By merging Eq. (7) and Eq. (8), we minimize the reconstruction loss of node features and the graph structure as follows:

[TABLE]

where $\lambda$ controls the contribution of the graph structure reconstruction loss.

4.4. Matrix Formulation

Since the adjacency matrix $\mathbf{A}$ is usually very sparse in practice, we can leverage sparse matrix operations (e.g., sparse softmax) to tackle large graphs. Therefore, we present the corresponding matrix formulas for the aforementioned encoder and decoder equations.

Let us begin with obtaining the attention matrix $\mathbf{C}^{(k)}\in\mathbb{R}^{N\times N}$ in the $k^{\text{th}}$ encoder layer, where $\mathbf{C}_{ij}^{(k)}=\alpha_{ij}^{(k)}$ if there is an edge between node $i$ and node $j$, and $\mathbf{C}_{ij}^{(k)}=0$ otherwise. We compute $\mathbf{C}^{(k)}$as follows:

[TABLE]

[TABLE]

[TABLE]

where $\odot$ is element-wise multiplication with broadcasting capability and $\sigma$ denotes the activation function.

By considering $\mathbf{H}^{(0)}=\mathbf{X}$, the $k^{\text{th}}$ encoder layer generates node representations in layer $k$ as follows:

[TABLE]

After applying $L$ encoder layers, we consider $\mathbf{H}^{(L)}$ as the final node representation matrix (i.e., $\mathbf{H}=\mathbf{H}^{(L)}$).

The attention matrix $\widehat{\mathbf{C}}^{(k)}\in\mathbb{R}^{N\times N}$ in the $k^{\text{th}}$ decoder layer, where $\widehat{\mathbf{C}}_{ij}^{(k)}=\widehat{\alpha}_{ij}^{(k)}$ if there is an edge between node $i$ and node $j$, and $\widehat{\mathbf{C}}_{ij}^{(k)}=0$ otherwise, is computed as follows:

[TABLE]

[TABLE]

[TABLE]

By considering $\widehat{\mathbf{H}}^{(L)}={\mathbf{H}}^{(L)}$, the $k^{\text{th}}$ decoder layer reconstructs node representations in layer $k-1$ as follows:

[TABLE]

After applying $L$ decoder layers, we consider $\widehat{\mathbf{H}}^{(0)}$ as the reconstructed node feature matrix (i.e., $\widehat{\mathbf{X}}=\widehat{\mathbf{H}}^{(0)}$).

Algorithm 1 shows the forward propagation of our proposed architecture using matrix formulation.

4.5. Complexity

Our proposed auto-encoder is highly efficient because the operations involved in the graph attention mechanisms can be parallelized across edges, and the rest of the operations in the encoder and decoder can be parallelized across nodes. Theoretically, the time complexity of our architecture for one iteration can be expressed as follows:

[TABLE]

where $N$ and $E$ are respectively the number of nodes and edges in the graph, $F$ is the number of node features and $D$ is the maximum $d^{(k)}$ in all layers (i.e., $D=\max_{k\in\{1,2,..,L\}}d^{(k)}$).

By taking advantage of sparse matrix operations, the space complexity of our auto-encoder is linear in terms of the number of nodes and edges.

5. Evaluation

In this section, we quantitatively and qualitatively evaluate the proposed GATE architecture using several benchmark datasets. Section 5.1, 5.2, and 5.3 respectively describe the datasets, baselines, and experimental setup used in our experiments. In Section 5.4, we quantitatively evaluate the efficacy of our architecture. Section 5.5 investigates the impact of the three main components used in our proposed architecture, namely the self-attention mechanism, graph structure reconstruction, and node feature reconstruction. Finally, we investigate the quality of the node representations learned by GATE in Section 5.6.

5.1. Datasets

For transductive tasks, we use three benchmark datasets—Cora, Citeseer and Pubmed (Sen et al., 2008)—that are widely used to evaluate attributed graph embedding methods. In all datasets, each node belongs to one class. We follow the experimental setup of Yang et al. (Yang et al., 2016), where 20 nodes per class are used for training. In the transductive setup, we have access to the graph structure and all nodes’ feature vectors during training. We evaluate the predictive performance of each method on 1000 test nodes; 500 additional nodes are also used for validation of supervised methods. The statistics of the datasets are presented in Table 2.

For inductive tasks, we also use the same datasets and experimental setup in order to evaluate the generalization power of different methods to unseen nodes by comparing the difference between their performance in transductive and inductive tasks for the same dataset. As required by inductive learning, any information related to (unseen) test nodes, including features and edges, are completely unobserved during training.

5.2. Baselines

We compare our proposed auto-encoder against the following state-of-the-art supervised and unsupervised methods:

• •

DeepWalk (Perozzi et al., 2014): DeepWalk is a graph embedding method, which trains Skipgram model (Mikolov et al., 2013) on simulated random walks over the graph.

• •

Enhanced DeepWalk (DeepWalk + features): This baseline is a variant of DeepWalk concatenating raw node features and DeepWalk embeddings to take advantage of node features.

• •

Label Propagation (LP) (Zhu and Ghahramani, 2002): LP assigns labels to unlabeled nodes by propagating available labels in the graph.

• •

Planetoid (Yang et al., 2016): This baseline is an attributed graph embedding, which learns node representations by predicting available class labels and the neighborhood context in the graph using random walks.

• •

Chebyshev (Defferrard et al., 2016): This baseline utilizes graph convolutional networks with high-order fast localized convolutions.

• •

Graph Convolutional Networks (GCN) (Kipf and Welling, 2017): GCN incorporates spectral convolutions into neural networks to learn node representations.

• •

Graph Auto-Encoder (GAE) (Kipf and Welling, 2016): GAE uses graph convolutional networks as the encoder and reconstruct the graph structure in the encoder.

• •

Variational Graph Auto-Encoder (VGAE) (Kipf and Welling, 2016): VGAE is the variational version of GAE.

• •

GraphSAGE (Hamilton et al., 2017): GraphSAGE has four unsupervised variants, which differ in their feature aggregator as follows: GraphSAGE-GCN (applying a convolution-style aggregator), GraphSAGE-mean (taking the element-wise mean of feature vectors), GraphSAGE-LSTM (aggregating by providing neighboring nodes’ features into a LSTM), and GraphSAGE-pool (performing an element-wise max-pooling operation after applying a fully-connected neural network).

• •

Monet (Monti et al., 2017): This baseline generalizes convolutional neural networks to graph-structured data.

• •

Deep Graph Infomax (DGI) (Veličković et al., 2019): DGI is an unsupervised attributed graph embedding, which simultaneously estimates and maximizes the mutual information between the graph-structured input and learned high-level graph summaries.

• •

StoGCN (Chen et al., 2018b): StoCGN is a control variate-based stochastic algorithm for graph convolutional networks, which uses neighborhood sampling and historical hidden representations to reduce the receptive field of the graph convolution.

• •

Graph Attention Networks (GAT) (Velickovic et al., 2018): GAT utilizes an attention mechanism to determine the influence of neighboring nodes in final node representations.

For transductive tasks, we compare our auto-encoder against supervised and unsupervised approaches. Unsupervised baselines include DeepWalk, enhanced DeepWalk, VGAE, GAE, and DGI. Supervised approaches are LP, Planetoid, Chebyshev, Monet, CGN, StoGCN, and GAT. For inductive tasks, we similarly compare GATE against supervised and unsupervised approaches. Unsupervised baselines include VGAE, GAE, and four unsupervised variants of GraphSAGE. Supervised approaches are Planetoid and GAT.

5.3. Experimental Setup

In our experiments, Adam optimizer (Kingma and Ba, 2014) is used to learn model parameters with an initial learning rate of $10^{-4}$. For all datasets, we use two layers with 512 node representation dimensions (i.e., $d^{(1)}=d^{(2)}=512$). We set the number of epochs to 100 for Cora and Citeseer, and 500 for Pubmed. We also set $\lambda$ to 0.5 for Cora and Pubmed, and 20 for Citeseer. We use only half of the trainable parameters by setting $\widehat{\mathbf{W}}^{(k)}={\mathbf{W}^{(k)}}^{T}$ and $\widehat{\mathbf{C}}^{(k)}=\mathbf{C}^{(k)}$. Moreover, $\sigma$ is set to the identity function, empirically resulting in better performance compared to other activation functions. Tensorflow (Abadi et al., 2016) is used to implement GATE.

For the baselines to which we directly compare GATE, we use their default hyperparameter settings as well as the following settings. We perform a hyperparameter sweep on initial learning rates $\{10^{-3},10^{-4},10^{-5},10^{-6},10^{-7}\}$ and $\{10^{-2},10^{-3},10^{-4}\}$ for unsupervised and supervised methods respectively. We also swept over the number epochs in the set $\{50,100,200,300\}$ for VGAE and GAE due to their sensitivity to this hyperparameter. For supervised methods, we perform a sweep on dropouts $\{0,0.2,0.5\}$. We also set the number of node representation dimensions to 512 for all of these baselines.

5.4. Comparison

In this section, we compare out proposed method with the aforementioned state-of-the-art baselines based on transductive and inductive node classifications. For transductive node classification, we report the mean classification accuracy (with standard deviation) of our method on the test nodes after 100 runs of training (followed by logistic regression). The accuracies for GCN, DeepWalk, and LP are retrieved from Kipf & Welling (Kipf and Welling, 2017). We also reuse the metrics reported in Velickovic et al. (Veličković et al., 2019) for the performance of enhanced DeepWalk, DGI, and logistic regression with raw features. The accuracies for GAT, Chebyshev, and Monet are taken from Velickovic et al. (Velickovic et al., 2018). For StoGCN and Planetoid, the metrics are retrieved from their papers (Chen et al., 2018b; Yang et al., 2016). Moreover, we directly compare our method against GAE and VGAE.

Table 3(a) shows the transductive node classification accuracies for the Cora, Citeseer, and Pubmed datasets. Accordingly, we make the following observations:

• •

GATE achieves strong performance across all three datasets. Particularly, GATE outperforms all supervised and unsupervised baselines on the Cora and Pubmed datasets.

• •

Our unsupervised architecture is competitive with the performance of the best supervised baseline (i.e., GAT), even improving upon it by a margin of 1.9% and 0.2% on Pubmed and Cora respectively.

• •

GATE outperforms or matches all unsupervised baselines across all datasets. We observe an improvement of 2.7% and 0.9% over the best unsupervised baselines for Pubmed and Cora respectively.

• •

For the Citeseer dataset, the accuracy of GATE follows that of GAT. This can be attributed to the low average node degree of 1.4 for Citeseer—which is lower than Cora’s (2) and Pubmed’s (2.25). The scarcity of neighbors and the abundance of features can give the supervised baselines (i.e., GAT), which take advantage of a supervised loss, leverage over unsupervised methods

• •

The reconstruction of node features by GATE results in a considerable improvement compared to the graph auto-encoder baselines reconstructing only the graph structure. Compared to the best graph auto-encoder baseline (i.e., GAE), we achieve an improvement gain of 2.7%, 2.6%, and 1.4% on Pubmed, Citeseer, and Cora respectively.

For inductive node classification, we utilize the same datasets used for the transductive tasks. This enables us to compare the performance of GATE between transductive and inductive tasks for the same dataset in order to evaluate the generalization power of our auto-encoder to unseen nodes. We report the mean classification accuracy (with standard deviation) of our method on the (unseen) test nodes after 100 runs of training (followed by logistic regression). For Planetoid, its accuracies are retrieved from Yang et al. (Yang et al., 2016). We directly compare our method against VGAE, GAE, GAT, and four variants of GraphSAGE.

Table 3(b) shows the inductive node classification accuracies for the Cora, Citeseer, and Pubmed datasets. Accordingly, we make the following observations:

• •

GATE exceeds the performance of all supervised and unsupervised baselines across all three datasets. We are able to improve upon the best baselines by a margin of 2.4%, 2%, and 0.9% on Citeseer, Cora, and Pubmed respectively.

• •

We can observe that GATE achieves similar accuracies for inductive and transductive tasks with regard to the same dataset. For example, the accuracy difference between inductive and transductive tasks is 0.1%, 0.3%, and 0.7% on Pubmed, Citeseer, and Cora respectively. This suggests that GATE naturally generalizes to unseen nodes.

• •

Unlike GATE, not every method performing well on transductive tasks (e.g., GAT) can perform well on inductive tasks.

5.5. In-depth Analysis

In this section, we investigate the impact of the three main components used in our proposed architecture, namely the self-attention mechanism, graph structure reconstruction and node feature reconstruction. In our experiments, we use the following variants of our architecture:

• •

GATE: The full version of our proposed auto-encoder which includes all three components.

• •

GATE/A: A variant of our architecture which includes all components except the self-attention mechanism. In other words, we assign the same importance to each neighbor.

• •

GATE/S: A variant of our architecture which includes all components except the graph structure reconstruction.

• •

GATE/F: A variant of our architecture which includes all components except the node feature reconstruction.

We first compare the four variants of our architecture based on transductive node classification. Figure 2(a) shows the mean classification accuracy (with standard deviation) of all four variants on the test nodes after 100 runs of training (followed by logistic regression). Accordingly, we make the following observations:

• •

GATE outperforms other variants in all datasets. Therefore, each component contributes to the overall performance of our architecture.

• •

GATE/A performs worse than other variants. This suggests that the self-attention mechanism contributes the most in our architecture compared to the graph structure and node feature reconstructions.

• •

In Cora and Pubmed which have higher average node degree (i.e., 2 and 2.5 respectively), GATE/F outweighs the performance of GATE/S. On the other hand, GATE/S exceeds the performance of GATE/F in Citeseer which has the lowest average node degree (i.e., 1.4) and the highest number of features.

Now we compare all variants of our architecture based on inductive node classification. Figure 2(b) shows the mean classification accuracy (with standard deviation) of all four variants on the (unseen) test nodes after 100 runs of training (followed by logistic regression). Accordingly, we make the following observations:

• •

Like the transductive node classification experiments, GATE and GATE/A are respectively the best and the worst variants of our architecture in all datasets.

• •

We observe that the performances of GATE/F and GATE/S in Cora and Citeseer are similar to those of transductive node classification experiments. However, we notice a huge drop in the performance of GATE/F in Pubmed even though the performance of GATE/S has not undergone such a decrease. This can be attributed to both the low number of features and high average node degree of Pubmed compared to those of Cora and Citeseer, which hugely benefit GATE/F in transductive learning over inductive learning.

5.6. Qualitative Analysis

In this section, we qualitatively investigate the effectiveness of the node representations and attention coefficients learned by GATE. To this end, we utilize t-SNE (Maaten and Hinton, 2008) to project the learned node representations into a two-dimensional space. Due to space limitation, we only show the visualization for the Cora dataset. Figure 3(a) shows the t-SNE visualization of the learned node representations for Cora, where node colors denote classes. We can observe that the learned node representations result in discernible clusters.

Figure 3(b) shows the t-SNE visualization of the edges, in the Cora dataset, thickened by their attention coefficients averaged across all layers. In this figure, the edges with source and target nodes belonging to the same class are colored with the color of the class, and the others are colored black. Accordingly, we expect high-quality node representations to result in thicker colorful edges. In Figure 3(b), we can observe that the colorful edges are usually thicker than the black edges. However, in few spots where GATE faces difficulty in separating nodes belonging to different classes, we can notice the presence of some thick black edges.

6. Conclusion

Graph-structured data can be found in many real-world scenarios, such as social media (Salehi et al., 2018; Salehi and Davulcu, 2018), protein-protein interaction networks (Velickovic et al., 2018), and citation networks (Kipf and Welling, 2017).

In this paper, we have introduced the graph attention auto-encoder (GATE), a novel neural architecture for unsupervised representation learning on graph-structured data. By stacking multiple encoder/decoder layers equipped with graph attention mechanisms, GATE is the first graph auto-encoder, which reconstructs both node features and the graph structure.

Experiments on both transductive and inductive tasks using three benchmark datasets demonstrate the efficacy of GATE, which learns high-quality node representations. In most experiments, our auto-encoder outweighs state-of-the-art supervised and unsupervised baselines. Moreover, our experiments show that GATE naturally generalizes to unseen nodes.

The tensor manipulation framework (i.e., Tensorflow (Abadi et al., 2016)) we used does not support matrix multiplication for rank-3 tensors, limiting batching capability of our auto-encoder. Therefore, addressing this limitation is an important direction for future work.