Knowledge Hypergraphs: Prediction Beyond Binary Relations
Authors: Bahare Fatemi
Perouz Taslakian
David Vazquez
David Poole
Venue:  (2020)
Keywords: knowledge graphs
knowledge hypergraphs
knowledge hypergraph completion

Abstract: A Knowledge Hypergraph is a knowledge base where relations are defined on two or more entities. In this work, we introduce two embedding-based models that perform link prediction in knowledge hypergraphs:
(1) HSimplE is a shift-based method that is inspired by an existing model operating on knowledge graphs, in which the representation of an entity is a function of its position in the relation, and (2) HypE is a convolution-based method which disentangles the representation of an entity from its position in the relation. We test our models on two new knowledge hypergraph datasets that we obtain from Freebase, and show that both HSimplE and HypE are more effective in predicting links in knowledge hypergraphs than the proposed baselines and existing methods.
Our experiments show that HypE outperforms HSimplE when trained with fewer parameters and when tested on samples that contain at least one entity in a position never encountered during training.

Under review as a conference paper at ICLR 2020
KNOWLEDGE HYPERGRAPHS: PREDICTION BEYOND BINARY RELATIONS
Anonymous authors Paper under double-blind review
ABSTRACT
Knowledge graphs store facts using relations between pairs of entities. In this work, we address the question of link prediction in knowledge hypergraphs where each relation is defined on any number of entities. While there exist techniques (such as reification) that convert the non-binary relations of a knowledge hyper- graph into binary ones, current embedding-baad based methods for knowledge graph completion do not work well out of the box for knowledge graphs obtained through these techniques. Thus we introduce HSimplE and HypE, two embedding- based methods that work directly with knowledge hypergraphs in which the repre- sentation of an entity is a function of its position in the relation. We also develop public benchmarks and baselines for this task and show experimentally that the proposed models are more effective than the baselines. Our experiments show that HypE outperforms HSimplE when trained with fewer parameters and when tested on samples that contain at least one entity in a position never encountered during training.
INTRODUCTION
Knowledge Hypergraphs are graph structured knowledge bases that store facts about the world in the form of relations between two or more entities. They can be seen as one generalization of Knowl- edge Graphs, in which relations are defined on exactly two entities. Since accessing and storing all the facts in the world is difficult, knowledge bases are incomplete; the goal of link prediction (or knowledge completion) in knowledge (hyper)graphs is to predict unknown links or relationships between entities based on the existing ones. In this work we are interested in the problem of link prediction in knowledge hypergraphs. Our motivation for studying link prediction in these more sophisticated knowledge structures is based on the fact that most knowledge in the world has in- herently complex composition, and that not all data be represented as relation between two entities without either losing a portion of the information or creating incorrect data points.
Link prediction in knowledge graphs is problem that is studied extensively, and has applications in several tasks such as searching (Singhall 2012) and automatic question answering (Ferrucci et al.) 2010). In these studies, knowledge graphs defined as directed graphs having nodes entities and labeled edges as relations; edges are directed from the head entity to the tail entity. The com- mon data structure for representing knowledge graphs is set of triples relation (head, tail) that represent information as collection of binary relations. There exist a large number of knowledge graphs that are publicly available, such as NELL (Carlson al., 2010) and FREEBASE (Bollacker) et al. 2008). It is noteworthy to mention that FREEBASE is a complex knowledge base where 61 % of the relations are beyond binary (defined on more than two nodes). However, current methods use simplified version of FREEBASE where the non-binary relations are converted to binary ones (defined on exactly two entities).
Embedding-basee models (Nguyen 2017) have proved to be effective for knowledge graph comple- tion. These approaches learn embeddings for entities and relations. To find out if r(h, t) is a fact (i.e. is true). such models define a function that embeds relation and entities h and and produces the probability that r(h, t) is a fact. While successful, such embedding- based methods make the strong assumption that all relations are binary.
In this work, we introduce two embedding- models that perform link prediction in knowledge hypergraphs. The first is HSimplFE, which is inspired from SimplE: (Kazemi & Poole 2018), origi-

---

Under review as a conference paper at ICLR 2020
Alan Turing
Alan
Turing
King's College
Gallage
Pho
Cambridge
PhD
Turnng
King's College Cambridge
Undergrad
Prineeton
Undergrad
Priseston
Undergrad
Michella Otama
Michelle
Michelle
Obama
(a) DEGREE_ CERERE_FRRM_MMU FROM_UNIVERS, ITY defined on three facts.
(b) Reifying non-binary relations with three additional entities.
(c) Converting non-binary rela- tions into cliques.
Figure I: this example, the three facts in the original graph (a) show that Turing received his PhD from Princeton and his undergraduate degree from King's College Cambridge. Figures (b) and (c) show two methods of converting this ternary relation into three binary ones.
nally designed to perform link prediction in knowledge graphs. For a given entity, HSimplE shifts the entity embedding by value that depends on the position of the entity in the given relation. Our second model HypE, which in addition to learning entity embeddings, learns positional (convo- lutional) filters; these filters are disentangled from entity representations and are used transform the representation of an entity based on its position in a relation. We show that both HSimplE and HypE are fully expressive. To evaluate our models, we introduce two new datasets from subsets of FREEBASE, and develop baselines by extending existing models on knowledge graphs to work with hypergraphs. We evaluate the proposed methods on standard binary and non- con-binary datasets. While both HSimplE and HypE outperform our baselines and the state-of-the-arr, HypE is more effective with fewer parameters. It also produces much better results when predicting relations that contain at least entity in position never encountered during training, demonstrating the clear advantage of disentangling position representation from entity embeddings.
The contributions of this paper are: (I) HypE and HSimplE, two embedding-based methods for knowledge hypergraph completion that outperform the baselines for knowledge hypergraphs, (2) a set of baselines for knowledge hypergraph completion, and (3) two knowledge hypergraphs obtained from subsets of FREEBASE, which can serve as new evaluation benchmarks for knowledge hypergraph completion methods.
MOTIVATION AND RELATED WORK
Knowledge hypergraph completion a relatively under-explored area. We motivate our work by outlining that adjusting current models accommodate hypergraphs does yield satisfactory results. Existing knowledge graph completion methods can be used in the beyond-binary setting by either (1) extending known models work with non-binary relational data (e.g., m-TransH (Wen) et al. 2016)), or by (2) converting non- non-binary relations into binary ones using methods such as reification star-to-clique (Wen al. 2016). and then applying known link prediction methods.
In the first case, the only example that extends known model to work with non-binary relations m-TransH (Wen et al., 2016), which an extension of TransH (Wang et al., 2014). and which we show to be less effective than our models in Section 6 The second case is about restructuring knowledge hypergraph to work with current knowledge graph completion methods. One common approach to reduce a hypergraph into a graph is reification. In order to reify a fact with relation defined on entities, we first create a new entity e (square nodes in Figure [b) and connect e to each of the l entities that are part of the given fact. Another approch is Star-to-clique, which converts fact defined i entities into (t) facts with distinct relations between all pairwise entities in the fact. See Figure Ic
Both conversion approaches have their caveats when current link fink-prediction models applied to the resulting graphs. The example in Figure Ia| shows three facts that pertain to the relation DEGREF_ DEGREF_FROW DOORRE__RRMMUNNVVRRSSS UNIVERSTTY. When reify the hypergraph in this example (Figure Tb).
2

---

Under review as a conference paper at ICLR 2020
add three reified entities. At test time, again need to reify the test samples, which means we need a way to embed newly created entities about which we have almost no information. Applying the star-to-clique method to the hypergraph does not yield better results either: in this case, the resulting graph loses some of the information that the original hypergraph had - in Figure Tcl it is no longer clear which degree was granted by which institution.
Existing methods that relate to our work in this paper can be grouped into three main categories:
Knowledge graph completion. Embedding based models such translational (Bordes et al. 2013 Wang et al. 2014), bilinear (Yang et al., 2015; Trouillon et al. 2016: Kazemi & Poole 2018). and deep modely (Nickel et al.) 2011]] [Socher al.) 2013) have proved effective for knowledge graphs where all relations are binary. We extend some of the models in this category and compare them with the proposed methods.
Knowledge hypergraph completion. Soft-rule models (Richardson & Domingos 2006 De Raedt al., 2007: Kazemi et al. 2014) can easily handle variable arity relations and have the advantage of being interpretable. However, they have limited learning capacity and can only learn a sub- set of patterns (Nickel et al., 2016). Embedding-
methods are more powerful than soft-rule approaches. Guan et al. (2019) proposed an mubbedding-based method based on the star-to-clique approach which its caveats are discussed. m-TransH (Wen et al. (0066) extends TransH (Wang et al.) 2014) to knowledge hypergraph completion. Kazemi & Poole (2018) prove that TransH and conse- quently m- m-TransH are not fully expressive and have restrictions in modeling relations. In contrast, embedding- -rreedddg--beedd proposed models are fully expressive and outperform m-TransH.
Learning on hypergraphs. Hypergraph learning has been employed to model high-order correla- tions among data in many tasks, such as in video object segmentation (Huang et al.] 2009) and in modeling image relationships and image ranking (Huang et al.] 2010). There is also a line of work extending graph neural networks to hypergraph neural networks (Feng al.] 2019) and hypergraph convolution networks (Yadati et al. 2018). On the other hand, these models are designed for undi- rected hypergraphs, with edges that are not labeled (no relations), while knowledge hypergraphs are directed and labeled. As there is no clear or easy way of extending these models to our knowledge hypergraph setting, we do not consider them as baselines for our experiments.
DEFINITION AND NOTATION
A world consists of finite set of entities E, finite set of relations R, and set of tuples defined over & and R. Each tuple in T is of the form r(u1, u2,..., v2) where r E R is relation and each e E & is an entity, for all i = 1, 1,2,.... k. Here arity [r] of relation is the number of arguments that the relation takes and is fixed for each relation. A world specifies what is true: all the tuples in 7 are true, and the tuples that are not in 7 are false. knowledge hypergraph consists of subset of the tuples r' C r. Link prediction in knowledge hypergraphs is the problem of predicting the missing tuples in r', that is, finding the tuples T \
An embedding is function that converts an entity or a relation into vector (or sometimes a higher order tensor) over a field (typically the real numbers). We use bold lower-case for vectors, that is, E & is an embedding of entity and E R is an embedding of relation
Let V1, ..,..., Vk a set of vectors. The variadic function concat(V1,.... vk) outputs the con- catenation of its input vectors. The ID convolution operator takes input vector and convolution weight filter w, and outputs the convolution of v with the filters w. We define the variadic function @0) to be the sum of the element-wise product of its input vectors, namely
O(V,, V2..... .2.....VV. vk) Ei= v, (9) (022() (f)... Vv.V (1) where each vector v; has the same length, and ()(0) is the i-th element of vector Vj.
(t)
For the task of knowledge graph completion, embedding-based model defines function ø that takes a tuple x as input, and generates a prediction, e.g. a probability (or score) of the tuple being true. A model is fully expressive if given any complete world (full assignment of truth values to all tuples), there exists an assignment of values to the embeddings of the entities and relations that accurately separates the tuples that are true in the world from those that are false.
3

---

Under review as a conference paper at ICLR 2020
shiftie,, B))
entty embeddling (9)
f(e.
(( 1)
O
O
P
O
P
outpui
convolutin
concal & projection
O
output arll
shifl ())
Key,
O
000 convoktion theer (mr)
00oo convolied embedding
oooooo relation embeeding
reletion embedding
(a) Function @ for HSimplE.
(b) Function f(e, used HypE.
(c) Function & for HypE.
Figure 2: Visualization of HypE and HSimplE architectures. (a) function ø for HSimplE transforms entity embeddings by shifting them based on their position and combining them with the relation embedding. (b) function f(e, i) for HypE takes an entity embedding and the position the entity appears in the given tuple, and returns a vector. (c) function & takes as input a tuple and outputs the score of HypE for the tuple.
4 KNOWLEDGE HYPERGRAPH EMBEDDING: PROPOSED METHODS
The idea at the core of our methods is that the way an entity representation used to make pre- dictions is affected by the role that the entity plays in given relation. In the example in Figure Turing plays the role of a student at a university, but he may have a different role (e.g. 'professor") in another relation. This means that the way we use Turing's embedding may need to be different for computing predictions for each of these roles.
The prediction for entity should depend on the position it appears. If the prediction does not depend on the position. then the relation has to be symmetric. If it does and positions are learned independently, information about one position will not interact with that of others. It should be noted that in several embedding-based methods for knowledge graph completion, such as canoni- cal polyadic (Hitchcock) [927 Lacroix et al., 2018). ComplEx (Trouillon al.) 2016), and Sim- plE Kazemi & Poole 2018), the prediction depends on the position of an entity.
In what follows, we propose two embedding- methods for link prediction in knowledge hy- pergraphs. The first model is inspired by SimplE and has its roots in link prediction in knowledge graphs; the second model takes fresh look at knowledge completion as a multi-arity problem, without first setting it up within the frame of binary relation prediction.
HSimplE is an embedding- based method for link prediction in knowledge hypergraphs that is inspired by SimplE (Kazemi & Poole, 2018). SimplE learns two embedding vectors e and e(?) for an entity (one for each possible position of the entity), and two embedding vectors r(1) and (2) for relation r (with one relation embedding as the inverse of the other). It then computes the score of a triple as ((r((1, e2)) @r(()) ef
HSimplE:
(1) e² 2 + ( .2 (1) ((2)).
In HSimplE, we adopt the idea of having different representations for an entity based on its position in a relation, and updating all these representations from a single training tuple. We this by representing each entity e as a single vector e (instead of multiple vectors as in SimplE), and each relation r as single vector r. Conceptually, each can be seen as the concatenation of the different representations of based on every possible position. For example, in knowledge hypergraph where the relation with maximum arity is 6, an entity can appear in 8 different positions; hence will be the concatenation of 5 vectors, one for each possible position. HSimplE scores tuple using the following function:
d(r(e,, Cy...,
or, e shift len((e)/o))... shi, len(ez) (5 1)/8).
Here, shift(a, x) shifts vector a to the left by x steps, len(c) returns length of vector c, and 5 max)) We observe that for knowledge graphs (6 = 2), SimplE is a special instance of HSimplE, with = co(cat(e(l), (())) and (r(cat(((1), (())) The architecture of HSimplE summarized in Figure 2a
HypE: HypE learns a single representation for each entity, a single representation for each rela- tion, and positional convolutional weight filters for each possible position. At inference time, the appropriate positional filters are first used to transform the embedding of each entity in the given fact; these transformed entity embeddings
then combined with the embedding of the relation to produce a score, e.g., a probability value that the input tuple is true. The architecture of HypE is summarized in Figures 2b and 2c
4

---

Under review as a conference paper at ICLR 2020
Let n, I, d, and denote the number of filters per position, the filter-length, the embedding dimension and the stride of the convolution, respectively. Let wi E R" x I be the convolutional filters associated with
entity at position i, and let wiy E R' be the jth row of w:- We denote by P R x Re the projection matrix, where g = [d (odd-)) 1)/s] + is the feature map size. For given tuple, define f(c i) concat(c * Wi1,.... C * Win) to be a function that returns a vector of size d based on the entity embedding e and it's position in the tuple. Thus, each entity embedding appearing at position in a given tuple is convolved with the set of position-specific filters wi to give feature maps of size q. All ni feature maps corresponding an entity concatenated to a vector of size nę and projected to the embedding space by multiplying it by P. The projected vectors of entities and the embedding of the relation are combined by an inner- anerrprrductt define
(r((en.... (x, f(e,, 1), ((jr) (r))
The advantage of learning positional filters independent of entities is two-folds: On one hand, learn- ing a single vector per entity keeps entity representations simple and disentangled from its position in given fact. On the other hand, unlike HSimplE, HypE learns positional filters from all entities that appear in the given position; Overall, this separation of representations for entities, relations, and position facilitates the representation of knowledge bases having facts of arbitrary number of entities. It also gives HypE an advantage in the case when we test a trained HypE model on a tu- ple that contains entity in position never seen before at train time. We discuss this further in Section 6.1
Both HSimplE and HypE are fully expressive an important property that has been the focus of several studies (Fatemi et al. 2019 Trouillon et al.) 2017: Xu et al. (018). A model that is not fully expressive can easily underfit the training data and embed assumptions that may not be reflected in reality. We defer the proofs of expressivity to Appendix A
4.1 OBJECTIVE FUNCTION AND TRAINING
To learn either of a HSimplE or HypE model, we use stochastic gradient descent with mini-batches. In each learning iteration, we iteratively take in a batch of positive tuples from the knowledge hy- pergraph. As we only have positive instances available, we need also to train our model on negative instances. For this purpose. for each positive instance, we produce set of negative instances. For negative sample generation, we follow the contrastive approach of Bordes et al. (2013) for knowl- edge graphs and extend it to knowledge hypergraphs: for each tuple, we produce a set of negative samples of size N|rl by replacing each of the entities with N random entities in the tuple, one at time. Here, N is the ratio of negative samples in our training set, and is a hyperparameter.
Given knowledge hypergraph defined on r', we let Fergin Thegy and T'attd denote the train, test, U and validation sets, respectively, so that 7' = Tirain U UTiee U Taalid For any tuple x in T', we let Tney(2) (z) be function that generates set of negative samples through the process described above. Let r represent relation embeddings, e represent entity embeddings. and let á be the function given by equation [ that maps tuple score based on and e. We define the following cross entropy loss, which is a combination of softmax and negative log likelihood loss, and has been shown to be effective for link prediction (Kadlec et al. 2017);
ealaa'
((r,e)= = Σ -log
ed(o) +
e((x)
2'Er/ruén
IETnco (x')
EXPERIMENTAL SETUP
5.1 DATASETS
We conduct experiments a total of 5 different datasets. For the experiments datasets with binary relations, we use two standard benchmarks for knowledge graph completion: WN18 (Bordes et al. 2014) and FB15k (Bordes al. 2013). WN18 is subset of WORDNET (Miller 1995) and FB15k is a subset of FREEBASE (Bollacker et al. 2008). We use the train, validation, and test split proposed by Bordes et al. 2013). The experiments on knowledge hypergraph completion
5

---

Under review as a conference paper at ICLR 2020
conducted on three datasets. The first is JF17K proposed by Wen et al. (2016); validation set is proposed for JF17K, we randomly select 20% of the train set as validation. We also create two datasets FB-AUTO and M-FB15K from FREEBASE. See Appendix A for more dataset details.
5.2 BASELINES
To compare our results to that of existing work, we first design few simple baselines that extend current models to work with knowledge hypergraphs. We only consider models that admit simple extension to beyond-binary relations for the link prediction task. The baselines for this task are grouped into the following categories: (1) methods that work with binary relations and that are easily extendable to higher-arity: r- r-SimplE, m-DistMult, and m-CP; (2) existing methods that can handle higher-arity relations: m- H-TransH. Below we give some details about methods in category (I).
r-SimplE: To test performance of model trained on reified data, we converted higher-arity rela- tions in the train set to binary relations through reification. We then use the SimplE model (that we this reified data. In this setting, test time higher-arity relations
call r-SimplE) to train and are first reified to a set of binary relations; this process creates new auxiliary entities for which the model has learned embeddings. To embed the auxiliary entities for the prediction step, the observation we have about them at test time. For example, a higher-arity relation r(e1, E2, e3) is reified test time by being replaced by three facts: ri (id123, e1), r2 72(id223 12,, e2), and ra (id123,, e3). When predicting the tail entity of rı (id123, ?), we use the other two reified facts to learn an embed- ding for entity id123. Because id123 is added only to help represent the higher-arity relations as set of binary relations, we only do tail prediction for reified relations.
m-DistMult: DistMult Yang et al. 2015) defines a score function @(((e, ez) = (r, o₁ oj). To accommodate non non-binary relations, we redefine this function as (fr(ei..... C2)) Cr.............................. Ci......... .g))
m-CP: Canonical Polyadic (CP) decomposition (Hitchoock) 1927) embeds each entity as two vectors e(1) and e(2), and each relation r single vector r. CP defines the score func- tion @(r(e,,,,) = O(r, of ((2)). We extend CP to a variant (m-CP) that accommodates non- binary relations, and which embeds each entity 8 diffferent vectors e(1), .... e()), where maxfeR((r)), m-CP computes the score of tuple as p(r(es....,.,) = O(r, (1) 9
(1r)))
5.3 EVALUATION METRICS
Given knowledge hypergraph on r', we evaluate various completion methods using train and test set Trrain and Tiest- We use two evaluation metrics: @it@t and Mean Reciprocal Rank (MRR). Both these measures rely on the ranking of tuple x Test within set of corrupted tuples. For each tuple r(e1, )x) ) Thest and each entity position in the tuple, we generate | corrupted tuples by replacing the entity with each of the entities in & \ {e:]. For example, by corrupting entity e;, ... Ex) where of E (ez). Let the set of corrupted (e1,,..,,ee) ex), be denoted by 0,(r(e1,..... ex)). Let (ran, of r(ei...., .x) within 0 (r(e)...... ((e())....,.))) .x)) based on the score σ(z) for each æ E (r(e,,...., Ex)). In ideal knowledge hypergraph completion method, the rank rank, (r(ei...., is 1 among where
we would obtain a new tuple r(ei..... ee...., tuples, plus r(e1,
ex)) be the ranking
all corrupted tuples. We compute the MRR as
Σ rank,r(e........... K = EEree,..ew)err... |rl is the number of prediction tasks. Hit@t measures the proportion of tuples in Téeat that rank among top / in their corresponding corrupted sets. We follow Bordes et al. 2013) and remove all corrupted tuples that are in r' from our computation of MRR and Hit@t.
EXPERIMENTS
This section summarizes our experiments with HSimplE and HypE. We evaluate both models on knowledge hypergraphs, as well as on knowledge graphs, and show results on training with different embedding dimensions. Moreover, to test their representation power further, evaluate HSimplE and HypE on a more challenging dataset that we describe below. We also conduct ablation studies based on performance breakdown across different arities.

---

Under review as a conference paper at ICLR 2020
Table I: Knowledge hypergraph completion results on JFI7K, FB-AUTO and M-FB15K for base- lines and the proposed method. The prefixes 'r' and 'm' in the model names stand for reification and multi-ard arity respectively. Both our methods outperform the baselines on all datasets.
JF17K
FB-AUTO
M-FBI5K
Model
MRR
Hic 1
Hire:3
Hit@f 10
MRR
Hit
Hire03
Hit6# 10
MRR
Hite:1
Hit@3
Hit 10
r-SimplE
0.102
0.069
0.112
0.168
0.106
0.082
0.115
0.147
0.051
0.042
0.054
0.070
m- DistMult
0.460
0.635
0.784
0.745
0.815
0.705
0.633
0.740
0.844
m-CP
0.392
0.303
0.441
0.560
0.752
0.704
0.785
0.837
0,680
0.605
0.715
0.828
m- TransH Wenn et ul.. 2016
0.446
0.357
0.495
0.614
0.728
0.727
0.728
0.728
0.623
0,531
0.669
0.809
HSimplE (Ours)
0.472
0.375
0.523
0.649
0.798
0.766
0.821
0.855
0.730
0.664
0.763
0,859
HypE (Ours)
0.492
0.409
0.533
0.650
0.804
0.774
0.823
0.856
0.777
0.725
0.800
0.881
0.49
0.3
0.47
0.25
0.45
0.2
50.43
0.15
0.41
0.1
0.39
HSimplE
0.05
HypE
0.35
MRR
hit@1
hit
hit@10
50
Embedding dimension
100 150
200
m_
HSimplE
HyPE
(a)
(b)
Figure 3: The above experiments show that HypE outperforms HSimplE when trained with fewer parameters, and when tested on samples that contain at least one entity in a position never encoun- tered during training. (a) MRR of HypE and HSimplE for different embedding dimensions. (b) Results of m-CP, HSimplE, and HypE on the missing positions test set.
6.1 KNOWLEDGE HYPERGRAPII COMPLETION RESULTS
The results of our experiments, summarized in Table I show that both HSimplE and HypE out- perform the proposed baselines across the three datasets JF17K, FB-AUTO, and M-FB 15K. They further demonstrate that reification for the r-SimplE model does not work well; this is because the reification process introduces auxiliary entities for which the model does not learn appropriate embeddings because these auxiliary entities appear in very few facts. Comparing the results of r- SimplE against HSimplE, we can also see that extending a model to work with hypergraphs works better than reification when high-arity relations are present.
The ability of knowledge sharing through the learned position-dependen convolution filters suggests that HypE would need a lower number of parameters than HSimplE in order to obtain good results. To test this, we train both models with embedding dimension 50, 100, and 200. Figure Bal shows the MRR evaluation
the test for each model with different embedding sizes. Based the MRR result, we can see that HypE outperforms HSimplE by 24% for embedding dimension 50, implying that HypE works better under a constrained budget. This difference becomes negligible for embedding dimensions of 200.
Disentangling the representations of entity embeddings and positional filters enables HypE to better learn the role of position within a relation, because the learning process considers the behaviour of all entities that appear the case when some entities never appear in certain positions in the train set, but you still want to be able to reason about them no matter what position they appear at test time. In order to test the effectiveness of our models in this more challenging scenario, we created missing positions test set by selecting the tuples from our original test set that contain at least one entity in position never appears in in the train dataset. The results on these experiments (Figure 3b) show that (1) both HSimplE and HypE outperform m-CP (which learns different embeddings for each pair), and more importantly, (2) HypE significantly outperforms HSimplE for this challenging test set, leading us to believe that disentangling entity and position representations may be a better strat- egy for this scenario.
given position time of training. This becomes specially important in

---

Under review as a conference paper at ICLR 2020
Table 2: Knowledge graph completion results on WN18 and FBI5K for baselines and HypE. Note that we do not include results SimplE. The table shows that HypE performs similar the best baselines for knowledge graphs with binary relations.
for HSimplE because for knowledge graphs, HSimplE is equivalent
WNI8
FB15k
Model
MRR
Hit@l
Hit@3
Hit@ 10
MRR
Hit@@
Hit@3
Hit@ 10
CP (Hitchhoock
[927]
0.074
0.049
0.080
0.125
0.326
0.219
0.376
0.532
TransHl ( (Wang cl al.
2014)
0.867
0.585
m-TransIT Wen el al.
2016
0.671
0.495
0.839
0.923
0.351
0.228
0.427
0.559
DistMult Yang
2015)
0.822
0.728
0.914
0.936
0.654
0.546
0.733
0.824
SimplE Kazemi Poole
2018
0.942
0.939
0.944
0.947
0.727
0.660
0.773
0.838
HypE (Ours)
0.934
0.927
0.940
0.944
0.725
0.648
0.777
0.856
Table 3: Breakdown performance of @it 10 across relations with different arities JF17K.
Arity
Model
2
All
r-SimplE
0.478
0.025
0.015
0.022
0.000
0.168
m- DistMult
0.359
0.591
0.745
0.869
0.359
0.635
m-CP
0.305
0.517
0.679
0.870
0.875
0.560
m-TransH (Wen al. 2016
0.316
0.563
0.762
0.925
0.979
0.614
HSimplE (Ours)
0.376
0.625
0.742
0.810
0.010
0.649
'HypE (Ours)
0.338
0.626
0.776
0.936
0.948
0.650
6.2 KNOWLEDGE GRAPH COMPLETION RESULTS
To confirm that HSimplE and HypE still work well on the more common knowledge graphs, we evaluate them on WN18 and FB 1515.. Table shows link prediction results WN18 and FB 15K.. Baseline results are taken from the original papers except that of m-TransH, which we implement ourselves. Instead of tuning the parameters of HypE to get potentially better results, instead follow the Kazemi & Poole (2018) setup with the same grid search approach by setting n = 2, I = 2, and 2. This results in all models in Table 2 having the same number of parameters, and thus makes them directly comparable to each other. Note that since HSimplE equivalent to SimplE for binary relations (as shown in Section
have excluded HSimplE from the table. The results show that on WN18 and FB 15K, HypE outperforms all baselines except SimplE, while its performance remains comparable that of SimplE.
6.3 ABLATION STUDY ON DIFFERENT ARITIES
We break down the performance of HSimplE. HypE and each of the baselines across relations with different arities. [able(]shows the Hit@ 10 results of the models for each arity JF17K. We observe that the proposed models outperform the state-of-the-as and the baselines in all arities except arity 6, which has a total of only 37 tuples in the train and test sets. Table also shows that the performance of all models generally improve arity increases. We note that the train set has much fewer relation types that are defined on a high number of entities - JF contains only two relation types that admit six entities. This leads us hypothesize that the position and/or entity representations learned for higher arities are optimized for these few relation types.
CONCLUSIONS
Knowledge hypergraph completion is an important problem that has received little attention. this work, having introduced two new knowledge hypergraph dataset, baselines, and two new methods for link prediction in knowledge hypergraphs, we hope to kindle interest in the problem. Unlike knowledge graphs, hypergraphs have lenging questions such as: how do we effectively predict the missing entities in a given (partial) tuple? MRR good evaluation metric for hypergraphs?
complex structure that opens the door to more chal-
8

---

Under review as a conference paper at ICLR 2020
REFERENCES
Kurt Bollacker, Colin Evans, Praveen Paritosh, Tim Sturge, and Jamie Taylor. Freebase: a collabo- ratively created graph database for structuring human knowledge. ACM ICMD, 2008.
Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. In NIPS, 2013.
Antoine Bordes, Xavier Glorot, Jason Weston, and Yoshua Bengio. A semantic matching energy function for learning with multi-relational data. Machine Learning, 94(2):233-25 259, 2014.
Andrew Carlson, Justin Betteridge, Bryan Kisiel, Burr Settles, Estevam R Hruschka Jr, and Tom M Mitchell. Toward an architecture for never-ending language learning. In AAAI, 2010.
Luc De Raedt, Angelika Kimmig, and Hannu Toivonen. Problog: probabilistic prolog and its application in link discovery. IJCAI, 2007.
John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. JMLR, 221111)2121 2011.
Bahare Fatemi, Siamak Ravanbakhsh, and David Poole. Improved knowledge graph embedding using background taxonomic information. In AAAI, 2019.
Yifan Feng, Haoxuan You, Zizhao Zhang, Rongrong Ji, and Yue Gao. Hypergraph neural networks. In AAAI, 2019.
David Ferrucci, Eric Brown, Jennifer Chu-Carroll, James Fan, David Gondek, Aditya A Kalyanpur, Adam Lally, J William Murdock, Eric Nyberg, John Prager, et al. Building watson: An overview of the deepqa project. Al magazine, (3):599777, 2010.
Saiping Guan, Xiaolong Jin, Yuanzhuo Wang, and Xueqi Cheng. Link prediction on n-ary relational data. In The World Wide Web Conference, pp. 583-593. ACM, 2019.
Frank I. Hitchcock. The expression of tensor polyadic as sum of products. Journal of Mathematics and Physics, 611-4):164-189, 1927.
Yuchi Huang, Qingshan Liu, and Dimitris Metaxas. Video object segmentation by hypergraph cut. In CVPR, 2009.
Yuchi Huang. Qingshan Liu, Shaoting Zhang, and Dimitris Metaxas. Image retrieval via proba- bilistic hypergraph ranking. In CVPR, 2010.
Rudolf Kadlec, Ondrej Bajgar, and Jan Kleindienst. Knowledge base completion: Baselines strike back. In RepLANLP, 2017.
Seyed Mehran Kazemi and David Poole. Simple embedding for link prediction in knowledge graphs. In NIPS, 2018.
Scyed Mchran Kazemi, David Buchman, Kristian Kersting, Sriraam Natarajan, and David Poole. Relational logistic regression. In KR, 2014.
Timothée Lacroix, Nicolas Usunier, and Guillaume Obozinski. Canonical tensor decomposition for knowledge base completion. ICML, 2018
George A Miller. Wordnet: a lexical database for english. Communications of the ACM, 38(11): 39-41, 1995.
Dat Quoe Nguyen. An overview of embedding models of entities and relationships for knowledge base completion. arXiv preprint arXiv: arXiv: 1703.0809, 2017.
Maximilian Nickel, Volker Tresp, and Hans-Peter Kriegel. A three-way model for collective learning on multi-relational data. In ICML, 101
Maximilian Nickel, Kevin Murphy, Volker Tresp, and Evgeniy Gabrilovich. A review of relational machine learning for knowledge graphs. Proceedings of the IEEE, 104(1):11-33, 2016.

---

Under review as a conference paper at ICLR 2020
Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary VeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch, 2017.
Matthew Richardson and Pedro Domingos. Markov logic networks. Machine learning, 62(1-2): 107-136, 2006.
Sameer Singh, Amarnag Subramanya, Fernando Percira, and Andrew McCallum. Wikilinks: A large-scale cross-document coreference corpus labeled via links wikipedia. University of Mas- sachusetts, Amherst, Tech. Rep. UM-CS-2012, 15, 2012.
Amit Singhal. Introducing the knowledge graph: things, not strings, 2012.
Richard Socher, Danqi Chen, Christopher D Manning, and Andrew Ng. Reasoning with neural tensor networks for knowledge base completion. In NIPS, 2013.
Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: simple way to prevent neural networks from overlitting. JMLR, 15(1):1929-1958, 2014.
Théo Trouillon, Johannes Welbl, Sebastian Riedel, Éric Gaussier, and Guillaume Bouchard. Com- plex embeddings for simple link prediction. ICML, 2016.
Théo Trouillon, Christopher R Dance, Éric Gaussier, Johannes Welbl, Sebastian Riedel, and Guil- laume Bouchard. Knowledge graph completion via complex tensor factorization. JMIRR, 18(1): 4735-4772, 2017.
Zhen Wang, Jianwen Zhang, Jianlin Feng, and Zheng Chen. Knowledge graph embedding by trans- lating on hyperplanes. AAAI, 2014.
Jianfeng Wen, Jianxin Li, Yongyi Mao, Shini Chen, and Richong Zhang. On the representation and embedding of knowledge bases beyond binary relations. In IJCAI, 2016.
Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv: 1010: 00.266 2018.
Nagamand Yadati, Madhav Nimishakavi, Prateek Yadav, Anand Louis, and Partha Talukdar. Hy- pergen: Hypergraph convolutional networks for semi emiisuupreised classification. arXiv preprint arXiv: 0809.80095550 2018
Bishan Yang. Wen tau Yih, Xiaodong He, Jianfeng Gao, and Deng. Embedding entities and relations for learning and inference in knowledge bases. CoRR, abs/ abs//441..657,, 2015.
A APPENDIX
A.1 DATASETS
Table 4 summarizes the statistics of the datasets. Note first that FREEBASE is a reified dataset; that is, it is created from knowledge base having facts with relations defined on more entities. To obtain knowledge hypergraph H from FREEBASE, we perform an inverse reification process by following the steps below.
1. From FREEBASE, remove the facts that have relations defined single entity, that contain numbers or enumeration as entities.
2. Convert the triples in FREEBASE that share the same entity into facts in H. For example, the triples ro Po(id123, e;), ri (id123, e,), and (id1233, ek). ). which were originally created by the addition the (unique) reified entity id123, now represent fact r(e,, ey, ex) in H.
3. Create the FB FB-AUTO dataset by selecting the facts from H whose subject is 'automotive'.
4. Create the M-FB 15K dataset by following strategy similar to that proposed by Bor- des et al. (2013): ) select the facts in H that pertain to entities present in the Wikilinks database (Singh al. 2012)
10

---

Under review as a conference paper at ICLR 2020
5. Split the facts in each of FB-AUTO and M-FB15K randomly into train, test, and validation sets.
Table 4: Dataset Statistics.
Datasct
|E]
[
#train
#valid
#test
#arity=2
#arity=3 #arity=4 #arity=S
#arity=6
WN18
40,943
141,442
5,000
5,000
151,442
0
FB15k
14,951
1,345
483,142
50,000
59,071
592,213
0
0
0
JF17K
29.177
327
77,733
24,915
56,322
34,550
9,509
2,230
37
FB-AUTO
3,410
8
6,778
2,255
2.180
3,786
0
215
7,212
0
M-FB 15K
10,314
71
415,375
39,348
38,797
82,247
400,027
26
11,220
A.2
IMPLEMENTATION DETAILS
We implement HSimplE, HypE. and the baselines in Py'Torch (Paszke et al. 2017). We use Ada- grad (Duchi al.) 2011) as the optimizer and dropout (Srivastava al.] 2014) regularize our model and baselines. We tune our hyperparameters over the validation set, and fix the maximum number of epochs to 500 and batch size 128. We set the embedding size and negative ratio to 200 and 10 respectively. We compute the MRR of models over the validation set every 50 epochs and select the epoch that results the best. The learning rate and dropout rate of all models are tuned. HypE also has n, I and 8 as hyperparameters. We select the hyperparameters of HypE, HSimplE and baselines via the same grid search based on MRR on the validation. The code of the proposed model, the basclines, and the datasets are available in this link
A.3 FULL EXPRESSIVITY
Theorem (Expressivity of HypE) Lel T be a set of true tuples defined over entities and rela- be the maximum arity of the relations in R. There exists HypE model with embedding vectors of size at most max(ōlT). 0]) 8) that assigns 1 to the tuples in T and 0 to others.
tions R. and let â max ((rl) )
Proof: To prove the theorem, we show an assignment of embedding values for each of the entities and relations in r such that the scoring function of HypE is as follows:
{0 if T
<xx)= [1 otherwise
We begin the proof by first describing the embeddings of each of the entities and relations in HypE; we then proceed show that with such embedding, HypE can represent any world accurately.
Let us first assume that |r| > 0 and let fp be the pth fact in r. We let each entity E E be represented with vector of length 8 /| in which the pth block of 8-bits is the one-hot representation of e in fact fo: if e appears in fact fo at position i, then the ith bit of the pth block is set to 1, and to 0 otherwise. Each relation r E then represented as a vector of length whose pth bit equal if fact fp is defined on relation and 0 otherwise.
HypE defines different convolutional weight filters for each entity position within tuple. As we have at most 5 possible positions, we define each convolutional filter w; as a vector of length ó where When the scoring function e is
the ith bit set to and all others to O, for each i = 1,2, 1,2, Ó. applied to some tuple for each entity position i in convolution filter w; is applied to the entity at position in the tuple as a first step; the @() function is then applied to the resulting vector and the relation embedding to obtain score.
Given any tuple x, we want to show that ((x) = 1 if x E r and otherwise.
First assume that æ fp is the pth fact in that is defined on relation r and entities where is the entity at position i. Convolving each e; with Wj results in a vector of length |r| where the pth bit is equal to (since both W; and the pth block of e; have a at the ith position) (See Figure 4 Then, as a first step, function @() computes the element- wise multiplication between the embedding of relation (that has 1 at position p) and all of the convolved entity vectors (each having at position

---

Under review as a conference paper at ICLR 2020
f r(e,
q.
d ==
el
0
e, *
Figure 4: An example of embedding where |r|
5, ö = 4 and fa is the third fact in
p): this results vector of length |r] where the pth bit set to 1 and all other bits set to 0. Finally, (()) sums the outcome of the resulting products to give score of 1.
To show that ((x) = 0 when x т, we prove the contrapositive, namely that if Φ(x) = 1, then x must be fact т. We proceed by contradiction. Assume that there exists a tuple x & T such that 6(x) = 1. This means that at the time of computing the element-wise product in the @() function, there was a position j at which all input vectors to @() had value of 1. This can happen only when (1) applying the convolution filter W to each of the entities in r produces a vector having at position j, and (2) the embedding of relation x has position j.
The first case can happen only if all entities of appear in the jth fact fj т; the second case happens only relation r E appears fj. But if all entities as well its relation appear in fact fj, then x E contradicting our assumption. Therefore, if ((x) = 1, then æ must be fact in T.
To complete the proof, we consider the case when |r| | 0. In this case, since there are no facts, all entities and relations are represented by zero-vectors of length 6. Then, for any tuple æ, d(x) 0. This completes the proof.
Theorem (Expressivity of HSimplE) Let T be a set of true tuples defined over entities & and relations and let ò max ([r) be the maximum arity of the relations in R. There exists HSimplE model with embedding vectors of size at most max(ō)r], 8) that assigns 1 to the tuples in T and others.
The proof of Theorem is similar to the proof Theorem | except that instead of applying con- volution filters, shifting applied entity embeddings. After applying shifting, the same proof by contradiction holds for HSimplE.
12


Reviews:
[{"review_id": "HJg2O8GM5S", "reviewer": "AnonReviewer3", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "This paper proposes two new embedding strategies for the task of knowledge graph completion, with special attention on generalizations that support hypergraphs.  The first method, HSimplE, learns an embedding for entities that directly contains multiple positional representations; these are shifted depending on the relation they're used in.  The second method, HypE, disentangles entity embeddings and positional convolutional filters, allowing stronger positional generalization.  Experiments on standard benchmarks demonstrate that the approaches work well.\n\nI think this paper should be accepted.  While the ideas are so simple that they border on being trivial generalizations of previous work, the paper is well written, and the results seem solid.  I think this is work that needs to be done, so I favor accepting it.\n\nOn the positive side:\n\n* The ideas underlying HSimplE and HypE are natural and clear - we basically want to learn better embeddings for hypergraphs, and there are a couple of obvious ways to do that.  Both of these seem clear.\n\n* The experiments are nicely done, and show a consistent (if unsurprising) benefit to the approach.\n\n* The paper is well written and well situated in the literature.\n\n* I expect that other researchers in this area will be able to reproduce and build upon this work without any difficulty.\n\nOn the negative side:\n\n* The ideas are obvious; the results are unsurprising; the paper lacks \"deep insight\".  It is a contribution in the sense that someone needed to do this work, and I'm glad that it's been done (and done well), but it's not earth-shattering.\n\n* It doesn't seem like this is quite the best version of this idea.  I really like the idea of HypE, but it seems strange that entity embeddings are modulated based on position *only*, without regard to relation -- that is, it seems like a given entity in position #2 might need to be represented in very different ways depending on which relation is being used.", "extra_scores": {"experience_assessment": "I have read many papers in this area.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper thoroughly.", "review_assessment:_checking_correctness_of_experiments": "I carefully checked the experiments.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I carefully checked the derivations and theory."}, "extra_text": {}}, {"review_id": "BkgiVLhJcH", "reviewer": "AnonReviewer1", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "Contributions:\n1. This paper extends SimplE, a previous embedding model, from modeling binary knowledge graphs to knowledge hypergraphs, where n-ary relations may show up.\n2. The paper designs two different architectures, HypE and HSimplE, to achieve knowledge hypergraph embedding.\n3. Empirical results comparing with existing methods are proposed.\n\nThe major contribution of this paper is to propose two new architectures for hypergraph embedding. However, I still have some concerns after reading this paper.\n\n1. The paper proposes to use 1d convolutions to separate entity positions and entity embeddings (HypE) and claim this strategy is better than just rotating the entity embeddings (HsimplE) because one can introduce additional parameters through the convolution filters. I'm expecting to see more evidence justifying this strategy. For example, in Table 2, SimplE is better than HypE in most cases. So probably HypE is not the most efficient way to use parameters. Besides, I'm curious about how performance will be when you use different n,l,d,s, since some of them are set to be very small according to 6.2.\n\n2. The second thing that I feel confused about is the fair comparison with other methods to handle hypergraphs. For example, t-SimplE performs badly on all metrics, including Hit@t and MRR in Table 1. This could result from a sub-optimal adaptation/reification of SimplE to hypergraphs. However, in Table 3 it does much better than the rest methods for binary relations (0.478 vs others). This makes me confused and I don't understand why that could happen. Moreover, have you tried another adaptation method? For example, by converting non-binary relations into cliques?\n\nI think the paper makes some contribution to the existing literature, but it should at least clarify its contribution with more evidence and better comparison criterions.", "extra_scores": {"experience_assessment": "I have read many papers in this area.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper at least twice and used my best judgement in assessing the paper.", "review_assessment:_checking_correctness_of_experiments": "I carefully checked the experiments.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I carefully checked the derivations and theory."}, "extra_text": {}}, {"review_id": "BJl2Bv6XqB", "reviewer": "AnonReviewer2", "summary": "", "questions": "", "limitations": "", "rating": 1, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "The paper proposes models for link prediction task in a generalized knowledge graph setting that can contain n-ary\nrelationships. The paper explains the problem of using only binary relationships to model real-world scenarios, typical workaround for converting n-ary relationships to binary relationships and their\nproblems. The work then extends one model for link prediction in a binary setting to n-ary setting. Work also proposes a novel model using positional convolutional filters for entity embeddings to model n-ary relationships and use that for link prediction. Work also establishes baselines for the new problem and publishes two\ndatasets (subsets of FREEBASE) for the same. Experimental results show the proposed models, outperform the baselines by good margin (with some exceptions). \n\nThis is a very obvious generalization from binary to n-array relations, but the work is very incremental and does not provide any good motivations. It is well known that hypergraphs can be approximated with graphs using clique and star expansions but I do not see any discussion regarding this. Frankly, I do not see any good motivation to consider this generalization. \n\n Comments: \n 1. Table 3: for arity 2, r-simply is performing better, but HSimplIE is marked best. Ideally, for arity 2 both should\nhave the same result right?\n 2. For arity 6, there is a sudden drop in performance for both the proposed models. But the baseline model mtransH holds very tight. Any reason or explanation for this massive drop and large gap in performance.\n 3. Have you conducted experiments for higher arity? On the continuation of the above point, the performance drop consistently for higher arity than 5? '\n ", "extra_scores": {"experience_assessment": "I have published one or two papers in this area.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper thoroughly.", "review_assessment:_checking_correctness_of_experiments": "I assessed the sensibility of the experiments.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I carefully checked the derivations and theory."}, "extra_text": {}}]

Author rebuttal:

Meta-review: The paper proposes two methods for link prediction in knowledge hypergraphs. The first method concatenates the embedding of all entities and relations in a hyperedge. The second method combines an entity embedding, a relation embedding, and a weighted convolution of positions. The authors demonstrate on two datasets (derived by the authors from Freebase), that the proposed methods work well compared to baselines. The paper proposes direct generalizations of knowledge graph approaches, and unfortunately does not yet provide a comprehensive coverage of the possible design space of the two proposed extensions.

The authors should be commended for providing the source code for reproducibility. One of the reviewers (who was unfortunately also the most negative), was time pressed. Unfortunately, the discussion period was not used by the reviewers to respond to the authors' rebuttal of their concerns.

Even discounting the most negative review, this paper is on the borderline, and given the large number of submissions to ICLR, it unfortunately falls below the acceptance threshold in its current form.



Decision: Reject