F EW - SHOT C LASSIFICATION ON G RAPHS WITH S TRUCTURAL R EGULARIZED GCN S
Anonymous authors
Paper under double-blind review
A BSTRACT
We consider the fundamental problem of semi-supervised node classiﬁcation in attributed graphs with a focus on few-shot learning.
Here, we propose Structural Regularized Graph Convolutional Networks (SRGCN), novel neural network architectures extending the well-known GCN structures by stacking transposed graph convolutional layers for reconstruction of input features.
We add a reconstruction error term in the loss function as a regularizer.
Unlike standard regularization such as L 1 or L 2 , which controls the model complexity by including a penalty term depends solely on parameters, our regularization function is parameterized by a trainable neural network whose structure depends on the topology of the underlying graph.
The new approach effectively addresses the shortcomings of previous graph convolution-based techniques for learning classiﬁers in the few-shot regime and signiﬁcantly improves generalization performance over original GCNs when the number of labeled samples is insufﬁcient.
Experimental studies on three challenging benchmarks demonstrate that the proposed approach has matched state-of-the-art results and can improve classiﬁcation accuracies by a notable margin when there are very few examples from each class.
I NTRODUCTION
Graph is the most natural structure to model interactions between different entities.
For example, graphs are often used to model social networks (Facebook, Twitter), biological networks (proteinprotein interaction), and citation networks (arXiv).
There has been an increasing research interest in learning tasks on arbitrary structured graphs recently, e.g., (Bruna et al., 2014; Monti et al., 2017;
Defferrard et al., 2016; Kipf & Welling, 2017; Hamilton et al., 2017; Velickovic et al., 2018).
In this paper, we consider the fundamental problem of semi-supervised node classiﬁcation in attributed graphs, where the labels of a small training set are available.
Such label information is critical to the performance of classiﬁcation algorithms.
However, it usually requires the inspection of human experts, and thus is often expensive to obtain sufﬁcient label information.
It is therefore important to design effective learning methods for the setting where only minimum amount of supervision is available: the classiﬁer needs to generalize well after seeing few or even zero training samples from each class.
To tackle the complexity of huge real-world networks, representation learning-based approaches have become popular for learning tasks on structured data.
One line of research is network embedding (Tang et al., 2015; Grover & Leskovec, 2016; Bojchevski & G¨unnemann, 2018).
This approach ﬁrst learns a lower-dimensional representation for each node in the graph in an unsupervised manner, followed by a supervised classiﬁer for node classiﬁcation, e.g., logistic regression or multi-layer perceptron (MLP).
Another popular line of research is trying to generalize convolutional neural networks (CNNs) to graph data, e.g., (Bruna et al., 2014; Duvenaud et al., 2015).
One family of such methods that is most related to the present work is Graph Convolutional Networks (GCNs) Kipf & Welling (2017).
GCNs are neural network models operating directly on graphs, which can be viewed as an effective ﬁrst-order approximation of spectral graph convolutions Hammond et al.
The above two approaches achieve impressive classiﬁcation accuracies and have drawn a great amount of attention.
However, deep neural networks generally perform poorly on few-shot learn- ing tasks Ravi & Larochelle (2017).
This work proposes a simple yet powerful framework, called
Structural Regularized Graph Convolutional Network (SRGCN), for few-shot and zero-shot learning tasks on graphs.
In the conventional GCN model of Kipf & Welling (2017), the convolution ﬁlter is restricted to operate in a 1 -hop neighborhood.
In each layer, the hidden features are ﬁrst linearly transformed by a trainable weight matrix; the new hidden feature vector of a node is computed by aggregating the hidden features from its neighboring nodes followed by a non-linear activation.
Such iterative aggregation schemes have proven to effectively learn node representations and achieve state-of-theart classiﬁcation accuracy by utilizing topological and feature information simultaneously.
When training examples are abundant, label information can be efﬁciently propagated to the entire graph in a couple of iterations; indeed, the best performance of GCN is typically achieved with a 2 -layer architecture Kipf & Welling (2017).
On the other hand, when labels are extremely scarce, intuitively more rounds of aggregations are needed hence deeper networks; a theoretical analysis on the limitation of shallow GCN for few-show learning is presented in Section 3.
However, deeper versions of GCN often lead to worse performance Kipf & Welling (2017); Xu et al.
(2018), and according to the analysis of Xu et al.
(2018), this is mainly because some critical feature information may be “washed out” via the iterative averaging process.
Present Work.
To resolve this dilemma, we propose a novel regularized graph convolutional network architecture, called SRGCN.
Regularization is usually applied to prevent over-ﬁtting Kipf &
Welling (2017); Velickovic et al.
(2018), however, the effect of standard regularization methods, which controls the model complexity by including a penalty term depends solely on the parameters, is limited in few-shot learning on graphs.
Our regularization on the other hand crucially depends on the structure of the underlying graph, whose form itself is also trainable.
We write the loss function as L =
L sup + α L sr , where L sup is the supervised loss and the structural regularization term L sr is:
[Equation]
Here ◦ denotes function composition, X is the input features, f θ 1 ( X ) is the encoding function deﬁned by a usual GCN, and g θ 2 () is a reconstruction function parameterized by a transposed graph convolutional network.
For ﬁxed X and θ 2 , L sr is a function of the GCN parameter θ 1 that we want to learn, hence it is indeed a regularizer for GCN.
Note this encoder-decoder structure is reminiscent of Autoencoder (Hinton & Salakhutdinov, 2006).
In other words, our neural network structure is the conventional GCN concatenated with a Transposed Graph Convolutional Network, which is used to reconstruct the original node features.
The loss function of the proposed framework consists of two parts: (1) the supervised loss w.r.t.
the labeled part of the graph and (2) the unsupervised reconstruction errors of features, i.e., the regularizer.
The SRGCN architecture has several desirable properties for few-shot learning tasks including:
The regularization term L sr is parameterized by a graph convolutional network, whose structure depends on the graph topology (encoded in g θ 2 ) with a trainable θ 2 , and thus has much more expressive powerful than standard regularizations.
The reconstruction term in the loss function effectively prevents critical feature information from being washed out during the layer-wise averaging process and could potentially be a building block for training deeper GCNs.
In the original GCN, the training of weight matrices is mainly guided by the supervised loss, which is less efﬁcient for the purpose of dimensionality reduction and denoising especially when the training set is small and the feature dimensionality is high, while the Autoencoder in SRGCN allows the neural network to learn the real signals more efﬁciently.
It is twice deeper than GCN, and thus good for label information propagation, which is particular helpful in the few-shot setting
We assess our new framework on three widely used benchmarks: Cora, Citeseer and Pubmed .
The experimental results show that the proposed approach can signiﬁcantly improve generalization when there are very few examples from each class, compared with strong baselines such as GCN, GAT (Velickovic et al., 2018), MoNet Monti et al.
(2017) etc.
For completeness, we also evaluate our model on standard dataset splits, in which the label rate is relatively high.
The results show that, with the reconstruction regularization, the accuracy of GCN could be improved in this setting as well.
Although GAT achieves slightly better accuracy on standard splits than SRGCN, it is arguably much more complicated and does not work well in the few-shot setting.
SRGCN A RCHITECTURE 2. P ROBLEM D EFINITION
A graph with features is denoted as G =
( V, E, X ) ,where V = { v 1 , v 2 , v 3 , ..., v n } is the vertex set, E = { e i,j } ni,j =1 is the edge set and X = { x 1 , x 2 , ..., x n } is the set of feature vectors of all nodes.
We assume there are totally c classes and each node belongs to exactly one class.
The (class) labels of a subset of nodes is revealed in the beginning (i.e., training set), whose indices is denoted by Y L ⊆ { 1 , · · · , n } .
For each (cid:96) ∈ Y L , the label of v (cid:96) is indicated by a one-hot vector Y (cid:96) ∈ { 0 , 1 } c .
The task is to predict the labels of other nodes.
We are most interested in the setting when |Y L | is very few and the labels in the training set may not cover all classes.
2. F RAMEWORK
In this paper, we propose a semi-supervised model named SRGCN.
The architecture conceptually consists of two neural networks concatenated together.
The ﬁrst one is a GCN based encoder, while the second one is a decoder, which is essentially a transposed graph convolutional network.
2.2. E NCODER
We ﬁrst describe the encoder part of SRGCN, which is a standard GCN of Kipf & Welling (2017).
In general, it is composed of m e graph convolution layers.
The input of each layer is a set of node features represented as a matrix H l
= { h 1 , h 2 , ..., h n } ∈ R n × d l , in which n is the number of nodes and d l is the output dimension of the previous layer.
The output of the layer is a new set of node features, denoted as H l +
= { h (cid:48) 1 , h (cid:48) 2 , ..., h (cid:48) n } ∈ R n × d l +1 , where typically d l +1 <
d l .
More precisely, the layer-wise propagation rule applied on the l -th layer can be formalized as follows:
[Equation]
Here, ˜ A =
A + I n is the adjacency matrix of the graph after adding self-loops to each node, where
I n is the identity matrix; ˜ D is a diagonal matrix with ˜ D ii = (cid:80)
j ˜
A ij ; W l ∈ R d × k is the trainable weight matrix of layer l ; and σ () is an activation function (usually ReLU or softmax).
In the 0 -th layer we have H
= X , i.e. using original features as input.
The output of the last layer, denoted as Z ∈ R d × c , is the matrix containing the probabilities that every node v belongs to different classes.
Here, we used θ to denote the set of all trainable parameters and the supervised loss is the cross-entropy error, which is deﬁned as follows:
[Equation]
For notational convenience, we deﬁne ˆ A =
˜ D − 12 ˜
A ˜ D − 12 , which is symmetric.
After the dimensionality of the feature space is reduced with a graph convolutional network, a series of transposed graph convolutional layers, each of which is of the form H (cid:48)
=
σ ( ˆ A T HW T ) =
σ ( ˆ AHW T ) , are applied to reconstruct the original features of all nodes from their low dimensional representations.
Here
W ∈ R d (cid:48)
× d is a trainable weight matrix with d (cid:48) >
d , so that the dimensionality of feature vectors increases after each layer.
Moreover, as mentioned earlier, iterative use of the smoothing operator ˆ
AX results in losing some critical feature information, we hence add a pooling operation (usually max or mean) in each layer to prevent over-smoothing as in (Hamilton et al., 2017; Xu et al., 2018).
In all, the decoder part of the SRGCN consists of the m d layers of transposed graph convolutions.
Each layer takes in as input a set of hidden features, H l = { h 1 , h 2 , ..., h n } ∈ R n × d l and produces a new set of node features H l
+1 =
{ h (cid:48) 1 , h (cid:48) 2 , ..., h (cid:48) n } ∈ R n × d l +1 , where typically d l +1 > d l .
More speciﬁcally, the layer-wise propagation rule can be written as follows:
[Equation]
The transposed graph convolutional network use H
=
Z as the input, whose last layer outputs ˆ X , a matrix of the same size as X .
The reconstruction loss function is the squared Euclidean distance (or squared Frobenius norm of matrices):
[Equation]
2. I MPLEMENTATION D ETAILS
For all experiments in this paper, SRGCN uses the following four-layer network architecture:
[Equation]
Here, c is the number of classes and the pooling method is simply an entry-wise max function.
This max-pooling operation does not introduce any additional parameters.
Both GCN and GAT use a Lregularizer in all the experiments in (Kipf & Welling, 2017) and (Velickovic et al., 2018), which is also included in our loss function.
Thus, the actual loss function of SRGCN in all experiments is:
L = L sup + α L sr + βL 2 .
Note that, without the L sr term, our model is essentially the same as Lregularized GCN.
L IMITATIONS OF SHALLOW GCN S
In this section we discuss the limitations of shallow GCN (refer to the encoder part of SRGCN for the deﬁnition of GCN).
Suppose the number of layers in GCN is K and let H K be the output of the last layer.
We ﬁrst assume the loss is a function of the ﬁnal representations of the labeled nodes, denoted as H K Y L and their corresponding labels Y Y L , i.e., L =
f
( H K Y L , Y Y L ) , which is typically the cross entropy function.
Let N i ( x ) be the order i neighborhood of node x , i.e., the set of nodes connected to x by a path of length at most i .
For any set S ⊆ V , we deﬁne N i ( S ) =
(cid:83) x ∈ S N i ( x ) .
By a simple induction argument, we have the following lemma.
Lemma 1.
H K Y L does not depend on the input features of nodes v ∈ V \ N K ( Y L ) , and is only a function of the weight matrices W 1 , · · · , W K − 1 and the feature vectors of nodes in the set N K ( Y L ) denoted as X N K ( Y L ) .
Therefore
[Equation]
for some function g .
In the classiﬁcation problem, g, X N K ( Y L ) and Y Y L are given and the training algorithm is to ﬁnd the optimal weight matrices to minimize the loss function.
Let W ∗ be the optimal parameters computed by the algorithm.
If we assume the optimization algorithm only uses the information of the loss function to update the optimization variables in each iteration, e.g., its gradients or the Hessian matrix w.r.t.
W 1 , · · · , W K − 1 , then W ∗ must be independent of the feature vectors of nodes v ∈ V \ N K ( Y L ) .
Lemma 2.
W ∗ is function of X N K ( Y L ) , Y Y L .
Any changes in the input features X V \ N K
( Y L ) will not affect the value of W ∗ as long as the random seeds used in the optimization algorithm is ﬁxed.
The above Lemma shows that in the training of parameters, X N K ( Y L ) , Y Y L is the only relevant input data.
When the labeled set Y L is very small and the depth of the GCN K is small ( K = 2 is commonly used), the set N K ( Y L ) only consists of a negligible fraction of the entire graph, and thus most of the input features of the graph are ignored by the training algorithm.
Moreover, applying a standard regularization does not bring any beneﬁts.
To see this, if we add a penalty term r ( W ) that only depends on the parameters W , e.g., L 1 or L 2 regularization, the overall loss is still a function of W 1 , · · · , W K − 1 , X N K ( Y L ) ,
Y Y L (from equation 1).
Hence the conclusion of Lemma 2 still holds.
On the other hand, our regularization is L sr = (cid:107) ˆ X − X (cid:107) 2 , where X includes the input features of all nodes.
This force the training algorithm to utilize the information of the entire graph, not just the order K neighborhood of the labeled set.
R ELATED W ORK
Our approach extends graph convolutional networks of Kipf & Welling (2017), and thus can be categorized as a spectral approach (Bruna et al., 2014; Henaff et al., 2015; Defferrard et al., 2016).
Such spectral methods generalize convolutions to the graph domain, working with a spectral operator depending on the graph structure, which learns hidden layer representations that encode both graph structure and node features simultaneously.
Our network structure follows the work of Kipf &
Welling (2017), which simpliﬁes previous spectral techniques by restricting the propagation to a 1 -hop neighborhood in each layer.
Chen et al.
(2018) propose fast GCNs, which improves the training speed of the original GCN.
GAT of Velickovic et al.
(2018) allows for assigning different importances to nodes of a same neighborhood via attention mechanisms.
Xu et al.
(2018) introduce
JK networks, which adaptively adjust (i.e., learn) the inﬂuence radii for each node and task.
Z¨ugner et al.
(2018) study adversarial attacks on neural networks for graphs.
In contrast to this paper, such work does not explicitly consider the few-shot learning problem and their performance often degenerates rapidly as the number of labeled samples decreases.
Another direction that generalizes convolutions to the graph structured data, namely non-spectral approaches, deﬁne convolutions directly on the graph (Duvenaud et al., 2015; Atwood & Towsley, 2016; Monti et al., 2017).
Such methods are easier to be adapted to do inductive learning Hamilton et al.
(2017); Velickovic et al.
Bojchevski & G ¨ unnemann (2018).
However, few-shot learning remains a challenge for this class of methods.
On the other hand, node classiﬁcation is also one of the main applications of network embedding methods, which learns a lower-dimensional representation for each node in an unsupervised manner, followed by a supervised classiﬁer layer for node classiﬁcation (Perozzi et al., 2014; Tang et al., 2015; Grover & Leskovec, 2016; Wang et al., 2016; Bojchevski & G ¨ unnemann, 2018).
DeepWalk of Perozzi et al.
(2014) uses local information obtained from truncated random walks to learn latent representations.
It assumes that a pair of nodes are similar if they are close in the random walks.
LINE preserves the ﬁrst-order and second order proximity between nodes respectively, and concatenates the representations for the ﬁrst-order and second order proximity (Tang et al., 2015).
A recent work of Bojchevski & G ¨ unnemann (2018) proposes Graph2Gauss.
This method embeds each node as a Gaussian distribution according to a novel ranking similarity based on the shortest path between nodes.
A distribution embedding naturally captures the uncertainty about the representation.
The work of (Zhou et al., 2018) tackles the challenge of rare category characterization, which is a similar but different problem considered in this paper.
Embedding approaches achieve comparable performance in node classiﬁcation tasks, while the learned representations also prove to be extremely helpful for other downstream applications.
E XPERIMENT
In this section, extensive empirical results on three commonly used datasets are provided.
In most previous work, a standard split of each datasets 1 is used to evaluate accuracies.
Since this work focuses on the few-shot setting, we evaluate the performance of each method using training sets of varying size that are much smaller than in the standard split.
The training samples in our experiments are randomly selected from the graph.
We observe that, when the training set is extremely small, the performance of each method is highly sensitive to which subset of nodes are labeled.
Therefore, in each experiment (with ﬁxed sample size), we evaluate each method on 50 random splits and report the average accuracy, standard deviation, and a detailed accuracy distribution.
Moreover, the results of SRGCN under standard splits are also presented.
Under this setting,
SRGCN shows a clear improvement over the original GCN, which demonstrates the effectiveness of our regularization technique.
The results of GAT are slightly better than those of SRGCN.
GAT
[Table]
uses sophisticated attention mechanisms and achieve state-of-the-art accuracies over standard splits, but is more prone to overﬁtting in few-shot learning.
5. E XPERIMENT S ETTING
We evaluated the performance of SRGCN in two classiﬁcation tasks.
In the ﬁrst task, the set of labeled nodes (i.e., training set) is uniformly randomly sampled from the graph, so the number of samples from each class is random.
Moreover, when the size of the training set is small relative to the number of classes, it is likely that some type of labels may not appear in the training set, i.e., zero-shot learning.
In the second task, the training set contains the same number of nodes from each class; and the samples from each class are randomly selected from the class.
In the above two tasks, the validation set is chosen in the same size and manner as the training set, and the rest of nodes will be used as the testing set.
Baseline Methods: We compare SRGCN with six representative baseline methods: DeepWalk (Perozzi et al., 2014), LINE (Tang et al., 2015), Graph2Gauss (Bojchevski & G ¨ unnemann, 2018), GCN (Kipf & Welling, 2017), MoNet(Monti et al., 2017) and GAT (Velickovic et al., 2018).
DeepWalk,
LINE and Graph2Gauss are unsupervised network embedding methods.
For node classiﬁcation, after the embeddings of nodes are learned, a classiﬁer is trained by applying logistic regression in the embedding space.
GCN, MoNet and GAT are semi-supervised node classiﬁcation methods.
Datasets.
We consider three most commonly used citation network datasets: Cora, Citeseer and
Pubmed.
Each node in the graph corresponds to a document and the edges are citation links between documents; the feature vector of a node is a sparse bag-of-words vector.
See Table 1 for more details.
Tasks.
For task 1 , we evaluate the classiﬁcation performance with respect to ﬁve different training set sizes: 10 , 20 , 30 , 40 , 50 .
In this task, zero-shot instances are likely to occur.
Note that the logistic regression step in embedding-based methods is unable to deal with zero-shot instances.
Hence, we only use GCN, MoNet and GAT as baselines in this task.
For task 2 , we test the performance with varying numbers of labeled examples from each class (more speciﬁcally 1 , 3 , 5 , 7 , 10 ).
In this task, SRGCN are compared with both embedding-based and semi-supervised methods.
For each particular training set size, we evaluate each method on 50 random splits and report the average accuracy, standard deviation, and a detailed accuracy distribution.
Parameter Settings.
We train SRGCN for a maximum of 300 epochs and use the Adam optimizer with learning rate 0 .
To better assess the effectiveness of our SRGCN, we use the same set of hyperparameters as in (Kipf & Welling, 2017) for GCN.
More precisely, the dropout rate is 0 .
5 , the number of the hidden units in H 1 and H 2 is 16 and the weight of L 2 regularization is β = 0 . 0005 .
Hence the only difference between GCN and SRGCN in the actual implementations is the reconstruction loss.
In all the experiments, the weight of the reconstruction loss is set to α = 0 . 0001 , which is the only one extra hyperparameter needs to be tuned compared with GCN.
The parameter settings of MoNet and GAT are directly taken from (Monti et al., 2017) and (Velickovic et al., 2018).
The embedding size of each unsupervised learning method is set to 128 and other parameters are set in common with settings in (Bojchevski & G¨unnemann, 2018).
5. E XPERIMENT R ESULTS
The empirical results of task 1 and task 2 are summarized in Table 2 and Table 3 respectively.
We complement our few-shot results with experiments on standard splits, the results of which are presented in Table 4.
[Table]
For task 1 , the empirical results clearly demonstrate the advantage of SRGCN across all three datasets.
In particular, SRGCN achieves signiﬁcant improvements over GCN (by a margin of up to 6% and 10% on Cora and Citeseer, respectively), while GCN consistently outperforms the other two baselines.
Since GCN and SRGCN use the same encoding network structure and the same set of hyperparameters, the effectiveness of the proposed SR regularization is obvious from the results.
Perhaps surprisingly, we observe that the performance of GAT is much worse than other baselines in the few-show setting, even though it achieves state-of-the-art accuracy for standard splits.
We think a possible reason for this might be that the attention mechanism in GAT results in higher model complexity, which requires more training samples and thus is more likely to cause overﬁtting in few-show learning.
Our regularization method might be a solution to this issue of GAT, which is left as future work.
We observe the classiﬁcation accuracy is sensitive to the selection of labeled examples in the fewshot setting.
In our experiments, the results w.r.t.
50 random splits are recorded.
From the standard deviations, we see that SRGCN is generally more robust against the choice of training samples than the baselines.
We present box-plots of the accuracy distributions on Cora for task 1 in Figure 1.
More results on accuracy distributions can be found in Appendix B.
[Figure]
In task 2 , compared with all embedding-based methods and semi-supervised methods,
SRGCN achieves the highest accuracy under almost all experimental settings.
We observe that the recent G2G method has impressive performance especially in one-shot experiments.
For GAT, contrast to task 1 , when training examples are evenly distributed among all classes, it attains very competitive performance.
Among three semi-supervised baselines, MoNet typically has the best performance.
On the other hand, as the number of labeled examples grows, the accuracy of GCN,
MoNet and GAT become closer to SRGCN.
This is reasonable, since the effect of structural regularization will be dominated by the supervised loss when the training set is large.
[Table] [Table]
Finally
[Table]
we report the classiﬁcation accuracies of semi-supervised models on the standard dataset splits, which are commonly used in previous works such as Yang et al.
; Kipf & Welling (2017); Velickovic et al.
Results for all baseline methods are taken from the original papers.
Even in this setting
[Table]
where the label rate is relatively high 2 , SRGCN still outperforms GCN.
This shows that our SR regularization not only improves accuracy signiﬁcantly for few-shot learning, the results on standard splits shows that it is also an effective regularization method for general purpose.
Equipped with attention mechanisms, GAT remains the best for standard splits.
Since our regularization technique is quite general, it is natural to ask whether it could be applied on GAT or other graph neural networks to improve their generalization, which is left as future work.
CONCLUSION
We have introduced a novel regularized GCN architecture for few-shot classiﬁcation problems on graph-structured data.
Our SRGCN model combines the original GCN structure with an encoderdecoder architecture, which can be considered as a regularization method.
What make this more powerful than standard methods is that the regularization term is a function parameterized by a trainable neural network, whose structure depends on the underlying graph topology.
Experiments on a number of network datasets shows that SRGCN has matched state-of-the-art results and can signiﬁcantly improve classiﬁcation accuracy when there are very few examples from each class.
Moreover, as the original GCN, our method is simple and easy to implement.
This suggest that the proposed SRGCN model is capable of overcoming the classiﬁcation accuracy degeneration caused by insufﬁcient labeled information, while being computationally efﬁcient on par with GCNs.
A N ETWORK V ISUALIZATION
Semi-supervised methods also learn a low-dimensional embedding for each node in the graph, which can be used to create meaningful visualizations of a network in
2D/3D.
Moreover, the effectiveness of such methods can also be investigated qualitatively when the learned representations are further projected onto the 2D space.
We provide such a visualization of the feature representation produced by GCN and SRGCN respectively on the Cora dataset (Figure 2) with t-SNE (Maaten & Hinton, 2008).
The visualization results show that the clustering effect exhibited by SRGCN is more discernible than that by GCN, which align with our numerical results
[Figure]
and SRGCN’s middle layer (used for classiﬁcation) on the Citeseer dataset.
The representations are trained using a labeled set of size 40 .
B M ORE EXPERIMENTAL RESULTS
We present the histograms of the accuracy distributions on Cora and Citeseer about task 1 .
As is shown in the histograms, X-axis represents accuracy, Y-axis represents the frequency of the experiment whose accuracy is in this interval.
[Figure] [Figure]