Abstract Question answering over temporal knowledge graphs (KGs) efficiently uses facts contained in a temporal KG, which records entity relations and when they occur in time, to answer natural language questions (e.g., Who was the president of the US before Obama?). These questions often involve three time-related challenges that previous work fail to adequately address: 1) questions often do not specify exact timestamps of interest (e.g., Obama instead of 2000); 2) subtle lexical differences in time relations (e.g., before vs after); 3) off-the-shelf temporal KG embeddings that previous work builds on ignore the temporal order of timestamps, which is crucial for answering temporal-order related questions. In this paper, we propose a time-sensitive question answering (TSQA) framework to tackle these problems. TSQA features a timestamp estimation module to infer the unwritten timestamp from the question. We also employ a time-sensitive KG encoder to inject ordering information into the temporal KG embeddings that TSQA is based on. With the help of techniques to reduce the search space for potential answers, TSQA significantly outperforms the previous state of the art on a new benchmark for question answering over temporal KGs, especially achieving a 32% (absolute) error reduction on complex questions that require multiple steps of reasoning over facts in the temporal KG. Temporal knowledge graphs (KGs) record the relations between entities and the timestamp or time period when such relation hold, e.g., in the form of a quadruple: (Franklin D. Roosevelt, position held, President of USA, [1933, 1945]). This makes them a perfect source of knowledge to answer questions that involve knowledge of when certain events occurred as well as how they are related temporally (see Figure 1 for an example). Unlike question  Work done at JD AI Research. answering (QA) over non-temporal KGs that is mainly concerned with relational inference, a core challenge in temporal KGQA is correctly identifying the time of reference mentioned explicitly or implicitly in the question, and locating relevant facts by jointly reasoning over relations and timestamps. Inspired by work on relational KGQA (Huang et al., 2019; Saxena et al., 2020), where knowledge graph embeddings (Dasgupta et al., 2018; Garca-Durn et al., 2018; Goel et al., 2020; Wu et al., 2020; Lacroix et al., 2020) learned independently of question answering are used as input to KGQA models, previous work (Saxena et al., 2021) employs temporal KG embeddings to attack the problem of temporal KGQA. Despite its relative success on simple temporal questions that directly queries facts in the KG with one out of the four facts left as the answer (e.g., When was Franklin D. Roosevelt the President of USA? or What position did Franklin D. Roosevelt hold between 1933 and 1945?), this approach still struggles to handle questions that require multiple steps of relational-temporal reasoning (e.g., the example in Figure 8017 1). We identify three main challenges that hinder further progress on temporal KGQA. Firstly, complex temporal questions often require inferring the correct point of reference in time, which is not considered by previous work. For instance, to correctly answer the question in Figure 1, it is crucial that we first identify that World War II took place between 1939 and 1945, and look for entities with the desired relation with President of USA in the time interval specified by these times. Secondly, unlike entity relations, which are usually expressed in natural language with a handful of content words that correspond well with their recorded relations in KGs (e.g., What position did ... hold ... vs the position held relation), temporal relations often involve just one or two prepositions (e.g., before or during) and are expressed only implicitly in temporal KGs (e.g., nowhere is it clearly stated that 1931 is earlier than, or before, 1934, by a gap of 3 years). As a result, a small lexical change can drastically alter the temporal relation expressed by the question, and therefore the answer set. Thirdly, previous work on temporal KGQA build on temporal KG embeddings, where each timestamp is assigned a randomly initialized vector representation that is jointly optimized with entity and relation representations to reconstruct quadruples in the KG from embeddings. While sound as a standalone method for encoding knowledge in temporal KGs, this approach does not guarantee that the learned timestamp representations can recover implicit temporal relations like temporal orders or distance, which are crucial for temporal KGQA. In this paper, we propose a time-sensitive question answering framework (TSQA) to address these challenges. We first equip the temporal KGQA model with a time estimation module that infers the unstated timestamps from questions as the first step of reasoning, and feed the result into relational inference as a reference timestamp. Even without explicit training data for this module, the explicit factorization of the problem yields significant improvement over previous work on complex questions that require reasoning over multiple temporal quadruples. To improve the sensitivity of our question encoder to time relation words, we also propose auxiliary contrastive losses that contrast the answer prediction and time estimation for questions that differ only by the time relation word (e.g., before vs after). By leveraging the mutual exclusiveness of answers and the prior knowledge regarding potential time estimates from different time relation words, we observe further improvements in model performance on complex questions. Next, to learn temporal KG embeddings with prior knowledge of temporal order and distance built in, we introduce an auxiliary loss of time-order classification between each pair of timestamp embeddings. As a result, the knowledge in the temporal KG can be distilled into the entity, relation, and timestamp embeddings where the timestamp embeddings can naturally recover order and distance information between the underlying timestamps, thus improving the performance of temporal KGQA where such information is crucial. Finally, we enhance TSQA with KG-based approaches to narrow the search space to speed up model training and inference, as well as reduce the number of false positives in model prediction. As a result, TSQA outperforms the previous state of the art on the CRONQUESTIONS benchmark (Saxena et al., 2021) by a large margin. To summarize, our contributions in this paper are: a) we propose a time-sensitive question answering framework (TSQA) that performs time estimation for complex temporal answers; b) we present contrastive losses that improve model sensitivity to time relation words in the question; c) we propose a time-sensitive temporal KG embedding approach that benefits temporal KGQA; d) with the help of KG-based pruning technique, our TSQA model outperforms the previous state of the art by a large margin. Temporal Knowledge Graph Embedding . Knowledge graph embedding learning (Bordes et al., 2013; Yang et al., 2014; Trouillon et al., 2016; Dettmers et al., 2018; Shang et al., 2019; Sun et al., 2019; Tang et al., 2019; Ji et al., 2021) has been an active research area with applications directly in knowledge base completion and relation extractions. Recently, there are several works that extended the static KG embedding models to temporal KGs. Jiang et al. (2016) first attempt to extend TransE (Bordes et al., 2013) by adding a timestamp embedding into the score function. Later, Hyte (Dasgupta et al., 2018) projects each timestamp with a corresponding hyperplane and utilizes the TransE score in each space. Garca-Durn et al. (2018) extend TransE and 8018 DistMult by utilizing recurrent neural networks to learn time-aware representations of relation types. TCompLEx (Lacroix et al., 2020) extends the ComplEx with time based on the canonical decomposition of tensors of order 4. Temporal QA on Knowledge Graph . Temporal QA have mostly been studied in the context of reading comprehension. ForecastQA (Jin et al., 2021) formulates the forecasting problem as a multiple-choice question answering task, where both the articles and questions include the timestamps. The recent released TORQUE (Ning et al., 2020) is a dataset that explores the temporal ordering relations between events described in a passage of text. Another direction is the temporal question answering over knowledge bases (KB) (Jia et al., 2018b,a), which retrieves time information from the KB. TempQuestions (Jia et al., 2018a) is a KGQA dataset specifically aimed at temporal QA. Based on this dataset, Jia et al. (2018b) design a method that decomposes and rewrites each question into nontemporal sub-question and temporal sub-question. Here the KG used in TempQuestions is based on a subset of FreeBase which is not a temporal KG. Later Jia et al. (2021) proposes a first end-to-end system (EXAQT) for answering complex temporal questions, which takes advantage of the question-relevant compact subgraphs within the KG, and relational graph convolutional networks (Schlichtkrull et al., 2018) for predicting the answers. All previous datasets only include a limited number of temporal questions. Recently, a much larger temporal KGQA dataset CRONQUESTIONS (Saxena et al., 2021) is released, which includes both the temporal questions and the temporal KG with time annotation for all edges. Based on this dataset, the CronKGQA model (Saxena et al., 2021) is presented that exploits recent advances in Temporal KG embeddings and achieves performance superior to all baselines. In this section, we first give the problem definition of temporal question answering over temporal knowledge graph. Then, we introduce the framework to solve this problem, which integrates time sensitivity into KG embedding and answer inference. Finally, we describe the key modules of our proposed system in details. QA on Temporal KG aims at finding out the answer from a given temporal KG G = ( V , E , R , T ) for a given free-text temporal question Q containing implicit temporal expression, and the answer is either an entity of entity set V or a timestamp of timestamp set T . Here, E  V  V is a set of edges, and R is the set of relations. Edge from a quadruple ( s, r, [ t s , t e ] , o ) indicates the relation r  R holds between subject entity s and object entity o during time interval [ t s , t e ] ( t s < t e and t e/s  T ). Framework . Our framework resorts to KG embeddings along with pretrained language models to perform temporal KGQA. Figure 2 shows the architecture which consists of two modules: 1) time-aware TKG encoder; 2) time-sensitive question answer. The time-aware TKG encoder extends the existing TKG embedding method by adding an auxiliary time-order learning task to consider the quadruple orders. And the time sensitive QA module first performs neighboring graph extraction to reduce the search space for question answer, then performs joint training for answer/time prediction and time-sensitive contrastive learning to enhance the model ability in capturing temporal signals in free-text question. Next, we will introduce these two modules in details. We first briefly review a time-aware KG embedding method based on TCompLEx (Lacroix et al., 2020) since it has been used in (Saxena et al., 2021) for TKGQA and shows competitive performance. Next, we show that how to perform TCompLEx on temporal KG, then analyze its weakness in TKGQA especially for complex question and further overcome such weakness by introducing an auxiliary time-order learning task in TKG embedding. TCompLEx for TKG . TCompLEx is an extension of ComplEx considering time information, which not only encodes the entity and relation to complex vectors, but also maps each timestamp to a complex vector. To perform TCompLEx over temporal KG in our problem definition, we first reformulate each quadruple to a set of new quadruples by ( s, r, [ t s , t e ] , o ) = { ( s, r, t, o ) | t s  t  t e } (1) Let e s , e r , e t , e o  C d be the complex-value embeddings of s, r, t, o , respectively. Then, TCom-8019 Figure 2: The architecture of our TSQA model ( Left : Time-aware TKG encoder; Right : Time-Sensitive TKG-QA). pLEx scores each quadruple ( s, r, t, o ) by S ( s, r, o, t ) = Re (  e s , e r , e o , e t  ) (2) where Re(.) denotes the real part of a complex vector, and  denotes the multi-linear product. Finally, we use a loss function similar to the negative sampling loss for effectively TCompLEx training. LTC =  log (  (   S ( s, r, o, t )))  1 KK (cid:88) i =1 ( log (  ( S ( s  i , r, o  i , t  i )   ))) , (3) where  is a fixed margin,  is the sigmoid function, ( s  i , r, o  i , t  i ) is the i -th negative quadruple. According to the loss function in equation 3, we observe that TCompLEx only cares about whether the quadruple is true or false and ignores the orders of different quadruples occur. However, the time orders are critical to find the correct answer in knowledge graphs. For example, to answer the Who is the President of USA before William J. Clinton?, we need not only the two facts (President of USA, Position Held, Ronald Reagan, [1981, 1989]) and (President of USA, Position Held, William J. Clinton, [1993, 2001]), but also the time order of these facts. To overcome such a limit of TCompLEx in TKGQA, we introduce an auxiliary time-order learning task over time-embeddings. Time-order learning in TKG . To keep the time order in embedding spaces, we first sort the timestamps in T by an ascending order and get ( t 1 , t 2 ,    , t | T | ) and t i < t j if 1  i < j  | T | . Let t i = [ Re ( e t i ) , Im ( e t i )]  R 2 d be the concatenation the real and imaginary components of embedding e t i of timestamp t i . Inspired by position embedding in (Vaswani et al., 2017), we first initialize the timestamp embedding t i as follows. t i [2 k ] = sin( i 10000 2 k/ 2 d ) t i [2 k + 1] = cos( i 10000 2 k/ 2 d ) (4) where 0  k  d  1 . Afterwards, for any pair of timestamps ( t i , t j ), we calculate the probability of time order as: p t ( i, j ) = sigmoid (( t 1  t 2 ) TW t ) , (5) where W t  R 2 d represents a parameter vector. Based on the time-order probabilities, we introduce a binary cross-entropy loss as a time-order constraint over timestamp embeddings as follow: LTO =   ( i, j ) log( p t ( i, j ))  (1   ( i, j )) log(1  p t ( i, j )) , (6) where  ( i, j ) = 1 if t i < t j else  ( i, j ) = 0 . Joint-training . A weighted sum of T-CompLEx training loss and time-order constraint is considered as the final objective function for the joint training for TKG embedding. In this section, we introduce our time-sensitive question answering module from the following aspects in details: 1) question decomposition which divides the questions as entities and relations described in free-text; 2) entity neighboring subgraph extraction which reduces the search space of candidate timestamps and answer entities; and 3) time-sensitive question answer which explores the time information implied in both KG and questions to help the model find the answer. For each question Q , we first identify all the entities {Ent 1 , Ent 2 ,    , Ent k } in Q which also appear in KG G , i.e., Ent i  E ( 1  i  k ). Then, by replacing the entities in question Q with special token [ subject ] and [ object ] in order, we obtain an entity-independent temporal relation description in free-text named temporal expression  Q . Taking the question When did Obama hold the position of President of USA ? as an example, by replacing the identified entities President of USA and Obama, we get its temporal expression as When did subject hold the position of object ?. Next [CLS] +  Q are fed into BERT that outputs [CLS] token embedding as e q  R d bert , where d bert is the output dimension of BERT, and two kinds of question representations as follows. where q r , q t  R 2 d represents the embedding of relation and time implied in question, respectively. W  R d bert  2 d , W rq , W tq  R 2 d  2 d are the parameter matrix, and  represents the activation function. Finally, to facilitate the calculation with KG embeddings, we reformulate q r , q t in complex space as: q r = q r [0 : d ] +  1  q r [ d : 2 d ] (9) q t = q t [0 : d ] +   1  q t [ d : 2 d ] (10) 3.3.2 Entity Neighbor Graph Extraction Let {Ent 1 , Ent 2 ,    , Ent k } be the k entities extracted from question Q , we first extract the m hop neighboring sub-graph G i for each entity Ent i . Then, by combining these k sub-graphs, we obtain the search graph G q for question Q : G q =  ki =1 G i . Suppose that E q and T q are the sets of entities and timestamps appearing in G q , respectively, they constitute the search space of time and entity prediction in our TKG-QA method. In training stage, we set the hop number m as the minimum value which results in correct answer entity appearing in G q . In testing stage, we set m as the largest hop number used in training stage. In practice, the size of graph G q in usually much smaller than that of whole graph G . For example, in CronKGQA, the average value of | G q | / | G | is about 3%. Entity Neighboring graph extraction aims at reducing the search space of candidate timestamps and answer entities. This results in not only more efficient training procedure, but also performance improvement of question answer because a larger number of candidates usually means a much more difficult learning problem. For temporal question answer over KG, the interaction of time and answer entity prediction is very important since the time range brings a strong constraint on the search space of answers. However, the existing method (Saxena et al., 2021) usually performs such two predictions independently which results in poor performance especially for complex questions which need to consider multiple facts to get the answer. To overcome this limitation, we directly feed the intermediate time representation t q learned from time estimation to answer prediction to enhance the interaction of these two tasks. Time Estimation. Based on the embeddings e s and e o of subject entity s and object entity o from KG and the time embedding q t from a question, we design the time estimation function FT for learning the time embedding t q as follows: 1 t q = FT ( e s , q t , e o ) = W tq ([ Re (  e s , q t , e o  ) , Im (  e s , q t , e o  )]) , (11) where W tq  R 2 d  2 d represents the parameter matrix. [.] is the concatenation function, Re ( . ) denotes the real part of a complex vector and Im ( . ) is the imaginary part. After getting the time embedding w.r.t. question t q , for timestamp prediction, the following score function to estimate the score for each timestamp t  T q as follow: S t = Re (  t q , t  ) (12) Entity Prediction . 1 A simple temporal question might contain the timestamp (e.g. 2001). In this case, we set t q as the linear combination of this learned time embedding and the timestamp embedding from KG. update the embedding of entity w.r.t. question by considering time embedding t q by an entity function FE as follow: e q = FE ( e s , q r , t q ) =  e s , q r , t q  (13) Finally, we score the entity e  E q by: S e = Re (  e q , e  ) (14) The answer entity of the question is either timestamp or entity. Let S a be the answer score and thus S a = S t or S e when the answer is timestamp or entity. Suppose C represents the number of candidate answers (i.e., C = | E q | + | T q | ), then we can define the probability of i -th candidate answer being true as: P a,i = exp( S a,i ) (cid:80) Cj =1 exp( S a,j )) . Finally, we train the answer prediction model by minimizing the cross-entropy loss as follow: L answer =  C (cid:88) i y i log( P a,i ) , (16) where y i = 1 if the i -th candidate is the true answer, otherwise y i = 0. 3.3.4 Temporal Contrastive Learning The temporal question answer system should be sensitive to the temporal relation implied in the question. For example, the answer of What does happen before a given event? is quite different from that of What does happen after a given event?. Existing works on TKG-QA usually resort to pre-trained language models for question understanding. But these models are not sensitive to the difference of temporal expressions in free-text (Ning et al., 2020; Dhingra et al., 2021; Shang et al., 2021; Han et al., 2021), and thus prone to wrong predictions. To make the system sensitive to the temporal relation implied in question, we resort to a contrastive learning method: we construct a contrastive question to the original question, then add auxiliary contrastive learning tasks to distinguish the latent temporal representation and prediction results coming from the pair of contrastive questions. Contrastive Question Generation . To generate the contrastive question  Q for the given question Q , we first extract all the temporal words based on large number of questions in temporal question answer dataset, and then build a contrastive word pair dictionary by finding the antonyms. The dictionary consists of D contr = {(first, last), (before, after), (before, during), (during, after), (before, when), (when, after)}. Based on such dictionary, we replace the temporal word in given question Q by its antonym to generate its contrastive question  Q . Contrastive time order learning . For the contrastive question pair Q and  Q , we follow the same encoder in Eq. 11 to get the corresponding time-aware embeddings t q and t q c , respectively. Meanwhile, according to the contrastive temporal word pair dictionary, suppose that we pickup the pair (word 1 , word 2 )  D contr for contrastive question construction, we can construct a question order label y o : y o = 0 if  Q is achieved by replacing word 1 as word 2 , else y o = 1. Afterward, we distinguish the temporal orders implied by word 1 and word 2 by predicting of the order label y o based on t q and t q c as follow: p o = sigmoid (( t q  t q c ) TW o ) (17) L order =  y o log( p o )  (1  y o ) log(1  p o ) , (18) where W o  R 2 d represents the parameter vector to be learned. Answer-guided Contrastive Learning . Let S = [ s 1 ,    , s C ] ,  S = [ s 1 ,    , s C ] be the answer scores w.r.t. questions Q and its contrastive question  Q , respectively, where C = | E q | + | T q | . By stacking these two scores together, we get S q = [ S ;  S ]  R 2  C . Then, we can apply softmax over S q along the last dimension and get the probability scores P q = softmax ( S q )  R 2  C and sum ( P q [: , i ]) = 1 for i = 1 ,    , C . Due to the fact that the answers of question Q are definitely not for question  Q , we construct an answer-guided learning labels as y a = [ y 1 ,    , y C ] , where y i = 1 if and only if the i -th candidate is true answer for Q , otherwise y i = 0. Then, we get an answer-guided contrastive loss as follow: L contrast =  1 CC (cid:88) j =0 y i log( P q [0 , i ]) (19) Joint Training . We combine the answer prediction loss and contrastive losses as the final objective function for joint training: Loss = L answer +  o L order +  c L contrast , (20) where  o > 0 ,  c > 0 are the weight factors to make tradeoffs between different losses. In this section, we conduct experiments to assess the effectiveness of our proposed method TSQA for TKG-QA. Our experimental results show that our approach obtains significant improvements over the baseline models. Data . CRONQUESTIONS 2 is the largest known Temporal KGQA dataset consisting of two parts: a KG with temporal annotations, and a set of free-text questions requiring temporal reasoning. This Temporal KG has 125k entities and 328k facts (quadru-ples), while a set of 410k questions is given. The facts have the time spans in the edge. These time spans or timestamps were discretized to years. This dataset consists of questions that can be categorized into two groups based on their answer type: entity questions where the answer is an entity in the KG, and time questions where the answer is a timestamp. The authors also categorize these questions into simple reasoning (including simple entity and simple time subtypes) and complex reasoning (including before/after , first/last and time join subtypes). Table 1 provides the number of questions across different categories. Complex questions require complex temporal reasoning which takes advantage of multiple facts and temporal order of these facts. Evaluation Metrics include Hits@1 and Hits@10 , which is the standard evaluation metrics on CRONQUESTIONS (Saxena et al., 2021). Hyper-parameter setting . We train the TSQA models by setting the hyper-parameters as: learning rate = { 1 e  4 , 2 e  5 , 1 e  5 } ,  o = { 0.5, 1.0, 2.0, 3.0, 5.0 } and  c = { 0.5, 1.0, 2.0, 3.0, 5.0 } , and pick up 2 https://github.com/apoorvumang/ CronKGQA the best hyper-parameters on dev set by the overall Hits@1 metrics. Our models are implemented by PyTorch and trained using NVIDIA Tesla V100 GPUs. EmbedKGQA (Saxena et al., 2020) is the first method to use KG embeddings for the multi-hop KGQA task. It uses ComplEx (Trouillon et al., 2016) embeddings and can only deal with nontemporal KGs and single entity questions. T-EaE-add/replacement (Saxena et al., 2021) are two modifications of KG enhanced language model EaE (Fvry et al., 2020), which integrates entity knowledge into a transformer-based language model and has been used for TKGQA (Saxena et al., 2020). T-EaE-add has all grounded entities and time spans marked in the question, and T-EaE-replace replaces the BERT embeddings with the entity/time embeddings instead of adding them with token embeddings. CronKGQA (Saxena et al., 2021) extends EmbedKGQA to the temporal QA task, and takes advantage of the temporal KG embeddings to answering temporal questions. This is the current SOTA model on CRONQUESTIONS . Table 2 compares different TKG-QA methods in terms of Hits@1 and Hits@10. From this table, we observe that: 1) our proposed TSQA has achieved state-of-the-art performance in terms of all types of questions on both Hits@1 and Hits@10. 2) The performance improvement over the SOTA model is significant. TSQA outperforms the SOTA results by more than 82% Hits@1 relative improvement (32% absolute error reduction) on complex questions and 21% Hits@10 relative improvement on simple questions. These results proved the excellent performance of our proposed TSQA on question answering on the temporal knowledge graph, especially for complex temporal reasoning. We also compare our method with baselines in terms of Hits@1 on different subtype questions in Table 3. From this table, we observe that: on complex questions, our proposed TSQA model outperforms all baseline models significantly. The relative improvement is up to 75%, 94%, 56%, for before/after, first/last and Time Joint, respectively. The first two kinds of questions are more 8023 Model Hits@1 Hits@10 Question Type Answer Type Question Type Answer Type Overall Complex Simple Entity Time Overall Complex Simple Entity Time EmbedKGQA 0.288 0.286 0.290 0.411 0.057 0.672 0.632 0.725 0.850 0.341 T-EaE-add 0.278 0.257 0.306 0.313 0.213 0.663 0.614 0.729 0.662 0.665 T-EaE-replace 0.288 0.257 0.329 0.318 0.231 0.678 0.623 0.753 0.668 0.698 CronKGQA 0.647 0.392 0.987 0.699 0.549 0.884 0.802 0.992 0.898 0.857 TSQA 0.831 0.713 0.987 0.829 0.836 0.980 0.968 0.997 0.981 0.978 Table 2: Comparison of different TKG-QA models on CRONQUESTIONS dataset. challenging as they require a better understanding of the temporal expressions in question. Our method is better in capturing such time-sensitivity change in temporal words and thus results in great improvement. Moreover, for the simple questions, our method still keeps competitive performance compared to the SOTA model. To understand the contributions of the proposed modules in our method, we perform an ablation study by sequentially removing the following components from our proposed TSQA: temporal Contrastive learning (TC), time-aware TKG embeddings (TKE), entity neighboring graph extractor (NG), and time estimation for question answer (TE) in Table 4. It is noted that removing TKE means that we replace TKE with T-CompLEx as KG encoder, and removing NG means that we perform QA over the whole knowledge graph. By comparing the two adjacent rows of this table, we can infer the contributions of TC, TKE, NG and TE, respectively: 1) all these modules improve the overall performance in terms of Hits@1, especially for complex questions; 2) by comparing the last two adjacent rows, the proposed time estimation brings significant Hits@1 improvement (14.5%), since this module supplies the latent time embedding which not only enhances the interaction of timestamp estimation and answer estimation but also supplies a good anchor for finding the answer entity, which is very crucial for answering complex questions; 3) entity neighboring graph extraction gets 7.8% Hits@1 improvement over complex questions by comparing rows TC-TKE and TC-TKE-NG, since it significantly narrows down the search space of the candidate answers; 4) by comparing the first three rows, time-aware TKG embedding (TKE) and temporal contrastive learning (TC) further boost the Hits@1 over complex questions. This is because the complex questions usually require the model to capture time ordering information implied in temporal words of the question. And these two modules enhance temporal order learning by adding explicit time-order constraints. In this paper, we propose a time-sensitive question answering framework (TSQA) over temporal knowledge graphs (KGs). To facilitate the reasoning over temporal and relational facts over multiple facts, we propose a time estimation component to infer the unstated timestamp in the question. To further improve the model's sensitivity to time relation words in the question and facilitate temporal reasoning, we enhance the model with a temporal KG encoder that produces KG embeddings that can recover the implicit temporal order and distance between different timestamps, and with contrastive losses that compare temporally exclusive questions. With the help of answer search space pruning from entity neighboring sub-graphs, our TSQA model significantly improves the performance on complex temporal questions that require reasoning over multiple pieces of facts, and outperforms the previous state of the art by a large margin. This work is supported by the Research and Development Grant No. 2020AAA0108600. Zhen Jia, Abdalghani Abujabal, Rishiraj Saha Roy, Jan-nik Strtgen, and Gerhard Weikum. 2018a. Tempquestions: A benchmark for temporal question answering. In Companion Proceedings of the The Web Conference 2018 , pages 10571062. Zhen Jia, Abdalghani Abujabal, Rishiraj Saha Roy, Jan-nik Strtgen, and Gerhard Weikum. 2018b. Tequila: Temporal question answering over knowledge bases. In Proceedings of the 27th ACM International Conference on Information and Knowledge Management , pages 18071810. Zhen Jia, Soumajit Pramanik, Rishiraj Saha Roy, and Gerhard Weikum. 2021. Complex temporal question answering on knowledge graphs. In Proceedings of the 30th ACM International Conference on Information & Knowledge Management , pages 792802. Tingsong Jiang, Tianyu Liu, Tao Ge, Lei Sha, Baobao Chang, Sujian Li, and Zhifang Sui. 2016. Towards time-aware knowledge graph completion. In Proceedings of COLING 2016, the 26th International Conference on Computational Linguistics: Technical Papers , pages 17151724. Timothe Lacroix, Guillaume Obozinski, and Nicolas Usunier. 2020. Tensor decompositions for temporal knowledge base completion. arXiv preprint arXiv:2004.04926 . Qiang Ning, Hao Wu, Rujun Han, Nanyun Peng, Matt Gardner, and Dan Roth. 2020. Torque: A reading comprehension dataset of temporal ordering questions. arXiv preprint arXiv:2005.00242 . Apoorv Saxena, Soumen Chakrabarti, and Partha Talukdar. 2021. Question answering over temporal knowledge graphs. arXiv preprint arXiv:2106.01515 . Apoorv Saxena, Aditay Tripathi, and Partha Talukdar. 2020. Improving multi-hop question answering over knowledge graphs using knowledge base embeddings. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics , pages 4498 4507. Chao Shang, Peng Qi, Guangtao Wang, Jing Huang, Youzheng Wu, and Bowen Zhou.
method other abstain abstain method abstain abstain abstain abstain abstain other other method abstain objective other abstain abstain abstain objective objective abstain objective result method abstain method abstain objective objective result objective result other other other other other other other other other other other other other other other other other other other method method method abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain method other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain method abstain abstain abstain method abstain abstain abstain other abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain method abstain abstain abstain abstain method method abstain abstain abstain abstain abstain abstain abstain method abstain method abstain other abstain abstain abstain method other abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other abstain result abstain abstain abstain other abstain abstain objective objective result result other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain other abstain abstain abstain other abstain abstain abstain abstain abstain