Recurrent Event Network : Global Structure Inference Over Temporal Knowledge Graph
Authors: Woojeong Jin
He Jiang
Meng Qu
Tong Chen
Changlin Zhang
Pedro Szekely
Xiang Ren
Venue:  (2020)
Keywords: Temporal Knowledge Graphs
Representation Learning
Graph Sequence Inference
Knowledge Graph Completion

Abstract: Modeling dynamically-evolving, multi-relational graph data has received a surge of interests with the rapid growth of heterogeneous event data. However, predicting future events on such data requires global structure inference over time and the ability to integrate temporal and structural information, which are not yet well understood. We present Recurrent Event Network (RE-Net), a novel autoregressive architecture for modeling temporal sequences of multi-relational graphs (e.g., temporal knowledge graph), which can perform sequential, global structure inference over future time stamps to predict new events. RE-Net employs a recurrent event encoder to model the temporally conditioned joint probability distribution for the event sequences, and equips the event encoder with a neighborhood aggregator for modeling the concurrent events within a time window associated with each entity. We apply teacher forcing for model training over historical data, and infer graph sequences over future time stamps by sampling from the learned joint distribution in a sequential manner. We evaluate the proposed method via temporal link prediction on ﬁve public datasets. Extensive experiments demonstrate the strength of RE-Net, especially on multi-step inference over future time stamps.

Under review as a conference paper at ICLR 2020
RECURRENT EVENT NETWORK: GLOBAL STRUCTURE INFERENCE OVER TEMPORAL KNOWLEDGE GRAPH
Anonymous authors Paper under double-blind review
ABSTRACT
Modeling dynamically-evolving multi-relational graph data has received surge of interests with the rapid growth of heterogeneous event data. However, predicting future events such data requires global structure inference over time and the ability to integrate temporal and structural information, which are not yet well un- derstood. We present Recurrent Event Network (RE-NET), novel autoregressive architecture for modeling temporal sequences of multi-relational graphs (e.g. tem- poral knowledge graph), which can perform sequential, global structure inference over future time stamps to predict new events. RE-NET employs a recurrent event encoder model the temporally conditioned joint probability distribution for the event sequences, and equips the event encoder with neighborhood aggregator for modeling the concurrent events within a time window associated with each entity. We apply teacher forcing for model training over historical data, and infer graph sequences over future time stamps by sampling from the learned joint distribution in a sequential manner. We evaluate the proposed method via temporal link predic- tion on five public datasets. Extensive experiment! demonstrate the strength RE-NET, especially multi-step inference over future time stamps.
INTRODUCTION
Representation learning on dynamically graph-structured data has emerged as an important problem in wide range of upplications, including social network analysis (Zhou et al. 2018a]
Trivedi
et al. 2019), knowledge graph reasoning (Trivedi et al. 2017; Nguyen et al. 2018 Kazemi et al.
2019 event forecasting (Du et al.] 2016), and recommender systems (Kumar et al. 2019 You et al.
2019). Previous methods over dynamic graphs mainly focus on learning time-sensitive structure
representations for node classification and link prediction in singie-relational graphs. However,
the rapid growth of heterogeneous event data (Mahdisoltani et al. 2014 Boschee et al. 2015) has created new challenges on modeling temporal, complex interactions between entities (i.e., viewed as temporal knowledge graph or TKG), and calls for approaches that can predict new events in different future time stamps based on the history-i.e., structure inference of a TKG over time.
Recent attempts on learning over temporal knowledge graphs have focused on either predicting missing events (facts) for the observed time stamps (Garefa- et al. 2018 Dasgupta et al.) 2018 Leblay & Chekol 2018), or estimating the conditional probability of observing a future event using temporal point process (Trivedi et al. 2017 2019). However, the former group of methods adopts an interpolation problem formulation over TKGs and thus cannot predict future events, representations of unseen time stamps are unavailable. The latter group of methods, including Know-Evolve and its extension, DyRep, computes the probability of future events using ground-truths of the proceeding events during inference time, and cannot model concurrent events occurring within the same time window- which often happens when event time stamps are discrete. It is thus desirable to have principled method that can infer graph structure sequentially over time and can incorporate local structural information (e.g., concurrent events) during temporal modeling.
To this end, we propose a sequential structure inference architecture, called Recurrent Event Network TRE-NET), for modeling heterogeneous event data in the form of temporal knowledge graphs. Key ideas of RE-NET are based on the following observations: (1) predicting future events can be viewed as a sequential (multi-step) inference of multi-relational interactions between entities over time; (2)
"ooee and data have heen uploaded and will be published upon acceptance of the paper.

---

Under review as a conference paper at ICLR 2020
Gr-3
G-2
Maake spaement 278/18
Visi at Siana
Local
Global
diplomti recggittio at
Consult at antrne
P(G G
Make recwest 4/2/18
Malo asterment 8/1318
Aggrogate
Encoder
Decockr
(a) An example of temporal KG
(b) Overview of the RE-NET architecture
Figure I: Illustration of (a) temporal knowledge graph and (b) the Recurrent Event Network architecture. RE-NET employs an RNN to capture s-related interactions N (modeled by neighborhood aggregator) different time t. Also the global information from G2 is used to capture the global graph structures. Recurrent event encoder updates its state with graph sequences in an autoregressive manner. The decoder defines the probability P(st, Fx, 0z Ga-1) current time step conditioned on the preceding events.
temporally adjacent events may carry related semantics and informative patterns, which can further help inform future events (i.e., temporal information); and (3) multiple events may co-occur within the same time window and exhibit structural dependencies as they share entities (i.e., local structural information). To incorporate these ideas, RE-NET defines the joint probability distribution of all the events in a TKG in an autoregressive fashion, where it models the probability distribution of the concurrent events at the current time step conditioned on all the preceding events (see Fig. Tb for an illustration). Specifically, a recurrent event encoder, parametrized by RNNs, is used to summarize information of the past event sequences, and neighborhood aggregator is employed aggregate the information of concurrent events for the related entity within each time stamp. With the summarized information of the past event sequences, Such an autoregressive model can be effectively trained by using teacher forcing. Global structure inference for predicting future events can be achieved by performing sampling in sequential manner.
decoder defines the joint probability of current event.
We evaluate our proposed method on temporal link prediction task, by testing the performance of multi-step inference over time five public temporal knowledge graph datasets. Experimental results demonstrate that RE-NET outperforms saat-ooftthe-ae models of both static and temporal graph reasoning, showing its better capacity to model temporal, multi-relational graph data with concurrent events. We further show that RE-NET can perform effective multi-step inference to predict unseen entity relationships distant future.
2 RELATED WORK
Our work is related previous studies on temporal knowledge graph reasoning, temporal modeling on homogeneous graphs, recurrent graph neural networks, and deep autoregressive models.
Temporal KG Reasoning. There are some recent attempts incorporating temporal information in modeling dynamic knowledge graphs. (Trivedi et al.) 2017) presented Know-Evolve which models the occurrence of fact a temporal point process. However, this method is built on problematic formulation when dealing with concurrent events, as shown in Section F Several embedding based methods have been proposed (Gareía- -urán al. 2018 Leblay Chekol 2018 Dasgupta et al. 2018) to model time information. They embed the associate into low dimensional space such as relation embeddings with RNN on the text of time (García-Durán et al., 2018). time embeddings (Leblay & Chekol 2018), and temporal hyperplanes (Leblay & Chekol 2018). However, these models do not capture temporal dependency and cannot generalize to unobserved time stamps.
Temporal Modeling Homogeneous Graphs. There attempts predicting future links homogencous graphs (Pareja et al.) 2019) Goyal et al. 20188] 2019: Zhou et al.) [2018b) Singer et al.. 2019). Some of the methods try to incorporate and learn graphical structures to predict future links Pareja et al.) [019: Zhou et al. 20188) [Singer et al.) 2019), while other methods predict by reconstructing adjacency matrix by using autoencoder (Goyal et al. 2018 2019). These
2

---

Under review as a conference paper at ICLR 2020
methods seek to predict single-relational graphs, and are designed to predict future edges in one future step (i.e., for t + 1). However, our work focuses on "multi-relationa"" knowledge graphs and aims for multi-step prediction (i.c., for t ,....,,t t k).
Recurrent Graph Neural Models. There have been some studies on recurrent graph neural models for sequential or temporal graph-structured data (Sanchez-Gonzalee et al. 2018 Battaglia al.) 2018 Palm et al., 2018: Seo et al.] 2017] Pareja et al. (019). These methods adopt a message-
passing framework for aggregating nodes' neighborhood information (e.g., via graph convolutional operations). GN (Sanchez-Gonzalez et al. 2018 [Battagiia et al. 2018) and RRN (Palm et al., 2018)
update node representations by a peasssae-passinng scheme between time stamps. Some prior methods adopt an RNN to memorize and update the states of node embeddings that are dynamically evolving (Seo et al. 2017). , or memorize and update the model parameters for different time stamps (Pareja et al. 2019). In contrast, our proposed method, RE-NET, aims to leverage autoregressive modeling to parameterize the joint probability distributions of events with RNNs.
Deep Autoregressive Models. Deep autoregressive models define joint probability distributions as a product of conditionals. DeepGMG (Li et al., 2018) and GraphRNN (You et al. 2018) are deep generative models of graphs and focus on generating homogeneous graphs where there is only single type of edge. In contrast to these studies, our work focuses on generating heterogencous graphs, in which multiple types of edges exist, and thus our problem is more challenging. To the best of my knowledge, this is the first paper to formulate the structure inference (prediction) problem for temporal, multi-relational (knowledge) graphs in autoregressive fashion.
3 PROPOSED METHOD: RE-NET
We consider temporal knowledge graph (TKG) as multi-relational, directed graph with time- stamped edges (relationships) between nodes (entities). An event is defined as a time-stamped edge, i.., (subject entity, relation, object entity, time) and is denoted by quadruple (s, r, o, or (St: re, Oz). We denote a set of events at time as G.. A TKG is built upon sequence of event quadruples ordered ascending based on their time stamps, i.e., {Gr}: = {(s,, re, 4:); (with & < tj. Vi < j), where each time-stamped edge has a direction pointing from the subject entity to the object entity? [ The goal of learning generative models of events is to learn a distribution (P()) over temporal knowledge graphs, based on set of observed event sets (G1,.... Gr To model lasting events which span over time range, i.e., (s, o, [f1, t2]), we simply partition such event into a sequence of time-stamp events [Gr, Gr2). J. We leave more sophisticated modeling of lasting events as future work.
3.1 RECURRENT EVENT NETWORK
Sequential Structure Inference in TKG. The key idea in RE-NET is to define the joint distribution of all the events G ..., Gr) an autoregressive manner, i.e., P(G) = II Basically, we decompose the joint distribution into sequence of conditional distributions (e.g.. (G-,(Cimm)))). where we assume the probability of the events at a time step, e-g. G,, only depends on the events at the previous P(G, GG) we further assume that the events in G, are mutually independent given the previous events G2 Gt-mat-.. In this way, the joint distribution can be rewritten follows.
steps, e.g., G1-mat1- For each conditional distribution
P(G)- = -II
II (B.F).)))
IP(s, It, Gr-Gmm)
(I)
II
II (EL
IP.o.|s., Go-ma-1) [P(resst, Gr-mat (P(se Go-mat-1).
Intuitively, the generation process of each triplet (st, It, o₂) is defined as below. Given all the past events Gı-mat-1, we fist generate subject entity st through the distribution (G-m)))- Then we further generate relation I2 with P(rc|se, G Gi-mat1), and finally the object entity o, is generated by defining (P(o,|ss, re; Gz-mat-1).
In this work, we assume that P(ox rt, Gr-mat) and (P(rr (st, G.-ma-1 depend only on events that are related s, and focus modeling the following joint probability:
(P(S, It. Gr/GGmmit-) = IP(o, (())) m P(re|s, (())
N ((se(G)mma))), (2)
The same triple (s, r.) may occur multiple times in different time stamps, yielding different event quadruples.
3

---

Under review as a conference paper at ICLR 2020
eapregator 24hpp
g(N6)a
5(H(0) 2)
Graph from
Graph
Graph
RGCN Aggregation
Illustration of the multi-relational graph (RGCN) aggregator. The blue node corre- sponds to node 8, red nodes are 1-hop neighbors, and green nodes are 2-hop neighbors. Different colored edges are different relations. In this figure, we get ((N(s) ((N(s))-1) and g(N(s))-22 for each graph from two-layered RGCN aggregator.
Figure 2:
where G. becomes N which is set of neighboring entities interacted with subject entity under all relations at time stamp f. For the third probability, the event sets should be considered since subject not given. Next, we introduce how we parameterize these distributions.
Recurrent Event Encoder. RE-NET parameterizes ((o,,ss. Gt-mat1) in the following way:
P( s, N(*) mi) x exp (les : e, h r)) w..))
where esy e, Idd are learnable embedding vectors specified for subject entity s and relation r. (s-1(s, r) Rd is history vector which encodes the information from the neighbor sets interacted with in the past, as well as the global information from graph structures of G Basically, [e, Cr h (s. r)] is encoding to summarize all the past information. Based that, we further compute the probability of different object entities by passing the encoding into a linear softmax classifier parameterized by {w..}-
Similarly, we define the probabilities for relations and subjects as follows:
[r,r/ss, ((2) exp (le, hs-1(s))] w..).
(4)
IPs (((s/GGmmmt-)) x exp (H,_1 w..).
(5)
where (s) captures all the local information about the past, and H Rd is vector representation to encode the global graph structures Gr- Gt-la-m-
For each time step I, since the hidden vectors h;- (s), (s, and H,-1 preserve the information from the past events, and we update them in the following recurrent way:
he(s, r) RNN' (g(N()) Hr, 1
hr (s) RNN (o))))), H,, 1s)),
H. RNN (g( (N H:-1),
where is an aggregation function, and N(!)) stands for all the events related to s at the current time step f. Intuitively, we obtain the current information related s by aggregating all the related events at time i.e. )(N Then update the hidden vector h, r) by using the aggregated information g(N( at the current step, the past value 1 r) and also the global hidden vector H. The hidden vector h₂(s) is updated in a similar way. For the aggregation of all events g(G)) we define g(G.) max (N(")) which is from the element-wise max-po max-pooling operation over all ((N We use Gated Recurrent Units Cho et al. 2014 as RNN. Details are described in Section
For each subject entity s, it can interact with multiple relations and object entities at each time step t. In other words, the set N(2) can contain multiple events. Designing effective aggregation functions aggregate information from N(*) for is therefore nontrivial problem. Next, we introduce how we design (-) in RE-NET.
3.2 CELLTI-RLLAIONAL GRAPH (RGCN) AGGREGATOR
Here we discuss the aggregate function 9(-), which capture different kinds of neighborhood infor- mation for each subject entity and relation, i.e., (s, r). We first introduce two simple aggregation
4

---

Under review as a conference paper at ICLR 2020
functions, i.e., mean pooling aggregator and attentive pooling aggregator. These two simple aggrega- tors only collect neighboring entities under the same relation r. Then we introduce a more powerful aggregation function, i.e., multi-relational aggregator.
Mean Pooling Aggregator. The baseline aggregator simply takes the element-wise mean of the vectors (e, : o E N where N( a set of objects interacted with s under But the mean aggregator treats all neighboring objects equally, and thus ignores the different importance of each neighbor entity.
Attentive Pooling Aggregator. We define attentive aggregator based on the additive attention introduced (Bahdanau et al. 2015) to distinguish the important entities for (s, r). The aggregate
function is defined as g(N) EeeN( aoCo, where ao softmax(v" tanh (anh(W((e)) (es; er; e.))). e
Rd and W E Rdxad are trainable weight matrices. By adding the attention function of the subject and the relation, the weight can determine how relevant each object entity is to the subject and relation.
Relti-Relational Aggregator. Here, we introduce a multi-relational graph aggregator based on (Schlichtkrull et al.) 2018). This is general aggregator that can incorporate information from multi-relational neighbors and multi-hop neighbors. Formally, the aggregator is defined as follows:
((N = (1+1) a Σ
Σ
W (1) + W. n!)).
Ce
rE
OEN(
where initial hidden representations for each node (h! are set to trainable embedding vectors (e,) for each node.
Basically, each relation can derive local graph structure between entities, which further yield a message on each entity by aggregating the information from the neighbors of that entity, i.e., Even(en) ( h The overall message on each entity is further computed by aggregating all the relation-specific messages, i.c., ErER Eoen(an) ww Finally, the aggregator g(((") is defined by combining both the overall message and the information from past steps, i.c., ( h
To distinguish between different relations, we introduce independent weight matrices (W for each relation Furthermore, the aggregator collects representations of multi-hop neighbors by introducing multiple layers of the neural network, with each layer indexed by The number of layers determines the depth to which the node reaches to aggregate information from its local neighborhood.
We depict this aggregator in Fig. 2
The major issue of this aggregator is that the number of parameters grows rapidly with the number of relations. In practice, this can easily lead to overfitting on rare relations and models of very large size. Thus, we adopt the block-diagona decomposition (Schlichtkrull al. 2018). where each relation-specific weight matrix decomposed into a block-diagonal by decomposing into low- .... )
dimensional matrices. !!!)) in equation is defined as a block diagonal matrix, diag(A (1)
where A (1) bo E 1 (B) and is the number of basis matrices. The block decomposition
reduces the number of parameters and helps to prevent overfitting.
3.3 PARAMETER LEARNING AND INFERENCE OF RE-NET
Parameter Learning via Event Prediction. The (object) entity prediction given (s, can be viewed as a multi-class classification task, where each class corresponds to one object entity. Similarly, rela- tion prediction given and subject entity prediction be considered task. Here we omit the notation for previous events. To learn weights and representations for entities and relations, we adopt multi-class cross-entropy loss to the model's output,Thh The loss function is comprised of three losses and defined as:
multi-class classification
-=
Σ (Iog(P(o.|st,,.)) + Y₁ log(IP(re|st)) + de log(P(s:))), (s.r,o.))GG
(10)
where is set of events, and dS and ) are importance parameters that control the importance of each loss term. Xj and X2 can chosen depending on task. If the task aims to predict given (s, r). then we can give small values to λ₁ and d2. Each probability is defined in equations and 5 respectively. We apply teacher forcing for model training over historical data.
5

---

Under review as a conference paper at ICLR 2020
Algorithm 1: Inference algorithm of RE-NET
Observed graph sequence: [Gi, Gr-1), Number of events to sample at each step: M. Output: An estimation of the conditional distribution: F(Ge+ar[G.a)
Input:
t' =t
while L'
11+ Ai
Sample M number of P(s)G(+1:r-1, Ga) by Equation 5
Pick top-k triples (i,, (Sk, Tie OR, {')} ranked by Equation
Ge = { o1, (Sk, Tk, oN,
t'='+
Estimate the probability of each event (ss, r,
G.) by Equation Estimate the joint distribution of all events P(C GG41++ G.t) by Equation
return PG G441444111 G.)) as the estimation.
Multi-step Inference over Time. At inference time, RE-NET seeks to predict the forthcoming events based the previous observations. Suppose that the current time ( and aim predicting events at time /. + Al, then the problem of multi-step inference can be formalized as an inference problem, i..., inferring the conditional probability P(Gr+2+|G:.) The problem is nontrivial as we need to integrate over all 1++1:+Ae-11 To achieve efficient inference, we draw sample of Ge-1:tAe-1. and estimate the conditional probability in the following way:
((G++a:/G.))
Σ Get1i4At-1
= -Be(Ge4ne+ae-- (G..) (GGa)((GHHaGGaa = P(CreadlGGH G.) (11) Such an inference procedure is intuitive. Basically, one starts with computing P(G++ G.t), and drawing sample G.+1 from the conditional distribution. With this sample, one can further compute GGe4, G.). By iteratively computing the conditional distribution for Ge and drawing sample from it, one can eventually estimate P(G(+ai|Gaa) as P(G++ /G412+44-11 a/GG=a///44 G.)). practice, we can improve the estimation by drawing multiple graph samples at each step. but RE-NET already performs very well with a single sample, and thus we only draw one sample graph at each step for better efficiency. Based on the estimation of the conditional distribution, we can further predict events which are likely to form in the future. We summarize the detailed inference algorithm Algorithm In Algorithm I. we sample one graph time. To obtain the graph, first sample M number of (line and pick top-k triples (line 4p. Then we have a knowledge graph at time (line
Computational Complexity Analysis. Here analyze the time complexity of the graph genera- tion algorithm [] To compute (s GG-mat-1) (equation 5) it takes O Lm). where |E| is the maximum number of triples among {Gr-m; .... Gt-1). L is the number of layers of aggregation, and m is the number of the past time steps since we unroll m time steps in RNN. From this prob- ability, we sample M number of subjects takes ODDmm). where D is the maximum degree of entities. To get probabilities of all possible triples given sampled subjects, it needs OMM R O (0m)) where |R| is the total number of relations and [O] is the total number of entities. Thus. the time complexity for generating one graph is O() F[ + M R[] + log k)) where i the cutoff number for picking top-k triples. The time complexity is linear to the number of entities and relations, and the number of sampled 8.
To compute P(s Ir, Or Gr-mat-)) (equation 2
4 EXPERIMENTS
Evaluating the quality of generated graphs is challenging, especially in knowledge graphs (Theis) al. 2015). Instead, we evaluate our proposed method on a link prediction task on temporal knowledge graphs. The task of predicting future links aims to predict unseen relationships with object entities given (s, r, () (or subject entities given (?, r, o, t)), based on the observed events in the TKG. Essentially, the task is ranking problem over all the events rs, t) (or (?, r, o, t)). RE-NET can approach this problem by computing the probability of each event in a distant future with the inference algorithm in Algorithm|] [ and further rank all the events according to their probabilities.
We evaluate our proposed method on three benchmark tasks: (1) predicting future events on three event-based datasets; (2) predicting future facts two knowledge graphs which include facts with time spans, and (3) studying parameter sensitivity and ablation of our proposed method. Section 4.1

---

Under review as a conference paper at ICLR 2020
Table 1: Performance comparison on temporal link prediction (average metries in % over 5 runs) on three event-based TKG datasets with filtered setting. RE-NET achieves the best results. Results with raw setting are in the supplementary material.
ICEWS18- filtered
GDELT
filtered
ICEWS14 filtered
Method
MRR
H@
H@3
H@10 10
MRR
H@1
H@3 3
H@
MRR
H@I
H@3
H 10
TransE:
17.56
2.48
26.95
43.87
16.05
0.00
26.10
42.29
18.65
1.21
31.34
47.07
DistMult
12.13
42.18
18.71
11.59
20.05
19.06
10.09
22,00
36.41
Statie
ComplEx
30.09
21.88
34.15
45.96
22.77
15.77
24.05
36.33
24.47
16.13
27.49
41.09
R-GON
23.19
16.36
25.34
36.48
23.31
17.24
24.94
34.36
26.31
18.23
30.43
45.34
ConvE
36.67
28.51
39.80
50.69
35.99
27.05
39.32
49.44
40.73
33.20
43.92
54.35
RotatE
23.10
14.33
27.61
38.72
22.33
16.68
23.89
32.29
29.56
22.14
32.92
42.68
HyTE
7.31
3.10
7.50
14.95
6.37
0.00
6.72
18.63
11.45
5.64
13.04
22.51
TTransE
8.36
1.94
8.71
21.93
5.52
0.47
5.01
15.27
6.35
1.23
5.80
16.65
TA-DistMolt
28.53
20.30
31.57
44,96
29.35
22.11
31.56
41.39
20.78
13.43
22,80
35,26
3,27
3.23
3.23
3.26
2.43
2.33
2.35
2,41
1.42
1.35
1.37
1.43
Know-Bvolve-MLP
9.29
9.62
17.18
22.78
15,40
25,49
35.41
22.89
14.31
26.68
38.57
Temporal
DyRep+MLP
9.86
5.14
10.66
18.66
23.94
155557
27.88
36.58
24.61
15.88
28.87
39.34
R-GCRN-MLP
35.12
27.19
38.26
50.49
37.29
29.00
41.08
51.88
36.77
28.63
40.15
52.33
RE-NET wlo multi-step
40.05
33.32
42,60
52.92
38.72
30.57
42.52
52.78
42.72
35.42
46.06
56. 15
RE RE.NET wlo agg.
38.10
29.34
41,26
51.61
42.23
56.07
RE-NET w. mean agg-
40.70
34,24
43.27
53.65
38.35
29.92
42.13
52.52
43.79
36.21
47.34
57.47
RE-NET w. attn agg.
40.96
34.57
44.08
54,32
38.
29.65
42.25
52.85
33.94
37,01
47,85
57,91
RE-NET
42.93
36.19
45.47
55.80
40.12
32.43
43.40
53.80
45.71
38.42
49.06
59.12
RE-NET w. GT (8.1)
44.33
37.61
46.83
57.27
41.80
33.54
45.71
56.03
46.74
39.41
50.10
60.19
summarizes the datasets, and the supplementary material contains additional information. In all these experiments, we perform predictions on time stamps that are not observed during training.
4.1 EXPERIMENTAL SET-UP
Datasets. We use five datasets: 1) three event-based temporal knowledge graphs: ICEWS18 (Boschee et al. 2013). ICEWS14 14 (Trivedi et al. (017). and GDELT (Leetaru & Schrod( 2013); and 2) two
knowledge graphs where temporally associated facts have meta-facts as (s. r, o. t.. tc where t, is the starting time point and t, is the ending time point: WIKI (Leblay & Chekol 2018) and
YAGO (Mahdisoltani et al. 2014). The details of the datasets are described in Section
Evaluation Setting and Metrics. For each dataset except ICEWS14, 14, we split it into three subsets, i.e., train(80%) / 10% (ites(10%)) by time stamps. Thus, (times of train) < (times of valid) < (times of test). We report Mean Reciprocal Ranks (MRR) and Hits @tts1 1/3/10, using the filtered version and the raw version of the datasets. Similar to the definition of filtered setting in (Bordes et al. (013). during evaluation, we remove from the list of corrupted triplets all the triplets that appear either in the train, dev, or test set.
Competitors. We compare approach to baselines for static graphs and temporal graphs:
(1) Static Methods. By ignoring the edge time stamps, we construct a static, cumulative graph for all the training events, and apply multi-relational graph representation learning methods including TransE (Bordes et al. 2013), DistMult (Yang et al., 2013), ComplEx (Trouillon et al., 2016). R-
GCN (Schlichtkrull et a 2018). ConvE (Dettmers et al. 2018). and RotatE (Sun et al. 2019).
(2) Temporal Reasoning Methods. We also compare state-of tftte-t temporal reasoning methods for knowledge graphs, including Know-Evvlvvel Trivedi et al. 2017). TA-DistMult (García-Durán et al. 2018). HyTE (Dasgupta et al.) 2018), and TTranst: (Leblay & Chekol 2018). TAlDDstMMlt,, HyTE, and TTranSE are for a interpolation task which is to make predictions at time t such that t <t<<t t2, which is different from our setting. We give random values or embeddings that are not observed during training. To see the effectiveness of our recurrent event encoder, we use encoders Dyrep (Trivedi) jet al. 2019), and GCRN (Seo et al.) 2017) combined with our MLP decoder, which are called DyRep+MLP, and M-GCRN+MLP. The GCRN utilizes Graph Gonvolutional Network (Kipf & Welling 2016). Instead, we use RGCN (Schlichtkrull et al. 2018) to deal with multi-relational graphs.
of previous work and our MLP decoder as baselines; we compare Know-Exoly
1a, We found a problematic formulation in Know Evolve when dealing with concument events (Eq. (3) in its paper) and a flww in its evaluation onde. The performance dimaatcclll drops after fixing the evaluation code. Details issues are discussed in Section
7

---

Under review as a conference paper at ICLR 2020
Table 2: Performance comparison on temporal link prediction (average metries in % over 5 runs) on two public temporal knowledge graphs, i.e., WIKI and YAGO.
WIKI filtered
WIKI
YAGO filtered
YAGO
Method
MRR
H@
H@ 10
MRR
H@3
H@ 10
MRR
H@
H@ 10
MRR
H@3
H@ 10
TransE
46.68
49.71
51.71
26.21
31.25
39.06
48,97
62.45
66.05
33.85
48.19
59.50
DistMult
46.12
49.81
51.38
27.96
32.45
39.51
59.47
60.91
65 65.26
44,05
49,70
59.94
Statie
ComplEx
50.08
27.69
38.61
62.28
66.82
44.09
49.57
59.64
R-GCN
37.57
39.56
41.90
13.96
15.75
22.05
41.30
44,44
52.68
20.25
24.01
37.30
Convi
47.57
50.10
26.03
30.51
39.18
63.97
59.90
RotatE
50.67
50.74
50.88
26.08
31.63
38.51
65.09
63.67
66.16
42.08
46.77
59.39
ByyTE
45.12
37.54
45.74
14.42
TTransE
31.74
36.25
43,45
20.66
23.88
33.04
32.57
43.39
53.37
26. 10
36.28 28
47.73
Milt
48.09
49.51
51.70
31.36
38.97
61.72
65.32
67.19
50.64
61.11
Know-Evolve*
0.09
00.03
0.10
0.03
0
0.04
00.07
0
0.04
0.02
0
0.01
Know EvoLve+MPP
21.57
10.54
13.08
20.21
6.59
5.2.
Temporal
DLR
11.60
12.74
21.66
10.41
12.06
20.93
5.87
6,54
11.98
4.98
5,54
10.19
R G.RN++LLP
47.71
48.14
28.68
38.58
53.89
56.06
61.19
56.98
RE-NET w/o multi-stop
51.01
51.14
52.91
29.91
32.60
40.29
64.21
64.70
67.11
45.88
51.78
60.97
RE-NET w/o age
31.08
33.98
45.53
17.55
20.65
33.51
33.86
36.89
50.72
27.37
30.20
46.35
RE-NET w. mean agg.
51.13
51.37
53,01
30.19
32.94
40.57
65,10
65.24
67.34
46.33
52,49
61.21
RE-NET w. altn agg.
51.25
52.54
53.12
30.25
30.12
40.86
65,13
67.54
67.87
46.56
52.56
61.35
RE-NET
$1.97
52.07
53,91
34.87
33.55
41.27
65.16
65.63
68.08
46.81
52.71
61.93
RE NET w. GT (s.r)
53.57
54.10
55.72
32.44
35.42
43.16
66.80
67.23
69.77
48.60
54.20
63.59
(3) Variants of RE-NET. To evaluate the importance of different components of RE-NET, we varied our base model in different ways: RE-NET w/o multi-step which does not update history during inference, RE-NET without the aggregator (RE-NET w/o agg.). RE-NET with a mean aggregator (RE-NET W. mean agg.), and RE-NET with an attentive aggregator (RE-NET w. attn agg.). takes zero vector instead of representation of the aggregator. RE-NET w. GT (s, r) denotes RE-NET with ground truth history or interactions during multi-step inference, and thus the model knows all the interactions before the time for testing. It does not update history (or generate graph) since it already has ground truth history. Experiment settings and implementation details of RE-NET and baselines are described in Section
4.2 PERFORMANCE COMPARISON ON TEMPORAL KNOWLEDGE GRAPHS.
In this section compare our proposed method with other baselines. The test results obtained by averaged metrics over the entire test sets on datasets.
Performances on Event-based TKGs. Table summarizess results on three event-based datasets: ICEWS18, GDELT, and ICEWS14. Our proposed RE-NET outperforms all other baselines on these datasets. Static methods show good results but they underperform our method since they do not consider temporal factors. Also, RE-NET outperforms all other temporal methods, which demonstrates effectiveness of the proposed method. The modified Know-Evolve with our MLP decoder -voole++ooll) achieves the better performances than Know-Evolve which shows effectiveness of our MLP decoder, but there still large gap from our model. We notice that and DyRep has a gradient exploding issue on their encoder since their RNN-like structures keep accumulating embedding over time. This issue degrades their performances. Graph Convolutional Recurrent Network (GCRN) is not for dynamic and multi-relational graphs, and is not capable of link prediction. We modified the model to work on dynamic graphs and our problem setting by using RGCN instead of GCN, and our MLP decoder. The modified model (R-GCRN+MLP) shows good performances but it does not outperform our method. R-GCRN+MLP has a similar structure to ours in that it has recurrent encoder and an RGCN aggregator but it lacks multi-step inference, global information, and sophisticated modeling for the recurrent encoder. These results of the combined models suggest the our recurrent event encoder shows better performances in link prediction. Importantly, all these temporal methods are not capable of multi-step inference, while RE-NET sequentially infers multi-step events.
Performances on Public KGs. Previous results have proved the effectiveness of RE-NET, and here we will compare the method on the Public KGs: WIKI and YAGO. In Table our proposed RE-NET outperforms all other baselines. In these datasets, baselines show better results than in the Eveet-based TKGs. This is due to the characteristics of the datasets; they have facts that are valid within a time span. However, our proposed method consistently outperforms the static and temporal
8

---

Under review as a conference paper at ICLR 2020
ConvE
TA-DistMult
0.54
0.66
0.4
0.59
0.3
0.8
0.5
4010
2017
2012
2014
2016
Ago
2013
2014
2016
2ute
am
10
15
1000
2000
2000
4000
5000
Mirutea
Years
(a) ICEWSI8 (H(3)
(b) GDELT (H03)
(c) WIKI (HK33
(d) YAGO (H@3)
Figure 3: Performance of temporal link prediction over future time stamps with filtered Hits @ 3.
RE-NET consistently outperforms the baselines.
45
global global
Attn RGON
omp pis) RE Net
40
41
MRR
MRR
His@3
MRR
(a) RE-NET with dif- ferent aggregators
(b) Effect of global rep-
(c) Study of empirical
resentations
((s) and P(s,r)
Figure 4: Performance study on model variations. We study the effects (a) RE-NET with different aggregators, (b) effect of the global representation from global graph structure, and (c) empirical F(s) and (s)
methods. which implies that RE-NET effectively infers new events using powerful event encoder and an aggregator, and provides accurate prediction results.
Performances of Prediction over Time. Next, we further study performances of RE-NET over time. Figs. 1igs.3shen shows the performance comparisons over different time stamps on the ICEWS18, GDELT, WIKI, and YAGO datasets with filtered @its@3 metrics. RE-NET consistently outperforms baseline methods for different time stamps. Performances each method fluctuate since testing entities different at each time step. We notice that with the increase of time step, the difference between RE-NET and ConvE is getting smaller as shown in Fig. B This is expected since further future events harder to predict. Furthermore,
think that the decline of the performances is due the generation of a long graph sequence. To estimate the joint probability distribution all events in distant future, RE-NET should generates long sequence of graphs. The quality of generated graphs deteriorates when RE-NET generates a long graph sequence.
4.3 ABLATION STUDY
In this section, we study the effect variations in RE-NET. To evaluate the importance of different components of RE-NET, we varied base model in different ways, measuring the change in performance on the link prediction task on the ICEWSI8 dataset. We present the results in Tables [ and Figs. 4
Different Aggregators. We first analyze the effect of the aggregator: In Tables we observe that RE-NET w/o agg. hurts model quality. This suggests that introducing aggregators make the model capable of dealing with concurrent events and aggregators improve the prediction performances. Fig. shows the performances of RE-NET with different aggregators. Among them, RGCN aggregator outperforms other aggregators. This aggregator has the advantage of exploring multi- relational neighbors not limited to neighbors under the same relation. Also, RE-NET with an attentive aggregator shows better performances than RE-NET with mean aggregator, which implies that giving different attention weights to each neighbor helps predictions.
Global Information. We further observe that representations from global graph structures help the predictions. Fig. (bbsswss effectiveness of a representation of global graph structures. We consider that global representations give information beyond local graph structures.

---

Under review as a conference paper at ICLR 2020
50
44
3-layers
45
42
42
40
14
30
Longth of history
Cutolf position
MRR
Hit@@
(a) Length of past history
(b) Cutoff position k
(c) layers of RGCN
Figure 5: Parameter sensitivity on RE-NET. We study the effects of (a) length of RNN history in event sequence encoder, (b) cutoff position inference time, and (c) number of RGCN layers in neigborhood aggregation.
Empirical Probabilities. Here, we study the role of F( ([ss)))ma--) and P(rels, Gt-mat-)). We simply denote them as (ss)) and P(r) for brevity. Also, P(s,, (= (or simply P(s.r) is equivalent (r)) In Fig 4c emp. P(s) denotes model with empirical PP(s) (or IP (s)) which defined as P. (s) = (#f of s-related triples) / (total # of triples). Also, emp. P(s. r) denotes model with (s) and Po (r(r) which is defined as (r) (# of r-related triples) (total # of triples). Thus, Pa r) P. (s)P (r). RE-NET use a trained ((s) and P(r). The results show that the trained P(s) and P(r) help RE-NET for multi-step predictions. Using (s)(s) underperforms RE-NET, and using (s, P. (r) shows the worst performances, which suggests that training each part of the
probability in equation 2 gives better prediction performances.
4.4 SENSITIVITY ANALYSIS
In this section, we study the parameter sensitivity of RE-NET including the length of history for the event encoder, cutoff position k for events generate graph. Furthermore, study the layers of RGCN aggregator. We report the performance change of RE-NET on the ICEWS18 dataset by varying the hyper- papre-pprraeters in Table
Length of Past History in Recurrent Event Encoder. The recurrent event encoder takes the graph sequences previous histories. Figure 5a shows the
sequence of past interactions up performances with varying length of past histories. When RE-NET uses longer histories, MRR is getting higher. However, the MRR This implies that long history does not make big differences.
likely go higher when the length of history is and over.
Cut-off Position A at Inference Time. To generate graph at each time, we off top-k triples on ranking results. Fig. 5b shows the performances with choosing different cutoff position k. When k is O, RE-NET does not generate graphs for estimating P(G++Ar (G.), and it shows the lowest result. which means RE-NET performs single-step predictions. When A: is larger, the performance is getting higher and is saturated after 500. We notice that the conditional distribution (()+) can be approximated by P(G++AI G441444111 G+2) by using a larger cutoff position.
Layers of RGCN Aggregator. We examine the number of layers in the RGCN aggregator. The number of layers in the aggregator means the depth to which the node reaches. Fig. [c shows the performances according to different numbers of layers of RGCN. We notice that 2-layered RGCN improves the performances considerably compared to 1-layered RGCN since 2-layered RGCN aggregates more information. However, RE-NET with 3-layered RGCN underperforms RE-NET with 2-layered RGCN, We conjecture that the bigger parameter space leads to overfitting.
CONCLUSION
In this work, we studied the sequential graph generation on temporal knowledge graphs. To tackle this problem, proposed Recurrent Event Network (RE-NET) which models temporal, multi-relational. and concurrent interactions between entities. A recurrent event encoder in RE-NET summarizes information of the past event sequences, and neighborhood aggregator collects the information of concurrent. RE-NET defines the joint probability of all events, and thus is capable of inferring global structures sequential manner. We tested the proposed model on link prediction task on temporal knowledge graphs. The experiment revealed that the proposed RE-NET outperforms all the static and temporal methods and our extensive experiments shows strength. Interesting future work includes modeling lasting events and performing inference on the long-lasting graph structures.
10

---

Under review as a conference paper at ICLR 2020
REFERENCES
Dzmitry Bahdanau. Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. CoRR, 0ts/1140.04755 2015.
Peter W. Battaglia, Jessica B. Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinícius Flores Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, Çaglar Gülçehre, Francis Song, Andrew J. Ballard, Justin Gilmer, George E. Dahl, Ashish Vaswani, Kelsey R. Allen, Charles Nash, Victoria Langston, Chris Dyer, Nicolas Heess, Daan Wierstra, Pushmeet Kohli, Matthew Botvinick, Oriol Vinyals, Yujia Li, and Razvan Pascanu. Relational inductive biases, deep learning, and graph networks. CoRR, abs/1806.01200 2018.
Antoine Bordes, Nicolas Usunier, Alberto Garcfa-Durán Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. In NIPS, 2013.
Elizabeth Boschee, Jennifer Lautenschlager, Sean O' OrBrien, Steve Shellman, James Starz, and Michael Ward. Icews coded event data. Harvard Dataverse, 12, 2015.
Kyunghyun Cho, Bart van Merrienboer, Çaglar Gülçehre, Dzmitry Bahdanau. Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. In EMNIP,, 2014.
Shib Sankar Dasgupta, Swayambhu Nath Ray, and Partha Talukdar. Hyte: Hyperplane-based temporally aware knowledge graph embedding. In EMNLP, 2018.
Tim Dettmers, Pasquale Minervini, Pontus Stenetorp, and Sebastian Riedel. Convolutional 2d knowledge graph embeddings. AAAI, 2018.
Nan Du, Hanjun Dai, Rakshit Trivedi, Utkarsh Upadhyay, Manuel Gomez-Rodriguez, and Le Song. Recurrent marked temporal point processes: Embedding event history to vector. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2016.
Alberto García-Durán Sebastijan Dumancic, and Mathias Niepert. Learning sequence encoders for temporal knowledge graph completion. In EMNLP, 2018.
Palash Goyal, Nitin Kamra, Xinran He, and Yan Liu. Dyngem: Deep embedding method for dynamic graphs. arXiv preprint arXiv: 1805. /273, 2018.
Palash Goyal, Suját Rokka Chhetri, and Arquimedes Canedo. dyngraph2vec: Capturing network dynamics using dynamic graph representation learning. Knowledge-Based Systems, pp. (04816, 2019.
William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning large graphs. NIPS, 2017.
Xu Han, Shulin Cao, Xin Lv, Yankai Lin, Zhiyuan Liu, Maosong Sun, and Juan-Zi Li. Openke: An open toolkit for knowledge embedding. In EMNLP, 2018.
Seyed Mehran Kazemi, Rishab Goel, Kshitij Jain, Ivan Kobyzev, Akshay Sethi, Peter Forsyth, and Pascal Poupart. Relational representation learning for dynamic (knowledge) graphs: A survey, arXiv preprint arXiv: 14485 2019.
Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv: 1412.6980, 2014.
Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. CoRR, hbbs/1009.02901, 2016.
Srijan Kumar, Xikun Zhang, and Jure Leskovec. Predicting dynamic embedding trajectory in temporal interaction networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, 2019.
11

---

Under review as a conference paper at ICLR 2020
Julien Leblay and Melisachew Wudage Chekol. Deriving validity time in knowledge graph. In Companion of the The Web Conference 2018 on The Web Conference 2018, pp. 1771-1776. International World Wide Web Conferences Steering Committee, 2018.
Kalev Leetaru and Philip A Schrodt. Gdelt: Global data on events, location, and tone, 1979-2012. In ISA annual convention, volume 2, pp. 1-49. Citeseer, 2013.
Yujia Li, Oriol Vinyals, Chris Dyer, Razvan Pascanu, and Peter Battaglia. Learning deep generative models of graphs. arXiv preprint arXiv:/803 0et.::338...33.. 2018.
Farzaneh Mahdisoltani, Joanna Asia Biega, and Fabian M. Suchanek. Yago3: A knowledge base from multilingual wikipedias. In CIDR, 2014.
Giang Hoang Nguyen, John Boaz Lee, Ryan A. Rossi, Nesreen K. Ahmed, Eunyce Koh, and Sungchul Kim. Continuous-tiin dynamic network embeddings. In www, 2018.
Rasmus Berg Palm, UIrich Paquet, and Ole Winther, Recurrent relational networks. In NeurlPS, 2018.
Aldo Pareja, Giacomo Domeniconi, Jie Chen, Tengfei Ma, Toyotaro Suzumura, Hiroki Kanezashi, Tim Kaler, and Charles E. Leisersen. Evolvegen: Evolving graph convolutional networks for dynamic graphs. CoRR, http//922.1111.1.. 2019.
Alvaro Sanchez-Gonzaler, Nicolas Heess, Jost Tobias Springenberg, Josh Merel, Martin A. Ried- miller, Raia Hadsell, and Peter W. Battaglia. Graph networks learnable physics engines for inference and control. In ICML, 2018
Michael Sejr Schlichtkrull, Thomas N. Kipf, Peter Bloem, Rianne van den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional networks. In ESWC, 2018.
Youngjoo Seo. Michaël Defferrard, Pierre Vandergheynst, and Xavier Bresson. Structured sequence modeling with graph convolutional recurrent networks. In ICONIP, 2017.
Uriel Singer, Ido Guy, and Kira Radinsky. Node embedding over temporal graphs. arXiv preprint arX3v:/003.0800 2019.
Zhiqing Sun, Zhi-Hong Deng, Yun Nie, and Jian Tang. Rotate: Knowledge graph embedding by relational rotation in complex space. arXiv preprint 19X2::9902.11197 2019.
Lucas Theis, Aäron van den Oord, and Matthias Bethge. A note on the evaluation of generative models. arXiv preprint 1wXiv:1511.01844, 2015.
Rakshit Trivedi, Hanjun Dai, Yichen Wang, and Le Song. Know-evolve: Deep temporal reasoning for dynamic knowledge graphs. In /CML, 2017.
Rakshit Trivedi, Mehrdad Farajtabar, Prasenjeet Biswal, and Hongyuan Zha. Dyrep: Learning representations over dynamic graphs. In ICLR 2019, 2019.
Théo Trouillon, Johannes Welbl, Sebastian Riedel, Éric Gaussier, and Guillaume Bouchard. Complex embeddings for simple link prediction. In ICML, 2016.
Bishan Yang. Wen tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. Embedding entities and relations for learning and inference in knowledge bases. CoRR, abs/1412.6575. 2015.
Jiaxuan You, Rex Ying, Xiang Ren, William Hamilton, and Jure Leskovec. Graphrnn: Generating realistic graphs with deep auto-regressive models. In International Conference on Machine Learning, pp. 5694-5703, 2018.
Jiaxuan You, Yichen Wang, Aditya Pal, Pong Eksombatchai, Chuck Rosenburg, and Jure Leskovec. Hierarchical temporal convolutional networks for dynamic recommender systems. In The World Wide Web Conference, 2019.
Lekui Zhou, Yang Yang, Xiang Ren, Fei Wu, and Yueting Zhuang. Dynamic network embedding by modeling triadic closure process. In AAAI, 2018a. Sa.
Lekui Zhou, Yang Yang, Xiang Ren, Fei Wu, and Yueting Zhuang. Dynamic network embedding by modeling triadic closure process. Thirty-Secome AAAI Conference on Artificial Intelligence, 2018b.
12

---

Under review as a conference paper at ICLR 2020
A
RECURRENT EVENT ENCODER
We define a recurrent event encoder based on RNN as follows:
(s,r)) (N(()((((s)), He, 11.1(sss)))
We use Gated Recurrent Units (Cho et al. 2014) as RNN:
a: [e e, (NN) H.)
2: = (W + U-h+-1)
P: oWW -U)
h = (1 21) o h4-1 + 2₁ tanh(Waaa + UR(r: o h4-1)),
where is concatenation, (-) is activation function, and is a Hadamard operator. The imput is concatenation of four vectors: subject embedding, object embedding, aggregation of neighborhood representations, and global information vector (Cg, cr. 9 (s), H₂). (s(s) and H, are similarly de- fined. For (s)s), a concatenation of subject embedding, aggregation of neighborhood representations, and global information vector (es, (N,(s() Hi) is input. For H,, aggregation of the whole graph representations g(Gr) is input.
B DATASET
We use five datasets: 1) three event-based temporal knowledge graphs and 2) two knowledge graphs where temporally associated facts have meta-facts as (s. r, (e]) where t, is the starting time point and te is the ending time point. The first group of graphs includes Integrated Crisis Early Warning System (ICEWS18 (Boschee al. 2015) and ICEWS14 (Trivedi al. 2017). and Global Database of Events. Language, and Tone (GDELT) (eettaru & Schrodt 2013). The second group of graphs includes WIKI (Leblay & Chekol 2018) and YAGO (Mahdisoltani et al. 2014).
ICEWS18 is collected from 1/1/2018 to 10/31/2018, ICEWS14 is from 1/122014400 to 12/31/2014, and GDELT from 1/1/2018 to 1/31/2018. The ICEWS14 is from (Trivedi al. 2017). their version of the GDELT dataset since they didn't release the dataset.
We didn't use
WIKI and YAGO datasets have temporally associated facts (s, r,,,,, o, [4x, de)). We preprocess the datasets such that each fact is converted to {(s, r, o, (.),, o,, la + 12), (.....,. (s, r, o, (e)] where 1, is a unit time to ensure each fact has a sequence of events. Noisy events of early years are removed (before 1786 for WIKI and 1830 for YAGO).
The difference between the first group and the second group is that facts happen multiple times (even periodically) on the first group (event-based knowledge graphs) while facts last long time but are not likely to occur multiple times in the second group.
Dataset statistics are described on table
Table 3:
Dataset Statistics.
Data
N
Nyalid
Niest
Nent
Nyet
Time granularity
GDELT
1,734,399
238,765
305,241
7,691
240
15 mins
ICEWS18
373,018
45,995
49,545
23,033
256
24 hours
ICEWS14
323,895
341,409
12,498
260
24 hours
WIKI
539,286
67,538
63,110
12,554
24
year
YAGO
161,540
19,523
20,026
10,623
10
1 year
C DETAILED EXPERIMENTAL SETTINGS
Model details of RE-NET. We use Gated Recurrent Units (Cho al. 2014 as our recurrent event encoder, where the length of history is set as 10 which means saving past 10 event sequences. If the events related to s are sparse, we check the previous time steps until we get m previous time steps related to the entity s. We pretrain the parameters related to equations 5 and due to large size of training graphs. We use a multi-relational aggregator to compute H. The aggregator provides hidden representations for each node and max-pool over all hidden representations to get H,. At inference time, RE-NET performs multi-step prediction across the time stamps in dev and test sets. In each time step, sample 1000 (= M) number of subjects and save top- 1000 (= k) triples to use
13

---

Under review as a conference paper at ICLR 2020
Table 4: Performance comparison on ICEWS and GDELT datasets with raw metrics. We observe our method outperforms all other methods.
ICEWS18
GDELT
ICEWSI4
Method
MRR
H@]
H@3
H@ 10
MRR
H@) 1
H@ 3
H@ 10
MRR
H@l
H@3
H@ 10
Transti
12.37
34.65
7.84
0.00
8.92
23,30
11.17
32.29
DisMult
13.86
5.61
15.22
31.26
8.61
3.91
8.27
17.04
9.72
3.23
10.09
22.53
State
ComplEx
8.04
17.19
30.73
9.84
5.17
9.58
11.20
24.17
R R-GON
15.05
8.13
16.49
29.00
12.17
7.40
12.37
20.63
15.03
7.17
16.12
31.47
ConvE
22,81
13.63
25.83
41.43
18.37
11.29
19.36
32.13
21.32
12.83
23.45
38.44
RotatE
11.63
4.21
12.31
28.03
3,62
0,52
2.26
8.37
9.79
3.77
9.37
22.24
HyTE
7.41
3.10
7.33
16.01
6.69
0.01
7.57
19.06
7.72
1.65
7.94
20.16
TTransE
8.44
1.85
8.95
22.38
5.53
0.46
4,97
15.37
4.34
0.81
3.27
10:47
TA MisiiiMlllt
15.62
7.63
17.09
32.21
10.34
4.44
10.44
21.63
11.29
5.11
11,60
23.71
Frow-Fvalve*
0.11
0.00
0.00
0.47
0.11
0.00
0.02
0.10
0.05
0.00
0.00
0.10
Know Exolve+MLP
7.41
3.31
7.87
14.76
15.88
11.66
15.69
22.28
16.81
9.95
18.63
29.20
Temporal
DLRepsMLP
7.82
3.57
7.73
16.33
16.25
11.78
16.45
23.86
17.54
10.39
19.87
30.34
R-GCRN-MLP
23.46
14.24
26.62
41,96
18.63
11.33
19.80
32.42
21.39
12.74
23.60
38.96
RE-NET w/o multi step
25.67
44.65
11.87
20.34
22.55
1.3446
41.45
R.F NET wlo agg.
23.11
14.46
26.45
39.96
18.90
11.69
20.07
32.93
21.43
12.25
24.12
40.09
RE-NET w. mean agg.
15.76
19.03
11.78
20.20
13.52
25.47
41.48
R.F NET w. altn
25.76
16.07
29. 56
44,86
19.35
11.87
20.42
33.55
23.18
14.02
25.98
41.95
RE-NET
26.62
16.96
30.27
45.57
19.60
12.03
20.56
33.89
85
14.63
26.52
42.58
RE-NET GT (8.1)
27.87
18.12
31.60
46.94
21.29
13.99
22.53
35.59
24.88
15.63
27.55
43.63
them as a generated graph We set the size of entity/relation embeddings be 200 and embedding of unobserved embeddings are randomly initialized. We use two-layer RGCN in the RGCN aggregator with block dimension x The model is trained by the Adam optimizer (Kingma & Ba 2014). We set λι to 0.1, the learning rate to 0.001 and the weight decay rate to 0.00001. All experiments were done on GeForce GTX 1080 Ti.
Experimental Settings for Bascline Methods. In this section, we provide detailed settings for baselines. We use implementations of TransE and Dust We implemented TTransE and TA- DistMult based on the implementation of TransE and Distmult, respectively. For TA-DistMult, We use temporal tokens with the vocabulary of year, month and day on the ICEWS dataset and the vocabulary of year, month, day, hour and minute on the GDELT dataset. We use margin- -assdd ranking loss with L1 norm for TransE and use a binary cross-entropy loss for DistMult and Mu-DistMult, We validate the embedding size among 100 and 200. We set the batch size to 1024, margin to 1.0, negative sampling ratio to 1, and use the Adam optimizer.
We the implementation of ComplEx Han al. 2018). We validate the embedding size among 50, 100 and 200. The batch size is 100, the margin is 1.0, and the negative sampling ratio is 1. We use the Adagrad optimizer.
We use the implementation of Ty We use every timestamp as hyperplane. The embedding size is set to 128, the negative sampling ratio to 5, and margin to 1.0. We use time agnostic negative sampling (TANS) for entity prediction, and the Adam optimizer.
We use the codes for ConvE and use implementation by Deep Graph Library? Embedding sizes are 200 for both methods. We use to all negative sampling for ConvE and use 10 negative sampling ratio for RGCN, and use the Adam optimizer for both methods. We use the codes for Know-Evolve" For Know-Fxolve, we fix the issue in their codes. Issues are described in Section F default settings.
We follow their
We use the code for RotatE other values follow the best values for the larger FB FB15K dataset configurations supplied by the author. The author reports filtered metrics only, so we added the implementation of the raw setting.
10 The hidden layer/embedding size is set to 100, and batch size 256;
"https://github https//gggguuuoooo//ss/////o/wws "hups://gtthub.ccm
14

---

shows better Under review as a conference paper at ICLR 2020
RE-Net
ConvE
TA-DistMult
0.5
0.68
0.88
0.5
0.68
0.54
g 0.4
0.52
0.5
0.3
0.62
2058
2000
2016
2b1
2013
0.
2014
2016
201
10
15
30
1000
2000
3000
4020
5030
Haa
Year
(a) ICEWSI8 (MRR)
(b) GDELT (MRR)
(c) WIKI (MRR)
(d) YAGO (MRR)
Figure 6: Performance of temporal link prediction future time stamps. We report filtered MRR
(average metrics in %) on the test sets of ICEWS18,, GDELT, WIKI, and YAGO datasets.
Table 5: Performance comparison on temporal link prediction on three TKG datasets with filtered
metrics. RE-NET achieves the best results.
ICEWSI8
filtered
ICEWS14
filtered
WIKI
filtered
Method
MRR
H@1
H@3
H@
MRR
H@
H@3
H@10
MRR
H@:
H@3
H@ 10
R-GCN
23.19
16.36
25.34
36.48
26.31
18.23
30.43
45.34
37.57
37.4
39.66
41.90
ConvE
36.67
28.51
39.80
50.69
40.73
33.20
43.92
54.35
47.57
48 48.89
50.10
50,53
COnVE+RGON
24.59
17.77
27.19
37.41
27.76
20.23
30.13
42.16
38.76
38.46
40.88
43.12
EvalveRGCN
18.50
16.38
19.19
22,09
21.70
18.21
22.81
28.04
36.58
32.50
38.10
41,30
DynGiEM
0.001
dyngraph2vecAE
1.88
1.77
1.99
2.02
11.30
8.67
13.31
15.66
1.08
1.05
1.09
1.10
DynTriad
3.48
0
3.55
11.47
8.49
12:45
24.24
2.62
00.01
4.26
6.63
(NodeEsmbed
9.74
17.47
20.16
32.88
10.44
16.60
RE-NET
42,93
45.47
55.80
45.71
49.06
59.12
51.97
51.01
52.07
53.91
D ADDITIONAL EXPERIMENTS
D.1 RESULTS WITH RAW METRICS.
Table the performance comparison on ICEWS18, GDELT, ICEWS14 with raw settings. Our proposed RE-NET outperforms all other baselines. Figs. shows performance comparisons over different time stamps on the ICEWS18. GDELT, WIKI and YAGO datasets with filtered MRR. Our proposed RE-NET consistently outperform baselines over time.
D.2 COMPARISONS WITH CONVE+RGCN.
To examine aggregation techniques other baselines, we combine ConvE and R-GCN. We first run 2- 2-layered R-GCN over the training graph and then each node has its transformed representations. We run ConvE on this transformed representations. As in Table ConvE+R-GEn performances than R-GCN and worse performances than ConvE, which implies that the aggregation technique is not helpful to ConvE. However, aggregators our framework is a complementary and necessary component to the temporal part, which shows superiority over the baselines.
D.3 COMPARISONS
DYNAMIC METHODS.
Here compare method with dynamic methods on homogeneous graphs: EvolveGCN-O (Pareja ctt al. 2019), DynGEM (Goyal et al. 2018). dyngraph2vecAE (Goyal et al.. 2019). DynTriad (Zhou al. 2018b), and tNodeHmbed (Singer al., 2019). These methods interactions at future time on homogeneous graphs, while our proposed method for predicting (or knowledge graphs). Furthermore, those methods predict links at one future time stamp, whereas our method seeks to predict interactions at multiple future time stamps. We modified some methods apply them multi-relational graphs follows.
proposed to predict
interactions on multi-relational graphs
Experimental Settings. We adopt R-GCN (Schlichtkrull et al. 2018) for EvolveGCN-O and call EvOlveRGCN, We convert knowledge graphs into homogeneous graphs for vengraap2vecAAE The idea of this method is to reconstruct an adjacency matrix using auto-encoder and regard it adjacca
future adjacency matrix. If we keep relations, relation-specific adjacency matrices will be extremely sparse; the method learns to reconstruct near-zero adjacency matrices. tNodeEmbed is temporal method on homogeneous graphs. To use this on multi-relational graphs, we first train entity
15

---

Under review as a conference paper at ICLR 2020
Query (s, f ?)
History (r, o) with same different times
Answer
Accuse, ?)
(Criticite,
[ visit,
Statement,
Use force, Businessman Men)
Milittry, Use force, ?)
Arrest, Businessman)
( Aid, Citizen )
Men
President of South Africa
Use force,
Employ weapons,
2
--3
Figure 7: Case study of RE-NET's predictions. RE-NET's predictions depend interaction histories. Interaction histories are categorized into three cases: (1) consistent interactions with an object, (2) specific temporal pattern, and (3) irrelevant history. RE-NET achieves good performances on the first two cases, and poor performances on the third case.
embeddings with DistMult and set these initial embeddings for entities in tNodeEmbbed. Also give entity embeddings as input to LSTM of tNodeEmbed. We concatenate output of LSTM and relation embeddings to predict objects. We did modified other methods since is trivial to extend the methods.
Results. As shown in Table 5 RE-NET significantly outperforms the methods. Furthermore, all the dynamic methods do not show good performances. We conjecture that the methods are not designed for multi-relational graphs, and thus not capable of effectively handling multiple relations, which leads to degradation of their performances. Also, DynGEM is not suitable for our setting since it predicts edges based on observed edges future time stamps. However, in our setting, we are not given any observed edges future times stamps, it shows poor performances.
E CASE STUDY
In this section, we study RE-NET's predictions. Its predictions depend on interaction histories. We categorize histories into three cases: (1) consistent interactions with an object, (2) specific temporal pattern, and (3) irrelevant history. RE-NET can learn (1) and (2) cases, so it achieves high performances. For the first case, static methods cannot predict the answer since it does not see past interactions. However, RE-NET can predict the answer because it consistently interacts with object. The second case shows specific temporal patterns on relations: (Arrest, o )) - ( Use force, Without knowing this patter,, method might predict "Businessman" instead of "Men". RE-NET able to learn these temporal patterns so it can predict the second case. Lastly, the third case shows irrelevant history the answer and the history is not helpful predictions. RE-NET fails predict the third case.
F IMPLEMENTATION ISSUES OF KNOW-EVOLVE
We found problematic formulation in the Know-Evolve model and codes. The intensity function (equation 3 in (Trivedi et al. 2017 is defined as X (t(E) f f), where 9(-) is score function, / is current time, and is the most recent time point when either subject or object entity was involved in an event. This intensity function is used in inference rank entity candidates. However, they don't consider concurrent event at the same time stamps, and thus f will become t after one event. For example, we have events e (s, T, 01, t1), E2 = (s, 02, f1). After e1, f will become (subject s's most recent time point), and thus the value of intensity function for will be O. This problematic in inference since if t f, then the intensity function will always be 0 regardless of entity candidates. In inference, all object candidates are ranked by the intensity function. But all intensity scores for all candidates will 0 score. In their code, they give the highest ranks (first rank) for all entities including the ground truth object in this case. Thus, we fixed their code for a fair comparison; we give an average rank to entities who have the same scores.
(f)
since = [, which means all candidates have the same
G THEORETICAL ANALYSIS
Here we analyze the model capacity of RE-NET of capturing complex time-invariant local structure like (Hamilton et al. 2017), as well as the emerging global community structure as (You et al. 2018).
16

---

Under review as a conference paper at ICLR 2020
Theorem Les {G be the snapshot of temporal knowledge graph after T time-steps. Let h2 E R. U {8,} U {oi} to be the input feature representation for Algorithm of each entity node Suppose that there exists fixed positive constant C R* such that | h > C for all pair of all pair of entities v'. Then we have that Ve > 0, there exist a parameter setting è for RE-NET s.t. after K = 4 layers of aggregation,
heer Co.T. < <e,VU E VV E [T),
where N are output values generated by RE-NET and Co,r are clustering coefficients of (Gi)
Observation 1 Consider a temporal graph under stochastic block model described in Section G.2 Let h E R2, U E {st} U {or} to be the input feature representation for Algorithm 1 of each node. Suppose that a constant portion Pe of input representations can be linearly separated by hyperplane, while the representation of other nodes lies on the hyperplane. There exists a parameter setting of RE-NET that can output the probability that new node connected to node i.
G.1 PROOF FOR THEOREM 1
Using pooling aggregator of GraphSAGE, we can actually copy its behavior by setting recurrent weight matrix of the RNN model be In this case, we lose time-dependency our RE-NET and the representation model becomes time-invariant. However, RE-NET have exactly the same model capacity as GraphSAGE.
G.2 ANALYSIS FOR OBSERVATION
Here we define the generation process of our temporal graph. Assume that the generation process of the graph follows a stochastic block model, and there are two communities in the graph. Half of the nodes belong to community A and the other half belong to community B. Nodes within one community have probability Ps to be connected while other pairs have pa < ps probability to be connected. The edges in the graph are introduced into the graph in a time. Suppose a sequence of time-steps, new node is introduced the community and each edge is added to the graph.
This observation follows from three facts: (1) For each node V/ in the neighborhood ((v), using pooling aggregator, can detect their community assignment 8j. We assign the output of community to be +1 and the output of community B to be -1. (2) The error of incorrectly discerning the community of a node decrease exponentially with the number of links. For example let the node be in community A. Let the total number of nodes at time to be n4, by Hoeffding's 's incquality we have
P(
Σ
8j <)
exp( 2(p, W()
(3) Given the correct community classification, the relation classifier is able to predict the probability of linking nodes.
Combining these three facts, RE-NET able to infer the community structure the node.
17


Reviews:
[{"review_id": "rJxg-r9pFB", "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": "This paper properly applied several technique from RNN and graph neural networks to model dynamically-evolving, multi-relational graph data. There are two key component: a RNN to encode temporal information from the past event sequences, and a neighborhood aggregator collects the information from the neighbor nodes. The contribution on RNN part is design the loss and parameterizes the tuple of the graph. The contribution of the second part was adapting Multi-Relational Aggregator to this network. The paper is well-written. Although I'm familiar with the dataset, the analysis and comparison seems thorough. \n\nI'm leaning to reject or give borderline for this paper because (1) This paper is more like an application paper. Although the two component is carefully designed, the are more like direct application. I'm not challenge this paper is not good for the target task. But from the point of view on Machine learning / deep learning, there is not much insight from it. The technical difficult was more from how to make existing technique to fit this new problem.  This \"new\" problem seems more fit to data mining conference. (2) The experiments give tons of number but it lack of detailed analysis, like specific win/loss case of this model. As a more application-side paper, these concrete example can help the reader understand why this design outperform others. For example, it can show what the attention weights look like, and compare to the proposed aggregator. \n\nSome questions:\n[This question is directly related to my decision] Does this the first paper to apply autoregressive to knowledge graph? from related work, the answer is no. Can the author clarify more on this sentence? \n\n\"In contrast, our proposed method, RE-NET, augments a RNN with message passing procedure between entity neighborhood to encode temporal dependency between (concurrent) events (i.e., entity interactions), instead of using the RNN to memorize historical information about\nthe node representations.\"\n\nThe paper give complexity of this algorithm but no comments about how it compare with other method and how practical it is.\n\nIt lacks of some details for the model:\n(1) what is the RNN structure? \n(2) For the aggregator, what is the detailed formulation of h_o^0? \n ", "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 assessed the sensibility of the experiments.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I carefully checked the derivations and theory."}, "extra_text": {}}, {"review_id": "SkeXaQV0cr", "reviewer": "AnonReviewer3", "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": "The paper proposes a recurrent and autorgressive architecture to model temporal knowledge graphs and perform multi-time-step inference in the form of future link prediction. Specifically, given a historical sequence of graphs at discrete time points, the authors build sequential probabilistic approach to infer the next graph using joint over all previous graphs factorized into conditional distributions of subject, relation and the objects. The model is parameterized by a recurrent architecture that employs a multi-step aggregation to capture information within the graph at particular time step. The authors also propose a sequential approach to perform multi-step inference. The proposed method is evaluated on the task of future link prediction across several baselines, both static and dynamic, and ablation analysis is provided to measure the effect of each component in the architecture.\n\nThe authors propose to model temporal knowledge graphs with the key contribution being the sequential inference and augmentation of RNN with multi-step aggregation. The paper is well written in most parts and provides adequate details with some exceptions. I appreciate the extended ablation analysis as it helps to segregate the effect of each component very clearly. However, there are several major concerns which makes this paper weaker:\n\n- The paper approaches temporal knowledge graphs in discrete-time fashion where multiple events/edges are available at each time step. While this is intuitive, the authors fail to position the paper in light of various existing discrete-time approaches that focus on representation learning over evolving graphs [1,2,3,4,5]. Related work mentions [1] learns evolving representations but all these methods can do future link prediction and hence this is a big miss for the paper. A discussion and comparison with these approaches is certainly required as most of static and dynamic baselines currently compared also focus on learning representations, hence that is not a valid argument to miss comparison. \n\n- The baselines tested by the authors are either support static graphs, supports interpolation or supports continuous time data. However, as the authors explicitly propose a discrete time model starting from Section 3, it is important to perform experiments on atleast few of the discrete time baselines to demonstrate the efficacy of the proposed method. For instance, authors can augment relation as extra feature or use their encoders and optimization function to perform experiments e.g. Evolve-GCN  only require to replace GCN with R-GCN.\n\n- From the ablation it is clear that aggregation is the most important component as without it, the performance drops much closer to ConvE which is a static baseline and significantly worse than other RE-Net variants. However, the aggregation techniques are not novel contributions but augmentation to the RNN architecture. Hence it is important to show how augmenting aggregation module with other baselines (for instance, ConvE and TA-DistMult)) and the above mentioned discrete baselines would affect the performance of these baselines. \n\n- While the authors describe attentive Pooling Aggregator, the experiments only show mean aggregator and multi-step one. Is there a reason Attentive pooling is not used for any experiments? \n-It appears that global vector H_t is not playing significant role based on ablation study. Can the authors explain why that si the case? Also, what aggregation is used to compute H_t? Is it sum over all previous h_t's?\n\n- Algorithm 1 is not very clearly explained. When the authors mention that they only use one sample, does that mean a single subject is sampled at each time point t'? If so, how do you ensure the coverage is good across subjects in the newly generated graph? I admit I am not clear on this and would recommend the authors to elaborate in response and also in the paper. Also, the inference computation complexity is concerning. While it seems fine for the provided dataset, most real-world graphs have billion of nodes and I all of E, L and D would be larger for such graphs. This seems to put a strict limitation on scalability of inference module. \n\n- It is not clear what is the difference between RE-NET and RE-NET w. GT. Could the authors elaborate this more? It seems the authors do not update history when they perform RE-NET w/o multi-step. However, in the RE-NET w. GT, where is the ground truth history used in Algorithm 1?\n\n- The time span expansion for WIKI and YAGO is very unnatural and it is not clear if these experiments provide any value. For instance, can the authors show that in multi-step inference scheme, they can actually predict events at multiple time points corresponding to time span events in actual dataset? As multiple triplets can appear at consecutive time points, the current modification just makes them equivalent which doesn't seem correct. \n\nI am willing to revisit my score if the above concerns are appropriately addressed and requested experiments are provided.\n\n[1] Evolve-GCN: Evolving Graph Convolutional Networks for Dynamic Graphs, Pareja et. al.\n[2] DynGEM: Deep embedding method for dynamic graphs, Goyal et. al.\n[3] dyngraph2vec: Capturing network dynamics using dynamic graph representation learning, Goyal et. al.\n[4] Dynamic Network Embedding by Modeling Triadic Closure Process, Zhou et. al.\n[5] Node Embedding over Temporal Graphs, Singer et. al.", "extra_scores": {"experience_assessment": "I have published one or two papers in this area.", "review_assessment:_checking_correctness_of_derivations_and_theory": "N/A", "review_assessment:_checking_correctness_of_experiments": "I carefully checked the experiments.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper thoroughly."}, "extra_text": {}}, {"review_id": "HJl_y3iTFS", "reviewer": "AnonReviewer2", "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 presents the Re-Net model which sequentially generates a temporal knowledge graph (TKG) in an autoregressive fashion by taking both global and local information into account.\nThe generation of TKG is motivated via a joint distribution problem which is then parametrized by the usage of a recurrent event encoder.\nIn addition to past information, the encoder aggregates local as well as global information for which the authors propose three different aggregation schemes build upon the works of, e.g., attentive pooling and the RGCN model.\nIn an in-depth-evaluation study, the performance of the proposed model is evaluated on five different datasets on which it consistently improves upon the state-of-the-art.\nAn ablation study shows the benefits of all proposed features of Re-Net, e.g., the usage of more sophisticated aggregation schemes, the impact of using global information, and the number of RGCN layers.\n\nAs far as I know, the proposed method is a novel and clever (though not ground-breaking) contribution to the field of performing global structure inference over TGKs.\nThe paper is well-written but is partially becoming a little hard to comprehend due to its overloaded notation, e.g., $h_t(s)$ vs. $h_s^l$ and $N(s)_t$ vs. $N_t^{(s)}$ vs. $N_t^{(s,r)}$, and could be improved by a more rigorous formulation, e.g., for $N(s)_t$ or $c_s$ (which should also depend on r).\n\n1. Re-Net evolves the embeddings of entities and performs predictions via negative log likelihood. Hence, the model seems to be limited to predict events between entities which have been already seen during training and does not generalize to unseen entities. In addition, by applying a softmax classifier your model does not seem to be able to scale to large knowledge graphs? Are those observations correct and how could they be resolved?\n\n2. As far as I understood, the formulation of $N^{(s,r)}$ is not needed for defining the mean and attentive pooling aggregators since you are aggregating information independent of the relation type. However, the current formulation could confuse readers (including me).\n\n3. Algorithm 1 could be made more clear since the sampled number of M subjects does not get mentioned again. I guess the top-k triples are picked across all M samples and not individually? In addition, the sampling of subjects should relate to Equation 5 instead of Equation 4.\n\n4. In Figure 3 it is not clear why the accuracy does not decrease with temporal distance from the training examples. It would be helpful to interpret and clarify the results in more detail.\n\n5. I was not able to fully comprehend your complexity analysis. For example, it is not clear what $|E|$ means (I guess the maximum number of triples in a time step?). In addition, it seems that you are still dependent on computing node embeddings for all entities in your graph, even if you only report runtimes for computing a single example. In my opinion, there is a $L \\cdot |E|$ term missing in your complexity analysis for computing RGCN across the whole graph. Please clarify!\n\n6. The results of using the attentive aggregation scheme should be included into Tables 1 and 2.\n\n7. Since Figure 5c signalizes that Re-Net can effectively leverage larger receptive field sizes, how does it perform when increasing the number of layers further?\n\n------------------------\nUpdate after the rebuttal:\n\nI would like to thank the authors for answering my questions and clarifying several issues. The raised questions were not critical for my overall rating, which remains unchanged (6: Weak Accept).", "extra_scores": {"experience_assessment": "I have read many papers in this area.", "review_assessment:_checking_correctness_of_experiments": "I assessed the sensibility of the experiments.", "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_derivations_and_theory": "I assessed the sensibility of the derivations and theory."}, "extra_text": {}}]

Author rebuttal:

Meta-review: The paper proposes a recurrent and autorgressive architecture to model temporal knowledge graphs and perform multi-time-step inference in the form of future link prediction. However, the reviewers feel that the papers are more of a straight application of current techniques. Furthermore, a better presentation of the experimental section will also help improve the paper.  
Decision: Reject