Original: One-shot Learning for Temporal Knowledge Graphs
Revised: One-shot Learning for Temporal Knowledge Graphs

Original: Anonymous authors

Original: Abstract
Revised: Abstract

Original: Most real-world knowledge graphs are characterized by a frequency distribution with a long-tail where a signiﬁcant fraction of relations occurs only a handful of times.
Revised: Most real-world knowledge graphs are characterized by a frequency distribution with a long-tail where a signiﬁcant fraction of relations occurs only a handful of times.

Original: This observation has given rise to recent interest in low-shot learning methods that are able to generalize from only a few examples per relation.
Revised: This observation has given rise to recent interest in low-shot learning methods that are able to generalize from only a few examples per relation.

Original: The existing approaches, however, are tailored to static knowledge graphs and do not easily generalize to temporal settings, where data scarcity poses even bigger problems, e g., due to occurrence of new, previously unseen relations.
Revised: The existing approaches, however, are tailored to static knowledge graphs and do not easily generalize to temporal settings, where data scarcity poses even bigger problems, e.g., due to occurrence of new, previously unseen relations.

Original: We address this shortcoming by proposing a one-shot learning framework for link prediction in temporal knowledge graphs.
Revised: We address this shortcoming by proposing a one-shot learning framework for link prediction in temporal knowledge graphs.

Original: Our proposed method employs a self-attention mechanism to effectively encode temporal interactions between entities, and a network to compute a similarity score between a given query and a (one-shot) example.
Revised: Our proposed method employs a self-attention mechanism to effectively encode temporal interactions between entities, and a network to compute a similarity score between a given query and a (one-shot) example.

Original: Our experiments show that the proposed algorithm outperforms the state of the art baselines for two well-studied benchmarks while achieving signiﬁcantly better performance for sparse relations.
Revised: Our experiments show that the proposed algorithm outperforms the state of the art baselines for two well-studied benchmarks while achieving signiﬁcantly better performance for sparse relations.

Original: 1. Introduction
Revised: 1. Introduction

Original: Knowledge graphs (KGs) provide a principled way of representing factual information and have become a crucial component for performing various Natural Language Processing (NLP) tasks, including cross-lingual translation [Wang et al., 2018], Q&A [Yao and Van Durme, 2014] and information retrieval [Dietz et al., 2018].
Revised: Knowledge graphs (KGs) provide a principled way of representing factual information and have become a crucial component for performing various Natural Language Processing (NLP) tasks, including cross-lingual translation [Wang et al., 2018], Q&A [Yao and Van Durme, 2014] and information retrieval [Dietz et al., 2018].

Original: Semantic KGs such as YAGO [Kasneci et al., 2009] and WikiData [Vrandeˇci´c and Krötzsch, 2014] store facts as collections of triples in the form of (subject entity, relation, object entity), while Temporal Knowledge Graphs (TKGs) contain events presented as quadruples (subject entity, relation, object entity, t), where t is a time-labeling of the edges, that associates punctual dates to the occurrence of the interactions between the entities.
Revised: Semantic KGs such as YAGO [Kasneci et al., 2009] and WikiData [Vrandeˇci´c and Krötzsch, 2014] store facts as collections of triples in the form of (subject entity, relation, object entity), while Temporal Knowledge Graphs (TKGs) contain events presented as quadruples (subject entity, relation, object entity, t), where t is a time-labeling of the edges, that associates punctual dates to the occurrence of the interactions between the entities.

Original: Despite development of advanced extraction techniques, KGs are typically incomplete, which limits the performance and range of KG-based applications.
Revised: Despite development of advanced extraction techniques, KGs are typically incomplete, which limits the performance and range of KG-based applications.

Original: Recent research has focused on developing methods for predicting missing facts/events for static KGs [Trouillon et al., 2016, Xiong et al., 2017,
Revised: Recent research has focused on developing methods for predicting missing facts/events for static KGs [Trouillon et al., 2016, Xiong et al., 2017,

Original: Chen et al., 2018] and TKGs [Garcia-Duran et al., 2018, Xu et al., 2019, Wu et al., 2020].
Revised: Chen et al., 2018] and TKGs [Garcia-Duran et al., 2018, Xu et al., 2019, Wu et al., 2020].

Original: Most existing KG completion methods rely on a sufﬁciently large number of training examples per relation.
Revised: Most existing KG completion methods rely on a sufﬁciently large number of training examples per relation.

Original: However, most real-world KGs have a long-tail structure, i.e, many relations occur only a handful of times.
Revised: However, most real-world KGs have a long-tail structure, i.e, many relations occur only a handful of times.

Original: The data scarcity issue is exacerbated for temporal graphs, since the dynamics governing the evolution of those graphs might be highly non-stationary.
Revised: The data scarcity issue is exacerbated for temporal graphs, since the dynamics governing the evolution of those graphs might be highly non-stationary.

Original: First, new types
Revised: First, new types

Original: [Figure]

Original: [Figure]

Original: F r e q u e n c y

Original: [Figure]
Revised: [Figure]

Original: of relations/events
Revised: of relations/events

Original: might emerge that have not been observed before.
Revised: might emerge that have not been observed before.

Original: Furthermore, even if a given relation has been observed frequently over some time interval, the distribution of occurrences over that interval might be highly inhomogeneous and bursty.
Revised: Furthermore, even if a given relation has been observed frequently over some time interval, the distribution of occurrences over that interval might be highly inhomogeneous and bursty.

Original: Figure 1 shows that such non-stationarities exist for relations with different frequencies.
Revised: Figure 1 shows that such non-stationarities exist for relations with different frequencies.

Original: To alleviate this issue for static KGs, several recent studies have focused on adopting Few-Shot
Revised: To alleviate this issue for static KGs, several recent studies have focused on adopting Few-Shot

Original: Learning (FSL) methods for KG reasoning under the condition that only a few triples (shots) are available for each relation.
Revised: Learning (FSL) methods for KG reasoning under the condition that only a few triples (shots) are available for each relation.

Original: Xiong et al.
Revised: Xiong et al.

Original: 2018 and follow-up works [Chen et al., 2019, Wang et al., 2019a,b] aim to generate a similarity score to infer true entity pairs (subject, object) given the set of few training entity pairs for each relation.
Revised: 2018 and follow-up works [Chen et al., 2019, Wang et al., 2019a,b] aim to generate a similarity score to infer true entity pairs (subject, object) given the set of few training entity pairs for each relation.

Original: They obtain a representation for each entity pair through an encoder that aggregates the information from local neighborhood structure of each entity.
Revised: They obtain a representation for each entity pair through an encoder that aggregates the information from local neighborhood structure of each entity.

Original: However,
Revised: However,

Original: FSL methods developed for static KGs are not adequate in temporal settings.
Revised: FSL methods developed for static KGs are not adequate in temporal settings.

Original: Indeed, while data scarcity makes it even more imperative to consider temporal dependencies between events, existing static encoders designed for FSL methods [Xiong et al., 2018, Zhang et al., 2020, Du et al., 2019] are not able to incorporate such temporal dependencies that often contain crucial insights.
Revised: Indeed, while data scarcity makes it even more imperative to consider temporal dependencies between events, existing static encoders designed for FSL methods [Xiong et al., 2018, Zhang et al., 2020, Du et al., 2019] are not able to incorporate such temporal dependencies that often contain crucial insights.

Original: We address the above shortcomings of static FSL methods and propose One-shot Attention Temporal Graph Learning (OAT) for predicting new events for unseen relations and unseen timestamps in
Revised: We address the above shortcomings of static FSL methods and propose One-shot Attention Temporal Graph Learning (OAT) for predicting new events for unseen relations and unseen timestamps in

Original: TKGs when there is only one training example for each relation.
Revised: TKGs when there is only one training example for each relation.

Original: Our model can effectively encode an entity’s interactions with others from (cid:96) previous times and capture the temporal dependencies between entities.
Revised: Our model can effectively encode an entity’s interactions with others from (cid:96) previous times and capture the temporal dependencies between entities.

Original: It leverages a self-attention mechanism that sequentially aggregates an entity’s neighborhood over time and extracts a time-aware representation for each entity.
Revised: It leverages a self-attention mechanism that sequentially aggregates an entity’s neighborhood over time and extracts a time-aware representation for each entity.

Original: Furthermore, our model employs few-shot episodic training [Vinyals et al., 2016] to learn a similarity metric between a training entity pair and a given query entity pair, which indicates the likelihood of a given relation between the query entity pair.
Revised: Furthermore, our model employs few-shot episodic training [Vinyals et al., 2016] to learn a similarity metric between a training entity pair and a given query entity pair, which indicates the likelihood of a given relation between the query entity pair.

Original: Unlike other existing TKG methods [Garcia-Duran et al., 2018, Jin et al., 2019], our model is able to predict future occurrences of a new relation type based on one training example, and without the need to ﬁne-tune parameters to accommodate the new relation type.
Revised: Unlike other existing TKG methods [Garcia-Duran et al., 2018, Jin et al., 2019], our model is able to predict future occurrences of a new relation type based on one training example, and without the need to ﬁne-tune parameters to accommodate the new relation type.

Original: We also propose a new time-dependent approach to sample the training batch, and show its effectiveness over the random approach.
Revised: We also propose a new time-dependent approach to sample the training batch, and show its effectiveness over the random approach.

Original: Finally, we use past information to predict links in the future.
Revised: Finally, we use past information to predict links in the future.

Original: Thus, it is capable of extrapolation , e.g., given the graph upto time t 0 , inferring links for timestamps t > t 0 , which is not addressed in previous TKG completion studies.
Revised: Thus, it is capable of extrapolation , e.g., given the graph upto time t 0 , inferring links for timestamps t > t 0 , which is not addressed in previous TKG completion studies.

Original: This helps to populate the KG for future timestamps which could be of potential beneﬁt for various applications.
Revised: This helps to populate the KG for future timestamps which could be of potential beneﬁt for various applications.

Original: Our contributions are as follows: (1) We formulate one-shot learning for TKGs, which improves upon existing low-shot techniques for static graphs, (2) We propose a temporal neighborhood encoder with a self-attention mechanism that effectively extracts the temporally-resolved neighborhood information for each entity, (3) We conduct experiments on two real-world datasets and demonstrate the superiority of the proposed model over state-of-the-art baselines, and (4) We construct two new publicly-available benchmarks for one-shot learning over TKGs.
Revised: Our contributions are as follows: (1) We formulate one-shot learning for TKGs, which improves upon existing low-shot techniques for static graphs, (2) We propose a temporal neighborhood encoder with a self-attention mechanism that effectively extracts the temporally-resolved neighborhood information for each entity, (3) We conduct experiments on two real-world datasets and demonstrate the superiority of the proposed model over state-of-the-art baselines, and (4) We construct two new publicly-available benchmarks for one-shot learning over TKGs

Original: 2. Related Work
Revised: 2. Related Work

Original: Our work is related to representation learning for temporal relational graphs, low-shot learning methods, and recent developments of meta-learning approaches for graphs.
Revised: Our work is related to representation learning for temporal relational graphs, low-shot learning methods, and recent developments of meta-learning approaches for graphs.

Original: Low-Shot Learning.
Revised: Low-Shot Learning.

Original: An effective approach for low-shot learning is based on learning a similarity metric and a ranking function using training triples [Koch et al., 2015, Vinyals et al., 2016, Snell et al., 2017, Mishra et al., 2018].
Revised: An effective approach for low-shot learning is based on learning a similarity metric and a ranking function using training triples [Koch et al., 2015, Vinyals et al., 2016, Snell et al., 2017, Mishra et al., 2018].

Original: Siamese networks [Koch et al., 2015] use a pairwise loss to learn a metric between input representations in an embedding space and then use the learned metric to perform nearest-neighbors separately.
Revised: Siamese networks [Koch et al., 2015] use a pairwise loss to learn a metric between input representations in an embedding space and then use the learned metric to perform nearest-neighbors separately.

Original: Matching networks [Vinyals et al., 2016] learn a function to embed input features in a low-dimensional space and then use cosine similarity in a kernel for classiﬁcation.
Revised: Matching networks [Vinyals et al., 2016] learn a function to embed input features in a low-dimensional space and then use cosine similarity in a kernel for classiﬁcation.

Original: Prototypical networks [Snell et al., 2017] compute a prototype for each class in an embedding space and then classify an input using the distance to the prototypes in the embedding.
Revised: Prototypical networks [Snell et al., 2017] compute a prototype for each class in an embedding space and then classify an input using the distance to the prototypes in the embedding.

Original: SNAIL [Mishra et al., 2018] uses temporal convolution to aggregate information from past experiences and causal attention layers to select important information from past experiences.
Revised: SNAIL [Mishra et al., 2018] uses temporal convolution to aggregate information from past experiences and causal attention layers to select important information from past experiences.

Original: Another paradigm of low-shot learning includes optimization-based approaches that usually include a neural network to control and optimize the parameters of the main network.
Revised: Another paradigm of low-shot learning includes optimization-based approaches that usually include a neural network to control and optimize the parameters of the main network.

Original: One example is MAML
Revised: One example is MAML

Original: [Finn et al., 2017] which learns how to generalize with only a few examples for gradient updates.
Revised: [Finn et al., 2017] which learns how to generalize with only a few examples for gradient updates.

Original: Relation Learning for TKGs.
Revised: Relation Learning for TKGs.

Original: TKG completion methods can be broadly categorized into translationbased methods, and evolving methods, based on their approach in encoding time information.
Revised: TKG completion methods can be broadly categorized into translationbased methods, and evolving methods, based on their approach in encoding time information.

Original: The ﬁrst category [Leblay and Chekol, 2018, Garcia-Duran et al., 2018, Dasgupta et al., 2018, Wang and
Revised: The ﬁrst category [Leblay and Chekol, 2018, Garcia-Duran et al., 2018, Dasgupta et al., 2018, Wang and

Original: Li, 2019, Jain et al., 2020] considers a distinct lower dimensional space such as a vector [Leblay and
Revised: Li, 2019, Jain et al., 2020] considers a distinct lower dimensional space such as a vector [Leblay and

Original: Chekol, 2018, Jain et al., 2020] or a hyperplane [Dasgupta et al., 2018, Wang and Li, 2019] for the event timestamps and deﬁnes a function to map an initial embedding to a time-aware embedding.
Revised: Chekol, 2018, Jain et al., 2020] or a hyperplane [Dasgupta et al., 2018, Wang and Li, 2019] for the event timestamps and deﬁnes a function to map an initial embedding to a time-aware embedding.

Original: Evolving models assume a dynamic representation for entities or relations that is being updated over time.
Revised: Evolving models assume a dynamic representation for entities or relations that is being updated over time.

Original: Such dynamics can be captured by a shallow encoder [Xu et al., 2019, Han et al., 2020a] or a sequential neural network [Trivedi et al., 2017, Jin et al., 2019, Wu et al., 2020, Zhu et al., 2020,
Revised: Such dynamics can be captured by a shallow encoder [Xu et al., 2019, Han et al., 2020a] or a sequential neural network [Trivedi et al., 2017, Jin et al., 2019, Wu et al., 2020, Zhu et al., 2020,

Original: Han et al., 2020b,c].
Revised: Han et al., 2020b,c].

Original: Xu et al.
Revised: Xu et al.

Original: 2019 model the entities & relations as timeseries, and decompose the timeseries into three components using adaptive timeseries decomposition.
Revised: 2019 model the entities & relations as timeseries, and decompose the timeseries into three components using adaptive timeseries decomposition.

Original: DyERNIE
Revised: DyERNIE

Original: [Han et al., 2020a] proposes a non-Euclidean embedding approach in the hyperbolic space.
Revised: [Han et al., 2020a] proposes a non-Euclidean embedding approach in the hyperbolic space.

Original: Trivedi et.
Revised: Trivedi et.

Original: al.represents events as the point processes, and Jin et.
Revised: al.represents events as the point processes, and Jin et.

Original: al.
Revised: al.

Original: [Jin et al., 2019] aggregates the one-hop entity neighborhood at each timestamp by a pooling layer, and passes it to an RNN.
Revised: [Jin et al., 2019] aggregates the one-hop entity neighborhood at each timestamp by a pooling layer, and passes it to an RNN.

Original: Low-shot Learning for Graphs.
Revised: Low-shot Learning for Graphs.

Original: Metric based FSL models for graphs [Xiong et al., 2018, Chen et al., 2019, Zhang et al., 2020] adopt few-shot episodic training proposed by Vinyals et al.for few-shot link prediction over new unseen relations.
Revised: Metric based FSL models for graphs [Xiong et al., 2018, Chen et al., 2019, Zhang et al., 2020] adopt few-shot episodic training proposed by Vinyals et al.for few-shot link prediction over new unseen relations.

Original: In contrast, Beck et al.
Revised: In contrast, Beck et al.

Original: propose a FSL framework to address the unseen entities.
Revised: propose a FSL framework to address the unseen entities.

Original: These methods are usually composed of two components (i) an encoder that maps the support set to a low dimensional embedding, and (ii) a similarity network to compute the similarity score between the support set representation and a query.
Revised: These methods are usually composed of two components (i) an encoder that maps the support set to a low dimensional embedding, and (ii) a similarity network to compute the similarity score between the support set representation and a query.

Original: Xiong et.
Revised: Xiong et.

Original: al.
Revised: al.

Original: 2018,Du et.
Revised: 2018, Du et.

Original: al.
Revised: al.

Original: 2019, and Zhang et.
Revised: 2019, and Zhang et.

Original: al.
Revised: al.

Original: 2020 learn a representation for entities from their one-hop neighborhood.
Revised: 2020 learn a representation for entities from their one-hop neighborhood.

Original: [Xiong et al., 2018] assumes that all the neighbors contribute equally, while Zhang et.
Revised: [Xiong et al., 2018] assumes that all the neighbors contribute equally, while Zhang et.

Original: al.
Revised: al.

Original: 2020 assigns an attention weight to each neighbor.
Revised: 2020 assigns an attention weight to each neighbor.

Original: Sheng et.al.deﬁne a similarity score between a relation and the task relation and allows the neighborhood encoder to be dynamically adaptive to the task.
Revised: Sheng et.al.deﬁne a similarity score between a relation and the task relation and allows the neighborhood encoder to be dynamically adaptive to the task.

Original: MetaR [Chen et al., 2019] does not consider neighborhood interactions explicitly, and embeds a pair ( s, o ) independently using L fully connected layers.
Revised: MetaR [Chen et al., 2019] does not consider neighborhood interactions explicitly, and embeds a pair ( s, o ) independently using L fully connected layers.

Original: Qin et.al.
Revised: Qin et.al.

Original: 2020 studies zero-shot learning for relations using a generative adversarial network, where the generator tries to generate relations embeddings from text descriptions that are similar to the real embeddings.
Revised: 2020 studies zero-shot learning for relations using a generative adversarial network, where the generator tries to generate relations embeddings from text descriptions that are similar to the real embeddings.

Original: [Wang et al., 2019b, Baek et al., 2020] focus on rare or unseen entities; Wang et.
Revised: [Wang et al., 2019b, Baek et al., 2020] focus on rare or unseen entities; Wang et.

Original: al. 2019b addresses this issue by incorporating entities textual description into the model.
Revised: al. 2019b addresses this issue by incorporating entities textual description into the model.

Original: They further improve the performance by generating triples during training.
Revised: They further improve the performance by generating triples during training.

Original: Baek et.al.
Revised: Baek et.al.

Original: 2020 leverage the episodic training framework, but unlike previous methods, a task is associated with an entity.
Revised: 2020 leverage the episodic training framework, but unlike previous methods, a task is associated with an entity.

Original: Unlike similarity-based approaches [Lv et al., 2019, Wang et al., 2019a] adopt the optimization-based meta-learning proposed in MAML [Finn et al., 2017].
Revised: Unlike similarity-based approaches [Lv et al., 2019, Wang et al., 2019a] adopt the optimization-based meta-learning proposed in MAML [Finn et al., 2017].

Original: The core of these approaches is to learn a parameter θ ∗ which can later be used as a good initialization for a new unseen task, and the model can be adapted to the new task with only a few gradient update steps.
Revised: The core of these approaches is to learn a parameter θ ∗ which can later be used as a good initialization for a new unseen task, and the model can be adapted to the new task with only a few gradient update steps.

Original: These approaches all assume a static graph.
Revised: These approaches all assume a static graph.

Original: To the best of our knowledge, we are the ﬁrst to study one-shot learning for TKGs.
Revised: To the best of our knowledge, we are the ﬁrst to study one-shot learning for TKGs.

Original: 3. Problem Formulation
Revised: 3. Problem Formulation

Original: In this section, we present the formal deﬁnition of the one-shot link prediction problem for TKGs.
Revised: In this section, we present the formal deﬁnition of the one-shot link prediction problem for TKGs.

Original: 3.1 Temporal Knowledge Graph Completion
Revised: 3.1 Temporal Knowledge Graph Completion

Original: A TKG is a collection of events represented as a set of quadruples G = { ( s, r, o, t ) | s, o ∈ E , r ∈ R} , where E and R are the set of entities and relations, and t is the event timestamp.
Revised: A TKG is a collection of events represented as a set of quadruples G = { ( s, r, o, t ) | s, o ∈ E , r ∈ R} , where E and R are the set of entities and relations, and t is the event timestamp.

Original: Static KG completion involves predicting new facts by inferring either a relation r between two existing entities s and o , or predicting the object entity o given the subject entity s and a relation r .
Revised: Static KG completion involves predicting new facts by inferring either a relation r between two existing entities s and o , or predicting the object entity o given the subject entity s and a relation r .

Original: In this work, we are interested in the later, but at a particular timestamp t .
Revised: In this work, we are interested in the later, but at a particular timestamp t .

Original: More formally, given an object query ( s, r, ? , t ) and a set of candidates C , the goal is to assign a likelihood to each entity, such that the true object entity is ranked higher than the other candidates in C .
Revised: More formally, given an object query ( s, r, ? , t ) and a set of candidates C , the goal is to assign a likelihood to each entity, such that the true object entity is ranked higher than the other candidates in C .

Original: The likelihood is estimated by a scoring function P , usually parameterized by a neural network.
Revised: The likelihood is estimated by a scoring function P , usually parameterized by a neural network.

Original: We assume that the likelihood of an event depends not only on the current state of the graph, but also on the history of events from previous (cid:96) timesteps { t − (cid:96), . . .
Revised: We assume that the likelihood of an event depends not only on the current state of the graph, but also on the history of events from previous (cid:96) timesteps { t − (cid:96), . . .

Original: , t − 2 , t − 1 } .
Revised: , t − 2 , t − 1 } .

Original: In Section 4.1 we explain how to encode events’ temporal information.
Revised: In Section 4.1 we explain how to encode events’ temporal information.

Original: 3.2 Few-shot Learning and Episodic Training
Revised: 3.2 Few-shot Learning and Episodic Training

Original: Generally, FSL focuses on building and training a model with only a few labeled instances for each class.
Revised: Generally, FSL focuses on building and training a model with only a few labeled instances for each class.

Original: Episodic training is a meta-learning framework for FSL proposed by Vinyals et al. 2016 and involves learning a model over a large set of tasks.
Revised: Episodic training is a meta-learning framework for FSL proposed by Vinyals et al. 2016 and involves learning a model over a large set of tasks.

Original: Intuitively, each episode can be considered as a mini-training procedure with a training and a test set denoted as support and query set, respectively.
Revised: Intuitively, each episode can be considered as a mini-training procedure with a training and a test set denoted as support and query set, respectively.

Original: At each iteration (episode), the training and test sets are sampled independently and an objective function l θ is calculated over the test set.
Revised: At each iteration (episode), the training and test sets are sampled independently and an objective function l θ is calculated over the test set.

Original: The goal is to learn a meta-model that maps a given (possibly unseen) support set to a model that performs effectively for the given query set.
Revised: The goal is to learn a meta-model that maps a given (possibly unseen) support set to a model that performs effectively for the given query set.

Original: More speciﬁcally, assume we have a large set of tasks T
Revised: More speciﬁcally, assume we have a large set of tasks T

Original: = {T i =
Revised: = {T i =

Original: ( S i , Q i ) } Ni =1 where S i and Q i are the support and query set of task
Revised: ( S i , Q i ) } Ni =1 where S i and Q i are the support and query set of task

Original: T i , the probabilistic optimization objective for this problem is given as:
Revised: T i , the probabilistic optimization objective for this problem is given as:

Original: [Equation]
Revised: [Equation]

Original: We adopt the standard episodic training framework in Eq.
Revised: We adopt the standard episodic training framework in Eq.

Original: (1) for the purpose of TKG completion.
Revised: (1) for the purpose of TKG completion.

Original: 3.3 One-shot TKG Setup
Revised: 3.3 One-shot TKG Setup

Original: As mentioned earlier, data scarcity is even a bigger problem in relational learning with TKGs.
Revised: As mentioned earlier, data scarcity is even a bigger problem in relational learning with TKGs.

Original: Fewshot episodic training has been proven to be effective to tackle this problem for static KGs [Xiong et al., 2018].
Revised: Fewshot episodic training has been proven to be effective to tackle this problem for static KGs [Xiong et al., 2018].

Original: We further extend the framework proposed by Xiong et al.
Revised: We further extend the framework proposed by Xiong et al.

Original: 2018 for TKG completion.
Revised: 2018 for TKG completion.

Original: ( s i ,r,o i ,t i ) t i + w t
Revised: ( s i ,r,o i ,t i ) t i + w t

Original: i
Revised: i

Original: Q t i r S r (a) Query and support set construction
Revised: Q t i r S r (a) Query and support set construction

Original: Start
Revised: Start

Original: End
Revised: End

Original: G train
Revised: G train

Original: G val
Revised: G val

Original: G test (b) Train, validation and test split across time
Revised: G test (b) Train, validation and test split across time

Original: Given a TKG, G = { ( s, r, o, t ) | s, o ∈ E , r ∈ R} , the relations in R are divided into two groups based on their frequency: frequent relations F and sparse relations T .
Revised: Given a TKG, G = { ( s, r, o, t ) | s, o ∈ E , r ∈ R} , the relations in R are divided into two groups based on their frequency: frequent relations F and sparse relations T .

Original: The sparse relations are used to build the task set needed by the model for the episodic training.
Revised: The sparse relations are used to build the task set needed by the model for the episodic training.

Original: Each task corresponds to a relation r ∈ T with its own training (support) and test (query) set, i.e. T r = ( S r , Q r ) where S r includes one reference entity pair at a speciﬁc time and Q r is a set of query entity pairs, formally deﬁned as:
Revised: Each task corresponds to a relation r ∈ T with its own training (support) and test (query) set, i.e. T r = ( S r , Q r ) where S r includes one reference entity pair at a speciﬁc time and Q r is a set of query entity pairs, formally deﬁned as:

Original: [Equation]
Revised: [Equation]

Original: Given a relation r ∈ T and its reference set S r , one-shot TKG completion is to complete a given query ( s q , r, o q , t q ) where the object entity o q ∈ E is missing.
Revised: Given a relation r ∈ T and its reference set S r , one-shot TKG completion is to complete a given query ( s q , r, o q , t q ) where the object entity o q ∈ E is missing.

Original: At each episode, a relation r is selected randomly along with a quadruple containing that relation to form the support set.
Revised: At each episode, a relation r is selected randomly along with a quadruple containing that relation to form the support set.

Original: The query set can be selected in two ways: (i)
Revised: The query set can be selected in two ways: (i)

Original: Random : We randomly select m positive quadruples containing r from all the quadruples in G (ii)
Revised: Random : We randomly select m positive quadruples containing r from all the quadruples in G (ii)

Original: Time dependent : The quadruples of the query set are restricted by their distance from the support set timestamp.
Revised: Time dependent : The quadruples of the query set are restricted by their distance from the support set timestamp.

Original: More speciﬁcally, if the support quadruple timestamp is τ the time-dependent query set Q τr is deﬁned as:
Revised: More speciﬁcally, if the support quadruple timestamp is τ the time-dependent query set Q τr is deﬁned as:

Original: [Equation]
Revised: [Equation]

Original: where I τ =
Revised: where I τ =

Original: ( τ, τ + w ] and the w is called the episode length .
Revised: ( τ, τ + w ] and the w is called the episode length .

Original: Figure 2a illustrates the time constraint for selecting the query quadruples.
Revised: Figure 2a illustrates the time constraint for selecting the query quadruples.

Original: Sampling procedure for the support and query set are provided in
Revised: Sampling procedure for the support and query set are provided in

Original: Section 4.3.
Revised: Section 4.3.

Original: The loss function l θ at each episode optimizes a score function P θ such that it assigns a higher score to the true query events than the other events.
Revised: The loss function l θ at each episode optimizes a score function P θ such that it assigns a higher score to the true query events than the other events.

Original: P θ represents the similarity of a given query and the support set, and is proportional the event likelihood.
Revised: P θ represents the similarity of a given query and the support set, and is proportional the event likelihood.

Original: The ﬁnal optimization loss is:
Revised: The ﬁnal optimization loss is:

Original: [Equation]
Revised: [Equation]

Original: The relations in T are divided into mutually exclusive sets: T meta − train , T meta − test , T meta − val .
Revised: The relations in T are divided into mutually exclusive sets: T meta − train , T meta − test , T meta − val .

Original: From this, G train is deﬁned as G train =
Revised: From this, G train is deﬁned as G train =

Original: { ( s, r, o, t ) | r ∈ T meta − train } , with G val and G test deﬁned similarly.
Revised: { ( s, r, o, t ) | r ∈ T meta − train } , with G val and G test deﬁned similarly.

Original: We do not allow any time overlap between the quadruples in G train , G val and G test since we are doing extrapolation and we do not want any information from the future timestamps to be given to the model.
Revised: We do not allow any time overlap between the quadruples in G train , G val and G test since we are doing extrapolation and we do not want any information from the future timestamps to be given to the model.

Original: Figure 2b depicts the time split for G train , G val and G test .
Revised: Figure 2b depicts the time split for G train , G val and G test .

Original: Finally, we assume that the model has access to a background knowledge graph deﬁned as G (cid:48)
Revised: Finally, we assume that the model has access to a background knowledge graph deﬁned as G (cid:48)

Original: = { ( s, r, o, t ) | s, o ∈ E , r ∈ F} , and the entity set E is a closed set, i.e., there are no unseen entities during the inference time.
Revised: = { ( s, r, o, t ) | s, o ∈ E , r ∈ F} , and the entity set E is a closed set, i.e., there are no unseen entities during the inference time.

Original: 4. Model
Revised: 4. Model

Original: Our key idea is to represent a relation r by the entity pair in their support set S r = { ( s 0 , o 0 , t 0 ) } .
Revised: Our key idea is to represent a relation r by the entity pair in their support set S r = { ( s 0 , o 0 , t 0 ) } .

Original: The similarity score P θ (( s q , o q , t q ) , S r ) between a query ( s q , o q , t q ) and the support set representation determines the likelihood of the event ( s q , r, o q , t q ) .
Revised: The similarity score P θ (( s q , o q , t q ) , S r ) between a query ( s q , o q , t q ) and the support set representation determines the likelihood of the event ( s q , r, o q , t q ) .

Original: For any task T r (even unseen during the
Revised: For any task T r (even unseen during the

Original: N ( t −) N ( t −)
Revised: N ( t −) N ( t −)

Original: N ( t − (cid:96) )
Revised: N ( t − (cid:96) )

Original: f η
Revised: f η

Original: SnapshotEncoder x ( t −) x ( t −) x
Revised: SnapshotEncoder x ( t −) x ( t −) x

Original: ( t − (cid:96) )
Revised: ( t − (cid:96) )

Original: Att
Revised: Att

Original: MultiheadAttention z ( t −) z ( t −)
Revised: MultiheadAttention z ( t −) z ( t −)

Original: z ( t − (cid:96) )
Revised: z ( t − (cid:96) )

Original: W ∗ h e (a) Neighborhood Encoder
Revised: W ∗ h e (a) Neighborhood Encoder

Original: h s v
Revised: h s v

Original: s h o v
Revised: s h o v

Original: o h s v s h o v o query support
Revised: o h s v s h o v o query support

Original: M score
Revised: M score

Original: M ( q )
Revised: M ( q )

Original: M ( s ) (b) Similarity Network training), this enables the model to predict the likelihood of a given query event for relation r , as long as one reference example ( s 0 , o 0 , t 0 )
Revised: M ( s ) (b) Similarity Network training), this enables the model to predict the likelihood of a given query event for relation r , as long as one reference example ( s 0 , o 0 , t 0 )

Original: ∈ S r is given to the model during the inference.
Revised: ∈ S r is given to the model during the inference.

Original: To achieve the aforementioned goal, we propose a model that is built upon two steps: (i) obtaining the representation for the support set and query entity pairs, and (ii) computing the similarity of the support set and a query instance.
Revised: To achieve the aforementioned goal, we propose a model that is built upon two steps: (i) obtaining the representation for the support set and query entity pairs, and (ii) computing the similarity of the support set and a query instance.

Original: Our model consists of two main components (Figure 3), as follows:
Revised: Our model consists of two main components (Figure 3), as follows:

Original: Neighborhood Encoder  neighborhood  the neighborhood information of  d dimensional
Revised: Neighborhood Encoder . The neighborhood encoder represents the neighborhood information of a given entity e as a d -dimensional vector h e .

Original: It encodes an entity’s one neighborhood in the graph during the previous  a 
Revised: It encodes an entity’s one-hop neighborhood in the graph during the previous (cid:96) timesteps as a sequence.

Original: In Section 1 we explain the detail of obtaining  the 
Revised: In Section 4.1 we explain the detail of obtaining a test query and support set representation via the encoder.

Original: Similarity Network .
Revised: Similarity Network .

Original: A similarity function parameterized by a neural network, P θ (( s q , o q , t q ) , S r ) , that outputs a scalar similarity score between a query pair ( s q , o q , t q ) , and the support set S r .
Revised: A similarity function parameterized by a neural network, P θ (( s q , o q , t q ) , S r ) , that outputs a scalar similarity score between a query pair ( s q , o q , t q ) , and the support set S r .

Original: The similarity score indicates the likelihood of the query event ( s q , r, o q , t q ) .
Revised: The similarity score indicates the likelihood of the query event ( s q , r, o q , t q ) .

Original: 4.1 Neighborhood Encoder
Revised: 4.1 Neighborhood Encoder

Original: For a given entity e , we deﬁne N τ ( e ) = { ( r j , e j ) | ( e, r j , e j , τ ) ∈ G (cid:48) } to be the one-hop neighborhood of e at time τ , and e ’s temporal neighborhood N ( e ) is the set of all e ’s interactions within the previous (cid:96) timestamps, i.e. N ( e )
Revised: For a given entity e , we deﬁne N τ ( e ) = { ( r j , e j ) | ( e, r j , e j , τ ) ∈ G (cid:48) } to be the one-hop neighborhood of e at time τ , and e ’s temporal neighborhood N ( e ) is the set of all e ’s interactions within the previous (cid:96) timestamps, i.e. N ( e )

Original: = (cid:83)
Revised: = (cid:83)

Original: τ ∈
Revised: τ ∈

Original: [ t − (cid:96),t − 1] N τ ( e ) .
Revised: [ t − (cid:96),t − 1] N τ ( e ) .

Original: The neighborhood encoder is comprised of two parts: (i) function f η that encodes the one-hop neighborhood at a given timestamp τ , and (ii) function g , that utilizes the output of function f η , at previous timesteps, to generate a temporal neighborhood representation.
Revised: The neighborhood encoder is comprised of two parts: (i function f η that encodes the one-hop neighborhood at a given timestamp τ , and (ii) function g , that utilizes the output of function f η , at previous timesteps, to generate a temporal neighborhood representation.

Original: Any pooling layer can be selected for f η and g , however, we show that the model can signiﬁcantly beneﬁt from the use of a sequential model as g .
Revised: Any pooling layer can be selected for f η and g , however, we show that the model can signiﬁcantly beneﬁt from the use of a sequential model as g .

Original: 4.1.1 S NAPSHOT A GGREGATION.
Revised: 4.1.1 S NAPSHOT A GGREGATION

Original: The snapshot aggregator f η aggregates local neighborhood information at a speciﬁc time τ .
Revised: The snapshot aggregator f η aggregates local neighborhood information at a speciﬁc time τ .

Original: [Equation]
Revised: [Equation]

Original:  where C e τ is a normalizing factor, v e j ∈ R d × 1 , v r j ∈ R d × 1 are entity and relation representations, and
Revised: [Equation] where C e τ is a normalizing factor, v e j ∈ R d × 1 , v r j ∈ R d × 1 are entity and relation representations, and

Original: W ∈ R 2 d × d and b ∈ R d × 1 are model parameters to be learnt.
Revised: W ∈ R 2 d × d and b ∈ R d × 1 are model parameters to be learnt.

Original: The concatenation is shown as [:] and σ ( . ) is a nonlinear activation function ( Relu in our implementation).
Revised: The concatenation is shown as [:] and σ ( . ) is a nonlinear activation function ( Relu in our implementation).

Original: 4.1.2 S EQUENTIAL A GGREGATION
Revised: 4.1.2 S EQUENTIAL A GGREGATION

Original: Function g aggregates the sequence of snapshots from previous l timesteps { t − (cid:96), . . .
Revised: Function g aggregates the sequence of snapshots from previous l timesteps { t − (cid:96), . . .

Original: , t − 2 , t − 1 } .
Revised: , t − 2 , t − 1 } .

Original: To effectively capture the temporal dependencies between the timestamps, we use a sequential neural network.
Revised: To effectively capture the temporal dependencies between the timestamps, we use a sequential neural network.

Original: The sequential encoder employs the self-attention mechanism proposed in [Vaswani et al., 2017].
Revised: The sequential encoder employs the self-attention mechanism proposed in [Vaswani et al., 2017].

Original: The core of the encoder is a layer denoted as Att , and is made up of two sublayers:
Revised: The core of the encoder is a layer denoted as Att , and is made up of two sublayers:

Original: Attention sublayer projects the input sequence to a query and a set of key-value vectors. 
Revised: Attention sublayer projects the input sequence to a query and a set of key-value vectors. MultiHead ( Q, [Equation] [Equation]

Revised: ) =

Original: [Equation]
Revised: [Equation]

Revised: =

Revised: Attention ( QW Qi

Revised: [Equation]

Revised: KW Ki

Revised: [Equation]

Revised: W Vi

Original:  where W Qi ∈ R d model × d k , W Ki ∈ R d model × d k , W Vi ∈ R d model × d v , W O ∈ R hd v × d model are parameter matrices, and d model is the input embedding dimension ( d model = 2 d in our case).
Revised: [Equation] where W Q i [Equation] model are parameter matrices, and d model is the input embedding dimension ( d model = 2 d in our case).

Original: Position wise sublayer is a fully connected feed-forward network, applied to each sequence position separately and identically.
Revised: Position wise sublayer is a fully connected feed-forward network, applied to each sequence position separately and identically.

Original: The Att ( x, n head , n layer ) takes as input the neighborhood snapshots’ representations x = [ x e t − (cid:96) , . . 
Revised: The Att ( x, n head , n layer ) takes as input the neighborhood snapshots’ representations x = [ x et − (cid:96) , . . .

Original: , x et − 1 ] , the number of layers, and number of attention heads, and maps input sequence x to a time-aware sequence output z e =
Revised: , x et − 1 ] , the number of layers, and number of attention heads, and maps input sequence x to a time-aware sequence output z e =

Original: Att ( x, n head , n layer ) , where z e =
Revised: Att ( x, n head , n layer ) , where z e =

Original: [ z et − (cid:96) , . . .
Revised: [ z et − (cid:96) , . . .

Original: , z et − 1 ] and z eτ ∈ R 2 d × 1 , ∀ t − (cid:96) ≤ τ ≤ t − 1 .
Revised: , z et − 1 ] and z eτ ∈ R 2 d × 1 , ∀ t − (cid:96) ≤ τ ≤ t − 1 .

Original: Finally the temporal representation for e at time t is obtained by:
Revised: Finally the temporal representation for e at time t is obtained by:

Original: [Equation]
Revised: [Equation]

Original: (7) where W ∗ ∈ R 2 d × d out is a parameter matrix, [:] is concatenation and σ ( . ) is a nonlinear activation function ( Relu in our implementation).
Revised: where W ∗ ∈ R 2 d × d out is a parameter matrix, [:] is concatenation and σ ( . ) is a nonlinear activation function ( Relu in our implementation).

Original: 4.2 Similarity Network
Revised: 4.2 Similarity Network

Original: Using the neighborhood encoder, any pair of subject and object at a given time ( s, o, t ) can be represented with a vector [ h s : v s : h o : v o ] , where h s and h o are the temporal representations obtained from the neighborhood encoder, and v s and v o are the subject and object embeddings.
Revised: Using the neighborhood encoder, any pair of subject and object at a given time ( s, o, t ) can be represented with a vector [ h s : v s : h o : v o ] , where h s and h o are the temporal representations obtained from the neighborhood encoder, and v s and v o are the subject and object embeddings.

Original: Given the reference entity pair ( s 0 , o 0 , t 0 ) for a relation r , we learn the representation for similarity from the support and the query entity pair by two layers of fully connected layers:
Revised: Given the reference entity pair ( s 0 , o 0 , t 0 ) for a relation r , we learn the representation for similarity from the support and the query entity pair by two layers of fully connected layers:

Original: [Equation]
Revised: [Equation]

Original: The similarity score between the reference entity pair and a given query entity pair ( s q , o q , t q ) deﬁned as score =
Revised: The similarity score between the reference entity pair and a given query entity pair ( s q , o q , t q ) deﬁned as score =

Original: M ( s ) (cid:62) M ( q ) , where s =
Revised: M ( s ) (cid:62) M ( q ) , where s =

Original: [ h s 0 : v s 0 : h o 0 : v o 0 ] and q =
Revised: [ h s 0 : v s 0 : h o 0 : v o 0 ] and q =

Original: [ h s q : v s q : h o q : v o q ] .
Revised: [ h s q : v s q : h o q : v o q ] .

Original: We use the dot product to output a similarity score between the support and query pair that corresponds to the likelihood of s q and o q being connected with r at time t q .
Revised: We use the dot product to output a similarity score between the support and query pair that corresponds to the likelihood of s q and o q being connected with r at time t q .

Original: 4.3 Loss Function and Training
Revised: 4.3 Loss Function and Training

Original: For a given relation r and its support set S r = { ( s 0 , o 0 , t 0 ) } , we have a set of positive quadruples ( Q + r ) and construct the negative pairs ( Q − r ) by polluting the subject or object entities for each positive quadruple and the ﬁnal query set is Q r = Q − r (cid:83) Q
Revised: For a given relation r and its support set S r = { ( s 0 , o 0 , t 0 ) } , we have a set of positive quadruples ( Q + r ) and construct the negative pairs ( Q − r ) by polluting the subject or object entities for each positive quadruple and the ﬁnal query set is Q r = Q − r (cid:83) Q

Original: + r .
Revised: + r .

Original: We want the positive quadruples to be close tothe support set’s ﬁnal representation and the negatives to be as far as possible. The objective function is a hinge loss, deﬁned as: [Equation] [Equation]
Revised: We want the positive quadruples to be close to

Original: The score + and score − are similarity scores calculated over Q + r and Q − r .

Original: We employ episodic training over the task set T to optimize the loss function.

Original: Algorithm 1 summarizes the the episodic training algorithm and the time dependent selection to construct the query set.

Original: Algorithm
Revised: Algorithm

Original: Input: T meta training relations); G back ground TKG); number of shots);  for do
Revised: Input: T meta training relations); G (cid:48) background ; w shots of shots); ∀ ; for i =

Original:  Shufﬂe 
Revised: N do Shufﬂe relations in T

Original: Sample relation r from T
Revised: Sample relation r from T

Original: S r , Q r ← M AKE T ASK ( r w A  n 
Revised: S r , Q r ← M AKE T ASK ( r, w, A r , n shots )

Original: Sample B + from Q r and make B −
Revised: Sample B + from Q r and make B −

Original: L ← max( score − − score + λ, 0) θ ← θ − ∇L return θ function M AKE T ASK ( r, w, A r , n shots ) i ∼ Uniform (1 , | A r | )
Revised: L ← max( score − − score + λ, 0) θ ← θ − ∇L return θ function M AKE T ASK ( r, w, A r , n shots ) i ∼ Uniform (1 , | A r | )

Original: S r ← { A r [ i ] } limit ← w + t i while t j < limit do
Revised: S r ← { A r [ i ] } limit ← w + t i while t j < limit do

Original: Add A r [ j ] to Q r j ← j +return S r , Q r 
Revised: Add A r [ j ] to Q r j ← j +return S r , Q r the support set’s ﬁnal representation and the negatives to be as far as possible. The objective function is a hinge loss, deﬁned as L = max ( score − − score + + λ, 0) . The score + and score − are similarity scores calculated over Q + r and Q − r . We employ episodic training over the task set T to optimize the loss function.

Revised: Algorithm 1 summarizes the the episodic training algorithm and the time dependent selection to construct the query set.

Original: 5. Experimental Validation
Revised: 5. Experimental Validation

Original: We evaluate our model on predicting new events for a relation by predicting the object entity ( s, r, ? , t ) and conduct qualitative and quantitative experiments to validate the model.
Revised: We evaluate our model on predicting new events for a relation by predicting the object entity ( s, r, ? , t ) and conduct qualitative and quantitative experiments to validate the model.

Original: 5.1 Datasets
Revised: 5.1 Datasets

Original: We use two datasets: Integrated Crisis Early Warning System (ICEWS)
Revised: We use two datasets: Integrated Crisis Early Warning System (ICEWS)

Original: [Boschee et al., 2015] and Global Database of Events, Language, and Tone (GDELT)
Revised: [Boschee et al., 2015] and Global Database of Events, Language, and Tone (GDELT)

Original: [Leetaru and Schrodt, 2013].
Revised: [Leetaru and Schrodt, 2013].

Original: Dataset # Ents # Rels # Tasks # Quads
Revised: Dataset # Ents # Rels # Tasks # Quads

Original: ICEWS14 66/5/
Revised: ICEWS14 66/5/

Original: ICEWS

Revised: ICEWS

Original: GDELT  50/5/
Revised: GDELT  50/5/

Original: From ICEWS dataset, we construct ICEWS from Jan 2017 to Jan 2019, and ICEWS14 from
Revised: From ICEWS dataset, we construct ICEWS from Jan 2017 to Jan 2019, and ICEWS14 from

Original: Jan 2014 to Jan 2016.
Revised: Jan 2014 to Jan 2016.

Original: We select the relations with frequency between 50 and 500 for the one-shot learning tasks and frequency higher than 500 as the background relations.
Revised: We select the relations with frequency between 50 and 500 for the one-shot learning tasks and frequency higher than 500 as the background relations.

Original: Our second dataset includes one month of GDELT (Jan 2018).
Revised: Our second dataset includes one month of GDELT (Jan 2018).

Original: The low and high frequency thresholds for selecting tasks and background relations are 50 and 700, respectively, for the GDELT dataset.
Revised: The low and high frequency thresholds for selecting tasks and background relations are 50 and 700, respectively, for the GDELT dataset.

Original: The rest of the dataset pre-processing is the same for both GDELT and ICEWS.
Revised: The rest of the dataset pre-processing is the same for both GDELT and ICEWS.

Original: Table 1 shows the statistics for both datasets.
Revised: Table 1 shows the statistics for both datasets.

Original: 5.2 Baselines
Revised: 5.2 Baselines

Original: There is no prior work on one-shot learning for temporal knowledge graphs.
Revised: There is no prior work on one-shot learning for temporal knowledge graphs.

Original: Therefore, we propose two different ways to evaluate our model:
Revised: Therefore, we propose two different ways to evaluate our model:

Revised: Training Task

Revised: Support Set (US, Fight, Syria, 04-14-18)

Original: One-shot training of existing TKG models To simulate the one-shot condition, we build a training dataset by adding all the quadruples of the background knowledge graph and the quadruples of the G train .
Revised: Query Set (Turkey, Fight, Iraq, 07-04-18) (Israel, Fight, Syria, 05-01-18) ... Training Task Support Set (US, Consult, Germany, 04-14-17) Query Set (India, Consult, Syria, 05-25-18) (China, Consult, Japan, 01-01-19) ...

Revised: Test Task

Revised: Support Set (Greece, Yield, Spain, 03-16-19)

Revised: Query Set (India, Yield, Yemen, 07-19-19) (Iraq, Yield, India, 01-29-19) ...

Revised: Training Set

Revised: Support Set (Training Task 1) (US, Fight, Syria, 04-14-18)

Revised: Support Set (Training Task 2) (US, Consult, Germany, 04-14-17)

Revised: Support Set (Test Task 1) (Greece, Yield, Spain, 03-16-19)

Revised: Test Set

Revised: Query Set (Test Task 1) (India, Yield, Yemen, 07-19-19) (Iraq, Yield, India, 01-29-19) ...

Revised: Query Set (Test Task 2) ...

Revised: One-shot training of existing TKG models To simulate the one-shot condition, we build a training dataset by adding all the quadruples of the background knowledge graph and the quadruples of the G train .

Original: Per each relation in the T meta − test and T meta − val , wealso include exactly one quadruple into the training set.
Revised: Per each relation in the T meta − test and T meta − val , we include exactly one quadruple into the training set.

Original: We test the model on the exact same quadruples from G test  .
Revised: We test the model on the exact same quadruples from G test (Figure 4) .

Original: We used TKG reasoning baseline models: TADistMult [Garcia-Duran et al., 2018], TTransE [Leblay and Chekol, 2018] and ReNet [Jin et al.,  2019].[Table]
Revised: We used TKG reasoning baseline models: TADistMult [Garcia-Duran et al., 2018], TTransE [Leblay and Chekol, 2018], ReNet [Jin et al., 2019], and ATiSE [Xu et al., 2019].

Original: FSL methods for static graphs: We collapse the temporal training graph into an unweighted static graph.
Revised: FSL methods for static graphs: We collapse the temporal training graph into an unweighted static graph.

Original: An edge exists between two entities in the static graph if there is a corresponding edge in the temporal graph at any time.
Revised: An edge exists between two entities in the static graph if there is a corresponding edge in the temporal graph at any time.

Original: We use three state of the art static low-shot learning methods: GMatch [Xiong et al., 2018], FSRL [Zhang et al., 2020], and MetaR [Chen et al., 2019].
Revised: We use three state of the art static low-shot learning methods: GMatch [Xiong et al., 2018], FSRL [Zhang et al., 2020], and MetaR [Chen et al., 2019].

Original: Unlike the ﬁrst two, MetaR doesn’t incorporate any neighborhood information into its modeling, meaning that there is no difference between ( s, r, o, t i ) and ( s, r, o, t j ) in the test.
Revised: Unlike the ﬁrst two, MetaR doesn’t incorporate any neighborhood information into its modeling, meaning that there is no difference between ( s, r, o, t i ) and ( s, r, o, t j ) in the test.

Original: In contrast, the one-hop neighborhood information provided for ( s, r, o, t i ) is different than ( s, r, o, t j ) during the test time of GMatch and FSRL.
Revised: In contrast, the one-hop neighborhood information provided for ( s, r, o, t i ) is different than ( s, r, o, t j ) during the test time of GMatch and FSRL.

Original: Discussion .
Revised: Discussion .

Original: We present the results of our experiments in Table2, which demonstrates the superiority of our approach over the baselines.
Revised: We present the results of our experiments in Table which demonstrates the superiority of our approach over the baselines.

Original: In particular, for GDELT and ICEWS17 datasets, our model shows the best results according to all metrics, and at times with quite signiﬁcant margins.
Revised: In particular, for GDELT and ICEWS17 datasets, our model shows the best results according to all metrics and at times with quite signiﬁcant margins.

Original: For the ICEWS14 dataset, our model signiﬁcantly outperforms the baselines according to the Hit@ and MRR metrics, and is very close to the best methods in Hit@5 and Hit@10 metrics (TATransE and ReNet, respectively).
Revised: For the ICEWS14 dataset, our model signiﬁcantly outperforms the baselines according to the Hit@ and MRR metrics and is very close to the best methods in Hit@5 and Hit@10 metrics (TATransE and ReNet, respectively).

Original: We believe the superior performance of our model can be attributed to the episodic training approach, which provides more generalizability compared to the ﬁrst set of baselines that use regular training.
Revised: We believe the superior performance of our model can be attributed to the episodic training approach, which provides more generalizability compared to the ﬁrst set of baselines that use regular training.

Original: Our experiments conﬁrm that the performance of TKG-inspired baselines are better for frequent relations and deteriorate when evaluated over only sparse relations.
Revised: Our experiments conﬁrm that the performance of TKG-inspired GDELT [Table] [Table]

Revised: , and (iii) ICEWS14 from Jan 2014 to Jan 2016 for relations in meta test .

Revised: “OAT-R” and “OAT-T” correspond to the random and time dependent query set selection method.

Original:  TTransE/TATransE are translation based models which are not able to handle one-to-many/many-toone relations, and in general perform poorly on event datasets.
Revised: baselines are better for frequent relations and deteriorate when evaluated over only sparse relations. TTransE/TATransE are translation based models which are not able to handle one-to-many/many-toone relations, and in general perform poorly on event datasets.

Original: Similar to our model, ReNet generates a time-aware representation for an entity by aggregating the local neighborhood at each timestamp using a pooling layer and a sequential encoder.
Revised: Similar to our model, ReNet generates a time-aware representation for an entity by aggregating the local neighborhood at each timestamp using a pooling layer and a sequential encoder.

Original: In Section B of the Appendix we provide some insight on why and when the ReNet model outperforms our model.
Revised: In Section B of the Appendix we provide some insight on why and when the ReNet model outperforms our model.

Original: Although the second set of baselines employ episodic training, these methods still fail to consider the temporal dependency between events, which is captured effectively by self-attention in our model.
Revised: Although the second set of baselines employ episodic training, these methods still fail to consider the temporal dependency between events, which is captured effectively by self-attention in our model.

Original: GMatch uses a mean pooling layer to aggregate the entities and edges adjacent to the given entity, while FSRL uses a weighted mean pooling layer with attention weights.
Revised: GMatch uses a mean pooling layer to aggregate the entities and edges adjacent to the given entity, while FSRL uses a weighted mean pooling layer with attention weights.

Original: The reason that FSRL works better than GMatch might be that a part of the temporal information is captured by attention weights.
Revised: The reason that FSRL works better than GMatch might be that a part of the temporal information is captured by attention weights.

Original: To summarize, our experiments indicate that combination of both techniques – a self-attention to encode the temporal neighborhood information and a temporal task deﬁnition for episodic training – is essential for showing improved performance over the baselines.[Table]
Revised: To summarize, our experiments indicate that combination of both techniques – a self-attention to encode the temporal neighborhood information and a temporal task deﬁnition for episodic training – is essential for showing improved performance over the baselines.

Original: 5.3 Ablation Study
Revised: 5.3 Ablation Study

Original: To demonstrate the importance of each component of our model [Table] we conduct multiple ablation studies that evaluate the model from three main angles: (1) The temporal neighborhood encoder added by self-attention to the model: We disable the sequential encoder and feed all the neighbors of an entity in { t − (cid:96), . . .
Revised: To demonstrate the importance of each component of our model, we conduct multiple ablation studies that evaluate the model from three main angles: (1) The temporal neighborhood encoder added by self-attention to the model: We disable the sequential encoder and feed all the neighbors of an entity in { t − (cid:96), . . .

Original: , t − 1 } to the snapshot function f η , as if they all happened at one timestamp (M1), shown in Table 3 as “Att”.
Revised: , t − 1 } to the snapshot function f η , as if they all happened at one timestamp (M1), shown in Table 3 as “Att”.

Original: (2) Query set selection method: According to Section 3.3, it can either be random or time dependent.
Revised: (2) Query set selection method: According to Section 3.3, it can either be random or time dependent.

Original: “Rand” is checked in Table 3 if the selection method is random [Table] and time dependent otherwise.
Revised: “Rand” is checked in Table 3 if the selection method is random, and time dependent otherwise.

Original: (3) We analyze the inner product effectiveness compared to using Matching
Revised: (3) We analyze the inner product effectiveness compared to using Matching

Original: Network [Xiong et al., 2018] on the query representation, shown as “MatchNet” in Table [Table]
Revised: Network [Xiong et al., 2018] on the query representation, shown as “MatchNet” in Table 3.

Original: Table 3 summarizes the ablation study’s results, showing that the full pipeline of our proposed algorithm outperforms the other variations.
Revised: Table 3 summarizes the ablation study’s results, showing that the full pipeline of our proposed algorithm outperforms the other variations.

Original: M1 and M2 demonstrate the effectiveness of a sequential encoder, since disabling it results a signiﬁcant performance decline.
Revised: M1 and M2 demonstrate the effectiveness of a sequential encoder, since disabling it results a signiﬁcant performance decline.

Original: It is worth noting that adding
Revised: It is worth noting that adding

Original: MatchNet helps to capture similarity information when the model is simple (M1 and M2). 
Revised: MatchNet helps to capture similarity information when the model is simple (M1 and M2). However,

Original: However, comparing OAT-T/OAT-R with M3 and M4 shows that, due to the data scarcity, adding MatchNet will lead to model overparameterization and decreased performance, while self-attention is powerful enough to learn a representation that captures not only the temporal dependencies but also a similarity space that enables accurate prediction.
Revised: [Table] comparing OAT-T/OAT-R with M3 and M4 shows that, due to the data scarcity, adding MatchNet will lead to model overparameterization and decreased performance [Table] while self-attention is powerful enough to learn a representation that captures not only the temporal dependencies but also a similarity space that enables accurate prediction.

Revised: 5.4 Performance Over Different Relations

Revised: We conduct experiments to evaluate the model performance for each relation separately.

Revised: Table 4 in

Original:  6. Conclusion and Future Work
Revised: Section B of the appendix shows the decomposed results on ICEWS17 test set by OAT-T and ReNet, sorted by their frequency. It shows that in most relations (11 out of 14) OAT-T outperforms ReNet. Section B of the appendix include further discussion and detail of the experiments. 6. Conclusion and Future Work

Original: We introduce a novel one-shot learning framework for temporal knowledge graphs to address the problem of sparse relations in those graphs.
Revised: We introduce a novel one-shot learning framework for temporal knowledge graphs to address the problem of sparse relations in those graphs.

Original: Our model employs a self-attention mechanism to sequentially encode temporal dependencies among the entities, as well as a similarity network for assessing the similarity between a query and an example.
Revised: Our model employs a self-attention mechanism to sequentially encode temporal dependencies among the entities, as well as a similarity network for assessing the similarity between a query and an example.

Original: Our experiments demonstrate that the proposed method outperforms existing state-of-the-art baselines in predicting new events for infrequent relations.
Revised: Our experiments demonstrate that the proposed method outperforms existing state-of-the-art baselines in predicting new events for infrequent relations.

Original: In future work, we would like to generalize the current one-shot learning to a few-shot scenario.
Revised: In future work, we would like to generalize the current one-shot learning to a few-shot scenario.

Original: Another direction is extending our framework to handle emergent entities, a challenge since new entities will have fewer interactions and thus sparser neighborhood information. 
Revised: Another direction is extending our framework to handle emergent entities, a challenge since new entities will have fewer interactions and thus sparser neighborhood information. 7. Acknowledgments

Revised: This research is based upon work supported in part by the Ofﬁce of the Director of National

Revised: Intelligence (ODNI), Intelligence Advanced Research Projects Activity (IARPA), via IARPA Contract

Original:  Appendix A. Attention Encoder Details
Revised: No.2017-17071900005. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the ofﬁcial policies, either expressed or implied, of ODNI, IARPA, or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for governmental purposes notwithstanding any copyright annotation therein. Appendix A. Attention Encoder Details

Original: The Attention function used in Equation 6 to calculate the attention score is called “Scaled Dot
Revised: The Attention function used in Equation 6 to calculate the attention score is called “Scaled Dot

Original: Product Attention” in [Vaswani et al., 2017] and deﬁned as follows:
Revised: Product Attention” in [Vaswani et al., 2017] and deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: Position wise sublayer is a fully connected feed-forward network, applied to each sequence position separately and identically.
Revised: Position wise sublayer is a fully connected feed-forward network, applied to each sequence position separately and identically.

Original: [Equation]
Revised: [Equation]

Original: In order for the attention model to make use of sequential order, a positional encoding is added to the input embeddings.
Revised: In order for the attention model to make use of sequential order, a positional encoding is added to the input embeddings.

Original: [Equation]
Revised: [Equation]

Original: Where pos is the position and i is the dimension.
Revised: Where pos is the position and i is the dimension.

Original: The purpose of positional encoding is to introduce to the model the information about relative or absolute position of each element in the sequence.
Revised: The purpose of positional encoding is to introduce to the model the information about relative or absolute position of each element in the sequence.

Original: The positional encoding has similar dimension as d model .
Revised: The positional encoding has similar dimension as d model .

Original: Appendix B. Performance Over Different Relations
Revised: Appendix B. Performance Over Different Relations

Original: In this section, we conduct experiments to evaluate the model performance over each relation separately.
Revised: In this section, we conduct experiments to evaluate the model performance over each relation separately.

Original: Table 4 shows relations in ICEWS test set by performance.
Revised: Table 4 shows relations in ICEWS test set by performance.

Original: Our model struggles on
Revised: Our model struggles on

Original: CAMEO codes “1831” and “1823,” which lie under a higher level CAMEO event “Assault” coded as “18.”
Revised: CAMEO codes “1831” and “1823,” which lie under a higher level CAMEO event “Assault” coded as “18.”

Original: Also, we manually inspected the test examples for “1823,” for which ReNet performs very well.
Revised: Also, we manually inspected the test examples for “1823,” for which ReNet performs very well.

Original: Our inspection shows that ReNet tends to generate higher ranks for a quadruple ( s, r, o, t ) if it has already seen many examples of s , o being paired with any other relations.
Revised: Our inspection shows that ReNet tends to generate higher ranks for a quadruple ( s, r, o, t ) if it has already seen many examples of s , o being paired with any other relations.

Original: For example, (ISIS, 1831, Afghanistan) was the test example, and we found 30 matches for (ISIS, 183, Afghanistan) in the training set.
Revised: For example, (ISIS, 1831, Afghanistan) was the test example, and we found 30 matches for (ISIS, 183, Afghanistan) in the training set.

Original: It is worth noting that “1831” is a subcategory of “183” in the CAMEO-code scheme.
Revised: It is worth noting that “1831” is a subcategory of “183” in the CAMEO-code scheme.

Original: This was the case for 4 out of 5 query examples of “1831.”
Revised: This was the case for 4 out of 5 query examples of “1831.”

Original: The one query example that
Revised: The one query example that

Original: ReNet doesn’t perform well, (ISIS, 1831, Libya) , the combination of ISIS and any other Libya related entities only appeared 7 times in the training data.
Revised: ReNet doesn’t perform well, (ISIS, 1831, Libya) , the combination of ISIS and any other Libya related entities only appeared 7 times in the training data.

Original: The rank predicted by our model for this query is 14, while the ReNet rank is over 1,000.
Revised: The rank predicted by our model for this query is 14, while the ReNet rank is over 1,000.

Original: Our model doesn’t use the information from the edges in the background graph.
Revised: Our model doesn’t use the information from the edges in the background graph.

Original: Although ReNet leverages this information, it could become biased toward them.
Revised: Although ReNet leverages this information, it could become biased toward them.

Original: Therefore, designing a few-shot model that leverages this information and is able to generalize well over new edges remains a challenge for future work.
Revised: Therefore, designing a few-shot model that leverages this information and is able to generalize well over new edges remains a challenge for future work.

Original: Appendix C. Performance over Time
Revised: Appendix C. Performance over Time

Original: Figure 4 visualizes the performance of our model over time for ICEWS dataset.
Revised: Figure 5 visualizes the performance of our model over time for ICEWS dataset.

Original: Since relations selected for the task are very sparse, the number of query examples in one unit of time is very small.
Revised: Since relations selected for the task are very sparse, the number of query examples in one unit of time is very small.

Original: So we aggregated every 7 days.
Revised: So we aggregated every 7 days.

Original: The y axis is the time difference between the query timestamp and its support example timestamp.
Revised: The y axis is the time difference between the query timestamp and its support example timestamp.

Original: Figure 4 shows that our model outperforms the best baseline over time.
Revised: Figure 5 shows that our model outperforms the best baseline over time.

Original: [Table]
Revised: [Table]

Original: Appendix D. Hyperparameters  Implementation Detail
Revised: Appendix D. Hyperparameters and Implementation Detail

Original: We select the relations with frequency between 50 and 500 for the one-shot learning tasks and frequency higher than 500 as the background relations for ICEWS dataset.
Revised: We select the relations with frequency between 50 and 500 for the one-shot learning tasks and frequency higher than 500 as the background relations for ICEWS dataset.

Original: The low and high frequency thresholds for selecting tasks and background relations are 50 and 700, respectively, for the GDELT dataset.
Revised: The low and high frequency thresholds for selecting tasks and background relations are 50 and 700, respectively, for the GDELT dataset.

Original: The threshold for choosing the sparse relations should be selected such that the sparsity is preserved and also, we have enough data for training the model.
Revised: The threshold for choosing the sparse relations should be selected such that the sparsity is preserved and also, we have enough data for training the model.

Original: We have selected the exact threshold values based on the prior work [Xiong et al., 2018] which also is based on the above rationale.
Revised: We have selected the exact threshold values based on the prior work [Xiong et al., 2018] which also is based on the above rationale.

Original: GDELT is less sparse than ICEWS, so we increased the upper threshold to increase the number of tasks for the training.
Revised: GDELT is less sparse than ICEWS, so we increased the upper threshold to increase the number of tasks for the training.

Original: We use a manual tuning approach to select the model hyperparameters, during which we keep all the parameters constant except one and we run the model with the selected hyperparameters 5 times and select the best model over the validation set using MRR metric.
Revised: We use a manual tuning approach to select the model hyperparameters, during which we keep all the parameters constant except one and we run the model with the selected hyperparameters 5 times and select the best model over the validation set using MRR metric.

Original: The episode length w chosen to construct the datasets for one-shot learning from GDELT and ICEWS is 120 time units (e.g. 120 days for ICEWS).
Revised: The episode length w chosen to construct the datasets for one-shot learning from GDELT and ICEWS is 120 time units (e.g. 120 days for ICEWS).

Original: The history period is 20 days for ICEWS and 10 time units (every 15 minutes) for GDELT.
Revised: The history period is 20 days for ICEWS and 10 time units (every 15 minutes) for GDELT.

Original: The embedding size for both datasets is 50 .
Revised: The embedding size for both datasets is 50 .

Original: We use one layer of multi-head attention with 4 heads.
Revised: We use one layer of multi-head attention with 4 heads.

Original: Number of heads is selected by hyperparameter search from 1 to 6.
Revised: Number of heads is selected by hyperparameter search from 1 to 6.

Original: Attention inner dimension is 256.
Revised: Attention inner dimension is 256.

Original: Attention parameters are similar for both datasets.
Revised: Attention parameters are similar for both datasets.

Original: The matching network performs 3 steps of matching.
Revised: The matching network performs 3 steps of matching.

Original: The loss margin is 10 for ICEWS and 18 for GDELT.
Revised: The loss margin is 10 for ICEWS and 18 for GDELT.

Original: We found out that increasing margin value affects the performance as it is depicted in Figure 5.
Revised: We found out that increasing margin value affects the performance as it is depicted in Figure 6.

Original: The number of parameters for the model with this choice of hyperparameters is 1,380,656 for GDELT dataset and 1,469,056 for ICEWS.
Revised: The number of parameters for the model with this choice of hyperparameters is 1,380,656 for GDELT dataset and 1,469,056 for ICEWS.

Original: We use Adam optimizer with initial learning rate 0.001.
Revised: We use Adam optimizer with initial learning rate 0.001.

Original: We implemented our solution using Pytorch.
Revised: We implemented our solution using Pytorch.

Original: We run all the experiments on a CPU Intel(R)
Revised: We run all the experiments on a CPU Intel(R)

Original: Xeon(R) Gold 5220 CPU @
Revised: Xeon(R) Gold 5220 CPU @

Original: 2.20GHz , and 53 GBs of memory.
Revised: 2.20GHz , and 53 GBs of memory.

Original: The eval function in trainer.py includes the details to calculate MRR and Hit@K metrics.
Revised: The eval function in trainer.py includes the details to calculate MRR and Hit@K metrics.

Original: The implementation and the dataset is available at https://github.com/AnonymousForReview
Revised: The implementation and the dataset is available at https://github.com/AnonymousForReview

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: H i t @

Original: [Figure] [Figure][Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: Hit
Revised: H i t @ ReNet FTAG

Original: [Figure]
Revised: [Figure]

Original: Hit@

Original: Hit@

Original: Hit@

Original: Appendix E. Model Analysis
Revised: Appendix E. Model Analysis

Original: In this section we provide more insights on the shortcoming of the existing baselines and the justiﬁcation about why our model outperforms these models.
Revised: In this section we provide more insights on the shortcoming of the existing baselines and the justiﬁcation about why our model outperforms these models.

Original: We compare our model against two categories of baselines:
Revised: We compare our model against two categories of baselines:

Original: TKG baselines : Regular TKG methods tend to get biased toward the frequent relations.
Revised: TKG baselines : Regular TKG methods tend to get biased toward the frequent relations.

Original: We conducted some initial experiments to conﬁrm it; We provided a training set containing all the relations to the model, and evaluated it on all the relations as well as sparse/frequent relations separately.
Revised: We conducted some initial experiments to conﬁrm it; We provided a training set containing all the relations to the model, and evaluated it on all the relations as well as sparse/frequent relations separately.

Original: The model performance (MRR/Hit@K) over all the relations was more close to the
Revised: The model performance (MRR/Hit@K) over all the relations was more close to the

Original: MRR/Hit@K for frequent relations and the MRR/Hit@K for sparse relations was much lower.
Revised: MRR/Hit@K for frequent relations and the MRR/Hit@K for sparse relations was much lower.

Original: The main difference between regular TKG models and our model is the episodic training framework, which enables our model to generalize well from only one example.
Revised: The main difference between regular TKG models and our model is the episodic training framework, which enables our model to generalize well from only one example.

Original: • TTransE/TATransE are translation based models which are not able to handle one-tomany/many-to-one relations.
Revised: • TTransE/TATransE are translation based models which are not able to handle one-tomany/many-to-one relations.

Original: they map the timestamp in a quadruple (s, r, o, t) into a lower dimensional space and are not capable of extrapolation
Revised: they map the timestamp in a quadruple (s, r, o, t) into a lower dimensional space and are not capable of extrapolation

Original: (i
Revised: (i

Original: e. forecasting the future events).
Revised: e. forecasting the future events).

Original: • ReNet : Same as our model, ReNet generates a time-aware representation for an entity by aggregating the local neighborhood at each timestamp using a pooling layer and feeding it to an RNN.
Revised: • ReNet : Same as our model, ReNet generates a time-aware representation for an entity by aggregating the local neighborhood at each timestamp using a pooling layer and feeding it to an RNN.

Original: In Section B we provide some insight on why and when the ReNet model outperforms our model.
Revised: In Section B we provide some insight on why and when the ReNet model outperforms our model.

Original: FSL 
Revised: FSL baselines :The main difference between our model and static FSL models is a temporal neighborhood aggregator.

Original: baselines
Revised: Temporal adjacent events could convey useful information about the events that will happen in the future and different timestamps can have different effects on future events. The multi-head self-attention module in our model captures this information. We did some experiments on history length that indicated that as we increased the history length upto some point, it helped to improve the model performance.

Original: • GMatching uses a mean pooling layer to aggregate the entities and edges adjacent to the given entity.
Revised: • GMatching uses a mean pooling layer to aggregate the entities and edges adjacent to the given entity.

Original: • FSRL uses a weighted mean pooling layer with attention weights.
Revised: • FSRL uses a weighted mean pooling layer with attention weights.

Original: The reason that FSRL works better than GMatching might be that a part of the temporal information is captured by attention weights.
Revised: The reason that FSRL works better than GMatching might be that a part of the temporal information is captured by attention weights.

Original: • MetaR does not use the local neighborhood structure for extracting the embedding of a node.
Revised: • MetaR does not use the local neighborhood structure for extracting the embedding of a node.

Original: To summarize, our model combines the beneﬁts of both approaches: a self-attention to encode the temporal neighborhood information and a temporal task deﬁnition for episodic training, resulting in better performance over the baselines.
Revised: To summarize, our model combines the beneﬁts of both approaches: a self-attention to encode the temporal neighborhood information and a temporal task deﬁnition for episodic training, resulting in better performance over the baselines.

Original: Appendix F. Data Construction
Revised: Appendix F. Data Construction

Original: We provide the details of two newly constructed baselines for one-shot learning over temporal knowledge graphs.
Revised: We provide the details of two newly constructed baselines for one-shot learning over temporal knowledge graphs.

Original: We conducted the following steps over both GDELT and ICEWS dataset:
Revised: We conducted the following steps over both GDELT and ICEWS dataset:

Original: A pre-processing step to deduplicate the dataset records by Source Name (subject), Target Name (object), CAMEO Code (relation), and Event Date (timestamp).
Revised: A pre-processing step to deduplicate the dataset records by Source Name (subject), Target Name (object), CAMEO Code (relation), and Event Date (timestamp).

Original: We divide the relations into two groups: frequent and sparse by their frequency of occurrence in the main dataset.
Revised: We divide the relations into two groups: frequent and sparse by their frequency of occurrence in the main dataset.

Original: Relations occurring between 50 and 500 in ICEWS, and 70 and 700 for GDELT are considered “sparse.”
Revised: Relations occurring between 50 and 500 in ICEWS, and 70 and 700 for GDELT are considered “sparse.”

Original: Those occurring more than 500 times in ICEWS and more than 700 times in GDELT are considered frequent. 3.
Revised: Those occurring more than 500 times in ICEWS and more than 700 times in GDELT are considered frequent. 3.

Original: The quadruples of the main dataset are then split into two groups based on their relations.
Revised: The quadruples of the main dataset are then split into two groups based on their relations.

Original: The quadruples containing frequent relations make background knowledge graph kept in pretrain.csv , and the quadruples containing sparse relations are kept for meta learning process (meta quadruples) kept in fewshot.txt 4.
Revised: The quadruples containing frequent relations make background knowledge graph kept in pretrain.csv , and the quadruples containing sparse relations are kept for meta learning process (meta quadruples) kept in fewshot.txt 4.

Original: From the sparse relations, 5 are selected for meta-validation, 15 for meta-test and rest kept for meta-training.
Revised: From the sparse relations, 5 are selected for meta-validation, 15 for meta-test and rest kept for meta-training.

Original: We split the meta quadruples into meta-train, meta-validation, and meta-test not only based on their relations, but also based on the non-overlapping time split explained in Figure 2b of the paper
Revised: We split the meta quadruples into meta-train, meta-validation, and meta-test not only based on their relations, but also based on the non-overlapping time split explained in Figure 2b of the paper.

Original: Data Format Description
Revised: Data Format Description

Original: Each constructed dataset contains the following ﬁles:
Revised: Each constructed dataset contains the following ﬁles:

Original: • symbols2id.pkl .
Revised: • symbols2id.pkl .

Original: A dictionary containing ent2id , rel2id , and dt2id , which are the mapping from entities, relations and dates to IDs respectively.
Revised: A dictionary containing ent2id , rel2id , and dt2id , which are the mapping from entities, relations and dates to IDs respectively.

Original: • id2symbol.pkl .
Revised: • id2symbol.pkl .

Original: A reverse mapping from IDs to symbols.
Revised: A reverse mapping from IDs to symbols.

Original: • data2id.csv .
Revised: • data2id.csv .

Original: A ﬁle containing all the quadruples after the deduplication step.
Revised: A ﬁle containing all the quadruples after the deduplication step.

Original: The symbols are represented by their ids.
Revised: The symbols are represented by their ids.

Original: • pretrain.csv .
Revised: • pretrain.csv .

Original: Contains the quadruples of the background knowledge graph.
Revised: Contains the quadruples of the background knowledge graph.

Original: • fewshot.txt .
Revised: • fewshot.txt .

Original: Contains the meta quadruples in text format.
Revised: Contains the meta quadruples in text format.

Original: Each line is a tab separated quadruple with the order s, r, o, t . • meta_train.pkl .
Revised: Each line is a tab separated quadruple with the order s, r, o, t . • meta_train.pkl .

Original: A mapping from relations to meta quadruple IDs containing that relation.
Revised: A mapping from relations to meta quadruple IDs containing that relation.

Original: A quadruple ID indicates the line number corresponding to that quadruple in fewshot.txt .
Revised: A quadruple ID indicates the line number corresponding to that quadruple in fewshot.txt .

Original: meta_test.pkl and meta_val.pkl are also created similarly, using meta-validation and metatest relations.
Revised: meta_test.pkl and meta_val.pkl are also created similarly, using meta-validation and metatest relations.

Original: • hist_l_n .
Revised: • hist_l_n .

Original: A folder containing the entities’ neighborhood information, with a maximum of n neighbors at each snapshot and history length l .
Revised: A folder containing the entities’ neighborhood information, with a maximum of n neighbors at each snapshot and history length l .

Original: It includes the following ﬁles: – hist_o.pkl .
Revised: It includes the following ﬁles: – hist_o.pkl .

Original: The object neighborhood of meta quadruples in the fewshot.txt .
Revised: The object neighborhood of meta quadruples in the fewshot.txt .

Original: The i th record corresponds to the quadruple in i th line of fewshot.txt . – hist_s.pkl .
Revised: The i th record corresponds to the quadruple in i th line of fewshot.txt . – hist_s.pkl .

Original: The subject neighborhood of meta quadruples in the fewshot.txt .
Revised: The subject neighborhood of meta quadruples in the fewshot.txt .

Original: The i th record corresponds to the quadruple in i th line of fewshot.txt . .
Revised: The i th record corresponds to the quadruple in i th line of fewshot.txt . .