Recurrent Event Network : Global Structure Inference Over Temporal Knowledge Graph

1 INTRODUCTION . Representation learning on dynamically-evolving , graph-structured data has emerged as an important problem in a wide range of applications , 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 single-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 a temporal knowledge graph or a 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 ( García-Durán 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 can not predict future events , as 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 can not model concurrent events occurring within the same time window—which often happens when event time stamps are discrete . It is thus desirable to have a 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 ( RE-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 ) 1Code and data have been uploaded and will be published upon acceptance of the paper . 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 . 1b for an illustration ) . Specifically , a recurrent event encoder , parametrized by RNNs , is used to summarize information of the past event sequences , and a neighborhood aggregator is employed to aggregate the information of concurrent events for the related entity within each time stamp . With the summarized information of the past event sequences , our decoder defines the joint probability of a current event . 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 a sequential manner . We evaluate our proposed method on temporal link prediction task , by testing the performance of multi-step inference over time on five public temporal knowledge graph datasets . Experimental results demonstrate that RE-NET outperforms state-of-the-art 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 in a distant future . 2 RELATED WORK . Our work is related to 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 on incorporating temporal information in modeling dynamic knowledge graphs . ( Trivedi et al. , 2017 ) presented Know-Evolve which models the occurrence of a fact as a temporal point process . However , this method is built on a problematic formulation when dealing with concurrent events , as shown in Section F. Several embedding-based methods have been proposed ( García-Durán et al. , 2018 ; Leblay & Chekol , 2018 ; Dasgupta et al. , 2018 ) to model time information . They embed the associate into a 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 can not generalize to unobserved time stamps . Temporal Modeling on Homogeneous Graphs . There are attempts on predicting future links on homogeneous graphs ( Pareja et al. , 2019 ; Goyal et al. , 2018 ; 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. , 2019 ; Zhou et al. , 2018b ; Singer et al. , 2019 ) , while other methods predict by reconstructing an adjacency matrix by using an autoencoder ( Goyal et al. , 2018 ; 2019 ) . These methods seek to predict on 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-relational ” knowledge graphs and aims for multi-step prediction ( i.e. , for t+ 1 , . . . , t+ k ) . Recurrent Graph Neural Models . There have been some studies on recurrent graph neural models for sequential or temporal graph-structured data ( Sanchez-Gonzalez et al. , 2018 ; Battaglia et al. , 2018 ; Palm et al. , 2018 ; Seo et al. , 2017 ; Pareja et al. , 2019 ) . These methods adopt a messagepassing framework for aggregating nodes ’ neighborhood information ( e.g. , via graph convolutional operations ) . GN ( Sanchez-Gonzalez et al. , 2018 ; Battaglia et al. , 2018 ) and RRN ( Palm et al. , 2018 ) update node representations by a message-passing 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 a single type of edge . In contrast to these studies , our work focuses on generating heterogeneous 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 an autoregressive fashion . 3 PROPOSED METHOD : RE-NET . We consider a temporal knowledge graph ( TKG ) as a multi-relational , directed graph with timestamped edges ( relationships ) between nodes ( entities ) . An event is defined as a time-stamped edge , i.e. , ( subject entity , relation , object entity , time ) and is denoted by a quadruple ( s , r , o , t ) or ( st , rt , ot ) . We denote a set of events at time t asGt . A TKG is built upon a sequence of event quadruples ordered ascending based on their time stamps , i.e. , { Gt } t = { ( si , ri , oi , ti ) } i ( with ti < tj , ∀i < j ) , where each time-stamped edge has a direction pointing from the subject entity to the object entity.2 The goal of learning generative models of events is to learn a distribution P ( G ) over temporal knowledge graphs , based on a set of observed event sets { G1 , ... , GT } . To model lasting events which span over a time range , i.e. , ( s , r , o , [ t1 , t2 ] ) , we simply partition such event into a sequence of time-stamp events { Gt1 , ... , Gt2 } . 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 eventsG = { G1 , ... , GT } in an autoregressive manner , i.e. , P ( G ) = ∏T t=1 P ( Gt|Gt−m : t−1 ) . Basically , we decompose the joint distribution into a sequence of conditional distributions ( e.g. , P ( Gt|Gt−m : t−1 ) ) , where we assume the probability of the events at a time step , e.g . Gt , only depends on the events at the previous m steps , e.g. , Gt−m : t−1 . For each conditional distribution P ( Gt|Gt−m : t−1 ) , we further assume that the events inGt are mutually independent given the previous events Gt−m : t−1 . In this way , the joint distribution can be rewritten as follows . P ( G ) = ∏ t ∏ ( st , rt , ot ) ∈Gt P ( st , rt , ot|Gt−m : t−1 ) = ∏ t ∏ ( st , rt , ot ) ∈Gt P ( ot|st , rt , Gt−m : t−1 ) · P ( rt|st , Gt−m : t−1 ) · P ( st|Gt−m : t−1 ) . ( 1 ) Intuitively , the generation process of each triplet ( st , rt , ot ) is defined as below . Given all the past events Gt−m : t−1 , we fist generate a subject entity st through the distribution P ( st|Gt−m : t−1 ) . Then we further generate a relation rt with P ( rt|st , Gt−m : t−1 ) , and finally the object entity ot is generated by defining P ( ot|st , rt , Gt−m : t−1 ) . In this work , we assume that P ( ot|st , rt , Gt−m : t−1 ) and P ( rt|st , Gt−m : t−1 ) depend only on events that are related to s , and focus on modeling the following joint probability : P ( st , rt , ot|Gt−m : t−1 ) = P ( ot|s , r , N ( s ) t−m : t−1 ) · P ( rt|s , N ( s ) t−m : t−1 ) · P ( st|Gt−m : t−1 ) , ( 2 ) 2The same triple ( s , r , o ) may occur multiple times in different time stamps , yielding different event quadruples . where Gt becomes N ( s ) t which is a set of neighboring entities interacted with subject entity s under all relations at time stamp t. For the third probability , the event sets should be considered since subject is not given . Next , we introduce how we parameterize these distributions . Recurrent Event Encoder . RE-NET parameterizes P ( ot|s , r , Gt−m : t−1 ) in the following way : P ( ot|s , r , N ( s ) t−m : t−1 ) ∝ exp ( [ es : er : ht−1 ( s , r ) ] > ·wot ) , ( 3 ) where es , er ∈ Rd are learnable embedding vectors specified for subject entity s and relation r. ht−1 ( s , r ) ∈ Rd is a history vector which encodes the information from the neighbor sets interacted with s in the past , as well as the global information from graph structures of Gt−1 : t−m . Basically , [ es : er : ht−1 ( s , r ) ] is an encoding to summarize all the past information . Based on that , we further compute the probability of different object entities ot by passing the encoding into a linear softmax classifier parameterized by { wot } . Similarly , we define the probabilities for relations and subjects as follows : P ( rt|s , N ( s ) t−m : t−1 ) ∝ exp ( [ es : ht−1 ( s ) ) ] > ·wrt ) , ( 4 ) P ( st|Gt−m : t−1 ) ∝ exp ( H > t−1 ·wst ) , ( 5 ) where ht−1 ( s ) captures all the local information about s in the past , and Ht−1 ∈ Rd is a vector representation to encode the global graph structures Gt−1 : t−m . For each time step t , since the hidden vectors ht−1 ( s ) , ht−1 ( s , r ) and Ht−1 preserve the information from the past events , and we update them in the following recurrent way : ht ( s , r ) = RNN1 ( g ( N ( s ) t ) , Ht , ht−1 ( s , r ) ) , ( 6 ) ht ( s ) = RNN2 ( g ( N ( s ) t ) , Ht , ht−1 ( s ) ) , ( 7 ) Ht = RNN3 ( g ( Gt ) , Ht−1 ) , ( 8 ) where g is an aggregation function , and N ( s ) t stands for all the events related to s at the current time step t. Intuitively , we obtain the current information related to s by aggregating all the related events at time t , i.e. , g ( N ( s ) t ) . Then we update the hidden vector ht ( s , r ) by using the aggregated information g ( N ( s ) t ) at the current step , the past value ht−1 ( s , r ) and also the global hidden vector Ht . The hidden vector ht ( s ) is updated in a similar way . For the aggregation of all events g ( Gt ) , we define g ( Gt ) = max ( { g ( N ( s ) t ) } s ) , which is from the element-wise max-pooling operation over all g ( N ( s ) t ) . We use Gated Recurrent Units Cho et al . ( 2014 ) as RNN . Details are described in Section A . 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 ( s ) t can contain multiple events . Designing effective aggregation functions g to aggregate information from N ( s ) t for s is therefore a nontrivial problem . Next , we introduce how we design g ( · ) in RE-NET .

Summary: 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.