Year: 2019

Abstract:
Network representation learning (NRL) is a powerful technique for learning lowdimensional vector representation of high-dimensional and sparse graphs. Most studies explore the structure and metadata associated with the graph using random walks and employ an unsupervised or semi-supervised learning schemes. Learning in these methods is context-free, because only a single representation per node is learned. Recently studies have argued on the sufficiency of a single representation and proposed a context-sensitive approach that proved to be highly effective in applications such as link prediction and ranking. However, most of these methods rely on additional textual features that require RNNs or CNNs to capture high-level features or rely on a community detection algorithm to identify multiple contexts of a node. In this study, without requiring additional features nor a community detection algorithm, we propose a novel context-sensitive algorithm called GAP that learns to attend on different parts of a node’s neighborhood using attentive pooling networks. We show the efficacy of GAP using three real-world datasets on link prediction and node clustering tasks and compare it against 10 popular and state-ofthe-art (SOTA) baselines. GAP consistently outperforms them and achieves up to ≈ 9% and ≈ 20% gain over the best performing methods on link prediction and clustering tasks, respectively.

heading: 1 INTRODUCTION
text: NRL is a powerful technique to learn representation of a graph. Such a representation gracefully lends itself to a wide variety of network analysis tasks, such as link prediction, node clustering, node classification, recommendation, and so forth.
In most studies, the learning is done in a context-free fashion. That is, the representation of a node characterizes just a single aspect of the node, for instance, the local or global neighborhood of a node. Recently, a complementary line of research has questioned the sufficiency of single representations and considered a context-sensitive approach. Given a node, this approach projects it to different points in a space depending on other contexts it is coupled with. A context node can be sampled from a neighborhood (Tu et al., 2017; Zhang et al., 2018), random walk (Ying et al., 2018), and so on. In this study we sample from a node neighborhood (nodes connected by an edge). Thus, in the learning process of our approach a source node’s representation changes depending on the target (context) node it is accompanied by. Studies have shown that context-sensitive approaches significantly outperform previous context-free SOTA methods in link-prediction task. A related notion (Peters et al., 2018; Devlin et al., 2018) in NLP has significantly improved SOTA across several NLP tasks.
In this paper we propose GAP (Graph neighborhood attentive pooling), which is inspired by attentive pooling networks (APN) (dos Santos et al., 2016), originally proposed for solving the problem of pair ranking in NLP. For instance, given a question q, and a set of answers A = {a1, . . . , az}, an APN can be trained to rank the answers in A with respect to q by using a two-way attention mechanism. APN is based on the prevalent deep learning formula for SOTA NLP, that is, embed, encode, attend, predict (Honnibal, 2018). Given a question-answer pair (q, ai), the APN model first projects the embedding of the pairs using two separate encoders, and the encoder can be a CNN or LSTM. The projection helps to capture n-gram context information and/or long-term dependencies in the input sequence. Next, a soft-alignment matrix is obtained by a mutual-attention mechanism that transforms these projections using a parameter matrix. Attention vectors are then computed through
a column-wise and row-wise pooling operations on the alignment matrix. Finally, the weighted sum of each of the above projections by its respective attention vector is computed to obtain the representations of the question and answer. Each candidate answer ai is then ranked according to its similarity with the question q computed using the representations of q and ai.
Recently, APN have been applied to context-sensitive NRL by Tu et al. (2017), and the inputs are textual information attached with a pair of incident nodes of edges in a graph. Such information, however, has the added overhead of encoding textual information.
Though we adopt APN in GAP, we capitalize on the graph neighborhood of nodes to avoid the need for textual documents without compromising the quality of the learned representations. Our hypothesis is that one can learn high-quality context-sensitive node representations just by mutually attending to the graph neighborhood of a node and its context node. To achieve this, we naturally assume that the order of nodes in the graph neighborhood of a node is arbitrary. Moreover, we exploit this assumption to simplify the APN model by removing the expensive encode phase.
Akin to textual features in APN, GAP simply uses graph neighborhood of nodes. That is, for every node in the graph we define a graph neighborhood function to build a fixed size neighborhood sequence, which specifies the input of GAP. In the APN model, the encoder phase is usually required to capture high-level features such as n-grams, and long term and order dependencies in textual inputs. As we have no textual features and due to our assumption that there is no ordering in the graph neighborhood of nodes, we can effectively strip off the encoder. The encoder is the expensive part of APN as it involves a RNN or CNN, and hence GAP can be trained faster than APN.
This simple yet empirically fruitful modification of the APN model enables GAP to achieve SOTA performance on link prediction and node clustering tasks using three real world datasets. Furthermore, we have empirically shown that GAP is more than 2 times faster than an APN like NRL algorithm based on text input. In addition, the simplification in GAP does not introduce new hyperparameters other than the usual ones, such as the learning rate and sequence length in APN.

heading: 2 APN ARCHITECTURE
text: For the sake of being self-contained, here we briefly describe the original APN architecture. We are given a pair of natural language texts (x, y) as input, where x = (w1, . . . wX) and y = (w1, . . . , wY ) are a sequence of words of variable lengths, and each word wi is a sample from a vocabulary V, X = |x|, Y = |y|, and X and Y could be different. The APN’s forward execution is shown in Fig. 1(A) and in the following we describe each component.
Embed: First embedding matrices of x and y are constructed through a lookup operation on an embedding matrix E ∈ Rd×|V| of words, where d is the embedding dimension. That is, for both x and y, respectively, embedding matrices X = [w1, . . . ,wX ] and Y = [w1, . . . ,wY ] are constructed by concatenating embeddings wi of each word wi in x and y, the Embed box in Fig. 1(A).
Encode: Each embedding matrix is then projected using a CNN or BI-LSTM encoder to capture inherent high-level features, the Encode box in Fig. 1(A). More formally, the embedded texts X ∈ Rd×X , Y ∈ Rd×Y are projected as Xenc = f(X,Θ) and Yenc = f(Y ,Θ) where f is the encoder, CNN or BI-LSTM, Θ is the set of parameters of the encoder, and Xenc ∈ Rc×X and Yenc ∈ Rc×Y , where c is the number of filters or hidden features of the CNN and BI-LSTM, respectively.
Attend: In the third step, a parameter matrix P ∈ Rc×c is introduced so as to learn a similarity or soft-alignment matrix A ∈ RX×Y between the sequence projections Xenc and Yenc as:
A = tanh(XTencPYenc)
Then unnormalized attention weight vectors x′ ∈ RX and y′ ∈ RY are obtained through a column-wise and row-wise max-pooling operations on A, respectively as x′i = max(Ai,:),y ′ j = max(A:,j), where 0 ≤ i < X , 0 ≤ j < Y and Ai,: and A:,j are the i-th and j-th row and column of A, respectively. Next, the attention vectors are normalized using softmax, x = softmax(x′)
and y = softmax(y′). Finally, the normalized attention vectors are used to compute the final representations as rx = Xenc · xT and ry = Yenc · yT .
Predict: In the last step, the representations rx and ry will be used for ranking depending on the task on hand. For instance, in a question and answer setting, each candidate answer’s representation ry will be ranked based on its similarity score with the question’s representation rx.

heading: 3 GAP
text: GAP adopts the APN model for learning the representations of node pairs in a graph G = (V,E) with a set of n nodes V and m edges E. G can be a directed or undirected and weighted or unweighted graph. Without loss of generality we assume that G is an unweighted directed graph.
We define a neighborhood function N : V → 2V , which maps each node u ∈ V to a set of nodes Nu ⊆ V . A simple way of materializing Nu is to consider the first-order neighbors of u, that is, Nu = [v : (u, v) ∈ E ∨ (v, u) ∈ E]. An important assumption that we have on Nu is that the ordering of the nodes in Nu is not important. GAP capitalizes on this assumption to simplify the APN model and achieve SOTA performance. Even though one can explore more sophisticated neighborhood functions, in this study we simply consider the first order neighborhood.
Our goal is to learn node representations using the simplified APN based on the node neighborhood function N . Hence, akin to the input text pairs in APN, we consider a pair of neighborhood sequences Ns = (u1, . . . , uS) and Nt = (v1, . . . , vT ) associated with a pair (s, t) ∈ E of nodes s and t, and S = |Ns| and T = |Nt|. Without loss of generality we consider S = T . Recall that we assume the order of nodes in Ns and Nt is arbitrary.
Given a source node s, we seek to learn multiple context-sensitive embeddings of s with respect to a target node t it is paired with. In principle one can learn using all pairs of nodes, however that is not scalable, and hence we restrict learning between pairs in E.
GAP’s forward execution model is shown in Fig 1(B), and learning starts by embedding Ns and Nt, respectively, as S = (u1, . . . ,uS) and T = (v1, . . . ,vT ). Since there is no order dependency between the nodes in Ns or Nt, besides being a neighbor of the respective node, we leave out the CNN or BI-LSTM based projections of S and T that could capture the dependencies. No encoder!
Thus, the next step of GAP is mutually attending on the embeddings, S and T , of the graph neighborhood of the node pairs; the Attend box of 1(B). That is, we employ the trainable parameter matrix P ∈ Rd×d and compute the soft-alignment matrix, A, between the neighbors of s and t.
A = tanh(STPT ) (1)
Here A is a soft-alignment matrix between every pair of nodes, (u, v) ∈ Ns × Nt. Therefore, for each axis of A, we proceed by pooling the maximum alignment score for each node to obtain the unnormalized attention vectors s′i = max(Ai,:) and t ′ j = max(A:,j). As a result of the pooling operations, each neighbor u ∈ Ns of the source node, s, selects a neighbor v ∈ Nt of the target node, t, with the maximum alignment or similarity score. A similar selection is done for v ∈ Nt. This enables the source and target neighborhood sequences of the pair to influence each other in order to learn a context-sensitive representation of s and t. The normalized attention vectors are then obtained by applying softmax as s = softmax(s′) and t = softmax(t′). Ultimately, we compute the context-sensitive representations rs and rt of the source and target nodes s and t, respectively as rs = S · sT and rt = T · tT .
Optimization: The objective of GAP is to maximize the likelihood of the graph (edges) by predicting edge similarities using the dot product of the source and target representations as rs · rt; the Predict box of Fig 1(B). Hence, we employ a hard-margin loss given in Eq. 2.
L(s, t) = max(0, 1− rs · rt + rs · r−t ) (2)
where r−t is the representation of a negative target node t −, that is (s, t−) /∈ E. The goal is to learn, in an unsupervised fashion, a context-sensitive embedding of nodes that enable us to rank the positive edges (s, t) ∈ E higher than the negative pairs (s, t−). Finally a word on the computational complexity of GAP that is proportional to the the number of edges, as we are considering each edge as an input pair.

heading: 4 EXPERIMENTAL EVALUATION
text: In this section we provide an empirical evaluation of GAP. To this end, experiments are carried out using the following datasets, and a basic summary is given in Table 1.
1. Cora Tu et al. (2017); Zhang et al. (2018): is a citation network dataset, where a node represents a paper and an edge (u, v) ∈ E represents that paper u has cited paper v.
2. Zhihu Tu et al. (2017); Zhang et al. (2018): is the biggest social network for Q&A and it is based in China. Nodes are the users and the edges are follower relations between the users.
3. Email Leskovec et al. (2007): is an email communication network between the largest European research institutes. A node represents a person and an edge (u, v) ∈ G denotes that person u has sent an email to v.
The first two datasets have features (documents) associated to nodes. For Cora, abstract of papers and Zhihu user posts. Some of the baselines, discussed beneath, require textual information, and hence they consume the aforementioned features. The Email dataset has ground-truth community assignment for nodes based on a person’s affiliation to one of the 42 departments.
We compare our method against the following 10 popular and SOTA baselines grouped as:
• Structure based methods: DEEPWALK Perozzi et al. (2014), NODE2VEC Grover & Leskovec (2016), WALKLETS Perozzi et al. (2016), ATTENTIVEWALK Abu-El-Haija et al. (2017), LINE Tang et al. (2015):
• Structure and attribute based methods: TRIDNR Pan et al. (2016), TADW Yang et al. (2015), CENE Sun et al. (2016)
• Context-sensitive: CANE Tu et al. (2017), DMTE Zhang et al. (2018)
We are aware of another SOTA context-sensitive algorithm (Epasto & Perozzi, 2019) that do not require textual information, however we have not included it in our experiments because the source code is not available.1 Now we report the experimental results carried out in two tasks, which are link prediction and node clustering. All experiments are performed using a 24-Core CPU and 125GB RAM Ubuntu 18.04 machine.

heading: 4.1 LINK PREDICTION
text: Link prediction is an important task that graph embedding algorithms are applied to. Particularly context-sensitive embedding techniques have proved to be well suited for this task. Similar to existing studies we perform this experiment using a fraction of the edges as a training set. We hold out the remaining fraction of the edges from the training phase and we will only reveal them during the test phase, results are reported using this set. All hyper-parameter tuning is performed by taking a small fraction of the training set as a validation set.
Setup: In-line with existing techniques (Tu et al., 2017; Zhang et al., 2018), the percentage of training edges ranges from 15% to 95% by a step of 10. The hyper-parameters of all algorithms are tuned using random-search. For some of the baselines, our results are consistent with what is reported in previous studies, and hence for Cora and Zhihu we simply report these results.
Except the “unavoidable” hyper-parameters (eg. learning rate, regularization/dropout rate) that are common in all the algorithms, our model has just one hyper-parameter which is the neighborhood sequence length (#Neighborhood = S = T ), for nodes with smaller neighborhood size we use zero padding. As we shall verify later, GAP is not significantly affected by the choice of this parameter.
The quality of the prediction task is measured using the AUC score. AUC indicates the probability that a randomly selected pair (u,w) /∈ E will have a higher similarity score than an edge (u, v) ∈ E. Similarity between a pair of nodes is computed as the dot product of their representation. For all the algorithms the representation size – d is 200 and GAP’s configuration is shown in Table 2.
Results: The results of the empirical evaluations on the Cora, Zhihu, and Email datasets are reported in Tables 3, 4, and 5. GAP outperforms the SOTA baselines in all cases for Zhihu and Email, and in almost all cases for Cora. One can see that as we increase the percentage of training edges, performance increases for all the algorithms. As indicated by the “Gain” row, GAP achieves up to 9% improvement over SOTA context-sensitive techniques. Notably the gain is pronounced for
1We have contacted the authors and have been told that the code is not ready for release
smaller values of percentage of edges used for training. This is shows that GAP is suitable both in cases where there are several missing links and most of the links are present.

heading: 4.2 NODE CLUSTERING
text: Nodes in a network has the tendency to form cohesive structures based on some kinds of shared aspects. These structures are usually referred to as groups, clusters or communities and identifying them is an important task in network analysis. In this section we use the Email dataset that has ground truth communities, and there are 42 of them. Since this dataset has only structural information, we have excluded the baselines that require textual information.
Setup: Since each node belongs to exactly one cluster, we employ the Spectral Clustering algorithm to identify clusters. The learned representations of nodes by a certain algorithm are the input features of the clustering algorithm. In this experiment the percentage of training edges varies from 25% to 95% by a step of 20%, for the rest we use the same configuration as in the above experiment.
Given the ground truth community assignment y of nodes and the predicted community assignments ŷ, usually the agreement between y and ŷ are measured using mutual information I(y, ŷ). However, I is not bounded and difficult for comparing methods, hence we use two other variants of I (Vinh et al., 2010). Which are, the normalized mutual information NMI(y, ŷ), which simply normalizes I and adjusted mutual information AMI(y, ŷ), which adjusts or normalizes I to random chances.
Results: The results of this experiment are reported in Table 6, and GAP significantly outperforms all the baselines by up to 20% with respect to AMI score. Consistent to our previous experiment GAP performs well in both extremes for the value of the percentage of the training edges. Similar improvements are achieved for AMI score.

heading: 4.3 PARAMETER SENSITIVITY ANALYSIS
text: Here we first show the sensitivity of the main hyper-parameter of GAP, which is the size of the neighborhood, #Neighborhood = S = T . Figures 2 and 3(A) show the effects of this parameter both on link prediction and node clustering tasks. In both cases we notice that GAP is not significantly affected by the change of values. We show the effect across different values of percentage and fixed (55%) of training edges for link prediction and node clustering tasks, respectively. Regardless of the percentage of training edges, we only see a small change of AUC (Fig 2), and NMI and AMI (Fig 3-a) across different values of #Neighborhood.
Next, we analyze the run time of training GAP and our goal is to show the benefit of removing the encoder of APN and we do this by comparing GAP against CANE, which employs the exact APN ar-
chitecture. For this experiment we include two randomly generated graphs, using ErdősRényi (ERG) and BarabásiAlbert (BAG) models. ERG has 200K edges, and BAG has 1.5M edges. Figure 3(B) clearly shows that GAP is at least 2 times faster than CANE in all the graphs.

heading: 5 RELATED WORK
text: NRL is usually carried out by exploring the structure of the graph and meta data, such as node attributes, attached to the graph (Perozzi et al., 2014; Grover & Leskovec, 2016; Tang et al., 2015; Perozzi et al., 2016; Wang et al., 2016; Yang et al., 2015; Pan et al., 2016; Sheikh et al., 2019). Random walks are widely used to explore local/global neighborhood structures, which are then fed into a learning algorithm. The learning is carried out in unsupervised manner by maximizing the likelihood of observing the neighbor nodes and/or attributes of a center node.
Recently graph convolutional networks have also been proposed for semi-supervised network analysis tasks (Kipf & Welling, 2017; Hamilton et al., 2017; Wu et al., 2019; Velickovic et al., 2017; Abu-El-Haija et al., 2019). These algorithms work by way of aggregating neighborhood features, with a down-stream objective based on partial labels of nodes, for example. All these methods are essentially different from our approach because they are context-free.
Context-sensitive learning is another paradigm to NRL that challenges the sufficiency of a single representation of a node for applications such as, link prediction, product recommendation, ranking. While some of these methods (Tu et al., 2017; Zhang et al., 2018) rely on textual information, others have also shown that a similar goal can be achieved using just the structure of the graph (Epasto & Perozzi, 2019). However, they require an extra step of persona decomposition that is based on microscopic level community detection algorithms to identify multiple contexts of a node. Unlike the first approaches our algorithm does not require extra textual information and with respect to the second ones our approach does not require any sort of community detection algorithm.

heading: 6 CONCLUSION
text: In this study we present a novel context-sensitive graph embedding algorithm called GAP. It consumes node neighborhood as input feature, which are constructed based on an important assumption that their ordering is arbitrary. To learn representations of nodes GAP employs attentive pooling networks (APN). By exploiting the above assumption, it makes an important simplification of APN and gains more than 2X speed up over another SOTA method, which employs the exact APN. Furthermore, GAP consistently outperforms all the baselines and achieves up to ≈ 9% and ≈ 20% improvement over the best performing ones on the link prediction and node clustering tasks, respectively. In future we will investigate how node attributes can be incorporated and provide a theoretical framework on the relation between the neighborhood sampling and topological properties.

heading: A APPENDIX
text: Here we give a brief ablation experiment to strengthen the case for GAP. Concretely, we seek to compare GAP with different baselines to further motivate our choice of (i) the way we model nodes using their neighborhood, (ii) the assumption that order in this neighborhood is not important, and (iii) the choice of the APN algorithm without the CNN or BI-LSTM encoder. To this end, we introduce the following baselines and apart from the indicated difference everything will be the same as GAP.
1. First we assume order is important in the neighborhood of nodes based on neighbors similarity with the current node. We use a topological feature to induce order, which is common neighbors. This baseline is referred to as GAPCN and uses the exact APN model to capture “order”.
2. Second, we use the same input as in GAP, but nodes’ neighborhood is now randomly permuted and fed multiple times (concretely 5 times), and the exact APN model is employed; this baseline is referred to as GAPAPN
3. Finally we replace GAP’s Attend component with a standard feed-forward neural network that consumes the same input (Embedding matrices S and T) and also has the same learning objective specified in Eq. 2; the baseline is referred to as GAPMLP.
In Table 7 we report the results of the ablation experiment. This sheds some light on the assumptions and the design choices of GAP. For the reported results, GAPCN and GAPAPN use a CNN Encoder. In both cases, they quickly over-fit the data, and we found out that we have to employ aggressive regularization using a dropout rate of 0.95. In addition, for GAPCN we have also observed that as we increase the kernel size to greater values than 1 (up to 5) the results keep getting worse, and hence, what we reported is the best one which is obtained using a kernel size of 1. For example, with a kernel size of 3 and training ratios of 25, 55, 75, and 95 percent the AUC scores respectively dropped to 54, 55, 56, and 58 percent on the Cora dataset, and 66, 69, 78 and 77 percent on the Email dataset. We conjecture that this is due the model’s attempt to enforce high-level neighborhood patterns (eg. a combination of arbitrary neighbors) that are not intrinsically governing the underlying edge formation phenomena. Rather, what is important is to effectively pay attention to the presence of individual neighbors both in Ns and Nt regardless of their order. Apparently, training this model is at least twice slower than GAP as it is also illustrated in Section 4.3.
In the case of GAPAPN, though the variations in AUC are marginal with respect to the change in the kernel size, the training time of these model has increased almost by an order of magnitude. Finally we see that the mutual attention mechanism (Attend component) plays an important role by comparing the results between the GAPMLP and GAP.

Review summaries:
This paper proposed a GAP (graph neighborhood attentive pooling) method to solve problems of node clustering and link prediction. The proposed idea is mostly inspired by the attentive pooling network approach (APN) that has been widely used in the NLP domains; indeed the detailed steps of the proposed method is almost a ``mirror” application of APN from question-answer pair ranking in NLP to the graph domains, and the only difference is that rather than using an RNN or LSTM to deal with the temporal orders in sentences (as in APN), the proposed method simply collect the first-order neighbors of the source node and target node and concatenate them without considering their orders. For the rest part, the authors used a hard margin loss function which is also the same as in APN.