We consider the problem of learning distributed representations for entities and relations of multi-relational data so as to predict missing links therein. Convolutional neural networks have recently shown their superiority for this problem, bringing increased model expressiveness while remaining parameter efficient. Despite the success, previous convolution designs fail to model full interactions between input entities and relations, which potentially limits the performance of link prediction. In this work we introduce ConvR, an adaptive convolutional network designed to maximize entity-relation interactions in a convolutional fashion. ConvR adaptively constructs convolution filters from relation representations, and applies these filters across entity representations to generate convolutional features. As such, ConvR enables rich interactions between entity and relation representations at diverse regions, and all the convolutional features generated will be able to capture such interactions. We evaluate ConvR on multiple benchmark datasets. Experimental results show that: (1) ConvR performs substantially better than competitive baselines in almost all the metrics and on all the datasets; (2) Compared with state-of-the-art convolutional models, ConvR is not only more effective but also more efficient. It offers a 7% increase in MRR and a 6% increase in Hits@10, while saving 12% in parameter storage. Multi-relational data refers to directed graphs whose nodes correspond to entities and edges different types of relations between entities. An edge of the form ( subject , relation , object ) indicates that there exists a specific relation between the subject and object entities. Learning with multi-relational data plays a pivotal role in many application domains, ranging from social networks or recommender systems to large-scale knowledge bases (KBs) (Bordes et al., 2013; Jenatton et al., 2012). This work focuses on modeling multi-relational data from KBs, with the aim of predicting missing facts on KBs, a challenging task known as link prediction in statistical relational learning (SRL) (Getoor and Taskar, 2007). Various SRL techniques (Nickel et al., 2016a) have been proposed for this task, among which vector space embedding models (Wang et al., 2017) are gaining increasing attention due to their superior performance and potential scalability. The key idea there is to learn and operate on latent features (embeddings) of entities and relations, so as to uncover non-trivial connectivity patterns in multi-relational data. Previous works of this kind tend to adopt shallow, simple models to extract latent features, e.g., the translation based models (Bordes et al., 2013; Wang et al., 2014) or the bilinear models and their variants (Jenatton et al., 2012; Yang et al., 2015; Trouillon et al., 2016). Using these simple models allows one to easily handle large-scale KBs, but usually at the cost of learning less expressive features. In fact, such simple models typically generate a single feature with each entry of the embeddings. The only way to increase the number of features (and thus their expressiveness) is to increase the embedding size (Dettmers et al., 2018). This potentially limits the performance of link prediction with a given number of parameters. To increase model expressiveness, there emerge some deeper, more complicated designs, in particular those on the basis of neural network architectures (Socher et al., 2013; Bordes et al., 2014; Dong et al., 2014; Schlichtkrull et al., 2017a). Such approaches, however, often have more parameters and are prone to overfit, at least on the (relatively small) benchmark datasets used by the scientific community (Nickel et al., 2016a). Recently, Dettmers et al. (2018) devised ConvE, 979 a multi-layer convolutional network which enables expressive feature learning while remaining highly parameter efficient. Given a subject-relation-object triple ( s, r, o ) , ConvE first reshapes the vector representation of the subject s and that of the relation r into 2D matrices, and then concatenates the two matrices and feeds them into a 2D convolutional layer to extract higher-level, non-linear features, as illustrated in Figure 1(a). The resultant convolutional features are finally projected and matched with the vector representation of the object o via an inner product. Note that by sliding across the embeddings using small-sized filters, the convolution operator can easily generate much more features without increasing the embedding size. As such, ConvE offers increased expressiveness and achieves competitive performance in link prediction. Nevertheless, despite its success, ConvE is still insufficient to fully capture the interactions between input entities and relations, which has long been recognized as crucial for modeling multi-relational data (Nickel et al., 2011; Garca-Durn et al., 2014; Trouillon et al., 2016). In ConvE, the (reshaped) representations of input entities and relations are simply stacked together and fed into a convolutional layer. Although 2D convolution is better than 1D convolution in modeling entity-relation interactions, typical 2D convolution with global filters on such a stacked matrix, however, can only model interactions around the concatenation line (Dettmers et al., 2018). Consider the example in Figure 1(a), where two matrices of size 3  3 are formed after reshaping, stacked, and fed as input to a convolutional layer. Convolving across the input with a global filter of size 2  2 will then be able to model interactions only in the regions where the two matrices adjoin (e.g., the region outlined in red). That means, only a small proportion of the output convolutional features (20% in this example, striped with orange and blue) will effectively capture entity-relation interactions, and the vast majority others will be entityor relation-independent. This poses potential negative impacts on the link prediction task. This paper, aiming at maximizing the interactions between input entities and relations, introduces ConvR, an adaptive convolutional network specifically designed for multi-relational data. As illustrated in Figure 1(b), the key idea of ConvR is to facilitate convolution across entity representations with its filters adaptively constructed from relation representations. Such adaptive convolution will model the interactions between the two types of input not only more naturally but also more effectively. Specifically, given a triple, the vector representation of the subject is reshaped and fed as input to a convolutional layer, while that of the relation is split and reshaped into a set of filters. ConvR then convolves across the input with these filters, enabling each filter (a part of the relation representation) to interact with diverse regions of the input (the entity representation). Through this adaptive convolution process, all the features generated will be able to capture entity-relation interactions (striped with orange and blue in Figure 1(b)). These convolutional features are finally projected and matched with the representation of the object. Besides being more effective, adaptive convolution enables potentially more efficient modeling (in terms of the number of parameters). Compared with ConvE (Figure 1(a)), ConvR (Figure 1(b)) needs no global filters and generates smaller feature maps, making the follow-up projection layer roughly half as large as that of ConvE. The idea of adaptive convolution, in fact, is rather generic for the multi-relational scenario. By splitting and reshaping relation vectors, ConvR can be easily generalized to other paradigms such as 1D or 3D convolution, not restricted to the 2D setting. To facilitate a direct and fair comparison to ConvE where only 2D convolution is considered and tested, this paper takes the 2D setting as an example, and shows the superiority of ConvR over ConvE in this setting. We will investigate higher dimensional convolution in our future work. Our contributions are as follows. (1) We propose a novel adaptive convolution model for learning with multi-relational data. Our approach, ConvR, takes full advantage of entity-relation interactions in a convolutional fashion, while still remaining highly parameter efficient. (2) We evaluate ConvR in the link prediction task on KBs and achieve very promising results on multiple benchmark datasets, including not only the popular WN18 and FB15K (Bordes et al., 2013), but also the more difficult WN18RR (Dettmers et al., 2018) and FB15K-237 (Toutanova and Chen, 2015). (3) We systematically compare the efficiency and effectiveness of ConvR and ConvE on FB15K-237, showing that ConvR can perform substantially better with a good variety of parameter settings. In particular, it offers a 7% 980 Global filters Reshape Stack Convolve Embeddings (cid:256) Image (cid:257) Feature maps s r (b) ConvR: Convolution with relation-specfic filters. increase in MRR and a 6% increase in Hits@10, with the total parameter number only 88% as large as that of ConvE. We consider multi-relational data represented as a graph, which can also be formalized as a set of subject-relation-object triples G = { ( s, r, o ) }  E  R  E . Here, E is the set of entities, and R the set of relations. Each triple ( s, r, o ) is composed of a subject entity s  E , a relation r  R , and an object entity o  E , indicating that there exists a relation of type r between the two entities s and o . Such triples are also called facts in knowledge bases (KBs). We follow (Dettmers et al., 2018) and formalize link prediction on multi-relational data as a pointwise learning to rank problem, where the objective is to learn a scoring function  : E  R  E  R . For any input triple ( s, r, o ) , the higher the score  ( s, r, o ) , the more likely the triple is true. Various statistical relational learning (SRL) techniques have been proposed for this task. See (Nickel et al., 2016a) for a thorough review of such techniques, with their application on large-scale KBs. This paper focuses on vector space embedding models, a branch of SRL with superior performance and potential scalability. Given an input triple ( s, r, o ) , a model of this kind first maps the entities s, o and relation r to their distributed representations (i.e., embeddings), usually vectors s , r , o  R d for efficient learning. A score is then defined for the triple by operating on these distributed representations, i.e.,  ( s, r, o ) =  ( s , r , o ) . A great many approaches of this kind have been devised in the last few years, where a key difference is the designing of the scoring function  ( s , r , o ) . See (Wang et al., 2017) for a recent survey. This section presents ConvR, an adaptive convolutional network specifically designed for learning with multi-relational data. The key idea of ConvR is to facilitate convolution across entity representations with its filters adaptively constructed from relation representations, so as to maximize the interactions between the two types of input. Figure 1(b) provides a simple illustration of this idea. In the rest of this section, we detail the ConvR model, discuss parameter learning of it, and show its advantages over ConvE, a convolutional network achieving promising results in multi-relational link prediction (Dettmers et al., 2018). To facilitate a direct and fair comparison to ConvE, we focus on the 2D setting. But the idea can be easily generalized to other convolution paradigms. The ConvR model Given a triple ( s, r, o ) , ConvR maps the two entities s, o to vectors s , o  R d e , and the relation r to vector r  R d r , where d e and d r are the embedding size of entities and relations, respectively. Then, the subject vector s is reshaped into a 2D matrix S  R d he  d we (where d e = d he d we ) and fed as input to a convolutional layer. As shown in (Dettmers et al., 2018), using 2D rather than 1D convolution would be able to extract more feature interactions and increase model expressiveness. The relation vector r is further split into blocks r (1) ,    , r ( c ) with equal size, where each r ( (cid:2) )  R d r /c is reshaped into a 2D convolution filter R ( (cid:2) )  R h  w . Here, c is the number of filters, h and w the height and width of each filter, and d r = chw . Figure 1(b) gives a simple example of this reshaping process, where a subject vector of length 9 is reshaped into a 3  3 matrix, and a relation vector of length 8 is split and reshaped into 981 s r = Adaptive convolution Feature maps s r s r s r = RS (1) Figure 2: A simple illustration of adaptive convolution, where a 2  2 filter R (1) (constructed from the first half of the relation vector r ) is convolved across a 3  3 input S (reshaped from the subject vector s ), generating a feature map of size 2  2 . After reshaping, ConvR convolves across the input S using these adaptively constructed, relation-specific filters. For each filter R ( (cid:2) ) , a convolutional feature map C ( (cid:2) )  R ( d he  h +1)  ( d we  w +1) will be generated, with the mn -th entry calculated as: c ( (cid:2) ) m,n = f (cid:2)(cid:3) i,j s m + i  1 ,n + j  1  r ( (cid:2) ) i,j (cid:4) , (1) where f (  ) is a non-linear function, e.g., ReLU (Krizhevsky et al., 2012). Figure 2 visualizes how such a feature map could be generated by convolving across the input with a relation-specific filter (the first equality sign  = ), and how each entry of the feature map could be calculated with the original entity and relation vectors (the second equality sign  = ). We can see that the adaptive convolution paradigm is quite effective in modeling entity-relation interactions. It enables rich interactions between input entity and relation representations at diverse regions, and all the convolutional features generated will be able to capture such interactions. Finally, to compute the triple score  ( s, r, o ) , we flatten the convolutional feature maps C (1) ,    , C ( c ) and stack them into a single vector c . This vector is then projected into R d e by a fully-connected layer, and matched with the object vector o with an inner product, i.e.,  ( s, r, o ) = f ( Wc + b ) (cid:2) o , (2) where W  R d e  c ( d he  h +1)( d we  w +1) and b  R d e are parameters of the fully-connected layer, and f (  ) is again a non-linear function. 1 During reshaping we consider the most natural ordering of the embedding entries. That means, a lengthx vector is reshaped into a y  z matrix ( x = yz ) such that the first row of the matrix comes from the first z entries of the vector, the second row from the second z entries, and the y -th row from the last z entries. Parameter learning For learning the model parameters, we follow (Dettmers et al., 2018) and use 1-to-many scoring to speed-up training and evaluation. Unlike traditional 1-to-1 scoring which takes a triple ( s, r, o ) as input and directly scores it, 1-to-many scoring takes ( s, r ) as input and scores it against all candidate objects o  E simultaneously, generating a score vector p s,r  R |E| . Each dimension of this score vector corresponds to an entity o  E , calculated as p s,ro =  (  ( s, r, o )) , where  ( s, r, o ) is the triple score defined in Eq. (2) and  ( x ) = 1 1+ e  x the sigmoid function. For each input ( s, r ) , we minimize the following cross-entropy loss: L ( s,r )=  1 |E| (cid:3) o E y s,ro log( p s,ro )+ (1  y s,ro )log(1  p s,ro ) , (3) where y s,ro is a binary label. We have y s,ro = 1 if ( s, r, o ) is a valid triple and y s,ro = 0 otherwise. During optimization, we use dropout (Srivastava et al., 2014) to prevent overfitting. Specifically, we use dropout on the reshaped subject representations, the convolutional feature maps, and the projected vectors after the fully-connected layer. We also use batch normalization (Ioffe and Szegedy, 2015) on these representations to stabilize and speed up convergence. We use Adam (Kingma and Ba, 2014) optimizer and label smoothing (Szegedy et al., 2016) as suggested by ConvE. Advantages over ConvE The most prominent advantage of ConvR over ConvE is its high ability to model entity-relation interactions in a convolutional fashion, which is crucial for learning with multi-relational data. ConvE, which convolves across stacked entity-relation representations with global filters, can only model interactions between 982 the two types of input around the concatenation line, and only a small proportion of the convolutional features would be able to capture such interactions (see Figure 1(a)). ConvR, by contrast, enables entity-relation interactions at diverse regions, and all the convolutional features are able to capture such interactions (see Figure 1(b) and Figure 2). Besides being more effective, ConvR might potentially be more efficient (in terms of the number of parameters). ConvE has a space complexity of O ( d |E| + d |R| + chw + cd (2 d h  h + 1)( d w  w + 1)) , where d |E| is to store entity vectors, d |R| relation vectors, chw the c global filters with size h  w , cd (2 d h  h +1)( d w  w +1) the projection matrix in the fully-connected layer, and d = d h d w . As entity and relation representations need to be stacked in ConvE, they are usually of the same size, say d . In ConvR, convolution filters are adaptively constructed from relation vectors, so there is no need for global filters. Also, the input of the convolutional layer will be half-sized, generating smaller feature maps, and hence requires a smaller fully-connected layer. The space complexity of ConvR would be O ( d e |E| + d r |R| + cd e ( d he  h +1)( d we  w + 1)) . Although it could be possible to use different configuration of those common arguments in the two methods (e.g., different number of filters or entity vectors with different size), which may result in different memory cost, we empirically show that ConvR can perform substantially better than ConvE with a good variety of configurations, even those with fewer parameters (see the section Parameter efficiency of ConvR for details). In this section, we evaluate ConvR against competitive baselines in the link prediction task on multiple benchmark KBs. We also investigate parameter efficiency of ConvR against ConvE to further show its superiority. Datasets We use four datasets for our experiments. The first two are the popular WN18 and FB15k, both released by (Bordes et al., 2013). 2 WN18 is a subset of WordNet for lexical relationships between words, and FB15k a subgraph of Freebase for generic facts. In most cases WN18 2 https://everest.hds.utc.fr/doku.php? and FB15k encode a relation and its inverse relation at the same time. That means, once a fact is observed, there are usually two distinct triples created for it, e.g., ( s, hyponym , o ) and ( o, hypernym , s ) , or ( s, director-of , o ) and ( o, directed-by , s ) . As pointed out by (Toutanova and Chen, 2015) and (Dettmers et al., 2018), encoding inverse relations might suffer from test leakage, i.e., for each test triple ( s, r, o ) , it is likely to find its inverse ( o, r  1 , s ) in the training set. To avoid this test leakage issue, we further use WN18RR (Dettmers et al., 2018), 3 a subset of WN18 with inverse relations removed, and FB15k-237 (Toutanova and Chen, 2015), 4 a filtered version of FB15k with both inverse and duplicate relations removed. Table 1 summarizes the statistics of the four datasets, where the training sets are used for parameter learning, the validation sets for hyperparameter tuning, and the test sets for evaluation. Evaluation protocol We adopt the ranking process proposed in (Bordes et al., 2013) for evaluation. For each triple ( s, r, o ) in the test set, we replace the subject s with every entity e  E , and calculate a score for the corrupted triple ( e, r, o ) . Then we sort these scores in descending order to get the rank of the correct subject s . Since corrupted triples may also be valid, we remove those that already exist in either the training, validation, or test set during ranking, i.e., the filtered setting as called by (Bordes et al., 2013). This whole procedure is repeated while replacing the object o . We aggregate over all test triples, and report the mean reciprocal rank (MRR) and the proportion of correct entities ranked in the top n (Hits@n), with n = 1 , 3 , 10 . 3 https://github.com/TimDettmers/ConvE/ blob/master/WN18RR.tar.gz 4 https://www.microsoft.com/en-us/ download/details.aspx?id=52312 983 Dataset d e c h  w  1  2  3 FB15k 200 100 3  3 0.1 0.4 0.2 WN18 200 100 3  3 0.4 0.3 0.3 FB15k-237 100 100 5  5 0.3 0.2 0.3 WN18RR 200 200 3  3 0.2 0.2 0.5 Table 2: Optimal configurations of ConvR on the four datasets. size to 128, initial learning rate to 0.001, and label smoothing coefficient to 0.1. Other hyper-parameters are selected with grid search on the validation set. Specifically, we tune the entity embedding size d e  { 100 , 200 } , filter number c  { 50 , 100 , 150 , 200 } , and filter size h  w  { 3  3 , 4  4 , 5  5 } . All dropout ratios, i.e.,  1 on reshaped subject representations,  2 on convolutional feature maps, and  3 on projected vectors after the fully-connected layer, are tuned in { 0 . 1 , 0 . 2 , 0 . 3 , 0 . 4 , 0 . 5 } . On each dataset, we choose the optimal configuration with the highest MRR on the validation set within 1000 epochs, and report its performance on the test set. Table 2 lists the optimal configurations of ConvR on the four datasets. Methods that use (relatively) simple operations in vector space to model multi-relational data, including TransE (Bordes et al., 2013), DistMult (Yang et al., 2015) and its re-implementation (Kadlec et al., 2017), HolE (Nickel et al., 2016b), ComplEx (Trouillon et al., 2016), ANALOGY (Liu et al., 2017), TorusE (Ebisu and Ichise, 2017), Gaifman (Niepert, 2016), KBGAN (Cai and Wang, 2017), KBLRN (Garcia-Duran and Niepert, 2018), and Node+LinkFeat (Toutanova and Chen, 2015). Methods that further introduce multi-layer structures and non-linearity, in particular those based on neural networks, including R-GCN (Schlichtkrull et al., 2017a), Neural LP (Yang et al., 2017), ConvE (Dettmers et al., 2018), and ConvKB (Nguyen et al., 2018). Table 3 reports the results on WN18 and FB15k, and Table 4 the results on WN18RR and FB15k-237. On all the four datasets, the results for the baselines are taken directly from previous literature to avoid re-implementation bias. Since not all baselines have their results reported on all the four datasets, we cannot make the two sets of baselines compared in Table 3 and Table 4 exactly the same. From the results, we can see that: (1) On WN18 and FB15k, ConvR performs better than or at least as well as the baselines in almost all the metrics. (2) Compared to ConvE, it offers a 5% increase in MRR, a 7% increase in Hits@1, and a 2% increase in Hits@10 on FB15k. (3) On the more difficult WN18RR and FB15k-237, ConvR consistently outperforms most of the baselines, except for MRR score of ConvKB on FB15k-237. However, on WN18RR ConvR outperforms ConvKB on all known metrices, especially MRR. This discrepancy may be attributed to ConvKB's initialization with TransE on FB15k-237. (4) Compared to ConvE, it offers a 3% increase in MRR, a 14% increase in Hits@1, a 12% increase in Hits@10 on WN18RR, and an 11% increase in MRR, a 9% increase in Hits@1, an 8% increase in Hits@10 on FB15k-237. We further investigate parameter efficiency of ConvR against ConvE on FB15k-237. Specifically, we tune the number of filters c  { 20 , 40 , 60 , 80 , 100 } and the filter size h  w  { 2  2 , 3  3 , 4  4 , 5  5 } , fix the other hyper-parameters to their optimal configurations (see Table 2 for details), and show how the performance of ConvR (on the test set) will change as the number of parameters varies. For comparison, we directly show the performance and parameter efficiency of the optimal ConvE model, as reported in (Dettmers et al., 2018). The results are given in Table 5. 5 From the results, we can see that: (1) The parameter number of ConvR steadily grows as the filter number c and filter size h  w increase, but the performance does not change much. That means, ConvR might achieve relatively good (though not best) performance with a potentially small number 5 Note that some results reported here are even better than those reported in Table 4. This is because in Table 4 we determine optimal configurations according to MRR on the validation set, which may not necessarily lead to best performance on the test set. of parameters. (2) ConvR consistently and substantially outperforms the best performing ConvE with all the configurations listed in Table 5. (3) In particular, even the most efficient configuration (i.e., c = 20 and h  w = 2  2 ) offers a 7% increase in MRR and a 6% increase in Hits@10, with its parameter number only 88% as large as that of ConvE. Link prediction is a crucial task for knowledge bases (KBs). A good variety of statistical relational learning techniques have been proposed for this task (Nickel et al., 2016a), among which vector space embedding models are most particular due to their superior performance and potential scal-ability. Early works of this kind tend to employ simple vector space operations for link prediction. For example, TransE (Bordes et al., 2013) takes relations as translations between subject and object entities. DistMult (Yang et al., 2015) uses multilinear dot product to characterize three-way interactions among subjects, relations, and objects. ComplEx (Trouillon et al., 2016) further generalizes DistMult to complex vector space. Using simple models allows one to easily handle large-scale KBs, but usually at the cost of less model expressiveness (Dettmers et al., 2018). HolE (Nickel et al., 2016b) tries to increase model expressiveness while keeping simplicity. It uses cross-correlation, i.e., the 985 h  w = 2  2 h  w = 3  3 h  w = 4  4 h  w = 5  5 ConvE  1.89M | 0.32 | 0.49   ConvR, c = 20 1.67M | 0.342 | 0.520 1.68M | 0.342 | 0.522 1.72M | 0.342 | 0.522 1.78M | 0.342 | 0.522 ConvR, c = 40 1.87M | 0.345 | 0.526 1.90M | 0.344 | 0.524 1.97M | 0.348 | 0.529 2.09M | 0.347 | 0.526 ConvR, c = 60 2.07M | 0.347 | 0.525 2.11M | 0.348 | 0.530 2.22M | 0.350 | 0.529 2.40M | 0.350 | 0.527 ConvR, c = 80 2.27M | 0.347 | 0.528 2.32M | 0.348 | 0.532 2.47M | 0.350 | 0.532 2.71M | 0.348 | 0.528 ConvR, c = 100 2.47M | 0.348 | 0.531 2.54M | 0.348 | 0.527 2.72M | 0.349 | 0.527 3.02M | 0.350 | 0.528 Table 5: Parameter efficiency on FB15k-237. inverse of circular convolution, to match subject and object entities, which has some similarity to our work. But HolE is not a typical neural network architecture. It does not learn multiple layers of non-linear features, and hence is less expressive than our approach. A more direct way of increasing model expressiveness is to employ deeper, more complicated neural network architectures, e.g., multi-layer per-ceptron (Dong et al., 2014), semantic matching energy networks (Bordes et al., 2014), and neural tensor networks (Socher et al., 2013). This kind of approaches, however, often have more parameters and are prone to overfit (Nickel et al., 2016a). (Dettmers et al., 2018) recently devised ConvE, a multi-layer convolutional network which offers increased model expressiveness while remaining highly parameter efficient. After that, (Nguyen et al., 2018) propose ConvKB that explores the global relationships among same dimensional entries of the entity and relation embeddings. However, neither of them models the interactions between various positions of entities and relations. R-GCN (Schlichtkrull et al., 2017a) is another convolutional network designed for KBs, generalized from GCN (Kipf and Welling, 2016) for uni-relational data. But the convolution of R-GCN is conducted in a message passing manner, quite different from our work. Convolutional neural networks have been successfully applied to a wide variety of domains, ranging from speech or visual recognition (Abdel-Hamid et al., 2014; Krizhevsky et al., 2012) to natural language processing (Collobert et al., 2011). Similar ideas of using adaptive or dynamic convolutional filters have been studied before (Lee et al., 2010; Jia et al., 2016; Kang et al., 2017). But most of such works focus on image or video processing. This work focuses on multi-relational data and devises an adaptive convolution paradigm particularly suitable for this scenario. In this paper, we propose ConvR, an adaptive convolutional network specially designed for learning with multi-relational data. In contrast to previous work which convolves across stacked representations with global filters, ConvR adaptively constructs convolution filters from relation representations, and applies these filters across entity representations to generate convolutional features. This adaptive convolution paradigm enables rich interactions between entity and relation representations at diverse regions, and all convolutional features generated in this way will be able to capture such interactions. Experimental results on multiple benchmark knowledge bases show that ConvR achieves significant and consistent improvements against a variety of baselines. In particular, it is not only more effective but also more efficient than state-of-the-art convolutional models, offering a 7% increase in MRR and a 6% increase in Hits@10, while saving 12% in parameter storage. As future work, we plan to devise convolutional paradigms that can maximize interactions not only between subject entities and relations, but also between object entities and relations. In ConvR, we use 1-to-many scoring to speed up training and evaluation. As a side effect, object representations can only interact with a hidden vector (output of the fully-connected layer) via an inner product, which potentially limits the performance of ConvR. It is worth investigating modeling these interactions while keeping the merit of fast training and evaluation. We would like to thank all the anonymous reviewers for their insightful and valuable suggestions, which help to improve the quality of this paper. This work is supported by the National Natural Science Foundation of China (grant No. 61876223).
method abstain abstain method abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result objective objective objective method result result abstain abstain abstain objective other other other abstain other other other method other other other other abstain abstain abstain abstain result method abstain abstain abstain abstain abstain abstain abstain other abstain method abstain abstain abstain method other method abstain method abstain abstain abstain method abstain method method method method abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain method abstain abstain other abstain abstain abstain method abstain method method method method abstain method other abstain abstain abstain method abstain abstain abstain abstain abstain abstain method abstain other abstain abstain abstain result result abstain abstain abstain abstain abstain abstain result result abstain result abstain abstain abstain abstain abstain other other other other other other other other other abstain other abstain other other other other other other method other other other method objective abstain abstain abstain abstain abstain method abstain abstain other other