Relational Graph Attention Networks
Anonymous authors
Paper under double-blind review
Abstract
We investigate Relational Graph Attention Networks, a class of models that extends non-relational graph attention mechanisms to incorporate relational information, opening up these methods to a wider variety of problems. A thorough evaluation of these models is performed, and comparisons are made against established benchmarks.
To provide a meaningful comparison, we retrain Relational Graph Convolutional Networks, the spectral counterpart of Relational Graph Attention Networks, and evaluate them under the same conditions. We ﬁnd that Relational Graph Attention Networks perform worse than anticipated, although some conﬁgurations are marginally beneﬁcial for modelling molecular properties.
We provide insights as to why this may be, and suggest both modiﬁcations to evaluation strategies, as well as directions to investigate for future work.
Introduction
Convolutional Neural Networks ( CNN s) successfully solve a variety of tasks in Euclidean grid-like domains, such as image captioning (Donahue et al., 2017) and classifying videos (Karpathy et al., 2014).
CNN s are successful because they assume the data is locally stationary and compositional (Deﬀerrard et al., 2016;
Henaﬀ et al., 2015; Bruna et al., 2013).
However, data often occurs in the form of graphs or manifolds, which are classic examples of non-Euclidean domains. Speciﬁc instances include knowledge bases, molecules, and point clouds captured by 3D data acquisition devices (Wang et al., 2018).
The generalisation of Neural Networks ( NN s) to non-Euclidean domains is termed Geometric Deep Learning ( GDL ), and may be roughly divided into spectral, spatial and hybrid approaches (Bronstein et al., 2017).
Spectral approaches (Deﬀerrard et al., 2016), most notably Graph Convolutional Networks ( GCN s) (Kipf and Welling, 2016), are limited by their basis-dependence.
A ﬁlter that is learned with respect to a basis on one domain is not guaranteed to behave similarly when applied to another basis and domain.
Spatial approaches are limited by an absence of shift invariance and lack of coordinate system (Duvenaud et al., 2015; Atwood and Towsley, 2016; Monti et al., 2017).
Hybrid approaches combine spectral and spatial approaches, trading their advantages and deﬁciencies against each-other (Bronstein et al., 2017; Rustamov and
Guibas, 2013; Szlam et al., 2005; Gavish et al., 2010). A recent approach that began with Graph Attention Networks ( GAT s), applied attention mechanisms to graphs, and does not share these limitations (Veličković et al., 2017; Gong and Cheng, 2018; Zhang et al., 2018; Monti et al., 2018; Lee et al., 2018).
An alternative direction has been to generalise Recurrent Neural Networks ( RNN s) from sequential message passing on one-dimensional signals, to message passing on graphs (Sperduti and Starita, 1997; Frasconi et al., 1997; Gori et al., 2005). Incorporating gating mechanisms led to the development of Gated Graph Neural Networks ( GGNN s) (Scarselli et al., 2009; Allamanis et al., 2017) 1 .
Relational Graph Convolutional Networks ( RGCN s) have been proposed as an extension of GCN s to the domain of relational graphs (Schlichtkrull et al., 2018).
This model has achieved impressive performance on node classiﬁcation and link prediction tasks, however, its mechanisms still resides within spectral methods and shares their deﬁciencies. The focus of this work investigate generalisations of RGCN away from its spectral origins. We take RGCN as a starting point, and investigate a class of models we term Relational
Graph Attention Networks ( RGAT s), extending attention mechanisms to the relational graph domain. We consider two variants, Within-Relation Graph Attention ( WIRGAT ) and Across-Relation Graph Attention ( ARGAT ), each with either additive or multiplicative attention.
We perform an extensive hyperparameter search, and evaluate these models on challenging transductive node classiﬁcation and inductive graph classiﬁcation tasks. These models are compared against established benchmarks, as well as a re-tuned RGCN model. We show that RGAT performs worse than expected, although some conﬁgurations produce marginal beneﬁts on inductive graph classiﬁcation tasks.
In order to aid further investigation in this direction, we present the full Cumulative Distribution Functions ( CDF s) for the hyperparameter searches in Appendix D, and statistical hypothesis tests in Appendix E.
We also provide a vectorised, sparse, batched implementation of RGAT and RGCN in TensorFlow which is compatible with eager execution mode to open up research into these models to a wider audience 2 .
RGAT architecture 2. Relational graph attention layer
We follow the construction of the GAT layer in Veličković et al.
(2017), extending to the relational setting, using ideas from Schlichtkrull et al.
Layer input and output The input to the layer is a graph with R = | (cid:82) | relation types and N nodes.
The i th node is represented by a feature vector h i ∈ R F , and the features of all nodes are summarised in the feature matrix H =
[ h 1 h 2 . . .
h N ] ∈ R N × F .
The output of the layer is the transformed feature matrix H (cid:48) =
[ h (cid:48) 1 h (cid:48) 2 . . .
h (cid:48) N ] ∈ R N × F (cid:48) , where h (cid:48) i ∈ R F (cid:48) is the transformed feature vector of the i th node.
Intermediate representations Diﬀerent relations convey distinct pieces of information.
The update rule of Schlichtkrull et al.
(2018) made this manifest by assigning each node i a distinct intermediate representation g ( r ) i
[Equation]
R F (cid:48) under relation r
[Equation]
) where G ( r ) = (cid:104) g ( r ) 1 g ( r ). . .
g ( r ) N (cid:105) is the intermediate representation feature matrix under relation r , and W ( r ) ∈ R F × F (cid:48) are the learnable parameters of a shared linear transformation.
Logits Following Veličković et al.
; Zhang et al. (2018), we assume the attention coeﬃcient between two nodes is based only on the features of those nodes up to a neighborhoodlevel normalisation.
To keep computational complexity linear in R , we assume that, given linear transformations W ( r ) , the logits E ( r ) i,j of each relation r are independent
[Equation]
) and indicate the importance of node j ’s intermediate representation to that of node i under relation r .
The attention is masked so that, for node i , coeﬃcients α ( r ) i,j exist only for j ∈ (cid:78) ( r ) i , where (cid:78) ( r ) i denotes the set of neighbor indices of node i under relation r ∈ (cid:82) .
Queries, keys and values The logits are composed from queries and keys, and specify how the values, i.e. the intermediate representations g ( r ) i , will combine to produce the updated
Rel_
Rel_R
E
E ( 1 )
Softmax node_i j
Softmax j i,j ( R ) i,j ( R ) i,j α α ( 1 ) i,j node representations h (cid:48) i (Vaswani et al., 2017). A separate query kernel Q ( r ) ∈ R F (cid:48) × D and key kernel K ( r ) ∈ R F (cid:48)
× D project the intermediate representations g ( r ) i , into query and key representations of dimensionality D
[Equation]
For convenience, the query and key kernels are combined to form the attention kernels A ( r ) = Q ( r ) ⊕ K ( r ) ∈ R 2 F (cid:48)
× D .
These query and representations are the building blocks of the two speciﬁc realisations of a in Equation (2) that we now consider.
Additive attention logits
The ﬁrst realisation of a we consider is the relational modiﬁcation of the logit mechanism of Veličković et al.
[Equation]
[Equation]
) where the query and key dimensionality are both D = 1 , and q ( r ) i and k ( r ) i are scalar ﬂattenings of their one-dimensional vector counterparts q ( r ) i , k ( r ) i ∈
R 1 .
We refer to any instance of RGAT using logits of the form in Equation (4) as additive RGAT . Multiplicative attention logits The second realisation we consider is the multiplicative mechanism of Vaswani et al. ; Zhang et al. [Equation]
[Equation]
where the query and key dimensionality D can be any positive integer.
We refer to any instance of RGAT using logits of the form in Equation (4) as multiplicative RGAT .
It should be noted that there are many types of attention mechanisms beyond vanilla additive and multiplicative.
These include mechanisms leveraging the structure of the dual graph
Monti et al.
(2018) as well as learned edge features Gong and Cheng (2018).
The attention coeﬃcients should be comparable across nodes.
This can be achieved by applying softmax appropriately to any logits E ( r ) i,j .
We investigate two candidates, each encoding a diﬀerent prior belief about how the importance of diﬀerent relations.
[Figure] j,r i,j ( R ) i,j α ( R ) i,j α ( 1 ) i,j WIRGAT The simplest way to take the softmax over the logits E ( r ) i,j of Equation (4) or
Equation (5) is to do so independently for each relation r
[Equation]
We call the attention in Equation (6) Within-Relation Graph Attention ( WIRGAT ), and it is shown in Figure 1.
This mechanism encodes the prior that relation importance is a purely global property of the graph by implementing an independent probability distribution over nodes in the neighborhood of i for each relation r .
Explicitly, for any node i and relation r , nodes j, k ∈ (cid:78) ( r ) i yield competing attention coeﬃcients α ( r ) i,j and α ( r ) i,k with sizes depending on their corresponding representations g ( r ) j and g ( r ) k .
There is no competition between any attention coeﬃcients α ( r ) i,j and α ( r (cid:48) )
i,k for all nodes i and nodes j ∈ (cid:78) ( r ) i , j (cid:48) ∈ (cid:78) ( r (cid:48) )
where r (cid:48) (cid:54) =
r irrespective of node representations.
ARGAT An alternative way to take the softmax over the logits E ( r ) i,j of Equation (4) or Equation (5) is across node neighborhoods irrespective of relation r
[Equation]
We call the attention in Equation (7) Equation (6) Across-Relation Graph Attention ( AR- GAT ), and it is shown in Figure 2.
This mechanism encodes the prior that relation importance is a local property of the graph by implementing a single probability distribution over the diﬀerent representations g ( r ) j for nodes j in the neighborhood of node i .
Explicitly, for any node i and all r, r (cid:48) ∈ (cid:82) , all nodes j ∈ (cid:78) ( r ) i and k ∈ (cid:78) ( r (cid:48) )
i yield competing attention coeﬃcients α ( r ) i,j and α ( r (cid:48) )
i,k with sizes depending on their corresponding representations g ( r ) j and g ( r (cid:48) )
k .
Comparison to RGCN For comparison, the coeﬃcients of RGCN are given by α ( r ) i,j = | (cid:78) ( r ) i | − 1 . This encodes the prior that the intermediate representations of nodes j ∈ (cid:78) ( r ) i to node i under relation r are equally important. I npu t R G
A T c o n c a t
R G A T m e a n N o d e l o ss (a) Node classiﬁcation. I npu t
R G
A T c o n c a t R G A T c o n c a t G r a ph ga t h e r
D e n s e D e n s e G r a ph l o ss [Figure]
This architecture is the same as in Schlichtkrull et al. (2018) except with RGCN s replaced with RGAT s. (b) The network architecture used for multi-task graph classiﬁcation on Tox21. This architecture is the same as the GCN s architecture in Altae-Tran et al. except with RGCN s replaces with GAT s
and we do not use graph pooling. Propagation rule Combining the attention mechanism of either Equation (6) or Equation (7) with the neighborhood aggregation step of Schlichtkrull et al.
(2018) gives
[Equation]
where σ represents an optional nonlinearity.
Similar to Vaswani et al.
; Veličković et al.
(2017), we also ﬁnd that using multiple heads in the attention mechanism can enhance performance
[Equation]
where ⊕ denotes vector concatenation, α ( r,k ) i,j are the normalised attention coeﬃcients under relation r computed by either WIRGAT or ARGAT , and g ( r,k ) i
= h
i
[Equation]
W ( r,k ) (cid:1) T is the head speciﬁc intermediate representation of node i under relation r .
It might be interesting to consider cases where there are a diﬀerent number of heads for diﬀerent relationship types, as well as when a mixture of ARGAT and WIRGAT produce the attention coeﬃcients, however, we leave that subject for future investigation and will not consider it further.
Basis decomposition The number of parameters in the RGAT layer increases linearly with the number of relations R and heads K , and can lead quickly to overparameterisation.
In RGCN s it was found that decomposing the kernels was beneﬁcial for generalisation, although it comes at the cost of increased model bias (Schlichtkrull et al., 2018).
We follow this approach, decomposing both the kernels W ( r,k ) as well as the kernels of attention mechanism A ( r,k ) into B V basis matrices V ( b ) ∈ R F × F (cid:48) and B X basis vectors
[Equation]
where c ( r,k ) b , d ( r,k ) b ∈ R are basis coeﬃcients.
We consider models using full and decomposed
W and A .
2. Node classification
For the transductive task of semi-supervised node classiﬁcation, we employ a two-layer RGAT architecture shown in Figure 3a.
We use a Rectiﬁed Linear Unit ( ReLU ) activation after the RGAT concat layer, and a node-wise softmax on the ﬁnal layer to produce an estimate for the probability that the i th label is in the class α
[Equation]
[Table] We then employ a masked cross-entropy loss (cid:76) to constrain the network updates to the subset of nodes (cid:89) whose labels are known
[Equation]
where y i is the one-hot representation of the true label for node i .
2. Graph classification
For inductive graph classiﬁcation, we employ a two-layer RGAT followed by a graph gather and dense network architecture shown in Figure 3b.
We use ReLU activations after each RGAT layer and the ﬁrst dense layer.
We use a tanh activation after the
GraphGather : R N × F → R 2 F , which is a vector concatenation of the mean of the node representations with the feature-wise max of the node representations
[Equation]
The ﬁnal dense layer then produces logits of the size n classes × n tasks , and we apply a task-wise softmax to its output to produce an estimate ˆ y t,α for the probability that the graph is in class α for a given task t , analogous to Equation (11).
Weighted cross-entropy loss (cid:76) is then used to form the learning objective
[Equation]
where w t,α and y t,α are the weights and one-hot true labels for task t and class α respectively.
Evaluation 3. Datasets
We evaluate the models on transductive and inductive tasks.
Following the experimental setup of Schlichtkrull et al.
(2018) for the transductive tasks, we evaluate our model on the Resource Description Framework ( RDF ) datasets AIFB and MUTAG.
We also evaluate our model for an inductive task on the molecular dataset, Tox21.
Details of these data sets are given in Table 1.
For further details on the transductive and inductive datasets, please see Ristoski and Paulheim (2016) and Wu et al.
(2018) respectively.
Transductive baselines We consider as a baseline the recent state-of-the-art results from
Schlichtkrull et al.
(2018) obtained with a two-layer RGCN model with 16 hidden units and basis function decomposition.
We also include the same challenging baselines of FEAT (Paulheim and Fümkranz, 2012), WL (Shervashidze et al., 2011; de Vries and de Rooij, 2015) and RDF2Vec (Ristoski and Paulheim, 2016).
In-depth details of these baselines are given by Ristoski and Paulheim (2016).
Inductive baselines As baselines for Tox21, we compare against the most competitive methods on Tox21 reported in Wu et al.
Speciﬁcally, we compare against deep multitask networks Ramsundar et al.
(2015), deep bypass multitask networks Wu et al.
(2018), Weave Kearnes et al.
(2016), and a RGCN model whose relational structure is determined by the degree of the node to be updated
Altae-Tran et al.
Speciﬁcally, up to and including some maximum degree D max ,
[Equation]
where W deg ( i ) ∈ R F × F (cid:48) is a degree-speciﬁc linear transformation for self-connections,
U deg(i) ∈ R F × F (cid:48) is a degree-speciﬁc linear transformation for neighbours into their intermediate representations g i ∈ R F (cid:48) , and b deg ( i ) is a degree-speciﬁc bias.
Any update for any degree d ( i ) >
D max gets assigned to the update for the maximum degree D max .
3. Experimental setup
Transductive learning For the transductive learning tasks, the architecture discussed in Section 2.2 was applied.
Its hyperparameters were optimised for both AIFB and MUTAG on their respective training/validation sets deﬁned in Ristoski and Paulheim (2016), using 5-fold cross validation.
Using the found hyperparameters, we retrain on the full training set and report results on the test set across 200 seeds.
We employ early stopping on the validation set during cross-validation to determine the number of epochs we will run on the ﬁnal training set.
Hyperparameter optimisation details are given in Table 4 of Appendix B.
Inductive learning For the inductive learning tasks, the architecture discussed in Section 2.3 was applied.
In order to optimise hyperparameters once, ensure no data leakage, but also provide comparable benchmarks to those presented in Wu et al.
(2018), three benchmark splits were taken from the MolNet benchmarks 4 , and graphs belonging to any of the test sets were isolated.
Using the remaining graphs we performed a hyperparameter search using 2 folds of 10-fold cross validation.
Using the found hyperparameters, we then retrained on the three benchmark splits provided with 2 seeds each, giving an unbiased estimate of model performance.
We employ early stopping during both the cross-validation and ﬁnal run (the validation set of the inductive task is available for the ﬁnal benchmark, in contrast to the transductive tasks) to determine the number of training epochs.
Hyperparameter optimisation details are given in Table 5 of Appendix B.
Constant attention In all experiments, we train with the attention mechanism turned on.
At evaluation time, however, we report results with and without the attention mechanism to provide insight into whether the attention mechanism helps.
ARGAT ( WIRGAT ) without the attention is called C- ARGAT (C- WIRGAT ).
3. Results 3.3. Benchmarks and additional analyses
Model means and standard deviations are presented in Table 2.
To provide a picture of characteristic model behaviour, the CDF s for the hyperparameter sweep are presented in
Figure 5 of Appendix D. To draw meaningful conclusions, we compare against our own implementation of RGCN rather than the results reported in Schlichtkrull et al. ; Wu et al.
We will occasionally employ a one-sided hypothesis test in order to make concrete statements about model performance. The details and complete results of this test are presented in Appendix E. When we refer to signiﬁcant results this corresponds to a test statistic supporting our hypothesis with a p − value p ≤ 0 .
[Table] 3.3. Transductive learning In Table 2a we evaluate RGAT on MUTAG and AIFB.
With additive attention, WIRGAT outperforms ARGAT , consistent with Schlichtkrull et al.
Interestingly, when employing multiplicative attention, the converse appears true.
For node classiﬁcation tasks on RDF data, this indicates that the importance of a particular relation type does not vary much (if at all) across the graph unless one employs a multiplicative comparison 5 between node representations.
AIFB On AIFB, the best to worst performing models are: 1) additive WIRGAT 2) multiplicative ARGAT 3) RGCN 4) additive ARGAT , and 5) multiplicative WIRGAT , with each comparison being signiﬁcant. When comparing against their constant attention counterparts, the signiﬁcant diﬀerences observed were for additive and multiplicative ARGAT , where attention gives a relative mean performance improvements of 1.03% and 0.31% respectively, and multiplicative WIRGAT , where attention gives a relative mean performance drop of 0.84%.
Although we present state-of-the art result on AIFB with additive WIRGAT , since its performance with and without attention are not signiﬁcantly diﬀerent, it is unlikely that this is due to the attention mechanism itself, at least at inference time. Over the hyperparameter space, additive WIRGAT and RGCN are comparable in performance (see Figure 5a in
Appendix D), leading us to conclude that the result is more likely attributable to ﬁnding a better hyperparameter point for additive WIRGAT during the search.
MUTAG On MUTAG, the best to worst performing models are: 1) RGCN 2) multiplicative ARGAT 3) additive WIRGAT tied with multiplicative WIRGAT , and 4) additive ARGAT , with each comparison being signiﬁcant. When comparing against their constant attention counterparts, the signiﬁcant diﬀerences observed were for additive WIRGAT and ARGAT , where attention gives relative mean performance improvements of 0.66% and 2.90% respectively, and multiplicative ARGAT , where attention gives a relative mean performance drop of 1.63%.
We note that RGCN consistently outperforms RGAT on MUTAG, contrary to what might be expected (Schlichtkrull et al., 2018).
The result is surprising given that RGCN lies within the parameter space of RGAT (where the attention kernel is zero), a conﬁguration we check through evaluating C- WIRGAT .
In our experiments we have observed that both RGCN and RGAT can memorise the MUTAG training set with 100% accuracy without diﬃculty (this is not the case for AIFB).
The performance gap between RGCN and RGAT could then be explained by the following:
- During training, the RGAT layer uses its attention mechanism to solve the learning objective.
Once the objective is solved, the model is not encouraged by the loss function to seek a point in the parameter space that would also behave well when attention is set to a normalising constant within neighbourhoods (i.e. the parameter space point that would be found by RGCN ).
- The RDF tasks are transductive, meaning that a basis-dependent spectral approach is suﬃcient to solve them.
As RGCN already memorises the MUTAG training set, a model more complex 6 than RGCN , for example RGAT , that can also memorise the training set is unlikely to generalise as well, although this is a hotly debated topic - see e.g. Zhang et al.
We employed a suite of regularisation techniques to get RGAT to generalise on MUTAG, including L2-norm penalties, dropout in multiple places, batch normalisation, parameter reduction and early stopping, however, no evaluated harshly regularised points for RGAT generalise well on MUTAG.
Our ﬁnal observation is that the attention mechanism presented in Section 2.1 relies on node features.
The node features for the above tasks are learned from scratch (the input feature matrix is a one-hot node index) as part of the task. It is possible that in this semi-supervised setup, there is insuﬃcient signal in the data to learn both the input node embeddings as well as a meaningful attention mechanism to act upon them.
3.3. Inductive learning
In Table 2b we evaluate RGAT on Tox21.
The number of samples is lower for these evaluations than for the transductive tasks, and so fewer model comparisons will be accompanied with a reasonable signiﬁcance, although there are still some conclusions we can draw.
Through a thorough hyperparameter search, and incorporating various regularisation techniques, we obtained the relative mean performance of 0.72% for RGCN compared to the result reported in Wu et al.
(2018), providing a much stronger baseline.
Both additive attention models match the performance of RGCN , whereas multiplicative WIRGAT and ARGAT marginally outperform RGCN , although this is not signiﬁcant ( p = 0 .
24 and p = 0 .
41 respectively).
When comparing against their constant attention counterparts, signiﬁcant diﬀerences observed were for multiplicative WIRGAT and ARGAT , where attention gives a relative mean performance improvements of 3.33% and 4.36% respectively.
We do not observe any signiﬁcant gains coming from additive attention when compared to their constant counterparts.
Conclusion
We have investigated a class of models we call Relational Graph Attention Networks ( RGAT s).
These models act upon graph structures, inducing a masked self-attention that takes account of local relational structure as well as node features.
This allows both nodes and their properties under speciﬁc relations to be dynamically assigned an importance for diﬀerent nodes in the graph, and opens up graph attention mechanisms to a wider variety of problems.
We evaluted two speciﬁc attention mechanisms, Within-Relation Graph Attention ( WIRGAT ) and Across-Relation Graph Attention ( ARGAT ), under both an additive and multiplicative logit construction, and compared them to their equivalently evaluated spectral counterpart Relational Graph Convolutional Networks ( RGCN s).
We ﬁnd RGAT s perform competitively or poorly on established baselines.
This behavior appears strongly task-dependent.
Speciﬁcally, relational inductive tasks such as graph classiﬁcation beneﬁt from multiplicative ARGAT , whereas transductive relational tasks, such as knowledge base completion, at least in the absence of node features, are better tackled using spectral methods like RGCN s or other graph feature extraction methods like Weisfeiler-Lehman ( WL ) graph kernels.
In general we have found that WIRGAT should be paired with an additive logit mechanism, and fares marginally better than ARGAT on transductive tasks, whereas ARGAT should be paired with a multiplicative logit mechanism, and fares marginally better on inductive tasks. We have found no cases where choosing any variation of RGAT is guaranteed to signiﬁcantly outperform RGCN , although we have found that in cases where RGCN can memorise the training set, we are conﬁdent that RGAT will not perform as well as RGCN . Consequently, we suggest that before attempting to train RGAT , a good ﬁrst test is to inspect the training set performance of RGCN .
Through our thorough evaluation and presentation of the behaviours and limitations of these models, insights can be derived that will enable the discovery of more powerful model architectures that act upon relational structures. Observing that model variance on all of the tasks presented here is high, any future work developing and expanding these methods must choose larger, more challenging datasets. In addition, a comparison between the generalisation of spectral methods, like those presented here, and generalisations of Recurrent Neural Networks ( RNN s), like Gated Graph Sequence Networks, is a necessary ingredient for determining the most promising future direction for these models.
A Tox21 Results
For completeness, we present the training, validation and test set performance of our models in addition to those in Wu et al.
(2018) in Table
[Table]
[Table]
B Hyperparameters
We perform hyperparameter optimisation using hyperopt Bergstra et al.
(2013) with priors for the transductive tasks speciﬁed in Table 4 and priors for the inductive tasks speciﬁed in
Table 5.
In all experiments we use the Adam optimiser (Kingma and Ba, 2014).
[Table] [Table] C Charts To aid interpretability of the results presented in Table 2 we present a chart representation in Figure 4.
[Figure]
D Cumulative distribution functions
To aid further insight into our results
[Figure]
we present the Cumulative Distribution Functions ( CDF s) for each model on each task in Figure 4.
In this context, we treat the performance metric of interest during the hyperparameter search as the empirical distribution of some random variable X .
We then deﬁne its CDF F X ( x ) in the standard way
[Equation]
16) where P ( X ≤ x ) is the probability that X takes on a value less than or equal to x .
The CDF allows one to gauge whether any given architecture typically performs better than another across the whole space
[Figure]
rather than comparison of the tuned hyperparameters
[Figure]
which in some cases may be outliers in terms of generic behavior for that architecture
[Figure]
AIFB Additive and multiplicative ARGAT perform poorly for most areas of the hyperparameter
, whereas RGCN and multiplicative WIRGAT perform comparably across the hyperparameter
MUTAG Interestingly, the models that have a greater amount of hyperparameter space covering poor performance (i.e. RGCN , multiplicative and additive WIRGAT ) are also the models which also have a greater amount of hyperparameter space covering good performance.
In other words, on the MUTAG, the ARGAT prior resulted in a model whose test set performance was relatively insensitive to hyperparameter choice when compared against the other candidates.
Given that the ARGAT model was the most ﬂexible of the models evaluated, and that it was able to memorise the training set, this suggests that the task contained insuﬃcient information for the model to learn its attention mechanism.
Given that WIRGAT was able to at least partially learn to its attention mechanism suggests that WIRGAT is less data hungry than ARGAT .
{+Tox
+}
The multiplicative attention models fare poorly on the majority of the hyperparameter space compared to the other models.
There is a slice of the hyperparameter space where the multiplicative attention models outperform the other models, however, indicating that although they are diﬃcult to train, it may be worth spending time hyperoptimising them if you need the best performing model on a relational inductive task.
The additive attention models and RGCN perform comparably across the entirety of the hyperparameter space and generally perform better than the multiplicative methods except for the very small region of hyperparameter space mentioned above.
E Significance testing
In order to determine if any of our model comparisons are signiﬁcant, we employ the one-sided
Mann-Whitney U test Mann and Whitney (1947) as we are interested in the direction of movement (i.e. performance) and do not want to make any parametric assumptions about model response.
For two populations X and Y :
• The null hypothesis H 0 is that the two populations are equal, and • The alternative hypothesis H 1 is that the probability of an observation from population X exceeding an observation from population Y is larger than the probability of an observation from Y exceeding an observation from X;
i
e., H 1 : P ( X > Y ) >
P ( Y > X ) .
We treat the empirical distributions of Model A as samples from population X and the empirical distributions of Model B as samples from population Y .
This allows us a window into whether, given a task, whether which is the better model out of a pair of models.
Results on AIFB, MUTAG and TOX21 are given in Figure 6, Figure 7 and Figure 8 respectively.
R G C N ( o u r s )
A dd i t i v e C - W
I R G A
T
A dd i t i v e W
I R
G A T
A dd i t i v e C - A R
G A T
A dd i t i v e A R G
A T
M u l t i p li c a t
i v e C - W
I R G A
T
M u l t i p li c a t
i v e W I R
G A T
M u l t i p li c a t
i v e C - A R
G A T
M u l t i p li c a t
i v e A R G
A T
Model
[Table]
Additive
[Table]
[Figure]
R G C N ( o u r s )
A dd i t i v e C - W
I R G A
T
A dd i t i v e W
I R
G A T
A dd i t i v e C - A R
G A T
A dd i t i v e A R G
A T
M u l t i p li c a t
i v e C - W
I R G A
T
M u l t i p li c a t
i v e W I R
G A T
M
[Table]
l t i p li c a t
i v e C
[Table]
A R
G A T
M u l t i p
[Table]
i v
[Table]
A
[Table]
[Figure]
R G C N ( o u r s )
A dd i t i v e C - W
I R G A
T
A dd i t i v e W
I R
G A T
A dd i t i v e C - A R
G A T
A dd i t i v e A R G
A T
M u l t i p li c a t
i v e C - W
I R G A
T
M u l t i p li c a t
i v e W I R
G A T
M
[Table]
i p li
[Table]
a t i v e C
[Table]
R
[Table]
T
[Table]
[Figure]